Annotation of embedaddon/php/ext/imap/php_imap.c, revision 1.1.1.1
1.1 misho 1: /*
2: +----------------------------------------------------------------------+
3: | PHP Version 5 |
4: +----------------------------------------------------------------------+
5: | Copyright (c) 1997-2012 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: | Authors: Rex Logan <veebert@dimensional.com> |
16: | Mark Musone <musone@afterfive.com> |
17: | Brian Wang <brian@vividnet.com> |
18: | Kaj-Michael Lang <milang@tal.org> |
19: | Antoni Pamies Olive <toni@readysoft.net> |
20: | Rasmus Lerdorf <rasmus@php.net> |
21: | Chuck Hagenbuch <chuck@horde.org> |
22: | Andrew Skalski <askalski@chekinc.com> |
23: | Hartmut Holzgraefe <hholzgra@php.net> |
24: | Jani Taskinen <jani.taskinen@iki.fi> |
25: | Daniel R. Kalowsky <kalowsky@php.net> |
26: | PHP 4.0 updates: Zeev Suraski <zeev@zend.com> |
27: +----------------------------------------------------------------------+
28: */
29: /* $Id: php_imap.c 321634 2012-01-01 13:15:04Z felipe $ */
30:
31: #define IMAP41
32:
33: #ifdef HAVE_CONFIG_H
34: #include "config.h"
35: #endif
36:
37: #include "php.h"
38: #include "php_ini.h"
39: #include "php_streams.h"
40: #include "ext/standard/php_string.h"
41: #include "ext/standard/info.h"
42: #include "ext/standard/file.h"
43: #include "ext/standard/php_smart_str.h"
44: #include "ext/pcre/php_pcre.h"
45:
46: #ifdef ERROR
47: #undef ERROR
48: #endif
49: #include "php_imap.h"
50:
51: #include <time.h>
52: #include <stdio.h>
53: #include <ctype.h>
54: #include <signal.h>
55:
56: #ifdef PHP_WIN32
57: #include <winsock2.h>
58: #include <stdlib.h>
59: #include "win32/sendmail.h"
60: MAILSTREAM DEFAULTPROTO;
61: #endif
62:
63: #define CRLF "\015\012"
64: #define CRLF_LEN sizeof("\015\012") - 1
65: #define PHP_EXPUNGE 32768
66: #define PHP_IMAP_ADDRESS_SIZE_BUF 10
67: #ifndef SENDBUFLEN
68: #define SENDBUFLEN 16385
69: #endif
70:
71: #if defined(__GNUC__) && __GNUC__ >= 4
72: # define PHP_IMAP_EXPORT __attribute__ ((visibility("default")))
73: #else
74: # define PHP_IMAP_EXPORT
75: #endif
76:
77: static void _php_make_header_object(zval *myzvalue, ENVELOPE *en TSRMLS_DC);
78: static void _php_imap_add_body(zval *arg, BODY *body TSRMLS_DC);
79: static char* _php_imap_parse_address(ADDRESS *addresslist, zval *paddress TSRMLS_DC);
80: static char* _php_rfc822_write_address(ADDRESS *addresslist TSRMLS_DC);
81:
82: /* the gets we use */
83: static char *php_mail_gets(readfn_t f, void *stream, unsigned long size, GETS_DATA *md);
84:
85: /* These function declarations are missing from the IMAP header files... */
86: void rfc822_date(char *date);
87: char *cpystr(const char *str);
88: char *cpytxt(SIZEDTEXT *dst, char *text, unsigned long size);
89: #ifndef HAVE_NEW_MIME2TEXT
90: long utf8_mime2text(SIZEDTEXT *src, SIZEDTEXT *dst);
91: #else
92: long utf8_mime2text (SIZEDTEXT *src, SIZEDTEXT *dst, long flags);
93: #endif
94: unsigned long find_rightmost_bit(unsigned long *valptr);
95: void fs_give(void **block);
96: void *fs_get(size_t size);
97:
98: ZEND_DECLARE_MODULE_GLOBALS(imap)
99: static PHP_GINIT_FUNCTION(imap);
100:
101: /* {{{ arginfo */
102: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_open, 0, 0, 3)
103: ZEND_ARG_INFO(0, mailbox)
104: ZEND_ARG_INFO(0, user)
105: ZEND_ARG_INFO(0, password)
106: ZEND_ARG_INFO(0, options)
107: ZEND_ARG_INFO(0, n_retries)
108: ZEND_ARG_INFO(0, params)
109: ZEND_END_ARG_INFO()
110:
111: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_reopen, 0, 0, 2)
112: ZEND_ARG_INFO(0, stream_id)
113: ZEND_ARG_INFO(0, mailbox)
114: ZEND_ARG_INFO(0, options)
115: ZEND_ARG_INFO(0, n_retries)
116: ZEND_END_ARG_INFO()
117:
118: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_append, 0, 0, 3)
119: ZEND_ARG_INFO(0, stream_id)
120: ZEND_ARG_INFO(0, folder)
121: ZEND_ARG_INFO(0, message)
122: ZEND_ARG_INFO(0, options)
123: ZEND_ARG_INFO(0, date)
124: ZEND_END_ARG_INFO()
125:
126: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_num_msg, 0, 0, 1)
127: ZEND_ARG_INFO(0, stream_id)
128: ZEND_END_ARG_INFO()
129:
130: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_ping, 0, 0, 1)
131: ZEND_ARG_INFO(0, stream_id)
132: ZEND_END_ARG_INFO()
133:
134: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_num_recent, 0, 0, 1)
135: ZEND_ARG_INFO(0, stream_id)
136: ZEND_END_ARG_INFO()
137:
138: #if defined(HAVE_IMAP2000) || defined(HAVE_IMAP2001)
139: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_get_quota, 0, 0, 2)
140: ZEND_ARG_INFO(0, stream_id)
141: ZEND_ARG_INFO(0, qroot)
142: ZEND_END_ARG_INFO()
143:
144: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_get_quotaroot, 0, 0, 2)
145: ZEND_ARG_INFO(0, stream_id)
146: ZEND_ARG_INFO(0, mbox)
147: ZEND_END_ARG_INFO()
148:
149: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_set_quota, 0, 0, 3)
150: ZEND_ARG_INFO(0, stream_id)
151: ZEND_ARG_INFO(0, qroot)
152: ZEND_ARG_INFO(0, mailbox_size)
153: ZEND_END_ARG_INFO()
154:
155: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_setacl, 0, 0, 4)
156: ZEND_ARG_INFO(0, stream_id)
157: ZEND_ARG_INFO(0, mailbox)
158: ZEND_ARG_INFO(0, id)
159: ZEND_ARG_INFO(0, rights)
160: ZEND_END_ARG_INFO()
161:
162: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_getacl, 0, 0, 2)
163: ZEND_ARG_INFO(0, stream_id)
164: ZEND_ARG_INFO(0, mailbox)
165: ZEND_END_ARG_INFO()
166: #endif
167:
168: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_expunge, 0, 0, 1)
169: ZEND_ARG_INFO(0, stream_id)
170: ZEND_END_ARG_INFO()
171:
172: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_gc, 0, 0, 1)
173: ZEND_ARG_INFO(0, stream_id)
174: ZEND_ARG_INFO(0, flags)
175: ZEND_END_ARG_INFO()
176:
177: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_close, 0, 0, 1)
178: ZEND_ARG_INFO(0, stream_id)
179: ZEND_ARG_INFO(0, options)
180: ZEND_END_ARG_INFO()
181:
182: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_headers, 0, 0, 1)
183: ZEND_ARG_INFO(0, stream_id)
184: ZEND_END_ARG_INFO()
185:
186: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_body, 0, 0, 2)
187: ZEND_ARG_INFO(0, stream_id)
188: ZEND_ARG_INFO(0, msg_no)
189: ZEND_ARG_INFO(0, options)
190: ZEND_END_ARG_INFO()
191:
192: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_mail_copy, 0, 0, 3)
193: ZEND_ARG_INFO(0, stream_id)
194: ZEND_ARG_INFO(0, msglist)
195: ZEND_ARG_INFO(0, mailbox)
196: ZEND_ARG_INFO(0, options)
197: ZEND_END_ARG_INFO()
198:
199: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_mail_move, 0, 0, 3)
200: ZEND_ARG_INFO(0, stream_id)
201: ZEND_ARG_INFO(0, sequence)
202: ZEND_ARG_INFO(0, mailbox)
203: ZEND_ARG_INFO(0, options)
204: ZEND_END_ARG_INFO()
205:
206: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_createmailbox, 0, 0, 2)
207: ZEND_ARG_INFO(0, stream_id)
208: ZEND_ARG_INFO(0, mailbox)
209: ZEND_END_ARG_INFO()
210:
211: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_renamemailbox, 0, 0, 3)
212: ZEND_ARG_INFO(0, stream_id)
213: ZEND_ARG_INFO(0, old_name)
214: ZEND_ARG_INFO(0, new_name)
215: ZEND_END_ARG_INFO()
216:
217: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_deletemailbox, 0, 0, 2)
218: ZEND_ARG_INFO(0, stream_id)
219: ZEND_ARG_INFO(0, mailbox)
220: ZEND_END_ARG_INFO()
221:
222: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_list, 0, 0, 3)
223: ZEND_ARG_INFO(0, stream_id)
224: ZEND_ARG_INFO(0, ref)
225: ZEND_ARG_INFO(0, pattern)
226: ZEND_END_ARG_INFO()
227:
228: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_getmailboxes, 0, 0, 3)
229: ZEND_ARG_INFO(0, stream_id)
230: ZEND_ARG_INFO(0, ref)
231: ZEND_ARG_INFO(0, pattern)
232: ZEND_END_ARG_INFO()
233:
234: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_listscan, 0, 0, 4)
235: ZEND_ARG_INFO(0, stream_id)
236: ZEND_ARG_INFO(0, ref)
237: ZEND_ARG_INFO(0, pattern)
238: ZEND_ARG_INFO(0, content)
239: ZEND_END_ARG_INFO()
240:
241: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_check, 0, 0, 1)
242: ZEND_ARG_INFO(0, stream_id)
243: ZEND_END_ARG_INFO()
244:
245: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_delete, 0, 0, 2)
246: ZEND_ARG_INFO(0, stream_id)
247: ZEND_ARG_INFO(0, msg_no)
248: ZEND_ARG_INFO(0, options)
249: ZEND_END_ARG_INFO()
250:
251: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_undelete, 0, 0, 2)
252: ZEND_ARG_INFO(0, stream_id)
253: ZEND_ARG_INFO(0, msg_no)
254: ZEND_ARG_INFO(0, flags)
255: ZEND_END_ARG_INFO()
256:
257: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_headerinfo, 0, 0, 2)
258: ZEND_ARG_INFO(0, stream_id)
259: ZEND_ARG_INFO(0, msg_no)
260: ZEND_ARG_INFO(0, from_length)
261: ZEND_ARG_INFO(0, subject_length)
262: ZEND_ARG_INFO(0, default_host)
263: ZEND_END_ARG_INFO()
264:
265: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_rfc822_parse_headers, 0, 0, 1)
266: ZEND_ARG_INFO(0, headers)
267: ZEND_ARG_INFO(0, default_host)
268: ZEND_END_ARG_INFO()
269:
270: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_lsub, 0, 0, 3)
271: ZEND_ARG_INFO(0, stream_id)
272: ZEND_ARG_INFO(0, ref)
273: ZEND_ARG_INFO(0, pattern)
274: ZEND_END_ARG_INFO()
275:
276: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_getsubscribed, 0, 0, 3)
277: ZEND_ARG_INFO(0, stream_id)
278: ZEND_ARG_INFO(0, ref)
279: ZEND_ARG_INFO(0, pattern)
280: ZEND_END_ARG_INFO()
281:
282: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_subscribe, 0, 0, 2)
283: ZEND_ARG_INFO(0, stream_id)
284: ZEND_ARG_INFO(0, mailbox)
285: ZEND_END_ARG_INFO()
286:
287: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_unsubscribe, 0, 0, 2)
288: ZEND_ARG_INFO(0, stream_id)
289: ZEND_ARG_INFO(0, mailbox)
290: ZEND_END_ARG_INFO()
291:
292: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_fetchstructure, 0, 0, 2)
293: ZEND_ARG_INFO(0, stream_id)
294: ZEND_ARG_INFO(0, msg_no)
295: ZEND_ARG_INFO(0, options)
296: ZEND_END_ARG_INFO()
297:
298: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_fetchbody, 0, 0, 3)
299: ZEND_ARG_INFO(0, stream_id)
300: ZEND_ARG_INFO(0, msg_no)
301: ZEND_ARG_INFO(0, section)
302: ZEND_ARG_INFO(0, options)
303: ZEND_END_ARG_INFO()
304:
305: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_savebody, 0, 0, 3)
306: ZEND_ARG_INFO(0, stream_id)
307: ZEND_ARG_INFO(0, file)
308: ZEND_ARG_INFO(0, msg_no)
309: ZEND_ARG_INFO(0, section)
310: ZEND_ARG_INFO(0, options)
311: ZEND_END_ARG_INFO()
312:
313: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_base64, 0, 0, 1)
314: ZEND_ARG_INFO(0, text)
315: ZEND_END_ARG_INFO()
316:
317: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_qprint, 0, 0, 1)
318: ZEND_ARG_INFO(0, text)
319: ZEND_END_ARG_INFO()
320:
321: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_8bit, 0, 0, 1)
322: ZEND_ARG_INFO(0, text)
323: ZEND_END_ARG_INFO()
324:
325: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_binary, 0, 0, 1)
326: ZEND_ARG_INFO(0, text)
327: ZEND_END_ARG_INFO()
328:
329: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_mailboxmsginfo, 0, 0, 1)
330: ZEND_ARG_INFO(0, stream_id)
331: ZEND_END_ARG_INFO()
332:
333: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_rfc822_write_address, 0, 0, 3)
334: ZEND_ARG_INFO(0, mailbox)
335: ZEND_ARG_INFO(0, host)
336: ZEND_ARG_INFO(0, personal)
337: ZEND_END_ARG_INFO()
338:
339: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_rfc822_parse_adrlist, 0, 0, 2)
340: ZEND_ARG_INFO(0, address_string)
341: ZEND_ARG_INFO(0, default_host)
342: ZEND_END_ARG_INFO()
343:
344: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_utf8, 0, 0, 1)
345: ZEND_ARG_INFO(0, mime_encoded_text)
346: ZEND_END_ARG_INFO()
347:
348: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_utf7_decode, 0, 0, 1)
349: ZEND_ARG_INFO(0, buf)
350: ZEND_END_ARG_INFO()
351:
352: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_utf7_encode, 0, 0, 1)
353: ZEND_ARG_INFO(0, buf)
354: ZEND_END_ARG_INFO()
355:
356: #ifdef HAVE_IMAP_MUTF7
357: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_utf8_to_mutf7, 0, 0, 1)
358: ZEND_ARG_INFO(0, in)
359: ZEND_END_ARG_INFO()
360:
361: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_mutf7_to_utf8, 0, 0, 1)
362: ZEND_ARG_INFO(0, in)
363: ZEND_END_ARG_INFO()
364: #endif
365:
366: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_setflag_full, 0, 0, 3)
367: ZEND_ARG_INFO(0, stream_id)
368: ZEND_ARG_INFO(0, sequence)
369: ZEND_ARG_INFO(0, flag)
370: ZEND_ARG_INFO(0, options)
371: ZEND_END_ARG_INFO()
372:
373: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_clearflag_full, 0, 0, 3)
374: ZEND_ARG_INFO(0, stream_id)
375: ZEND_ARG_INFO(0, sequence)
376: ZEND_ARG_INFO(0, flag)
377: ZEND_ARG_INFO(0, options)
378: ZEND_END_ARG_INFO()
379:
380: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_sort, 0, 0, 3)
381: ZEND_ARG_INFO(0, stream_id)
382: ZEND_ARG_INFO(0, criteria)
383: ZEND_ARG_INFO(0, reverse)
384: ZEND_ARG_INFO(0, options)
385: ZEND_ARG_INFO(0, search_criteria)
386: ZEND_ARG_INFO(0, charset)
387: ZEND_END_ARG_INFO()
388:
389: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_fetchheader, 0, 0, 2)
390: ZEND_ARG_INFO(0, stream_id)
391: ZEND_ARG_INFO(0, msg_no)
392: ZEND_ARG_INFO(0, options)
393: ZEND_END_ARG_INFO()
394:
395: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_uid, 0, 0, 2)
396: ZEND_ARG_INFO(0, stream_id)
397: ZEND_ARG_INFO(0, msg_no)
398: ZEND_END_ARG_INFO()
399:
400: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_msgno, 0, 0, 2)
401: ZEND_ARG_INFO(0, stream_id)
402: ZEND_ARG_INFO(0, unique_msg_id)
403: ZEND_END_ARG_INFO()
404:
405: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_status, 0, 0, 3)
406: ZEND_ARG_INFO(0, stream_id)
407: ZEND_ARG_INFO(0, mailbox)
408: ZEND_ARG_INFO(0, options)
409: ZEND_END_ARG_INFO()
410:
411: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_bodystruct, 0, 0, 3)
412: ZEND_ARG_INFO(0, stream_id)
413: ZEND_ARG_INFO(0, msg_no)
414: ZEND_ARG_INFO(0, section)
415: ZEND_END_ARG_INFO()
416:
417: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_fetch_overview, 0, 0, 2)
418: ZEND_ARG_INFO(0, stream_id)
419: ZEND_ARG_INFO(0, sequence)
420: ZEND_ARG_INFO(0, options)
421: ZEND_END_ARG_INFO()
422:
423: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_mail_compose, 0, 0, 2)
424: ZEND_ARG_INFO(0, envelope)
425: ZEND_ARG_INFO(0, body)
426: ZEND_END_ARG_INFO()
427:
428: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_mail, 0, 0, 3)
429: ZEND_ARG_INFO(0, to)
430: ZEND_ARG_INFO(0, subject)
431: ZEND_ARG_INFO(0, message)
432: ZEND_ARG_INFO(0, additional_headers)
433: ZEND_ARG_INFO(0, cc)
434: ZEND_ARG_INFO(0, bcc)
435: ZEND_ARG_INFO(0, rpath)
436: ZEND_END_ARG_INFO()
437:
438: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_search, 0, 0, 2)
439: ZEND_ARG_INFO(0, stream_id)
440: ZEND_ARG_INFO(0, criteria)
441: ZEND_ARG_INFO(0, options)
442: ZEND_ARG_INFO(0, charset)
443: ZEND_END_ARG_INFO()
444:
445: ZEND_BEGIN_ARG_INFO(arginfo_imap_alerts, 0)
446: ZEND_END_ARG_INFO()
447:
448: ZEND_BEGIN_ARG_INFO(arginfo_imap_errors, 0)
449: ZEND_END_ARG_INFO()
450:
451: ZEND_BEGIN_ARG_INFO(arginfo_imap_last_error, 0)
452: ZEND_END_ARG_INFO()
453:
454: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_mime_header_decode, 0, 0, 1)
455: ZEND_ARG_INFO(0, str)
456: ZEND_END_ARG_INFO()
457:
458: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_thread, 0, 0, 1)
459: ZEND_ARG_INFO(0, stream_id)
460: ZEND_ARG_INFO(0, options)
461: ZEND_END_ARG_INFO()
462:
463: ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_timeout, 0, 0, 1)
464: ZEND_ARG_INFO(0, timeout_type)
465: ZEND_ARG_INFO(0, timeout)
466: ZEND_END_ARG_INFO()
467: /* }}} */
468:
469: /* {{{ imap_functions[]
470: */
471: const zend_function_entry imap_functions[] = {
472: PHP_FE(imap_open, arginfo_imap_open)
473: PHP_FE(imap_reopen, arginfo_imap_reopen)
474: PHP_FE(imap_close, arginfo_imap_close)
475: PHP_FE(imap_num_msg, arginfo_imap_num_msg)
476: PHP_FE(imap_num_recent, arginfo_imap_num_recent)
477: PHP_FE(imap_headers, arginfo_imap_headers)
478: PHP_FE(imap_headerinfo, arginfo_imap_headerinfo)
479: PHP_FE(imap_rfc822_parse_headers, arginfo_imap_rfc822_parse_headers)
480: PHP_FE(imap_rfc822_write_address, arginfo_imap_rfc822_write_address)
481: PHP_FE(imap_rfc822_parse_adrlist, arginfo_imap_rfc822_parse_adrlist)
482: PHP_FE(imap_body, arginfo_imap_body)
483: PHP_FE(imap_bodystruct, arginfo_imap_bodystruct)
484: PHP_FE(imap_fetchbody, arginfo_imap_fetchbody)
485: PHP_FE(imap_fetchmime, arginfo_imap_fetchbody)
486: PHP_FE(imap_savebody, arginfo_imap_savebody)
487: PHP_FE(imap_fetchheader, arginfo_imap_fetchheader)
488: PHP_FE(imap_fetchstructure, arginfo_imap_fetchstructure)
489: PHP_FE(imap_gc, arginfo_imap_gc)
490: PHP_FE(imap_expunge, arginfo_imap_expunge)
491: PHP_FE(imap_delete, arginfo_imap_delete)
492: PHP_FE(imap_undelete, arginfo_imap_undelete)
493: PHP_FE(imap_check, arginfo_imap_check)
494: PHP_FE(imap_listscan, arginfo_imap_listscan)
495: PHP_FE(imap_mail_copy, arginfo_imap_mail_copy)
496: PHP_FE(imap_mail_move, arginfo_imap_mail_move)
497: PHP_FE(imap_mail_compose, arginfo_imap_mail_compose)
498: PHP_FE(imap_createmailbox, arginfo_imap_createmailbox)
499: PHP_FE(imap_renamemailbox, arginfo_imap_renamemailbox)
500: PHP_FE(imap_deletemailbox, arginfo_imap_deletemailbox)
501: PHP_FE(imap_subscribe, arginfo_imap_subscribe)
502: PHP_FE(imap_unsubscribe, arginfo_imap_unsubscribe)
503: PHP_FE(imap_append, arginfo_imap_append)
504: PHP_FE(imap_ping, arginfo_imap_ping)
505: PHP_FE(imap_base64, arginfo_imap_base64)
506: PHP_FE(imap_qprint, arginfo_imap_qprint)
507: PHP_FE(imap_8bit, arginfo_imap_8bit)
508: PHP_FE(imap_binary, arginfo_imap_binary)
509: PHP_FE(imap_utf8, arginfo_imap_utf8)
510: PHP_FE(imap_status, arginfo_imap_status)
511: PHP_FE(imap_mailboxmsginfo, arginfo_imap_mailboxmsginfo)
512: PHP_FE(imap_setflag_full, arginfo_imap_setflag_full)
513: PHP_FE(imap_clearflag_full, arginfo_imap_clearflag_full)
514: PHP_FE(imap_sort, arginfo_imap_sort)
515: PHP_FE(imap_uid, arginfo_imap_uid)
516: PHP_FE(imap_msgno, arginfo_imap_msgno)
517: PHP_FE(imap_list, arginfo_imap_list)
518: PHP_FE(imap_lsub, arginfo_imap_lsub)
519: PHP_FE(imap_fetch_overview, arginfo_imap_fetch_overview)
520: PHP_FE(imap_alerts, arginfo_imap_alerts)
521: PHP_FE(imap_errors, arginfo_imap_errors)
522: PHP_FE(imap_last_error, arginfo_imap_last_error)
523: PHP_FE(imap_search, arginfo_imap_search)
524: PHP_FE(imap_utf7_decode, arginfo_imap_utf7_decode)
525: PHP_FE(imap_utf7_encode, arginfo_imap_utf7_encode)
526: #ifdef HAVE_IMAP_MUTF7
527: PHP_FE(imap_utf8_to_mutf7, arginfo_imap_utf8_to_mutf7)
528: PHP_FE(imap_mutf7_to_utf8, arginfo_imap_mutf7_to_utf8)
529: #endif
530: PHP_FE(imap_mime_header_decode, arginfo_imap_mime_header_decode)
531: PHP_FE(imap_thread, arginfo_imap_thread)
532: PHP_FE(imap_timeout, arginfo_imap_timeout)
533:
534: #if defined(HAVE_IMAP2000) || defined(HAVE_IMAP2001)
535: PHP_FE(imap_get_quota, arginfo_imap_get_quota)
536: PHP_FE(imap_get_quotaroot, arginfo_imap_get_quotaroot)
537: PHP_FE(imap_set_quota, arginfo_imap_set_quota)
538: PHP_FE(imap_setacl, arginfo_imap_setacl)
539: PHP_FE(imap_getacl, arginfo_imap_getacl)
540: #endif
541:
542: PHP_FE(imap_mail, arginfo_imap_mail)
543:
544: PHP_FALIAS(imap_header, imap_headerinfo, arginfo_imap_headerinfo)
545: PHP_FALIAS(imap_listmailbox, imap_list, arginfo_imap_list)
546: PHP_FALIAS(imap_getmailboxes, imap_list_full, arginfo_imap_getmailboxes)
547: PHP_FALIAS(imap_scanmailbox, imap_listscan, arginfo_imap_listscan)
548: PHP_FALIAS(imap_listsubscribed, imap_lsub, arginfo_imap_lsub)
549: PHP_FALIAS(imap_getsubscribed, imap_lsub_full, arginfo_imap_getsubscribed)
550: PHP_FALIAS(imap_fetchtext, imap_body, arginfo_imap_body)
551: PHP_FALIAS(imap_scan, imap_listscan, arginfo_imap_listscan)
552: PHP_FALIAS(imap_create, imap_createmailbox, arginfo_imap_createmailbox)
553: PHP_FALIAS(imap_rename, imap_renamemailbox, arginfo_imap_renamemailbox)
554: PHP_FE_END
555: };
556: /* }}} */
557:
558: /* {{{ imap dependencies */
559: static const zend_module_dep imap_deps[] = {
560: ZEND_MOD_REQUIRED("standard")
561: ZEND_MOD_END
562: };
563: /* }}} */
564:
565: /* {{{ imap_module_entry
566: */
567: zend_module_entry imap_module_entry = {
568: STANDARD_MODULE_HEADER_EX, NULL,
569: imap_deps,
570: "imap",
571: imap_functions,
572: PHP_MINIT(imap),
573: NULL,
574: PHP_RINIT(imap),
575: PHP_RSHUTDOWN(imap),
576: PHP_MINFO(imap),
577: NO_VERSION_YET,
578: PHP_MODULE_GLOBALS(imap),
579: PHP_GINIT(imap),
580: NULL,
581: NULL,
582: STANDARD_MODULE_PROPERTIES_EX
583: };
584: /* }}} */
585:
586: #ifdef COMPILE_DL_IMAP
587: ZEND_GET_MODULE(imap)
588: #endif
589:
590: /* True globals, no need for thread safety */
591: static int le_imap;
592:
593: #define PHP_IMAP_CHECK_MSGNO(msgindex) \
594: if ((msgindex < 1) || ((unsigned) msgindex > imap_le_struct->imap_stream->nmsgs)) { \
595: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Bad message number"); \
596: RETURN_FALSE; \
597: } \
598:
599: /* {{{ mail_close_it
600: */
601: static void mail_close_it(zend_rsrc_list_entry *rsrc TSRMLS_DC)
602: {
603: pils *imap_le_struct = (pils *)rsrc->ptr;
604:
605: /* Do not try to close prototype streams */
606: if (!(imap_le_struct->flags & OP_PROTOTYPE)) {
607: mail_close_full(imap_le_struct->imap_stream, imap_le_struct->flags);
608: }
609:
610: if (IMAPG(imap_user)) {
611: efree(IMAPG(imap_user));
612: IMAPG(imap_user) = 0;
613: }
614: if (IMAPG(imap_password)) {
615: efree(IMAPG(imap_password));
616: IMAPG(imap_password) = 0;
617: }
618:
619: efree(imap_le_struct);
620: }
621: /* }}} */
622:
623: /* {{{ add_assoc_object
624: */
625: static int add_assoc_object(zval *arg, char *key, zval *tmp TSRMLS_DC)
626: {
627: HashTable *symtable;
628:
629: if (Z_TYPE_P(arg) == IS_OBJECT) {
630: symtable = Z_OBJPROP_P(arg);
631: } else {
632: symtable = Z_ARRVAL_P(arg);
633: }
634: return zend_hash_update(symtable, key, strlen(key)+1, (void *) &tmp, sizeof(zval *), NULL);
635: }
636: /* }}} */
637:
638: /* {{{ add_next_index_object
639: */
640: static inline int add_next_index_object(zval *arg, zval *tmp TSRMLS_DC)
641: {
642: HashTable *symtable;
643:
644: if (Z_TYPE_P(arg) == IS_OBJECT) {
645: symtable = Z_OBJPROP_P(arg);
646: } else {
647: symtable = Z_ARRVAL_P(arg);
648: }
649:
650: return zend_hash_next_index_insert(symtable, (void *) &tmp, sizeof(zval *), NULL);
651: }
652: /* }}} */
653:
654: /* {{{ mail_newfolderobjectlist
655: *
656: * Mail instantiate FOBJECTLIST
657: * Returns: new FOBJECTLIST list
658: * Author: CJH
659: */
660: FOBJECTLIST *mail_newfolderobjectlist(void)
661: {
662: return (FOBJECTLIST *) memset(fs_get(sizeof(FOBJECTLIST)), 0, sizeof(FOBJECTLIST));
663: }
664: /* }}} */
665:
666: /* {{{ mail_free_foblist
667: *
668: * Mail garbage collect FOBJECTLIST
669: * Accepts: pointer to FOBJECTLIST pointer
670: * Author: CJH
671: */
672: void mail_free_foblist(FOBJECTLIST **foblist, FOBJECTLIST **tail)
673: {
674: FOBJECTLIST *cur, *next;
675:
676: for (cur=*foblist, next=cur->next; cur; cur=next) {
677: next = cur->next;
678:
679: if(cur->text.data)
680: fs_give((void **)&(cur->text.data));
681:
682: fs_give((void **)&cur);
683: }
684:
685: *tail = NIL;
686: *foblist = NIL;
687: }
688: /* }}} */
689:
690: /* {{{ mail_newerrorlist
691: *
692: * Mail instantiate ERRORLIST
693: * Returns: new ERRORLIST list
694: * Author: CJH
695: */
696: ERRORLIST *mail_newerrorlist(void)
697: {
698: return (ERRORLIST *) memset(fs_get(sizeof(ERRORLIST)), 0, sizeof(ERRORLIST));
699: }
700: /* }}} */
701:
702: /* {{{ mail_free_errorlist
703: *
704: * Mail garbage collect FOBJECTLIST
705: * Accepts: pointer to FOBJECTLIST pointer
706: * Author: CJH
707: */
708: void mail_free_errorlist(ERRORLIST **errlist)
709: {
710: if (*errlist) { /* only free if exists */
711: if ((*errlist)->text.data) {
712: fs_give((void **) &(*errlist)->text.data);
713: }
714: mail_free_errorlist (&(*errlist)->next);
715: fs_give((void **) errlist); /* return string to free storage */
716: }
717: }
718: /* }}} */
719:
720: /* {{{ mail_newmessagelist
721: *
722: * Mail instantiate MESSAGELIST
723: * Returns: new MESSAGELIST list
724: * Author: CJH
725: */
726: MESSAGELIST *mail_newmessagelist(void)
727: {
728: return (MESSAGELIST *) memset(fs_get(sizeof(MESSAGELIST)), 0, sizeof(MESSAGELIST));
729: }
730: /* }}} */
731:
732: /* {{{ mail_free_messagelist
733: *
734: * Mail garbage collect MESSAGELIST
735: * Accepts: pointer to MESSAGELIST pointer
736: * Author: CJH
737: */
738: void mail_free_messagelist(MESSAGELIST **msglist, MESSAGELIST **tail)
739: {
740: MESSAGELIST *cur, *next;
741:
742: for (cur = *msglist, next = cur->next; cur; cur = next) {
743: next = cur->next;
744: fs_give((void **)&cur);
745: }
746:
747: *tail = NIL;
748: *msglist = NIL;
749: }
750: /* }}} */
751:
752: #if defined(HAVE_IMAP2000) || defined(HAVE_IMAP2001)
753: /* {{{ mail_getquota
754: *
755: * Mail GET_QUOTA callback
756: * Called via the mail_parameter function in c-client:src/c-client/mail.c
757: * Author DRK
758: */
759:
760: void mail_getquota(MAILSTREAM *stream, char *qroot, QUOTALIST *qlist)
761: {
762: zval *t_map, *return_value;
763: TSRMLS_FETCH();
764:
765: return_value = *IMAPG(quota_return);
766:
767: /* put parsing code here */
768: for(; qlist; qlist = qlist->next) {
769: MAKE_STD_ZVAL(t_map);
770: array_init(t_map);
771: if (strncmp(qlist->name, "STORAGE", 7) == 0)
772: {
773: /* this is to add backwards compatibility */
774: add_assoc_long_ex(return_value, "usage", sizeof("usage"), qlist->usage);
775: add_assoc_long_ex(return_value, "limit", sizeof("limit"), qlist->limit);
776: }
777:
778: add_assoc_long_ex(t_map, "usage", sizeof("usage"), qlist->usage);
779: add_assoc_long_ex(t_map, "limit", sizeof("limit"), qlist->limit);
780: add_assoc_zval_ex(return_value, qlist->name, strlen(qlist->name)+1, t_map);
781: }
782: }
783: /* }}} */
784:
785: /* {{{ mail_getquota
786: *
787: * Mail GET_ACL callback
788: * Called via the mail_parameter function in c-client:src/c-client/mail.c
789: */
790: void mail_getacl(MAILSTREAM *stream, char *mailbox, ACLLIST *alist)
791: {
792: TSRMLS_FETCH();
793:
794: /* walk through the ACLLIST */
795: for(; alist; alist = alist->next) {
796: add_assoc_stringl(IMAPG(imap_acl_list), alist->identifier, alist->rights, strlen(alist->rights), 1);
797: }
798: }
799: /* }}} */
800: #endif
801:
802: /* {{{ PHP_GINIT_FUNCTION
803: */
804: static PHP_GINIT_FUNCTION(imap)
805: {
806: imap_globals->imap_user = NIL;
807: imap_globals->imap_password = NIL;
808:
809: imap_globals->imap_alertstack = NIL;
810: imap_globals->imap_errorstack = NIL;
811:
812: imap_globals->imap_folders = NIL;
813: imap_globals->imap_folders_tail = NIL;
814: imap_globals->imap_sfolders = NIL;
815: imap_globals->imap_sfolders_tail = NIL;
816: imap_globals->imap_messages = NIL;
817: imap_globals->imap_messages_tail = NIL;
818: imap_globals->imap_folder_objects = NIL;
819: imap_globals->imap_folder_objects_tail = NIL;
820: imap_globals->imap_sfolder_objects = NIL;
821: imap_globals->imap_sfolder_objects_tail = NIL;
822:
823: imap_globals->folderlist_style = FLIST_ARRAY;
824: #if defined(HAVE_IMAP2000) || defined(HAVE_IMAP2001)
825: imap_globals->quota_return = NIL;
826: imap_globals->imap_acl_list = NIL;
827: #endif
828: imap_globals->gets_stream = NIL;
829: }
830: /* }}} */
831:
832: /* {{{ PHP_MINIT_FUNCTION
833: */
834: PHP_MINIT_FUNCTION(imap)
835: {
836: unsigned long sa_all = SA_MESSAGES | SA_RECENT | SA_UNSEEN | SA_UIDNEXT | SA_UIDVALIDITY;
837:
838: #ifndef PHP_WIN32
839: mail_link(&unixdriver); /* link in the unix driver */
840: mail_link(&mhdriver); /* link in the mh driver */
841: /* mail_link(&mxdriver); */ /* According to c-client docs (internal.txt) this shouldn't be used. */
842: mail_link(&mmdfdriver); /* link in the mmdf driver */
843: mail_link(&newsdriver); /* link in the news driver */
844: mail_link(&philedriver); /* link in the phile driver */
845: #endif
846: mail_link(&imapdriver); /* link in the imap driver */
847: mail_link(&nntpdriver); /* link in the nntp driver */
848: mail_link(&pop3driver); /* link in the pop3 driver */
849: mail_link(&mbxdriver); /* link in the mbx driver */
850: mail_link(&tenexdriver); /* link in the tenex driver */
851: mail_link(&mtxdriver); /* link in the mtx driver */
852: mail_link(&dummydriver); /* link in the dummy driver */
853:
854: #ifndef PHP_WIN32
855: auth_link(&auth_log); /* link in the log authenticator */
856: auth_link(&auth_md5); /* link in the cram-md5 authenticator */
857: #if HAVE_IMAP_KRB && defined(HAVE_IMAP_AUTH_GSS)
858: auth_link(&auth_gss); /* link in the gss authenticator */
859: #endif
860: auth_link(&auth_pla); /* link in the plain authenticator */
861: #endif
862:
863: #ifdef HAVE_IMAP_SSL
864: ssl_onceonlyinit ();
865: #endif
866:
867: /* lets allow NIL */
868: REGISTER_LONG_CONSTANT("NIL", NIL, CONST_PERSISTENT | CONST_CS);
869:
870: /* plug in our gets */
871: mail_parameters(NIL, SET_GETS, (void *) NIL);
872:
873: /* set default timeout values */
874: mail_parameters(NIL, SET_OPENTIMEOUT, (void *) FG(default_socket_timeout));
875: mail_parameters(NIL, SET_READTIMEOUT, (void *) FG(default_socket_timeout));
876: mail_parameters(NIL, SET_WRITETIMEOUT, (void *) FG(default_socket_timeout));
877: mail_parameters(NIL, SET_CLOSETIMEOUT, (void *) FG(default_socket_timeout));
878:
879: /* timeout constants */
880: REGISTER_LONG_CONSTANT("IMAP_OPENTIMEOUT", 1, CONST_PERSISTENT | CONST_CS);
881: REGISTER_LONG_CONSTANT("IMAP_READTIMEOUT", 2, CONST_PERSISTENT | CONST_CS);
882: REGISTER_LONG_CONSTANT("IMAP_WRITETIMEOUT", 3, CONST_PERSISTENT | CONST_CS);
883: REGISTER_LONG_CONSTANT("IMAP_CLOSETIMEOUT", 4, CONST_PERSISTENT | CONST_CS);
884:
885: /* Open Options */
886:
887: REGISTER_LONG_CONSTANT("OP_DEBUG", OP_DEBUG, CONST_PERSISTENT | CONST_CS);
888: /* debug protocol negotiations */
889: REGISTER_LONG_CONSTANT("OP_READONLY", OP_READONLY, CONST_PERSISTENT | CONST_CS);
890: /* read-only open */
891: REGISTER_LONG_CONSTANT("OP_ANONYMOUS", OP_ANONYMOUS, CONST_PERSISTENT | CONST_CS);
892: /* anonymous open of newsgroup */
893: REGISTER_LONG_CONSTANT("OP_SHORTCACHE", OP_SHORTCACHE, CONST_PERSISTENT | CONST_CS);
894: /* short (elt-only) caching */
895: REGISTER_LONG_CONSTANT("OP_SILENT", OP_SILENT, CONST_PERSISTENT | CONST_CS);
896: /* don't pass up events (internal use) */
897: REGISTER_LONG_CONSTANT("OP_PROTOTYPE", OP_PROTOTYPE, CONST_PERSISTENT | CONST_CS);
898: /* return driver prototype */
899: REGISTER_LONG_CONSTANT("OP_HALFOPEN", OP_HALFOPEN, CONST_PERSISTENT | CONST_CS);
900: /* half-open (IMAP connect but no select) */
901: REGISTER_LONG_CONSTANT("OP_EXPUNGE", OP_EXPUNGE, CONST_PERSISTENT | CONST_CS);
902: /* silently expunge recycle stream */
903: REGISTER_LONG_CONSTANT("OP_SECURE", OP_SECURE, CONST_PERSISTENT | CONST_CS);
904: /* don't do non-secure authentication */
905:
906: /*
907: PHP re-assigns CL_EXPUNGE a custom value that can be used as part of the imap_open() bitfield
908: because it seems like a good idea to be able to indicate that the mailbox should be
909: automatically expunged during imap_open in case the script get interrupted and it doesn't get
910: to the imap_close() where this option is normally placed. If the c-client library adds other
911: options and the value for this one conflicts, simply make PHP_EXPUNGE higher at the top of
912: this file
913: */
914: REGISTER_LONG_CONSTANT("CL_EXPUNGE", PHP_EXPUNGE, CONST_PERSISTENT | CONST_CS);
915: /* expunge silently */
916:
917: /* Fetch options */
918:
919: REGISTER_LONG_CONSTANT("FT_UID", FT_UID, CONST_PERSISTENT | CONST_CS);
920: /* argument is a UID */
921: REGISTER_LONG_CONSTANT("FT_PEEK", FT_PEEK, CONST_PERSISTENT | CONST_CS);
922: /* peek at data */
923: REGISTER_LONG_CONSTANT("FT_NOT", FT_NOT, CONST_PERSISTENT | CONST_CS);
924: /* NOT flag for header lines fetch */
925: REGISTER_LONG_CONSTANT("FT_INTERNAL", FT_INTERNAL, CONST_PERSISTENT | CONST_CS);
926: /* text can be internal strings */
927: REGISTER_LONG_CONSTANT("FT_PREFETCHTEXT", FT_PREFETCHTEXT, CONST_PERSISTENT | CONST_CS);
928: /* IMAP prefetch text when fetching header */
929:
930: /* Flagging options */
931:
932: REGISTER_LONG_CONSTANT("ST_UID", ST_UID, CONST_PERSISTENT | CONST_CS);
933: /* argument is a UID sequence */
934: REGISTER_LONG_CONSTANT("ST_SILENT", ST_SILENT, CONST_PERSISTENT | CONST_CS);
935: /* don't return results */
936: REGISTER_LONG_CONSTANT("ST_SET", ST_SET, CONST_PERSISTENT | CONST_CS);
937: /* set vs. clear */
938:
939: /* Copy options */
940:
941: REGISTER_LONG_CONSTANT("CP_UID", CP_UID, CONST_PERSISTENT | CONST_CS);
942: /* argument is a UID sequence */
943: REGISTER_LONG_CONSTANT("CP_MOVE", CP_MOVE, CONST_PERSISTENT | CONST_CS);
944: /* delete from source after copying */
945:
946: /* Search/sort options */
947:
948: REGISTER_LONG_CONSTANT("SE_UID", SE_UID, CONST_PERSISTENT | CONST_CS);
949: /* return UID */
950: REGISTER_LONG_CONSTANT("SE_FREE", SE_FREE, CONST_PERSISTENT | CONST_CS);
951: /* free search program after finished */
952: REGISTER_LONG_CONSTANT("SE_NOPREFETCH", SE_NOPREFETCH, CONST_PERSISTENT | CONST_CS);
953: /* no search prefetching */
954: REGISTER_LONG_CONSTANT("SO_FREE", SO_FREE, CONST_PERSISTENT | CONST_CS);
955: /* free sort program after finished */
956: REGISTER_LONG_CONSTANT("SO_NOSERVER", SO_NOSERVER, CONST_PERSISTENT | CONST_CS);
957: /* don't do server-based sort */
958:
959: /* Status options */
960:
961: REGISTER_LONG_CONSTANT("SA_MESSAGES", SA_MESSAGES , CONST_PERSISTENT | CONST_CS);
962: /* number of messages */
963: REGISTER_LONG_CONSTANT("SA_RECENT", SA_RECENT, CONST_PERSISTENT | CONST_CS);
964: /* number of recent messages */
965: REGISTER_LONG_CONSTANT("SA_UNSEEN", SA_UNSEEN , CONST_PERSISTENT | CONST_CS);
966: /* number of unseen messages */
967: REGISTER_LONG_CONSTANT("SA_UIDNEXT", SA_UIDNEXT, CONST_PERSISTENT | CONST_CS);
968: /* next UID to be assigned */
969: REGISTER_LONG_CONSTANT("SA_UIDVALIDITY", SA_UIDVALIDITY , CONST_PERSISTENT | CONST_CS);
970: /* UID validity value */
971: REGISTER_LONG_CONSTANT("SA_ALL", sa_all, CONST_PERSISTENT | CONST_CS);
972: /* get all status information */
973:
974: /* Bits for mm_list() and mm_lsub() */
975:
976: REGISTER_LONG_CONSTANT("LATT_NOINFERIORS", LATT_NOINFERIORS , CONST_PERSISTENT | CONST_CS);
977: REGISTER_LONG_CONSTANT("LATT_NOSELECT", LATT_NOSELECT, CONST_PERSISTENT | CONST_CS);
978: REGISTER_LONG_CONSTANT("LATT_MARKED", LATT_MARKED, CONST_PERSISTENT | CONST_CS);
979: REGISTER_LONG_CONSTANT("LATT_UNMARKED", LATT_UNMARKED , CONST_PERSISTENT | CONST_CS);
980:
981: #ifdef LATT_REFERRAL
982: REGISTER_LONG_CONSTANT("LATT_REFERRAL", LATT_REFERRAL, CONST_PERSISTENT | CONST_CS);
983: #endif
984:
985: #ifdef LATT_HASCHILDREN
986: REGISTER_LONG_CONSTANT("LATT_HASCHILDREN", LATT_HASCHILDREN, CONST_PERSISTENT | CONST_CS);
987: #endif
988:
989: #ifdef LATT_HASNOCHILDREN
990: REGISTER_LONG_CONSTANT("LATT_HASNOCHILDREN", LATT_HASNOCHILDREN, CONST_PERSISTENT | CONST_CS);
991: #endif
992:
993: /* Sort functions */
994:
995: REGISTER_LONG_CONSTANT("SORTDATE", SORTDATE , CONST_PERSISTENT | CONST_CS);
996: /* date */
997: REGISTER_LONG_CONSTANT("SORTARRIVAL", SORTARRIVAL , CONST_PERSISTENT | CONST_CS);
998: /* arrival date */
999: REGISTER_LONG_CONSTANT("SORTFROM", SORTFROM , CONST_PERSISTENT | CONST_CS);
1000: /* from */
1001: REGISTER_LONG_CONSTANT("SORTSUBJECT", SORTSUBJECT , CONST_PERSISTENT | CONST_CS);
1002: /* subject */
1003: REGISTER_LONG_CONSTANT("SORTTO", SORTTO , CONST_PERSISTENT | CONST_CS);
1004: /* to */
1005: REGISTER_LONG_CONSTANT("SORTCC", SORTCC , CONST_PERSISTENT | CONST_CS);
1006: /* cc */
1007: REGISTER_LONG_CONSTANT("SORTSIZE", SORTSIZE , CONST_PERSISTENT | CONST_CS);
1008: /* size */
1009:
1010: REGISTER_LONG_CONSTANT("TYPETEXT", TYPETEXT , CONST_PERSISTENT | CONST_CS);
1011: REGISTER_LONG_CONSTANT("TYPEMULTIPART", TYPEMULTIPART , CONST_PERSISTENT | CONST_CS);
1012: REGISTER_LONG_CONSTANT("TYPEMESSAGE", TYPEMESSAGE , CONST_PERSISTENT | CONST_CS);
1013: REGISTER_LONG_CONSTANT("TYPEAPPLICATION", TYPEAPPLICATION , CONST_PERSISTENT | CONST_CS);
1014: REGISTER_LONG_CONSTANT("TYPEAUDIO", TYPEAUDIO , CONST_PERSISTENT | CONST_CS);
1015: REGISTER_LONG_CONSTANT("TYPEIMAGE", TYPEIMAGE , CONST_PERSISTENT | CONST_CS);
1016: REGISTER_LONG_CONSTANT("TYPEVIDEO", TYPEVIDEO , CONST_PERSISTENT | CONST_CS);
1017: REGISTER_LONG_CONSTANT("TYPEMODEL", TYPEMODEL , CONST_PERSISTENT | CONST_CS);
1018: REGISTER_LONG_CONSTANT("TYPEOTHER", TYPEOTHER , CONST_PERSISTENT | CONST_CS);
1019: /*
1020: TYPETEXT unformatted text
1021: TYPEMULTIPART multiple part
1022: TYPEMESSAGE encapsulated message
1023: TYPEAPPLICATION application data
1024: TYPEAUDIO audio
1025: TYPEIMAGE static image (GIF, JPEG, etc.)
1026: TYPEVIDEO video
1027: TYPEMODEL model
1028: TYPEOTHER unknown
1029: */
1030:
1031: REGISTER_LONG_CONSTANT("ENC7BIT", ENC7BIT , CONST_PERSISTENT | CONST_CS);
1032: REGISTER_LONG_CONSTANT("ENC8BIT", ENC8BIT , CONST_PERSISTENT | CONST_CS);
1033: REGISTER_LONG_CONSTANT("ENCBINARY", ENCBINARY , CONST_PERSISTENT | CONST_CS);
1034: REGISTER_LONG_CONSTANT("ENCBASE64", ENCBASE64, CONST_PERSISTENT | CONST_CS);
1035: REGISTER_LONG_CONSTANT("ENCQUOTEDPRINTABLE", ENCQUOTEDPRINTABLE , CONST_PERSISTENT | CONST_CS);
1036: REGISTER_LONG_CONSTANT("ENCOTHER", ENCOTHER , CONST_PERSISTENT | CONST_CS);
1037: /*
1038: ENC7BIT 7 bit SMTP semantic data
1039: ENC8BIT 8 bit SMTP semantic data
1040: ENCBINARY 8 bit binary data
1041: ENCBASE64 base-64 encoded data
1042: ENCQUOTEDPRINTABLE human-readable 8-as-7 bit data
1043: ENCOTHER unknown
1044: */
1045:
1046: REGISTER_LONG_CONSTANT("IMAP_GC_ELT", GC_ELT , CONST_PERSISTENT | CONST_CS);
1047: REGISTER_LONG_CONSTANT("IMAP_GC_ENV", GC_ENV , CONST_PERSISTENT | CONST_CS);
1048: REGISTER_LONG_CONSTANT("IMAP_GC_TEXTS", GC_TEXTS , CONST_PERSISTENT | CONST_CS);
1049: /*
1050: GC_ELT message cache elements
1051: GC_ENV ENVELOPEs and BODYs
1052: GC_TEXTS texts
1053: */
1054:
1055: le_imap = zend_register_list_destructors_ex(mail_close_it, NULL, "imap", module_number);
1056: return SUCCESS;
1057: }
1058: /* }}} */
1059:
1060: /* {{{ PHP_RINIT_FUNCTION
1061: */
1062: PHP_RINIT_FUNCTION(imap)
1063: {
1064: IMAPG(imap_errorstack) = NIL;
1065: IMAPG(imap_alertstack) = NIL;
1066: IMAPG(gets_stream) = NIL;
1067: return SUCCESS;
1068: }
1069: /* }}} */
1070:
1071: /* {{{ PHP_RSHUTDOWN_FUNCTION
1072: */
1073: PHP_RSHUTDOWN_FUNCTION(imap)
1074: {
1075: ERRORLIST *ecur = NIL;
1076: STRINGLIST *acur = NIL;
1077:
1078: if (IMAPG(imap_errorstack) != NIL) {
1079: /* output any remaining errors at their original error level */
1080: if (EG(error_reporting) & E_NOTICE) {
1081: ecur = IMAPG(imap_errorstack);
1082: while (ecur != NIL) {
1083: php_error_docref(NULL TSRMLS_CC, E_NOTICE, "%s (errflg=%ld)", ecur->LTEXT, ecur->errflg);
1084: ecur = ecur->next;
1085: }
1086: }
1087: mail_free_errorlist(&IMAPG(imap_errorstack));
1088: }
1089:
1090: if (IMAPG(imap_alertstack) != NIL) {
1091: /* output any remaining alerts at E_NOTICE level */
1092: if (EG(error_reporting) & E_NOTICE) {
1093: acur = IMAPG(imap_alertstack);
1094: while (acur != NIL) {
1095: php_error_docref(NULL TSRMLS_CC, E_NOTICE, "%s", acur->LTEXT);
1096: acur = acur->next;
1097: }
1098: }
1099: mail_free_stringlist(&IMAPG(imap_alertstack));
1100: IMAPG(imap_alertstack) = NIL;
1101: }
1102: return SUCCESS;
1103: }
1104: /* }}} */
1105:
1106: #if !defined(CCLIENTVERSION)
1107: #if HAVE_IMAP2007e
1108: #define CCLIENTVERSION "2007e"
1109: #elif HAVE_IMAP2007d
1110: #define CCLIENTVERSION "2007d"
1111: #elif HAVE_IMAP2007b
1112: #define CCLIENTVERSION "2007b"
1113: #elif HAVE_IMAP2007a
1114: #define CCLIENTVERSION "2007a"
1115: #elif HAVE_IMAP2004
1116: #define CCLIENTVERSION "2004"
1117: #elif HAVE_IMAP2001
1118: #define CCLIENTVERSION "2001"
1119: #elif HAVE_IMAP2000
1120: #define CCLIENTVERSION "2000"
1121: #elif defined(IMAP41)
1122: #define CCLIENTVERSION "4.1"
1123: #else
1124: #define CCLIENTVERSION "4.0"
1125: #endif
1126: #endif
1127:
1128: /* {{{ PHP_MINFO_FUNCTION
1129: */
1130: PHP_MINFO_FUNCTION(imap)
1131: {
1132: php_info_print_table_start();
1133: php_info_print_table_row(2, "IMAP c-Client Version", CCLIENTVERSION);
1134: #if HAVE_IMAP_SSL
1135: php_info_print_table_row(2, "SSL Support", "enabled");
1136: #endif
1137: #if HAVE_IMAP_KRB && HAVE_IMAP_AUTH_GSS
1138: php_info_print_table_row(2, "Kerberos Support", "enabled");
1139: #endif
1140: php_info_print_table_end();
1141: }
1142: /* }}} */
1143:
1144: /* {{{ imap_do_open
1145: */
1146: static void php_imap_do_open(INTERNAL_FUNCTION_PARAMETERS, int persistent)
1147: {
1148: char *mailbox, *user, *passwd;
1149: int mailbox_len, user_len, passwd_len;
1150: long retries = 0, flags = NIL, cl_flags = NIL;
1151: MAILSTREAM *imap_stream;
1152: pils *imap_le_struct;
1153: zval *params = NULL;
1154: int argc = ZEND_NUM_ARGS();
1155:
1156: if (zend_parse_parameters(argc TSRMLS_CC, "sss|lla", &mailbox, &mailbox_len, &user, &user_len,
1157: &passwd, &passwd_len, &flags, &retries, ¶ms) == FAILURE) {
1158: return;
1159: }
1160:
1161: if (argc >= 4) {
1162: if (flags & PHP_EXPUNGE) {
1163: cl_flags = CL_EXPUNGE;
1164: flags ^= PHP_EXPUNGE;
1165: }
1166: if (flags & OP_PROTOTYPE) {
1167: cl_flags |= OP_PROTOTYPE;
1168: }
1169: }
1170:
1171: if (params) {
1172: zval **disabled_auth_method;
1173:
1174: if (zend_hash_find(HASH_OF(params), "DISABLE_AUTHENTICATOR", sizeof("DISABLE_AUTHENTICATOR"), (void **)&disabled_auth_method) == SUCCESS) {
1175: switch (Z_TYPE_PP(disabled_auth_method)) {
1176: case IS_STRING:
1177: if (Z_STRLEN_PP(disabled_auth_method) > 1) {
1178: mail_parameters (NIL, DISABLE_AUTHENTICATOR, (void *)Z_STRVAL_PP(disabled_auth_method));
1179: }
1180: break;
1181: case IS_ARRAY:
1182: {
1183: zval **z_auth_method;
1184: int i;
1185: int nelems = zend_hash_num_elements(Z_ARRVAL_PP(disabled_auth_method));
1186:
1187: if (nelems == 0 ) {
1188: break;
1189: }
1190: for (i = 0; i < nelems; i++) {
1191: if (zend_hash_index_find(Z_ARRVAL_PP(disabled_auth_method), i, (void **) &z_auth_method) == SUCCESS) {
1192: if (Z_TYPE_PP(z_auth_method) == IS_STRING) {
1193: if (Z_STRLEN_PP(z_auth_method) > 1) {
1194: mail_parameters (NIL, DISABLE_AUTHENTICATOR, (void *)Z_STRVAL_PP(disabled_auth_method));
1195: }
1196: } else {
1197: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid argument, expect string or array of strings");
1198: }
1199: }
1200: }
1201: }
1202: break;
1203: case IS_LONG:
1204: default:
1205: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid argument, expect string or array of strings");
1206: break;
1207: }
1208: }
1209: }
1210:
1211: if (IMAPG(imap_user)) {
1212: efree(IMAPG(imap_user));
1213: IMAPG(imap_user) = 0;
1214: }
1215:
1216: if (IMAPG(imap_password)) {
1217: efree(IMAPG(imap_password));
1218: IMAPG(imap_password) = 0;
1219: }
1220:
1221: /* local filename, need to perform open_basedir and safe_mode checks */
1222: if (mailbox[0] != '{') {
1223: if (strlen(mailbox) != mailbox_len) {
1224: RETURN_FALSE;
1225: }
1226: if (php_check_open_basedir(mailbox TSRMLS_CC) ||
1227: (PG(safe_mode) && !php_checkuid(mailbox, NULL, CHECKUID_CHECK_FILE_AND_DIR))) {
1228: RETURN_FALSE;
1229: }
1230: }
1231:
1232: IMAPG(imap_user) = estrndup(user, user_len);
1233: IMAPG(imap_password) = estrndup(passwd, passwd_len);
1234:
1235: #ifdef SET_MAXLOGINTRIALS
1236: if (argc >= 5) {
1237: if (retries < 0) {
1238: php_error_docref(NULL TSRMLS_CC, E_WARNING ,"Retries must be greater or equal to 0");
1239: } else {
1240: mail_parameters(NIL, SET_MAXLOGINTRIALS, (void *) retries);
1241: }
1242: }
1243: #endif
1244:
1245: imap_stream = mail_open(NIL, mailbox, flags);
1246:
1247: if (imap_stream == NIL) {
1248: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Couldn't open stream %s", mailbox);
1249: efree(IMAPG(imap_user)); IMAPG(imap_user) = 0;
1250: efree(IMAPG(imap_password)); IMAPG(imap_password) = 0;
1251: RETURN_FALSE;
1252: }
1253:
1254: imap_le_struct = emalloc(sizeof(pils));
1255: imap_le_struct->imap_stream = imap_stream;
1256: imap_le_struct->flags = cl_flags;
1257:
1258: ZEND_REGISTER_RESOURCE(return_value, imap_le_struct, le_imap);
1259: }
1260: /* }}} */
1261:
1262: /* {{{ proto resource imap_open(string mailbox, string user, string password [, int options [, int n_retries]])
1263: Open an IMAP stream to a mailbox */
1264: PHP_FUNCTION(imap_open)
1265: {
1266: php_imap_do_open(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
1267: }
1268: /* }}} */
1269:
1270: /* {{{ proto bool imap_reopen(resource stream_id, string mailbox [, int options [, int n_retries]])
1271: Reopen an IMAP stream to a new mailbox */
1272: PHP_FUNCTION(imap_reopen)
1273: {
1274: zval *streamind;
1275: char *mailbox;
1276: int mailbox_len;
1277: long options = 0, retries = 0;
1278: pils *imap_le_struct;
1279: MAILSTREAM *imap_stream;
1280: long flags=NIL;
1281: long cl_flags=NIL;
1282:
1283: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|ll", &streamind, &mailbox, &mailbox_len, &options, &retries) == FAILURE) {
1284: return;
1285: }
1286:
1287: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
1288:
1289: if (options) {
1290: flags = options;
1291: if (flags & PHP_EXPUNGE) {
1292: cl_flags = CL_EXPUNGE;
1293: flags ^= PHP_EXPUNGE;
1294: }
1295: imap_le_struct->flags = cl_flags;
1296: }
1297: #ifdef SET_MAXLOGINTRIALS
1298: if (retries) {
1299: mail_parameters(NIL, SET_MAXLOGINTRIALS, (void *) retries);
1300: }
1301: #endif
1302: /* local filename, need to perform open_basedir and safe_mode checks */
1303: if (mailbox[0] != '{' &&
1304: (php_check_open_basedir(mailbox TSRMLS_CC) ||
1305: (PG(safe_mode) && !php_checkuid(mailbox, NULL, CHECKUID_CHECK_FILE_AND_DIR)))) {
1306: RETURN_FALSE;
1307: }
1308:
1309: imap_stream = mail_open(imap_le_struct->imap_stream, mailbox, flags);
1310: if (imap_stream == NIL) {
1311: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Couldn't re-open stream");
1312: RETURN_FALSE;
1313: }
1314: imap_le_struct->imap_stream = imap_stream;
1315: RETURN_TRUE;
1316: }
1317: /* }}} */
1318:
1319: /* {{{ proto bool imap_append(resource stream_id, string folder, string message [, string options [, string internal_date]])
1320: Append a new message to a specified mailbox */
1321: PHP_FUNCTION(imap_append)
1322: {
1323: zval *streamind;
1324: char *folder, *message, *internal_date = NULL, *flags = NULL;
1325: int folder_len, message_len, internal_date_len = 0, flags_len = 0;
1326: pils *imap_le_struct;
1327: STRING st;
1328: char* regex = "/[0-3][0-9]-((Jan)|(Feb)|(Mar)|(Apr)|(May)|(Jun)|(Jul)|(Aug)|(Sep)|(Oct)|(Nov)|(Dec))-[0-9]{4} [0-2][0-9]:[0-5][0-9]:[0-5][0-9] [+-][0-9]{4}/";
1329: const int regex_len = strlen(regex);
1330: pcre_cache_entry *pce; /* Compiled regex */
1331: zval *subpats = NULL; /* Parts (not used) */
1332: long regex_flags = 0; /* Flags (not used) */
1333: long start_offset = 0; /* Start offset (not used) */
1334: int global = 0;
1335:
1336: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rss|ss", &streamind, &folder, &folder_len, &message, &message_len, &flags, &flags_len, &internal_date, &internal_date_len) == FAILURE) {
1337: return;
1338: }
1339:
1340: if (internal_date) {
1341: /* Make sure the given internal_date string matches the RFC specifiedformat */
1342: if ((pce = pcre_get_compiled_regex_cache(regex, regex_len TSRMLS_CC))== NULL) {
1343: RETURN_FALSE;
1344: }
1345:
1346: php_pcre_match_impl(pce, internal_date, internal_date_len, return_value, subpats, global,
1347: 0, regex_flags, start_offset TSRMLS_CC);
1348:
1349: if (!Z_LVAL_P(return_value)) {
1350: php_error_docref(NULL TSRMLS_CC, E_WARNING, "internal date not correctly formatted");
1351: internal_date = NULL;
1352: }
1353: }
1354:
1355: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
1356:
1357: INIT (&st, mail_string, (void *) message, message_len);
1358:
1359: if (mail_append_full(imap_le_struct->imap_stream, folder, (flags ? flags : NIL), (internal_date ? internal_date : NIL), &st)) {
1360: RETURN_TRUE;
1361: } else {
1362: RETURN_FALSE;
1363: }
1364: }
1365: /* }}} */
1366:
1367: /* {{{ proto int imap_num_msg(resource stream_id)
1368: Gives the number of messages in the current mailbox */
1369: PHP_FUNCTION(imap_num_msg)
1370: {
1371: zval *streamind;
1372: pils *imap_le_struct;
1373:
1374: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &streamind) == FAILURE) {
1375: return;
1376: }
1377:
1378: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
1379:
1380: RETURN_LONG(imap_le_struct->imap_stream->nmsgs);
1381: }
1382: /* }}} */
1383:
1384: /* {{{ proto bool imap_ping(resource stream_id)
1385: Check if the IMAP stream is still active */
1386: PHP_FUNCTION(imap_ping)
1387: {
1388: zval *streamind;
1389: pils *imap_le_struct;
1390:
1391: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &streamind) == FAILURE) {
1392: return;
1393: }
1394:
1395: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
1396:
1397: RETURN_BOOL(mail_ping(imap_le_struct->imap_stream));
1398: }
1399: /* }}} */
1400:
1401: /* {{{ proto int imap_num_recent(resource stream_id)
1402: Gives the number of recent messages in current mailbox */
1403: PHP_FUNCTION(imap_num_recent)
1404: {
1405: zval *streamind;
1406: pils *imap_le_struct;
1407:
1408: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &streamind) == FAILURE) {
1409: return;
1410: }
1411:
1412: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
1413:
1414: RETURN_LONG(imap_le_struct->imap_stream->recent);
1415: }
1416: /* }}} */
1417:
1418: #if defined(HAVE_IMAP2000) || defined(HAVE_IMAP2001)
1419: /* {{{ proto array imap_get_quota(resource stream_id, string qroot)
1420: Returns the quota set to the mailbox account qroot */
1421: PHP_FUNCTION(imap_get_quota)
1422: {
1423: zval *streamind;
1424: char *qroot;
1425: int qroot_len;
1426: pils *imap_le_struct;
1427:
1428: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &streamind, &qroot, &qroot_len) == FAILURE) {
1429: return;
1430: }
1431:
1432: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
1433:
1434: array_init(return_value);
1435: IMAPG(quota_return) = &return_value;
1436:
1437: /* set the callback for the GET_QUOTA function */
1438: mail_parameters(NIL, SET_QUOTA, (void *) mail_getquota);
1439: if (!imap_getquota(imap_le_struct->imap_stream, qroot)) {
1440: php_error_docref(NULL TSRMLS_CC, E_WARNING, "c-client imap_getquota failed");
1441: zval_dtor(return_value);
1442: RETURN_FALSE;
1443: }
1444: }
1445: /* }}} */
1446:
1447: /* {{{ proto array imap_get_quotaroot(resource stream_id, string mbox)
1448: Returns the quota set to the mailbox account mbox */
1449: PHP_FUNCTION(imap_get_quotaroot)
1450: {
1451: zval *streamind;
1452: char *mbox;
1453: int mbox_len;
1454: pils *imap_le_struct;
1455:
1456: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &streamind, &mbox, &mbox_len) == FAILURE) {
1457: return;
1458: }
1459:
1460: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
1461:
1462: array_init(return_value);
1463: IMAPG(quota_return) = &return_value;
1464:
1465: /* set the callback for the GET_QUOTAROOT function */
1466: mail_parameters(NIL, SET_QUOTA, (void *) mail_getquota);
1467: if (!imap_getquotaroot(imap_le_struct->imap_stream, mbox)) {
1468: php_error_docref(NULL TSRMLS_CC, E_WARNING, "c-client imap_getquotaroot failed");
1469: zval_dtor(return_value);
1470: RETURN_FALSE;
1471: }
1472: }
1473: /* }}} */
1474:
1475: /* {{{ proto bool imap_set_quota(resource stream_id, string qroot, int mailbox_size)
1476: Will set the quota for qroot mailbox */
1477: PHP_FUNCTION(imap_set_quota)
1478: {
1479: zval *streamind;
1480: char *qroot;
1481: int qroot_len;
1482: long mailbox_size;
1483: pils *imap_le_struct;
1484: STRINGLIST limits;
1485:
1486: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsl", &streamind, &qroot, &qroot_len, &mailbox_size) == FAILURE) {
1487: return;
1488: }
1489:
1490: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
1491:
1492: limits.text.data = "STORAGE";
1493: limits.text.size = mailbox_size;
1494: limits.next = NIL;
1495:
1496: RETURN_BOOL(imap_setquota(imap_le_struct->imap_stream, qroot, &limits));
1497: }
1498: /* }}} */
1499:
1500: /* {{{ proto bool imap_setacl(resource stream_id, string mailbox, string id, string rights)
1501: Sets the ACL for a given mailbox */
1502: PHP_FUNCTION(imap_setacl)
1503: {
1504: zval *streamind;
1505: char *mailbox, *id, *rights;
1506: int mailbox_len, id_len, rights_len;
1507: pils *imap_le_struct;
1508:
1509: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsss", &streamind, &mailbox, &mailbox_len, &id, &id_len, &rights, &rights_len) == FAILURE) {
1510: return;
1511: }
1512:
1513: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
1514:
1515: RETURN_BOOL(imap_setacl(imap_le_struct->imap_stream, mailbox, id, rights));
1516: }
1517: /* }}} */
1518:
1519: /* {{{ proto array imap_getacl(resource stream_id, string mailbox)
1520: Gets the ACL for a given mailbox */
1521: PHP_FUNCTION(imap_getacl)
1522: {
1523: zval *streamind;
1524: char *mailbox;
1525: int mailbox_len;
1526: pils *imap_le_struct;
1527:
1528: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &streamind, &mailbox, &mailbox_len) == FAILURE) {
1529: return;
1530: }
1531:
1532: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
1533:
1534: /* initializing the special array for the return values */
1535: array_init(return_value);
1536:
1537: IMAPG(imap_acl_list) = return_value;
1538:
1539: /* set the callback for the GET_ACL function */
1540: mail_parameters(NIL, SET_ACL, (void *) mail_getacl);
1541: if (!imap_getacl(imap_le_struct->imap_stream, mailbox)) {
1542: php_error(E_WARNING, "c-client imap_getacl failed");
1543: zval_dtor(return_value);
1544: RETURN_FALSE;
1545: }
1546:
1547: IMAPG(imap_acl_list) = NIL;
1548: }
1549: /* }}} */
1550: #endif /* HAVE_IMAP2000 || HAVE_IMAP2001 */
1551:
1552: /* {{{ proto bool imap_expunge(resource stream_id)
1553: Permanently delete all messages marked for deletion */
1554: PHP_FUNCTION(imap_expunge)
1555: {
1556: zval *streamind;
1557: pils *imap_le_struct;
1558:
1559: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &streamind) == FAILURE) {
1560: return;
1561: }
1562:
1563: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
1564:
1565: mail_expunge (imap_le_struct->imap_stream);
1566:
1567: RETURN_TRUE;
1568: }
1569: /* }}} */
1570:
1571: /* {{{ proto bool imap_gc(resource stream_id, int flags)
1572: This function garbage collects (purges) the cache of entries of a specific type. */
1573: PHP_FUNCTION(imap_gc)
1574: {
1575: zval *streamind;
1576: pils *imap_le_struct;
1577: long flags;
1578:
1579: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &streamind, &flags) == FAILURE) {
1580: return;
1581: }
1582:
1583: if (flags && ((flags & ~(GC_TEXTS | GC_ELT | GC_ENV)) != 0)) {
1584: php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid value for the flags parameter");
1585: RETURN_FALSE;
1586: }
1587:
1588: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
1589:
1590: mail_gc(imap_le_struct->imap_stream, flags);
1591:
1592: RETURN_TRUE;
1593: }
1594: /* }}} */
1595:
1596: /* {{{ proto bool imap_close(resource stream_id [, int options])
1597: Close an IMAP stream */
1598: PHP_FUNCTION(imap_close)
1599: {
1600: zval *streamind;
1601: pils *imap_le_struct=NULL;
1602: long options = 0, flags = NIL;
1603: int argc = ZEND_NUM_ARGS();
1604:
1605: if (zend_parse_parameters(argc TSRMLS_CC, "r|l", &streamind, &options) == FAILURE) {
1606: return;
1607: }
1608:
1609: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
1610:
1611: if (argc == 2) {
1612: flags = options;
1613:
1614: /* Check that flags is exactly equal to PHP_EXPUNGE or zero */
1615: if (flags && ((flags & ~PHP_EXPUNGE) != 0)) {
1616: php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid value for the flags parameter");
1617: RETURN_FALSE;
1618: }
1619:
1620: /* Do the translation from PHP's internal PHP_EXPUNGE define to c-client's CL_EXPUNGE */
1621: if (flags & PHP_EXPUNGE) {
1622: flags ^= PHP_EXPUNGE;
1623: flags |= CL_EXPUNGE;
1624: }
1625: imap_le_struct->flags = flags;
1626: }
1627:
1628: zend_list_delete(Z_RESVAL_P(streamind));
1629:
1630: RETURN_TRUE;
1631: }
1632: /* }}} */
1633:
1634: /* {{{ proto array imap_headers(resource stream_id)
1635: Returns headers for all messages in a mailbox */
1636: PHP_FUNCTION(imap_headers)
1637: {
1638: zval *streamind;
1639: pils *imap_le_struct;
1640: unsigned long i;
1641: char *t;
1642: unsigned int msgno;
1643: char tmp[MAILTMPLEN];
1644:
1645: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &streamind) == FAILURE) {
1646: return;
1647: }
1648:
1649: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
1650:
1651: /* Initialize return array */
1652: array_init(return_value);
1653:
1654: for (msgno = 1; msgno <= imap_le_struct->imap_stream->nmsgs; msgno++) {
1655: MESSAGECACHE * cache = mail_elt (imap_le_struct->imap_stream, msgno);
1656: mail_fetchstructure(imap_le_struct->imap_stream, msgno, NIL);
1657: tmp[0] = cache->recent ? (cache->seen ? 'R': 'N') : ' ';
1658: tmp[1] = (cache->recent | cache->seen) ? ' ' : 'U';
1659: tmp[2] = cache->flagged ? 'F' : ' ';
1660: tmp[3] = cache->answered ? 'A' : ' ';
1661: tmp[4] = cache->deleted ? 'D' : ' ';
1662: tmp[5] = cache->draft ? 'X' : ' ';
1663: snprintf(tmp + 6, sizeof(tmp) - 6, "%4ld) ", cache->msgno);
1664: mail_date(tmp+11, cache);
1665: tmp[22] = ' ';
1666: tmp[23] = '\0';
1667: mail_fetchfrom(tmp+23, imap_le_struct->imap_stream, msgno, (long)20);
1668: strcat(tmp, " ");
1669: if ((i = cache->user_flags)) {
1670: strcat(tmp, "{");
1671: while (i) {
1672: strlcat(tmp, imap_le_struct->imap_stream->user_flags[find_rightmost_bit (&i)], sizeof(tmp));
1673: if (i) strlcat(tmp, " ", sizeof(tmp));
1674: }
1675: strlcat(tmp, "} ", sizeof(tmp));
1676: }
1677: mail_fetchsubject(t = tmp + strlen(tmp), imap_le_struct->imap_stream, msgno, (long)25);
1678: snprintf(t += strlen(t), sizeof(tmp) - strlen(tmp), " (%ld chars)", cache->rfc822_size);
1679: add_next_index_string(return_value, tmp, 1);
1680: }
1681: }
1682: /* }}} */
1683:
1684: /* {{{ proto string imap_body(resource stream_id, int msg_no [, int options])
1685: Read the message body */
1686: PHP_FUNCTION(imap_body)
1687: {
1688: zval *streamind;
1689: long msgno, flags = 0;
1690: pils *imap_le_struct;
1691: int msgindex, argc = ZEND_NUM_ARGS();
1692: char *body;
1693: unsigned long body_len = 0;
1694:
1695: if (zend_parse_parameters(argc TSRMLS_CC, "rl|l", &streamind, &msgno, &flags) == FAILURE) {
1696: return;
1697: }
1698:
1699: if (flags && ((flags & ~(FT_UID|FT_PEEK|FT_INTERNAL)) != 0)) {
1700: php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid value for the options parameter");
1701: RETURN_FALSE;
1702: }
1703:
1704: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
1705:
1706: if ((argc == 3) && (flags & FT_UID)) {
1707: /* This should be cached; if it causes an extra RTT to the
1708: IMAP server, then that's the price we pay for making
1709: sure we don't crash. */
1710: msgindex = mail_msgno(imap_le_struct->imap_stream, msgno);
1711: } else {
1712: msgindex = msgno;
1713: }
1714: if ((msgindex < 1) || ((unsigned) msgindex > imap_le_struct->imap_stream->nmsgs)) {
1715: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Bad message number");
1716: RETURN_FALSE;
1717: }
1718:
1719: body = mail_fetchtext_full (imap_le_struct->imap_stream, msgno, &body_len, (argc == 3 ? flags : NIL));
1720: if (body_len == 0) {
1721: RETVAL_EMPTY_STRING();
1722: } else {
1723: RETVAL_STRINGL(body, body_len, 1);
1724: }
1725: }
1726: /* }}} */
1727:
1728: /* {{{ proto bool imap_mail_copy(resource stream_id, string msglist, string mailbox [, int options])
1729: Copy specified message to a mailbox */
1730: PHP_FUNCTION(imap_mail_copy)
1731: {
1732: zval *streamind;
1733: long options = 0;
1734: char *seq, *folder;
1735: int seq_len, folder_len, argc = ZEND_NUM_ARGS();
1736: pils *imap_le_struct;
1737:
1738: if (zend_parse_parameters(argc TSRMLS_CC, "rss|l", &streamind, &seq, &seq_len, &folder, &folder_len, &options) == FAILURE) {
1739: return;
1740: }
1741:
1742: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
1743:
1744: if (mail_copy_full(imap_le_struct->imap_stream, seq, folder, (argc == 4 ? options : NIL)) == T) {
1745: RETURN_TRUE;
1746: } else {
1747: RETURN_FALSE;
1748: }
1749: }
1750: /* }}} */
1751:
1752: /* {{{ proto bool imap_mail_move(resource stream_id, string sequence, string mailbox [, int options])
1753: Move specified message to a mailbox */
1754: PHP_FUNCTION(imap_mail_move)
1755: {
1756: zval *streamind;
1757: char *seq, *folder;
1758: int seq_len, folder_len;
1759: long options = 0;
1760: pils *imap_le_struct;
1761: int argc = ZEND_NUM_ARGS();
1762:
1763: if (zend_parse_parameters(argc TSRMLS_CC, "rss|l", &streamind, &seq, &seq_len, &folder, &folder_len, &options) == FAILURE) {
1764: return;
1765: }
1766:
1767: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
1768:
1769: if (mail_copy_full(imap_le_struct->imap_stream, seq, folder, (argc == 4 ? (options | CP_MOVE) : CP_MOVE)) == T) {
1770: RETURN_TRUE;
1771: } else {
1772: RETURN_FALSE;
1773: }
1774: }
1775: /* }}} */
1776:
1777: /* {{{ proto bool imap_createmailbox(resource stream_id, string mailbox)
1778: Create a new mailbox */
1779: PHP_FUNCTION(imap_createmailbox)
1780: {
1781: zval *streamind;
1782: char *folder;
1783: int folder_len;
1784: pils *imap_le_struct;
1785:
1786: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &streamind, &folder, &folder_len) == FAILURE) {
1787: return;
1788: }
1789:
1790: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
1791:
1792: if (mail_create(imap_le_struct->imap_stream, folder) == T) {
1793: RETURN_TRUE;
1794: } else {
1795: RETURN_FALSE;
1796: }
1797: }
1798: /* }}} */
1799:
1800: /* {{{ proto bool imap_renamemailbox(resource stream_id, string old_name, string new_name)
1801: Rename a mailbox */
1802: PHP_FUNCTION(imap_renamemailbox)
1803: {
1804: zval *streamind;
1805: char *old_mailbox, *new_mailbox;
1806: int old_mailbox_len, new_mailbox_len;
1807: pils *imap_le_struct;
1808:
1809: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rss", &streamind, &old_mailbox, &old_mailbox_len, &new_mailbox, &new_mailbox_len) == FAILURE) {
1810: return;
1811: }
1812:
1813: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
1814:
1815: if (mail_rename(imap_le_struct->imap_stream, old_mailbox, new_mailbox) == T) {
1816: RETURN_TRUE;
1817: } else {
1818: RETURN_FALSE;
1819: }
1820: }
1821: /* }}} */
1822:
1823: /* {{{ proto bool imap_deletemailbox(resource stream_id, string mailbox)
1824: Delete a mailbox */
1825: PHP_FUNCTION(imap_deletemailbox)
1826: {
1827: zval *streamind;
1828: char *folder;
1829: int folder_len;
1830: pils *imap_le_struct;
1831:
1832: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &streamind, &folder, &folder_len) == FAILURE) {
1833: return;
1834: }
1835:
1836: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
1837:
1838: if (mail_delete(imap_le_struct->imap_stream, folder) == T) {
1839: RETURN_TRUE;
1840: } else {
1841: RETURN_FALSE;
1842: }
1843: }
1844: /* }}} */
1845:
1846: /* {{{ proto array imap_list(resource stream_id, string ref, string pattern)
1847: Read the list of mailboxes */
1848: PHP_FUNCTION(imap_list)
1849: {
1850: zval *streamind;
1851: char *ref, *pat;
1852: int ref_len, pat_len;
1853: pils *imap_le_struct;
1854: STRINGLIST *cur=NIL;
1855:
1856: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rss", &streamind, &ref, &ref_len, &pat, &pat_len) == FAILURE) {
1857: return;
1858: }
1859:
1860: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
1861:
1862: /* set flag for normal, old mailbox list */
1863: IMAPG(folderlist_style) = FLIST_ARRAY;
1864:
1865: IMAPG(imap_folders) = IMAPG(imap_folders_tail) = NIL;
1866: mail_list(imap_le_struct->imap_stream, ref, pat);
1867: if (IMAPG(imap_folders) == NIL) {
1868: RETURN_FALSE;
1869: }
1870:
1871: array_init(return_value);
1872: cur=IMAPG(imap_folders);
1873: while (cur != NIL) {
1874: add_next_index_string(return_value, cur->LTEXT, 1);
1875: cur=cur->next;
1876: }
1877: mail_free_stringlist (&IMAPG(imap_folders));
1878: IMAPG(imap_folders) = IMAPG(imap_folders_tail) = NIL;
1879: }
1880:
1881: /* }}} */
1882:
1883: /* {{{ proto array imap_getmailboxes(resource stream_id, string ref, string pattern)
1884: Reads the list of mailboxes and returns a full array of objects containing name, attributes, and delimiter */
1885: /* Author: CJH */
1886: PHP_FUNCTION(imap_list_full)
1887: {
1888: zval *streamind, *mboxob;
1889: char *ref, *pat;
1890: int ref_len, pat_len;
1891: pils *imap_le_struct;
1892: FOBJECTLIST *cur=NIL;
1893: char *delim=NIL;
1894:
1895: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rss", &streamind, &ref, &ref_len, &pat, &pat_len) == FAILURE) {
1896: return;
1897: }
1898:
1899: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
1900:
1901: /* set flag for new, improved array of objects mailbox list */
1902: IMAPG(folderlist_style) = FLIST_OBJECT;
1903:
1904: IMAPG(imap_folder_objects) = IMAPG(imap_folder_objects_tail) = NIL;
1905: mail_list(imap_le_struct->imap_stream, ref, pat);
1906: if (IMAPG(imap_folder_objects) == NIL) {
1907: RETURN_FALSE;
1908: }
1909:
1910: array_init(return_value);
1911: delim = safe_emalloc(2, sizeof(char), 0);
1912: cur=IMAPG(imap_folder_objects);
1913: while (cur != NIL) {
1914: MAKE_STD_ZVAL(mboxob);
1915: object_init(mboxob);
1916: add_property_string(mboxob, "name", cur->LTEXT, 1);
1917: add_property_long(mboxob, "attributes", cur->attributes);
1918: #ifdef IMAP41
1919: delim[0] = (char)cur->delimiter;
1920: delim[1] = 0;
1921: add_property_string(mboxob, "delimiter", delim, 1);
1922: #else
1923: add_property_string(mboxob, "delimiter", cur->delimiter, 1);
1924: #endif
1925: add_next_index_object(return_value, mboxob TSRMLS_CC);
1926: cur=cur->next;
1927: }
1928: mail_free_foblist(&IMAPG(imap_folder_objects), &IMAPG(imap_folder_objects_tail));
1929: efree(delim);
1930: IMAPG(folderlist_style) = FLIST_ARRAY; /* reset to default */
1931: }
1932: /* }}} */
1933:
1934: /* {{{ proto array imap_listscan(resource stream_id, string ref, string pattern, string content)
1935: Read list of mailboxes containing a certain string */
1936: PHP_FUNCTION(imap_listscan)
1937: {
1938: zval *streamind;
1939: char *ref, *pat, *content;
1940: int ref_len, pat_len, content_len;
1941: pils *imap_le_struct;
1942: STRINGLIST *cur=NIL;
1943:
1944: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsss", &streamind, &ref, &ref_len, &pat, &pat_len, &content, &content_len) == FAILURE) {
1945: return;
1946: }
1947:
1948: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
1949:
1950: IMAPG(imap_folders) = NIL;
1951: mail_scan(imap_le_struct->imap_stream, ref, pat, content);
1952: if (IMAPG(imap_folders) == NIL) {
1953: RETURN_FALSE;
1954: }
1955:
1956: array_init(return_value);
1957: cur=IMAPG(imap_folders);
1958: while (cur != NIL) {
1959: add_next_index_string(return_value, cur->LTEXT, 1);
1960: cur=cur->next;
1961: }
1962: mail_free_stringlist (&IMAPG(imap_folders));
1963: IMAPG(imap_folders) = IMAPG(imap_folders_tail) = NIL;
1964: }
1965:
1966: /* }}} */
1967:
1968: /* {{{ proto object imap_check(resource stream_id)
1969: Get mailbox properties */
1970: PHP_FUNCTION(imap_check)
1971: {
1972: zval *streamind;
1973: pils *imap_le_struct;
1974: char date[100];
1975:
1976: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &streamind) == FAILURE) {
1977: return;
1978: }
1979:
1980: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
1981:
1982: if (mail_ping (imap_le_struct->imap_stream) == NIL) {
1983: RETURN_FALSE;
1984: }
1985:
1986: if (imap_le_struct->imap_stream && imap_le_struct->imap_stream->mailbox) {
1987: rfc822_date(date);
1988: object_init(return_value);
1989: add_property_string(return_value, "Date", date, 1);
1990: add_property_string(return_value, "Driver", imap_le_struct->imap_stream->dtb->name, 1);
1991: add_property_string(return_value, "Mailbox", imap_le_struct->imap_stream->mailbox, 1);
1992: add_property_long(return_value, "Nmsgs", imap_le_struct->imap_stream->nmsgs);
1993: add_property_long(return_value, "Recent", imap_le_struct->imap_stream->recent);
1994: } else {
1995: RETURN_FALSE;
1996: }
1997: }
1998: /* }}} */
1999:
2000: /* {{{ proto bool imap_delete(resource stream_id, int msg_no [, int options])
2001: Mark a message for deletion */
2002: PHP_FUNCTION(imap_delete)
2003: {
2004: zval *streamind, **sequence;
2005: pils *imap_le_struct;
2006: long flags = 0;
2007: int argc = ZEND_NUM_ARGS();
2008:
2009: if (zend_parse_parameters(argc TSRMLS_CC, "rZ|l", &streamind, &sequence, &flags) == FAILURE) {
2010: return;
2011: }
2012:
2013: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
2014:
2015: convert_to_string_ex(sequence);
2016:
2017: mail_setflag_full(imap_le_struct->imap_stream, Z_STRVAL_PP(sequence), "\\DELETED", (argc == 3 ? flags : NIL));
2018: RETVAL_TRUE;
2019: }
2020: /* }}} */
2021:
2022: /* {{{ proto bool imap_undelete(resource stream_id, int msg_no [, int flags])
2023: Remove the delete flag from a message */
2024: PHP_FUNCTION(imap_undelete)
2025: {
2026: zval *streamind, **sequence;
2027: long flags = 0;
2028: pils *imap_le_struct;
2029: int argc = ZEND_NUM_ARGS();
2030:
2031: if (zend_parse_parameters(argc TSRMLS_CC, "rZ|l", &streamind, &sequence, &flags) == FAILURE) {
2032: return;
2033: }
2034:
2035: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
2036:
2037: convert_to_string_ex(sequence);
2038:
2039: mail_clearflag_full(imap_le_struct->imap_stream, Z_STRVAL_PP(sequence), "\\DELETED", (argc == 3 ? flags : NIL));
2040: RETVAL_TRUE;
2041: }
2042: /* }}} */
2043:
2044: /* {{{ proto object imap_headerinfo(resource stream_id, int msg_no [, int from_length [, int subject_length [, string default_host]]])
2045: Read the headers of the message */
2046: PHP_FUNCTION(imap_headerinfo)
2047: {
2048: zval *streamind;
2049: char *defaulthost = NULL;
2050: int defaulthost_len = 0, argc = ZEND_NUM_ARGS();
2051: long msgno, fromlength, subjectlength;
2052: pils *imap_le_struct;
2053: MESSAGECACHE *cache;
2054: ENVELOPE *en;
2055: char dummy[2000], fulladdress[MAILTMPLEN + 1];
2056:
2057: if (zend_parse_parameters(argc TSRMLS_CC, "rl|lls", &streamind, &msgno, &fromlength, &subjectlength, &defaulthost, &defaulthost_len) == FAILURE) {
2058: return;
2059: }
2060:
2061: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
2062:
2063: if (argc >= 3) {
2064: if (fromlength < 0 || fromlength > MAILTMPLEN) {
2065: php_error_docref(NULL TSRMLS_CC, E_WARNING, "From length has to be between 0 and %d", MAILTMPLEN);
2066: RETURN_FALSE;
2067: }
2068: } else {
2069: fromlength = 0x00;
2070: }
2071: if (argc >= 4) {
2072: if (subjectlength < 0 || subjectlength > MAILTMPLEN) {
2073: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Subject length has to be between 0 and %d", MAILTMPLEN);
2074: RETURN_FALSE;
2075: }
2076: } else {
2077: subjectlength = 0x00;
2078: }
2079:
2080: PHP_IMAP_CHECK_MSGNO(msgno);
2081:
2082: if (mail_fetchstructure(imap_le_struct->imap_stream, msgno, NIL)) {
2083: cache = mail_elt(imap_le_struct->imap_stream, msgno);
2084: } else {
2085: RETURN_FALSE;
2086: }
2087:
2088: en = mail_fetchenvelope(imap_le_struct->imap_stream, msgno);
2089:
2090: /* call a function to parse all the text, so that we can use the
2091: same function to parse text from other sources */
2092: _php_make_header_object(return_value, en TSRMLS_CC);
2093:
2094: /* now run through properties that are only going to be returned
2095: from a server, not text headers */
2096: add_property_string(return_value, "Recent", cache->recent ? (cache->seen ? "R": "N") : " ", 1);
2097: add_property_string(return_value, "Unseen", (cache->recent | cache->seen) ? " " : "U", 1);
2098: add_property_string(return_value, "Flagged", cache->flagged ? "F" : " ", 1);
2099: add_property_string(return_value, "Answered", cache->answered ? "A" : " ", 1);
2100: add_property_string(return_value, "Deleted", cache->deleted ? "D" : " ", 1);
2101: add_property_string(return_value, "Draft", cache->draft ? "X" : " ", 1);
2102:
2103: snprintf(dummy, sizeof(dummy), "%4ld", cache->msgno);
2104: add_property_string(return_value, "Msgno", dummy, 1);
2105:
2106: mail_date(dummy, cache);
2107: add_property_string(return_value, "MailDate", dummy, 1);
2108:
2109: snprintf(dummy, sizeof(dummy), "%ld", cache->rfc822_size);
2110: add_property_string(return_value, "Size", dummy, 1);
2111:
2112: add_property_long(return_value, "udate", mail_longdate(cache));
2113:
2114: if (en->from && fromlength) {
2115: fulladdress[0] = 0x00;
2116: mail_fetchfrom(fulladdress, imap_le_struct->imap_stream, msgno, fromlength);
2117: add_property_string(return_value, "fetchfrom", fulladdress, 1);
2118: }
2119: if (en->subject && subjectlength) {
2120: fulladdress[0] = 0x00;
2121: mail_fetchsubject(fulladdress, imap_le_struct->imap_stream, msgno, subjectlength);
2122: add_property_string(return_value, "fetchsubject", fulladdress, 1);
2123: }
2124: }
2125: /* }}} */
2126:
2127: /* {{{ proto object imap_rfc822_parse_headers(string headers [, string default_host])
2128: Parse a set of mail headers contained in a string, and return an object similar to imap_headerinfo() */
2129: PHP_FUNCTION(imap_rfc822_parse_headers)
2130: {
2131: char *headers, *defaulthost = NULL;
2132: ENVELOPE *en;
2133: int headers_len, defaulthost_len = 0, argc = ZEND_NUM_ARGS();
2134:
2135: if (zend_parse_parameters(argc TSRMLS_CC, "s|s", &headers, &headers_len, &defaulthost, &defaulthost_len) == FAILURE) {
2136: return;
2137: }
2138:
2139: if (argc == 2) {
2140: rfc822_parse_msg(&en, NULL, headers, headers_len, NULL, defaulthost, NIL);
2141: } else {
2142: rfc822_parse_msg(&en, NULL, headers, headers_len, NULL, "UNKNOWN", NIL);
2143: }
2144:
2145: /* call a function to parse all the text, so that we can use the
2146: same function no matter where the headers are from */
2147: _php_make_header_object(return_value, en TSRMLS_CC);
2148: mail_free_envelope(&en);
2149: }
2150: /* }}} */
2151:
2152: /* KMLANG */
2153: /* {{{ proto array imap_lsub(resource stream_id, string ref, string pattern)
2154: Return a list of subscribed mailboxes */
2155: PHP_FUNCTION(imap_lsub)
2156: {
2157: zval *streamind;
2158: char *ref, *pat;
2159: int ref_len, pat_len;
2160: pils *imap_le_struct;
2161: STRINGLIST *cur=NIL;
2162:
2163: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rss", &streamind, &ref, &ref_len, &pat, &pat_len) == FAILURE) {
2164: return;
2165: }
2166:
2167: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
2168:
2169: /* set flag for normal, old mailbox list */
2170: IMAPG(folderlist_style) = FLIST_ARRAY;
2171:
2172: IMAPG(imap_sfolders) = NIL;
2173: mail_lsub(imap_le_struct->imap_stream, ref, pat);
2174: if (IMAPG(imap_sfolders) == NIL) {
2175: RETURN_FALSE;
2176: }
2177:
2178: array_init(return_value);
2179: cur=IMAPG(imap_sfolders);
2180: while (cur != NIL) {
2181: add_next_index_string(return_value, cur->LTEXT, 1);
2182: cur=cur->next;
2183: }
2184: mail_free_stringlist (&IMAPG(imap_sfolders));
2185: IMAPG(imap_sfolders) = IMAPG(imap_sfolders_tail) = NIL;
2186: }
2187: /* }}} */
2188:
2189: /* {{{ proto array imap_getsubscribed(resource stream_id, string ref, string pattern)
2190: Return a list of subscribed mailboxes, in the same format as imap_getmailboxes() */
2191: /* Author: CJH */
2192: PHP_FUNCTION(imap_lsub_full)
2193: {
2194: zval *streamind, *mboxob;
2195: char *ref, *pat;
2196: int ref_len, pat_len;
2197: pils *imap_le_struct;
2198: FOBJECTLIST *cur=NIL;
2199: char *delim=NIL;
2200:
2201: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rss", &streamind, &ref, &ref_len, &pat, &pat_len) == FAILURE) {
2202: return;
2203: }
2204:
2205: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
2206:
2207: /* set flag for new, improved array of objects list */
2208: IMAPG(folderlist_style) = FLIST_OBJECT;
2209:
2210: IMAPG(imap_sfolder_objects) = IMAPG(imap_sfolder_objects_tail) = NIL;
2211: mail_lsub(imap_le_struct->imap_stream, ref, pat);
2212: if (IMAPG(imap_sfolder_objects) == NIL) {
2213: RETURN_FALSE;
2214: }
2215:
2216: array_init(return_value);
2217: delim = safe_emalloc(2, sizeof(char), 0);
2218: cur=IMAPG(imap_sfolder_objects);
2219: while (cur != NIL) {
2220: MAKE_STD_ZVAL(mboxob);
2221: object_init(mboxob);
2222: add_property_string(mboxob, "name", cur->LTEXT, 1);
2223: add_property_long(mboxob, "attributes", cur->attributes);
2224: #ifdef IMAP41
2225: delim[0] = (char)cur->delimiter;
2226: delim[1] = 0;
2227: add_property_string(mboxob, "delimiter", delim, 1);
2228: #else
2229: add_property_string(mboxob, "delimiter", cur->delimiter, 1);
2230: #endif
2231: add_next_index_object(return_value, mboxob TSRMLS_CC);
2232: cur=cur->next;
2233: }
2234: mail_free_foblist (&IMAPG(imap_sfolder_objects), &IMAPG(imap_sfolder_objects_tail));
2235: efree(delim);
2236: IMAPG(folderlist_style) = FLIST_ARRAY; /* reset to default */
2237: }
2238: /* }}} */
2239:
2240: /* {{{ proto bool imap_subscribe(resource stream_id, string mailbox)
2241: Subscribe to a mailbox */
2242: PHP_FUNCTION(imap_subscribe)
2243: {
2244: zval *streamind;
2245: char *folder;
2246: int folder_len;
2247: pils *imap_le_struct;
2248:
2249: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &streamind, &folder, &folder_len) == FAILURE) {
2250: return;
2251: }
2252:
2253: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
2254:
2255: if (mail_subscribe(imap_le_struct->imap_stream, folder) == T) {
2256: RETURN_TRUE;
2257: } else {
2258: RETURN_FALSE;
2259: }
2260: }
2261: /* }}} */
2262:
2263: /* {{{ proto bool imap_unsubscribe(resource stream_id, string mailbox)
2264: Unsubscribe from a mailbox */
2265: PHP_FUNCTION(imap_unsubscribe)
2266: {
2267: zval *streamind;
2268: char *folder;
2269: int folder_len;
2270: pils *imap_le_struct;
2271:
2272: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &streamind, &folder, &folder_len) == FAILURE) {
2273: return;
2274: }
2275:
2276: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
2277:
2278: if (mail_unsubscribe(imap_le_struct->imap_stream, folder) == T) {
2279: RETURN_TRUE;
2280: } else {
2281: RETURN_FALSE;
2282: }
2283: }
2284: /* }}} */
2285:
2286: /* {{{ proto object imap_fetchstructure(resource stream_id, int msg_no [, int options])
2287: Read the full structure of a message */
2288: PHP_FUNCTION(imap_fetchstructure)
2289: {
2290: zval *streamind;
2291: long msgno, flags = 0;
2292: pils *imap_le_struct;
2293: BODY *body;
2294: int msgindex, argc = ZEND_NUM_ARGS();
2295:
2296: if (zend_parse_parameters(argc TSRMLS_CC, "rl|l", &streamind, &msgno, &flags) == FAILURE) {
2297: return;
2298: }
2299:
2300: if (flags && ((flags & ~FT_UID) != 0)) {
2301: php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid value for the options parameter");
2302: RETURN_FALSE;
2303: }
2304:
2305: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
2306:
2307: if (msgno < 1) {
2308: RETURN_FALSE;
2309: }
2310:
2311: object_init(return_value);
2312:
2313: if ((argc == 3) && (flags & FT_UID)) {
2314: /* This should be cached; if it causes an extra RTT to the
2315: IMAP server, then that's the price we pay for making
2316: sure we don't crash. */
2317: msgindex = mail_msgno(imap_le_struct->imap_stream, msgno);
2318: } else {
2319: msgindex = msgno;
2320: }
2321: PHP_IMAP_CHECK_MSGNO(msgindex);
2322:
2323: mail_fetchstructure_full(imap_le_struct->imap_stream, msgno, &body , (argc == 3 ? flags : NIL));
2324:
2325: if (!body) {
2326: php_error_docref(NULL TSRMLS_CC, E_WARNING, "No body information available");
2327: RETURN_FALSE;
2328: }
2329:
2330: _php_imap_add_body(return_value, body TSRMLS_CC);
2331: }
2332: /* }}} */
2333:
2334: /* {{{ proto string imap_fetchbody(resource stream_id, int msg_no, string section [, int options])
2335: Get a specific body section */
2336: PHP_FUNCTION(imap_fetchbody)
2337: {
2338: zval *streamind;
2339: long msgno, flags = 0;
2340: pils *imap_le_struct;
2341: char *body, *sec;
2342: int sec_len;
2343: unsigned long len;
2344: int argc = ZEND_NUM_ARGS();
2345:
2346: if (zend_parse_parameters(argc TSRMLS_CC, "rls|l", &streamind, &msgno, &sec, &sec_len, &flags) == FAILURE) {
2347: return;
2348: }
2349:
2350: if (flags && ((flags & ~(FT_UID|FT_PEEK|FT_INTERNAL)) != 0)) {
2351: php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid value for the options parameter");
2352: RETURN_FALSE;
2353: }
2354:
2355: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
2356:
2357: if (argc < 4 || !(flags & FT_UID)) {
2358: /* only perform the check if the msgno is a message number and not a UID */
2359: PHP_IMAP_CHECK_MSGNO(msgno);
2360: }
2361:
2362: body = mail_fetchbody_full(imap_le_struct->imap_stream, msgno, sec, &len, (argc == 4 ? flags : NIL));
2363:
2364: if (!body) {
2365: php_error_docref(NULL TSRMLS_CC, E_WARNING, "No body information available");
2366: RETURN_FALSE;
2367: }
2368: RETVAL_STRINGL(body, len, 1);
2369: }
2370:
2371: /* }}} */
2372:
2373:
2374: /* {{{ proto string imap_fetchmime(resource stream_id, int msg_no, string section [, int options])
2375: Get a specific body section's MIME headers */
2376: PHP_FUNCTION(imap_fetchmime)
2377: {
2378: zval *streamind;
2379: long msgno, flags = 0;
2380: pils *imap_le_struct;
2381: char *body, *sec;
2382: int sec_len;
2383: unsigned long len;
2384: int argc = ZEND_NUM_ARGS();
2385:
2386: if (zend_parse_parameters(argc TSRMLS_CC, "rls|l", &streamind, &msgno, &sec, &sec_len, &flags) == FAILURE) {
2387: return;
2388: }
2389:
2390: if (flags && ((flags & ~(FT_UID|FT_PEEK|FT_INTERNAL)) != 0)) {
2391: php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid value for the options parameter");
2392: RETURN_FALSE;
2393: }
2394:
2395: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
2396:
2397: if (argc < 4 || !(flags & FT_UID)) {
2398: /* only perform the check if the msgno is a message number and not a UID */
2399: PHP_IMAP_CHECK_MSGNO(msgno);
2400: }
2401:
2402: body = mail_fetch_mime(imap_le_struct->imap_stream, msgno, sec, &len, (argc == 4 ? flags : NIL));
2403:
2404: if (!body) {
2405: php_error_docref(NULL TSRMLS_CC, E_WARNING, "No body MIME information available");
2406: RETURN_FALSE;
2407: }
2408: RETVAL_STRINGL(body, len, 1);
2409: }
2410:
2411: /* }}} */
2412:
2413: /* {{{ proto bool imap_savebody(resource stream_id, string|resource file, int msg_no[, string section = ""[, int options = 0]])
2414: Save a specific body section to a file */
2415: PHP_FUNCTION(imap_savebody)
2416: {
2417: zval *stream, **out;
2418: pils *imap_ptr = NULL;
2419: php_stream *writer = NULL;
2420: char *section = "";
2421: int section_len = 0, close_stream = 1;
2422: long msgno, flags = 0;
2423:
2424: if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZl|sl", &stream, &out, &msgno, §ion, §ion_len, &flags)) {
2425: RETURN_FALSE;
2426: }
2427:
2428: ZEND_FETCH_RESOURCE(imap_ptr, pils *, &stream, -1, "imap", le_imap);
2429:
2430: if (!imap_ptr) {
2431: RETURN_FALSE;
2432: }
2433:
2434: switch (Z_TYPE_PP(out))
2435: {
2436: case IS_LONG:
2437: case IS_RESOURCE:
2438: close_stream = 0;
2439: php_stream_from_zval(writer, out);
2440: break;
2441:
2442: default:
2443: convert_to_string_ex(out);
2444: writer = php_stream_open_wrapper(Z_STRVAL_PP(out), "wb", REPORT_ERRORS|ENFORCE_SAFE_MODE, NULL);
2445: break;
2446: }
2447:
2448: if (!writer) {
2449: RETURN_FALSE;
2450: }
2451:
2452: IMAPG(gets_stream) = writer;
2453: mail_parameters(NIL, SET_GETS, (void *) php_mail_gets);
2454: mail_fetchbody_full(imap_ptr->imap_stream, msgno, section, NULL, flags);
2455: mail_parameters(NIL, SET_GETS, (void *) NULL);
2456: IMAPG(gets_stream) = NULL;
2457:
2458: if (close_stream) {
2459: php_stream_close(writer);
2460: }
2461:
2462: RETURN_TRUE;
2463: }
2464: /* }}} */
2465:
2466: /* {{{ proto string imap_base64(string text)
2467: Decode BASE64 encoded text */
2468: PHP_FUNCTION(imap_base64)
2469: {
2470: char *text, *decode;
2471: int text_len;
2472: unsigned long newlength;
2473:
2474: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &text, &text_len) == FAILURE) {
2475: return;
2476: }
2477:
2478: decode = (char *) rfc822_base64((unsigned char *) text, text_len, &newlength);
2479:
2480: if (decode == NULL) {
2481: RETURN_FALSE;
2482: }
2483:
2484: RETVAL_STRINGL(decode, newlength, 1);
2485: fs_give((void**) &decode);
2486: }
2487: /* }}} */
2488:
2489: /* {{{ proto string imap_qprint(string text)
2490: Convert a quoted-printable string to an 8-bit string */
2491: PHP_FUNCTION(imap_qprint)
2492: {
2493: char *text, *decode;
2494: int text_len;
2495: unsigned long newlength;
2496:
2497: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &text, &text_len) == FAILURE) {
2498: return;
2499: }
2500:
2501: decode = (char *) rfc822_qprint((unsigned char *) text, text_len, &newlength);
2502:
2503: if (decode == NULL) {
2504: RETURN_FALSE;
2505: }
2506:
2507: RETVAL_STRINGL(decode, newlength, 1);
2508: fs_give((void**) &decode);
2509: }
2510: /* }}} */
2511:
2512: /* {{{ proto string imap_8bit(string text)
2513: Convert an 8-bit string to a quoted-printable string */
2514: PHP_FUNCTION(imap_8bit)
2515: {
2516: char *text, *decode;
2517: int text_len;
2518: unsigned long newlength;
2519:
2520: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &text, &text_len) == FAILURE) {
2521: return;
2522: }
2523:
2524: decode = (char *) rfc822_8bit((unsigned char *) text, text_len, &newlength);
2525:
2526: if (decode == NULL) {
2527: RETURN_FALSE;
2528: }
2529:
2530: RETVAL_STRINGL(decode, newlength, 1);
2531: fs_give((void**) &decode);
2532: }
2533: /* }}} */
2534:
2535: /* {{{ proto string imap_binary(string text)
2536: Convert an 8bit string to a base64 string */
2537: PHP_FUNCTION(imap_binary)
2538: {
2539: char *text, *decode;
2540: int text_len;
2541: unsigned long newlength;
2542:
2543: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &text, &text_len) == FAILURE) {
2544: return;
2545: }
2546:
2547: decode = rfc822_binary(text, text_len, &newlength);
2548:
2549: if (decode == NULL) {
2550: RETURN_FALSE;
2551: }
2552:
2553: RETVAL_STRINGL(decode, newlength, 1);
2554: fs_give((void**) &decode);
2555: }
2556: /* }}} */
2557:
2558: /* {{{ proto object imap_mailboxmsginfo(resource stream_id)
2559: Returns info about the current mailbox */
2560: PHP_FUNCTION(imap_mailboxmsginfo)
2561: {
2562: zval *streamind;
2563: pils *imap_le_struct;
2564: char date[100];
2565: unsigned int msgno, unreadmsg, deletedmsg, msize;
2566:
2567: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &streamind) == FAILURE) {
2568: return;
2569: }
2570:
2571: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
2572:
2573: /* Initialize return object */
2574: object_init(return_value);
2575:
2576: unreadmsg = 0;
2577: deletedmsg = 0;
2578: msize = 0;
2579:
2580: for (msgno = 1; msgno <= imap_le_struct->imap_stream->nmsgs; msgno++) {
2581: MESSAGECACHE * cache = mail_elt (imap_le_struct->imap_stream, msgno);
2582: mail_fetchstructure (imap_le_struct->imap_stream, msgno, NIL);
2583:
2584: if (!cache->seen || cache->recent) {
2585: unreadmsg++;
2586: }
2587:
2588: if (cache->deleted) {
2589: deletedmsg++;
2590: }
2591: msize = msize + cache->rfc822_size;
2592: }
2593: add_property_long(return_value, "Unread", unreadmsg);
2594: add_property_long(return_value, "Deleted", deletedmsg);
2595: add_property_long(return_value, "Nmsgs", imap_le_struct->imap_stream->nmsgs);
2596: add_property_long(return_value, "Size", msize);
2597: rfc822_date(date);
2598: add_property_string(return_value, "Date", date, 1);
2599: add_property_string(return_value, "Driver", imap_le_struct->imap_stream->dtb->name, 1);
2600: add_property_string(return_value, "Mailbox", imap_le_struct->imap_stream->mailbox, 1);
2601: add_property_long(return_value, "Recent", imap_le_struct->imap_stream->recent);
2602: }
2603: /* }}} */
2604:
2605: /* {{{ proto string imap_rfc822_write_address(string mailbox, string host, string personal)
2606: Returns a properly formatted email address given the mailbox, host, and personal info */
2607: PHP_FUNCTION(imap_rfc822_write_address)
2608: {
2609: char *mailbox, *host, *personal;
2610: int mailbox_len, host_len, personal_len;
2611: ADDRESS *addr;
2612: char *string;
2613:
2614: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sss", &mailbox, &mailbox_len, &host, &host_len, &personal, &personal_len) == FAILURE) {
2615: return;
2616: }
2617:
2618: addr=mail_newaddr();
2619:
2620: if (mailbox) {
2621: addr->mailbox = cpystr(mailbox);
2622: }
2623:
2624: if (host) {
2625: addr->host = cpystr(host);
2626: }
2627:
2628: if (personal) {
2629: addr->personal = cpystr(personal);
2630: }
2631:
2632: addr->next=NIL;
2633: addr->error=NIL;
2634: addr->adl=NIL;
2635:
2636: string = _php_rfc822_write_address(addr TSRMLS_CC);
2637: if (string) {
2638: RETVAL_STRING(string, 0);
2639: } else {
2640: RETURN_FALSE;
2641: }
2642: }
2643: /* }}} */
2644:
2645: /* {{{ proto array imap_rfc822_parse_adrlist(string address_string, string default_host)
2646: Parses an address string */
2647: PHP_FUNCTION(imap_rfc822_parse_adrlist)
2648: {
2649: zval *tovals;
2650: char *str, *defaulthost, *str_copy;
2651: int str_len, defaulthost_len;
2652: ADDRESS *addresstmp;
2653: ENVELOPE *env;
2654:
2655: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &str, &str_len, &defaulthost, &defaulthost_len) == FAILURE) {
2656: return;
2657: }
2658:
2659: env = mail_newenvelope();
2660:
2661: /* rfc822_parse_adrlist() modifies passed string. Copy it. */
2662: str_copy = estrndup(str, str_len);
2663: rfc822_parse_adrlist(&env->to, str_copy, defaulthost);
2664: efree(str_copy);
2665:
2666: array_init(return_value);
2667:
2668: addresstmp = env->to;
2669:
2670: if (addresstmp) do {
2671: MAKE_STD_ZVAL(tovals);
2672: object_init(tovals);
2673: if (addresstmp->mailbox) {
2674: add_property_string(tovals, "mailbox", addresstmp->mailbox, 1);
2675: }
2676: if (addresstmp->host) {
2677: add_property_string(tovals, "host", addresstmp->host, 1);
2678: }
2679: if (addresstmp->personal) {
2680: add_property_string(tovals, "personal", addresstmp->personal, 1);
2681: }
2682: if (addresstmp->adl) {
2683: add_property_string(tovals, "adl", addresstmp->adl, 1);
2684: }
2685: add_next_index_object(return_value, tovals TSRMLS_CC);
2686: } while ((addresstmp = addresstmp->next));
2687:
2688: mail_free_envelope(&env);
2689: }
2690: /* }}} */
2691:
2692: /* {{{ proto string imap_utf8(string mime_encoded_text)
2693: Convert a mime-encoded text to UTF-8 */
2694: PHP_FUNCTION(imap_utf8)
2695: {
2696: char *str;
2697: int str_len;
2698: SIZEDTEXT src, dest;
2699:
2700: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {
2701: return;
2702: }
2703:
2704: src.data = NULL;
2705: src.size = 0;
2706: dest.data = NULL;
2707: dest.size = 0;
2708:
2709: cpytxt(&src, str, str_len);
2710:
2711: #ifndef HAVE_NEW_MIME2TEXT
2712: utf8_mime2text(&src, &dest);
2713: #else
2714: utf8_mime2text(&src, &dest, U8T_DECOMPOSE);
2715: #endif
2716: RETVAL_STRINGL(dest.data, dest.size, 1);
2717: if (dest.data) {
2718: free(dest.data);
2719: }
2720: if (src.data && src.data != dest.data) {
2721: free(src.data);
2722: }
2723: }
2724: /* }}} */
2725:
2726: /* {{{ macros for the modified utf7 conversion functions
2727: *
2728: * author: Andrew Skalski <askalski@chek.com>
2729: */
2730:
2731: /* tests `c' and returns true if it is a special character */
2732: #define SPECIAL(c) ((c) <= 0x1f || (c) >= 0x7f)
2733:
2734: /* validate a modified-base64 character */
2735: #define B64CHAR(c) (isalnum(c) || (c) == '+' || (c) == ',')
2736:
2737: /* map the low 64 bits of `n' to the modified-base64 characters */
2738: #define B64(n) ("ABCDEFGHIJKLMNOPQRSTUVWXYZ" \
2739: "abcdefghijklmnopqrstuvwxyz0123456789+,"[(n) & 0x3f])
2740:
2741: /* map the modified-base64 character `c' to its 64 bit value */
2742: #define UNB64(c) ((c) == '+' ? 62 : (c) == ',' ? 63 : (c) >= 'a' ? \
2743: (c) - 71 : (c) >= 'A' ? (c) - 65 : (c) + 4)
2744: /* }}} */
2745:
2746: /* {{{ proto string imap_utf7_decode(string buf)
2747: Decode a modified UTF-7 string */
2748: PHP_FUNCTION(imap_utf7_decode)
2749: {
2750: /* author: Andrew Skalski <askalski@chek.com> */
2751: char *arg;
2752: const unsigned char *in, *inp, *endp;
2753: unsigned char *out, *outp;
2754: unsigned char c;
2755: int arg_len, inlen, outlen;
2756: enum {
2757: ST_NORMAL, /* printable text */
2758: ST_DECODE0, /* encoded text rotation... */
2759: ST_DECODE1,
2760: ST_DECODE2,
2761: ST_DECODE3
2762: } state;
2763:
2764: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &arg, &arg_len) == FAILURE) {
2765: return;
2766: }
2767:
2768: in = (const unsigned char *) arg;
2769: inlen = arg_len;
2770:
2771: /* validate and compute length of output string */
2772: outlen = 0;
2773: state = ST_NORMAL;
2774: for (endp = (inp = in) + inlen; inp < endp; inp++) {
2775: if (state == ST_NORMAL) {
2776: /* process printable character */
2777: if (SPECIAL(*inp)) {
2778: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid modified UTF-7 character: `%c'", *inp);
2779: RETURN_FALSE;
2780: } else if (*inp != '&') {
2781: outlen++;
2782: } else if (inp + 1 == endp) {
2783: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unexpected end of string");
2784: RETURN_FALSE;
2785: } else if (inp[1] != '-') {
2786: state = ST_DECODE0;
2787: } else {
2788: outlen++;
2789: inp++;
2790: }
2791: } else if (*inp == '-') {
2792: /* return to NORMAL mode */
2793: if (state == ST_DECODE1) {
2794: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Stray modified base64 character: `%c'", *--inp);
2795: RETURN_FALSE;
2796: }
2797: state = ST_NORMAL;
2798: } else if (!B64CHAR(*inp)) {
2799: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid modified base64 character: `%c'", *inp);
2800: RETURN_FALSE;
2801: } else {
2802: switch (state) {
2803: case ST_DECODE3:
2804: outlen++;
2805: state = ST_DECODE0;
2806: break;
2807: case ST_DECODE2:
2808: case ST_DECODE1:
2809: outlen++;
2810: case ST_DECODE0:
2811: state++;
2812: case ST_NORMAL:
2813: break;
2814: }
2815: }
2816: }
2817:
2818: /* enforce end state */
2819: if (state != ST_NORMAL) {
2820: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unexpected end of string");
2821: RETURN_FALSE;
2822: }
2823:
2824: /* allocate output buffer */
2825: out = emalloc(outlen + 1);
2826:
2827: /* decode input string */
2828: outp = out;
2829: state = ST_NORMAL;
2830: for (endp = (inp = in) + inlen; inp < endp; inp++) {
2831: if (state == ST_NORMAL) {
2832: if (*inp == '&' && inp[1] != '-') {
2833: state = ST_DECODE0;
2834: }
2835: else if ((*outp++ = *inp) == '&') {
2836: inp++;
2837: }
2838: }
2839: else if (*inp == '-') {
2840: state = ST_NORMAL;
2841: }
2842: else {
2843: /* decode input character */
2844: switch (state) {
2845: case ST_DECODE0:
2846: *outp = UNB64(*inp) << 2;
2847: state = ST_DECODE1;
2848: break;
2849: case ST_DECODE1:
2850: outp[1] = UNB64(*inp);
2851: c = outp[1] >> 4;
2852: *outp++ |= c;
2853: *outp <<= 4;
2854: state = ST_DECODE2;
2855: break;
2856: case ST_DECODE2:
2857: outp[1] = UNB64(*inp);
2858: c = outp[1] >> 2;
2859: *outp++ |= c;
2860: *outp <<= 6;
2861: state = ST_DECODE3;
2862: break;
2863: case ST_DECODE3:
2864: *outp++ |= UNB64(*inp);
2865: state = ST_DECODE0;
2866: case ST_NORMAL:
2867: break;
2868: }
2869: }
2870: }
2871:
2872: *outp = 0;
2873:
2874: #if PHP_DEBUG
2875: /* warn if we computed outlen incorrectly */
2876: if (outp - out != outlen) {
2877: php_error_docref(NULL TSRMLS_CC, E_WARNING, "outp - out [%ld] != outlen [%d]", outp - out, outlen);
2878: }
2879: #endif
2880:
2881: RETURN_STRINGL(out, outlen, 0);
2882: }
2883: /* }}} */
2884:
2885: /* {{{ proto string imap_utf7_encode(string buf)
2886: Encode a string in modified UTF-7 */
2887: PHP_FUNCTION(imap_utf7_encode)
2888: {
2889: /* author: Andrew Skalski <askalski@chek.com> */
2890: char *arg;
2891: const unsigned char *in, *inp, *endp;
2892: unsigned char *out, *outp;
2893: unsigned char c;
2894: int arg_len, inlen, outlen;
2895: enum {
2896: ST_NORMAL, /* printable text */
2897: ST_ENCODE0, /* encoded text rotation... */
2898: ST_ENCODE1,
2899: ST_ENCODE2
2900: } state;
2901:
2902: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &arg, &arg_len) == FAILURE) {
2903: return;
2904: }
2905:
2906: in = (const unsigned char *) arg;
2907: inlen = arg_len;
2908:
2909: /* compute the length of the result string */
2910: outlen = 0;
2911: state = ST_NORMAL;
2912: endp = (inp = in) + inlen;
2913: while (inp < endp) {
2914: if (state == ST_NORMAL) {
2915: if (SPECIAL(*inp)) {
2916: state = ST_ENCODE0;
2917: outlen++;
2918: } else if (*inp++ == '&') {
2919: outlen++;
2920: }
2921: outlen++;
2922: } else if (!SPECIAL(*inp)) {
2923: state = ST_NORMAL;
2924: } else {
2925: /* ST_ENCODE0 -> ST_ENCODE1 - two chars
2926: * ST_ENCODE1 -> ST_ENCODE2 - one char
2927: * ST_ENCODE2 -> ST_ENCODE0 - one char
2928: */
2929: if (state == ST_ENCODE2) {
2930: state = ST_ENCODE0;
2931: }
2932: else if (state++ == ST_ENCODE0) {
2933: outlen++;
2934: }
2935: outlen++;
2936: inp++;
2937: }
2938: }
2939:
2940: /* allocate output buffer */
2941: out = emalloc(outlen + 1);
2942:
2943: /* encode input string */
2944: outp = out;
2945: state = ST_NORMAL;
2946: endp = (inp = in) + inlen;
2947: while (inp < endp || state != ST_NORMAL) {
2948: if (state == ST_NORMAL) {
2949: if (SPECIAL(*inp)) {
2950: /* begin encoding */
2951: *outp++ = '&';
2952: state = ST_ENCODE0;
2953: } else if ((*outp++ = *inp++) == '&') {
2954: *outp++ = '-';
2955: }
2956: } else if (inp == endp || !SPECIAL(*inp)) {
2957: /* flush overflow and terminate region */
2958: if (state != ST_ENCODE0) {
2959: c = B64(*outp);
2960: *outp++ = c;
2961: }
2962: *outp++ = '-';
2963: state = ST_NORMAL;
2964: } else {
2965: /* encode input character */
2966: switch (state) {
2967: case ST_ENCODE0:
2968: *outp++ = B64(*inp >> 2);
2969: *outp = *inp++ << 4;
2970: state = ST_ENCODE1;
2971: break;
2972: case ST_ENCODE1:
2973: c = B64(*outp | *inp >> 4);
2974: *outp++ = c;
2975: *outp = *inp++ << 2;
2976: state = ST_ENCODE2;
2977: break;
2978: case ST_ENCODE2:
2979: c = B64(*outp | *inp >> 6);
2980: *outp++ = c;
2981: *outp++ = B64(*inp++);
2982: state = ST_ENCODE0;
2983: case ST_NORMAL:
2984: break;
2985: }
2986: }
2987: }
2988:
2989: *outp = 0;
2990:
2991: #if PHP_DEBUG
2992: /* warn if we computed outlen incorrectly */
2993: if (outp - out != outlen) {
2994: php_error_docref(NULL TSRMLS_CC, E_WARNING, "outp - out [%ld] != outlen [%d]", outp - out, outlen);
2995: }
2996: #endif
2997:
2998: RETURN_STRINGL(out, outlen, 0);
2999: }
3000: /* }}} */
3001:
3002: #undef SPECIAL
3003: #undef B64CHAR
3004: #undef B64
3005: #undef UNB64
3006:
3007: #ifdef HAVE_IMAP_MUTF7
3008: static void php_imap_mutf7(INTERNAL_FUNCTION_PARAMETERS, int mode) /* {{{ */
3009: {
3010: char *in;
3011: int in_len;
3012: unsigned char *out;
3013:
3014: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &in, &in_len) == FAILURE) {
3015: return;
3016: }
3017:
3018: if (in_len < 1) {
3019: RETURN_EMPTY_STRING();
3020: }
3021:
3022: if (mode == 0) {
3023: out = utf8_to_mutf7((unsigned char *) in);
3024: } else {
3025: out = utf8_from_mutf7((unsigned char *) in);
3026: }
3027:
3028: if (out == NIL) {
3029: RETURN_FALSE;
3030: } else {
3031: RETURN_STRING((char *)out, 1);
3032: }
3033: }
3034: /* }}} */
3035:
3036: /* {{{ proto string imap_utf8_to_mutf7(string in)
3037: Encode a UTF-8 string to modified UTF-7 */
3038: PHP_FUNCTION(imap_utf8_to_mutf7)
3039: {
3040: php_imap_mutf7(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
3041: }
3042: /* }}} */
3043:
3044: /* {{{ proto string imap_mutf7_to_utf8(string in)
3045: Decode a modified UTF-7 string to UTF-8 */
3046: PHP_FUNCTION(imap_mutf7_to_utf8)
3047: {
3048: php_imap_mutf7(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
3049: }
3050: /* }}} */
3051: #endif
3052:
3053: /* {{{ proto bool imap_setflag_full(resource stream_id, string sequence, string flag [, int options])
3054: Sets flags on messages */
3055: PHP_FUNCTION(imap_setflag_full)
3056: {
3057: zval *streamind;
3058: char *sequence, *flag;
3059: int sequence_len, flag_len;
3060: long flags = 0;
3061: pils *imap_le_struct;
3062:
3063: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rss|l", &streamind, &sequence, &sequence_len, &flag, &flag_len, &flags) == FAILURE) {
3064: return;
3065: }
3066:
3067: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
3068:
3069: mail_setflag_full(imap_le_struct->imap_stream, sequence, flag, (flags ? flags : NIL));
3070: RETURN_TRUE;
3071: }
3072: /* }}} */
3073:
3074: /* {{{ proto bool imap_clearflag_full(resource stream_id, string sequence, string flag [, int options])
3075: Clears flags on messages */
3076: PHP_FUNCTION(imap_clearflag_full)
3077: {
3078: zval *streamind;
3079: char *sequence, *flag;
3080: int sequence_len, flag_len;
3081: long flags = 0;
3082: pils *imap_le_struct;
3083: int argc = ZEND_NUM_ARGS();
3084:
3085: if (zend_parse_parameters(argc TSRMLS_CC, "rss|l", &streamind, &sequence, &sequence_len, &flag, &flag_len, &flags) ==FAILURE) {
3086: return;
3087: }
3088:
3089: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
3090:
3091: mail_clearflag_full(imap_le_struct->imap_stream, sequence, flag, (argc == 4 ? flags : NIL));
3092: RETURN_TRUE;
3093: }
3094: /* }}} */
3095:
3096: /* {{{ proto array imap_sort(resource stream_id, int criteria, int reverse [, int options [, string search_criteria [, string charset]]])
3097: Sort an array of message headers, optionally including only messages that meet specified criteria. */
3098: PHP_FUNCTION(imap_sort)
3099: {
3100: zval *streamind;
3101: char *criteria = NULL, *charset = NULL;
3102: int criteria_len, charset_len;
3103: long pgm, rev, flags = 0;
3104: pils *imap_le_struct;
3105: unsigned long *slst, *sl;
3106: char *search_criteria;
3107: SORTPGM *mypgm=NIL;
3108: SEARCHPGM *spg=NIL;
3109: int argc = ZEND_NUM_ARGS();
3110:
3111: if (zend_parse_parameters(argc TSRMLS_CC, "rll|lss", &streamind, &pgm, &rev, &flags, &criteria, &criteria_len, &charset, &charset_len) == FAILURE) {
3112: return;
3113: }
3114:
3115: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
3116:
3117: if (pgm > SORTSIZE) {
3118: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unrecognized sort criteria");
3119: RETURN_FALSE;
3120: }
3121: if (argc >= 4) {
3122: if (flags < 0) {
3123: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Search options parameter has to be greater than or equal to 0");
3124: RETURN_FALSE;
3125: }
3126: }
3127: if (argc >= 5) {
3128: search_criteria = estrndup(criteria, criteria_len);
3129: spg = mail_criteria(search_criteria);
3130: efree(search_criteria);
3131: } else {
3132: spg = mail_newsearchpgm();
3133: }
3134:
3135: mypgm = mail_newsortpgm();
3136: mypgm->reverse = rev;
3137: mypgm->function = (short) pgm;
3138: mypgm->next = NIL;
3139:
3140: slst = mail_sort(imap_le_struct->imap_stream, (argc == 6 ? charset : NIL), spg, mypgm, (argc >= 4 ? flags : NIL));
3141:
3142: if (spg && !(flags & SE_FREE)) {
3143: mail_free_searchpgm(&spg);
3144: }
3145:
3146: array_init(return_value);
3147: if (slst != NIL && slst != 0) {
3148: for (sl = slst; *sl; sl++) {
3149: add_next_index_long(return_value, *sl);
3150: }
3151: fs_give ((void **) &slst);
3152: }
3153: }
3154: /* }}} */
3155:
3156: /* {{{ proto string imap_fetchheader(resource stream_id, int msg_no [, int options])
3157: Get the full unfiltered header for a message */
3158: PHP_FUNCTION(imap_fetchheader)
3159: {
3160: zval *streamind;
3161: long msgno, flags=0L;
3162: pils *imap_le_struct;
3163: int msgindex, argc = ZEND_NUM_ARGS();
3164:
3165: if (zend_parse_parameters(argc TSRMLS_CC, "rl|l", &streamind, &msgno, &flags) == FAILURE) {
3166: return;
3167: }
3168:
3169: if (flags && ((flags & ~(FT_UID|FT_INTERNAL|FT_PREFETCHTEXT)) != 0)) {
3170: php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid value for the options parameter");
3171: RETURN_FALSE;
3172: }
3173:
3174: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
3175:
3176: if ((argc == 3) && (flags & FT_UID)) {
3177: /* This should be cached; if it causes an extra RTT to the
3178: IMAP server, then that's the price we pay for making sure
3179: we don't crash. */
3180: msgindex = mail_msgno(imap_le_struct->imap_stream, msgno);
3181: } else {
3182: msgindex = msgno;
3183: }
3184:
3185: PHP_IMAP_CHECK_MSGNO(msgindex);
3186:
3187: RETVAL_STRING(mail_fetchheader_full(imap_le_struct->imap_stream, msgno, NIL, NIL, (argc == 3 ? flags : NIL)), 1);
3188: }
3189: /* }}} */
3190:
3191: /* {{{ proto int imap_uid(resource stream_id, int msg_no)
3192: Get the unique message id associated with a standard sequential message number */
3193: PHP_FUNCTION(imap_uid)
3194: {
3195: zval *streamind;
3196: long msgno;
3197: pils *imap_le_struct;
3198: int msgindex;
3199:
3200: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &streamind, &msgno) == FAILURE) {
3201: return;
3202: }
3203:
3204: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
3205:
3206: msgindex = msgno;
3207: if ((msgindex < 1) || ((unsigned) msgindex > imap_le_struct->imap_stream->nmsgs)) {
3208: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Bad message number");
3209: RETURN_FALSE;
3210: }
3211:
3212: RETURN_LONG(mail_uid(imap_le_struct->imap_stream, msgno));
3213: }
3214: /* }}} */
3215:
3216: /* {{{ proto int imap_msgno(resource stream_id, int unique_msg_id)
3217: Get the sequence number associated with a UID */
3218: PHP_FUNCTION(imap_msgno)
3219: {
3220: zval *streamind;
3221: long msgno;
3222: pils *imap_le_struct;
3223:
3224: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &streamind, &msgno) == FAILURE) {
3225: return;
3226: }
3227:
3228: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
3229:
3230: RETURN_LONG(mail_msgno(imap_le_struct->imap_stream, msgno));
3231: }
3232: /* }}} */
3233:
3234: /* {{{ proto object imap_status(resource stream_id, string mailbox, int options)
3235: Get status info from a mailbox */
3236: PHP_FUNCTION(imap_status)
3237: {
3238: zval *streamind;
3239: char *mbx;
3240: int mbx_len;
3241: long flags;
3242: pils *imap_le_struct;
3243:
3244: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsl", &streamind, &mbx, &mbx_len, &flags) == FAILURE) {
3245: return;
3246: }
3247:
3248: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
3249:
3250: object_init(return_value);
3251:
3252: if (mail_status(imap_le_struct->imap_stream, mbx, flags)) {
3253: add_property_long(return_value, "flags", IMAPG(status_flags));
3254: if (IMAPG(status_flags) & SA_MESSAGES) {
3255: add_property_long(return_value, "messages", IMAPG(status_messages));
3256: }
3257: if (IMAPG(status_flags) & SA_RECENT) {
3258: add_property_long(return_value, "recent", IMAPG(status_recent));
3259: }
3260: if (IMAPG(status_flags) & SA_UNSEEN) {
3261: add_property_long(return_value, "unseen", IMAPG(status_unseen));
3262: }
3263: if (IMAPG(status_flags) & SA_UIDNEXT) {
3264: add_property_long(return_value, "uidnext", IMAPG(status_uidnext));
3265: }
3266: if (IMAPG(status_flags) & SA_UIDVALIDITY) {
3267: add_property_long(return_value, "uidvalidity", IMAPG(status_uidvalidity));
3268: }
3269: } else {
3270: RETURN_FALSE;
3271: }
3272: }
3273: /* }}} */
3274:
3275: /* {{{ proto object imap_bodystruct(resource stream_id, int msg_no, string section)
3276: Read the structure of a specified body section of a specific message */
3277: PHP_FUNCTION(imap_bodystruct)
3278: {
3279: zval *streamind;
3280: long msg;
3281: char *section;
3282: int section_len;
3283: pils *imap_le_struct;
3284: zval *parametres, *param, *dparametres, *dparam;
3285: PARAMETER *par, *dpar;
3286: BODY *body;
3287:
3288: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rls", &streamind, &msg, §ion, §ion_len) == FAILURE) {
3289: return;
3290: }
3291:
3292: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
3293:
3294: if (!msg || msg < 1 || (unsigned) msg > imap_le_struct->imap_stream->nmsgs) {
3295: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Bad message number");
3296: RETURN_FALSE;
3297: }
3298:
3299: object_init(return_value);
3300:
3301: body=mail_body(imap_le_struct->imap_stream, msg, section);
3302: if (body == NULL) {
3303: zval_dtor(return_value);
3304: RETURN_FALSE;
3305: }
3306: if (body->type <= TYPEMAX) {
3307: add_property_long(return_value, "type", body->type);
3308: }
3309: if (body->encoding <= ENCMAX) {
3310: add_property_long(return_value, "encoding", body->encoding);
3311: }
3312:
3313: if (body->subtype) {
3314: add_property_long(return_value, "ifsubtype", 1);
3315: add_property_string(return_value, "subtype", body->subtype, 1);
3316: } else {
3317: add_property_long(return_value, "ifsubtype", 0);
3318: }
3319:
3320: if (body->description) {
3321: add_property_long(return_value, "ifdescription", 1);
3322: add_property_string(return_value, "description", body->description, 1);
3323: } else {
3324: add_property_long(return_value, "ifdescription", 0);
3325: }
3326: if (body->id) {
3327: add_property_long(return_value, "ifid", 1);
3328: add_property_string(return_value, "id", body->id, 1);
3329: } else {
3330: add_property_long(return_value, "ifid", 0);
3331: }
3332:
3333: if (body->size.lines) {
3334: add_property_long(return_value, "lines", body->size.lines);
3335: }
3336: if (body->size.bytes) {
3337: add_property_long(return_value, "bytes", body->size.bytes);
3338: }
3339: #ifdef IMAP41
3340: if (body->disposition.type) {
3341: add_property_long(return_value, "ifdisposition", 1);
3342: add_property_string(return_value, "disposition", body->disposition.type, 1);
3343: } else {
3344: add_property_long(return_value, "ifdisposition", 0);
3345: }
3346:
3347: if (body->disposition.parameter) {
3348: dpar = body->disposition.parameter;
3349: add_property_long(return_value, "ifdparameters", 1);
3350: MAKE_STD_ZVAL(dparametres);
3351: array_init(dparametres);
3352: do {
3353: MAKE_STD_ZVAL(dparam);
3354: object_init(dparam);
3355: add_property_string(dparam, "attribute", dpar->attribute, 1);
3356: add_property_string(dparam, "value", dpar->value, 1);
3357: add_next_index_object(dparametres, dparam TSRMLS_CC);
3358: } while ((dpar = dpar->next));
3359: add_assoc_object(return_value, "dparameters", dparametres TSRMLS_CC);
3360: } else {
3361: add_property_long(return_value, "ifdparameters", 0);
3362: }
3363: #endif
3364:
3365: if ((par = body->parameter)) {
3366: add_property_long(return_value, "ifparameters", 1);
3367:
3368: MAKE_STD_ZVAL(parametres);
3369: array_init(parametres);
3370: do {
3371: MAKE_STD_ZVAL(param);
3372: object_init(param);
3373: if (par->attribute) {
3374: add_property_string(param, "attribute", par->attribute, 1);
3375: }
3376: if (par->value) {
3377: add_property_string(param, "value", par->value, 1);
3378: }
3379:
3380: add_next_index_object(parametres, param TSRMLS_CC);
3381: } while ((par = par->next));
3382: } else {
3383: MAKE_STD_ZVAL(parametres);
3384: object_init(parametres);
3385: add_property_long(return_value, "ifparameters", 0);
3386: }
3387: add_assoc_object(return_value, "parameters", parametres TSRMLS_CC);
3388: }
3389:
3390: /* }}} */
3391:
3392: /* {{{ proto array imap_fetch_overview(resource stream_id, string sequence [, int options])
3393: Read an overview of the information in the headers of the given message sequence */
3394: PHP_FUNCTION(imap_fetch_overview)
3395: {
3396: zval *streamind;
3397: char *sequence;
3398: int sequence_len;
3399: pils *imap_le_struct;
3400: zval *myoverview;
3401: char *address;
3402: long status, flags = 0L;
3403: int argc = ZEND_NUM_ARGS();
3404:
3405: if (zend_parse_parameters(argc TSRMLS_CC, "rs|l", &streamind, &sequence, &sequence_len, &flags) == FAILURE) {
3406: return;
3407: }
3408:
3409: if (flags && ((flags & ~FT_UID) != 0)) {
3410: php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid value for the options parameter");
3411: RETURN_FALSE;
3412: }
3413:
3414: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
3415:
3416: array_init(return_value);
3417:
3418: status = (flags & FT_UID)
3419: ? mail_uid_sequence(imap_le_struct->imap_stream, sequence)
3420: : mail_sequence(imap_le_struct->imap_stream, sequence);
3421:
3422: if (status) {
3423: MESSAGECACHE *elt;
3424: ENVELOPE *env;
3425: unsigned long i;
3426:
3427: for (i = 1; i <= imap_le_struct->imap_stream->nmsgs; i++) {
3428: if (((elt = mail_elt (imap_le_struct->imap_stream, i))->sequence) &&
3429: (env = mail_fetch_structure (imap_le_struct->imap_stream, i, NIL, NIL))) {
3430: MAKE_STD_ZVAL(myoverview);
3431: object_init(myoverview);
3432: if (env->subject) {
3433: add_property_string(myoverview, "subject", env->subject, 1);
3434: }
3435: if (env->from) {
3436: env->from->next=NULL;
3437: address =_php_rfc822_write_address(env->from TSRMLS_CC);
3438: if (address) {
3439: add_property_string(myoverview, "from", address, 0);
3440: }
3441: }
3442: if (env->to) {
3443: env->to->next = NULL;
3444: address = _php_rfc822_write_address(env->to TSRMLS_CC);
3445: if (address) {
3446: add_property_string(myoverview, "to", address, 0);
3447: }
3448: }
3449: if (env->date) {
3450: add_property_string(myoverview, "date", env->date, 1);
3451: }
3452: if (env->message_id) {
3453: add_property_string(myoverview, "message_id", env->message_id, 1);
3454: }
3455: if (env->references) {
3456: add_property_string(myoverview, "references", env->references, 1);
3457: }
3458: if (env->in_reply_to) {
3459: add_property_string(myoverview, "in_reply_to", env->in_reply_to, 1);
3460: }
3461: add_property_long(myoverview, "size", elt->rfc822_size);
3462: add_property_long(myoverview, "uid", mail_uid(imap_le_struct->imap_stream, i));
3463: add_property_long(myoverview, "msgno", i);
3464: add_property_long(myoverview, "recent", elt->recent);
3465: add_property_long(myoverview, "flagged", elt->flagged);
3466: add_property_long(myoverview, "answered", elt->answered);
3467: add_property_long(myoverview, "deleted", elt->deleted);
3468: add_property_long(myoverview, "seen", elt->seen);
3469: add_property_long(myoverview, "draft", elt->draft);
3470: add_property_long(myoverview, "udate", mail_longdate(elt));
3471: add_next_index_object(return_value, myoverview TSRMLS_CC);
3472: }
3473: }
3474: }
3475: }
3476: /* }}} */
3477:
3478: /* {{{ proto string imap_mail_compose(array envelope, array body)
3479: Create a MIME message based on given envelope and body sections */
3480: PHP_FUNCTION(imap_mail_compose)
3481: {
3482: zval *envelope, *body;
3483: char *key;
3484: zval **data, **pvalue, **disp_data, **env_data;
3485: ulong ind;
3486: char *cookie = NIL;
3487: ENVELOPE *env;
3488: BODY *bod=NULL, *topbod=NULL;
3489: PART *mypart=NULL, *part;
3490: PARAMETER *param, *disp_param = NULL, *custom_headers_param = NULL, *tmp_param = NULL;
3491: char *tmp=NULL, *mystring=NULL, *t=NULL, *tempstring=NULL, *str_copy = NULL;
3492: int toppart = 0;
3493:
3494: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "aa", &envelope, &body) == FAILURE) {
3495: return;
3496: }
3497:
3498: #define PHP_RFC822_PARSE_ADRLIST(target, value) \
3499: str_copy = estrndup(Z_STRVAL_PP(value), Z_STRLEN_PP(value)); \
3500: rfc822_parse_adrlist(target, str_copy, "NO HOST"); \
3501: efree(str_copy);
3502:
3503: env = mail_newenvelope();
3504: if (zend_hash_find(Z_ARRVAL_P(envelope), "remail", sizeof("remail"), (void **) &pvalue)== SUCCESS) {
3505: convert_to_string_ex(pvalue);
3506: env->remail = cpystr(Z_STRVAL_PP(pvalue));
3507: }
3508: if (zend_hash_find(Z_ARRVAL_P(envelope), "return_path", sizeof("return_path"), (void **) &pvalue)== SUCCESS) {
3509: convert_to_string_ex(pvalue);
3510: PHP_RFC822_PARSE_ADRLIST(&env->return_path, pvalue);
3511: }
3512: if (zend_hash_find(Z_ARRVAL_P(envelope), "date", sizeof("date"), (void **) &pvalue)== SUCCESS) {
3513: convert_to_string_ex(pvalue);
3514: env->date = cpystr(Z_STRVAL_PP(pvalue));
3515: }
3516: if (zend_hash_find(Z_ARRVAL_P(envelope), "from", sizeof("from"), (void **) &pvalue)== SUCCESS) {
3517: convert_to_string_ex(pvalue);
3518: PHP_RFC822_PARSE_ADRLIST(&env->from, pvalue);
3519: }
3520: if (zend_hash_find(Z_ARRVAL_P(envelope), "reply_to", sizeof("reply_to"), (void **) &pvalue)== SUCCESS) {
3521: convert_to_string_ex(pvalue);
3522: PHP_RFC822_PARSE_ADRLIST(&env->reply_to, pvalue);
3523: }
3524: if (zend_hash_find(Z_ARRVAL_P(envelope), "in_reply_to", sizeof("in_reply_to"), (void **) &pvalue)== SUCCESS) {
3525: convert_to_string_ex(pvalue);
3526: env->in_reply_to = cpystr(Z_STRVAL_PP(pvalue));
3527: }
3528: if (zend_hash_find(Z_ARRVAL_P(envelope), "subject", sizeof("subject"), (void **) &pvalue)== SUCCESS) {
3529: convert_to_string_ex(pvalue);
3530: env->subject = cpystr(Z_STRVAL_PP(pvalue));
3531: }
3532: if (zend_hash_find(Z_ARRVAL_P(envelope), "to", sizeof("to"), (void **) &pvalue)== SUCCESS) {
3533: convert_to_string_ex(pvalue);
3534: PHP_RFC822_PARSE_ADRLIST(&env->to, pvalue);
3535: }
3536: if (zend_hash_find(Z_ARRVAL_P(envelope), "cc", sizeof("cc"), (void **) &pvalue)== SUCCESS) {
3537: convert_to_string_ex(pvalue);
3538: PHP_RFC822_PARSE_ADRLIST(&env->cc, pvalue);
3539: }
3540: if (zend_hash_find(Z_ARRVAL_P(envelope), "bcc", sizeof("bcc"), (void **) &pvalue)== SUCCESS) {
3541: convert_to_string_ex(pvalue);
3542: PHP_RFC822_PARSE_ADRLIST(&env->bcc, pvalue);
3543: }
3544: if (zend_hash_find(Z_ARRVAL_P(envelope), "message_id", sizeof("message_id"), (void **) &pvalue)== SUCCESS) {
3545: convert_to_string_ex(pvalue);
3546: env->message_id=cpystr(Z_STRVAL_PP(pvalue));
3547: }
3548:
3549: if (zend_hash_find(Z_ARRVAL_P(envelope), "custom_headers", sizeof("custom_headers"), (void **) &pvalue)== SUCCESS) {
3550: if (Z_TYPE_PP(pvalue) == IS_ARRAY) {
3551: custom_headers_param = tmp_param = NULL;
3552: while (zend_hash_get_current_data(Z_ARRVAL_PP(pvalue), (void **) &env_data) == SUCCESS) {
3553: custom_headers_param = mail_newbody_parameter();
3554: convert_to_string_ex(env_data);
3555: custom_headers_param->value = (char *) fs_get(Z_STRLEN_PP(env_data) + 1);
3556: custom_headers_param->attribute = NULL;
3557: memcpy(custom_headers_param->value, Z_STRVAL_PP(env_data), Z_STRLEN_PP(env_data) + 1);
3558: zend_hash_move_forward(Z_ARRVAL_PP(pvalue));
3559: custom_headers_param->next = tmp_param;
3560: tmp_param = custom_headers_param;
3561: }
3562: }
3563: }
3564:
3565: zend_hash_internal_pointer_reset(Z_ARRVAL_P(body));
3566: if (zend_hash_get_current_data(Z_ARRVAL_P(body), (void **) &data) != SUCCESS || Z_TYPE_PP(data) != IS_ARRAY) {
3567: php_error_docref(NULL TSRMLS_CC, E_WARNING, "body parameter must be a non-empty array");
3568: RETURN_FALSE;
3569: }
3570:
3571: if (Z_TYPE_PP(data) == IS_ARRAY) {
3572: bod = mail_newbody();
3573: topbod = bod;
3574:
3575: if (zend_hash_find(Z_ARRVAL_PP(data), "type", sizeof("type"), (void **) &pvalue)== SUCCESS) {
3576: convert_to_long_ex(pvalue);
3577: bod->type = (short) Z_LVAL_PP(pvalue);
3578: }
3579: if (zend_hash_find(Z_ARRVAL_PP(data), "encoding", sizeof("encoding"), (void **) &pvalue)== SUCCESS) {
3580: convert_to_long_ex(pvalue);
3581: bod->encoding = (short) Z_LVAL_PP(pvalue);
3582: }
3583: if (zend_hash_find(Z_ARRVAL_PP(data), "charset", sizeof("charset"), (void **) &pvalue)== SUCCESS) {
3584: convert_to_string_ex(pvalue);
3585: tmp_param = mail_newbody_parameter();
3586: tmp_param->value = cpystr(Z_STRVAL_PP(pvalue));
3587: tmp_param->attribute = cpystr("CHARSET");
3588: tmp_param->next = bod->parameter;
3589: bod->parameter = tmp_param;
3590: }
3591: if (zend_hash_find(Z_ARRVAL_PP(data), "type.parameters", sizeof("type.parameters"), (void **) &pvalue)== SUCCESS) {
3592: if(Z_TYPE_PP(pvalue) == IS_ARRAY) {
3593: disp_param = tmp_param = NULL;
3594: while (zend_hash_get_current_data(Z_ARRVAL_PP(pvalue), (void **) &disp_data) == SUCCESS) {
3595: disp_param = mail_newbody_parameter();
3596: zend_hash_get_current_key(Z_ARRVAL_PP(pvalue), &key, &ind, 0);
3597: disp_param->attribute = cpystr(key);
3598: convert_to_string_ex(disp_data);
3599: disp_param->value = (char *) fs_get(Z_STRLEN_PP(disp_data) + 1);
3600: memcpy(disp_param->value, Z_STRVAL_PP(disp_data), Z_STRLEN_PP(disp_data) + 1);
3601: zend_hash_move_forward(Z_ARRVAL_PP(pvalue));
3602: disp_param->next = tmp_param;
3603: tmp_param = disp_param;
3604: }
3605: bod->parameter = disp_param;
3606: }
3607: }
3608: if (zend_hash_find(Z_ARRVAL_PP(data), "subtype", sizeof("subtype"), (void **) &pvalue)== SUCCESS) {
3609: convert_to_string_ex(pvalue);
3610: bod->subtype = cpystr(Z_STRVAL_PP(pvalue));
3611: }
3612: if (zend_hash_find(Z_ARRVAL_PP(data), "id", sizeof("id"), (void **) &pvalue)== SUCCESS) {
3613: convert_to_string_ex(pvalue);
3614: bod->id = cpystr(Z_STRVAL_PP(pvalue));
3615: }
3616: if (zend_hash_find(Z_ARRVAL_PP(data), "description", sizeof("description"), (void **) &pvalue)== SUCCESS) {
3617: convert_to_string_ex(pvalue);
3618: bod->description = cpystr(Z_STRVAL_PP(pvalue));
3619: }
3620: if (zend_hash_find(Z_ARRVAL_PP(data), "disposition.type", sizeof("disposition.type"), (void **) &pvalue)== SUCCESS) {
3621: convert_to_string_ex(pvalue);
3622: bod->disposition.type = (char *) fs_get(Z_STRLEN_PP(pvalue) + 1);
3623: memcpy(bod->disposition.type, Z_STRVAL_PP(pvalue), Z_STRLEN_PP(pvalue)+1);
3624: }
3625: if (zend_hash_find(Z_ARRVAL_PP(data), "disposition", sizeof("disposition"), (void **) &pvalue)== SUCCESS) {
3626: if (Z_TYPE_PP(pvalue) == IS_ARRAY) {
3627: disp_param = tmp_param = NULL;
3628: while (zend_hash_get_current_data(Z_ARRVAL_PP(pvalue), (void **) &disp_data) == SUCCESS) {
3629: disp_param = mail_newbody_parameter();
3630: zend_hash_get_current_key(Z_ARRVAL_PP(pvalue), &key, &ind, 0);
3631: disp_param->attribute = cpystr(key);
3632: convert_to_string_ex(disp_data);
3633: disp_param->value = (char *) fs_get(Z_STRLEN_PP(disp_data) + 1);
3634: memcpy(disp_param->value, Z_STRVAL_PP(disp_data), Z_STRLEN_PP(disp_data) + 1);
3635: zend_hash_move_forward(Z_ARRVAL_PP(pvalue));
3636: disp_param->next = tmp_param;
3637: tmp_param = disp_param;
3638: }
3639: bod->disposition.parameter = disp_param;
3640: }
3641: }
3642: if (zend_hash_find(Z_ARRVAL_PP(data), "contents.data", sizeof("contents.data"), (void **) &pvalue)== SUCCESS) {
3643: convert_to_string_ex(pvalue);
3644: bod->contents.text.data = (char *) fs_get(Z_STRLEN_PP(pvalue) + 1);
3645: memcpy(bod->contents.text.data, Z_STRVAL_PP(pvalue), Z_STRLEN_PP(pvalue)+1);
3646: bod->contents.text.size = Z_STRLEN_PP(pvalue);
3647: } else {
3648: bod->contents.text.data = (char *) fs_get(1);
3649: memcpy(bod->contents.text.data, "", 1);
3650: bod->contents.text.size = 0;
3651: }
3652: if (zend_hash_find(Z_ARRVAL_PP(data), "lines", sizeof("lines"), (void **) &pvalue)== SUCCESS) {
3653: convert_to_long_ex(pvalue);
3654: bod->size.lines = Z_LVAL_PP(pvalue);
3655: }
3656: if (zend_hash_find(Z_ARRVAL_PP(data), "bytes", sizeof("bytes"), (void **) &pvalue)== SUCCESS) {
3657: convert_to_long_ex(pvalue);
3658: bod->size.bytes = Z_LVAL_PP(pvalue);
3659: }
3660: if (zend_hash_find(Z_ARRVAL_PP(data), "md5", sizeof("md5"), (void **) &pvalue)== SUCCESS) {
3661: convert_to_string_ex(pvalue);
3662: bod->md5 = cpystr(Z_STRVAL_PP(pvalue));
3663: }
3664: }
3665:
3666: zend_hash_move_forward(Z_ARRVAL_P(body));
3667:
3668: while (zend_hash_get_current_data(Z_ARRVAL_P(body), (void **) &data) == SUCCESS) {
3669: if (Z_TYPE_PP(data) == IS_ARRAY) {
3670: short type = -1;
3671: if (zend_hash_find(Z_ARRVAL_PP(data), "type", sizeof("type"), (void **) &pvalue)== SUCCESS) {
3672: convert_to_long_ex(pvalue);
3673: type = (short) Z_LVAL_PP(pvalue);
3674: }
3675:
3676: if (!toppart) {
3677: bod->nested.part = mail_newbody_part();
3678: mypart = bod->nested.part;
3679: toppart = 1;
3680: } else {
3681: mypart->next = mail_newbody_part();
3682: mypart = mypart->next;
3683: }
3684:
3685: bod = &mypart->body;
3686:
3687: if (type != TYPEMULTIPART) {
3688: bod->type = type;
3689: }
3690:
3691: if (zend_hash_find(Z_ARRVAL_PP(data), "encoding", sizeof("encoding"), (void **) &pvalue)== SUCCESS) {
3692: convert_to_long_ex(pvalue);
3693: bod->encoding = (short) Z_LVAL_PP(pvalue);
3694: }
3695: if (zend_hash_find(Z_ARRVAL_PP(data), "charset", sizeof("charset"), (void **) &pvalue)== SUCCESS) {
3696: convert_to_string_ex(pvalue);
3697: tmp_param = mail_newbody_parameter();
3698: tmp_param->value = (char *) fs_get(Z_STRLEN_PP(pvalue) + 1);
3699: memcpy(tmp_param->value, Z_STRVAL_PP(pvalue), Z_STRLEN_PP(pvalue) + 1);
3700: tmp_param->attribute = cpystr("CHARSET");
3701: tmp_param->next = bod->parameter;
3702: bod->parameter = tmp_param;
3703: }
3704: if (zend_hash_find(Z_ARRVAL_PP(data), "type.parameters", sizeof("type.parameters"), (void **) &pvalue)== SUCCESS) {
3705: if(Z_TYPE_PP(pvalue) == IS_ARRAY) {
3706: disp_param = tmp_param = NULL;
3707: while (zend_hash_get_current_data(Z_ARRVAL_PP(pvalue), (void **) &disp_data) == SUCCESS) {
3708: disp_param = mail_newbody_parameter();
3709: zend_hash_get_current_key(Z_ARRVAL_PP(pvalue), &key, &ind, 0);
3710: disp_param->attribute = cpystr(key);
3711: convert_to_string_ex(disp_data);
3712: disp_param->value = (char *) fs_get(Z_STRLEN_PP(disp_data) + 1);
3713: memcpy(disp_param->value, Z_STRVAL_PP(disp_data), Z_STRLEN_PP(disp_data) + 1);
3714: zend_hash_move_forward(Z_ARRVAL_PP(pvalue));
3715: disp_param->next = tmp_param;
3716: tmp_param = disp_param;
3717: }
3718: bod->parameter = disp_param;
3719: }
3720: }
3721: if (zend_hash_find(Z_ARRVAL_PP(data), "subtype", sizeof("subtype"), (void **) &pvalue)== SUCCESS) {
3722: convert_to_string_ex(pvalue);
3723: bod->subtype = cpystr(Z_STRVAL_PP(pvalue));
3724: }
3725: if (zend_hash_find(Z_ARRVAL_PP(data), "id", sizeof("id"), (void **) &pvalue)== SUCCESS) {
3726: convert_to_string_ex(pvalue);
3727: bod->id = cpystr(Z_STRVAL_PP(pvalue));
3728: }
3729: if (zend_hash_find(Z_ARRVAL_PP(data), "description", sizeof("description"), (void **) &pvalue)== SUCCESS) {
3730: convert_to_string_ex(pvalue);
3731: bod->description = cpystr(Z_STRVAL_PP(pvalue));
3732: }
3733: if (zend_hash_find(Z_ARRVAL_PP(data), "disposition.type", sizeof("disposition.type"), (void **) &pvalue)== SUCCESS) {
3734: convert_to_string_ex(pvalue);
3735: bod->disposition.type = (char *) fs_get(Z_STRLEN_PP(pvalue) + 1);
3736: memcpy(bod->disposition.type, Z_STRVAL_PP(pvalue), Z_STRLEN_PP(pvalue)+1);
3737: }
3738: if (zend_hash_find(Z_ARRVAL_PP(data), "disposition", sizeof("disposition"), (void **) &pvalue)== SUCCESS) {
3739: if (Z_TYPE_PP(pvalue) == IS_ARRAY) {
3740: disp_param = tmp_param = NULL;
3741: while (zend_hash_get_current_data(Z_ARRVAL_PP(pvalue), (void **) &disp_data) == SUCCESS) {
3742: disp_param = mail_newbody_parameter();
3743: zend_hash_get_current_key(Z_ARRVAL_PP(pvalue), &key, &ind, 0);
3744: disp_param->attribute = cpystr(key);
3745: convert_to_string_ex(disp_data);
3746: disp_param->value = (char *) fs_get(Z_STRLEN_PP(disp_data) + 1);
3747: memcpy(disp_param->value, Z_STRVAL_PP(disp_data), Z_STRLEN_PP(disp_data) + 1);
3748: zend_hash_move_forward(Z_ARRVAL_PP(pvalue));
3749: disp_param->next = tmp_param;
3750: tmp_param = disp_param;
3751: }
3752: bod->disposition.parameter = disp_param;
3753: }
3754: }
3755: if (zend_hash_find(Z_ARRVAL_PP(data), "contents.data", sizeof("contents.data"), (void **) &pvalue)== SUCCESS) {
3756: convert_to_string_ex(pvalue);
3757: bod->contents.text.data = (char *) fs_get(Z_STRLEN_PP(pvalue) + 1);
3758: memcpy(bod->contents.text.data, Z_STRVAL_PP(pvalue), Z_STRLEN_PP(pvalue) + 1);
3759: bod->contents.text.size = Z_STRLEN_PP(pvalue);
3760: } else {
3761: bod->contents.text.data = (char *) fs_get(1);
3762: memcpy(bod->contents.text.data, "", 1);
3763: bod->contents.text.size = 0;
3764: }
3765: if (zend_hash_find(Z_ARRVAL_PP(data), "lines", sizeof("lines"), (void **) &pvalue)== SUCCESS) {
3766: convert_to_long_ex(pvalue);
3767: bod->size.lines = Z_LVAL_PP(pvalue);
3768: }
3769: if (zend_hash_find(Z_ARRVAL_PP(data), "bytes", sizeof("bytes"), (void **) &pvalue)== SUCCESS) {
3770: convert_to_long_ex(pvalue);
3771: bod->size.bytes = Z_LVAL_PP(pvalue);
3772: }
3773: if (zend_hash_find(Z_ARRVAL_PP(data), "md5", sizeof("md5"), (void **) &pvalue)== SUCCESS) {
3774: convert_to_string_ex(pvalue);
3775: bod->md5 = cpystr(Z_STRVAL_PP(pvalue));
3776: }
3777: }
3778: zend_hash_move_forward(Z_ARRVAL_P(body));
3779: }
3780:
3781: if (bod && bod->type == TYPEMULTIPART && (!bod->nested.part || !bod->nested.part->next)) {
3782: php_error_docref(NULL TSRMLS_CC, E_WARNING, "cannot generate multipart e-mail without components.");
3783: RETVAL_FALSE;
3784: goto done;
3785: }
3786:
3787: rfc822_encode_body_7bit(env, topbod);
3788:
3789: tmp = emalloc(SENDBUFLEN + 1);
3790:
3791: rfc822_header(tmp, env, topbod);
3792:
3793: /* add custom envelope headers */
3794: if (custom_headers_param) {
3795: int l = strlen(tmp) - 2, l2;
3796: PARAMETER *tp = custom_headers_param;
3797:
3798: /* remove last CRLF from tmp */
3799: tmp[l] = '\0';
3800: tempstring = emalloc(l);
3801: memcpy(tempstring, tmp, l);
3802:
3803: do {
3804: l2 = strlen(custom_headers_param->value);
3805: tempstring = erealloc(tempstring, l + l2 + CRLF_LEN + 1);
3806: memcpy(tempstring + l, custom_headers_param->value, l2);
3807: memcpy(tempstring + l + l2, CRLF, CRLF_LEN);
3808: l += l2 + CRLF_LEN;
3809: } while ((custom_headers_param = custom_headers_param->next));
3810:
3811: mail_free_body_parameter(&tp);
3812:
3813: mystring = emalloc(l + CRLF_LEN + 1);
3814: memcpy(mystring, tempstring, l);
3815: memcpy(mystring + l , CRLF, CRLF_LEN);
3816: mystring[l + CRLF_LEN] = '\0';
3817:
3818: efree(tempstring);
3819: } else {
3820: mystring = estrdup(tmp);
3821: }
3822:
3823: bod = topbod;
3824:
3825: if (bod && bod->type == TYPEMULTIPART) {
3826:
3827: /* first body part */
3828: part = bod->nested.part;
3829:
3830: /* find cookie */
3831: for (param = bod->parameter; param && !cookie; param = param->next) {
3832: if (!strcmp (param->attribute, "BOUNDARY")) {
3833: cookie = param->value;
3834: }
3835: }
3836:
3837: /* yucky default */
3838: if (!cookie) {
3839: cookie = "-";
3840: } else if (strlen(cookie) > (SENDBUFLEN - 2 - 2 - 2)) { /* validate cookie length -- + CRLF * 2 */
3841: php_error_docref(NULL TSRMLS_CC, E_WARNING, "The boundary should be no longer than 4kb");
3842: RETVAL_FALSE;
3843: goto done;
3844: }
3845:
3846: /* for each part */
3847: do {
3848: t = tmp;
3849:
3850: /* append mini-header */
3851: *t = '\0';
3852: rfc822_write_body_header(&t, &part->body);
3853:
3854: /* output cookie, mini-header, and contents */
3855: spprintf(&tempstring, 0, "%s--%s%s%s%s", mystring, cookie, CRLF, tmp, CRLF);
3856: efree(mystring);
3857: mystring=tempstring;
3858:
3859: bod=&part->body;
3860:
3861: spprintf(&tempstring, 0, "%s%s%s", mystring, bod->contents.text.data, CRLF);
3862: efree(mystring);
3863: mystring=tempstring;
3864: } while ((part = part->next)); /* until done */
3865:
3866: /* output trailing cookie */
3867: spprintf(&tempstring, 0, "%s--%s--%s", mystring, cookie, CRLF);
3868: efree(mystring);
3869: mystring=tempstring;
3870: } else if (bod) {
3871: spprintf(&tempstring, 0, "%s%s%s", mystring, bod->contents.text.data, CRLF);
3872: efree(mystring);
3873: mystring=tempstring;
3874: } else {
3875: efree(mystring);
3876: RETVAL_FALSE;
3877: goto done;
3878: }
3879:
3880: RETVAL_STRING(tempstring, 0);
3881: done:
3882: if (tmp) {
3883: efree(tmp);
3884: }
3885: mail_free_body(&topbod);
3886: mail_free_envelope(&env);
3887: }
3888: /* }}} */
3889:
3890: /* {{{ _php_imap_mail
3891: */
3892: int _php_imap_mail(char *to, char *subject, char *message, char *headers, char *cc, char *bcc, char* rpath TSRMLS_DC)
3893: {
3894: #ifdef PHP_WIN32
3895: int tsm_err;
3896: #else
3897: FILE *sendmail;
3898: int ret;
3899: #endif
3900:
3901: #ifdef PHP_WIN32
3902: char *tempMailTo;
3903: char *tsm_errmsg = NULL;
3904: ADDRESS *addr;
3905: char *bufferTo = NULL, *bufferCc = NULL, *bufferBcc = NULL, *bufferHeader = NULL;
3906: int offset, bufferLen = 0;
3907: size_t bt_len;
3908:
3909: if (headers) {
3910: bufferLen += strlen(headers);
3911: }
3912: if (to) {
3913: bufferLen += strlen(to) + 6;
3914: }
3915: if (cc) {
3916: bufferLen += strlen(cc) + 6;
3917: }
3918:
3919: #define PHP_IMAP_CLEAN if (bufferTo) efree(bufferTo); if (bufferCc) efree(bufferCc); if (bufferBcc) efree(bufferBcc); if (bufferHeader) efree(bufferHeader);
3920: #define PHP_IMAP_BAD_DEST PHP_IMAP_CLEAN; efree(tempMailTo); return (BAD_MSG_DESTINATION);
3921:
3922: bufferHeader = (char *)emalloc(bufferLen + 1);
3923: memset(bufferHeader, 0, bufferLen);
3924: if (to && *to) {
3925: strlcat(bufferHeader, "To: ", bufferLen + 1);
3926: strlcat(bufferHeader, to, bufferLen + 1);
3927: strlcat(bufferHeader, "\r\n", bufferLen + 1);
3928: tempMailTo = estrdup(to);
3929: bt_len = strlen(to);
3930: bufferTo = (char *)safe_emalloc(bt_len, 1, 1);
3931: bt_len++;
3932: offset = 0;
3933: addr = NULL;
3934: rfc822_parse_adrlist(&addr, tempMailTo, NULL);
3935: while (addr) {
3936: if (addr->host == NULL || strcmp(addr->host, ERRHOST) == 0) {
3937: PHP_IMAP_BAD_DEST;
3938: } else {
3939: bufferTo = safe_erealloc(bufferTo, bt_len, 1, strlen(addr->mailbox));
3940: bt_len += strlen(addr->mailbox);
3941: bufferTo = safe_erealloc(bufferTo, bt_len, 1, strlen(addr->host));
3942: bt_len += strlen(addr->host);
3943: offset += slprintf(bufferTo + offset, bt_len - offset, "%s@%s,", addr->mailbox, addr->host);
3944: }
3945: addr = addr->next;
3946: }
3947: efree(tempMailTo);
3948: if (offset>0) {
3949: bufferTo[offset-1] = 0;
3950: }
3951: }
3952:
3953: if (cc && *cc) {
3954: strlcat(bufferHeader, "Cc: ", bufferLen + 1);
3955: strlcat(bufferHeader, cc, bufferLen + 1);
3956: strlcat(bufferHeader, "\r\n", bufferLen + 1);
3957: tempMailTo = estrdup(cc);
3958: bt_len = strlen(cc);
3959: bufferCc = (char *)safe_emalloc(bt_len, 1, 1);
3960: bt_len++;
3961: offset = 0;
3962: addr = NULL;
3963: rfc822_parse_adrlist(&addr, tempMailTo, NULL);
3964: while (addr) {
3965: if (addr->host == NULL || strcmp(addr->host, ERRHOST) == 0) {
3966: PHP_IMAP_BAD_DEST;
3967: } else {
3968: bufferCc = safe_erealloc(bufferCc, bt_len, 1, strlen(addr->mailbox));
3969: bt_len += strlen(addr->mailbox);
3970: bufferCc = safe_erealloc(bufferCc, bt_len, 1, strlen(addr->host));
3971: bt_len += strlen(addr->host);
3972: offset += slprintf(bufferCc + offset, bt_len - offset, "%s@%s,", addr->mailbox, addr->host);
3973: }
3974: addr = addr->next;
3975: }
3976: efree(tempMailTo);
3977: if (offset>0) {
3978: bufferCc[offset-1] = 0;
3979: }
3980: }
3981:
3982: if (bcc && *bcc) {
3983: tempMailTo = estrdup(bcc);
3984: bt_len = strlen(bcc);
3985: bufferBcc = (char *)safe_emalloc(bt_len, 1, 1);
3986: bt_len++;
3987: offset = 0;
3988: addr = NULL;
3989: rfc822_parse_adrlist(&addr, tempMailTo, NULL);
3990: while (addr) {
3991: if (addr->host == NULL || strcmp(addr->host, ERRHOST) == 0) {
3992: PHP_IMAP_BAD_DEST;
3993: } else {
3994: bufferBcc = safe_erealloc(bufferBcc, bt_len, 1, strlen(addr->mailbox));
3995: bt_len += strlen(addr->mailbox);
3996: bufferBcc = safe_erealloc(bufferBcc, bt_len, 1, strlen(addr->host));
3997: bt_len += strlen(addr->host);
3998: offset += slprintf(bufferBcc + offset, bt_len - offset, "%s@%s,", addr->mailbox, addr->host);
3999: }
4000: addr = addr->next;
4001: }
4002: efree(tempMailTo);
4003: if (offset>0) {
4004: bufferBcc[offset-1] = 0;
4005: }
4006: }
4007:
4008: if (headers && *headers) {
4009: strlcat(bufferHeader, headers, bufferLen + 1);
4010: }
4011:
4012: if (TSendMail(INI_STR("SMTP"), &tsm_err, &tsm_errmsg, bufferHeader, subject, bufferTo, message, bufferCc, bufferBcc, rpath TSRMLS_CC) != SUCCESS) {
4013: if (tsm_errmsg) {
4014: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", tsm_errmsg);
4015: efree(tsm_errmsg);
4016: } else {
4017: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", GetSMErrorText(tsm_err));
4018: }
4019: PHP_IMAP_CLEAN;
4020: return 0;
4021: }
4022: PHP_IMAP_CLEAN;
4023: #else
4024: if (!INI_STR("sendmail_path")) {
4025: return 0;
4026: }
4027: sendmail = popen(INI_STR("sendmail_path"), "w");
4028: if (sendmail) {
4029: if (rpath && rpath[0]) fprintf(sendmail, "From: %s\n", rpath);
4030: fprintf(sendmail, "To: %s\n", to);
4031: if (cc && cc[0]) fprintf(sendmail, "Cc: %s\n", cc);
4032: if (bcc && bcc[0]) fprintf(sendmail, "Bcc: %s\n", bcc);
4033: fprintf(sendmail, "Subject: %s\n", subject);
4034: if (headers != NULL) {
4035: fprintf(sendmail, "%s\n", headers);
4036: }
4037: fprintf(sendmail, "\n%s\n", message);
4038: ret = pclose(sendmail);
4039: if (ret == -1) {
4040: return 0;
4041: } else {
4042: return 1;
4043: }
4044: } else {
4045: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not execute mail delivery program");
4046: return 0;
4047: }
4048: #endif
4049: return 1;
4050: }
4051: /* }}} */
4052:
4053: /* {{{ proto bool imap_mail(string to, string subject, string message [, string additional_headers [, string cc [, string bcc [, string rpath]]]])
4054: Send an email message */
4055: PHP_FUNCTION(imap_mail)
4056: {
4057: char *to=NULL, *message=NULL, *headers=NULL, *subject=NULL, *cc=NULL, *bcc=NULL, *rpath=NULL;
4058: int to_len, message_len, headers_len, subject_len, cc_len, bcc_len, rpath_len, argc = ZEND_NUM_ARGS();
4059:
4060: if (zend_parse_parameters(argc TSRMLS_CC, "sss|ssss", &to, &to_len, &subject, &subject_len, &message, &message_len,
4061: &headers, &headers_len, &cc, &cc_len, &bcc, &bcc_len, &rpath, &rpath_len) == FAILURE) {
4062: return;
4063: }
4064:
4065: /* To: */
4066: if (!to_len) {
4067: php_error_docref(NULL TSRMLS_CC, E_WARNING, "No to field in mail command");
4068: RETURN_FALSE;
4069: }
4070:
4071: /* Subject: */
4072: if (!subject_len) {
4073: php_error_docref(NULL TSRMLS_CC, E_WARNING, "No subject field in mail command");
4074: RETURN_FALSE;
4075: }
4076:
4077: /* message body */
4078: if (!message_len) {
4079: /* this is not really an error, so it is allowed. */
4080: php_error_docref(NULL TSRMLS_CC, E_WARNING, "No message string in mail command");
4081: message = NULL;
4082: }
4083:
4084: if (_php_imap_mail(to, subject, message, headers, cc, bcc, rpath TSRMLS_CC)) {
4085: RETURN_TRUE;
4086: } else {
4087: RETURN_FALSE;
4088: }
4089: }
4090: /* }}} */
4091:
4092: /* {{{ proto array imap_search(resource stream_id, string criteria [, int options [, string charset]])
4093: Return a list of messages matching the given criteria */
4094: PHP_FUNCTION(imap_search)
4095: {
4096: zval *streamind;
4097: char *criteria, *charset = NULL;
4098: int criteria_len, charset_len = 0;
4099: long flags = SE_FREE;
4100: pils *imap_le_struct;
4101: char *search_criteria;
4102: MESSAGELIST *cur;
4103: int argc = ZEND_NUM_ARGS();
4104: SEARCHPGM *pgm = NIL;
4105:
4106: if (zend_parse_parameters(argc TSRMLS_CC, "rs|ls", &streamind, &criteria, &criteria_len, &flags, &charset, &charset_len) == FAILURE) {
4107: return;
4108: }
4109:
4110: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
4111:
4112: search_criteria = estrndup(criteria, criteria_len);
4113:
4114: IMAPG(imap_messages) = IMAPG(imap_messages_tail) = NIL;
4115: pgm = mail_criteria(search_criteria);
4116:
4117: mail_search_full(imap_le_struct->imap_stream, (argc == 4 ? charset : NIL), pgm, flags);
4118:
4119: if (pgm && !(flags & SE_FREE)) {
4120: mail_free_searchpgm(&pgm);
4121: }
4122:
4123: if (IMAPG(imap_messages) == NIL) {
4124: efree(search_criteria);
4125: RETURN_FALSE;
4126: }
4127:
4128: array_init(return_value);
4129:
4130: cur = IMAPG(imap_messages);
4131: while (cur != NIL) {
4132: add_next_index_long(return_value, cur->msgid);
4133: cur = cur->next;
4134: }
4135: mail_free_messagelist(&IMAPG(imap_messages), &IMAPG(imap_messages_tail));
4136: efree(search_criteria);
4137: }
4138: /* }}} */
4139:
4140: /* {{{ proto array imap_alerts(void)
4141: Returns an array of all IMAP alerts that have been generated since the last page load or since the last imap_alerts() call, whichever came last. The alert stack is cleared after imap_alerts() is called. */
4142: /* Author: CJH */
4143: PHP_FUNCTION(imap_alerts)
4144: {
4145: STRINGLIST *cur=NIL;
4146:
4147: if (zend_parse_parameters_none() == FAILURE) {
4148: return;
4149: }
4150:
4151: if (IMAPG(imap_alertstack) == NIL) {
4152: RETURN_FALSE;
4153: }
4154:
4155: array_init(return_value);
4156:
4157: cur = IMAPG(imap_alertstack);
4158: while (cur != NIL) {
4159: add_next_index_string(return_value, cur->LTEXT, 1);
4160: cur = cur->next;
4161: }
4162: mail_free_stringlist(&IMAPG(imap_alertstack));
4163: IMAPG(imap_alertstack) = NIL;
4164: }
4165: /* }}} */
4166:
4167: /* {{{ proto array imap_errors(void)
4168: Returns an array of all IMAP errors generated since the last page load, or since the last imap_errors() call, whichever came last. The error stack is cleared after imap_errors() is called. */
4169: /* Author: CJH */
4170: PHP_FUNCTION(imap_errors)
4171: {
4172: ERRORLIST *cur=NIL;
4173:
4174: if (zend_parse_parameters_none() == FAILURE) {
4175: return;
4176: }
4177:
4178: if (IMAPG(imap_errorstack) == NIL) {
4179: RETURN_FALSE;
4180: }
4181:
4182: array_init(return_value);
4183:
4184: cur = IMAPG(imap_errorstack);
4185: while (cur != NIL) {
4186: add_next_index_string(return_value, cur->LTEXT, 1);
4187: cur = cur->next;
4188: }
4189: mail_free_errorlist(&IMAPG(imap_errorstack));
4190: IMAPG(imap_errorstack) = NIL;
4191: }
4192: /* }}} */
4193:
4194: /* {{{ proto string imap_last_error(void)
4195: Returns the last error that was generated by an IMAP function. The error stack is NOT cleared after this call. */
4196: /* Author: CJH */
4197: PHP_FUNCTION(imap_last_error)
4198: {
4199: ERRORLIST *cur=NIL;
4200:
4201: if (zend_parse_parameters_none() == FAILURE) {
4202: return;
4203: }
4204:
4205: if (IMAPG(imap_errorstack) == NIL) {
4206: RETURN_FALSE;
4207: }
4208:
4209: cur = IMAPG(imap_errorstack);
4210: while (cur != NIL) {
4211: if (cur->next == NIL) {
4212: RETURN_STRING(cur->LTEXT, 1);
4213: }
4214: cur = cur->next;
4215: }
4216: }
4217: /* }}} */
4218:
4219: /* {{{ proto array imap_mime_header_decode(string str)
4220: Decode mime header element in accordance with RFC 2047 and return array of objects containing 'charset' encoding and decoded 'text' */
4221: PHP_FUNCTION(imap_mime_header_decode)
4222: {
4223: /* Author: Ted Parnefors <ted@mtv.se> */
4224: zval *myobject;
4225: char *str, *string, *charset, encoding, *text, *decode;
4226: int str_len;
4227: long charset_token, encoding_token, end_token, end, offset=0, i;
4228: unsigned long newlength;
4229:
4230: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {
4231: return;
4232: }
4233:
4234: array_init(return_value);
4235:
4236: string = str;
4237: end = str_len;
4238:
4239: charset = (char *) safe_emalloc((end + 1), 2, 0);
4240: text = &charset[end + 1];
4241: while (offset < end) { /* Reached end of the string? */
4242: if ((charset_token = (long)php_memnstr(&string[offset], "=?", 2, string + end))) { /* Is there anything encoded in the string? */
4243: charset_token -= (long)string;
4244: if (offset != charset_token) { /* Is there anything before the encoded data? */
4245: /* Retrieve unencoded data that is found before encoded data */
4246: memcpy(text, &string[offset], charset_token-offset);
4247: text[charset_token - offset] = 0x00;
4248: MAKE_STD_ZVAL(myobject);
4249: object_init(myobject);
4250: add_property_string(myobject, "charset", "default", 1);
4251: add_property_string(myobject, "text", text, 1);
4252: zend_hash_next_index_insert(Z_ARRVAL_P(return_value), (void *)&myobject, sizeof(zval *), NULL);
4253: }
4254: if ((encoding_token = (long)php_memnstr(&string[charset_token+2], "?", 1, string+end))) { /* Find token for encoding */
4255: encoding_token -= (long)string;
4256: if ((end_token = (long)php_memnstr(&string[encoding_token+3], "?=", 2, string+end))) { /* Find token for end of encoded data */
4257: end_token -= (long)string;
4258: memcpy(charset, &string[charset_token + 2], encoding_token - (charset_token + 2)); /* Extract charset encoding */
4259: charset[encoding_token-(charset_token + 2)] = 0x00;
4260: encoding=string[encoding_token + 1]; /* Extract encoding from string */
4261: memcpy(text, &string[encoding_token + 3], end_token - (encoding_token + 3)); /* Extract text */
4262: text[end_token - (encoding_token + 3)] = 0x00;
4263: decode = text;
4264: if (encoding == 'q' || encoding == 'Q') { /* Decode 'q' encoded data */
4265: for(i=0; text[i] != 0x00; i++) if (text[i] == '_') text[i] = ' '; /* Replace all *_' with space. */
4266: decode = (char *)rfc822_qprint((unsigned char *) text, strlen(text), &newlength);
4267: } else if (encoding == 'b' || encoding == 'B') {
4268: decode = (char *)rfc822_base64((unsigned char *) text, strlen(text), &newlength); /* Decode 'B' encoded data */
4269: }
4270: if (decode == NULL) {
4271: efree(charset);
4272: zval_dtor(return_value);
4273: RETURN_FALSE;
4274: }
4275: MAKE_STD_ZVAL(myobject);
4276: object_init(myobject);
4277: add_property_string(myobject, "charset", charset, 1);
4278: add_property_string(myobject, "text", decode, 1);
4279: zend_hash_next_index_insert(Z_ARRVAL_P(return_value), (void *)&myobject, sizeof(zval *), NULL);
4280:
4281: /* only free decode if it was allocated by rfc822_qprint or rfc822_base64 */
4282: if (decode != text) {
4283: fs_give((void**)&decode);
4284: }
4285:
4286: offset = end_token+2;
4287: for (i = 0; (string[offset + i] == ' ') || (string[offset + i] == 0x0a) || (string[offset + i] == 0x0d) || (string[offset + i] == '\t'); i++);
4288: if ((string[offset + i] == '=') && (string[offset + i + 1] == '?') && (offset + i < end)) {
4289: offset += i;
4290: }
4291: continue; /*/ Iterate the loop again please. */
4292: }
4293: }
4294: } else {
4295: /* Just some tweaking to optimize the code, and get the end statements work in a general manner.
4296: * If we end up here we didn't find a position for "charset_token",
4297: * so we need to set it to the start of the yet unextracted data.
4298: */
4299: charset_token = offset;
4300: }
4301: /* Return the rest of the data as unencoded, as it was either unencoded or was missing separators
4302: which rendered the remainder of the string impossible for us to decode. */
4303: memcpy(text, &string[charset_token], end - charset_token); /* Extract unencoded text from string */
4304: text[end - charset_token] = 0x00;
4305: MAKE_STD_ZVAL(myobject);
4306: object_init(myobject);
4307: add_property_string(myobject, "charset", "default", 1);
4308: add_property_string(myobject, "text", text, 1);
4309: zend_hash_next_index_insert(Z_ARRVAL_P(return_value), (void *)&myobject, sizeof(zval *), NULL);
4310:
4311: offset = end; /* We have reached the end of the string. */
4312: }
4313: efree(charset);
4314: }
4315: /* }}} */
4316:
4317: /* Support Functions */
4318:
4319: #ifdef HAVE_RFC822_OUTPUT_ADDRESS_LIST
4320: /* {{{ _php_rfc822_soutr
4321: */
4322: static long _php_rfc822_soutr (void *stream, char *string)
4323: {
4324: smart_str *ret = (smart_str*)stream;
4325: int len = strlen(string);
4326:
4327: smart_str_appendl(ret, string, len);
4328: return LONGT;
4329: }
4330: /* }}} */
4331:
4332: /* {{{ _php_rfc822_write_address
4333: */
4334: static char* _php_rfc822_write_address(ADDRESS *addresslist TSRMLS_DC)
4335: {
4336: char address[MAILTMPLEN];
4337: smart_str ret = {0};
4338: RFC822BUFFER buf;
4339:
4340: buf.beg = address;
4341: buf.cur = buf.beg;
4342: buf.end = buf.beg + sizeof(address) - 1;
4343: buf.s = &ret;
4344: buf.f = _php_rfc822_soutr;
4345: rfc822_output_address_list(&buf, addresslist, 0, NULL);
4346: rfc822_output_flush(&buf);
4347: smart_str_0(&ret);
4348: return ret.c;
4349: }
4350: /* }}} */
4351:
4352: #else
4353:
4354: /* {{{ _php_rfc822_len
4355: * Calculate string length based on imap's rfc822_cat function.
4356: */
4357: static int _php_rfc822_len(char *str)
4358: {
4359: int len;
4360: char *p;
4361:
4362: if (!str || !*str) {
4363: return 0;
4364: }
4365:
4366: /* strings with special characters will need to be quoted, as a safety measure we
4367: * add 2 bytes for the quotes just in case.
4368: */
4369: len = strlen(str) + 2;
4370: p = str;
4371: /* rfc822_cat() will escape all " and \ characters, therefor we need to increase
4372: * our buffer length to account for these characters.
4373: */
4374: while ((p = strpbrk(p, "\\\""))) {
4375: p++;
4376: len++;
4377: }
4378:
4379: return len;
4380: }
4381: /* }}} */
4382:
4383: /* {{{ _php_imap_get_address_size
4384: */
4385: static int _php_imap_address_size (ADDRESS *addresslist)
4386: {
4387: ADDRESS *tmp;
4388: int ret=0, num_ent=0;
4389:
4390: tmp = addresslist;
4391:
4392: if (tmp) do {
4393: ret += _php_rfc822_len(tmp->personal);
4394: ret += _php_rfc822_len(tmp->adl);
4395: ret += _php_rfc822_len(tmp->mailbox);
4396: ret += _php_rfc822_len(tmp->host);
4397: num_ent++;
4398: } while ((tmp = tmp->next));
4399:
4400: /*
4401: * rfc822_write_address_full() needs some extra space for '<>,', etc.
4402: * for this perpouse we allocate additional PHP_IMAP_ADDRESS_SIZE_BUF bytes
4403: * by default this buffer is 10 bytes long
4404: */
4405: ret += (ret) ? num_ent*PHP_IMAP_ADDRESS_SIZE_BUF : 0;
4406:
4407: return ret;
4408: }
4409:
4410: /* }}} */
4411:
4412: /* {{{ _php_rfc822_write_address
4413: */
4414: static char* _php_rfc822_write_address(ADDRESS *addresslist TSRMLS_DC)
4415: {
4416: char address[SENDBUFLEN];
4417:
4418: if (_php_imap_address_size(addresslist) >= SENDBUFLEN) {
4419: php_error_docref(NULL TSRMLS_CC, E_ERROR, "Address buffer overflow");
4420: return NULL;
4421: }
4422: address[0] = 0;
4423: rfc822_write_address(address, addresslist);
4424: return estrdup(address);
4425: }
4426: /* }}} */
4427: #endif
4428: /* {{{ _php_imap_parse_address
4429: */
4430: static char* _php_imap_parse_address (ADDRESS *addresslist, zval *paddress TSRMLS_DC)
4431: {
4432: char *fulladdress;
4433: ADDRESS *addresstmp;
4434: zval *tmpvals;
4435:
4436: addresstmp = addresslist;
4437:
4438: fulladdress = _php_rfc822_write_address(addresstmp TSRMLS_CC);
4439:
4440: addresstmp = addresslist;
4441: do {
4442: MAKE_STD_ZVAL(tmpvals);
4443: object_init(tmpvals);
4444: if (addresstmp->personal) add_property_string(tmpvals, "personal", addresstmp->personal, 1);
4445: if (addresstmp->adl) add_property_string(tmpvals, "adl", addresstmp->adl, 1);
4446: if (addresstmp->mailbox) add_property_string(tmpvals, "mailbox", addresstmp->mailbox, 1);
4447: if (addresstmp->host) add_property_string(tmpvals, "host", addresstmp->host, 1);
4448: add_next_index_object(paddress, tmpvals TSRMLS_CC);
4449: } while ((addresstmp = addresstmp->next));
4450: return fulladdress;
4451: }
4452: /* }}} */
4453:
4454: /* {{{ _php_make_header_object
4455: */
4456: static void _php_make_header_object(zval *myzvalue, ENVELOPE *en TSRMLS_DC)
4457: {
4458: zval *paddress;
4459: char *fulladdress=NULL;
4460:
4461: object_init(myzvalue);
4462:
4463: if (en->remail) add_property_string(myzvalue, "remail", en->remail, 1);
4464: if (en->date) add_property_string(myzvalue, "date", en->date, 1);
4465: if (en->date) add_property_string(myzvalue, "Date", en->date, 1);
4466: if (en->subject) add_property_string(myzvalue, "subject", en->subject, 1);
4467: if (en->subject) add_property_string(myzvalue, "Subject", en->subject, 1);
4468: if (en->in_reply_to) add_property_string(myzvalue, "in_reply_to", en->in_reply_to, 1);
4469: if (en->message_id) add_property_string(myzvalue, "message_id", en->message_id, 1);
4470: if (en->newsgroups) add_property_string(myzvalue, "newsgroups", en->newsgroups, 1);
4471: if (en->followup_to) add_property_string(myzvalue, "followup_to", en->followup_to, 1);
4472: if (en->references) add_property_string(myzvalue, "references", en->references, 1);
4473:
4474: if (en->to) {
4475: MAKE_STD_ZVAL(paddress);
4476: array_init(paddress);
4477: fulladdress = _php_imap_parse_address(en->to, paddress TSRMLS_CC);
4478: if (fulladdress) {
4479: add_property_string(myzvalue, "toaddress", fulladdress, 0);
4480: }
4481: add_assoc_object(myzvalue, "to", paddress TSRMLS_CC);
4482: }
4483:
4484: if (en->from) {
4485: MAKE_STD_ZVAL(paddress);
4486: array_init(paddress);
4487: fulladdress = _php_imap_parse_address(en->from, paddress TSRMLS_CC);
4488: if (fulladdress) {
4489: add_property_string(myzvalue, "fromaddress", fulladdress, 0);
4490: }
4491: add_assoc_object(myzvalue, "from", paddress TSRMLS_CC);
4492: }
4493:
4494: if (en->cc) {
4495: MAKE_STD_ZVAL(paddress);
4496: array_init(paddress);
4497: fulladdress = _php_imap_parse_address(en->cc, paddress TSRMLS_CC);
4498: if (fulladdress) {
4499: add_property_string(myzvalue, "ccaddress", fulladdress, 0);
4500: }
4501: add_assoc_object(myzvalue, "cc", paddress TSRMLS_CC);
4502: }
4503:
4504: if (en->bcc) {
4505: MAKE_STD_ZVAL(paddress);
4506: array_init(paddress);
4507: fulladdress = _php_imap_parse_address(en->bcc, paddress TSRMLS_CC);
4508: if (fulladdress) {
4509: add_property_string(myzvalue, "bccaddress", fulladdress, 0);
4510: }
4511: add_assoc_object(myzvalue, "bcc", paddress TSRMLS_CC);
4512: }
4513:
4514: if (en->reply_to) {
4515: MAKE_STD_ZVAL(paddress);
4516: array_init(paddress);
4517: fulladdress = _php_imap_parse_address(en->reply_to, paddress TSRMLS_CC);
4518: if (fulladdress) {
4519: add_property_string(myzvalue, "reply_toaddress", fulladdress, 0);
4520: }
4521: add_assoc_object(myzvalue, "reply_to", paddress TSRMLS_CC);
4522: }
4523:
4524: if (en->sender) {
4525: MAKE_STD_ZVAL(paddress);
4526: array_init(paddress);
4527: fulladdress = _php_imap_parse_address(en->sender, paddress TSRMLS_CC);
4528: if (fulladdress) {
4529: add_property_string(myzvalue, "senderaddress", fulladdress, 0);
4530: }
4531: add_assoc_object(myzvalue, "sender", paddress TSRMLS_CC);
4532: }
4533:
4534: if (en->return_path) {
4535: MAKE_STD_ZVAL(paddress);
4536: array_init(paddress);
4537: fulladdress = _php_imap_parse_address(en->return_path, paddress TSRMLS_CC);
4538: if (fulladdress) {
4539: add_property_string(myzvalue, "return_pathaddress", fulladdress, 0);
4540: }
4541: add_assoc_object(myzvalue, "return_path", paddress TSRMLS_CC);
4542: }
4543: }
4544: /* }}} */
4545:
4546: /* {{{ _php_imap_add_body
4547: */
4548: void _php_imap_add_body(zval *arg, BODY *body TSRMLS_DC)
4549: {
4550: zval *parametres, *param, *dparametres, *dparam;
4551: PARAMETER *par, *dpar;
4552: PART *part;
4553:
4554: if (body->type <= TYPEMAX) {
4555: add_property_long(arg, "type", body->type);
4556: }
4557:
4558: if (body->encoding <= ENCMAX) {
4559: add_property_long(arg, "encoding", body->encoding);
4560: }
4561:
4562: if (body->subtype) {
4563: add_property_long(arg, "ifsubtype", 1);
4564: add_property_string(arg, "subtype", body->subtype, 1);
4565: } else {
4566: add_property_long(arg, "ifsubtype", 0);
4567: }
4568:
4569: if (body->description) {
4570: add_property_long(arg, "ifdescription", 1);
4571: add_property_string(arg, "description", body->description, 1);
4572: } else {
4573: add_property_long(arg, "ifdescription", 0);
4574: }
4575:
4576: if (body->id) {
4577: add_property_long(arg, "ifid", 1);
4578: add_property_string(arg, "id", body->id, 1);
4579: } else {
4580: add_property_long(arg, "ifid", 0);
4581: }
4582:
4583: if (body->size.lines) {
4584: add_property_long(arg, "lines", body->size.lines);
4585: }
4586:
4587: if (body->size.bytes) {
4588: add_property_long(arg, "bytes", body->size.bytes);
4589: }
4590:
4591: #ifdef IMAP41
4592: if (body->disposition.type) {
4593: add_property_long(arg, "ifdisposition", 1);
4594: add_property_string(arg, "disposition", body->disposition.type, 1);
4595: } else {
4596: add_property_long(arg, "ifdisposition", 0);
4597: }
4598:
4599: if (body->disposition.parameter) {
4600: dpar = body->disposition.parameter;
4601: add_property_long(arg, "ifdparameters", 1);
4602: MAKE_STD_ZVAL(dparametres);
4603: array_init(dparametres);
4604: do {
4605: MAKE_STD_ZVAL(dparam);
4606: object_init(dparam);
4607: add_property_string(dparam, "attribute", dpar->attribute, 1);
4608: add_property_string(dparam, "value", dpar->value, 1);
4609: add_next_index_object(dparametres, dparam TSRMLS_CC);
4610: } while ((dpar = dpar->next));
4611: add_assoc_object(arg, "dparameters", dparametres TSRMLS_CC);
4612: } else {
4613: add_property_long(arg, "ifdparameters", 0);
4614: }
4615: #endif
4616:
4617: if ((par = body->parameter)) {
4618: add_property_long(arg, "ifparameters", 1);
4619:
4620: MAKE_STD_ZVAL(parametres);
4621: array_init(parametres);
4622: do {
4623: MAKE_STD_ZVAL(param);
4624: object_init(param);
4625: if (par->attribute) {
4626: add_property_string(param, "attribute", par->attribute, 1);
4627: }
4628: if (par->value) {
4629: add_property_string(param, "value", par->value, 1);
4630: }
4631:
4632: add_next_index_object(parametres, param TSRMLS_CC);
4633: } while ((par = par->next));
4634: } else {
4635: MAKE_STD_ZVAL(parametres);
4636: object_init(parametres);
4637: add_property_long(arg, "ifparameters", 0);
4638: }
4639: add_assoc_object(arg, "parameters", parametres TSRMLS_CC);
4640:
4641: /* multipart message ? */
4642: if (body->type == TYPEMULTIPART) {
4643: MAKE_STD_ZVAL(parametres);
4644: array_init(parametres);
4645: for (part = body->CONTENT_PART; part; part = part->next) {
4646: MAKE_STD_ZVAL(param);
4647: object_init(param);
4648: _php_imap_add_body(param, &part->body TSRMLS_CC);
4649: add_next_index_object(parametres, param TSRMLS_CC);
4650: }
4651: add_assoc_object(arg, "parts", parametres TSRMLS_CC);
4652: }
4653:
4654: /* encapsulated message ? */
4655: if ((body->type == TYPEMESSAGE) && (!strcasecmp(body->subtype, "rfc822"))) {
4656: body = body->CONTENT_MSG_BODY;
4657: MAKE_STD_ZVAL(parametres);
4658: array_init(parametres);
4659: MAKE_STD_ZVAL(param);
4660: object_init(param);
4661: _php_imap_add_body(param, body TSRMLS_CC);
4662: add_next_index_object(parametres, param TSRMLS_CC);
4663: add_assoc_object(arg, "parts", parametres TSRMLS_CC);
4664: }
4665: }
4666: /* }}} */
4667:
4668: /* imap_thread, stealing this from header cclient -rjs3 */
4669: /* {{{ build_thread_tree_helper
4670: */
4671: static void build_thread_tree_helper(THREADNODE *cur, zval *tree, long *numNodes, char *buf)
4672: {
4673: unsigned long thisNode = *numNodes;
4674:
4675: /* define "#.num" */
4676: snprintf(buf, 25, "%ld.num", thisNode);
4677:
4678: add_assoc_long(tree, buf, cur->num);
4679:
4680: snprintf(buf, 25, "%ld.next", thisNode);
4681: if(cur->next) {
4682: (*numNodes)++;
4683: add_assoc_long(tree, buf, *numNodes);
4684: build_thread_tree_helper(cur->next, tree, numNodes, buf);
4685: } else { /* "null pointer" */
4686: add_assoc_long(tree, buf, 0);
4687: }
4688:
4689: snprintf(buf, 25, "%ld.branch", thisNode);
4690: if(cur->branch) {
4691: (*numNodes)++;
4692: add_assoc_long(tree, buf, *numNodes);
4693: build_thread_tree_helper(cur->branch, tree, numNodes, buf);
4694: } else { /* "null pointer" */
4695: add_assoc_long(tree, buf, 0);
4696: }
4697: }
4698: /* }}} */
4699:
4700: /* {{{ build_thread_tree
4701: */
4702: static int build_thread_tree(THREADNODE *top, zval **tree)
4703: {
4704: long numNodes = 0;
4705: char buf[25];
4706:
4707: array_init(*tree);
4708:
4709: build_thread_tree_helper(top, *tree, &numNodes, buf);
4710:
4711: return SUCCESS;
4712: }
4713: /* }}} */
4714:
4715: /* {{{ proto array imap_thread(resource stream_id [, int options])
4716: Return threaded by REFERENCES tree */
4717: PHP_FUNCTION(imap_thread)
4718: {
4719: zval *streamind;
4720: pils *imap_le_struct;
4721: long flags = SE_FREE;
4722: char criteria[] = "ALL";
4723: THREADNODE *top;
4724: int argc = ZEND_NUM_ARGS();
4725: SEARCHPGM *pgm = NIL;
4726:
4727: if (zend_parse_parameters(argc TSRMLS_CC, "r|l", &streamind, &flags) == FAILURE) {
4728: return;
4729: }
4730:
4731: ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
4732:
4733: pgm = mail_criteria(criteria);
4734: top = mail_thread(imap_le_struct->imap_stream, "REFERENCES", NIL, pgm, flags);
4735: if (pgm && !(flags & SE_FREE)) {
4736: mail_free_searchpgm(&pgm);
4737: }
4738:
4739: if(top == NIL) {
4740: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Function returned an empty tree");
4741: RETURN_FALSE;
4742: }
4743:
4744: /* Populate our return value data structure here. */
4745: if(build_thread_tree(top, &return_value) == FAILURE) {
4746: mail_free_threadnode(&top);
4747: RETURN_FALSE;
4748: }
4749: mail_free_threadnode(&top);
4750: }
4751: /* }}} */
4752:
4753: /* {{{ proto mixed imap_timeout(int timeout_type [, int timeout])
4754: Set or fetch imap timeout */
4755: PHP_FUNCTION(imap_timeout)
4756: {
4757: long ttype, timeout=-1;
4758: int timeout_type;
4759:
4760: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|l", &ttype, &timeout) == FAILURE) {
4761: RETURN_FALSE;
4762: }
4763:
4764: if (timeout == -1) {
4765: switch (ttype) {
4766: case 1:
4767: timeout_type = GET_OPENTIMEOUT;
4768: break;
4769: case 2:
4770: timeout_type = GET_READTIMEOUT;
4771: break;
4772: case 3:
4773: timeout_type = GET_WRITETIMEOUT;
4774: break;
4775: case 4:
4776: timeout_type = GET_CLOSETIMEOUT;
4777: break;
4778: default:
4779: RETURN_FALSE;
4780: break;
4781: }
4782:
4783: timeout = (long) mail_parameters(NIL, timeout_type, NIL);
4784: RETURN_LONG(timeout);
4785: } else if (timeout >= 0) {
4786: switch (ttype) {
4787: case 1:
4788: timeout_type = SET_OPENTIMEOUT;
4789: break;
4790: case 2:
4791: timeout_type = SET_READTIMEOUT;
4792: break;
4793: case 3:
4794: timeout_type = SET_WRITETIMEOUT;
4795: break;
4796: case 4:
4797: timeout_type = SET_CLOSETIMEOUT;
4798: break;
4799: default:
4800: RETURN_FALSE;
4801: break;
4802: }
4803:
4804: timeout = (long) mail_parameters(NIL, timeout_type, (void *) timeout);
4805: RETURN_TRUE;
4806: } else {
4807: RETURN_FALSE;
4808: }
4809: }
4810: /* }}} */
4811:
4812: #define GETS_FETCH_SIZE 8196LU
4813: static char *php_mail_gets(readfn_t f, void *stream, unsigned long size, GETS_DATA *md) /* {{{ */
4814: {
4815: TSRMLS_FETCH();
4816:
4817: /* write to the gets stream if it is set,
4818: otherwise forward to c-clients gets */
4819: if (IMAPG(gets_stream)) {
4820: char buf[GETS_FETCH_SIZE];
4821:
4822: while (size) {
4823: unsigned long read;
4824:
4825: if (size > GETS_FETCH_SIZE) {
4826: read = GETS_FETCH_SIZE;
4827: size -=GETS_FETCH_SIZE;
4828: } else {
4829: read = size;
4830: size = 0;
4831: }
4832:
4833: if (!f(stream, read, buf)) {
4834: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to read from socket");
4835: break;
4836: } else if (read != php_stream_write(IMAPG(gets_stream), buf, read)) {
4837: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to write to stream");
4838: break;
4839: }
4840: }
4841: return NULL;
4842: } else {
4843: char *buf = pemalloc(size + 1, 1);
4844:
4845: if (f(stream, size, buf)) {
4846: buf[size] = '\0';
4847: } else {
4848: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to read from socket");
4849: free(buf);
4850: buf = NULL;
4851: }
4852: return buf;
4853: }
4854: }
4855: /* }}} */
4856:
4857: /* {{{ Interfaces to C-client
4858: */
4859: PHP_IMAP_EXPORT void mm_searched(MAILSTREAM *stream, unsigned long number)
4860: {
4861: MESSAGELIST *cur = NIL;
4862: TSRMLS_FETCH();
4863:
4864: if (IMAPG(imap_messages) == NIL) {
4865: IMAPG(imap_messages) = mail_newmessagelist();
4866: IMAPG(imap_messages)->msgid = number;
4867: IMAPG(imap_messages)->next = NIL;
4868: IMAPG(imap_messages_tail) = IMAPG(imap_messages);
4869: } else {
4870: cur = IMAPG(imap_messages_tail);
4871: cur->next = mail_newmessagelist();
4872: cur = cur->next;
4873: cur->msgid = number;
4874: cur->next = NIL;
4875: IMAPG(imap_messages_tail) = cur;
4876: }
4877: }
4878:
4879: PHP_IMAP_EXPORT void mm_exists(MAILSTREAM *stream, unsigned long number)
4880: {
4881: }
4882:
4883: PHP_IMAP_EXPORT void mm_expunged(MAILSTREAM *stream, unsigned long number)
4884: {
4885: }
4886:
4887: PHP_IMAP_EXPORT void mm_flags(MAILSTREAM *stream, unsigned long number)
4888: {
4889: }
4890:
4891: /* Author: CJH */
4892: PHP_IMAP_EXPORT void mm_notify(MAILSTREAM *stream, char *str, long errflg)
4893: {
4894: STRINGLIST *cur = NIL;
4895: TSRMLS_FETCH();
4896:
4897: if (strncmp(str, "[ALERT] ", 8) == 0) {
4898: if (IMAPG(imap_alertstack) == NIL) {
4899: IMAPG(imap_alertstack) = mail_newstringlist();
4900: IMAPG(imap_alertstack)->LSIZE = strlen(IMAPG(imap_alertstack)->LTEXT = cpystr(str));
4901: IMAPG(imap_alertstack)->next = NIL;
4902: } else {
4903: cur = IMAPG(imap_alertstack);
4904: while (cur->next != NIL) {
4905: cur = cur->next;
4906: }
4907: cur->next = mail_newstringlist ();
4908: cur = cur->next;
4909: cur->LSIZE = strlen(cur->LTEXT = cpystr(str));
4910: cur->next = NIL;
4911: }
4912: }
4913: }
4914:
4915: PHP_IMAP_EXPORT void mm_list(MAILSTREAM *stream, DTYPE delimiter, char *mailbox, long attributes)
4916: {
4917: STRINGLIST *cur=NIL;
4918: FOBJECTLIST *ocur=NIL;
4919: TSRMLS_FETCH();
4920:
4921: if (IMAPG(folderlist_style) == FLIST_OBJECT) {
4922: /* build up a the new array of objects */
4923: /* Author: CJH */
4924: if (IMAPG(imap_folder_objects) == NIL) {
4925: IMAPG(imap_folder_objects) = mail_newfolderobjectlist();
4926: IMAPG(imap_folder_objects)->LSIZE=strlen(IMAPG(imap_folder_objects)->LTEXT=cpystr(mailbox));
4927: IMAPG(imap_folder_objects)->delimiter = delimiter;
4928: IMAPG(imap_folder_objects)->attributes = attributes;
4929: IMAPG(imap_folder_objects)->next = NIL;
4930: IMAPG(imap_folder_objects_tail) = IMAPG(imap_folder_objects);
4931: } else {
4932: ocur=IMAPG(imap_folder_objects_tail);
4933: ocur->next=mail_newfolderobjectlist();
4934: ocur=ocur->next;
4935: ocur->LSIZE = strlen(ocur->LTEXT = cpystr(mailbox));
4936: ocur->delimiter = delimiter;
4937: ocur->attributes = attributes;
4938: ocur->next = NIL;
4939: IMAPG(imap_folder_objects_tail) = ocur;
4940: }
4941:
4942: } else {
4943: /* build the old IMAPG(imap_folders) variable to allow old imap_listmailbox() to work */
4944: if (!(attributes & LATT_NOSELECT)) {
4945: if (IMAPG(imap_folders) == NIL) {
4946: IMAPG(imap_folders)=mail_newstringlist();
4947: IMAPG(imap_folders)->LSIZE=strlen(IMAPG(imap_folders)->LTEXT=cpystr(mailbox));
4948: IMAPG(imap_folders)->next=NIL;
4949: IMAPG(imap_folders_tail) = IMAPG(imap_folders);
4950: } else {
4951: cur=IMAPG(imap_folders_tail);
4952: cur->next=mail_newstringlist ();
4953: cur=cur->next;
4954: cur->LSIZE = strlen (cur->LTEXT = cpystr (mailbox));
4955: cur->next = NIL;
4956: IMAPG(imap_folders_tail) = cur;
4957: }
4958: }
4959: }
4960: }
4961:
4962: PHP_IMAP_EXPORT void mm_lsub(MAILSTREAM *stream, DTYPE delimiter, char *mailbox, long attributes)
4963: {
4964: STRINGLIST *cur=NIL;
4965: FOBJECTLIST *ocur=NIL;
4966: TSRMLS_FETCH();
4967:
4968: if (IMAPG(folderlist_style) == FLIST_OBJECT) {
4969: /* build the array of objects */
4970: /* Author: CJH */
4971: if (IMAPG(imap_sfolder_objects) == NIL) {
4972: IMAPG(imap_sfolder_objects) = mail_newfolderobjectlist();
4973: IMAPG(imap_sfolder_objects)->LSIZE=strlen(IMAPG(imap_sfolder_objects)->LTEXT=cpystr(mailbox));
4974: IMAPG(imap_sfolder_objects)->delimiter = delimiter;
4975: IMAPG(imap_sfolder_objects)->attributes = attributes;
4976: IMAPG(imap_sfolder_objects)->next = NIL;
4977: IMAPG(imap_sfolder_objects_tail) = IMAPG(imap_sfolder_objects);
4978: } else {
4979: ocur=IMAPG(imap_sfolder_objects_tail);
4980: ocur->next=mail_newfolderobjectlist();
4981: ocur=ocur->next;
4982: ocur->LSIZE=strlen(ocur->LTEXT = cpystr(mailbox));
4983: ocur->delimiter = delimiter;
4984: ocur->attributes = attributes;
4985: ocur->next = NIL;
4986: IMAPG(imap_sfolder_objects_tail) = ocur;
4987: }
4988: } else {
4989: /* build the old simple array for imap_listsubscribed() */
4990: if (IMAPG(imap_sfolders) == NIL) {
4991: IMAPG(imap_sfolders)=mail_newstringlist();
4992: IMAPG(imap_sfolders)->LSIZE=strlen(IMAPG(imap_sfolders)->LTEXT=cpystr(mailbox));
4993: IMAPG(imap_sfolders)->next=NIL;
4994: IMAPG(imap_sfolders_tail) = IMAPG(imap_sfolders);
4995: } else {
4996: cur=IMAPG(imap_sfolders_tail);
4997: cur->next=mail_newstringlist ();
4998: cur=cur->next;
4999: cur->LSIZE = strlen (cur->LTEXT = cpystr (mailbox));
5000: cur->next = NIL;
5001: IMAPG(imap_sfolders_tail) = cur;
5002: }
5003: }
5004: }
5005:
5006: PHP_IMAP_EXPORT void mm_status(MAILSTREAM *stream, char *mailbox, MAILSTATUS *status)
5007: {
5008: TSRMLS_FETCH();
5009:
5010: IMAPG(status_flags)=status->flags;
5011: if (IMAPG(status_flags) & SA_MESSAGES) {
5012: IMAPG(status_messages)=status->messages;
5013: }
5014: if (IMAPG(status_flags) & SA_RECENT) {
5015: IMAPG(status_recent)=status->recent;
5016: }
5017: if (IMAPG(status_flags) & SA_UNSEEN) {
5018: IMAPG(status_unseen)=status->unseen;
5019: }
5020: if (IMAPG(status_flags) & SA_UIDNEXT) {
5021: IMAPG(status_uidnext)=status->uidnext;
5022: }
5023: if (IMAPG(status_flags) & SA_UIDVALIDITY) {
5024: IMAPG(status_uidvalidity)=status->uidvalidity;
5025: }
5026: }
5027:
5028: PHP_IMAP_EXPORT void mm_log(char *str, long errflg)
5029: {
5030: ERRORLIST *cur = NIL;
5031: TSRMLS_FETCH();
5032:
5033: /* Author: CJH */
5034: if (errflg != NIL) { /* CJH: maybe put these into a more comprehensive log for debugging purposes? */
5035: if (IMAPG(imap_errorstack) == NIL) {
5036: IMAPG(imap_errorstack) = mail_newerrorlist();
5037: IMAPG(imap_errorstack)->LSIZE = strlen(IMAPG(imap_errorstack)->LTEXT = cpystr(str));
5038: IMAPG(imap_errorstack)->errflg = errflg;
5039: IMAPG(imap_errorstack)->next = NIL;
5040: } else {
5041: cur = IMAPG(imap_errorstack);
5042: while (cur->next != NIL) {
5043: cur = cur->next;
5044: }
5045: cur->next = mail_newerrorlist();
5046: cur = cur->next;
5047: cur->LSIZE = strlen(cur->LTEXT = cpystr(str));
5048: cur->errflg = errflg;
5049: cur->next = NIL;
5050: }
5051: }
5052: }
5053:
5054: PHP_IMAP_EXPORT void mm_dlog(char *str)
5055: {
5056: /* CJH: this is for debugging; it might be useful to allow setting
5057: the stream to debug mode and capturing this somewhere - syslog?
5058: php debugger? */
5059: }
5060:
5061: PHP_IMAP_EXPORT void mm_login(NETMBX *mb, char *user, char *pwd, long trial)
5062: {
5063: TSRMLS_FETCH();
5064:
5065: if (*mb->user) {
5066: strlcpy (user, mb->user, MAILTMPLEN);
5067: } else {
5068: strlcpy (user, IMAPG(imap_user), MAILTMPLEN);
5069: }
5070: strlcpy (pwd, IMAPG(imap_password), MAILTMPLEN);
5071: }
5072:
5073: PHP_IMAP_EXPORT void mm_critical(MAILSTREAM *stream)
5074: {
5075: }
5076:
5077: PHP_IMAP_EXPORT void mm_nocritical(MAILSTREAM *stream)
5078: {
5079: }
5080:
5081: PHP_IMAP_EXPORT long mm_diskerror(MAILSTREAM *stream, long errcode, long serious)
5082: {
5083: return 1;
5084: }
5085:
5086: PHP_IMAP_EXPORT void mm_fatal(char *str)
5087: {
5088: }
5089: /* }}} */
5090:
5091: /*
5092: * Local variables:
5093: * tab-width: 4
5094: * c-basic-offset: 4
5095: * End:
5096: * vim600: sw=4 ts=4 fdm=marker
5097: * vim<600: sw=4 ts=4
5098: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to php_imap.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / imap