WebSVN – HomeAutomation – Diff – /trunk/PcSoftware/scripts/exchangeIntegration/exchange.php


<?php
 
require(dirname(__FILE__)."/config.php");
 
if (isset($_GET["function"]))
{
    switch ($_GET["function"])
    {
        case "getMeetingsRestOfDay":
        if (isset($_GET["shortname"]))
        {
            echo getMeetingsRestOfDay($_GET["shortname"]);
        }
        break;
       
        case "bookMeeting":
        if (isset($_GET["from"]) && isset($_GET["to"]))
        {
           
        }
        break;
       
        //case "":
        //
        //break;
    }
}
 
function getMeetingsRestOfDay($shortname)
{
    global $Calender;
    global $wsdl;
    $founditem = false;
   
    foreach($Calender as $item)
    {
        if ($item->Shortname == $shortname)
        {
            $founditem = $item;
            break;
        }
    }
   
    if ($founditem !== false)
    {
        $FindItem->Traversal = "Shallow";
        $FindItem->ItemShape->BaseShape = "AllProperties";
        $FindItem->ParentFolderIds->DistinguishedFolderId->Id = "calendar";
        /* Dont forget to use the proper timezone and setting for daylight saving time (php handles this fine) */
        $FindItem->CalendarView->StartDate = date("c");     //"2009-04-07T08:00:00Z";
        $FindItem->CalendarView->EndDate = date("c", strtotime("+9 hour")); //"2009-04-08T00:00:00Z";
        //echo date("c")." ".date("c", strtotime("+8 hour"))." ".date("c", strtotime("18:00"))."\n";
 
        stream_wrapper_unregister('https');
        stream_wrapper_register('https', 'NTLMStream') or die("Failed to register protocol");
         
        $returndata = "{ \n\tshortname:'".$shortname."',\n\tmeetings:[\n";
        try
        {
            $client = new ExchangeNTLMSoapClient($wsdl);
            $client->user = $founditem->UserName;
            $client->pass = $founditem->Password;
            $result = $client->FindItem($FindItem);
            if ($result)
            {
                //print_array($result);
                $calendaritems = $result->ResponseMessages->FindItemResponseMessage->RootFolder->Items->CalendarItem;
                //print_array($calendaritems);
                for ($i = 0; $i < count($calendaritems); $i++)
                {
                    if (count($calendaritems) > 1)
                    {
                        $item = $calendaritems[$i];
                    }
                    else
                    {
                        $item = $calendaritems;
                    }
                    $returndata .= "\t\t{\n";
                    $returndata .= "\t\torganizer:'".$item->Organizer->Mailbox->Name."',\n";
                    $returndata .= "\t\tstart:'".date("G:i", strtotime($item->Start))."',\n";
                    $returndata .= "\t\tend:'".date("G:i", strtotime($item->End))."'\n";
                    $returndata .= "\t\t}";
                    if ($i+1 < count($calendaritems))
                    {
                        $returndata .= ",\n";
                    }
                }
            }
           
        }
        catch (SoapFault $exception)
        {
            return "{ error:'".$exception."',\nshortname:'".$shortname."'}\n";
        }
 
        stream_wrapper_restore('https');
        $returndata .= "\n\t]\n}\n";
        return $returndata;
    }
    else
    {
        return "{ error:'Unknown shortname',\nshortname:'".$shortname."'}\n";
    }
}
 
 
function print_array($var)
{
    echo "<pre>\n";
    print_r($var);
    echo "</pre>\n";
}
 
class NTLMSoapClient extends SoapClient {
    function __doRequest($request, $location, $action, $version)
    {
        global $exchangeurl;
        $location=$exchangeurl; //override url to exchange server
 
        $headers = array( 'Method: POST',
            'Connection: Keep-Alive',
            'User-Agent: PHP-SOAP-CURL',
            'Content-Type: text/xml; charset=utf-8',
            'SOAPAction: "'.$action.'"',
            );
        $this->__last_request_headers = $headers;
        $ch = curl_init($location);
        curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
        curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, false);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
        curl_setopt($ch, CURLOPT_POST, true );
        curl_setopt($ch, CURLOPT_POSTFIELDS, $request);
        curl_setopt($ch, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1);
        curl_setopt($ch, CURLOPT_HTTPAUTH, CURLAUTH_NTLM);
        curl_setopt($ch, CURLOPT_USERPWD, $this->user.':'.$this->pass);
        $response = curl_exec($ch);
 
/*$myfile = "/tmp/debugex.txt";
$fh = fopen($myfile, 'w+') or die("can't open file");
fwrite($fh, "user: ". $this->user. " pass: ".$this->pass."\n");
fwrite($fh, "req: ". $request ."loc: ". $location ." act: ". $action ." ver: ". $version."\n");
fwrite($fh, "reponse: ". $response."\n\n");
fclose($fh);
*/
       
