class Cache
{
/**
* Resources of the opend memcached connections
* @var array [memcache objects]
*/
var $mc_servers = array();
/**
* Quantity of servers used
* @var int
*/
var $mc_servers_count;
 
var $servers = array(
//array of memcache servers
array('192.168.0.217'=>'11211')
 
);
/**
* Accepts the 2-d array with details of memcached servers
*
* @param array $servers
*/
var $memObj;
function Cache(){
$this->memObj = new Memcache;
if($this->memObj === false)
{
return false;
}
foreach($this->servers as $key=>$val)
{
$this->memObj->addServer(key($val),current($val),false,1,1,-1,TRUE);
}
}
 
/**
* Clear the cache
*
* @return void
*/
function flush() {
if($this->memObj)
{
$this->memObj->flush();
}
}
 
/**
* Returns the value stored in the memory by it's key
*
* @param string $key
* @return mix
*/
function get($key) {
if (is_array($key)) {
$dest = array();
foreach ($key as $subkey) {
$val = $this->memObj->get($subkey);
if (!($val === false)) $dest[$subkey] = $val;
}
return $dest;
} else {
 
return $this->memObj->get($key);
}
}
 
/**
* Store the value in the memcache memory (overwrite if key exists)
*
* @param string $key
* @param mix $var
* @param bool $compress
* @param int $expire (seconds before item expires)
* @return bool
*/
function set($key, $var, $compress=0, $expire=0) {
if($this->memObj)
{
return $this->memObj->set($key, $var, $compress?MEMCACHE_COMPRESSED:null, $expire);
}
}
/**
* Set the value in memcache if the value does not exist; returns FALSE if value exists
*
* @param sting $key
* @param mix $var
* @param bool $compress
* @param int $expire
* @return bool
*/
function add($key, $var, $compress=0, $expire=0) {
if($this->memObj)
{
return $this->memObj->add($key, $var, $compress?MEMCACHE_COMPRESSED:null, $expire);
}
}
 
/**
* Replace an existing value
*
* @param string $key
* @param mix $var
* @param bool $compress
* @param int $expire
* @return bool
*/
function replace($key, $var, $compress=0, $expire=0) {
if($this->memObj)
{
return $this->memObj->replace($key, $var, $compress?MEMCACHE_COMPRESSED:null, $expire);
}
}
/**
* Delete a record or set a timeout
*
* @param string $key
* @param int $timeout
* @return bool
*/
function delete($key, $timeout=0) {
if($this->memObj)
{
return $this->memObj->delete($key, $timeout);
}
}
/**
* Increment an existing integer value
*
* @param string $key
* @param mix $value
* @return bool
*/
function increment($key, $value=1) {
if($this->memObj)
{
return $this->memObj->increment($key, $value);
}
}
/**
* Decrement an existing value
*
* @param string $key
* @param mix $value
* @return bool
*/
function decrement($key, $value=1) {
if($this->memObj)
{
return $this->memObj->decrement($key, $value);
}
}
//class end
}

/**
 *cURL class
 * This is a wrapper class for curl
 * $c = new curl;
 * // enable cache
 * $c = new curl(array('cache'=>true));
 * // enable cookie
 * $c = new curl(array('cookie'=>true));
 * // enable proxy
 * $c = new curl(array('proxy'=>true));
 *
 * // HTTP GET Method
 * $html = $c->get('http://example.com');
 * // HTTP POST Method
 * $html = $c->post('http://example.com/', array('q'=>'words', 'name'=>'moodle'));
 * // HTTP PUT Method
 * $html = $c->put('http://example.com/', array('file'=>'/var/www/test.txt');
 *
 */
class curl {
    public  $cache    = false;
    public  $proxy    = false;
    public  $version  = '0.4 dev';
    public  $response = array();
    public  $header   = array();
    public  $info;
    public  $error;
 
    private $options;
    private $proxy_host = '';
    private $proxy_auth = '';
    private $proxy_type = '';
    private $debug    = false;
    private $cookie   = false;
 
