xref: /PHP-5.4/ext/com_dotnet/com_persist.c (revision c0d060f5)
1 /*
2    +----------------------------------------------------------------------+
3    | PHP Version 5                                                        |
4    +----------------------------------------------------------------------+
5    | Copyright (c) 1997-2014 The PHP Group                                |
6    +----------------------------------------------------------------------+
7    | This source file is subject to version 3.01 of the PHP license,      |
8    | that is bundled with this package in the file LICENSE, and is        |
9    | available through the world-wide-web at the following url:           |
10    | http://www.php.net/license/3_01.txt                                  |
11    | If you did not receive a copy of the PHP license and are unable to   |
12    | obtain it through the world-wide-web, please send a note to          |
13    | license@php.net so we can mail you a copy immediately.               |
14    +----------------------------------------------------------------------+
15    | Author: Wez Furlong  <wez@thebrainroom.com>                          |
16    +----------------------------------------------------------------------+
17  */
18 
19 /* $Id$ */
20 
21 /* Infrastructure for working with persistent COM objects.
22  * Implements: IStream* wrapper for PHP streams.
23  * TODO: Magic __wakeup and __sleep handlers for serialization
24  * (can wait till 5.1) */
25 
26 #ifdef HAVE_CONFIG_H
27 #include "config.h"
28 #endif
29 
30 #include "php.h"
31 #include "php_ini.h"
32 #include "ext/standard/info.h"
33 #include "php_com_dotnet.h"
34 #include "php_com_dotnet_internal.h"
35 #include "Zend/zend_exceptions.h"
36 
37 /* {{{ expose php_stream as a COM IStream */
38 
39 typedef struct {
40 	CONST_VTBL struct IStreamVtbl *lpVtbl;
41 	DWORD engine_thread;
42 	LONG refcount;
43 	php_stream *stream;
44 	int id;
45 } php_istream;
46 
47 static int le_istream;
48 static void istream_destructor(php_istream *stm TSRMLS_DC);
49 
istream_dtor(zend_rsrc_list_entry * rsrc TSRMLS_DC)50 static void istream_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC)
51 {
52 	php_istream *stm = (php_istream *)rsrc->ptr;
53 	istream_destructor(stm TSRMLS_CC);
54 }
55 
56 #define FETCH_STM()	\
57 	php_istream *stm = (php_istream*)This; \
58 	TSRMLS_FETCH(); \
59 	if (GetCurrentThreadId() != stm->engine_thread) \
60 		return RPC_E_WRONG_THREAD;
61 
62 #define FETCH_STM_EX()	\
63 	php_istream *stm = (php_istream*)This;	\
64 	if (GetCurrentThreadId() != stm->engine_thread)	\
65 		return RPC_E_WRONG_THREAD;
66 
stm_queryinterface(IStream * This,REFIID riid,void ** ppvObject)67 static HRESULT STDMETHODCALLTYPE stm_queryinterface(
68 	IStream *This,
69 	/* [in] */ REFIID riid,
70 	/* [iid_is][out] */ void **ppvObject)
71 {
72 	FETCH_STM_EX();
73 
74 	if (IsEqualGUID(&IID_IUnknown, riid) ||
75 			IsEqualGUID(&IID_IStream, riid)) {
76 		*ppvObject = This;
77 		InterlockedIncrement(&stm->refcount);
78 		return S_OK;
79 	}
80 
81 	*ppvObject = NULL;
82 	return E_NOINTERFACE;
83 }
84 
stm_addref(IStream * This)85 static ULONG STDMETHODCALLTYPE stm_addref(IStream *This)
86 {
87 	FETCH_STM_EX();
88 
89 	return InterlockedIncrement(&stm->refcount);
90 }
91 
stm_release(IStream * This)92 static ULONG STDMETHODCALLTYPE stm_release(IStream *This)
93 {
94 	ULONG ret;
95 	FETCH_STM();
96 
97 	ret = InterlockedDecrement(&stm->refcount);
98 	if (ret == 0) {
99 		/* destroy it */
100 		if (stm->id)
101 			zend_list_delete(stm->id);
102 	}
103 	return ret;
104 }
105 
stm_read(IStream * This,void * pv,ULONG cb,ULONG * pcbRead)106 static HRESULT STDMETHODCALLTYPE stm_read(IStream *This, void *pv, ULONG cb, ULONG *pcbRead)
107 {
108 	int nread;
109 	FETCH_STM();
110 
111 	nread = php_stream_read(stm->stream, pv, cb);
112 
113 	if (pcbRead) {
114 		*pcbRead = nread > 0 ? nread : 0;
115 	}
116 	if (nread > 0) {
117 		return S_OK;
118 	}
119 	return S_FALSE;
120 }
121 
stm_write(IStream * This,void const * pv,ULONG cb,ULONG * pcbWritten)122 static HRESULT STDMETHODCALLTYPE stm_write(IStream *This, void const *pv, ULONG cb, ULONG *pcbWritten)
123 {
124 	int nwrote;
125 	FETCH_STM();
126 
127 	nwrote = php_stream_write(stm->stream, pv, cb);
128 
129 	if (pcbWritten) {
130 		*pcbWritten = nwrote > 0 ? nwrote : 0;
131 	}
132 	if (nwrote > 0) {
133 		return S_OK;
134 	}
135 	return S_FALSE;
136 }
137 
stm_seek(IStream * This,LARGE_INTEGER dlibMove,DWORD dwOrigin,ULARGE_INTEGER * plibNewPosition)138 static HRESULT STDMETHODCALLTYPE stm_seek(IStream *This, LARGE_INTEGER dlibMove,
139 		DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
140 {
141 	off_t offset;
142 	int whence;
143 	int ret;
144 	FETCH_STM();
145 
146 	switch (dwOrigin) {
147 		case STREAM_SEEK_SET:	whence = SEEK_SET;	break;
148 		case STREAM_SEEK_CUR:	whence = SEEK_CUR;	break;
149 		case STREAM_SEEK_END:	whence = SEEK_END;	break;
150 		default:
151 			return STG_E_INVALIDFUNCTION;
152 	}
153 
154 	if (dlibMove.HighPart) {
155 		/* we don't support 64-bit offsets */
156 		return STG_E_INVALIDFUNCTION;
157 	}
158 
159 	offset = (off_t) dlibMove.QuadPart;
160 
161 	ret = php_stream_seek(stm->stream, offset, whence);
162 
163 	if (plibNewPosition) {
164 		plibNewPosition->QuadPart = (ULONGLONG)(ret >= 0 ? ret : 0);
165 	}
166 
167 	return ret >= 0 ? S_OK : STG_E_INVALIDFUNCTION;
168 }
169 
stm_set_size(IStream * This,ULARGE_INTEGER libNewSize)170 static HRESULT STDMETHODCALLTYPE stm_set_size(IStream *This, ULARGE_INTEGER libNewSize)
171 {
172 	FETCH_STM();
173 
174 	if (libNewSize.HighPart) {
175 		return STG_E_INVALIDFUNCTION;
176 	}
177 
178 	if (php_stream_truncate_supported(stm->stream)) {
179 		int ret = php_stream_truncate_set_size(stm->stream, (size_t)libNewSize.QuadPart);
180 
181 		if (ret == 0) {
182 			return S_OK;
183 		}
184 	}
185 
186 	return STG_E_INVALIDFUNCTION;
187 }
188 
stm_copy_to(IStream * This,IStream * pstm,ULARGE_INTEGER cb,ULARGE_INTEGER * pcbRead,ULARGE_INTEGER * pcbWritten)189 static HRESULT STDMETHODCALLTYPE stm_copy_to(IStream *This, IStream *pstm, ULARGE_INTEGER cb,
190 		ULARGE_INTEGER *pcbRead, ULARGE_INTEGER *pcbWritten)
191 {
192 	FETCH_STM_EX();
193 
194 	return E_NOTIMPL;
195 }
196 
stm_commit(IStream * This,DWORD grfCommitFlags)197 static HRESULT STDMETHODCALLTYPE stm_commit(IStream *This, DWORD grfCommitFlags)
198 {
199 	FETCH_STM();
200 
201 	php_stream_flush(stm->stream);
202 
203 	return S_OK;
204 }
205 
stm_revert(IStream * This)206 static HRESULT STDMETHODCALLTYPE stm_revert(IStream *This)
207 {
208 	/* NOP */
209 	return S_OK;
210 }
211 
stm_lock_region(IStream * This,ULARGE_INTEGER libOffset,ULARGE_INTEGER cb,DWORD lockType)212 static HRESULT STDMETHODCALLTYPE stm_lock_region(IStream *This,
213    	ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD lockType)
214 {
215 	return STG_E_INVALIDFUNCTION;
216 }
217 
stm_unlock_region(IStream * This,ULARGE_INTEGER libOffset,ULARGE_INTEGER cb,DWORD lockType)218 static HRESULT STDMETHODCALLTYPE stm_unlock_region(IStream *This,
219 		ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD lockType)
220 {
221 	return STG_E_INVALIDFUNCTION;
222 }
223 
stm_stat(IStream * This,STATSTG * pstatstg,DWORD grfStatFlag)224 static HRESULT STDMETHODCALLTYPE stm_stat(IStream *This,
225 		STATSTG *pstatstg, DWORD grfStatFlag)
226 {
227 	return STG_E_INVALIDFUNCTION;
228 }
229 
stm_clone(IStream * This,IStream ** ppstm)230 static HRESULT STDMETHODCALLTYPE stm_clone(IStream *This, IStream **ppstm)
231 {
232 	return STG_E_INVALIDFUNCTION;
233 }
234 
235 static struct IStreamVtbl php_istream_vtbl = {
236 	stm_queryinterface,
237 	stm_addref,
238 	stm_release,
239 	stm_read,
240 	stm_write,
241 	stm_seek,
242 	stm_set_size,
243 	stm_copy_to,
244 	stm_commit,
245 	stm_revert,
246 	stm_lock_region,
247 	stm_unlock_region,
248 	stm_stat,
249 	stm_clone
250 };
251 
istream_destructor(php_istream * stm TSRMLS_DC)252 static void istream_destructor(php_istream *stm TSRMLS_DC)
253 {
254 	if (stm->id) {
255 		int id = stm->id;
256 		stm->id = 0;
257 		zend_list_delete(id);
258 		return;
259 	}
260 
261 	if (stm->refcount > 0) {
262 		CoDisconnectObject((IUnknown*)stm, 0);
263 	}
264 
265 	zend_list_delete(stm->stream->rsrc_id);
266 
267 	CoTaskMemFree(stm);
268 }
269 /* }}} */
270 
php_com_wrapper_export_stream(php_stream * stream TSRMLS_DC)271 PHP_COM_DOTNET_API IStream *php_com_wrapper_export_stream(php_stream *stream TSRMLS_DC)
272 {
273 	php_istream *stm = (php_istream*)CoTaskMemAlloc(sizeof(*stm));
274 
275 	if (stm == NULL)
276 		return NULL;
277 
278 	memset(stm, 0, sizeof(*stm));
279 	stm->engine_thread = GetCurrentThreadId();
280 	stm->lpVtbl = &php_istream_vtbl;
281 	stm->refcount = 1;
282 	stm->stream = stream;
283 
284 	zend_list_addref(stream->rsrc_id);
285 	stm->id = zend_list_insert(stm, le_istream TSRMLS_CC);
286 
287 	return (IStream*)stm;
288 }
289 
290 #define CPH_ME(fname, arginfo)	PHP_ME(com_persist, fname, arginfo, ZEND_ACC_PUBLIC)
291 #define CPH_SME(fname, arginfo)	PHP_ME(com_persist, fname, arginfo, ZEND_ACC_ALLOW_STATIC|ZEND_ACC_PUBLIC)
292 #define CPH_METHOD(fname)		static PHP_METHOD(com_persist, fname)
293 
294 #define CPH_FETCH()				php_com_persist_helper *helper = (php_com_persist_helper*)zend_object_store_get_object(getThis() TSRMLS_CC);
295 
296 #define CPH_NO_OBJ()			if (helper->unk == NULL) { php_com_throw_exception(E_INVALIDARG, "No COM object is associated with this helper instance" TSRMLS_CC); return; }
297 
298 typedef struct {
299 	zend_object			std;
300 	long codepage;
301 	IUnknown 			*unk;
302 	IPersistStream 		*ips;
303 	IPersistStreamInit	*ipsi;
304 	IPersistFile		*ipf;
305 } php_com_persist_helper;
306 
307 static zend_object_handlers helper_handlers;
308 static zend_class_entry *helper_ce;
309 
get_persist_stream(php_com_persist_helper * helper)310 static inline HRESULT get_persist_stream(php_com_persist_helper *helper)
311 {
312 	if (!helper->ips && helper->unk) {
313 		return IUnknown_QueryInterface(helper->unk, &IID_IPersistStream, &helper->ips);
314 	}
315 	return helper->ips ? S_OK : E_NOTIMPL;
316 }
317 
get_persist_stream_init(php_com_persist_helper * helper)318 static inline HRESULT get_persist_stream_init(php_com_persist_helper *helper)
319 {
320 	if (!helper->ipsi && helper->unk) {
321 		return IUnknown_QueryInterface(helper->unk, &IID_IPersistStreamInit, &helper->ipsi);
322 	}
323 	return helper->ipsi ? S_OK : E_NOTIMPL;
324 }
325 
get_persist_file(php_com_persist_helper * helper)326 static inline HRESULT get_persist_file(php_com_persist_helper *helper)
327 {
328 	if (!helper->ipf && helper->unk) {
329 		return IUnknown_QueryInterface(helper->unk, &IID_IPersistFile, &helper->ipf);
330 	}
331 	return helper->ipf ? S_OK : E_NOTIMPL;
332 }
333 
334 
335 /* {{{ proto string COMPersistHelper::GetCurFile()
336    Determines the filename into which an object will be saved, or false if none is set, via IPersistFile::GetCurFile */
CPH_METHOD(GetCurFileName)337 CPH_METHOD(GetCurFileName)
338 {
339 	HRESULT res;
340 	OLECHAR *olename = NULL;
341 	CPH_FETCH();
342 
343 	CPH_NO_OBJ();
344 
345 	res = get_persist_file(helper);
346 	if (helper->ipf) {
347 		res = IPersistFile_GetCurFile(helper->ipf, &olename);
348 
349 		if (res == S_OK) {
350 			Z_TYPE_P(return_value) = IS_STRING;
351 			Z_STRVAL_P(return_value) = php_com_olestring_to_string(olename,
352 				   &Z_STRLEN_P(return_value), helper->codepage TSRMLS_CC);
353 			CoTaskMemFree(olename);
354 			return;
355 		} else if (res == S_FALSE) {
356 			CoTaskMemFree(olename);
357 			RETURN_FALSE;
358 		}
359 		php_com_throw_exception(res, NULL TSRMLS_CC);
360 	} else {
361 		php_com_throw_exception(res, NULL TSRMLS_CC);
362 	}
363 }
364 /* }}} */
365 
366 
367 /* {{{ proto bool COMPersistHelper::SaveToFile(string filename [, bool remember])
368    Persist object data to file, via IPersistFile::Save */
CPH_METHOD(SaveToFile)369 CPH_METHOD(SaveToFile)
370 {
371 	HRESULT res;
372 	char *filename, *fullpath = NULL;
373 	int filename_len;
374 	zend_bool remember = TRUE;
375 	OLECHAR *olefilename = NULL;
376 	CPH_FETCH();
377 
378 	CPH_NO_OBJ();
379 
380 	res = get_persist_file(helper);
381 	if (helper->ipf) {
382 		if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "p!|b",
383 					&filename, &filename_len, &remember)) {
384 			php_com_throw_exception(E_INVALIDARG, "Invalid arguments" TSRMLS_CC);
385 			return;
386 		}
387 
388 		if (filename) {
389 			fullpath = expand_filepath(filename, NULL TSRMLS_CC);
390 			if (!fullpath) {
391 				RETURN_FALSE;
392 			}
393 
394 			if (php_check_open_basedir(fullpath TSRMLS_CC)) {
395 				efree(fullpath);
396 				RETURN_FALSE;
397 			}
398 
399 			olefilename = php_com_string_to_olestring(filename, strlen(fullpath), helper->codepage TSRMLS_CC);
400 			efree(fullpath);
401 		}
402 		res = IPersistFile_Save(helper->ipf, olefilename, remember);
403 		if (SUCCEEDED(res)) {
404 			if (!olefilename) {
405 				res = IPersistFile_GetCurFile(helper->ipf, &olefilename);
406 				if (S_OK == res) {
407 					IPersistFile_SaveCompleted(helper->ipf, olefilename);
408 					CoTaskMemFree(olefilename);
409 					olefilename = NULL;
410 				}
411 			} else if (remember) {
412 				IPersistFile_SaveCompleted(helper->ipf, olefilename);
413 			}
414 		}
415 
416 		if (olefilename) {
417 			efree(olefilename);
418 		}
419 
420 		if (FAILED(res)) {
421 			php_com_throw_exception(res, NULL TSRMLS_CC);
422 		}
423 
424 	} else {
425 		php_com_throw_exception(res, NULL TSRMLS_CC);
426 	}
427 }
428 /* }}} */
429 
430 /* {{{ proto bool COMPersistHelper::LoadFromFile(string filename [, int flags])
431    Load object data from file, via IPersistFile::Load */
CPH_METHOD(LoadFromFile)432 CPH_METHOD(LoadFromFile)
433 {
434 	HRESULT res;
435 	char *filename, *fullpath;
436 	int filename_len;
437 	long flags = 0;
438 	OLECHAR *olefilename;
439 	CPH_FETCH();
440 
441 	CPH_NO_OBJ();
442 
443 	res = get_persist_file(helper);
444 	if (helper->ipf) {
445 
446 		if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "p|l",
447 					&filename, &filename_len, &flags)) {
448 			php_com_throw_exception(E_INVALIDARG, "Invalid arguments" TSRMLS_CC);
449 			return;
450 		}
451 
452 		if (!(fullpath = expand_filepath(filename, NULL TSRMLS_CC))) {
453 			RETURN_FALSE;
454 		}
455 
456 		if (php_check_open_basedir(fullpath TSRMLS_CC)) {
457 			efree(fullpath);
458 			RETURN_FALSE;
459 		}
460 
461 		olefilename = php_com_string_to_olestring(fullpath, strlen(fullpath), helper->codepage TSRMLS_CC);
462 		efree(fullpath);
463 
464 		res = IPersistFile_Load(helper->ipf, olefilename, flags);
465 		efree(olefilename);
466 
467 		if (FAILED(res)) {
468 			php_com_throw_exception(res, NULL TSRMLS_CC);
469 		}
470 
471 	} else {
472 		php_com_throw_exception(res, NULL TSRMLS_CC);
473 	}
474 }
475 /* }}} */
476 
477 /* {{{ proto int COMPersistHelper::GetMaxStreamSize()
478    Gets maximum stream size required to store the object data, via IPersistStream::GetSizeMax (or IPersistStreamInit::GetSizeMax) */
CPH_METHOD(GetMaxStreamSize)479 CPH_METHOD(GetMaxStreamSize)
480 {
481 	HRESULT res;
482 	ULARGE_INTEGER size;
483 	CPH_FETCH();
484 
485 	CPH_NO_OBJ();
486 
487 	res = get_persist_stream_init(helper);
488 	if (helper->ipsi) {
489 		res = IPersistStreamInit_GetSizeMax(helper->ipsi, &size);
490 	} else {
491 		res = get_persist_stream(helper);
492 		if (helper->ips) {
493 			res = IPersistStream_GetSizeMax(helper->ips, &size);
494 		} else {
495 			php_com_throw_exception(res, NULL TSRMLS_CC);
496 			return;
497 		}
498 	}
499 
500 	if (res != S_OK) {
501 		php_com_throw_exception(res, NULL TSRMLS_CC);
502 	} else {
503 		/* TODO: handle 64 bit properly */
504 		RETURN_LONG((LONG)size.QuadPart);
505 	}
506 }
507 /* }}} */
508 
509 /* {{{ proto int COMPersistHelper::InitNew()
510    Initializes the object to a default state, via IPersistStreamInit::InitNew */
CPH_METHOD(InitNew)511 CPH_METHOD(InitNew)
512 {
513 	HRESULT res;
514 	CPH_FETCH();
515 
516 	CPH_NO_OBJ();
517 
518 	res = get_persist_stream_init(helper);
519 	if (helper->ipsi) {
520 		res = IPersistStreamInit_InitNew(helper->ipsi);
521 
522 		if (res != S_OK) {
523 			php_com_throw_exception(res, NULL TSRMLS_CC);
524 		} else {
525 			RETURN_TRUE;
526 		}
527 	} else {
528 		php_com_throw_exception(res, NULL TSRMLS_CC);
529 	}
530 }
531 /* }}} */
532 
533 /* {{{ proto mixed COMPersistHelper::LoadFromStream(resource stream)
534    Initializes an object from the stream where it was previously saved, via IPersistStream::Load or OleLoadFromStream */
CPH_METHOD(LoadFromStream)535 CPH_METHOD(LoadFromStream)
536 {
537 	zval *zstm;
538 	php_stream *stream;
539 	IStream *stm = NULL;
540 	HRESULT res;
541 	CPH_FETCH();
542 
543 	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zstm)) {
544 		php_com_throw_exception(E_INVALIDARG, "invalid arguments" TSRMLS_CC);
545 		return;
546 	}
547 
548 	php_stream_from_zval_no_verify(stream, &zstm);
549 
550 	if (stream == NULL) {
551 		php_com_throw_exception(E_INVALIDARG, "expected a stream" TSRMLS_CC);
552 		return;
553 	}
554 
555 	stm = php_com_wrapper_export_stream(stream TSRMLS_CC);
556 	if (stm == NULL) {
557 		php_com_throw_exception(E_UNEXPECTED, "failed to wrap stream" TSRMLS_CC);
558 		return;
559 	}
560 
561 	res = S_OK;
562 	RETVAL_TRUE;
563 
564 	if (helper->unk == NULL) {
565 		IDispatch *disp = NULL;
566 
567 		/* we need to create an object and load using OleLoadFromStream */
568 		res = OleLoadFromStream(stm, &IID_IDispatch, &disp);
569 
570 		if (SUCCEEDED(res)) {
571 			php_com_wrap_dispatch(return_value, disp, COMG(code_page) TSRMLS_CC);
572 		}
573 	} else {
574 		res = get_persist_stream_init(helper);
575 		if (helper->ipsi) {
576 			res = IPersistStreamInit_Load(helper->ipsi, stm);
577 		} else {
578 			res = get_persist_stream(helper);
579 			if (helper->ips) {
580 				res = IPersistStreamInit_Load(helper->ipsi, stm);
581 			}
582 		}
583 	}
584 	IStream_Release(stm);
585 
586 	if (FAILED(res)) {
587 		php_com_throw_exception(res, NULL TSRMLS_CC);
588 		RETURN_NULL();
589 	}
590 }
591 /* }}} */
592 
593 /* {{{ proto int COMPersistHelper::SaveToStream(resource stream)
594    Saves the object to a stream, via IPersistStream::Save */
CPH_METHOD(SaveToStream)595 CPH_METHOD(SaveToStream)
596 {
597 	zval *zstm;
598 	php_stream *stream;
599 	IStream *stm = NULL;
600 	HRESULT res;
601 	CPH_FETCH();
602 
603 	CPH_NO_OBJ();
604 
605 	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zstm)) {
606 		php_com_throw_exception(E_INVALIDARG, "invalid arguments" TSRMLS_CC);
607 		return;
608 	}
609 
610 	php_stream_from_zval_no_verify(stream, &zstm);
611 
612 	if (stream == NULL) {
613 		php_com_throw_exception(E_INVALIDARG, "expected a stream" TSRMLS_CC);
614 		return;
615 	}
616 
617 	stm = php_com_wrapper_export_stream(stream TSRMLS_CC);
618 	if (stm == NULL) {
619 		php_com_throw_exception(E_UNEXPECTED, "failed to wrap stream" TSRMLS_CC);
620 		return;
621 	}
622 
623 	res = get_persist_stream_init(helper);
624 	if (helper->ipsi) {
625 		res = IPersistStreamInit_Save(helper->ipsi, stm, TRUE);
626 	} else {
627 		res = get_persist_stream(helper);
628 		if (helper->ips) {
629 			res = IPersistStream_Save(helper->ips, stm, TRUE);
630 		}
631 	}
632 
633 	IStream_Release(stm);
634 
635 	if (FAILED(res)) {
636 		php_com_throw_exception(res, NULL TSRMLS_CC);
637 		return;
638 	}
639 
640 	RETURN_TRUE;
641 }
642 /* }}} */
643 
644 /* {{{ proto int COMPersistHelper::__construct([object com_object])
645    Creates a persistence helper object, usually associated with a com_object */
CPH_METHOD(__construct)646 CPH_METHOD(__construct)
647 {
648 	php_com_dotnet_object *obj = NULL;
649 	zval *zobj = NULL;
650 	CPH_FETCH();
651 
652 	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|O!",
653 				&zobj, php_com_variant_class_entry)) {
654 		php_com_throw_exception(E_INVALIDARG, "invalid arguments" TSRMLS_CC);
655 		return;
656 	}
657 
658 	if (!zobj) {
659 		return;
660 	}
661 
662 	obj = CDNO_FETCH(zobj);
663 
664 	if (V_VT(&obj->v) != VT_DISPATCH || V_DISPATCH(&obj->v) == NULL) {
665 		php_com_throw_exception(E_INVALIDARG, "parameter must represent an IDispatch COM object" TSRMLS_CC);
666 		return;
667 	}
668 
669 	/* it is always safe to cast an interface to IUnknown */
670 	helper->unk = (IUnknown*)V_DISPATCH(&obj->v);
671 	IUnknown_AddRef(helper->unk);
672 	helper->codepage = obj->code_page;
673 }
674 /* }}} */
675 
676 
677 
678 
679 static const zend_function_entry com_persist_helper_methods[] = {
680 	CPH_ME(__construct, NULL)
681 	CPH_ME(GetCurFileName, NULL)
682 	CPH_ME(SaveToFile, NULL)
683 	CPH_ME(LoadFromFile, NULL)
684 	CPH_ME(GetMaxStreamSize, NULL)
685 	CPH_ME(InitNew, NULL)
686 	CPH_ME(LoadFromStream, NULL)
687 	CPH_ME(SaveToStream, NULL)
688 	PHP_FE_END
689 };
690 
helper_free_storage(void * obj TSRMLS_DC)691 static void helper_free_storage(void *obj TSRMLS_DC)
692 {
693 	php_com_persist_helper *object = (php_com_persist_helper*)obj;
694 
695 	if (object->ipf) {
696 		IPersistFile_Release(object->ipf);
697 	}
698 	if (object->ips) {
699 		IPersistStream_Release(object->ips);
700 	}
701 	if (object->ipsi) {
702 		IPersistStreamInit_Release(object->ipsi);
703 	}
704 	if (object->unk) {
705 		IUnknown_Release(object->unk);
706 	}
707 	zend_object_std_dtor(&object->std TSRMLS_CC);
708 	efree(object);
709 }
710 
711 
helper_clone(void * obj,void ** clone_ptr TSRMLS_DC)712 static void helper_clone(void *obj, void **clone_ptr TSRMLS_DC)
713 {
714 	php_com_persist_helper *clone, *object = (php_com_persist_helper*)obj;
715 
716 	clone = emalloc(sizeof(*object));
717 	memcpy(clone, object, sizeof(*object));
718 	*clone_ptr = clone;
719 
720 	zend_object_std_init(&clone->std, object->std.ce TSRMLS_CC);
721 
722 	if (clone->ipf) {
723 		IPersistFile_AddRef(clone->ipf);
724 	}
725 	if (clone->ips) {
726 		IPersistStream_AddRef(clone->ips);
727 	}
728 	if (clone->ipsi) {
729 		IPersistStreamInit_AddRef(clone->ipsi);
730 	}
731 	if (clone->unk) {
732 		IUnknown_AddRef(clone->unk);
733 	}
734 }
735 
helper_new(zend_class_entry * ce TSRMLS_DC)736 static zend_object_value helper_new(zend_class_entry *ce TSRMLS_DC)
737 {
738 	php_com_persist_helper *helper;
739 	zend_object_value retval;
740 
741 	helper = emalloc(sizeof(*helper));
742 	memset(helper, 0, sizeof(*helper));
743 
744 	zend_object_std_init(&helper->std, helper_ce TSRMLS_CC);
745 
746 	retval.handle = zend_objects_store_put(helper, NULL, helper_free_storage, helper_clone TSRMLS_CC);
747 	retval.handlers = &helper_handlers;
748 
749 	return retval;
750 }
751 
php_com_persist_minit(INIT_FUNC_ARGS)752 int php_com_persist_minit(INIT_FUNC_ARGS)
753 {
754 	zend_class_entry ce;
755 
756 	memcpy(&helper_handlers, zend_get_std_object_handlers(), sizeof(helper_handlers));
757 	helper_handlers.clone_obj = NULL;
758 
759 	INIT_CLASS_ENTRY(ce, "COMPersistHelper", com_persist_helper_methods);
760 	ce.create_object = helper_new;
761 	helper_ce = zend_register_internal_class(&ce TSRMLS_CC);
762 	helper_ce->ce_flags |= ZEND_ACC_FINAL;
763 
764 	le_istream = zend_register_list_destructors_ex(istream_dtor,
765 			NULL, "com_dotnet_istream_wrapper", module_number);
766 
767 	return SUCCESS;
768 }
769 
770 /*
771  * Local variables:
772  * tab-width: 4
773  * c-basic-offset: 4
774  * End:
775  * vim600: noet sw=4 ts=4 fdm=marker
776  * vim<600: noet sw=4 ts=4
777  */
778