        return $response;
    }
   
    function __getLastRequestHeaders()
    {
        return implode("\n", $this->__last_request_headers)."\n";
    }
}
 
class ExchangeNTLMSoapClient extends NTLMSoapClient
{
    public $user = '';
    public $password = '';
}
 
class NTLMStream
{
    private $path;
    private $mode;
    private $options;
    private $opened_path;
    private $buffer;
    private $pos;
 
    /**
     * Open the stream
     *
     * @param unknown_type $path
     * @param unknown_type $mode
     * @param unknown_type $options
     * @param unknown_type $opened_path
     * @return unknown
     */
    public function stream_open($path, $mode, $options, $opened_path)
    {
        echo "[NTLMStream::stream_open] $path , mode=$mode \n";
        $this->path = $path;
        $this->mode = $mode;
        $this->options = $options;
        $this->opened_path = $opened_path;
        $this->createBuffer($path);
        return true;
    }
 
    /**
     * Close the stream
     *
     */
    public function stream_close()
    {
        echo "[NTLMStream::stream_close] \n";
        curl_close($this->ch);
    }
 
    /**
     * Read the stream
     *
     * @param int $count number of bytes to read
     * @return content from pos to count
     */
    public function stream_read($count)
    {
        echo "[NTLMStream::stream_read] $count \n";
        if(strlen($this->buffer) == 0)
        {
            return false;
        }
        $read = substr($this->buffer,$this->pos, $count);
        $this->pos += $count;
        return $read;
    }
 
    /***
     * write the stream
     *
     * @param $data
     * @return
     */
    public function stream_write($data)
    {
        echo "[NTLMStream::stream_write] \n";
        if(strlen($this->buffer) == 0)
        {
            return false;
        }
        return true;
    }
 
    /**
     *
     * @return true if eof else false
     */
    public function stream_eof()
    {
        echo "[NTLMStream::stream_eof] ";
        if($this->pos > strlen($this->buffer))
        {
            echo "true \n";
            return true;
        }
        echo "false \n";
        return false;
    }
 
    /**
     * @return int the position of the current read pointer
     */
    public function stream_tell()
    {
        echo "[NTLMStream::stream_tell] \n";
        return $this->pos;
    }
 
    /**
     * Flush stream data
     */
    public function stream_flush()
    {
        echo "[NTLMStream::stream_flush] \n";
        $this->buffer = null;
        $this->pos = null;
    }
 
    /**
     * Stat the file, return only the size of the buffer
     *
     * @return array stat information
     */
    public function stream_stat()
    {
        echo "[NTLMStream::stream_stat] \n";
        $this->createBuffer($this->path);
        $stat = array( 'size' => strlen($this->buffer), );
        return $stat;
    }
 
    /**
     * Stat the url, return only the size of the buffer
     *
     * @return array stat information
     */
    public function url_stat($path, $flags)
    {
        echo "[NTLMStream::url_stat] \n";
        $this->createBuffer($path);
        $stat = array( 'size' => strlen($this->buffer), );
        return $stat;
    }
 