    public function __construct($options = array()){
        global $CFG;
        if (!function_exists('curl_init')) {
            $this->error = 'cURL module must be enabled!';
            trigger_error($this->error, E_USER_ERROR);
            return false;
        }
        // the options of curl should be init here.
        $this->resetopt();
        if (!empty($options['debug'])) {
            $this->debug = true;
        }
        if(!empty($options['cookie'])) {
            if($options['cookie'] === true) {
                $this->cookie = $CFG->dataroot.'/curl_cookie.txt';
            } else {
                $this->cookie = $options['cookie'];
            }
        }
        if (!empty($options['cache'])) {
            if (class_exists('repository_cache')) {
                $this->cache = new repository_cache;
            }
        }
        if (!empty($options['proxy'])) {
            if (!empty($CFG->proxyhost)) {
                if (empty($CFG->proxyport)) {
                    $this->proxy_host = $CFG->proxyhost;
                } else {
                    $this->proxy_host = $CFG->proxyhost.':'.$CFG->proxyport;
                }
                if (!empty($CFG->proxyuser) and !empty($CFG->proxypassword)) {
                    $this->proxy_auth = $CFG->proxyuser.':'.$CFG->proxypassword;
                    $this->setopt(array(
                                'proxyauth'=> CURLAUTH_BASIC | CURLAUTH_NTLM,
                                'proxyuserpwd'=>$this->proxy_auth));
                }
                if (!empty($CFG->proxytype)) {
                    if ($CFG->proxytype == 'SOCKS5') {
                        $this->proxy_type = CURLPROXY_SOCKS5;
                    } else {
                        $this->proxy_type = CURLPROXY_HTTP;
                        $this->setopt(array('httpproxytunnel'=>true));
                    }
                    $this->setopt(array('proxytype'=>$this->proxy_type));
                }
            }
            if (!empty($this->proxy_host)) {
                $this->proxy = array('proxy'=>$this->proxy_host);
            }
        }
    }
    public function resetopt(){
        $this->options = array();
        $this->options['CURLOPT_USERAGENT']         = 'MoodleBot/1.0';
        // True to include the header in the output
        $this->options['CURLOPT_HEADER']            = 0;
        // True to Exclude the body from the output
        $this->options['CURLOPT_NOBODY']            = 0;
        // TRUE to follow any "Location: " header that the server
        // sends as part of the HTTP header (note this is recursive,
        // PHP will follow as many "Location: " headers that it is sent,
        // unless CURLOPT_MAXREDIRS is set).
        $this->options['CURLOPT_FOLLOWLOCATION']    = 1;
        $this->options['CURLOPT_MAXREDIRS']         = 10;
        $this->options['CURLOPT_ENCODING']          = '';
        // TRUE to return the transfer as a string of the return
        // value of curl_exec() instead of outputting it out directly.
        $this->options['CURLOPT_RETURNTRANSFER']    = 1;
        $this->options['CURLOPT_BINARYTRANSFER']    = 0;
        $this->options['CURLOPT_SSL_VERIFYPEER']    = 0;
        $this->options['CURLOPT_SSL_VERIFYHOST']    = 2;
        $this->options['CURLOPT_TIMEOUT']           = 120;
    }
    /**
     * Reset Cookie
     *
     * @param array $options If array is null, this function will
     * reset the options to default value.
     *
     */
    public function resetcookie() {
        if (!empty($this->cookie)) {
            if (is_file($this->cookie)) {
                $fp = fopen($this->cookie, 'w');
                if (!empty($fp)) {
                    fwrite($fp, '');
                    fclose($fp);
                }
            }
        }
    }
    /**
     * Set curl options
     * @param array $options If array is null, this function will
     * reset the options to default value.
     *
     */
    public function setopt($options = array()) {
        if (is_array($options)) {
            foreach($options as $name => $val){
                if (stripos($name, 'CURLOPT_') === false) {
                    $name = strtoupper('CURLOPT_'.$name);
                }
                $this->options[$name] = $val;
            }
        }
    }
    /**
     * Reset http method
     *
     */
    public function cleanopt(){
        unset($this->options['CURLOPT_HTTPGET']);
        unset($this->options['CURLOPT_POST']);
        unset($this->options['CURLOPT_POSTFIELDS']);
        unset($this->options['CURLOPT_PUT']);
        unset($this->options['CURLOPT_INFILE']);
        unset($this->options['CURLOPT_INFILESIZE']);
        unset($this->options['CURLOPT_CUSTOMREQUEST']);
    }
    /**
     * Set HTTP Request Header
     *
     * @param array $headers
     *
     */
    public function setHeader($header) {
        if (is_array($header)){
            foreach ($header as $v) {
                $this->setHeader($v);
            }
        } else {
            $this->header[] = $header;
        }
    }
    /**
     * Set HTTP Response Header
     *
     */
    public function getResponse(){
        return $this->response;
    }
    /**
     * private callback function
     * Formatting HTTP Response Header
     *
     */
    private function formatHeader($ch, $header)
    {
        $this->count++;
        if (strlen($header) > 2) {
            list($key, $value) = explode(" ", rtrim($header, "\r\n"), 2);
            $key = rtrim($key, ':');
            if (!empty($this->response[$key])) {
                if (is_array($this->response[$key])){
                    $this->response[$key][] = $value;
                } else {
                    $tmp = $this->response[$key];
                    $this->response[$key] = array();
                    $this->response[$key][] = $tmp;
                    $this->response[$key][] = $value;
 
                }
            } else {
                $this->response[$key] = $value;
            }
        }
        return strlen($header);
    }
    /**
     * Set options for individual curl instance
     */
    private function apply_opt($curl, $options) {
        // Clean up
        $this->cleanopt();
        // set cookie
        if (!empty($this->cookie) || !empty($options['cookie'])) {
            $this->setopt(array('cookiejar'=>$this->cookie,
                            'cookiefile'=>$this->cookie
                             ));
        }
        // set proxy
        if (!empty($this->proxy) || !empty($options['proxy'])) {
            $this->setopt($this->proxy);
        }
        $this->setopt($options);
        // reset before set options
        curl_setopt($curl, CURLOPT_HEADERFUNCTION, array(&$this,'formatHeader'));
        // set headers
        if (empty($this->header)){
            $this->setHeader(array(
                'User-Agent: MoodleBot/1.0',
                'Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7',
                'Connection: keep-alive'
                ));
        }
        curl_setopt($curl, CURLOPT_HTTPHEADER, $this->header);
 
        if ($this->debug){
            echo '<h1>Options</h1>';
            var_dump($this->options);
            echo '<h1>Header</h1>';
            var_dump($this->header);
        }
 
        // set options
        foreach($this->options as $name => $val) {
            if (is_string($name)) {
                $name = constant(strtoupper($name));
            }
            curl_setopt($curl, $name, $val);
        }
        return $curl;
    }
    /*
     * Download multiple files in parallel
     * $c = new curl;
     * $c->download(array(
     *              array('url'=>'http://localhost/', 'file'=>fopen('a', 'wb')), 
     *              array('url'=>'http://localhost/20/', 'file'=>fopen('b', 'wb'))
     *              ));
     */
    public function download($requests, $options = array()) {
        $options['CURLOPT_BINARYTRANSFER'] = 1;
        $options['RETURNTRANSFER'] = false;
        return $this->multi($requests, $options);
    }
    /*
     * Mulit HTTP Requests
     * This function could run multi-requests in parallel.
     */
    protected function multi($requests, $options = array()) {
        $count   = count($requests);
        $handles = array();
        $results = array();
        $main    = curl_multi_init();
        for ($i = 0; $i < $count; $i++) {
            $url = $requests[$i];
            foreach($url as $n=>$v){
                $options[$n] = $url[$n];
            }
            $handles[$i] = curl_init($url['url']);
            $this->apply_opt($handles[$i], $options);
            curl_multi_add_handle($main, $handles[$i]);
        }
        $running = 0;
        do {
            curl_multi_exec($main, $running);
        } while($running > 0);
        for ($i = 0; $i < $count; $i++) {
            if (!empty($optins['CURLOPT_RETURNTRANSFER'])) {
                $results[] = true;
            } else {
                $results[] = curl_multi_getcontent($handles[$i]);
            }
            curl_multi_remove_handle($main, $handles[$i]);
        }
        curl_multi_close($main);
        return $results;
    }
    /**
     * Single HTTP Request
     */
    protected function request($url, $options = array()){
        // create curl instance
        $curl = curl_init($url);
        $options['url'] = $url;
        $this->apply_opt($curl, $options);
        if ($this->cache && $ret = $this->cache->get($this->options)) {
            return $ret;
        } else {
            $ret  = curl_exec($curl);
            if ($this->cache) {
                $this->cache->set($this->options, $ret);
            }
        }
        $this->info  = curl_getinfo($curl);
        $this->error = curl_error($curl);
        if ($this->debug){
            echo '<h1>Return Data</h1>';
            var_dump($ret);
            echo '<h1>Info</h1>';
            var_dump($this->info);
            echo '<h1>Error</h1>';
            var_dump($this->error);
        }
        curl_close($curl);
        if (!empty($ret)){
            return $ret;
        } else {
            return false;
        }
    }
    /**
     * HTTP HEAD method
     */
    public function head($url, $options = array()){
        $options['CURLOPT_HTTPGET'] = 0;
        $options['CURLOPT_HEADER']  = 1;
        $options['CURLOPT_NOBODY']  = 1;
        return $this->request($url, $options);
    }
    /**
     * HTTP POST method
     */
    public function post($url, $params = array(), $options = array()){
        //$options['CURLOPT_POST']       = 1;
        //$options['CURLOPT_POSTFIELDS'] = $params;
        //return $this->request($url, $options);
        $file = $params['file'];
        if (!is_file($file)){
            return null;
        }
        $fp   = fopen($file, 'r');
        $size = filesize($file);
        $options['CURLOPT_CUSTOMREQUEST'] = 'POST';
        $options['CURLOPT_UPLOAD'] = 1;
        $options['CURLOPT_INFILESIZE'] = $size;
        $options['CURLOPT_INFILE']     = $fp;
        if (!isset($this->options['CURLOPT_USERPWD'])){
            $this->setopt(array('CURLOPT_USERPWD'=>'anonymous: satishgaude@gmail.com'));
        }
        $ret = $this->request($url, $options);
        fclose($fp);
        return $ret;
    }
    /**
     * HTTP GET method
     */
    public function get($url, $params = array(), $options = array()){
        $options['CURLOPT_HTTPGET'] = 1;
        if (!empty($params)){
            $url .= (stripos($url, '?') !== false) ? '&' : '?';
            $url .= http_build_query($params, '', '&');
        }
        return $this->request($url, $options);
    }
    /**
     * HTTP PUT method
     */
    public function put($url, $params = array(), $options = array()){
        $file = $params['file'];
        if (!is_file($file)){
            return null;
        }
        $fp   = fopen($file, 'r');
        $size = filesize($file);
        $options['CURLOPT_PUT']        = 1;
        $options['CURLOPT_INFILESIZE'] = $size;
        $options['CURLOPT_INFILE']     = $fp;
        if (!isset($this->options['CURLOPT_USERPWD'])){
            $this->setopt(array('CURLOPT_USERPWD'=>'anonymous: satishgaude@gmail.com'));
        }
        $ret = $this->request($url, $options);
        fclose($fp);
        return $ret;
    }
    /**
     * HTTP DELETE method
     */
    public function delete($url, $params = array(), $options = array()){
        $file = $params['file'];
        if (!is_file($file)){
            return null;
        }
		$options['CURLOPT_CUSTOMREQUEST'] = 'DELETE';
        $fp   = fopen($file, 'r');
        $size = filesize($file);
        $options['CURLOPT_UPLOAD'] = 1;
        $options['CURLOPT_INFILESIZE'] = $size;
        $options['CURLOPT_INFILE']     = $fp;
        if (!isset($options['CURLOPT_USERPWD'])) {
            $options['CURLOPT_USERPWD'] = 'anonymous: satishgaude@gmail.com';
        }
        $ret = $this->request($url, $options);
        fclose($fp);
        return $ret;
    }
	/**
	* HTTP TRACE method
	*/
    public function trace($url, $options = array()){
        $options['CURLOPT_CUSTOMREQUEST'] = 'TRACE';
        $ret = $this->request($url, $options);  
        return $ret;
    }
    /**
     * HTTP OPTIONS method
     */
    public function options($url, $options = array()){
        $options['CURLOPT_CUSTOMREQUEST'] = 'OPTIONS';
        $ret = $this->request($url, $options);
        return $ret;
    }
}

