<?php
if(!defined('sugarEntry')) define('sugarEntry', true);
chdir('../../..');
$webservice_class = 'CustomSugarRestService';
$webservice_path = 'custom/service/core/CustomSugarRestService.php';
$webservice_impl_class = 'SugarRestServiceImpl';
$registry_class = 'registry';
$location = '/custom/service/v2/rest.php';
$registry_path = 'service/v2/registry.php';
require_once('service/core/webservice.php');

<?php
if(!defined('sugarEntry')) define('sugarEntry', true);
require_once('service/core/SugarRestService.php');
class CustomSugarRestService extends SugarRestService
{
   /**
         * @see SugarRestService::_getTypeName()
         */
        protected function _getTypeName($name)
        {
            if ( strtolower($name) == 'xml' ) {
                return 'SugarRestXML';
            }
        return parent::_getTypeName($name);
        }

        /**
         * @see SugarRestService::__construct()
         */
        public function __construct($url)
        {
              $GLOBALS['log']->info('Begin: SugarRestService->__construct');
              $this->restURL = $url;
              $this->responseClass = $this->_getTypeName
($_REQUEST['response_type']);
              $this->serverClass = $this->_getTypeName($_REQUEST['input_type']);
              $GLOBALS['log']->info('SugarRestService->__construct serverclass 
= ' . $this->serverClass);
              if ( file_exists('service/core/REST/'. $this->serverClass . '.php') ) {
                  require_once('service/core/REST/'. $this->serverClass . '.php');
                }
       elseif ( file_exists('custom/service/core/REST/'. $this->serverClass . 
'.php') ) {

           require_once('custom/service/core/REST/'. $this->serverClass . '.php');
       }
       else {
          $GLOBALS['log']->fatal('ERROR: SugarRestService->__construct serverClass
'.$this->serverClass.' not found');
       }
                $GLOBALS['log']->info('End: SugarRestService->__construct');
        }

        /**
         * @see SugarRestService::serve()
         */
        public function serve()
        {
            $GLOBALS['log']->info('Begin: SugarRestService->serve');
            if ( file_exists('service/core/REST/'. $this->responseClass . '.php') ) {
            require_once('service/core/REST/'. $this->responseClass . '.php');
                }
       elseif ( file_exists('custom/service/core/REST/'. $this->responseClass . 
'.php') ) {
           require_once('custom/service/core/REST/'. $this->responseClass . '.php');
       }
       else {
          $GLOBALS['log']->fatal('ERROR: SugarRestService->__construct serverClass
'.$this->responseClass.' not found');
       }
                $response  = $this->responseClass;
                $responseServer = new $response($this->implementation);
                $this->server->faultServer = $responseServer;
                $this->responseServer->faultServer = $responseServer;
                $responseServer->generateResponse($this->server->serve());
                $GLOBALS['log']->info('End: SugarRestService->serve');
        }
}

<?php
if(!defined('sugarEntry')) define('sugarEntry', true);
require_once('service/core/REST/SugarRest.php');

/**
* This class is a XML implementation of REST protocol
*/
class SugarRestXML extends SugarRest
{
        /**
         * @see SugarRest::serve()
         */
        public function serve()
        {
            $GLOBALS['log']->info('Begin: SugarRestXML->serve');
            $xml = !empty($_REQUEST['rest_data'])? $_REQUEST['rest_data']: '';
            if(empty($_REQUEST['method']) || !method_exists($this->implementation, 
$_REQUEST['method'])){
                        $er = new SoapError();
                        $er->set_error('invalid_call');
                        $this->fault($er);
                }
         else {
               $method = $_REQUEST['method'];
               $data = $this->_convertXMLToArray(from_html($xml));
               if(!is_array($data))$data = array($data);
               $GLOBALS['log']->info('End: SugarRestXML->serve');
               return call_user_func_array(array( $this->implementation, 
$method),$data);
               }
        }

<?xml version="1.0" encoding="UTF-8"?>
<parameters>
   <user_auth>
       <user_name>admin</user_name>
       <password>{md5 encoded password}</password>
       <version>0.1</version>
   </user_auth>
   <application_name>test</application_name>
   <name_value_list />
</parameters>

/**
         * Converts an XML string to a PHP array
         *
         * @param string $xml
         * @return array
         */
        protected function _convertXMLToArray($xml)
        {
            $returnArray = array();
            $xmlObject = simplexml_load_string($xml);

            foreach ( $xmlObject->children() as $child ) {

            // Attempt to convert the child element to a string; if it comes out a
            // non-empty string, then the child element has no children.
                $contents = trim((string) $child);
                if ( !empty($contents) ) {
                    $returnArray[$child->getName()] = $contents;
                }
                else {
                         // Recursively call this method to convert any 
                         // child arrays to XML
                    $returnArray[$child->getName()] 
= $this->_convertXMLToArray($child->asXML());
                }
           }
           return $returnArray;
        }

   /**
         * @see SugarRest::generateResponse()
         */
        public function generateResponse($input)
        {
             // If there is a fault object, return it instead.
             if (isset($this->faultObject)) {
                    $this->generateFaultResponse($this->faultObject);
                }
                else {
                    ob_clean();
                    echo $this->_convertArrayToXML($input);
                }
        }
        /**
         * @see SugarRest::generateFaultResponse()
         */
        public function generateFaultResponse($errorObject)
        {
                $error = $errorObject->number . ': ' . $errorObject->name . 
                '<br>' . $errorObject->description;
                $GLOBALS['log']->error($error);
                ob_clean();
                echo $this->_convertArrayToXML($errorObject);
        }

           /**
         * Converts a PHP array into XML
         *
         * @param array $input
         * @return string XML
         */
        protected function _convertArrayToXML($input)
        {
            $xmlWriter = new XMLWriter();
            $xmlWriter->openMemory();
            $xmlWriter->setIndent(true);
            $xmlWriter->startDocument('1.0','UTF-8');
            $xmlWriter->startElement('result');
            foreach ( $input as $key => $value ) {
                if ( is_array($value) ) {
               $xmlWriter->startElement($key);
               $this->_convertArrayItemToXML($value,$xmlWriter);
               $xmlWriter->endElement();
                }
                else {
                    $xmlWriter->writeElement($key,$value);
                }
            }
            $xmlWriter->endElement();
            $xmlWriter->endDocument();

            return $xmlWriter->outputMemory();
        }

        /**
         * Converts an item in a PHP array into XML
         *
         * @param array $item
         * @param object XMLWriter $xmlWriter
         * @return string XML
         */
        protected function _convertArrayItemToXML(array $item, XMLWriter $xmlWriter)
        {
            foreach ( $item as $key => $value ) {
            // If this is an array, we'll call SugarRestXML::_convertArrayItemToXML()
            // to convert the array to XML, containing inside the given $key element.
            if ( is_array($value) ) {
               $xmlWriter->startElement($key);
               $this->_convertArrayItemToXML($value,$xmlWriter);
               $xmlWriter->endElement();
                }
                // If it is just a scalar, we can write out the element directly.
                else {
                    $xmlWriter->writeElement($key,$value);
                }
       }
        }

<?xml version="1.0" encoding="UTF-8"?>
<result>
<id>jq4v1mj3a2e0vcer9s2n3pddi4</id>
<module_name>Users</module_name>
<name_value_list>
 <user_id>
  <name>user_id</name>
  <value>1</value>
 </user_id>
 <user_name>
  <name>user_name</name>
  <value>admin</value>
 </user_name>
 <user_language>
  <name>user_language</name>
  <value>en_us</value>
 </user_language>
 <user_currency_id>
  <name>user_currency_id</name>
  <value></value>
 </user_currency_id>
 <user_currency_name>
  <name>user_currency_name</name>
  <value>US Dollars</value>
 </user_currency_name>
</name_value_list>
</result>

<?php

// specify the REST web service to interact with
$url = 'http://localhost/sugarcrm/custom/service/v2/rest.php';
$username = 'username';
$password = md5('password');

// Open a curl session for making the call
$curl = curl_init($url);

// Tell curl to use HTTP POST
curl_setopt($curl, CURLOPT_POST, true);

// Tell curl not to return headers, but do return the response
curl_setopt($curl, CURLOPT_HEADER, false);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);

// Set the POST arguments to pass to the Sugar server
$xml = <<<EOXML
<?xml version="1.0" encoding="UTF-8"?>
<parameters>
   <user_auth>
       <user_name>{$username}</user_name>
       <password>{$password}</password>
   </user_auth>
</parameters>
EOXML;
$postArgs = array(
               'method' => 'login',
               'input_type' => 'xml',
               'response_type' => 'xml',
               'rest_data' => $xml
               );
curl_setopt($curl, CURLOPT_POSTFIELDS, $postArgs);

// Make the REST call, returning the result
$response = curl_exec($curl);

// Translate the returned XML data into a SimpleXML object
$xml = simplexml_load_string($response);

// Handle the case of an error response.
if ( !isset($xml->id) ) {
   die("Error: {$xml->name} - {$xml->description}\n.");
}

// Echo out successfully returning an session id
echo "Logged in successfully! Session ID is {$xml->id}\n";