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