/**
* sendDataOnSocket
* function to submit data via socket
* @param string $sContent content to send
* @param string $sHost Host name
* @param string $sFilePath  file to post data
* @param string $sMethod method name
* @return string aig response
* @access public
*/
public static function sendDataOnSocket($sContent,$sHost,$sFilePath,$sMethod) {
if(strlen($sHost)==0) {
return array(1, "Empty Host name");
}else if (strlen($sMethod)==0) {
return array(1, "Empty Method");
}
$fp = fsockopen($sHost, "80", $errno, $errstr, 30);
if (!$fp) {
//could not open socket
return array(1, "could not open socket");
} else {
$out = $sMethod." ".$sFilePath." HTTP/1.1\r\n";
$out .= "Content-type: application/x-www-form-urlencoded\r\n";
$out .= "Content-Length: ".strlen($sContent)."\r\n";
$out .= "Host: $sHost:80\r\n";
$out .= $sContent;
$out .= "\r\n";
fwrite($fp, $out);
while (!feof($fp))
{
$tempdata =  fgets($fp, 128);
$data .= $tempdata;
}
return array(0, $data);
}
}

/**
* validateXmlAgainstXsd
* function to validate xml against xsd file provided
* @param string $error error
* @return string api response
* @access public
*/
public static function validateXmlAgainstXsd($sXmlPath,$sXsdPath) {
// Enable user error handling
libxml_use_internal_errors(true);
$xml = new DOMDocument();
$xml->load($sXmlPath);
if (!$xml->schemaValidate($sXsdPath)) {
$aError =self::libxml_display_errors();
$iError=1;
}
else {
$iError=0;
}
return array($iError,$aError);
}
 