    /* Create the buffer by requesting the url through cURL */
    private function createBuffer($path)
    {
        if($this->buffer)
        {
            return;
        }
        echo "[NTLMStream::createBuffer] create buffer from : $path \n";
        $this->ch = curl_init($path);
        curl_setopt($this->ch, CURLOPT_SSL_VERIFYPEER, false);
        curl_setopt($this->ch, CURLOPT_SSL_VERIFYHOST, false);
        curl_setopt($this->ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($this->ch, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1);
        curl_setopt($this->ch, CURLOPT_HTTPAUTH, CURLAUTH_NTLM);
        curl_setopt($this->ch, CURLOPT_USERPWD, $user.':'.$pass);
        echo $this->buffer = curl_exec($this->ch);
       
        echo "[NTLMStream::createBuffer] buffer size : ".strlen($this->buffer)."bytes \n";
        $this->pos = 0;
/*$myfile = "/tmp/debugex.txt";
$fh = fopen($myfile, 'w+') or die("can't open file");
fwrite($fh, "user: ". $this->user. " pass: ".$this->pass."\n");
fwrite($fh, "req: ". $request ."loc: ". $location ." act: ". $action ." ver: ". $version."\n");
fwrite($fh, "reponse: ". $response."\n\n");
fclose($fh);
*/
    }
}
 
?>
 

Rev 1165	Rev 1169
1	<?php	1	<?php
2		2
3	require(dirname(__FILE__)."/config.php");	3	require(dirname(__FILE__)."/config.php");
4		4
5	if (isset($_GET["function"]))	5	if (isset($_GET["function"]))
6	{	6	{
7	switch ($_GET["function"])	7	switch ($_GET["function"])
8	{	8	{
9	case "getMeetingsRestOfDay":	9	case "getMeetingsRestOfDay":
10	if (isset($_GET["shortname"]))	10	if (isset($_GET["shortname"]))
11	{	11	{
12	echo getMeetingsRestOfDay($_GET["shortname"]);	12	echo getMeetingsRestOfDay($_GET["shortname"]);
13	}	13	}
14	break;	14	break;
15		15
16	case "bookMeeting":	16	case "bookMeeting":
17	if (isset($_GET["from"]) && isset($_GET["to"]))	17	if (isset($_GET["from"]) && isset($_GET["to"]))
18	{	18	{
19		19
20	}	20	}
21	break;	21	break;
22		22
23	//case "":	23	//case "":
24	//	24	//
25	//break;	25	//break;
26	}	26	}
27	}	27	}
28		28
29	function getMeetingsRestOfDay($shortname)	29	function getMeetingsRestOfDay($shortname)
30	{	30	{
31	global $Calender;	31	global $Calender;
32	global $wsdl;	32	global $wsdl;
33	$founditem = false;	33	$founditem = false;
34		34
35	foreach($Calender as $item)	35	foreach($Calender as $item)
36	{	36	{
37	if ($item->Shortname == $shortname)	37	if ($item->Shortname == $shortname)
38	{	38	{
39	$founditem = $item;	39	$founditem = $item;
40	break;	40	break;
41	}	41	}
42	}	42	}
43		43
44	if ($founditem !== false)	44	if ($founditem !== false)
45	{	45	{
46	$FindItem->Traversal = "Shallow";	46	$FindItem->Traversal = "Shallow";
47	$FindItem->ItemShape->BaseShape = "AllProperties";	47	$FindItem->ItemShape->BaseShape = "AllProperties";
48	$FindItem->ParentFolderIds->DistinguishedFolderId->Id = "calendar";	48	$FindItem->ParentFolderIds->DistinguishedFolderId->Id = "calendar";
49	/* Dont forget to use the proper timezone and setting for daylight saving time (php handles this fine) */	49	/* Dont forget to use the proper timezone and setting for daylight saving time (php handles this fine) */
50	$FindItem->CalendarView->StartDate = date("c"); //"2009-04-07T08:00:00Z";	50	$FindItem->CalendarView->StartDate = date("c"); //"2009-04-07T08:00:00Z";
51	$FindItem->CalendarView->EndDate = date("c", strtotime("+9 hour")); //"2009-04-08T00:00:00Z";	51	$FindItem->CalendarView->EndDate = date("c", strtotime("+9 hour")); //"2009-04-08T00:00:00Z";
52	//echo date("c")." ".date("c", strtotime("+8 hour"))." ".date("c", strtotime("18:00"))."\n";	52	//echo date("c")." ".date("c", strtotime("+8 hour"))." ".date("c", strtotime("18:00"))."\n";
53		53
54	stream_wrapper_unregister('https');	54	stream_wrapper_unregister('https');
55	stream_wrapper_register('https', 'NTLMStream') or die("Failed to register protocol");	55	stream_wrapper_register('https', 'NTLMStream') or die("Failed to register protocol");
56		56
57	$returndata = "~~<calendar>~~\n\t<shortname>".$shortname."~~</shortname>~~\n";	57	$returndata = "{ \n\tshortname:'".$shortname."',\n\tmeetings:[\n";
58	try	58	try
59	{	59	{
60	$client = new ExchangeNTLMSoapClient($wsdl);	60	$client = new ExchangeNTLMSoapClient($wsdl);
61	$client->user = $founditem->UserName;	61	$client->user = $founditem->UserName;
62	$client->pass = $founditem->Password;	62	$client->pass = $founditem->Password;
63	$result = $client->FindItem($FindItem);	63	$result = $client->FindItem($FindItem);
64	if ($result)	64	if ($result)
65	{	65	{
66	//print_array($result);	66	//print_array($result);
67	$calendaritems = $result->ResponseMessages->FindItemResponseMessage->RootFolder->Items->CalendarItem;	67	$calendaritems = $result->ResponseMessages->FindItemResponseMessage->RootFolder->Items->CalendarItem;
68	//print_array($calendaritems);	68	//print_array($calendaritems);
69	for ($i = 0; $i < count($calendaritems); $i++)	69	for ($i = 0; $i < count($calendaritems); $i++)
70	{	70	{
71	if (count($calendaritems) > 1)	71	if (count($calendaritems) > 1)
72	{	72	{
73	$item = $calendaritems[$i];	73	$item = $calendaritems[$i];
74	}	74	}
75	else	75	else
76	{	76	{
77	$item = $calendaritems;	77	$item = $calendaritems;
78	}	78	}
79	$returndata .= "\t~~<meeting>~~\n";	79	$returndata .= "\t\t{\n";
80	$returndata .= "\t\t<organizer>".$item->Organizer->~~Mailbox~~->Name."~~</organizer>~~\n";	80	$returndata .= "\t\torganizer:'".$item->Organizer->Mailbox->Name."',\n";
81	$returndata .= "\t\t<start>".~~date~~("G:i", strtotime($item->Start))."~~</start>~~\n";	81	$returndata .= "\t\tstart:'".date("G:i", strtotime($item->Start))."',\n";
82	$returndata .= "\t\t<end>".~~date~~("G:i", strtotime($item->End))."~~</end>~~\n";	82	$returndata .= "\t\tend:'".date("G:i", strtotime($item->End))."'\n";
83	$returndata .= "\t~~</meeting>~~\n";	83	$returndata .= "\t\t}";
-		84	if ($i+1 < count($calendaritems))
-		85	{
-		86	$returndata .= ",\n";
-		87	}
84	}	88	}
85	}	89	}
86		90
87	}	91	}
88	catch (SoapFault $exception)	92	catch (SoapFault $exception)
89	{	93	{
90	return "<error>".$exception."~~</error>~~";	94	return "{ error:'".$exception."',\nshortname:'".$shortname."'}\n";
91	}	95	}
92		96
93	stream_wrapper_restore('https');	97	stream_wrapper_restore('https');
94	$returndata .= "~~</calendar>~~\n";	98	$returndata .= "\n\t]\n}\n";
95	return $returndata;	99	return $returndata;
96	}	100	}
97	else	101	else
98	{	102	{
99	return "<error~~>Unknown~~ shortname~~</error>~~";	103	return "{ error:'Unknown shortname',\nshortname:'".$shortname."'}\n";
100	}	104	}
101	}	105	}
102		106
103		107
104	function print_array($var)	108	function print_array($var)
105	{	109	{
106	echo "<pre>\n";	110	echo "<pre>\n";
107	print_r($var);	111	print_r($var);
108	echo "</pre>\n";	112	echo "</pre>\n";
109	}	113	}
110		114
111	class NTLMSoapClient extends SoapClient {	115	class NTLMSoapClient extends SoapClient {
112	function __doRequest($request, $location, $action, $version)	116	function __doRequest($request, $location, $action, $version)
113	{	117	{
114	global $exchangeurl;	118	global $exchangeurl;
115	$location=$exchangeurl; //override url to exchange server	119	$location=$exchangeurl; //override url to exchange server
116		120
117	$headers = array( 'Method: POST',	121	$headers = array( 'Method: POST',
118	'Connection: Keep-Alive',	122	'Connection: Keep-Alive',
119	'User-Agent: PHP-SOAP-CURL',	123	'User-Agent: PHP-SOAP-CURL',
120	'Content-Type: text/xml; charset=utf-8',	124	'Content-Type: text/xml; charset=utf-8',
121	'SOAPAction: "'.$action.'"',	125	'SOAPAction: "'.$action.'"',
122	);	126	);
123	$this->__last_request_headers = $headers;	127	$this->__last_request_headers = $headers;
124	$ch = curl_init($location);	128	$ch = curl_init($location);
125	curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);	129	curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
126	curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, false);	130	curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, false);
127	curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);	131	curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
128	curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);	132	curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
129	curl_setopt($ch, CURLOPT_POST, true );	133	curl_setopt($ch, CURLOPT_POST, true );
130	curl_setopt($ch, CURLOPT_POSTFIELDS, $request);	134	curl_setopt($ch, CURLOPT_POSTFIELDS, $request);
131	curl_setopt($ch, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1);	135	curl_setopt($ch, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1);
132	curl_setopt($ch, CURLOPT_HTTPAUTH, CURLAUTH_NTLM);	136	curl_setopt($ch, CURLOPT_HTTPAUTH, CURLAUTH_NTLM);
133	curl_setopt($ch, CURLOPT_USERPWD, $this->user.':'.$this->pass);	137	curl_setopt($ch, CURLOPT_USERPWD, $this->user.':'.$this->pass);
134	$response = curl_exec($ch);	138	$response = curl_exec($ch);
135		139
136	/*$myfile = "/tmp/debugex.txt";	140	/*$myfile = "/tmp/debugex.txt";
137	$fh = fopen($myfile, 'w+') or die("can't open file");	141	$fh = fopen($myfile, 'w+') or die("can't open file");
138	fwrite($fh, "user: ". $this->user. " pass: ".$this->pass."\n");	142	fwrite($fh, "user: ". $this->user. " pass: ".$this->pass."\n");
139	fwrite($fh, "req: ". $request ."loc: ". $location ." act: ". $action ." ver: ". $version."\n");	143	fwrite($fh, "req: ". $request ."loc: ". $location ." act: ". $action ." ver: ". $version."\n");
140	fwrite($fh, "reponse: ". $response."\n\n");	144	fwrite($fh, "reponse: ". $response."\n\n");
141	fclose($fh);	145	fclose($fh);
142	*/	146	*/
143		147
144	return $response;	148	return $response;
145	}	149	}
146		150
147	function __getLastRequestHeaders()	151	function __getLastRequestHeaders()
148	{	152	{
149	return implode("\n", $this->__last_request_headers)."\n";	153	return implode("\n", $this->__last_request_headers)."\n";
150	}	154	}
151	}	155	}
152		156
153	class ExchangeNTLMSoapClient extends NTLMSoapClient	157	class ExchangeNTLMSoapClient extends NTLMSoapClient
154	{	158	{
155	public $user = '';	159	public $user = '';
156	public $password = '';	160	public $password = '';
157	}	161	}
158		162
159	class NTLMStream	163	class NTLMStream
160	{	164	{
161	private $path;	165	private $path;
162	private $mode;	166	private $mode;
163	private $options;	167	private $options;
164	private $opened_path;	168	private $opened_path;
165	private $buffer;	169	private $buffer;
166	private $pos;	170	private $pos;
167		171
168	/**	172	/**
169	* Open the stream	173	* Open the stream
170	*	174	*
171	* @param unknown_type $path	175	* @param unknown_type $path
172	* @param unknown_type $mode	176	* @param unknown_type $mode
173	* @param unknown_type $options	177	* @param unknown_type $options
174	* @param unknown_type $opened_path	178	* @param unknown_type $opened_path
175	* @return unknown	179	* @return unknown
176	*/	180	*/
177	public function stream_open($path, $mode, $options, $opened_path)	181	public function stream_open($path, $mode, $options, $opened_path)
178	{	182	{
179	echo "[NTLMStream::stream_open] $path , mode=$mode \n";	183	echo "[NTLMStream::stream_open] $path , mode=$mode \n";
180	$this->path = $path;	184	$this->path = $path;
181	$this->mode = $mode;	185	$this->mode = $mode;
182	$this->options = $options;	186	$this->options = $options;
183	$this->opened_path = $opened_path;	187	$this->opened_path = $opened_path;
184	$this->createBuffer($path);	188	$this->createBuffer($path);
185	return true;	189	return true;
186	}	190	}
187		191
188	/**	192	/**
189	* Close the stream	193	* Close the stream
190	*	194	*
191	*/	195	*/
192	public function stream_close()	196	public function stream_close()
193	{	197	{
194	echo "[NTLMStream::stream_close] \n";	198	echo "[NTLMStream::stream_close] \n";
195	curl_close($this->ch);	199	curl_close($this->ch);
196	}	200	}
197		201
198	/**	202	/**
199	* Read the stream	203	* Read the stream
200	*	204	*
201	* @param int $count number of bytes to read	205	* @param int $count number of bytes to read
202	* @return content from pos to count	206	* @return content from pos to count
203	*/	207	*/
204	public function stream_read($count)	208	public function stream_read($count)
205	{	209	{
206	echo "[NTLMStream::stream_read] $count \n";	210	echo "[NTLMStream::stream_read] $count \n";
207	if(strlen($this->buffer) == 0)	211	if(strlen($this->buffer) == 0)
208	{	212	{
209	return false;	213	return false;
210	}	214	}
211	$read = substr($this->buffer,$this->pos, $count);	215	$read = substr($this->buffer,$this->pos, $count);
212	$this->pos += $count;	216	$this->pos += $count;
213	return $read;	217	return $read;
214	}	218	}
215		219
216	/***	220	/***
217	* write the stream	221	* write the stream
218	*	222	*
219	* @param $data	223	* @param $data
220	* @return	224	* @return
221	*/	225	*/
222	public function stream_write($data)	226	public function stream_write($data)
223	{	227	{
224	echo "[NTLMStream::stream_write] \n";	228	echo "[NTLMStream::stream_write] \n";
225	if(strlen($this->buffer) == 0)	229	if(strlen($this->buffer) == 0)
226	{	230	{
227	return false;	231	return false;
228	}	232	}
229	return true;	233	return true;
230	}	234	}
231		235
232	/**	236	/**
233	*	237	*
234	* @return true if eof else false	238	* @return true if eof else false
235	*/	239	*/
236	public function stream_eof()	240	public function stream_eof()
237	{	241	{
238	echo "[NTLMStream::stream_eof] ";	242	echo "[NTLMStream::stream_eof] ";
239	if($this->pos > strlen($this->buffer))	243	if($this->pos > strlen($this->buffer))
240	{	244	{
241	echo "true \n";	245	echo "true \n";
242	return true;	246	return true;
243	}	247	}
244	echo "false \n";	248	echo "false \n";
245	return false;	249	return false;
246	}	250	}
247		251
248	/**	252	/**
249	* @return int the position of the current read pointer	253	* @return int the position of the current read pointer
250	*/	254	*/
251	public function stream_tell()	255	public function stream_tell()
252	{	256	{
253	echo "[NTLMStream::stream_tell] \n";	257	echo "[NTLMStream::stream_tell] \n";
254	return $this->pos;	258	return $this->pos;
255	}	259	}
256		260
257	/**	261	/**
258	* Flush stream data	262	* Flush stream data
259	*/	263	*/
260	public function stream_flush()	264	public function stream_flush()
261	{	265	{
262	echo "[NTLMStream::stream_flush] \n";	266	echo "[NTLMStream::stream_flush] \n";
263	$this->buffer = null;	267	$this->buffer = null;
264	$this->pos = null;	268	$this->pos = null;
265	}	269	}
266		270
267	/**	271	/**
268	* Stat the file, return only the size of the buffer	272	* Stat the file, return only the size of the buffer
269	*	273	*
270	* @return array stat information	274	* @return array stat information
271	*/	275	*/
272	public function stream_stat()	276	public function stream_stat()
273	{	277	{
274	echo "[NTLMStream::stream_stat] \n";	278	echo "[NTLMStream::stream_stat] \n";
275	$this->createBuffer($this->path);	279	$this->createBuffer($this->path);
276	$stat = array( 'size' => strlen($this->buffer), );	280	$stat = array( 'size' => strlen($this->buffer), );
277	return $stat;	281	return $stat;
278	}	282	}
279		283
280	/**	284	/**
281	* Stat the url, return only the size of the buffer	285	* Stat the url, return only the size of the buffer
282	*	286	*
283	* @return array stat information	287	* @return array stat information
284	*/	288	*/
285	public function url_stat($path, $flags)	289	public function url_stat($path, $flags)
286	{	290	{
287	echo "[NTLMStream::url_stat] \n";	291	echo "[NTLMStream::url_stat] \n";
288	$this->createBuffer($path);	292	$this->createBuffer($path);
289	$stat = array( 'size' => strlen($this->buffer), );	293	$stat = array( 'size' => strlen($this->buffer), );
290	return $stat;	294	return $stat;
291	}	295	}
292		296
293	/* Create the buffer by requesting the url through cURL */	297	/* Create the buffer by requesting the url through cURL */
294	private function createBuffer($path)	298	private function createBuffer($path)
295	{	299	{
296	if($this->buffer)	300	if($this->buffer)
297	{	301	{
298	return;	302	return;
299	}	303	}
300	echo "[NTLMStream::createBuffer] create buffer from : $path \n";	304	echo "[NTLMStream::createBuffer] create buffer from : $path \n";
301	$this->ch = curl_init($path);	305	$this->ch = curl_init($path);
302	curl_setopt($this->ch, CURLOPT_SSL_VERIFYPEER, false);	306	curl_setopt($this->ch, CURLOPT_SSL_VERIFYPEER, false);
303	curl_setopt($this->ch, CURLOPT_SSL_VERIFYHOST, false);	307	curl_setopt($this->ch, CURLOPT_SSL_VERIFYHOST, false);
304	curl_setopt($this->ch, CURLOPT_RETURNTRANSFER, true);	308	curl_setopt($this->ch, CURLOPT_RETURNTRANSFER, true);
305	curl_setopt($this->ch, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1);	309	curl_setopt($this->ch, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1);
306	curl_setopt($this->ch, CURLOPT_HTTPAUTH, CURLAUTH_NTLM);	310	curl_setopt($this->ch, CURLOPT_HTTPAUTH, CURLAUTH_NTLM);
307	curl_setopt($this->ch, CURLOPT_USERPWD, $user.':'.$pass);	311	curl_setopt($this->ch, CURLOPT_USERPWD, $user.':'.$pass);
308	echo $this->buffer = curl_exec($this->ch);	312	echo $this->buffer = curl_exec($this->ch);
309		313
310	echo "[NTLMStream::createBuffer] buffer size : ".strlen($this->buffer)."bytes \n";	314	echo "[NTLMStream::createBuffer] buffer size : ".strlen($this->buffer)."bytes \n";
311	$this->pos = 0;	315	$this->pos = 0;
312	/*$myfile = "/tmp/debugex.txt";	316	/*$myfile = "/tmp/debugex.txt";
313	$fh = fopen($myfile, 'w+') or die("can't open file");	317	$fh = fopen($myfile, 'w+') or die("can't open file");
314	fwrite($fh, "user: ". $this->user. " pass: ".$this->pass."\n");	318	fwrite($fh, "user: ". $this->user. " pass: ".$this->pass."\n");
315	fwrite($fh, "req: ". $request ."loc: ". $location ." act: ". $action ." ver: ". $version."\n");	319	fwrite($fh, "req: ". $request ."loc: ". $location ." act: ". $action ." ver: ". $version."\n");
316	fwrite($fh, "reponse: ". $response."\n\n");	320	fwrite($fh, "reponse: ". $response."\n\n");
317	fclose($fh);	321	fclose($fh);
318	*/	322	*/
319	}	323	}
320	}	324	}
321		325
322	?>	326	?>
323		327

Subversion Repositories HomeAutomation

(root)/trunk/PcSoftware/scripts/exchangeIntegration/exchange.php – Rev 1165 → 1169