PageRenderTime 62ms CodeModel.GetById 16ms RepoModel.GetById 1ms app.codeStats 1ms

/ext/imap/php_imap.c

http://github.com/infusion/PHP
C | 5095 lines | 3811 code | 702 blank | 582 comment | 869 complexity | 19aaaebfa2eb11f6332dff5a49519ba6 MD5 | raw file
Possible License(s): MPL-2.0-no-copyleft-exception, LGPL-2.1, BSD-3-Clause

Large files files are truncated, but you can click here to view the full file

    

  1. /*
    2. 

  2.    +----------------------------------------------------------------------+
    3. 

  3.    | PHP Version 5                                                        |
    4. 

  4.    +----------------------------------------------------------------------+
    5. 

  5.    | Copyright (c) 1997-2011 The PHP Group                                |
    6. 

  6.    +----------------------------------------------------------------------+
    7. 

  7.    | This source file is subject to version 3.01 of the PHP license,      |
    8. 

  8.    | that is bundled with this package in the file LICENSE, and is        |
    9. 

  9.    | available through the world-wide-web at the following url:           |
    10. 

  10.    | http://www.php.net/license/3_01.txt                                  |
    11. 

  11.    | If you did not receive a copy of the PHP license and are unable to   |
    12. 

  12.    | obtain it through the world-wide-web, please send a note to          |
    13. 

  13.    | license@php.net so we can mail you a copy immediately.               |
    14. 

  14.    +----------------------------------------------------------------------+
    15. 

  15.    | Authors: Rex Logan           <veebert@dimensional.com>               |
    16. 

  16.    |          Mark Musone         <musone@afterfive.com>                  |
    17. 

  17.    |          Brian Wang          <brian@vividnet.com>                    |
    18. 

  18.    |          Kaj-Michael Lang    <milang@tal.org>                        |
    19. 

  19.    |          Antoni Pamies Olive <toni@readysoft.net>                    |
    20. 

  20.    |          Rasmus Lerdorf      <rasmus@php.net>                        |
    21. 

  21.    |          Chuck Hagenbuch     <chuck@horde.org>                       |
    22. 

  22.    |          Andrew Skalski      <askalski@chekinc.com>                  |
    23. 

  23.    |          Hartmut Holzgraefe  <hholzgra@php.net>                      |
    24. 

  24.    |          Jani Taskinen       <jani.taskinen@iki.fi>                  |
    25. 

  25.    |          Daniel R. Kalowsky  <kalowsky@php.net>                      |
    26. 

  26.    | PHP 4.0 updates:  Zeev Suraski <zeev@zend.com>                       |
    27. 

  27.    +----------------------------------------------------------------------+
    28. 

  28.  */
    29. 

  29. /* $Id: php_imap.c 307691 2011-01-24 03:52:00Z stas $ */
    30. 

  30. 

  31. #define IMAP41
    32. 

  32. 

  33. #ifdef HAVE_CONFIG_H
    34. 

  34. #include "config.h"
    35. 

  35. #endif
    36. 

  36. 

  37. #include "php.h"
    38. 

  38. #include "php_ini.h"
    39. 

  39. #include "php_streams.h"
    40. 

  40. #include "ext/standard/php_string.h"
    41. 

  41. #include "ext/standard/info.h"
    42. 

  42. #include "ext/standard/file.h"
    43. 

  43. #include "ext/standard/php_smart_str.h"
    44. 

  44. #include "ext/pcre/php_pcre.h"
    45. 

  45. 

  46. #ifdef ERROR
    47. 

  47. #undef ERROR
    48. 

  48. #endif
    49. 

  49. #include "php_imap.h"
    50. 

  50. 

  51. #include <time.h>
    52. 

  52. #include <stdio.h>
    53. 

  53. #include <ctype.h>
    54. 

  54. #include <signal.h>
    55. 

  55. 

  56. #ifdef PHP_WIN32
    57. 

  57. #include <winsock2.h>
    58. 

  58. #include <stdlib.h>
    59. 

  59. #include "win32/sendmail.h"
    60. 

  60. MAILSTREAM DEFAULTPROTO;
    61. 

  61. #endif
    62. 

  62. 

  63. #define CRLF	"\015\012"
    64. 

  64. #define CRLF_LEN sizeof("\015\012") - 1
    65. 

  65. #define PHP_EXPUNGE 32768
    66. 

  66. #define PHP_IMAP_ADDRESS_SIZE_BUF 10
    67. 

  67. #ifndef SENDBUFLEN
    68. 

  68. #define SENDBUFLEN 16385
    69. 

  69. #endif
    70. 

  70. 

  71. #if defined(__GNUC__) && __GNUC__ >= 4
    72. 

  72. # define PHP_IMAP_EXPORT __attribute__ ((visibility("default")))
    73. 

  73. #else
    74. 

  74. # define PHP_IMAP_EXPORT
    75. 

  75. #endif
    76. 

  76. 

  77. static void _php_make_header_object(zval *myzvalue, ENVELOPE *en TSRMLS_DC);
    78. 

  78. static void _php_imap_add_body(zval *arg, BODY *body TSRMLS_DC);
    79. 

  79. static char* _php_imap_parse_address(ADDRESS *addresslist, zval *paddress TSRMLS_DC);
    80. 

  80. static char* _php_rfc822_write_address(ADDRESS *addresslist TSRMLS_DC);
    81. 

  81. 

  82. /* the gets we use */
    83. 

  83. static char *php_mail_gets(readfn_t f, void *stream, unsigned long size, GETS_DATA *md);
    84. 

  84. 

  85. /* These function declarations are missing from the IMAP header files... */
    86. 

  86. void rfc822_date(char *date);
    87. 

  87. char *cpystr(const char *str);
    88. 

  88. char *cpytxt(SIZEDTEXT *dst, char *text, unsigned long size);
    89. 

  89. #ifndef HAVE_NEW_MIME2TEXT
    90. 

  90. long utf8_mime2text(SIZEDTEXT *src, SIZEDTEXT *dst);
    91. 

  91. #else
    92. 

  92. long utf8_mime2text (SIZEDTEXT *src, SIZEDTEXT *dst, long flags);
    93. 

  93. #endif
    94. 

  94. unsigned long find_rightmost_bit(unsigned long *valptr);
    95. 

  95. void fs_give(void **block);
    96. 

  96. void *fs_get(size_t size);
    97. 

  97. 

  98. ZEND_DECLARE_MODULE_GLOBALS(imap)
    99. 

  99. static PHP_GINIT_FUNCTION(imap);
    100. 

  100. 

  101. /* {{{ arginfo */
    102. 

  102. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_open, 0, 0, 3)
    103. 

  103. 	ZEND_ARG_INFO(0, mailbox)
    104. 

  104. 	ZEND_ARG_INFO(0, user)
    105. 

  105. 	ZEND_ARG_INFO(0, password)
    106. 

  106. 	ZEND_ARG_INFO(0, options)
    107. 

  107. 	ZEND_ARG_INFO(0, n_retries)
    108. 

  108. 	ZEND_ARG_INFO(0, params)
    109. 

  109. ZEND_END_ARG_INFO()
    110. 

  110. 

  111. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_reopen, 0, 0, 2)
    112. 

  112. 	ZEND_ARG_INFO(0, stream_id)
    113. 

  113. 	ZEND_ARG_INFO(0, mailbox)
    114. 

  114. 	ZEND_ARG_INFO(0, options)
    115. 

  115. 	ZEND_ARG_INFO(0, n_retries)
    116. 

  116. ZEND_END_ARG_INFO()
    117. 

  117. 

  118. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_append, 0, 0, 3)
    119. 

  119. 	ZEND_ARG_INFO(0, stream_id)
    120. 

  120. 	ZEND_ARG_INFO(0, folder)
    121. 

  121. 	ZEND_ARG_INFO(0, message)
    122. 

  122. 	ZEND_ARG_INFO(0, options)
    123. 

  123. 	ZEND_ARG_INFO(0, date)
    124. 

  124. ZEND_END_ARG_INFO()
    125. 

  125. 

  126. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_num_msg, 0, 0, 1)
    127. 

  127. 	ZEND_ARG_INFO(0, stream_id)
    128. 

  128. ZEND_END_ARG_INFO()
    129. 

  129. 

  130. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_ping, 0, 0, 1)
    131. 

  131. 	ZEND_ARG_INFO(0, stream_id)
    132. 

  132. ZEND_END_ARG_INFO()
    133. 

  133. 

  134. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_num_recent, 0, 0, 1)
    135. 

  135. 	ZEND_ARG_INFO(0, stream_id)
    136. 

  136. ZEND_END_ARG_INFO()
    137. 

  137. 

  138. #if defined(HAVE_IMAP2000) || defined(HAVE_IMAP2001)
    139. 

  139. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_get_quota, 0, 0, 2)
    140. 

  140. 	ZEND_ARG_INFO(0, stream_id)
    141. 

  141. 	ZEND_ARG_INFO(0, qroot)
    142. 

  142. ZEND_END_ARG_INFO()
    143. 

  143. 

  144. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_get_quotaroot, 0, 0, 2)
    145. 

  145. 	ZEND_ARG_INFO(0, stream_id)
    146. 

  146. 	ZEND_ARG_INFO(0, mbox)
    147. 

  147. ZEND_END_ARG_INFO()
    148. 

  148. 

  149. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_set_quota, 0, 0, 3)
    150. 

  150. 	ZEND_ARG_INFO(0, stream_id)
    151. 

  151. 	ZEND_ARG_INFO(0, qroot)
    152. 

  152. 	ZEND_ARG_INFO(0, mailbox_size)
    153. 

  153. ZEND_END_ARG_INFO()
    154. 

  154. 

  155. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_setacl, 0, 0, 4)
    156. 

  156. 	ZEND_ARG_INFO(0, stream_id)
    157. 

  157. 	ZEND_ARG_INFO(0, mailbox)
    158. 

  158. 	ZEND_ARG_INFO(0, id)
    159. 

  159. 	ZEND_ARG_INFO(0, rights)
    160. 

  160. ZEND_END_ARG_INFO()
    161. 

  161. 

  162. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_getacl, 0, 0, 2)
    163. 

  163. 	ZEND_ARG_INFO(0, stream_id)
    164. 

  164. 	ZEND_ARG_INFO(0, mailbox)
    165. 

  165. ZEND_END_ARG_INFO()
    166. 

  166. #endif
    167. 

  167. 

  168. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_expunge, 0, 0, 1)
    169. 

  169. 	ZEND_ARG_INFO(0, stream_id)
    170. 

  170. ZEND_END_ARG_INFO()
    171. 

  171. 

  172. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_gc, 0, 0, 1)
    173. 

  173. 	ZEND_ARG_INFO(0, stream_id)
    174. 

  174. 	ZEND_ARG_INFO(0, flags)
    175. 

  175. ZEND_END_ARG_INFO()
    176. 

  176. 

  177. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_close, 0, 0, 1)
    178. 

  178. 	ZEND_ARG_INFO(0, stream_id)
    179. 

  179. 	ZEND_ARG_INFO(0, options)
    180. 

  180. ZEND_END_ARG_INFO()
    181. 

  181. 

  182. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_headers, 0, 0, 1)
    183. 

  183. 	ZEND_ARG_INFO(0, stream_id)
    184. 

  184. ZEND_END_ARG_INFO()
    185. 

  185. 

  186. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_body, 0, 0, 2)
    187. 

  187. 	ZEND_ARG_INFO(0, stream_id)
    188. 

  188. 	ZEND_ARG_INFO(0, msg_no)
    189. 

  189. 	ZEND_ARG_INFO(0, options)
    190. 

  190. ZEND_END_ARG_INFO()
    191. 

  191. 

  192. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_mail_copy, 0, 0, 3)
    193. 

  193. 	ZEND_ARG_INFO(0, stream_id)
    194. 

  194. 	ZEND_ARG_INFO(0, msglist)
    195. 

  195. 	ZEND_ARG_INFO(0, mailbox)
    196. 

  196. 	ZEND_ARG_INFO(0, options)
    197. 

  197. ZEND_END_ARG_INFO()
    198. 

  198. 

  199. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_mail_move, 0, 0, 3)
    200. 

  200. 	ZEND_ARG_INFO(0, stream_id)
    201. 

  201. 	ZEND_ARG_INFO(0, sequence)
    202. 

  202. 	ZEND_ARG_INFO(0, mailbox)
    203. 

  203. 	ZEND_ARG_INFO(0, options)
    204. 

  204. ZEND_END_ARG_INFO()
    205. 

  205. 

  206. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_createmailbox, 0, 0, 2)
    207. 

  207. 	ZEND_ARG_INFO(0, stream_id)
    208. 

  208. 	ZEND_ARG_INFO(0, mailbox)
    209. 

  209. ZEND_END_ARG_INFO()
    210. 

  210. 

  211. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_renamemailbox, 0, 0, 3)
    212. 

  212. 	ZEND_ARG_INFO(0, stream_id)
    213. 

  213. 	ZEND_ARG_INFO(0, old_name)
    214. 

  214. 	ZEND_ARG_INFO(0, new_name)
    215. 

  215. ZEND_END_ARG_INFO()
    216. 

  216. 

  217. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_deletemailbox, 0, 0, 2)
    218. 

  218. 	ZEND_ARG_INFO(0, stream_id)
    219. 

  219. 	ZEND_ARG_INFO(0, mailbox)
    220. 

  220. ZEND_END_ARG_INFO()
    221. 

  221. 

  222. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_list, 0, 0, 3)
    223. 

  223. 	ZEND_ARG_INFO(0, stream_id)
    224. 

  224. 	ZEND_ARG_INFO(0, ref)
    225. 

  225. 	ZEND_ARG_INFO(0, pattern)
    226. 

  226. ZEND_END_ARG_INFO()
    227. 

  227. 

  228. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_getmailboxes, 0, 0, 3)
    229. 

  229. 	ZEND_ARG_INFO(0, stream_id)
    230. 

  230. 	ZEND_ARG_INFO(0, ref)
    231. 

  231. 	ZEND_ARG_INFO(0, pattern)
    232. 

  232. ZEND_END_ARG_INFO()
    233. 

  233. 

  234. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_listscan, 0, 0, 4)
    235. 

  235. 	ZEND_ARG_INFO(0, stream_id)
    236. 

  236. 	ZEND_ARG_INFO(0, ref)
    237. 

  237. 	ZEND_ARG_INFO(0, pattern)
    238. 

  238. 	ZEND_ARG_INFO(0, content)
    239. 

  239. ZEND_END_ARG_INFO()
    240. 

  240. 

  241. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_check, 0, 0, 1)
    242. 

  242. 	ZEND_ARG_INFO(0, stream_id)
    243. 

  243. ZEND_END_ARG_INFO()
    244. 

  244. 

  245. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_delete, 0, 0, 2)
    246. 

  246. 	ZEND_ARG_INFO(0, stream_id)
    247. 

  247. 	ZEND_ARG_INFO(0, msg_no)
    248. 

  248. 	ZEND_ARG_INFO(0, options)
    249. 

  249. ZEND_END_ARG_INFO()
    250. 

  250. 

  251. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_undelete, 0, 0, 2)
    252. 

  252. 	ZEND_ARG_INFO(0, stream_id)
    253. 

  253. 	ZEND_ARG_INFO(0, msg_no)
    254. 

  254. 	ZEND_ARG_INFO(0, flags)
    255. 

  255. ZEND_END_ARG_INFO()
    256. 

  256. 

  257. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_headerinfo, 0, 0, 2)
    258. 

  258. 	ZEND_ARG_INFO(0, stream_id)
    259. 

  259. 	ZEND_ARG_INFO(0, msg_no)
    260. 

  260. 	ZEND_ARG_INFO(0, from_length)
    261. 

  261. 	ZEND_ARG_INFO(0, subject_length)
    262. 

  262. 	ZEND_ARG_INFO(0, default_host)
    263. 

  263. ZEND_END_ARG_INFO()
    264. 

  264. 

  265. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_rfc822_parse_headers, 0, 0, 1)
    266. 

  266. 	ZEND_ARG_INFO(0, headers)
    267. 

  267. 	ZEND_ARG_INFO(0, default_host)
    268. 

  268. ZEND_END_ARG_INFO()
    269. 

  269. 

  270. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_lsub, 0, 0, 3)
    271. 

  271. 	ZEND_ARG_INFO(0, stream_id)
    272. 

  272. 	ZEND_ARG_INFO(0, ref)
    273. 

  273. 	ZEND_ARG_INFO(0, pattern)
    274. 

  274. ZEND_END_ARG_INFO()
    275. 

  275. 

  276. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_getsubscribed, 0, 0, 3)
    277. 

  277. 	ZEND_ARG_INFO(0, stream_id)
    278. 

  278. 	ZEND_ARG_INFO(0, ref)
    279. 

  279. 	ZEND_ARG_INFO(0, pattern)
    280. 

  280. ZEND_END_ARG_INFO()
    281. 

  281. 

  282. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_subscribe, 0, 0, 2)
    283. 

  283. 	ZEND_ARG_INFO(0, stream_id)
    284. 

  284. 	ZEND_ARG_INFO(0, mailbox)
    285. 

  285. ZEND_END_ARG_INFO()
    286. 

  286. 

  287. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_unsubscribe, 0, 0, 2)
    288. 

  288. 	ZEND_ARG_INFO(0, stream_id)
    289. 

  289. 	ZEND_ARG_INFO(0, mailbox)
    290. 

  290. ZEND_END_ARG_INFO()
    291. 

  291. 

  292. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_fetchstructure, 0, 0, 2)
    293. 

  293. 	ZEND_ARG_INFO(0, stream_id)
    294. 

  294. 	ZEND_ARG_INFO(0, msg_no)
    295. 

  295. 	ZEND_ARG_INFO(0, options)
    296. 

  296. ZEND_END_ARG_INFO()
    297. 

  297. 

  298. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_fetchbody, 0, 0, 3)
    299. 

  299. 	ZEND_ARG_INFO(0, stream_id)
    300. 

  300. 	ZEND_ARG_INFO(0, msg_no)
    301. 

  301. 	ZEND_ARG_INFO(0, section)
    302. 

  302. 	ZEND_ARG_INFO(0, options)
    303. 

  303. ZEND_END_ARG_INFO()
    304. 

  304. 

  305. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_savebody, 0, 0, 3)
    306. 

  306. 	ZEND_ARG_INFO(0, stream_id)
    307. 

  307. 	ZEND_ARG_INFO(0, file)
    308. 

  308. 	ZEND_ARG_INFO(0, msg_no)
    309. 

  309. 	ZEND_ARG_INFO(0, section)
    310. 

  310. 	ZEND_ARG_INFO(0, options)
    311. 

  311. ZEND_END_ARG_INFO()
    312. 

  312. 

  313. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_base64, 0, 0, 1)
    314. 

  314. 	ZEND_ARG_INFO(0, text)
    315. 

  315. ZEND_END_ARG_INFO()
    316. 

  316. 

  317. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_qprint, 0, 0, 1)
    318. 

  318. 	ZEND_ARG_INFO(0, text)
    319. 

  319. ZEND_END_ARG_INFO()
    320. 

  320. 

  321. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_8bit, 0, 0, 1)
    322. 

  322. 	ZEND_ARG_INFO(0, text)
    323. 

  323. ZEND_END_ARG_INFO()
    324. 

  324. 

  325. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_binary, 0, 0, 1)
    326. 

  326. 	ZEND_ARG_INFO(0, text)
    327. 

  327. ZEND_END_ARG_INFO()
    328. 

  328. 

  329. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_mailboxmsginfo, 0, 0, 1)
    330. 

  330. 	ZEND_ARG_INFO(0, stream_id)
    331. 

  331. ZEND_END_ARG_INFO()
    332. 

  332. 

  333. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_rfc822_write_address, 0, 0, 3)
    334. 

  334. 	ZEND_ARG_INFO(0, mailbox)
    335. 

  335. 	ZEND_ARG_INFO(0, host)
    336. 

  336. 	ZEND_ARG_INFO(0, personal)
    337. 

  337. ZEND_END_ARG_INFO()
    338. 

  338. 

  339. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_rfc822_parse_adrlist, 0, 0, 2)
    340. 

  340. 	ZEND_ARG_INFO(0, address_string)
    341. 

  341. 	ZEND_ARG_INFO(0, default_host)
    342. 

  342. ZEND_END_ARG_INFO()
    343. 

  343. 

  344. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_utf8, 0, 0, 1)
    345. 

  345. 	ZEND_ARG_INFO(0, mime_encoded_text)
    346. 

  346. ZEND_END_ARG_INFO()
    347. 

  347. 

  348. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_utf7_decode, 0, 0, 1)
    349. 

  349. 	ZEND_ARG_INFO(0, buf)
    350. 

  350. ZEND_END_ARG_INFO()
    351. 

  351. 

  352. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_utf7_encode, 0, 0, 1)
    353. 

  353. 	ZEND_ARG_INFO(0, buf)
    354. 

  354. ZEND_END_ARG_INFO()
    355. 

  355. 

  356. #ifdef HAVE_IMAP_MUTF7
    357. 

  357. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_utf8_to_mutf7, 0, 0, 1)
    358. 

  358. 	ZEND_ARG_INFO(0, in)
    359. 

  359. ZEND_END_ARG_INFO()
    360. 

  360. 

  361. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_mutf7_to_utf8, 0, 0, 1)
    362. 

  362. 	ZEND_ARG_INFO(0, in)
    363. 

  363. ZEND_END_ARG_INFO()
    364. 

  364. #endif
    365. 

  365. 

  366. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_setflag_full, 0, 0, 3)
    367. 

  367. 	ZEND_ARG_INFO(0, stream_id)
    368. 

  368. 	ZEND_ARG_INFO(0, sequence)
    369. 

  369. 	ZEND_ARG_INFO(0, flag)
    370. 

  370. 	ZEND_ARG_INFO(0, options)
    371. 

  371. ZEND_END_ARG_INFO()
    372. 

  372. 

  373. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_clearflag_full, 0, 0, 3)
    374. 

  374. 	ZEND_ARG_INFO(0, stream_id)
    375. 

  375. 	ZEND_ARG_INFO(0, sequence)
    376. 

  376. 	ZEND_ARG_INFO(0, flag)
    377. 

  377. 	ZEND_ARG_INFO(0, options)
    378. 

  378. ZEND_END_ARG_INFO()
    379. 

  379. 

  380. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_sort, 0, 0, 3)
    381. 

  381. 	ZEND_ARG_INFO(0, stream_id)
    382. 

  382. 	ZEND_ARG_INFO(0, criteria)
    383. 

  383. 	ZEND_ARG_INFO(0, reverse)
    384. 

  384. 	ZEND_ARG_INFO(0, options)
    385. 

  385. 	ZEND_ARG_INFO(0, search_criteria)
    386. 

  386. 	ZEND_ARG_INFO(0, charset)
    387. 

  387. ZEND_END_ARG_INFO()
    388. 

  388. 

  389. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_fetchheader, 0, 0, 2)
    390. 

  390. 	ZEND_ARG_INFO(0, stream_id)
    391. 

  391. 	ZEND_ARG_INFO(0, msg_no)
    392. 

  392. 	ZEND_ARG_INFO(0, options)
    393. 

  393. ZEND_END_ARG_INFO()
    394. 

  394. 

  395. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_uid, 0, 0, 2)
    396. 

  396. 	ZEND_ARG_INFO(0, stream_id)
    397. 

  397. 	ZEND_ARG_INFO(0, msg_no)
    398. 

  398. ZEND_END_ARG_INFO()
    399. 

  399. 

  400. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_msgno, 0, 0, 2)
    401. 

  401. 	ZEND_ARG_INFO(0, stream_id)
    402. 

  402. 	ZEND_ARG_INFO(0, unique_msg_id)
    403. 

  403. ZEND_END_ARG_INFO()
    404. 

  404. 

  405. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_status, 0, 0, 3)
    406. 

  406. 	ZEND_ARG_INFO(0, stream_id)
    407. 

  407. 	ZEND_ARG_INFO(0, mailbox)
    408. 

  408. 	ZEND_ARG_INFO(0, options)
    409. 

  409. ZEND_END_ARG_INFO()
    410. 

  410. 

  411. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_bodystruct, 0, 0, 3)
    412. 

  412. 	ZEND_ARG_INFO(0, stream_id)
    413. 

  413. 	ZEND_ARG_INFO(0, msg_no)
    414. 

  414. 	ZEND_ARG_INFO(0, section)
    415. 

  415. ZEND_END_ARG_INFO()
    416. 

  416. 

  417. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_fetch_overview, 0, 0, 2)
    418. 

  418. 	ZEND_ARG_INFO(0, stream_id)
    419. 

  419. 	ZEND_ARG_INFO(0, sequence)
    420. 

  420. 	ZEND_ARG_INFO(0, options)
    421. 

  421. ZEND_END_ARG_INFO()
    422. 

  422. 

  423. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_mail_compose, 0, 0, 2)
    424. 

  424. 	ZEND_ARG_INFO(0, envelope)
    425. 

  425. 	ZEND_ARG_INFO(0, body)
    426. 

  426. ZEND_END_ARG_INFO()
    427. 

  427. 

  428. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_mail, 0, 0, 3)
    429. 

  429. 	ZEND_ARG_INFO(0, to)
    430. 

  430. 	ZEND_ARG_INFO(0, subject)
    431. 

  431. 	ZEND_ARG_INFO(0, message)
    432. 

  432. 	ZEND_ARG_INFO(0, additional_headers)
    433. 

  433. 	ZEND_ARG_INFO(0, cc)
    434. 

  434. 	ZEND_ARG_INFO(0, bcc)
    435. 

  435. 	ZEND_ARG_INFO(0, rpath)
    436. 

  436. ZEND_END_ARG_INFO()
    437. 

  437. 

  438. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_search, 0, 0, 2)
    439. 

  439. 	ZEND_ARG_INFO(0, stream_id)
    440. 

  440. 	ZEND_ARG_INFO(0, criteria)
    441. 

  441. 	ZEND_ARG_INFO(0, options)
    442. 

  442. 	ZEND_ARG_INFO(0, charset)
    443. 

  443. ZEND_END_ARG_INFO()
    444. 

  444. 

  445. ZEND_BEGIN_ARG_INFO(arginfo_imap_alerts, 0)
    446. 

  446. ZEND_END_ARG_INFO()
    447. 

  447. 

  448. ZEND_BEGIN_ARG_INFO(arginfo_imap_errors, 0)
    449. 

  449. ZEND_END_ARG_INFO()
    450. 

  450. 

  451. ZEND_BEGIN_ARG_INFO(arginfo_imap_last_error, 0)
    452. 

  452. ZEND_END_ARG_INFO()
    453. 

  453. 

  454. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_mime_header_decode, 0, 0, 1)
    455. 

  455. 	ZEND_ARG_INFO(0, str)
    456. 

  456. ZEND_END_ARG_INFO()
    457. 

  457. 

  458. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_thread, 0, 0, 1)
    459. 

  459. 	ZEND_ARG_INFO(0, stream_id)
    460. 

  460. 	ZEND_ARG_INFO(0, options)
    461. 

  461. ZEND_END_ARG_INFO()
    462. 

  462. 

  463. ZEND_BEGIN_ARG_INFO_EX(arginfo_imap_timeout, 0, 0, 1)
    464. 

  464. 	ZEND_ARG_INFO(0, timeout_type)
    465. 

  465. 	ZEND_ARG_INFO(0, timeout)
    466. 

  466. ZEND_END_ARG_INFO()
    467. 

  467. /* }}} */
    468. 

  468. 

  469. /* {{{ imap_functions[]
    470. 

  470.  */
    471. 

  471. const zend_function_entry imap_functions[] = {
    472. 

  472. 	PHP_FE(imap_open,								arginfo_imap_open)
    473. 

  473. 	PHP_FE(imap_reopen,								arginfo_imap_reopen)
    474. 

  474. 	PHP_FE(imap_close,								arginfo_imap_close)
    475. 

  475. 	PHP_FE(imap_num_msg,							arginfo_imap_num_msg)
    476. 

  476. 	PHP_FE(imap_num_recent,							arginfo_imap_num_recent)
    477. 

  477. 	PHP_FE(imap_headers,							arginfo_imap_headers)
    478. 

  478. 	PHP_FE(imap_headerinfo,							arginfo_imap_headerinfo)
    479. 

  479. 	PHP_FE(imap_rfc822_parse_headers,				arginfo_imap_rfc822_parse_headers)
    480. 

  480. 	PHP_FE(imap_rfc822_write_address,				arginfo_imap_rfc822_write_address)
    481. 

  481. 	PHP_FE(imap_rfc822_parse_adrlist,				arginfo_imap_rfc822_parse_adrlist)
    482. 

  482. 	PHP_FE(imap_body,								arginfo_imap_body)
    483. 

  483. 	PHP_FE(imap_bodystruct,							arginfo_imap_bodystruct)
    484. 

  484. 	PHP_FE(imap_fetchbody,							arginfo_imap_fetchbody)
    485. 

  485. 	PHP_FE(imap_fetchmime,							arginfo_imap_fetchbody)
    486. 

  486. 	PHP_FE(imap_savebody,							arginfo_imap_savebody)
    487. 

  487. 	PHP_FE(imap_fetchheader,						arginfo_imap_fetchheader)
    488. 

  488. 	PHP_FE(imap_fetchstructure,						arginfo_imap_fetchstructure)
    489. 

  489. 	PHP_FE(imap_gc,										arginfo_imap_gc)
    490. 

  490. 	PHP_FE(imap_expunge,							arginfo_imap_expunge)
    491. 

  491. 	PHP_FE(imap_delete,								arginfo_imap_delete)
    492. 

  492. 	PHP_FE(imap_undelete,							arginfo_imap_undelete)
    493. 

  493. 	PHP_FE(imap_check,								arginfo_imap_check)
    494. 

  494. 	PHP_FE(imap_listscan,							arginfo_imap_listscan)
    495. 

  495. 	PHP_FE(imap_mail_copy,							arginfo_imap_mail_copy)
    496. 

  496. 	PHP_FE(imap_mail_move,							arginfo_imap_mail_move)
    497. 

  497. 	PHP_FE(imap_mail_compose,						arginfo_imap_mail_compose)
    498. 

  498. 	PHP_FE(imap_createmailbox,						arginfo_imap_createmailbox)
    499. 

  499. 	PHP_FE(imap_renamemailbox,						arginfo_imap_renamemailbox)
    500. 

  500. 	PHP_FE(imap_deletemailbox,						arginfo_imap_deletemailbox)
    501. 

  501. 	PHP_FE(imap_subscribe,							arginfo_imap_subscribe)
    502. 

  502. 	PHP_FE(imap_unsubscribe,						arginfo_imap_unsubscribe)
    503. 

  503. 	PHP_FE(imap_append,								arginfo_imap_append)
    504. 

  504. 	PHP_FE(imap_ping,								arginfo_imap_ping)
    505. 

  505. 	PHP_FE(imap_base64,								arginfo_imap_base64)
    506. 

  506. 	PHP_FE(imap_qprint,								arginfo_imap_qprint)
    507. 

  507. 	PHP_FE(imap_8bit,								arginfo_imap_8bit)
    508. 

  508. 	PHP_FE(imap_binary,								arginfo_imap_binary)
    509. 

  509. 	PHP_FE(imap_utf8,								arginfo_imap_utf8)
    510. 

  510. 	PHP_FE(imap_status,								arginfo_imap_status)
    511. 

  511. 	PHP_FE(imap_mailboxmsginfo,						arginfo_imap_mailboxmsginfo)
    512. 

  512. 	PHP_FE(imap_setflag_full,						arginfo_imap_setflag_full)
    513. 

  513. 	PHP_FE(imap_clearflag_full,						arginfo_imap_clearflag_full)
    514. 

  514. 	PHP_FE(imap_sort,								arginfo_imap_sort)
    515. 

  515. 	PHP_FE(imap_uid,								arginfo_imap_uid)
    516. 

  516. 	PHP_FE(imap_msgno,								arginfo_imap_msgno)
    517. 

  517. 	PHP_FE(imap_list,								arginfo_imap_list)
    518. 

  518. 	PHP_FE(imap_lsub,								arginfo_imap_lsub)
    519. 

  519. 	PHP_FE(imap_fetch_overview,						arginfo_imap_fetch_overview)
    520. 

  520. 	PHP_FE(imap_alerts,								arginfo_imap_alerts)
    521. 

  521. 	PHP_FE(imap_errors,								arginfo_imap_errors)
    522. 

  522. 	PHP_FE(imap_last_error,							arginfo_imap_last_error)
    523. 

  523. 	PHP_FE(imap_search,								arginfo_imap_search)
    524. 

  524. 	PHP_FE(imap_utf7_decode,						arginfo_imap_utf7_decode)
    525. 

  525. 	PHP_FE(imap_utf7_encode,						arginfo_imap_utf7_encode)
    526. 

  526. #ifdef HAVE_IMAP_MUTF7
    527. 

  527. 	PHP_FE(imap_utf8_to_mutf7,						arginfo_imap_utf8_to_mutf7)
    528. 

  528. 	PHP_FE(imap_mutf7_to_utf8,						arginfo_imap_mutf7_to_utf8)
    529. 

  529. #endif
    530. 

  530. 	PHP_FE(imap_mime_header_decode,					arginfo_imap_mime_header_decode)
    531. 

  531. 	PHP_FE(imap_thread,								arginfo_imap_thread)
    532. 

  532. 	PHP_FE(imap_timeout,								arginfo_imap_timeout)
    533. 

  533. 

  534. #if defined(HAVE_IMAP2000) || defined(HAVE_IMAP2001)
    535. 

  535. 	PHP_FE(imap_get_quota,							arginfo_imap_get_quota)
    536. 

  536. 	PHP_FE(imap_get_quotaroot,						arginfo_imap_get_quotaroot)
    537. 

  537. 	PHP_FE(imap_set_quota,							arginfo_imap_set_quota)
    538. 

  538. 	PHP_FE(imap_setacl,								arginfo_imap_setacl)
    539. 

  539. 	PHP_FE(imap_getacl,								arginfo_imap_getacl)
    540. 

  540. #endif
    541. 

  541. 

  542. 	PHP_FE(imap_mail,								arginfo_imap_mail)
    543. 

  543. 

  544. 	PHP_FALIAS(imap_header,			imap_headerinfo,	arginfo_imap_headerinfo)
    545. 

  545. 	PHP_FALIAS(imap_listmailbox,	imap_list,			arginfo_imap_list)
    546. 

  546. 	PHP_FALIAS(imap_getmailboxes,	imap_list_full,		arginfo_imap_getmailboxes)
    547. 

  547. 	PHP_FALIAS(imap_scanmailbox,	imap_listscan,		arginfo_imap_listscan)
    548. 

  548. 	PHP_FALIAS(imap_listsubscribed,	imap_lsub,			arginfo_imap_lsub)
    549. 

  549. 	PHP_FALIAS(imap_getsubscribed,	imap_lsub_full,		arginfo_imap_getsubscribed)
    550. 

  550. 	PHP_FALIAS(imap_fetchtext,		imap_body,			arginfo_imap_body)
    551. 

  551. 	PHP_FALIAS(imap_scan,			imap_listscan,		arginfo_imap_listscan)
    552. 

  552. 	PHP_FALIAS(imap_create,			imap_createmailbox,	arginfo_imap_createmailbox)
    553. 

  553. 	PHP_FALIAS(imap_rename,			imap_renamemailbox,	arginfo_imap_renamemailbox)
    554. 

  554. 	{NULL, NULL, NULL}
    555. 

  555. };
    556. 

  556. /* }}} */
    557. 

  557. 

  558. /* {{{ imap dependencies */
    559. 

  559. static const zend_module_dep imap_deps[] = {
    560. 

  560. 	ZEND_MOD_REQUIRED("standard")
    561. 

  561. 	{NULL, NULL, NULL}
    562. 

  562. };
    563. 

  563. /* }}} */
    564. 

  564. 

  565. /* {{{ imap_module_entry
    566. 

  566.  */
    567. 

  567. zend_module_entry imap_module_entry = {
    568. 

  568. 	STANDARD_MODULE_HEADER_EX, NULL,
    569. 

  569. 	imap_deps,
    570. 

  570. 	"imap",
    571. 

  571. 	imap_functions,
    572. 

  572. 	PHP_MINIT(imap),
    573. 

  573. 	NULL,
    574. 

  574. 	PHP_RINIT(imap),
    575. 

  575. 	PHP_RSHUTDOWN(imap),
    576. 

  576. 	PHP_MINFO(imap),
    577. 

  577. 	NO_VERSION_YET,
    578. 

  578. 	PHP_MODULE_GLOBALS(imap),
    579. 

  579. 	PHP_GINIT(imap),
    580. 

  580. 	NULL,
    581. 

  581. 	NULL,
    582. 

  582. 	STANDARD_MODULE_PROPERTIES_EX
    583. 

  583. };
    584. 

  584. /* }}} */
    585. 

  585. 

  586. #ifdef COMPILE_DL_IMAP
    587. 

  587. ZEND_GET_MODULE(imap)
    588. 

  588. #endif
    589. 

  589. 

  590. /* True globals, no need for thread safety */
    591. 

  591. static int le_imap;
    592. 

  592. 

  593. #define PHP_IMAP_CHECK_MSGNO(msgindex)	\
    594. 

  594. 	if ((msgindex < 1) || ((unsigned) msgindex > imap_le_struct->imap_stream->nmsgs)) {	\
    595. 

  595. 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Bad message number");	\
    596. 

  596. 		RETURN_FALSE;	\
    597. 

  597. 	}	\
    598. 

  598. 

  599. /* {{{ mail_close_it
    600. 

  600.  */
    601. 

  601. static void mail_close_it(zend_rsrc_list_entry *rsrc TSRMLS_DC)
    602. 

  602. {
    603. 

  603. 	pils *imap_le_struct = (pils *)rsrc->ptr;
    604. 

  604. 

  605. 	/* Do not try to close prototype streams */
    606. 

  606. 	if (!(imap_le_struct->flags & OP_PROTOTYPE)) {
    607. 

  607. 		mail_close_full(imap_le_struct->imap_stream, imap_le_struct->flags);
    608. 

  608. 	}
    609. 

  609. 

  610. 	if (IMAPG(imap_user)) {
    611. 

  611. 		efree(IMAPG(imap_user));
    612. 

  612. 		IMAPG(imap_user) = 0;
    613. 

  613. 	}
    614. 

  614. 	if (IMAPG(imap_password)) {
    615. 

  615. 		efree(IMAPG(imap_password));
    616. 

  616. 		IMAPG(imap_password) = 0;
    617. 

  617. 	}
    618. 

  618. 

  619. 	efree(imap_le_struct);
    620. 

  620. }
    621. 

  621. /* }}} */
    622. 

  622. 

  623. /* {{{ add_assoc_object
    624. 

  624.  */
    625. 

  625. static int add_assoc_object(zval *arg, char *key, zval *tmp TSRMLS_DC)
    626. 

  626. {
    627. 

  627. 	HashTable *symtable;
    628. 

  628. 

  629. 	if (Z_TYPE_P(arg) == IS_OBJECT) {
    630. 

  630. 		symtable = Z_OBJPROP_P(arg);
    631. 

  631. 	} else {
    632. 

  632. 		symtable = Z_ARRVAL_P(arg);
    633. 

  633. 	}
    634. 

  634. 	return zend_hash_update(symtable, key, strlen(key)+1, (void *) &tmp, sizeof(zval *), NULL);
    635. 

  635. }
    636. 

  636. /* }}} */
    637. 

  637. 

  638. /* {{{ add_next_index_object
    639. 

  639.  */
    640. 

  640. static inline int add_next_index_object(zval *arg, zval *tmp TSRMLS_DC)
    641. 

  641. {
    642. 

  642. 	HashTable *symtable;
    643. 

  643. 

  644. 	if (Z_TYPE_P(arg) == IS_OBJECT) {
    645. 

  645. 		symtable = Z_OBJPROP_P(arg);
    646. 

  646. 	} else {
    647. 

  647. 		symtable = Z_ARRVAL_P(arg);
    648. 

  648. 	}
    649. 

  649. 

  650. 	return zend_hash_next_index_insert(symtable, (void *) &tmp, sizeof(zval *), NULL);
    651. 

  651. }
    652. 

  652. /* }}} */
    653. 

  653. 

  654. /* {{{ mail_newfolderobjectlist
    655. 

  655.  *
    656. 

  656.  * Mail instantiate FOBJECTLIST
    657. 

  657.  * Returns: new FOBJECTLIST list
    658. 

  658.  * Author: CJH
    659. 

  659.  */
    660. 

  660. FOBJECTLIST *mail_newfolderobjectlist(void)
    661. 

  661. {
    662. 

  662. 	return (FOBJECTLIST *) memset(fs_get(sizeof(FOBJECTLIST)), 0, sizeof(FOBJECTLIST));
    663. 

  663. }
    664. 

  664. /* }}} */
    665. 

  665. 

  666. /* {{{ mail_free_foblist
    667. 

  667.  *
    668. 

  668.  * Mail garbage collect FOBJECTLIST
    669. 

  669.  * Accepts: pointer to FOBJECTLIST pointer
    670. 

  670.  * Author: CJH
    671. 

  671.  */
    672. 

  672. void mail_free_foblist(FOBJECTLIST **foblist, FOBJECTLIST **tail)
    673. 

  673. {
    674. 

  674. 	FOBJECTLIST *cur, *next;
    675. 

  675. 

  676. 	for (cur=*foblist, next=cur->next; cur; cur=next) {
    677. 

  677. 		next = cur->next;
    678. 

  678. 

  679. 		if(cur->text.data)
    680. 

  680. 			fs_give((void **)&(cur->text.data));
    681. 

  681. 

  682. 		fs_give((void **)&cur);
    683. 

  683. 	}
    684. 

  684. 

  685. 	*tail = NIL;
    686. 

  686. 	*foblist = NIL;
    687. 

  687. }
    688. 

  688. /* }}} */
    689. 

  689. 

  690. /* {{{ mail_newerrorlist
    691. 

  691.  *
    692. 

  692.  * Mail instantiate ERRORLIST
    693. 

  693.  * Returns: new ERRORLIST list
    694. 

  694.  * Author: CJH
    695. 

  695.  */
    696. 

  696. ERRORLIST *mail_newerrorlist(void)
    697. 

  697. {
    698. 

  698. 	return (ERRORLIST *) memset(fs_get(sizeof(ERRORLIST)), 0, sizeof(ERRORLIST));
    699. 

  699. }
    700. 

  700. /* }}} */
    701. 

  701. 

  702. /* {{{ mail_free_errorlist
    703. 

  703.  *
    704. 

  704.  * Mail garbage collect FOBJECTLIST
    705. 

  705.  * Accepts: pointer to FOBJECTLIST pointer
    706. 

  706.  * Author: CJH
    707. 

  707.  */
    708. 

  708. void mail_free_errorlist(ERRORLIST **errlist)
    709. 

  709. {
    710. 

  710. 	if (*errlist) {		/* only free if exists */
    711. 

  711. 		if ((*errlist)->text.data) {
    712. 

  712. 			fs_give((void **) &(*errlist)->text.data);
    713. 

  713. 		}
    714. 

  714. 		mail_free_errorlist (&(*errlist)->next);
    715. 

  715. 		fs_give((void **) errlist);	/* return string to free storage */
    716. 

  716. 	}
    717. 

  717. }
    718. 

  718. /* }}} */
    719. 

  719. 

  720. /* {{{ mail_newmessagelist
    721. 

  721.  *
    722. 

  722.  * Mail instantiate MESSAGELIST
    723. 

  723.  * Returns: new MESSAGELIST list
    724. 

  724.  * Author: CJH
    725. 

  725.  */
    726. 

  726. MESSAGELIST *mail_newmessagelist(void)
    727. 

  727. {
    728. 

  728. 	return (MESSAGELIST *) memset(fs_get(sizeof(MESSAGELIST)), 0, sizeof(MESSAGELIST));
    729. 

  729. }
    730. 

  730. /* }}} */
    731. 

  731. 

  732. /* {{{ mail_free_messagelist
    733. 

  733.  *
    734. 

  734.  * Mail garbage collect MESSAGELIST
    735. 

  735.  * Accepts: pointer to MESSAGELIST pointer
    736. 

  736.  * Author: CJH
    737. 

  737.  */
    738. 

  738. void mail_free_messagelist(MESSAGELIST **msglist, MESSAGELIST **tail)
    739. 

  739. {
    740. 

  740. 	MESSAGELIST *cur, *next;
    741. 

  741. 

  742. 	for (cur = *msglist, next = cur->next; cur; cur = next) {
    743. 

  743. 		next = cur->next;
    744. 

  744. 		fs_give((void **)&cur);
    745. 

  745. 	}
    746. 

  746. 

  747. 	*tail = NIL;
    748. 

  748. 	*msglist = NIL;
    749. 

  749. }
    750. 

  750. /* }}} */
    751. 

  751. 

  752. #if defined(HAVE_IMAP2000) || defined(HAVE_IMAP2001)
    753. 

  753. /* {{{ mail_getquota
    754. 

  754.  *
    755. 

  755.  * Mail GET_QUOTA callback
    756. 

  756.  * Called via the mail_parameter function in c-client:src/c-client/mail.c
    757. 

  757.  * Author DRK
    758. 

  758.  */
    759. 

  759. 

  760. void mail_getquota(MAILSTREAM *stream, char *qroot, QUOTALIST *qlist)
    761. 

  761. {
    762. 

  762. 	zval *t_map, *return_value;
    763. 

  763. 	TSRMLS_FETCH();
    764. 

  764. 

  765. 	return_value = *IMAPG(quota_return);
    766. 

  766. 

  767. /* put parsing code here */
    768. 

  768. 	for(; qlist; qlist = qlist->next) {
    769. 

  769. 		MAKE_STD_ZVAL(t_map);
    770. 

  770. 		array_init(t_map);
    771. 

  771. 		if (strncmp(qlist->name, "STORAGE", 7) == 0)
    772. 

  772. 		{
    773. 

  773. 			/* this is to add backwards compatibility */
    774. 

  774. 			add_assoc_long_ex(return_value, "usage", sizeof("usage"), qlist->usage);
    775. 

  775. 			add_assoc_long_ex(return_value, "limit", sizeof("limit"), qlist->limit);
    776. 

  776. 		}
    777. 

  777. 

  778. 		add_assoc_long_ex(t_map, "usage", sizeof("usage"), qlist->usage);
    779. 

  779. 		add_assoc_long_ex(t_map, "limit", sizeof("limit"), qlist->limit);
    780. 

  780. 		add_assoc_zval_ex(return_value, qlist->name, strlen(qlist->name)+1, t_map);
    781. 

  781. 	}
    782. 

  782. }
    783. 

  783. /* }}} */
    784. 

  784. 

  785. /* {{{ mail_getquota
    786. 

  786.  *
    787. 

  787.  * Mail GET_ACL callback
    788. 

  788.  * Called via the mail_parameter function in c-client:src/c-client/mail.c
    789. 

  789.  */
    790. 

  790. void mail_getacl(MAILSTREAM *stream, char *mailbox, ACLLIST *alist)
    791. 

  791. {
    792. 

  792. 	TSRMLS_FETCH();
    793. 

  793. 

  794. 	/* walk through the ACLLIST */
    795. 

  795. 	for(; alist; alist = alist->next) {
    796. 

  796. 		add_assoc_stringl(IMAPG(imap_acl_list), alist->identifier, alist->rights, strlen(alist->rights), 1);
    797. 

  797. 	}
    798. 

  798. }
    799. 

  799. /* }}} */
    800. 

  800. #endif
    801. 

  801. 

  802. /* {{{ PHP_GINIT_FUNCTION
    803. 

  803.  */
    804. 

  804. static PHP_GINIT_FUNCTION(imap)
    805. 

  805. {
    806. 

  806. 	imap_globals->imap_user = NIL;
    807. 

  807. 	imap_globals->imap_password = NIL;
    808. 

  808. 

  809. 	imap_globals->imap_alertstack = NIL;
    810. 

  810. 	imap_globals->imap_errorstack = NIL;
    811. 

  811. 

  812. 	imap_globals->imap_folders = NIL;
    813. 

  813. 	imap_globals->imap_folders_tail = NIL;
    814. 

  814. 	imap_globals->imap_sfolders = NIL;
    815. 

  815. 	imap_globals->imap_sfolders_tail = NIL;
    816. 

  816. 	imap_globals->imap_messages = NIL;
    817. 

  817. 	imap_globals->imap_messages_tail = NIL;
    818. 

  818. 	imap_globals->imap_folder_objects = NIL;
    819. 

  819. 	imap_globals->imap_folder_objects_tail = NIL;
    820. 

  820. 	imap_globals->imap_sfolder_objects = NIL;
    821. 

  821. 	imap_globals->imap_sfolder_objects_tail = NIL;
    822. 

  822. 

  823. 	imap_globals->folderlist_style = FLIST_ARRAY;
    824. 

  824. #if defined(HAVE_IMAP2000) || defined(HAVE_IMAP2001)
    825. 

  825. 	imap_globals->quota_return = NIL;
    826. 

  826. 	imap_globals->imap_acl_list = NIL;
    827. 

  827. #endif
    828. 

  828. 	imap_globals->gets_stream = NIL;
    829. 

  829. }
    830. 

  830. /* }}} */
    831. 

  831. 

  832. /* {{{ PHP_MINIT_FUNCTION
    833. 

  833.  */
    834. 

  834. PHP_MINIT_FUNCTION(imap)
    835. 

  835. {
    836. 

  836. 	unsigned long sa_all =	SA_MESSAGES | SA_RECENT | SA_UNSEEN | SA_UIDNEXT | SA_UIDVALIDITY;
    837. 

  837. 

  838. #ifndef PHP_WIN32
    839. 

  839. 	mail_link(&unixdriver);		/* link in the unix driver */
    840. 

  840. 	mail_link(&mhdriver);		/* link in the mh driver */
    841. 

  841. 	/* mail_link(&mxdriver); */	/* According to c-client docs (internal.txt) this shouldn't be used. */
    842. 

  842. 	mail_link(&mmdfdriver);		/* link in the mmdf driver */
    843. 

  843. 	mail_link(&newsdriver);		/* link in the news driver */
    844. 

  844. 	mail_link(&philedriver);	/* link in the phile driver */
    845. 

  845. #endif
    846. 

  846. 	mail_link(&imapdriver);		/* link in the imap driver */
    847. 

  847. 	mail_link(&nntpdriver);		/* link in the nntp driver */
    848. 

  848. 	mail_link(&pop3driver);		/* link in the pop3 driver */
    849. 

  849. 	mail_link(&mbxdriver);		/* link in the mbx driver */
    850. 

  850. 	mail_link(&tenexdriver);	/* link in the tenex driver */
    851. 

  851. 	mail_link(&mtxdriver);		/* link in the mtx driver */
    852. 

  852. 	mail_link(&dummydriver);	/* link in the dummy driver */
    853. 

  853. 

  854. #ifndef PHP_WIN32
    855. 

  855. 	auth_link(&auth_log);		/* link in the log authenticator */
    856. 

  856. 	auth_link(&auth_md5);		/* link in the cram-md5 authenticator */
    857. 

  857. #if HAVE_IMAP_KRB && defined(HAVE_IMAP_AUTH_GSS)
    858. 

  858. 	auth_link(&auth_gss);		/* link in the gss authenticator */
    859. 

  859. #endif
    860. 

  860. 	auth_link(&auth_pla);		/* link in the plain authenticator */
    861. 

  861. #endif
    862. 

  862. 

  863. #ifdef HAVE_IMAP_SSL
    864. 

  864. 	ssl_onceonlyinit ();
    865. 

  865. #endif
    866. 

  866. 

  867. 	/* lets allow NIL */
    868. 

  868. 	REGISTER_LONG_CONSTANT("NIL", NIL, CONST_PERSISTENT | CONST_CS);
    869. 

  869. 

  870. 	/* plug in our gets */
    871. 

  871. 	mail_parameters(NIL, SET_GETS, (void *) NIL);
    872. 

  872. 

  873. 	/* set default timeout values */
    874. 

  874. 	mail_parameters(NIL, SET_OPENTIMEOUT, (void *) FG(default_socket_timeout));
    875. 

  875. 	mail_parameters(NIL, SET_READTIMEOUT, (void *) FG(default_socket_timeout));
    876. 

  876. 	mail_parameters(NIL, SET_WRITETIMEOUT, (void *) FG(default_socket_timeout));
    877. 

  877. 	mail_parameters(NIL, SET_CLOSETIMEOUT, (void *) FG(default_socket_timeout));
    878. 

  878. 

  879. 	/* timeout constants */
    880. 

  880. 	REGISTER_LONG_CONSTANT("IMAP_OPENTIMEOUT", 1, CONST_PERSISTENT | CONST_CS);
    881. 

  881. 	REGISTER_LONG_CONSTANT("IMAP_READTIMEOUT", 2, CONST_PERSISTENT | CONST_CS);
    882. 

  882. 	REGISTER_LONG_CONSTANT("IMAP_WRITETIMEOUT", 3, CONST_PERSISTENT | CONST_CS);
    883. 

  883. 	REGISTER_LONG_CONSTANT("IMAP_CLOSETIMEOUT", 4, CONST_PERSISTENT | CONST_CS);
    884. 

  884. 

  885. 	/* Open Options */
    886. 

  886. 

  887. 	REGISTER_LONG_CONSTANT("OP_DEBUG", OP_DEBUG, CONST_PERSISTENT | CONST_CS);
    888. 

  888. 	/* debug protocol negotiations */
    889. 

  889. 	REGISTER_LONG_CONSTANT("OP_READONLY", OP_READONLY, CONST_PERSISTENT | CONST_CS);
    890. 

  890. 	/* read-only open */
    891. 

  891. 	REGISTER_LONG_CONSTANT("OP_ANONYMOUS", OP_ANONYMOUS, CONST_PERSISTENT | CONST_CS);
    892. 

  892. 	/* anonymous open of newsgroup */
    893. 

  893. 	REGISTER_LONG_CONSTANT("OP_SHORTCACHE", OP_SHORTCACHE, CONST_PERSISTENT | CONST_CS);
    894. 

  894. 	/* short (elt-only) caching */
    895. 

  895. 	REGISTER_LONG_CONSTANT("OP_SILENT", OP_SILENT, CONST_PERSISTENT | CONST_CS);
    896. 

  896. 	/* don't pass up events (internal use) */
    897. 

  897. 	REGISTER_LONG_CONSTANT("OP_PROTOTYPE", OP_PROTOTYPE, CONST_PERSISTENT | CONST_CS);
    898. 

  898. 	/* return driver prototype */
    899. 

  899. 	REGISTER_LONG_CONSTANT("OP_HALFOPEN", OP_HALFOPEN, CONST_PERSISTENT | CONST_CS);
    900. 

  900. 	/* half-open (IMAP connect but no select) */
    901. 

  901. 	REGISTER_LONG_CONSTANT("OP_EXPUNGE", OP_EXPUNGE, CONST_PERSISTENT | CONST_CS);
    902. 

  902. 	/* silently expunge recycle stream */
    903. 

  903. 	REGISTER_LONG_CONSTANT("OP_SECURE", OP_SECURE, CONST_PERSISTENT | CONST_CS);
    904. 

  904. 	/* don't do non-secure authentication */
    905. 

  905. 

  906. 	/*
    907. 

  907. 	PHP re-assigns CL_EXPUNGE a custom value that can be used as part of the imap_open() bitfield
    908. 

  908. 	because it seems like a good idea to be able to indicate that the mailbox should be
    909. 

  909. 	automatically expunged during imap_open in case the script get interrupted and it doesn't get
    910. 

  910. 	to the imap_close() where this option is normally placed.  If the c-client library adds other
    911. 

  911. 	options and the value for this one conflicts, simply make PHP_EXPUNGE higher at the top of
    912. 

  912. 	this file
    913. 

  913. 	*/
    914. 

  914. 	REGISTER_LONG_CONSTANT("CL_EXPUNGE", PHP_EXPUNGE, CONST_PERSISTENT | CONST_CS);
    915. 

  915. 	/* expunge silently */
    916. 

  916. 

  917. 	/* Fetch options */
    918. 

  918. 

  919. 	REGISTER_LONG_CONSTANT("FT_UID", FT_UID, CONST_PERSISTENT | CONST_CS);
    920. 

  920. 	/* argument is a UID */
    921. 

  921. 	REGISTER_LONG_CONSTANT("FT_PEEK", FT_PEEK, CONST_PERSISTENT | CONST_CS);
    922. 

  922. 	/* peek at data */
    923. 

  923. 	REGISTER_LONG_CONSTANT("FT_NOT", FT_NOT, CONST_PERSISTENT | CONST_CS);
    924. 

  924. 	/* NOT flag for header lines fetch */
    925. 

  925. 	REGISTER_LONG_CONSTANT("FT_INTERNAL", FT_INTERNAL, CONST_PERSISTENT | CONST_CS);
    926. 

  926. 	/* text can be internal strings */
    927. 

  927. 	REGISTER_LONG_CONSTANT("FT_PREFETCHTEXT", FT_PREFETCHTEXT, CONST_PERSISTENT | CONST_CS);
    928. 

  928. 	/* IMAP prefetch text when fetching header */
    929. 

  929. 

  930. 	/* Flagging options */
    931. 

  931. 

  932. 	REGISTER_LONG_CONSTANT("ST_UID", ST_UID, CONST_PERSISTENT | CONST_CS);
    933. 

  933. 	/* argument is a UID sequence */
    934. 

  934. 	REGISTER_LONG_CONSTANT("ST_SILENT", ST_SILENT, CONST_PERSISTENT | CONST_CS);
    935. 

  935. 	/* don't return results */
    936. 

  936. 	REGISTER_LONG_CONSTANT("ST_SET", ST_SET, CONST_PERSISTENT | CONST_CS);
    937. 

  937. 	/* set vs. clear */
    938. 

  938. 

  939. 	/* Copy options */
    940. 

  940. 

  941. 	REGISTER_LONG_CONSTANT("CP_UID", CP_UID, CONST_PERSISTENT | CONST_CS);
    942. 

  942. 	/* argument is a UID sequence */
    943. 

  943. 	REGISTER_LONG_CONSTANT("CP_MOVE", CP_MOVE, CONST_PERSISTENT | CONST_CS);
    944. 

  944. 	/* delete from source after copying */
    945. 

  945. 

  946. 	/* Search/sort options */
    947. 

  947. 

  948. 	REGISTER_LONG_CONSTANT("SE_UID", SE_UID, CONST_PERSISTENT | CONST_CS);
    949. 

  949. 	/* return UID */
    950. 

  950. 	REGISTER_LONG_CONSTANT("SE_FREE", SE_FREE, CONST_PERSISTENT | CONST_CS);
    951. 

  951. 	/* free search program after finished */
    952. 

  952. 	REGISTER_LONG_CONSTANT("SE_NOPREFETCH", SE_NOPREFETCH, CONST_PERSISTENT | CONST_CS);
    953. 

  953. 	/* no search prefetching */
    954. 

  954. 	REGISTER_LONG_CONSTANT("SO_FREE", SO_FREE, CONST_PERSISTENT | CONST_CS);
    955. 

  955. 	/* free sort program after finished */
    956. 

  956. 	REGISTER_LONG_CONSTANT("SO_NOSERVER", SO_NOSERVER, CONST_PERSISTENT | CONST_CS);
    957. 

  957. 	/* don't do server-based sort */
    958. 

  958. 

  959. 	/* Status options */
    960. 

  960. 

  961. 	REGISTER_LONG_CONSTANT("SA_MESSAGES", SA_MESSAGES , CONST_PERSISTENT | CONST_CS);
    962. 

  962. 	/* number of messages */
    963. 

  963. 	REGISTER_LONG_CONSTANT("SA_RECENT", SA_RECENT, CONST_PERSISTENT | CONST_CS);
    964. 

  964. 	/* number of recent messages */
    965. 

  965. 	REGISTER_LONG_CONSTANT("SA_UNSEEN", SA_UNSEEN , CONST_PERSISTENT | CONST_CS);
    966. 

  966. 	/* number of unseen messages */
    967. 

  967. 	REGISTER_LONG_CONSTANT("SA_UIDNEXT", SA_UIDNEXT, CONST_PERSISTENT | CONST_CS);
    968. 

  968. 	/* next UID to be assigned */
    969. 

  969. 	REGISTER_LONG_CONSTANT("SA_UIDVALIDITY", SA_UIDVALIDITY , CONST_PERSISTENT | CONST_CS);
    970. 

  970. 	/* UID validity value */
    971. 

  971. 	REGISTER_LONG_CONSTANT("SA_ALL", sa_all, CONST_PERSISTENT | CONST_CS);
    972. 

  972. 	/* get all status information */
    973. 

  973. 

  974. 	/* Bits for mm_list() and mm_lsub() */
    975. 

  975. 

  976. 	REGISTER_LONG_CONSTANT("LATT_NOINFERIORS", LATT_NOINFERIORS , CONST_PERSISTENT | CONST_CS);
    977. 

  977. 	REGISTER_LONG_CONSTANT("LATT_NOSELECT", LATT_NOSELECT, CONST_PERSISTENT | CONST_CS);
    978. 

  978. 	REGISTER_LONG_CONSTANT("LATT_MARKED", LATT_MARKED, CONST_PERSISTENT | CONST_CS);
    979. 

  979. 	REGISTER_LONG_CONSTANT("LATT_UNMARKED", LATT_UNMARKED , CONST_PERSISTENT | CONST_CS);
    980. 

  980. 

  981. #ifdef LATT_REFERRAL
    982. 

  982. 	REGISTER_LONG_CONSTANT("LATT_REFERRAL", LATT_REFERRAL, CONST_PERSISTENT | CONST_CS);
    983. 

  983. #endif
    984. 

  984. 

  985. #ifdef LATT_HASCHILDREN
    986. 

  986. 	REGISTER_LONG_CONSTANT("LATT_HASCHILDREN", LATT_HASCHILDREN, CONST_PERSISTENT | CONST_CS);
    987. 

  987. #endif
    988. 

  988. 

  989. #ifdef LATT_HASNOCHILDREN
    990. 

  990. 	REGISTER_LONG_CONSTANT("LATT_HASNOCHILDREN", LATT_HASNOCHILDREN, CONST_PERSISTENT | CONST_CS);
    991. 

  991. #endif
    992. 

  992. 

  993. 	/* Sort functions */
    994. 

  994. 

  995. 	REGISTER_LONG_CONSTANT("SORTDATE", SORTDATE , CONST_PERSISTENT | CONST_CS);
    996. 

  996. 	/* date */
    997. 

  997. 	REGISTER_LONG_CONSTANT("SORTARRIVAL", SORTARRIVAL , CONST_PERSISTENT | CONST_CS);
    998. 

  998. 	/* arrival date */
    999. 

  999. 	REGISTER_LONG_CONSTANT("SORTFROM", SORTFROM , CONST_PERSISTENT | CONST_CS);
    1000. 

  1000. 	/* from */
    1001. 

  1001. 	REGISTER_LONG_CONSTANT("SORTSUBJECT", SORTSUBJECT , CONST_PERSISTENT | CONST_CS);
    1002. 

  1002. 	/* subject */
    1003. 

  1003. 	REGISTER_LONG_CONSTANT("SORTTO", SORTTO , CONST_PERSISTENT | CONST_CS);
    1004. 

  1004. 	/* to */
    1005. 

  1005. 	REGISTER_LONG_CONSTANT("SORTCC", SORTCC , CONST_PERSISTENT | CONST_CS);
    1006. 

  1006. 	/* cc */
    1007. 

  1007. 	REGISTER_LONG_CONSTANT("SORTSIZE", SORTSIZE , CONST_PERSISTENT | CONST_CS);
    1008. 

  1008. 	/* size */
    1009. 

  1009. 

  1010. 	REGISTER_LONG_CONSTANT("TYPETEXT", TYPETEXT , CONST_PERSISTENT | CONST_CS);
    1011. 

  1011. 	REGISTER_LONG_CONSTANT("TYPEMULTIPART", TYPEMULTIPART , CONST_PERSISTENT | CONST_CS);
    1012. 

  1012. 	REGISTER_LONG_CONSTANT("TYPEMESSAGE", TYPEMESSAGE , CONST_PERSISTENT | CONST_CS);
    1013. 

  1013. 	REGISTER_LONG_CONSTANT("TYPEAPPLICATION", TYPEAPPLICATION , CONST_PERSISTENT | CONST_CS);
    1014. 

  1014. 	REGISTER_LONG_CONSTANT("TYPEAUDIO", TYPEAUDIO , CONST_PERSISTENT | CONST_CS);
    1015. 

  1015. 	REGISTER_LONG_CONSTANT("TYPEIMAGE", TYPEIMAGE , CONST_PERSISTENT | CONST_CS);
    1016. 

  1016. 	REGISTER_LONG_CONSTANT("TYPEVIDEO", TYPEVIDEO , CONST_PERSISTENT | CONST_CS);
    1017. 

  1017. 	REGISTER_LONG_CONSTANT("TYPEMODEL", TYPEMODEL , CONST_PERSISTENT | CONST_CS);
    1018. 

  1018. 	REGISTER_LONG_CONSTANT("TYPEOTHER", TYPEOTHER , CONST_PERSISTENT | CONST_CS);
    1019. 

  1019. 	/*
    1020. 

  1020. 	TYPETEXT                unformatted text
    1021. 

  1021. 	TYPEMULTIPART           multiple part
    1022. 

  1022. 	TYPEMESSAGE             encapsulated message
    1023. 

  1023. 	TYPEAPPLICATION         application data
    1024. 

  1024. 	TYPEAUDIO               audio
    1025. 

  1025. 	TYPEIMAGE               static image (GIF, JPEG, etc.)
    1026. 

  1026. 	TYPEVIDEO               video
    1027. 

  1027. 	TYPEMODEL               model
    1028. 

  1028. 	TYPEOTHER               unknown
    1029. 

  1029. 	*/
    1030. 

  1030. 

  1031. 	REGISTER_LONG_CONSTANT("ENC7BIT", ENC7BIT , CONST_PERSISTENT | CONST_CS);
    1032. 

  1032. 	REGISTER_LONG_CONSTANT("ENC8BIT", ENC8BIT , CONST_PERSISTENT | CONST_CS);
    1033. 

  1033. 	REGISTER_LONG_CONSTANT("ENCBINARY", ENCBINARY , CONST_PERSISTENT | CONST_CS);
    1034. 

  1034. 	REGISTER_LONG_CONSTANT("ENCBASE64", ENCBASE64, CONST_PERSISTENT | CONST_CS);
    1035. 

  1035. 	REGISTER_LONG_CONSTANT("ENCQUOTEDPRINTABLE", ENCQUOTEDPRINTABLE , CONST_PERSISTENT | CONST_CS);
    1036. 

  1036. 	REGISTER_LONG_CONSTANT("ENCOTHER", ENCOTHER , CONST_PERSISTENT | CONST_CS);
    1037. 

  1037. 	/*
    1038. 

  1038. 	ENC7BIT                 7 bit SMTP semantic data
    1039. 

  1039. 	ENC8BIT                 8 bit SMTP semantic data
    1040. 

  1040. 	ENCBINARY               8 bit binary data
    1041. 

  1041. 	ENCBASE64               base-64 encoded data
    1042. 

  1042. 	ENCQUOTEDPRINTABLE      human-readable 8-as-7 bit data
    1043. 

  1043. 	ENCOTHER                unknown
    1044. 

  1044. 	*/
    1045. 

  1045. 

  1046. 	REGISTER_LONG_CONSTANT("IMAP_GC_ELT", GC_ELT , CONST_PERSISTENT | CONST_CS);
    1047. 

  1047. 	REGISTER_LONG_CONSTANT("IMAP_GC_ENV", GC_ENV , CONST_PERSISTENT | CONST_CS);
    1048. 

  1048. 	REGISTER_LONG_CONSTANT("IMAP_GC_TEXTS", GC_TEXTS , CONST_PERSISTENT | CONST_CS);
    1049. 

  1049. 	/*
    1050. 

  1050. 	GC_ELT                 message cache elements
    1051. 

  1051. 	GC_ENV                 ENVELOPEs and BODYs
    1052. 

  1052. 	GC_TEXTS               texts
    1053. 

  1053. 	*/
    1054. 

  1054. 

  1055. 	le_imap = zend_register_list_destructors_ex(mail_close_it, NULL, "imap", module_number);
    1056. 

  1056. 	return SUCCESS;
    1057. 

  1057. }
    1058. 

  1058. /* }}} */
    1059. 

  1059. 

  1060. /* {{{ PHP_RINIT_FUNCTION
    1061. 

  1061.  */
    1062. 

  1062. PHP_RINIT_FUNCTION(imap)
    1063. 

  1063. {
    1064. 

  1064. 	IMAPG(imap_errorstack) = NIL;
    1065. 

  1065. 	IMAPG(imap_alertstack) = NIL;
    1066. 

  1066. 	IMAPG(gets_stream) = NIL;
    1067. 

  1067. 	return SUCCESS;
    1068. 

  1068. }
    1069. 

  1069. /* }}} */
    1070. 

  1070. 

  1071. /* {{{ PHP_RSHUTDOWN_FUNCTION
    1072. 

  1072.  */
    1073. 

  1073. PHP_RSHUTDOWN_FUNCTION(imap)
    1074. 

  1074. {
    1075. 

  1075. 	ERRORLIST *ecur = NIL;
    1076. 

  1076. 	STRINGLIST *acur = NIL;
    1077. 

  1077. 

  1078. 	if (IMAPG(imap_errorstack) != NIL) {
    1079. 

  1079. 		/* output any remaining errors at their original error level */
    1080. 

  1080. 		if (EG(error_reporting) & E_NOTICE) {
    1081. 

  1081. 			ecur = IMAPG(imap_errorstack);
    1082. 

  1082. 			while (ecur != NIL) {
    1083. 

  1083. 				php_error_docref(NULL TSRMLS_CC, E_NOTICE, "%s (errflg=%ld)", ecur->LTEXT, ecur->errflg);
    1084. 

  1084. 				ecur = ecur->next;
    1085. 

  1085. 			}
    1086. 

  1086. 		}
    1087. 

  1087. 		mail_free_errorlist(&IMAPG(imap_errorstack));
    1088. 

  1088. 	}
    1089. 

  1089. 

  1090. 	if (IMAPG(imap_alertstack) != NIL) {
    1091. 

  1091. 		/* output any remaining alerts at E_NOTICE level */
    1092. 

  1092. 		if (EG(error_reporting) & E_NOTICE) {
    1093. 

  1093. 			acur = IMAPG(imap_alertstack);
    1094. 

  1094. 			while (acur != NIL) {
    1095. 

  1095. 				php_error_docref(NULL TSRMLS_CC, E_NOTICE, "%s", acur->LTEXT);
    1096. 

  1096. 				acur = acur->next;
    1097. 

  1097. 			}
    1098. 

  1098. 		}
    1099. 

  1099. 		mail_free_stringlist(&IMAPG(imap_alertstack));
    1100. 

  1100. 		IMAPG(imap_alertstack) = NIL;
    1101. 

  1101. 	}
    1102. 

  1102. 	return SUCCESS;
    1103. 

  1103. }
    1104. 

  1104. /* }}} */
    1105. 

  1105. 

  1106. #if !defined(CCLIENTVERSION)
    1107. 

  1107. #if HAVE_IMAP2007e
    1108. 

  1108. #define CCLIENTVERSION "2007e"
    1109. 

  1109. #elif HAVE_IMAP2007d
    1110. 

  1110. #define CCLIENTVERSION "2007d"
    1111. 

  1111. #elif HAVE_IMAP2007b
    1112. 

  1112. #define CCLIENTVERSION "2007b"
    1113. 

  1113. #elif HAVE_IMAP2007a
    1114. 

  1114. #define CCLIENTVERSION "2007a"
    1115. 

  1115. #elif HAVE_IMAP2004
    1116. 

  1116. #define CCLIENTVERSION "2004"
    1117. 

  1117. #elif HAVE_IMAP2001
    1118. 

  1118. #define CCLIENTVERSION "2001"
    1119. 

  1119. #elif HAVE_IMAP2000
    1120. 

  1120. #define CCLIENTVERSION "2000"
    1121. 

  1121. #elif defined(IMAP41)
    1122. 

  1122. #define CCLIENTVERSION "4.1"
    1123. 

  1123. #else
    1124. 

  1124. #define CCLIENTVERSION "4.0"
    1125. 

  1125. #endif
    1126. 

  1126. #endif
    1127. 

  1127. 

  1128. /* {{{ PHP_MINFO_FUNCTION
    1129. 

  1129.  */
    1130. 

  1130. PHP_MINFO_FUNCTION(imap)
    1131. 

  1131. {
    1132. 

  1132. 	php_info_print_table_start();
    1133. 

  1133. 	php_info_print_table_row(2, "IMAP c-Client Version", CCLIENTVERSION);
    1134. 

  1134. #if HAVE_IMAP_SSL
    1135. 

  1135. 	php_info_print_table_row(2, "SSL Support", "enabled");
    1136. 

  1136. #endif
    1137. 

  1137. #if HAVE_IMAP_KRB && HAVE_IMAP_AUTH_GSS
    1138. 

  1138. 	php_info_print_table_row(2, "Kerberos Support", "enabled");
    1139. 

  1139. #endif
    1140. 

  1140. 	php_info_print_table_end();
    1141. 

  1141. }
    1142. 

  1142. /* }}} */
    1143. 

  1143. 

  1144. /* {{{ imap_do_open
    1145. 

  1145.  */
    1146. 

  1146. static void php_imap_do_open(INTERNAL_FUNCTION_PARAMETERS, int persistent)
    1147. 

  1147. {
    1148. 

  1148. 	char *mailbox, *user, *passwd;
    1149. 

  1149. 	int mailbox_len, user_len, passwd_len;
    1150. 

  1150. 	long retries = 0, flags = NIL, cl_flags = NIL;
    1151. 

  1151. 	MAILSTREAM *imap_stream;
    1152. 

  1152. 	pils *imap_le_struct;
    1153. 

  1153. 	zval *params = NULL;
    1154. 

  1154. 	int argc = ZEND_NUM_ARGS();
    1155. 

  1155. 

  1156. 	if (zend_parse_parameters(argc TSRMLS_CC, "sss|lla", &mailbox, &mailbox_len, &user, &user_len,
    1157. 

  1157. 		&passwd, &passwd_len, &flags, &retries, &params) == FAILURE) {
    1158. 

  1158. 		return;
    1159. 

  1159. 	}
    1160. 

  1160. 

  1161. 	if (argc >= 4) {
    1162. 

  1162. 		if (flags & PHP_EXPUNGE) {
    1163. 

  1163. 			cl_flags = CL_EXPUNGE;
    1164. 

  1164. 			flags ^= PHP_EXPUNGE;
    1165. 

  1165. 		}
    1166. 

  1166. 		if (flags & OP_PROTOTYPE) {
    1167. 

  1167. 			cl_flags |= OP_PROTOTYPE;
    1168. 

  1168. 		}
    1169. 

  1169. 	}
    1170. 

  1170. 

  1171. 	if (params) {
    1172. 

  1172. 		zval **disabled_auth_method;
    1173. 

  1173. 

  1174. 		if (zend_hash_find(HASH_OF(params), "DISABLE_AUTHENTICATOR", sizeof("DISABLE_AUTHENTICATOR"), (void **)&disabled_auth_method) == SUCCESS) {
    1175. 

  1175. 			switch (Z_TYPE_PP(disabled_auth_method)) {
    1176. 

  1176. 				case IS_STRING:
    1177. 

  1177. 					if (Z_STRLEN_PP(disabled_auth_method) > 1) {
    1178. 

  1178. 						mail_parameters (NIL, DISABLE_AUTHENTICATOR, (void *)Z_STRVAL_PP(disabled_auth_method));
    1179. 

  1179. 					}
    1180. 

  1180. 					break;
    1181. 

  1181. 				case IS_ARRAY:
    1182. 

  1182. 					{
    1183. 

  1183. 						zval **z_auth_method;
    1184. 

  1184. 						int i;
    1185. 

  1185. 						int nelems = zend_hash_num_elements(Z_ARRVAL_PP(disabled_auth_method));
    1186. 

  1186. 

  1187. 						if (nelems == 0 ) {
    1188. 

  1188. 							break;
    1189. 

  1189. 						}
    1190. 

  1190. 						for (i = 0; i < nelems; i++) {
    1191. 

  1191. 							if (zend_hash_index_find(Z_ARRVAL_PP(disabled_auth_method), i, (void **) &z_auth_method) == SUCCESS) {
    1192. 

  1192. 								if (Z_TYPE_PP(z_auth_method) == IS_STRING) {
    1193. 

  1193. 									if (Z_STRLEN_PP(z_auth_method) > 1) {
    1194. 

  1194. 										mail_parameters (NIL, DISABLE_AUTHENTICATOR, (void *)Z_STRVAL_PP(disabled_auth_method));
    1195. 

  1195. 									}
    1196. 

  1196. 								} else {
    1197. 

  1197. 									php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid argument, expect string or array of strings");
    1198. 

  1198. 								}
    1199. 

  1199. 							}
    1200. 

  1200. 						}
    1201. 

  1201. 					}
    1202. 

  1202. 					break;
    1203. 

  1203. 				case IS_LONG:
    1204. 

  1204. 				default:
    1205. 

  1205. 					php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid argument, expect string or array of strings");
    1206. 

  1206. 					break;
    1207. 

  1207. 			}
    1208. 

  1208. 		}
    1209. 

  1209. 	}
    1210. 

  1210. 

  1211. 	if (IMAPG(imap_user)) {
    1212. 

  1212. 		efree(IMAPG(imap_user));
    1213. 

  1213. 		IMAPG(imap_user) = 0;
    1214. 

  1214. 	}
    1215. 

  1215. 

  1216. 	if (IMAPG(imap_password)) {
    1217. 

  1217. 		efree(IMAPG(imap_password));
    1218. 

  1218. 		IMAPG(imap_password) = 0;
    1219. 

  1219. 	}
    1220. 

  1220. 

  1221. 	/* local filename, need to perform open_basedir and safe_mode checks */
    1222. 

  1222. 	if (mailbox[0] != '{') {
    1223. 

  1223. 		if (strlen(mailbox) != mailbox_len) {
    1224. 

  1224. 			RETURN_FALSE;
    1225. 

  1225. 		}
    1226. 

  1226. 		if (php_check_open_basedir(mailbox TSRMLS_CC)) {
    1227. 

  1227. 			RETURN_FALSE;
    1228. 

  1228. 		}
    1229. 

  1229. 	}
    1230. 

  1230. 

  1231. 	IMAPG(imap_user)     = estrndup(user, user_len);
    1232. 

  1232. 	IMAPG(imap_password) = estrndup(passwd, passwd_len);
    1233. 

  1233. 

  1234. #ifdef SET_MAXLOGINTRIALS
    1235. 

  1235. 	if (argc == 5) {
    1236. 

  1236. 		if (retries < 0) {
    1237. 

  1237. 			php_error_docref(NULL TSRMLS_CC, E_WARNING ,"Retries must be greater or equal to 0");
    1238. 

  1238. 		} else {
    1239. 

  1239. 			mail_parameters(NIL, SET_MAXLOGINTRIALS, (void *) retries);
    1240. 

  1240. 		}
    1241. 

  1241. 	}
    1242. 

  1242. #endif
    1243. 

  1243. 

  1244. 	imap_stream = mail_open(NIL, mailbox, flags);
    1245. 

  1245. 

  1246. 	if (imap_stream == NIL) {
    1247. 

  1247. 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Couldn't open stream %s", mailbox);
    1248. 

  1248. 		efree(IMAPG(imap_user)); IMAPG(imap_user) = 0;
    1249. 

  1249. 		efree(IMAPG(imap_password)); IMAPG(imap_password) = 0;
    1250. 

  1250. 		RETURN_FALSE;
    1251. 

  1251. 	}
    1252. 

  1252. 

  1253. 	imap_le_struct = emalloc(sizeof(pils));
    1254. 

  1254. 	imap_le_struct->imap_stream = imap_stream;
    1255. 

  1255. 	imap_le_struct->flags = cl_flags;
    1256. 

  1256. 

  1257. 	ZEND_REGISTER_RESOURCE(return_value, imap_le_struct, le_imap);
    1258. 

  1258. }
    1259. 

  1259. /* }}} */
    1260. 

  1260. 

  1261. /* {{{ proto resource imap_open(string mailbox, string user, string password [, int options [, int n_retries]])
    1262. 

  1262.    Open an IMAP stream to a mailbox */
    1263. 

  1263. PHP_FUNCTION(imap_open)
    1264. 

  1264. {
    1265. 

  1265. 	php_imap_do_open(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
    1266. 

  1266. }
    1267. 

  1267. /* }}} */
    1268. 

  1268. 

  1269. /* {{{ proto bool imap_reopen(resource stream_id, string mailbox [, int options [, int n_retries]])
    1270. 

  1270.    Reopen an IMAP stream to a new mailbox */
    1271. 

  1271. PHP_FUNCTION(imap_reopen)
    1272. 

  1272. {
    1273. 

  1273. 	zval *streamind;
    1274. 

  1274. 	char *mailbox;
    1275. 

  1275. 	int mailbox_len;
    1276. 

  1276. 	long options = 0, retries = 0;
    1277. 

  1277. 	pils *imap_le_struct;
    1278. 

  1278. 	MAILSTREAM *imap_stream;
    1279. 

  1279. 	long flags=NIL;
    1280. 

  1280. 	long cl_flags=NIL;
    1281. 

  1281. 

  1282. 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|ll", &streamind, &mailbox, &mailbox_len, &options, &retries) == FAILURE) {
    1283. 

  1283. 		return;
    1284. 

  1284. 	}
    1285. 

  1285. 

  1286. 	ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
    1287. 

  1287. 

  1288. 	if (options) {
    1289. 

  1289. 		flags = options;
    1290. 

  1290. 		if (flags & PHP_EXPUNGE) {
    1291. 

  1291. 			cl_flags = CL_EXPUNGE;
    1292. 

  1292. 			flags ^= PHP_EXPUNGE;
    1293. 

  1293. 		}
    1294. 

  1294. 		imap_le_struct->flags = cl_flags;
    1295. 

  1295. 	}
    1296. 

  1296. #ifdef SET_MAXLOGINTRIALS
    1297. 

  1297. 	if (retries) {
    1298. 

  1298. 		mail_parameters(NIL, SET_MAXLOGINTRIALS, (void *) retries);
    1299. 

  1299. 	}
    1300. 

  1300. #endif
    1301. 

  1301. 	/* local filename, need to perform open_basedir and safe_mode checks */
    1302. 

  1302. 	if (mailbox[0] != '{' && php_check_open_basedir(mailbox TSRMLS_CC)) {
    1303. 

  1303. 		RETURN_FALSE;
    1304. 

  1304. 	}
    1305. 

  1305. 

  1306. 	imap_stream = mail_open(imap_le_struct->imap_stream, mailbox, flags);
    1307. 

  1307. 	if (imap_stream == NIL) {
    1308. 

  1308. 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Couldn't re-open stream");
    1309. 

  1309. 		RETURN_FALSE;
    1310. 

  1310. 	}
    1311. 

  1311. 	imap_le_struct->imap_stream = imap_stream;
    1312. 

  1312. 	RETURN_TRUE;
    1313. 

  1313. }
    1314. 

  1314. /* }}} */
    1315. 

  1315. 

  1316. /* {{{ proto bool imap_append(resource stream_id, string folder, string message [, string options [, string internal_date]])
    1317. 

  1317.    Append a new message to a specified mailbox */
    1318. 

  1318. PHP_FUNCTION(imap_append)
    1319. 

  1319. {
    1320. 

  1320. 	zval *streamind;
    1321. 

  1321. 	char *folder, *message, *internal_date = NULL, *flags = NULL;
    1322. 

  1322. 	int folder_len, message_len, internal_date_len = 0, flags_len = 0;
    1323. 

  1323. 	pils *imap_le_struct;
    1324. 

  1324. 	STRING st;
    1325. 

  1325. 	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}/";
    1326. 

  1326. 	const int regex_len = strlen(regex);
    1327. 

  1327. 	pcre_cache_entry *pce;				/* Compiled regex */
    1328. 

  1328. 	zval *subpats = NULL;				/* Parts (not used) */
    1329. 

  1329. 	long regex_flags = 0;				/* Flags (not used) */
    1330. 

  1330. 	long start_offset = 0;				/* Start offset (not used) */
    1331. 

  1331. 	int global = 0;
    1332. 

  1332. 

  1333. 	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) {
    1334. 

  1334. 		return;
    1335. 

  1335. 	}
    1336. 

  1336. 

  1337. 	if (internal_date) {
    1338. 

  1338. 		/* Make sure the given internal_date string matches the RFC specifiedformat */
    1339. 

  1339. 		if ((pce = pcre_get_compiled_regex_cache(regex, regex_len TSRMLS_CC))== NULL) {
    1340. 

  1340. 			RETURN_FALSE;
    1341. 

  1341. 		}
    1342. 

  1342. 

  1343. 		php_pcre_match_impl(pce, internal_date, internal_date_len, return_value, subpats, global,
    1344. 

  1344. 			0, regex_flags, start_offset TSRMLS_CC);
    1345. 

  1345. 

  1346. 		if (!Z_LVAL_P(return_value)) {
    1347. 

  1347. 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "internal date not correctly formatted");
    1348. 

  1348. 			internal_date = NULL;
    1349. 

  1349. 		}
    1350. 

  1350. 	}
    1351. 

  1351. 

  1352. 	ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
    1353. 

  1353. 

  1354. 	INIT (&st, mail_string, (void *) message, message_len);
    1355. 

  1355. 

  1356. 	if (mail_append_full(imap_le_struct->imap_stream, folder, (flags ? flags : NIL), (internal_date ? internal_date : NIL), &st)) {
    1357. 

  1357. 		RETURN_TRUE;
    1358. 

  1358. 	} else {
    1359. 

  1359. 		RETURN_FALSE;
    1360. 

  1360. 	}
    1361. 

  1361. }
    1362. 

  1362. /* }}} */
    1363. 

  1363. 

  1364. /* {{{ proto int imap_num_msg(resource stream_id)
    1365. 

  1365.    Gives the number of messages in the current mailbox */
    1366. 

  1366. PHP_FUNCTION(imap_num_msg)
    1367. 

  1367. {
    1368. 

  1368. 	zval *streamind;
    1369. 

  1369. 	pils *imap_le_struct;
    1370. 

  1370. 

  1371. 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &streamind) == FAILURE) {
    1372. 

  1372. 		return;
    1373. 

  1373. 	}
    1374. 

  1374. 

  1375. 	ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
    1376. 

  1376. 

  1377. 	RETURN_LONG(imap_le_struct->imap_stream->nmsgs);
    1378. 

  1378. }
    1379. 

  1379. /* }}} */
    1380. 

  1380. 

  1381. /* {{{ proto bool imap_ping(resource stream_id)
    1382. 

  1382.    Check if the IMAP stream is still active */
    1383. 

  1383. PHP_FUNCTION(imap_ping)
    1384. 

  1384. {
    1385. 

  1385. 	zval *streamind;
    1386. 

  1386. 	pils *imap_le_struct;
    1387. 

  1387. 

  1388. 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &streamind) == FAILURE) {
    1389. 

  1389. 		return;
    1390. 

  1390. 	}
    1391. 

  1391. 

  1392. 	ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
    1393. 

  1393. 

  1394. 	RETURN_BOOL(mail_ping(imap_le_struct->imap_stream));
    1395. 

  1395. }
    1396. 

  1396. /* }}} */
    1397. 

  1397. 

  1398. /* {{{ proto int imap_num_recent(resource stream_id)
    1399. 

  1399.    Gives the number of recent messages in current mailbox */
    1400. 

  1400. PHP_FUNCTION(imap_num_recent)
    1401. 

  1401. {
    1402. 

  1402. 	zval *streamind;
    1403. 

  1403. 	pils *imap_le_struct;
    1404. 

  1404. 

  1405. 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &streamind) == FAILURE) {
    1406. 

  1406. 		return;
    1407. 

  1407. 	}
    1408. 

  1408. 

  1409. 	ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
    1410. 

  1410. 

  1411. 	RETURN_LONG(imap_le_struct->imap_stream->recent);
    1412. 

  1412. }
    1413. 

  1413. /* }}} */
    1414. 

  1414. 

  1415. #if defined(HAVE_IMAP2000) || defined(HAVE_IMAP2001)
    1416. 

  1416. /* {{{ proto array imap_get_quota(resource stream_id, string qroot)
    1417. 

  1417. 	Returns the quota set to the mailbox account qroot */
    1418. 

  1418. PHP_FUNCTION(imap_get_quota)
    1419. 

  1419. {
    1420. 

  1420. 	zval *streamind;
    1421. 

  1421. 	char *qroot;
    1422. 

  1422. 	int qroot_len;
    1423. 

  1423. 	pils *imap_le_struct;
    1424. 

  1424. 

  1425. 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &streamind, &qroot, &qroot_len) == FAILURE) {
    1426. 

  1426. 		return;
    1427. 

  1427. 	}
    1428. 

  1428. 

  1429. 	ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
    1430. 

  1430. 

  1431. 	array_init(return_value);
    1432. 

  1432. 	IMAPG(quota_return) = &return_value;
    1433. 

  1433. 

  1434. 	/* set the callback for the GET_QUOTA function */
    1435. 

  1435. 	mail_parameters(NIL, SET_QUOTA, (void *) mail_getquota);
    1436. 

  1436. 	if (!imap_getquota(imap_le_struct->imap_stream, qroot)) {
    1437. 

  1437. 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "c-client imap_getquota failed");
    1438. 

  1438. 		zval_dtor(return_value);
    1439. 

  1439. 		RETURN_FALSE;
    1440. 

  1440. 	}
    1441. 

  1441. }
    1442. 

  1442. /* }}} */
    1443. 

  1443. 

  1444. /* {{{ proto array imap_get_quotaroot(resource stream_id, string mbox)
    1445. 

  1445. 	Returns the quota set to the mailbox account mbox */
    1446. 

  1446. PHP_FUNCTION(imap_get_quotaroot)
    1447. 

  1447. {
    1448. 

  1448. 	zval *streamind;
    1449. 

  1449. 	char *mbox;
    1450. 

  1450. 	int mbox_len;
    1451. 

  1451. 	pils *imap_le_struct;
    1452. 

  1452. 

  1453. 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &streamind, &mbox, &mbox_len) == FAILURE) {
    1454. 

  1454. 		return;
    1455. 

  1455. 	}
    1456. 

  1456. 

  1457. 	ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
    1458. 

  1458. 

  1459. 	array_init(return_value);
    1460. 

  1460. 	IMAPG(quota_return) = &return_value;
    1461. 

  1461. 

  1462. 	/* set the callback for the GET_QUOTAROOT function */
    1463. 

  1463. 	mail_parameters(NIL, SET_QUOTA, (void *) mail_getquota);
    1464. 

  1464. 	if (!imap_getquotaroot(imap_le_struct->imap_stream, mbox)) {
    1465. 

  1465. 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "c-client imap_getquotaroot failed");
    1466. 

  1466. 		zval_dtor(return_value);
    1467. 

  1467. 		RETURN_FALSE;
    1468. 

  1468. 	}
    1469. 

  1469. }
    1470. 

  1470. /* }}} */
    1471. 

  1471. 

  1472. /* {{{ proto bool imap_set_quota(resource stream_id, string qroot, int mailbox_size)
    1473. 

  1473.    Will set the quota for qroot mailbox */
    1474. 

  1474. PHP_FUNCTION(imap_set_quota)
    1475. 

  1475. {
    1476. 

  1476. 	zval *streamind;
    1477. 

  1477. 	char *qroot;
    1478. 

  1478. 	int qroot_len;
    1479. 

  1479. 	long mailbox_size;
    1480. 

  1480. 	pils *imap_le_struct;
    1481. 

  1481. 	STRINGLIST	limits;
    1482. 

  1482. 

  1483. 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsl", &streamind, &qroot, &qroot_len, &mailbox_size) == FAILURE) {
    1484. 

  1484. 		return;
    1485. 

  1485. 	}
    1486. 

  1486. 

  1487. 	ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
    1488. 

  1488. 

  1489. 	limits.text.data = "STORAGE";
    1490. 

  1490. 	limits.text.size = mailbox_size;
    1491. 

  1491. 	limits.next = NIL;
    1492. 

  1492. 

  1493. 	RETURN_BOOL(imap_setquota(imap_le_struct->imap_stream, qroot, &limits));
    1494. 

  1494. }
    1495. 

  1495. /* }}} */
    1496. 

  1496. 

  1497. /* {{{ proto bool imap_setacl(resource stream_id, string mailbox, string id, string rights)
    1498. 

  1498. 	Sets the ACL for a given mailbox */
    1499. 

  1499. PHP_FUNCTION(imap_setacl)
    1500. 

  1500. {
    1501. 

  1501. 	zval *streamind;
    1502. 

  1502. 	char *mailbox, *id, *rights;
    1503. 

  1503. 	int mailbox_len, id_len, rights_len;
    1504. 

  1504. 	pils *imap_le_struct;
    1505. 

  1505. 

  1506. 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsss", &streamind, &mailbox, &mailbox_len, &id, &id_len, &rights, &rights_len) == FAILURE) {
    1507. 

  1507. 		return;
    1508. 

  1508. 	}
    1509. 

  1509. 

  1510. 	ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
    1511. 

  1511. 

  1512. 	RETURN_BOOL(imap_setacl(imap_le_struct->imap_stream, mailbox, id, rights));
    1513. 

  1513. }
    1514. 

  1514. /* }}} */
    1515. 

  1515. 

  1516. /* {{{ proto array imap_getacl(resource stream_id, string mailbox)
    1517. 

  1517. 	Gets the ACL for a given mailbox */
    1518. 

  1518. PHP_FUNCTION(imap_getacl)
    1519. 

  1519. {
    1520. 

  1520. 	zval *streamind;
    1521. 

  1521. 	char *mailbox;
    1522. 

  1522. 	int mailbox_len;
    1523. 

  1523. 	pils *imap_le_struct;
    1524. 

  1524. 

  1525. 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &streamind, &mailbox, &mailbox_len) == FAILURE) {
    1526. 

  1526. 		return;
    1527. 

  1527. 	}
    1528. 

  1528. 

  1529. 	ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
    1530. 

  1530. 

  1531. 	/* initializing the special array for the return values */
    1532. 

  1532. 	array_init(return_value);
    1533. 

  1533. 

  1534. 	IMAPG(imap_acl_list) = return_value;
    1535. 

  1535. 

  1536. 	/* set the callback for the GET_ACL function */
    1537. 

  1537. 	mail_parameters(NIL, SET_ACL, (void *) mail_getacl);
    1538. 

  1538. 	if (!imap_getacl(imap_le_struct->imap_stream, mailbox)) {
    1539. 

  1539. 		php_error(E_WARNING, "c-client imap_getacl failed");
    1540. 

  1540. 		zval_dtor(return_value);
    1541. 

  1541. 		RETURN_FALSE;
    1542. 

  1542. 	}
    1543. 

  1543. 

  1544. 	IMAPG(imap_acl_list) = NIL;
    1545. 

  1545. }
    1546. 

  1546. /* }}} */
    1547. 

  1547. #endif /* HAVE_IMAP2000 || HAVE_IMAP2001 */
    1548. 

  1548. 

  1549. /* {{{ proto bool imap_expunge(resource stream_id)
    1550. 

  1550.    Permanently delete all messages marked for deletion */
    1551. 

  1551. PHP_FUNCTION(imap_expunge)
    1552. 

  1552. {
    1553. 

  1553. 	zval *streamind;
    1554. 

  1554. 	pils *imap_le_struct;
    1555. 

  1555. 

  1556. 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &streamind) == FAILURE) {
    1557. 

  1557. 		return;
    1558. 

  1558. 	}
    1559. 

  1559. 

  1560. 	ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
    1561. 

  1561. 

  1562. 	mail_expunge (imap_le_struct->imap_stream);
    1563. 

  1563. 

  1564. 	RETURN_TRUE;
    1565. 

  1565. }
    1566. 

  1566. /* }}} */
    1567. 

  1567. 

  1568. /* {{{ proto bool imap_gc(resource stream_id, int flags)
    1569. 

  1569.    This function garbage collects (purges) the cache of entries of a specific type. */
    1570. 

  1570. PHP_FUNCTION(imap_gc)
    1571. 

  1571. {
    1572. 

  1572. 	zval *streamind;
    1573. 

  1573. 	pils *imap_le_struct;
    1574. 

  1574. 	long flags;
    1575. 

  1575. 

  1576. 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &streamind, &flags) == FAILURE) {
    1577. 

  1577. 		return;
    1578. 

  1578. 	}
    1579. 

  1579. 

  1580. 	if (flags && ((flags & ~(GC_TEXTS | GC_ELT | GC_ENV)) != 0)) {
    1581. 

  1581. 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid value for the flags parameter");
    1582. 

  1582. 		RETURN_FALSE;
    1583. 

  1583. 	}
    1584. 

  1584. 

  1585. 	ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
    1586. 

  1586. 

  1587. 	mail_gc(imap_le_struct->imap_stream, flags);
    1588. 

  1588. 

  1589. 	RETURN_TRUE;
    1590. 

  1590. }
    1591. 

  1591. /* }}} */
    1592. 

  1592. 

  1593. /* {{{ proto bool imap_close(resource stream_id [, int options])
    1594. 

  1594.    Close an IMAP stream */
    1595. 

  1595. PHP_FUNCTION(imap_close)
    1596. 

  1596. {
    1597. 

  1597. 	zval *streamind;
    1598. 

  1598. 	pils *imap_le_struct=NULL;
    1599. 

  1599. 	long options = 0, flags = NIL;
    1600. 

  1600. 	int argc = ZEND_NUM_ARGS();
    1601. 

  1601. 

  1602. 	if (zend_parse_parameters(argc TSRMLS_CC, "r|l", &streamind, &options) == FAILURE) {
    1603. 

  1603. 		return;
    1604. 

  1604. 	}
    1605. 

  1605. 

  1606. 	ZEND_FETCH_RESOURCE(imap_le_struct, pils *, &streamind, -1, "imap", le_imap);
    1607. 

  1607. 

  1608. 	if (argc == 2) {
    1609. 

  1609. 		flags = options;
    1610. 

  1610. 

  1611. 		/* Check that flags is exactly equal to PHP_EXPUNGE or zero */
    1612. 

  1612. 		if (flags && ((flags & ~PHP_EXPUNGE) != 0)) {
    1613. 

  1613. 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid value for the flags parameter");
    1614. 

  1614. 			RETURN_FALSE;
    1615. 

  1615. 		}
    1616. 

  1616. 

  1617. 		/* Do the translation from PHP's internal PHP_EXPUNGE define to c-client's CL_EXPUNGE */
    1618. 

  1618. 		if (flags & PHP_EXPUNGE) {
    1619. 

  1619. 			flags ^= PHP_EXPUNGE;
    1620. 

  1620. 			flags |= CL_EXPUNGE;
    1621. 

  1621. 		}
    1622. 

  1622. 		imap_le_struct->flags = flags;
    1623. 

  1623. 	}
    1624. 

  1624. 

  1625. 	zend_list_delete(Z_RESVAL_P(streamind));
    1626. 

  1626. 

  1627. 	RETURN_TRUE;
    1628. 

  1628. }
    1629. 

  1629. /* }}} */
    1630. 

  1630. 

  1631. /* {{{ proto array imap_headers(resource stream_id)
    1632. 

  1632.    Returns headers for all messages in a mailbox */
    1633. 

  1633. PHP_FUNCTION(imap_headers)
    1634. 

  1634. {
    1635. 

  1635. 	zval *streamind;
    1636. 

  1636. 	pils *imap_le_struct;
    1637. 

  1637. 	unsigned long i;
    1638. 

  1638. 	char *t;
    1639. 

  1639. 	unsigned int msgno;
    1640. 

  1640. 	char tmp[MAILTMPLEN];
    1641. 

  1641. 

  1642. 	if (ze…
    1643.

Large files files are truncated, but you can click here to view the full file