Example of XSD file:
<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:annotation>
	<xs:documentation xml:lang="en">
		Job specification schema for scheduler.vubites.com
		Copyright 2010 satishgaudo.com. All rights reserved.
	</xs:documentation>
</xs:annotation>
<xs:element name="response" type="responseType"/>
	<xs:complexType name="responseType">
		<xs:sequence>
			<xs:element name="status" maxOccurs="1" type="xs:string"></xs:element>	
			<xs:element name="remark" maxOccurs="1" type="xs:string"></xs:element>
			<xs:element name="statuscode" maxOccurs="1" type="xs:int"></xs:element>
			<xs:element name="mashid" maxOccurs="1" type="xs:string"></xs:element>
			<xs:element name="channel_id" maxOccurs="1" type="xs:int"></xs:element>
			<xs:element name="profile_id" minOccurs="1" maxOccurs="1" type="xs:int"></xs:element>
			<xs:element name="md5checksum" minOccurs="0" type="xs:string"></xs:element>
		</xs:sequence>
	</xs:complexType>
</xs:schema>
 
 
Example of valid xml file:
<?xml version="1.0" encoding="UTF-8"?>
<response>
<status><![CDATA[Success]]></status>
<remark><![CDATA[MD5 ckecksum]]></remark>
<statuscode><![CDATA[58]]></statuscode>
<mashid><![CDATA[e3f03946968bc172d6e00c93a760d0c4]]></mashid><channel_id><![CDATA[10]]></channel_id>
<profile_id><![CDATA[1]]></profile_id>
<md5checksum><![CDATA[6f14e5acafa546495261adbd95f4a541]]></md5checksum>
</response>

/**
* getFileMimeType
* returns the mime type of the file
* @param string $sFilePath File path
* @return string mime type of the file
* @access public
*/
public function getFileMimeType($sFilePath)
{
exec('/usr/bin/file -i -b ' . realpath($sFilePath), $aOutput);
$sType = $aOutput[0];
$aMimeTypeDet = explode(';', $sType);
return trim($aMimeTypeDet[0]);
}