Back to index

php5  5.3.10
Defines | Functions | Variables
php_imap.c File Reference
#include "php.h"
#include "php_ini.h"
#include "php_streams.h"
#include "ext/standard/php_string.h"
#include "ext/standard/info.h"
#include "ext/standard/file.h"
#include "ext/standard/php_smart_str.h"
#include "ext/pcre/php_pcre.h"
#include "php_imap.h"
#include <time.h>
#include <stdio.h>
#include <ctype.h>
#include <signal.h>

Go to the source code of this file.

Defines

#define IMAP41
#define CRLF   "\015\012"
#define CRLF_LEN   sizeof("\015\012") - 1
#define PHP_EXPUNGE   32768
#define PHP_IMAP_ADDRESS_SIZE_BUF   10
#define SENDBUFLEN   16385
#define PHP_IMAP_EXPORT
#define PHP_IMAP_CHECK_MSGNO(msgindex)
#define CCLIENTVERSION   "4.1"
#define SPECIAL(c)   ((c) <= 0x1f || (c) >= 0x7f)
#define B64CHAR(c)   (isalnum(c) || (c) == '+' || (c) == ',')
#define B64(n)
#define UNB64(c)
#define PHP_RFC822_PARSE_ADRLIST(target, value)
#define GETS_FETCH_SIZE   8196LU

Functions

static void _php_make_header_object (zval *myzvalue, ENVELOPE *en TSRMLS_DC)
static void _php_imap_add_body (zval *arg, BODY *body TSRMLS_DC)
static char * _php_imap_parse_address (ADDRESS *addresslist, zval *paddress TSRMLS_DC)
static char * _php_rfc822_write_address (ADDRESS *addresslist TSRMLS_DC)
static char * php_mail_gets (readfn_t f, void *stream, unsigned long size, GETS_DATA *md)
void rfc822_date (char *date)
char * cpystr (const char *str)
char * cpytxt (SIZEDTEXT *dst, char *text, unsigned long size)
long utf8_mime2text (SIZEDTEXT *src, SIZEDTEXT *dst)
unsigned long find_rightmost_bit (unsigned long *valptr)
void fs_give (void **block)
void * fs_get (size_t size)
static PHP_GINIT_FUNCTION (imap)
static void mail_close_it (zend_rsrc_list_entry *rsrc TSRMLS_DC)
static int add_assoc_object (zval *arg, char *key, zval *tmp TSRMLS_DC)
static int add_next_index_object (zval *arg, zval *tmp TSRMLS_DC)
FOBJECTLIST * mail_newfolderobjectlist (void)
void mail_free_foblist (FOBJECTLIST **foblist, FOBJECTLIST **tail)
ERRORLIST * mail_newerrorlist (void)
void mail_free_errorlist (ERRORLIST **errlist)
MESSAGELIST * mail_newmessagelist (void)
void mail_free_messagelist (MESSAGELIST **msglist, MESSAGELIST **tail)
 PHP_MINIT_FUNCTION (imap)
 PHP_RINIT_FUNCTION (imap)
 PHP_RSHUTDOWN_FUNCTION (imap)
 PHP_MINFO_FUNCTION (imap)
static void php_imap_do_open (INTERNAL_FUNCTION_PARAMETERS, int persistent)
 PHP_FUNCTION (imap_open)
 PHP_FUNCTION (imap_reopen)
 PHP_FUNCTION (imap_append)
 PHP_FUNCTION (imap_num_msg)
 PHP_FUNCTION (imap_ping)
 PHP_FUNCTION (imap_num_recent)
 PHP_FUNCTION (imap_expunge)
 PHP_FUNCTION (imap_gc)
 PHP_FUNCTION (imap_close)
 PHP_FUNCTION (imap_headers)
 PHP_FUNCTION (imap_body)
 PHP_FUNCTION (imap_mail_copy)
 PHP_FUNCTION (imap_mail_move)
 PHP_FUNCTION (imap_createmailbox)
 PHP_FUNCTION (imap_renamemailbox)
 PHP_FUNCTION (imap_deletemailbox)
 PHP_FUNCTION (imap_list)
 PHP_FUNCTION (imap_list_full)
 PHP_FUNCTION (imap_listscan)
 PHP_FUNCTION (imap_check)
 PHP_FUNCTION (imap_delete)
 PHP_FUNCTION (imap_undelete)
 PHP_FUNCTION (imap_headerinfo)
 PHP_FUNCTION (imap_rfc822_parse_headers)
 PHP_FUNCTION (imap_lsub)
 PHP_FUNCTION (imap_lsub_full)
 PHP_FUNCTION (imap_subscribe)
 PHP_FUNCTION (imap_unsubscribe)
 PHP_FUNCTION (imap_fetchstructure)
 PHP_FUNCTION (imap_fetchbody)
 PHP_FUNCTION (imap_fetchmime)
 PHP_FUNCTION (imap_savebody)
 PHP_FUNCTION (imap_base64)
 PHP_FUNCTION (imap_qprint)
 PHP_FUNCTION (imap_8bit)
 PHP_FUNCTION (imap_binary)
 PHP_FUNCTION (imap_mailboxmsginfo)
 PHP_FUNCTION (imap_rfc822_write_address)
 PHP_FUNCTION (imap_rfc822_parse_adrlist)
 PHP_FUNCTION (imap_utf8)
 PHP_FUNCTION (imap_utf7_decode)
 PHP_FUNCTION (imap_utf7_encode)
 PHP_FUNCTION (imap_setflag_full)
 PHP_FUNCTION (imap_clearflag_full)
 PHP_FUNCTION (imap_sort)
 PHP_FUNCTION (imap_fetchheader)
 PHP_FUNCTION (imap_uid)
 PHP_FUNCTION (imap_msgno)
 PHP_FUNCTION (imap_status)
 PHP_FUNCTION (imap_bodystruct)
 PHP_FUNCTION (imap_fetch_overview)
 PHP_FUNCTION (imap_mail_compose)
int _php_imap_mail (char *to, char *subject, char *message, char *headers, char *cc, char *bcc, char *rpath TSRMLS_DC)
 PHP_FUNCTION (imap_mail)
 PHP_FUNCTION (imap_search)
 PHP_FUNCTION (imap_alerts)
 PHP_FUNCTION (imap_errors)
 PHP_FUNCTION (imap_last_error)
 PHP_FUNCTION (imap_mime_header_decode)
static int _php_rfc822_len (char *str)
static int _php_imap_address_size (ADDRESS *addresslist)
static void build_thread_tree_helper (THREADNODE *cur, zval *tree, long *numNodes, char *buf)
static int build_thread_tree (THREADNODE *top, zval **tree)
 PHP_FUNCTION (imap_thread)
 PHP_FUNCTION (imap_timeout)
PHP_IMAP_EXPORT void mm_searched (MAILSTREAM *stream, unsigned long number)
PHP_IMAP_EXPORT void mm_exists (MAILSTREAM *stream, unsigned long number)
PHP_IMAP_EXPORT void mm_expunged (MAILSTREAM *stream, unsigned long number)
PHP_IMAP_EXPORT void mm_flags (MAILSTREAM *stream, unsigned long number)
PHP_IMAP_EXPORT void mm_notify (MAILSTREAM *stream, char *str, long errflg)
PHP_IMAP_EXPORT void mm_list (MAILSTREAM *stream, DTYPE delimiter, char *mailbox, long attributes)
PHP_IMAP_EXPORT void mm_lsub (MAILSTREAM *stream, DTYPE delimiter, char *mailbox, long attributes)
PHP_IMAP_EXPORT void mm_status (MAILSTREAM *stream, char *mailbox, MAILSTATUS *status)
PHP_IMAP_EXPORT void mm_log (char *str, long errflg)
PHP_IMAP_EXPORT void mm_dlog (char *str)
PHP_IMAP_EXPORT void mm_login (NETMBX *mb, char *user, char *pwd, long trial)
PHP_IMAP_EXPORT void mm_critical (MAILSTREAM *stream)
PHP_IMAP_EXPORT void mm_nocritical (MAILSTREAM *stream)
PHP_IMAP_EXPORT long mm_diskerror (MAILSTREAM *stream, long errcode, long serious)
PHP_IMAP_EXPORT void mm_fatal (char *str)

Variables

const zend_function_entry imap_functions []
static const zend_module_dep imap_deps []
zend_module_entry imap_module_entry
static int le_imap

Define Documentation

#define B64 (   n)
Value:
("ABCDEFGHIJKLMNOPQRSTUVWXYZ" \
                            "abcdefghijklmnopqrstuvwxyz0123456789+,"[(n) & 0x3f])

Definition at line 2738 of file php_imap.c.

#define B64CHAR (   c)    (isalnum(c) || (c) == '+' || (c) == ',')

Definition at line 2735 of file php_imap.c.

#define CCLIENTVERSION   "4.1"

Definition at line 1122 of file php_imap.c.

#define CRLF   "\015\012"

Definition at line 63 of file php_imap.c.

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

Definition at line 64 of file php_imap.c.

#define GETS_FETCH_SIZE   8196LU

Definition at line 4812 of file php_imap.c.

#define IMAP41

Definition at line 31 of file php_imap.c.

#define PHP_EXPUNGE   32768

Definition at line 65 of file php_imap.c.

#define PHP_IMAP_ADDRESS_SIZE_BUF   10

Definition at line 66 of file php_imap.c.

#define PHP_IMAP_CHECK_MSGNO (   msgindex)
Value:
if ((msgindex < 1) || ((unsigned) msgindex > imap_le_struct->imap_stream->nmsgs)) { \
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "Bad message number");    \
              RETURN_FALSE; \
       }      \

Definition at line 593 of file php_imap.c.

#define PHP_IMAP_EXPORT

Definition at line 74 of file php_imap.c.

#define PHP_RFC822_PARSE_ADRLIST (   target,
  value 
)
Value:
str_copy = estrndup(Z_STRVAL_PP(value), Z_STRLEN_PP(value)); \
       rfc822_parse_adrlist(target, str_copy, "NO HOST"); \
       efree(str_copy);
#define SENDBUFLEN   16385

Definition at line 68 of file php_imap.c.

#define SPECIAL (   c)    ((c) <= 0x1f || (c) >= 0x7f)

Definition at line 2732 of file php_imap.c.

#define UNB64 (   c)
Value:
((c) == '+' ? 62 : (c) == ',' ? 63 : (c) >= 'a' ? \
                                   (c) - 71 : (c) >= 'A' ? (c) - 65 : (c) + 4)

Definition at line 2742 of file php_imap.c.


Function Documentation

void _php_imap_add_body ( zval *  arg,
BODY *body  TSRMLS_DC 
) [static]

Definition at line 4548 of file php_imap.c.

{
       zval *parametres, *param, *dparametres, *dparam;
       PARAMETER *par, *dpar;
       PART *part;

       if (body->type <= TYPEMAX) {
              add_property_long(arg, "type", body->type);
       }

       if (body->encoding <= ENCMAX) {
              add_property_long(arg, "encoding", body->encoding);
       }

       if (body->subtype) {
              add_property_long(arg, "ifsubtype", 1);
              add_property_string(arg, "subtype", body->subtype, 1);
       } else {
              add_property_long(arg, "ifsubtype", 0);
       }

       if (body->description) {
              add_property_long(arg, "ifdescription", 1);
              add_property_string(arg, "description", body->description, 1);
       } else {
              add_property_long(arg, "ifdescription", 0);
       }

       if (body->id) {
              add_property_long(arg, "ifid", 1);
              add_property_string(arg, "id", body->id, 1);
       } else {
              add_property_long(arg, "ifid", 0);
       }

       if (body->size.lines) {
              add_property_long(arg, "lines", body->size.lines);
       }

       if (body->size.bytes) {
              add_property_long(arg, "bytes", body->size.bytes);
       }

#ifdef IMAP41
       if (body->disposition.type) {
              add_property_long(arg, "ifdisposition", 1);
              add_property_string(arg, "disposition", body->disposition.type, 1);
       } else {
              add_property_long(arg, "ifdisposition", 0);
       }

       if (body->disposition.parameter) {
              dpar = body->disposition.parameter;
              add_property_long(arg, "ifdparameters", 1);
              MAKE_STD_ZVAL(dparametres);
              array_init(dparametres);
              do {
                     MAKE_STD_ZVAL(dparam);
                     object_init(dparam);
                     add_property_string(dparam, "attribute", dpar->attribute, 1);
                     add_property_string(dparam, "value", dpar->value, 1);
                     add_next_index_object(dparametres, dparam TSRMLS_CC);
              } while ((dpar = dpar->next));
              add_assoc_object(arg, "dparameters", dparametres TSRMLS_CC);
       } else {
              add_property_long(arg, "ifdparameters", 0);
       }
#endif

       if ((par = body->parameter)) {
              add_property_long(arg, "ifparameters", 1);

              MAKE_STD_ZVAL(parametres);
              array_init(parametres);
              do {
                     MAKE_STD_ZVAL(param);
                     object_init(param);
                     if (par->attribute) {
                            add_property_string(param, "attribute", par->attribute, 1);
                     }
                     if (par->value) {
                            add_property_string(param, "value", par->value, 1);
                     }

                     add_next_index_object(parametres, param TSRMLS_CC);
              } while ((par = par->next));
       } else {
              MAKE_STD_ZVAL(parametres);
              object_init(parametres);
              add_property_long(arg, "ifparameters", 0);
       }
       add_assoc_object(arg, "parameters", parametres TSRMLS_CC);

       /* multipart message ? */
       if (body->type == TYPEMULTIPART) {
              MAKE_STD_ZVAL(parametres);
              array_init(parametres);
              for (part = body->CONTENT_PART; part; part = part->next) {
                     MAKE_STD_ZVAL(param);
                     object_init(param);
                     _php_imap_add_body(param, &part->body TSRMLS_CC);
                     add_next_index_object(parametres, param TSRMLS_CC);
              }
              add_assoc_object(arg, "parts", parametres TSRMLS_CC);
       }

       /* encapsulated message ? */
       if ((body->type == TYPEMESSAGE) && (!strcasecmp(body->subtype, "rfc822"))) {
              body = body->CONTENT_MSG_BODY;
              MAKE_STD_ZVAL(parametres);
              array_init(parametres);
              MAKE_STD_ZVAL(param);
              object_init(param);
              _php_imap_add_body(param, body TSRMLS_CC);
              add_next_index_object(parametres, param TSRMLS_CC);
              add_assoc_object(arg, "parts", parametres TSRMLS_CC);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int _php_imap_address_size ( ADDRESS *  addresslist) [static]

Definition at line 4385 of file php_imap.c.

{
       ADDRESS *tmp;
       int ret=0, num_ent=0;

       tmp = addresslist;

       if (tmp) do {
              ret += _php_rfc822_len(tmp->personal);
              ret += _php_rfc822_len(tmp->adl);
              ret += _php_rfc822_len(tmp->mailbox);
              ret += _php_rfc822_len(tmp->host);
              num_ent++;
       } while ((tmp = tmp->next));

       /*
        * rfc822_write_address_full() needs some extra space for '<>,', etc.
        * for this perpouse we allocate additional PHP_IMAP_ADDRESS_SIZE_BUF bytes
        * by default this buffer is 10 bytes long
       */
       ret += (ret) ? num_ent*PHP_IMAP_ADDRESS_SIZE_BUF : 0;

       return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int _php_imap_mail ( char *  to,
char *  subject,
char *  message,
char *  headers,
char *  cc,
char *  bcc,
char *rpath  TSRMLS_DC 
)

Definition at line 3892 of file php_imap.c.

{
#ifdef PHP_WIN32
       int tsm_err;
#else
       FILE *sendmail;
       int ret;
#endif

#ifdef PHP_WIN32
       char *tempMailTo;
       char *tsm_errmsg = NULL;
       ADDRESS *addr;
       char *bufferTo = NULL, *bufferCc = NULL, *bufferBcc = NULL, *bufferHeader = NULL;
       int offset, bufferLen = 0;
       size_t bt_len;

       if (headers) {
              bufferLen += strlen(headers);
       }
       if (to) {
              bufferLen += strlen(to) + 6;
       }
       if (cc) {
              bufferLen += strlen(cc) + 6;
       }

#define PHP_IMAP_CLEAN      if (bufferTo) efree(bufferTo); if (bufferCc) efree(bufferCc); if (bufferBcc) efree(bufferBcc); if (bufferHeader) efree(bufferHeader);
#define PHP_IMAP_BAD_DEST PHP_IMAP_CLEAN; efree(tempMailTo); return (BAD_MSG_DESTINATION);

       bufferHeader = (char *)emalloc(bufferLen + 1);
       memset(bufferHeader, 0, bufferLen);
       if (to && *to) {
              strlcat(bufferHeader, "To: ", bufferLen + 1);
              strlcat(bufferHeader, to, bufferLen + 1);
              strlcat(bufferHeader, "\r\n", bufferLen + 1);
              tempMailTo = estrdup(to);
              bt_len = strlen(to);
              bufferTo = (char *)safe_emalloc(bt_len, 1, 1);
              bt_len++;
              offset = 0;
              addr = NULL;
              rfc822_parse_adrlist(&addr, tempMailTo, NULL);
              while (addr) {
                     if (addr->host == NULL || strcmp(addr->host, ERRHOST) == 0) {
                            PHP_IMAP_BAD_DEST;
                     } else {
                            bufferTo = safe_erealloc(bufferTo, bt_len, 1, strlen(addr->mailbox));
                            bt_len += strlen(addr->mailbox);
                            bufferTo = safe_erealloc(bufferTo, bt_len, 1, strlen(addr->host));
                            bt_len += strlen(addr->host);
                            offset += slprintf(bufferTo + offset, bt_len - offset, "%s@%s,", addr->mailbox, addr->host);
                     }
                     addr = addr->next;
              }
              efree(tempMailTo);
              if (offset>0) {
                     bufferTo[offset-1] = 0;
              }
       }

       if (cc && *cc) {
              strlcat(bufferHeader, "Cc: ", bufferLen + 1);
              strlcat(bufferHeader, cc, bufferLen + 1);
              strlcat(bufferHeader, "\r\n", bufferLen + 1);
              tempMailTo = estrdup(cc);
              bt_len = strlen(cc);
              bufferCc = (char *)safe_emalloc(bt_len, 1, 1);
              bt_len++;
              offset = 0;
              addr = NULL;
              rfc822_parse_adrlist(&addr, tempMailTo, NULL);
              while (addr) {
                     if (addr->host == NULL || strcmp(addr->host, ERRHOST) == 0) {
                            PHP_IMAP_BAD_DEST;
                     } else {
                            bufferCc = safe_erealloc(bufferCc, bt_len, 1, strlen(addr->mailbox));
                            bt_len += strlen(addr->mailbox);
                            bufferCc = safe_erealloc(bufferCc, bt_len, 1, strlen(addr->host));
                            bt_len += strlen(addr->host);
                            offset += slprintf(bufferCc + offset, bt_len - offset, "%s@%s,", addr->mailbox, addr->host);
                     }
                     addr = addr->next;
              }
              efree(tempMailTo);
              if (offset>0) {
                     bufferCc[offset-1] = 0;
              }
       }

       if (bcc && *bcc) {
              tempMailTo = estrdup(bcc);
              bt_len = strlen(bcc);
              bufferBcc = (char *)safe_emalloc(bt_len, 1, 1);
              bt_len++;
              offset = 0;
              addr = NULL;
              rfc822_parse_adrlist(&addr, tempMailTo, NULL);
              while (addr) {
                     if (addr->host == NULL || strcmp(addr->host, ERRHOST) == 0) {
                            PHP_IMAP_BAD_DEST;
                     } else {
                            bufferBcc = safe_erealloc(bufferBcc, bt_len, 1, strlen(addr->mailbox));
                            bt_len += strlen(addr->mailbox);
                            bufferBcc = safe_erealloc(bufferBcc, bt_len, 1, strlen(addr->host));
                            bt_len += strlen(addr->host);
                            offset += slprintf(bufferBcc + offset, bt_len - offset, "%s@%s,", addr->mailbox, addr->host);
                     }
                     addr = addr->next;
              }
              efree(tempMailTo);
              if (offset>0) {
                     bufferBcc[offset-1] = 0;
              }
       }

       if (headers && *headers) {
              strlcat(bufferHeader, headers, bufferLen + 1);
       }

       if (TSendMail(INI_STR("SMTP"), &tsm_err, &tsm_errmsg, bufferHeader, subject, bufferTo, message, bufferCc, bufferBcc, rpath TSRMLS_CC) != SUCCESS) {
              if (tsm_errmsg) {
                     php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", tsm_errmsg);
                     efree(tsm_errmsg);
              } else {
                     php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", GetSMErrorText(tsm_err));
              }
              PHP_IMAP_CLEAN;
              return 0;
       }
       PHP_IMAP_CLEAN;
#else
       if (!INI_STR("sendmail_path")) {
              return 0;
       }
       sendmail = popen(INI_STR("sendmail_path"), "w");
       if (sendmail) {
              if (rpath && rpath[0]) fprintf(sendmail, "From: %s\n", rpath);
              fprintf(sendmail, "To: %s\n", to);
              if (cc && cc[0]) fprintf(sendmail, "Cc: %s\n", cc);
              if (bcc && bcc[0]) fprintf(sendmail, "Bcc: %s\n", bcc);
              fprintf(sendmail, "Subject: %s\n", subject);
              if (headers != NULL) {
                     fprintf(sendmail, "%s\n", headers);
              }
              fprintf(sendmail, "\n%s\n", message);
              ret = pclose(sendmail);
              if (ret == -1) {
                     return 0;
              } else {
                     return 1;
              }
       } else {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not execute mail delivery program");
              return 0;
       }
#endif
       return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static char * _php_imap_parse_address ( ADDRESS *  addresslist,
zval *paddress  TSRMLS_DC 
) [static]

Definition at line 4430 of file php_imap.c.

{
       char *fulladdress;
       ADDRESS *addresstmp;
       zval *tmpvals;

       addresstmp = addresslist;

       fulladdress = _php_rfc822_write_address(addresstmp TSRMLS_CC);

       addresstmp = addresslist;
       do {
              MAKE_STD_ZVAL(tmpvals);
              object_init(tmpvals);
              if (addresstmp->personal) add_property_string(tmpvals, "personal", addresstmp->personal, 1);
              if (addresstmp->adl) add_property_string(tmpvals, "adl", addresstmp->adl, 1);
              if (addresstmp->mailbox) add_property_string(tmpvals, "mailbox", addresstmp->mailbox, 1);
              if (addresstmp->host) add_property_string(tmpvals, "host", addresstmp->host, 1);
              add_next_index_object(paddress, tmpvals TSRMLS_CC);
       } while ((addresstmp = addresstmp->next));
       return fulladdress;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void _php_make_header_object ( zval *  myzvalue,
ENVELOPE *en  TSRMLS_DC 
) [static]

Definition at line 4456 of file php_imap.c.

{
       zval *paddress;
       char *fulladdress=NULL;

       object_init(myzvalue);

       if (en->remail) add_property_string(myzvalue, "remail", en->remail, 1);
       if (en->date) add_property_string(myzvalue, "date", en->date, 1);
       if (en->date) add_property_string(myzvalue, "Date", en->date, 1);
       if (en->subject) add_property_string(myzvalue, "subject", en->subject, 1);
       if (en->subject) add_property_string(myzvalue, "Subject", en->subject, 1);
       if (en->in_reply_to) add_property_string(myzvalue, "in_reply_to", en->in_reply_to, 1);
       if (en->message_id) add_property_string(myzvalue, "message_id", en->message_id, 1);
       if (en->newsgroups) add_property_string(myzvalue, "newsgroups", en->newsgroups, 1);
       if (en->followup_to) add_property_string(myzvalue, "followup_to", en->followup_to, 1);
       if (en->references) add_property_string(myzvalue, "references", en->references, 1);

       if (en->to) {
              MAKE_STD_ZVAL(paddress);
              array_init(paddress);
              fulladdress = _php_imap_parse_address(en->to, paddress TSRMLS_CC);
              if (fulladdress) {
                     add_property_string(myzvalue, "toaddress", fulladdress, 0);
              }
              add_assoc_object(myzvalue, "to", paddress TSRMLS_CC);
       }

       if (en->from) {
              MAKE_STD_ZVAL(paddress);
              array_init(paddress);
              fulladdress = _php_imap_parse_address(en->from, paddress TSRMLS_CC);
              if (fulladdress) {
                     add_property_string(myzvalue, "fromaddress", fulladdress, 0);
              }
              add_assoc_object(myzvalue, "from", paddress TSRMLS_CC);
       }

       if (en->cc) {
              MAKE_STD_ZVAL(paddress);
              array_init(paddress);
              fulladdress = _php_imap_parse_address(en->cc, paddress TSRMLS_CC);
              if (fulladdress) {
                     add_property_string(myzvalue, "ccaddress", fulladdress, 0);
              }
              add_assoc_object(myzvalue, "cc", paddress TSRMLS_CC);
       }

       if (en->bcc) {
              MAKE_STD_ZVAL(paddress);
              array_init(paddress);
              fulladdress = _php_imap_parse_address(en->bcc, paddress TSRMLS_CC);
              if (fulladdress) {
                     add_property_string(myzvalue, "bccaddress", fulladdress, 0);
              }
              add_assoc_object(myzvalue, "bcc", paddress TSRMLS_CC);
       }

       if (en->reply_to) {
              MAKE_STD_ZVAL(paddress);
              array_init(paddress);
              fulladdress = _php_imap_parse_address(en->reply_to, paddress TSRMLS_CC);
              if (fulladdress) {
                     add_property_string(myzvalue, "reply_toaddress", fulladdress, 0);
              }
              add_assoc_object(myzvalue, "reply_to", paddress TSRMLS_CC);
       }

       if (en->sender) {
              MAKE_STD_ZVAL(paddress);
              array_init(paddress);
              fulladdress = _php_imap_parse_address(en->sender, paddress TSRMLS_CC);
              if (fulladdress) {
                     add_property_string(myzvalue, "senderaddress", fulladdress, 0);
              }
              add_assoc_object(myzvalue, "sender", paddress TSRMLS_CC);
       }

       if (en->return_path) {
              MAKE_STD_ZVAL(paddress);
              array_init(paddress);
              fulladdress = _php_imap_parse_address(en->return_path, paddress TSRMLS_CC);
              if (fulladdress) {
                     add_property_string(myzvalue, "return_pathaddress", fulladdress, 0);
              }
              add_assoc_object(myzvalue, "return_path", paddress TSRMLS_CC);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int _php_rfc822_len ( char *  str) [static]

Definition at line 4357 of file php_imap.c.

{
       int len;
       char *p;

       if (!str || !*str) {
              return 0;
       }

       /* strings with special characters will need to be quoted, as a safety measure we
        * add 2 bytes for the quotes just in case.
        */
       len = strlen(str) + 2;
       p = str;
       /* rfc822_cat() will escape all " and \ characters, therefor we need to increase
        * our buffer length to account for these characters.
        */
       while ((p = strpbrk(p, "\\\""))) {
              p++;
              len++;
       }

       return len;
}

Here is the caller graph for this function:

static char * _php_rfc822_write_address ( ADDRESS *addresslist  TSRMLS_DC) [static]

Definition at line 4414 of file php_imap.c.

{
       char address[SENDBUFLEN];

       if (_php_imap_address_size(addresslist) >= SENDBUFLEN) {
              php_error_docref(NULL TSRMLS_CC, E_ERROR, "Address buffer overflow");
              return NULL;
       }
       address[0] = 0;
       rfc822_write_address(address, addresslist);
       return estrdup(address);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int add_assoc_object ( zval *  arg,
char *  key,
zval *tmp  TSRMLS_DC 
) [static]

Definition at line 625 of file php_imap.c.

{
       HashTable *symtable;

       if (Z_TYPE_P(arg) == IS_OBJECT) {
              symtable = Z_OBJPROP_P(arg);
       } else {
              symtable = Z_ARRVAL_P(arg);
       }
       return zend_hash_update(symtable, key, strlen(key)+1, (void *) &tmp, sizeof(zval *), NULL);
}

Here is the caller graph for this function:

static int add_next_index_object ( zval *  arg,
zval *tmp  TSRMLS_DC 
) [inline, static]

Definition at line 640 of file php_imap.c.

{
       HashTable *symtable;

       if (Z_TYPE_P(arg) == IS_OBJECT) {
              symtable = Z_OBJPROP_P(arg);
       } else {
              symtable = Z_ARRVAL_P(arg);
       }

       return zend_hash_next_index_insert(symtable, (void *) &tmp, sizeof(zval *), NULL);
}

Here is the caller graph for this function:

static int build_thread_tree ( THREADNODE *  top,
zval **  tree 
) [static]

Definition at line 4702 of file php_imap.c.

{
       long numNodes = 0;
       char buf[25];

       array_init(*tree);

       build_thread_tree_helper(top, *tree, &numNodes, buf);

       return SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void build_thread_tree_helper ( THREADNODE *  cur,
zval *  tree,
long *  numNodes,
char *  buf 
) [static]

Definition at line 4671 of file php_imap.c.

{
       unsigned long thisNode = *numNodes;

       /* define "#.num" */
       snprintf(buf, 25, "%ld.num", thisNode);

       add_assoc_long(tree, buf, cur->num);

       snprintf(buf, 25, "%ld.next", thisNode);
       if(cur->next) {
              (*numNodes)++;
              add_assoc_long(tree, buf, *numNodes);
              build_thread_tree_helper(cur->next, tree, numNodes, buf);
       } else { /* "null pointer" */
              add_assoc_long(tree, buf, 0);
       }

       snprintf(buf, 25, "%ld.branch", thisNode);
       if(cur->branch) {
              (*numNodes)++;
              add_assoc_long(tree, buf, *numNodes);
              build_thread_tree_helper(cur->branch, tree, numNodes, buf);
       } else { /* "null pointer" */
              add_assoc_long(tree, buf, 0);
       }
}

Here is the caller graph for this function:

char* cpystr ( const char *  str)

Here is the caller graph for this function:

char* cpytxt ( SIZEDTEXT *  dst,
char *  text,
unsigned long  size 
)

Here is the caller graph for this function:

unsigned long find_rightmost_bit ( unsigned long *  valptr)

Here is the caller graph for this function:

void* fs_get ( size_t  size)

Here is the caller graph for this function:

void fs_give ( void **  block)

Here is the caller graph for this function:

static void mail_close_it ( zend_rsrc_list_entry *rsrc  TSRMLS_DC) [static]

Definition at line 601 of file php_imap.c.

{
       pils *imap_le_struct = (pils *)rsrc->ptr;

       /* Do not try to close prototype streams */
       if (!(imap_le_struct->flags & OP_PROTOTYPE)) {
              mail_close_full(imap_le_struct->imap_stream, imap_le_struct->flags);
       }

       if (IMAPG(imap_user)) {
              efree(IMAPG(imap_user));
              IMAPG(imap_user) = 0;
       }
       if (IMAPG(imap_password)) {
              efree(IMAPG(imap_password));
              IMAPG(imap_password) = 0;
       }

       efree(imap_le_struct);
}

Here is the caller graph for this function:

void mail_free_errorlist ( ERRORLIST **  errlist)

Definition at line 708 of file php_imap.c.

{
       if (*errlist) {             /* only free if exists */
              if ((*errlist)->text.data) {
                     fs_give((void **) &(*errlist)->text.data);
              }
              mail_free_errorlist (&(*errlist)->next);
              fs_give((void **) errlist); /* return string to free storage */
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void mail_free_foblist ( FOBJECTLIST **  foblist,
FOBJECTLIST **  tail 
)

Definition at line 672 of file php_imap.c.

{
       FOBJECTLIST *cur, *next;

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

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

              fs_give((void **)&cur);
       }

       *tail = NIL;
       *foblist = NIL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void mail_free_messagelist ( MESSAGELIST **  msglist,
MESSAGELIST **  tail 
)

Definition at line 738 of file php_imap.c.

{
       MESSAGELIST *cur, *next;

       for (cur = *msglist, next = cur->next; cur; cur = next) {
              next = cur->next;
              fs_give((void **)&cur);
       }

       *tail = NIL;
       *msglist = NIL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ERRORLIST* mail_newerrorlist ( void  )

Definition at line 696 of file php_imap.c.

{
       return (ERRORLIST *) memset(fs_get(sizeof(ERRORLIST)), 0, sizeof(ERRORLIST));
}

Here is the call graph for this function:

Here is the caller graph for this function:

FOBJECTLIST* mail_newfolderobjectlist ( void  )

Definition at line 660 of file php_imap.c.

{
       return (FOBJECTLIST *) memset(fs_get(sizeof(FOBJECTLIST)), 0, sizeof(FOBJECTLIST));
}

Here is the call graph for this function:

Here is the caller graph for this function:

MESSAGELIST* mail_newmessagelist ( void  )

Definition at line 726 of file php_imap.c.

{
       return (MESSAGELIST *) memset(fs_get(sizeof(MESSAGELIST)), 0, sizeof(MESSAGELIST));
}

Here is the call graph for this function:

Here is the caller graph for this function:

PHP_IMAP_EXPORT void mm_critical ( MAILSTREAM *  stream)

Definition at line 5073 of file php_imap.c.

{
}
PHP_IMAP_EXPORT long mm_diskerror ( MAILSTREAM *  stream,
long  errcode,
long  serious 
)

Definition at line 5081 of file php_imap.c.

{
       return 1;
}
PHP_IMAP_EXPORT void mm_dlog ( char *  str)

Definition at line 5054 of file php_imap.c.

{
       /* CJH: this is for debugging; it might be useful to allow setting
          the stream to debug mode and capturing this somewhere - syslog?
          php debugger? */
}
PHP_IMAP_EXPORT void mm_exists ( MAILSTREAM *  stream,
unsigned long  number 
)

Definition at line 4879 of file php_imap.c.

{
}
PHP_IMAP_EXPORT void mm_expunged ( MAILSTREAM *  stream,
unsigned long  number 
)

Definition at line 4883 of file php_imap.c.

{
}
PHP_IMAP_EXPORT void mm_fatal ( char *  str)

Definition at line 5086 of file php_imap.c.

{
}
PHP_IMAP_EXPORT void mm_flags ( MAILSTREAM *  stream,
unsigned long  number 
)

Definition at line 4887 of file php_imap.c.

{
}
PHP_IMAP_EXPORT void mm_list ( MAILSTREAM *  stream,
DTYPE  delimiter,
char *  mailbox,
long  attributes 
)

Definition at line 4915 of file php_imap.c.

{
       STRINGLIST *cur=NIL;
       FOBJECTLIST *ocur=NIL;
       TSRMLS_FETCH();

       if (IMAPG(folderlist_style) == FLIST_OBJECT) {
              /* build up a the new array of objects */
              /* Author: CJH */
              if (IMAPG(imap_folder_objects) == NIL) {
                     IMAPG(imap_folder_objects) = mail_newfolderobjectlist();
                     IMAPG(imap_folder_objects)->LSIZE=strlen(IMAPG(imap_folder_objects)->LTEXT=cpystr(mailbox));
                     IMAPG(imap_folder_objects)->delimiter = delimiter;
                     IMAPG(imap_folder_objects)->attributes = attributes;
                     IMAPG(imap_folder_objects)->next = NIL;
                     IMAPG(imap_folder_objects_tail) = IMAPG(imap_folder_objects);
              } else {
                     ocur=IMAPG(imap_folder_objects_tail);
                     ocur->next=mail_newfolderobjectlist();
                     ocur=ocur->next;
                     ocur->LSIZE = strlen(ocur->LTEXT = cpystr(mailbox));
                     ocur->delimiter = delimiter;
                     ocur->attributes = attributes;
                     ocur->next = NIL;
                     IMAPG(imap_folder_objects_tail) = ocur;
              }

       } else {
              /* build the old IMAPG(imap_folders) variable to allow old imap_listmailbox() to work */
              if (!(attributes & LATT_NOSELECT)) {
                     if (IMAPG(imap_folders) == NIL) {
                            IMAPG(imap_folders)=mail_newstringlist();
                            IMAPG(imap_folders)->LSIZE=strlen(IMAPG(imap_folders)->LTEXT=cpystr(mailbox));
                            IMAPG(imap_folders)->next=NIL;
                            IMAPG(imap_folders_tail) = IMAPG(imap_folders);
                     } else {
                            cur=IMAPG(imap_folders_tail);
                            cur->next=mail_newstringlist ();
                            cur=cur->next;
                            cur->LSIZE = strlen (cur->LTEXT = cpystr (mailbox));
                            cur->next = NIL;
                            IMAPG(imap_folders_tail) = cur;
                     }
              }
       }
}

Here is the call graph for this function:

PHP_IMAP_EXPORT void mm_log ( char *  str,
long  errflg 
)

Definition at line 5028 of file php_imap.c.

{
       ERRORLIST *cur = NIL;
       TSRMLS_FETCH();

       /* Author: CJH */
       if (errflg != NIL) { /* CJH: maybe put these into a more comprehensive log for debugging purposes? */
              if (IMAPG(imap_errorstack) == NIL) {
                     IMAPG(imap_errorstack) = mail_newerrorlist();
                     IMAPG(imap_errorstack)->LSIZE = strlen(IMAPG(imap_errorstack)->LTEXT = cpystr(str));
                     IMAPG(imap_errorstack)->errflg = errflg;
                     IMAPG(imap_errorstack)->next = NIL;
              } else {
                     cur = IMAPG(imap_errorstack);
                     while (cur->next != NIL) {
                            cur = cur->next;
                     }
                     cur->next = mail_newerrorlist();
                     cur = cur->next;
                     cur->LSIZE = strlen(cur->LTEXT = cpystr(str));
                     cur->errflg = errflg;
                     cur->next = NIL;
              }
       }
}

Here is the call graph for this function:

PHP_IMAP_EXPORT void mm_login ( NETMBX *  mb,
char *  user,
char *  pwd,
long  trial 
)

Definition at line 5061 of file php_imap.c.

{
       TSRMLS_FETCH();

       if (*mb->user) {
              strlcpy (user, mb->user, MAILTMPLEN);
       } else {
              strlcpy (user, IMAPG(imap_user), MAILTMPLEN);
       }
       strlcpy (pwd, IMAPG(imap_password), MAILTMPLEN);
}

Here is the call graph for this function:

PHP_IMAP_EXPORT void mm_lsub ( MAILSTREAM *  stream,
DTYPE  delimiter,
char *  mailbox,
long  attributes 
)

Definition at line 4962 of file php_imap.c.

{
       STRINGLIST *cur=NIL;
       FOBJECTLIST *ocur=NIL;
       TSRMLS_FETCH();

       if (IMAPG(folderlist_style) == FLIST_OBJECT) {
              /* build the array of objects */
              /* Author: CJH */
              if (IMAPG(imap_sfolder_objects) == NIL) {
                     IMAPG(imap_sfolder_objects) = mail_newfolderobjectlist();
                     IMAPG(imap_sfolder_objects)->LSIZE=strlen(IMAPG(imap_sfolder_objects)->LTEXT=cpystr(mailbox));
                     IMAPG(imap_sfolder_objects)->delimiter = delimiter;
                     IMAPG(imap_sfolder_objects)->attributes = attributes;
                     IMAPG(imap_sfolder_objects)->next = NIL;
                     IMAPG(imap_sfolder_objects_tail) = IMAPG(imap_sfolder_objects);
              } else {
                     ocur=IMAPG(imap_sfolder_objects_tail);
                     ocur->next=mail_newfolderobjectlist();
                     ocur=ocur->next;
                     ocur->LSIZE=strlen(ocur->LTEXT = cpystr(mailbox));
                     ocur->delimiter = delimiter;
                     ocur->attributes = attributes;
                     ocur->next = NIL;
                     IMAPG(imap_sfolder_objects_tail) = ocur;
              }
       } else {
              /* build the old simple array for imap_listsubscribed() */
              if (IMAPG(imap_sfolders) == NIL) {
                     IMAPG(imap_sfolders)=mail_newstringlist();
                     IMAPG(imap_sfolders)->LSIZE=strlen(IMAPG(imap_sfolders)->LTEXT=cpystr(mailbox));
                     IMAPG(imap_sfolders)->next=NIL;
                     IMAPG(imap_sfolders_tail) = IMAPG(imap_sfolders);
              } else {
                     cur=IMAPG(imap_sfolders_tail);
                     cur->next=mail_newstringlist ();
                     cur=cur->next;
                     cur->LSIZE = strlen (cur->LTEXT = cpystr (mailbox));
                     cur->next = NIL;
                     IMAPG(imap_sfolders_tail) = cur;
              }
       }
}

Here is the call graph for this function:

PHP_IMAP_EXPORT void mm_nocritical ( MAILSTREAM *  stream)

Definition at line 5077 of file php_imap.c.

{
}
PHP_IMAP_EXPORT void mm_notify ( MAILSTREAM *  stream,
char *  str,
long  errflg 
)

Definition at line 4892 of file php_imap.c.

{
       STRINGLIST *cur = NIL;
       TSRMLS_FETCH();

       if (strncmp(str, "[ALERT] ", 8) == 0) {
              if (IMAPG(imap_alertstack) == NIL) {
                     IMAPG(imap_alertstack) = mail_newstringlist();
                     IMAPG(imap_alertstack)->LSIZE = strlen(IMAPG(imap_alertstack)->LTEXT = cpystr(str));
                     IMAPG(imap_alertstack)->next = NIL;
              } else {
                     cur = IMAPG(imap_alertstack);
                     while (cur->next != NIL) {
                            cur = cur->next;
                     }
                     cur->next = mail_newstringlist ();
                     cur = cur->next;
                     cur->LSIZE = strlen(cur->LTEXT = cpystr(str));
                     cur->next = NIL;
              }
       }
}

Here is the call graph for this function:

PHP_IMAP_EXPORT void mm_searched ( MAILSTREAM *  stream,
unsigned long  number 
)

Definition at line 4859 of file php_imap.c.

{
       MESSAGELIST *cur = NIL;
       TSRMLS_FETCH();

       if (IMAPG(imap_messages) == NIL) {
              IMAPG(imap_messages) = mail_newmessagelist();
              IMAPG(imap_messages)->msgid = number;
              IMAPG(imap_messages)->next = NIL;
              IMAPG(imap_messages_tail) = IMAPG(imap_messages);
       } else {
              cur = IMAPG(imap_messages_tail);
              cur->next = mail_newmessagelist();
              cur = cur->next;
              cur->msgid = number;
              cur->next = NIL;
              IMAPG(imap_messages_tail) = cur;
       }
}

Here is the call graph for this function:

PHP_IMAP_EXPORT void mm_status ( MAILSTREAM *  stream,
char *  mailbox,
MAILSTATUS *  status 
)

Definition at line 5006 of file php_imap.c.

{
       TSRMLS_FETCH();

       IMAPG(status_flags)=status->flags;
       if (IMAPG(status_flags) & SA_MESSAGES) {
              IMAPG(status_messages)=status->messages;
       }
       if (IMAPG(status_flags) & SA_RECENT) {
              IMAPG(status_recent)=status->recent;
       }
       if (IMAPG(status_flags) & SA_UNSEEN) {
              IMAPG(status_unseen)=status->unseen;
       }
       if (IMAPG(status_flags) & SA_UIDNEXT) {
              IMAPG(status_uidnext)=status->uidnext;
       }
       if (IMAPG(status_flags) & SA_UIDVALIDITY) {
              IMAPG(status_uidvalidity)=status->uidvalidity;
       }
}
PHP_FUNCTION ( imap_open  )

Definition at line 1264 of file php_imap.c.

Here is the call graph for this function:

PHP_FUNCTION ( imap_reopen  )

Definition at line 1272 of file php_imap.c.

{
       zval *streamind;
       char *mailbox;
       int mailbox_len;
       long options = 0, retries = 0;
       pils *imap_le_struct;
       MAILSTREAM *imap_stream;
       long flags=NIL;
       long cl_flags=NIL;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|ll", &streamind, &mailbox, &mailbox_len, &options, &retries) == FAILURE) {
              return;
       }

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

       if (options) {
              flags = options;
              if (flags & PHP_EXPUNGE) {
                     cl_flags = CL_EXPUNGE;
                     flags ^= PHP_EXPUNGE;
              }
              imap_le_struct->flags = cl_flags;
       }
#ifdef SET_MAXLOGINTRIALS
       if (retries) {
              mail_parameters(NIL, SET_MAXLOGINTRIALS, (void *) retries);
       }
#endif
       /* local filename, need to perform open_basedir and safe_mode checks */
       if (mailbox[0] != '{' &&
                     (php_check_open_basedir(mailbox TSRMLS_CC) ||
                     (PG(safe_mode) && !php_checkuid(mailbox, NULL, CHECKUID_CHECK_FILE_AND_DIR)))) {
              RETURN_FALSE;
       }

       imap_stream = mail_open(imap_le_struct->imap_stream, mailbox, flags);
       if (imap_stream == NIL) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "Couldn't re-open stream");
              RETURN_FALSE;
       }
       imap_le_struct->imap_stream = imap_stream;
       RETURN_TRUE;
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_append  )

Definition at line 1321 of file php_imap.c.

{
       zval *streamind;
       char *folder, *message, *internal_date = NULL, *flags = NULL;
       int folder_len, message_len, internal_date_len = 0, flags_len = 0;
       pils *imap_le_struct;
       STRING st;
       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}/";
       const int regex_len = strlen(regex);
       pcre_cache_entry *pce;                           /* Compiled regex */
       zval *subpats = NULL;                            /* Parts (not used) */
       long regex_flags = 0;                            /* Flags (not used) */
       long start_offset = 0;                           /* Start offset (not used) */
       int global = 0;

       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) {
              return;
       }

       if (internal_date) {
              /* Make sure the given internal_date string matches the RFC specifiedformat */
              if ((pce = pcre_get_compiled_regex_cache(regex, regex_len TSRMLS_CC))== NULL) {
                     RETURN_FALSE;
              }

              php_pcre_match_impl(pce, internal_date, internal_date_len, return_value, subpats, global,
                     0, regex_flags, start_offset TSRMLS_CC);

              if (!Z_LVAL_P(return_value)) {
                     php_error_docref(NULL TSRMLS_CC, E_WARNING, "internal date not correctly formatted");
                     internal_date = NULL;
              }
       }

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

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

       if (mail_append_full(imap_le_struct->imap_stream, folder, (flags ? flags : NIL), (internal_date ? internal_date : NIL), &st)) {
              RETURN_TRUE;
       } else {
              RETURN_FALSE;
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_num_msg  )

Definition at line 1369 of file php_imap.c.

{
       zval *streamind;
       pils *imap_le_struct;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &streamind) == FAILURE) {
              return;
       }

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

       RETURN_LONG(imap_le_struct->imap_stream->nmsgs);
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_ping  )

Definition at line 1386 of file php_imap.c.

{
       zval *streamind;
       pils *imap_le_struct;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &streamind) == FAILURE) {
              return;
       }

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

       RETURN_BOOL(mail_ping(imap_le_struct->imap_stream));
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_num_recent  )

Definition at line 1403 of file php_imap.c.

{
       zval *streamind;
       pils *imap_le_struct;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &streamind) == FAILURE) {
              return;
       }

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

       RETURN_LONG(imap_le_struct->imap_stream->recent);
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_expunge  )

Definition at line 1554 of file php_imap.c.

{
       zval *streamind;
       pils *imap_le_struct;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &streamind) == FAILURE) {
              return;
       }

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

       mail_expunge (imap_le_struct->imap_stream);

       RETURN_TRUE;
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_gc  )

Definition at line 1573 of file php_imap.c.

{
       zval *streamind;
       pils *imap_le_struct;
       long flags;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &streamind, &flags) == FAILURE) {
              return;
       }

       if (flags && ((flags & ~(GC_TEXTS | GC_ELT | GC_ENV)) != 0)) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid value for the flags parameter");
              RETURN_FALSE;
       }

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

       mail_gc(imap_le_struct->imap_stream, flags);

       RETURN_TRUE;
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_close  )

Definition at line 1598 of file php_imap.c.

{
       zval *streamind;
       pils *imap_le_struct=NULL;
       long options = 0, flags = NIL;
       int argc = ZEND_NUM_ARGS();

       if (zend_parse_parameters(argc TSRMLS_CC, "r|l", &streamind, &options) == FAILURE) {
              return;
       }

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

       if (argc == 2) {
              flags = options;

              /* Check that flags is exactly equal to PHP_EXPUNGE or zero */
              if (flags && ((flags & ~PHP_EXPUNGE) != 0)) {
                     php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid value for the flags parameter");
                     RETURN_FALSE;
              }

              /* Do the translation from PHP's internal PHP_EXPUNGE define to c-client's CL_EXPUNGE */
              if (flags & PHP_EXPUNGE) {
                     flags ^= PHP_EXPUNGE;
                     flags |= CL_EXPUNGE;
              }
              imap_le_struct->flags = flags;
       }

       zend_list_delete(Z_RESVAL_P(streamind));

       RETURN_TRUE;
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_headers  )

Definition at line 1636 of file php_imap.c.

{
       zval *streamind;
       pils *imap_le_struct;
       unsigned long i;
       char *t;
       unsigned int msgno;
       char tmp[MAILTMPLEN];

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &streamind) == FAILURE) {
              return;
       }

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

       /* Initialize return array */
       array_init(return_value);

       for (msgno = 1; msgno <= imap_le_struct->imap_stream->nmsgs; msgno++) {
              MESSAGECACHE * cache = mail_elt (imap_le_struct->imap_stream, msgno);
              mail_fetchstructure(imap_le_struct->imap_stream, msgno, NIL);
              tmp[0] = cache->recent ? (cache->seen ? 'R': 'N') : ' ';
              tmp[1] = (cache->recent | cache->seen) ? ' ' : 'U';
              tmp[2] = cache->flagged ? 'F' : ' ';
              tmp[3] = cache->answered ? 'A' : ' ';
              tmp[4] = cache->deleted ? 'D' : ' ';
              tmp[5] = cache->draft ? 'X' : ' ';
              snprintf(tmp + 6, sizeof(tmp) - 6, "%4ld) ", cache->msgno);
              mail_date(tmp+11, cache);
              tmp[22] = ' ';
              tmp[23] = '\0';
              mail_fetchfrom(tmp+23, imap_le_struct->imap_stream, msgno, (long)20);
              strcat(tmp, " ");
              if ((i = cache->user_flags)) {
                     strcat(tmp, "{");
                     while (i) {
                            strlcat(tmp, imap_le_struct->imap_stream->user_flags[find_rightmost_bit (&i)], sizeof(tmp));
                            if (i) strlcat(tmp, " ", sizeof(tmp));
                     }
                     strlcat(tmp, "} ", sizeof(tmp));
              }
              mail_fetchsubject(t = tmp + strlen(tmp), imap_le_struct->imap_stream, msgno, (long)25);
              snprintf(t += strlen(t), sizeof(tmp) - strlen(tmp), " (%ld chars)", cache->rfc822_size);
              add_next_index_string(return_value, tmp, 1);
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_body  )

Definition at line 1686 of file php_imap.c.

{
       zval *streamind;
       long msgno, flags = 0;
       pils *imap_le_struct;
       int msgindex, argc = ZEND_NUM_ARGS();
       char *body;
       unsigned long body_len = 0;

       if (zend_parse_parameters(argc TSRMLS_CC, "rl|l", &streamind, &msgno, &flags) == FAILURE) {
              return;
       }

       if (flags && ((flags & ~(FT_UID|FT_PEEK|FT_INTERNAL)) != 0)) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid value for the options parameter");
              RETURN_FALSE;
       }

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

       if ((argc == 3) && (flags & FT_UID)) {
              /* This should be cached; if it causes an extra RTT to the
                 IMAP server, then that's the price we pay for making
                 sure we don't crash. */
              msgindex = mail_msgno(imap_le_struct->imap_stream, msgno);
       } else {
              msgindex = msgno;
       }
       if ((msgindex < 1) || ((unsigned) msgindex > imap_le_struct->imap_stream->nmsgs)) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "Bad message number");
              RETURN_FALSE;
       }

       body = mail_fetchtext_full (imap_le_struct->imap_stream, msgno, &body_len, (argc == 3 ? flags : NIL));
       if (body_len == 0) {
              RETVAL_EMPTY_STRING();
       } else {
              RETVAL_STRINGL(body, body_len, 1);
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_mail_copy  )

Definition at line 1730 of file php_imap.c.

{
       zval *streamind;
       long options = 0;
       char *seq, *folder;
       int seq_len, folder_len, argc = ZEND_NUM_ARGS();
       pils *imap_le_struct;

       if (zend_parse_parameters(argc TSRMLS_CC, "rss|l", &streamind, &seq, &seq_len, &folder, &folder_len, &options) == FAILURE) {
              return;
       }

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

       if (mail_copy_full(imap_le_struct->imap_stream, seq, folder, (argc == 4 ? options : NIL)) == T) {
              RETURN_TRUE;
       } else {
              RETURN_FALSE;
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_mail_move  )

Definition at line 1754 of file php_imap.c.

{
       zval *streamind;
       char *seq, *folder;
       int seq_len, folder_len;
       long options = 0;
       pils *imap_le_struct;
       int argc = ZEND_NUM_ARGS();

       if (zend_parse_parameters(argc TSRMLS_CC, "rss|l", &streamind, &seq, &seq_len, &folder, &folder_len, &options) == FAILURE) {
              return;
       }

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

       if (mail_copy_full(imap_le_struct->imap_stream, seq, folder, (argc == 4 ? (options | CP_MOVE) : CP_MOVE)) == T) {
              RETURN_TRUE;
       } else {
              RETURN_FALSE;
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_createmailbox  )

Definition at line 1779 of file php_imap.c.

{
       zval *streamind;
       char *folder;
       int folder_len;
       pils *imap_le_struct;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &streamind, &folder, &folder_len) == FAILURE) {
              return;
       }

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

       if (mail_create(imap_le_struct->imap_stream, folder) == T) {
              RETURN_TRUE;
       } else {
              RETURN_FALSE;
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_renamemailbox  )

Definition at line 1802 of file php_imap.c.

{
       zval *streamind;
       char *old_mailbox, *new_mailbox;
       int old_mailbox_len, new_mailbox_len;
       pils *imap_le_struct;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rss", &streamind, &old_mailbox, &old_mailbox_len, &new_mailbox, &new_mailbox_len) == FAILURE) {
              return;
       }

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

       if (mail_rename(imap_le_struct->imap_stream, old_mailbox, new_mailbox) == T) {
              RETURN_TRUE;
       } else {
              RETURN_FALSE;
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_deletemailbox  )

Definition at line 1825 of file php_imap.c.

{
       zval *streamind;
       char *folder;
       int folder_len;
       pils *imap_le_struct;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &streamind, &folder, &folder_len) == FAILURE) {
              return;
       }

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

       if (mail_delete(imap_le_struct->imap_stream, folder) == T) {
              RETURN_TRUE;
       } else {
              RETURN_FALSE;
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_list  )

Definition at line 1848 of file php_imap.c.

{
       zval *streamind;
       char *ref, *pat;
       int ref_len, pat_len;
       pils *imap_le_struct;
       STRINGLIST *cur=NIL;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rss", &streamind, &ref, &ref_len, &pat, &pat_len) == FAILURE) {
              return;
       }

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

       /* set flag for normal, old mailbox list */
       IMAPG(folderlist_style) = FLIST_ARRAY;

       IMAPG(imap_folders) = IMAPG(imap_folders_tail) = NIL;
       mail_list(imap_le_struct->imap_stream, ref, pat);
       if (IMAPG(imap_folders) == NIL) {
              RETURN_FALSE;
       }

       array_init(return_value);
       cur=IMAPG(imap_folders);
       while (cur != NIL) {
              add_next_index_string(return_value, cur->LTEXT, 1);
              cur=cur->next;
       }
       mail_free_stringlist (&IMAPG(imap_folders));
       IMAPG(imap_folders) = IMAPG(imap_folders_tail) = NIL;
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_list_full  )

Definition at line 1886 of file php_imap.c.

{
       zval *streamind, *mboxob;
       char *ref, *pat;
       int ref_len, pat_len;
       pils *imap_le_struct;
       FOBJECTLIST *cur=NIL;
       char *delim=NIL;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rss", &streamind, &ref, &ref_len, &pat, &pat_len) == FAILURE) {
              return;
       }

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

       /* set flag for new, improved array of objects mailbox list */
       IMAPG(folderlist_style) = FLIST_OBJECT;

       IMAPG(imap_folder_objects) = IMAPG(imap_folder_objects_tail) = NIL;
       mail_list(imap_le_struct->imap_stream, ref, pat);
       if (IMAPG(imap_folder_objects) == NIL) {
              RETURN_FALSE;
       }

       array_init(return_value);
       delim = safe_emalloc(2, sizeof(char), 0);
       cur=IMAPG(imap_folder_objects);
       while (cur != NIL) {
              MAKE_STD_ZVAL(mboxob);
              object_init(mboxob);
              add_property_string(mboxob, "name", cur->LTEXT, 1);
              add_property_long(mboxob, "attributes", cur->attributes);
#ifdef IMAP41
              delim[0] = (char)cur->delimiter;
              delim[1] = 0;
              add_property_string(mboxob, "delimiter", delim, 1);
#else
              add_property_string(mboxob, "delimiter", cur->delimiter, 1);
#endif
              add_next_index_object(return_value, mboxob TSRMLS_CC);
              cur=cur->next;
       }
       mail_free_foblist(&IMAPG(imap_folder_objects), &IMAPG(imap_folder_objects_tail));
       efree(delim);
       IMAPG(folderlist_style) = FLIST_ARRAY;           /* reset to default */
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_listscan  )

Definition at line 1936 of file php_imap.c.

{
       zval *streamind;
       char *ref, *pat, *content;
       int ref_len, pat_len, content_len;
       pils *imap_le_struct;
       STRINGLIST *cur=NIL;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsss", &streamind, &ref, &ref_len, &pat, &pat_len, &content, &content_len) == FAILURE) {
              return;
       }

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

       IMAPG(imap_folders) = NIL;
       mail_scan(imap_le_struct->imap_stream, ref, pat, content);
       if (IMAPG(imap_folders) == NIL) {
              RETURN_FALSE;
       }

       array_init(return_value);
       cur=IMAPG(imap_folders);
       while (cur != NIL) {
              add_next_index_string(return_value, cur->LTEXT, 1);
              cur=cur->next;
       }
       mail_free_stringlist (&IMAPG(imap_folders));
       IMAPG(imap_folders) = IMAPG(imap_folders_tail) = NIL;
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_check  )

Definition at line 1970 of file php_imap.c.

{
       zval *streamind;
       pils *imap_le_struct;
       char date[100];

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &streamind) == FAILURE) {
              return;
       }

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

       if (mail_ping (imap_le_struct->imap_stream) == NIL) {
              RETURN_FALSE;
       }

       if (imap_le_struct->imap_stream && imap_le_struct->imap_stream->mailbox) {
              rfc822_date(date);
              object_init(return_value);
              add_property_string(return_value, "Date", date, 1);
              add_property_string(return_value, "Driver", imap_le_struct->imap_stream->dtb->name, 1);
              add_property_string(return_value, "Mailbox", imap_le_struct->imap_stream->mailbox, 1);
              add_property_long(return_value, "Nmsgs", imap_le_struct->imap_stream->nmsgs);
              add_property_long(return_value, "Recent", imap_le_struct->imap_stream->recent);
       } else {
              RETURN_FALSE;
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_delete  )

Definition at line 2002 of file php_imap.c.

{
       zval *streamind, **sequence;
       pils *imap_le_struct;
       long flags = 0;
       int argc = ZEND_NUM_ARGS();

       if (zend_parse_parameters(argc TSRMLS_CC, "rZ|l", &streamind, &sequence, &flags) == FAILURE) {
              return;
       }

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

       convert_to_string_ex(sequence);

       mail_setflag_full(imap_le_struct->imap_stream, Z_STRVAL_PP(sequence), "\\DELETED", (argc == 3 ? flags : NIL));
       RETVAL_TRUE;
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_undelete  )

Definition at line 2024 of file php_imap.c.

{
       zval *streamind, **sequence;
       long flags = 0;
       pils *imap_le_struct;
       int argc = ZEND_NUM_ARGS();

       if (zend_parse_parameters(argc TSRMLS_CC, "rZ|l", &streamind, &sequence, &flags) == FAILURE) {
              return;
       }

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

       convert_to_string_ex(sequence);

       mail_clearflag_full(imap_le_struct->imap_stream, Z_STRVAL_PP(sequence), "\\DELETED", (argc == 3 ? flags : NIL));
       RETVAL_TRUE;
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_headerinfo  )

Definition at line 2046 of file php_imap.c.

{
       zval *streamind;
       char *defaulthost = NULL;
       int defaulthost_len = 0, argc = ZEND_NUM_ARGS();
       long msgno, fromlength, subjectlength;
       pils *imap_le_struct;
       MESSAGECACHE *cache;
       ENVELOPE *en;
       char dummy[2000], fulladdress[MAILTMPLEN + 1];

       if (zend_parse_parameters(argc TSRMLS_CC, "rl|lls", &streamind, &msgno, &fromlength, &subjectlength, &defaulthost, &defaulthost_len) == FAILURE) {
              return;
       }

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

       if (argc >= 3) {
              if (fromlength < 0 || fromlength > MAILTMPLEN) {
                     php_error_docref(NULL TSRMLS_CC, E_WARNING, "From length has to be between 0 and %d", MAILTMPLEN);
                     RETURN_FALSE;
              }
       } else {
              fromlength = 0x00;
       }
       if (argc >= 4) {
              if (subjectlength < 0 || subjectlength > MAILTMPLEN) {
                     php_error_docref(NULL TSRMLS_CC, E_WARNING, "Subject length has to be between 0 and %d", MAILTMPLEN);
                     RETURN_FALSE;
              }
       } else {
              subjectlength = 0x00;
       }

       PHP_IMAP_CHECK_MSGNO(msgno);

       if (mail_fetchstructure(imap_le_struct->imap_stream, msgno, NIL)) {
              cache = mail_elt(imap_le_struct->imap_stream, msgno);
       } else {
              RETURN_FALSE;
       }

       en = mail_fetchenvelope(imap_le_struct->imap_stream, msgno);

       /* call a function to parse all the text, so that we can use the
          same function to parse text from other sources */
       _php_make_header_object(return_value, en TSRMLS_CC);

       /* now run through properties that are only going to be returned
          from a server, not text headers */
       add_property_string(return_value, "Recent", cache->recent ? (cache->seen ? "R": "N") : " ", 1);
       add_property_string(return_value, "Unseen", (cache->recent | cache->seen) ? " " : "U", 1);
       add_property_string(return_value, "Flagged", cache->flagged ? "F" : " ", 1);
       add_property_string(return_value, "Answered", cache->answered ? "A" : " ", 1);
       add_property_string(return_value, "Deleted", cache->deleted ? "D" : " ", 1);
       add_property_string(return_value, "Draft", cache->draft ? "X" : " ", 1);

       snprintf(dummy, sizeof(dummy), "%4ld", cache->msgno);
       add_property_string(return_value, "Msgno", dummy, 1);

       mail_date(dummy, cache);
       add_property_string(return_value, "MailDate", dummy, 1);

       snprintf(dummy, sizeof(dummy), "%ld", cache->rfc822_size);
       add_property_string(return_value, "Size", dummy, 1);

       add_property_long(return_value, "udate", mail_longdate(cache));

       if (en->from && fromlength) {
              fulladdress[0] = 0x00;
              mail_fetchfrom(fulladdress, imap_le_struct->imap_stream, msgno, fromlength);
              add_property_string(return_value, "fetchfrom", fulladdress, 1);
       }
       if (en->subject && subjectlength) {
              fulladdress[0] = 0x00;
              mail_fetchsubject(fulladdress, imap_le_struct->imap_stream, msgno, subjectlength);
              add_property_string(return_value, "fetchsubject", fulladdress, 1);
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_rfc822_parse_headers  )

Definition at line 2129 of file php_imap.c.

{
       char *headers, *defaulthost = NULL;
       ENVELOPE *en;
       int headers_len, defaulthost_len = 0, argc = ZEND_NUM_ARGS();

       if (zend_parse_parameters(argc TSRMLS_CC, "s|s", &headers, &headers_len, &defaulthost, &defaulthost_len) == FAILURE) {
              return;
       }

       if (argc == 2) {
              rfc822_parse_msg(&en, NULL, headers, headers_len, NULL, defaulthost, NIL);
       } else {
              rfc822_parse_msg(&en, NULL, headers, headers_len, NULL, "UNKNOWN", NIL);
       }

       /* call a function to parse all the text, so that we can use the
          same function no matter where the headers are from */
       _php_make_header_object(return_value, en TSRMLS_CC);
       mail_free_envelope(&en);
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_lsub  )

Definition at line 2155 of file php_imap.c.

{
       zval *streamind;
       char *ref, *pat;
       int ref_len, pat_len;
       pils *imap_le_struct;
       STRINGLIST *cur=NIL;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rss", &streamind, &ref, &ref_len, &pat, &pat_len) == FAILURE) {
              return;
       }

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

       /* set flag for normal, old mailbox list */
       IMAPG(folderlist_style) = FLIST_ARRAY;

       IMAPG(imap_sfolders) = NIL;
       mail_lsub(imap_le_struct->imap_stream, ref, pat);
       if (IMAPG(imap_sfolders) == NIL) {
              RETURN_FALSE;
       }

       array_init(return_value);
       cur=IMAPG(imap_sfolders);
       while (cur != NIL) {
              add_next_index_string(return_value, cur->LTEXT, 1);
              cur=cur->next;
       }
       mail_free_stringlist (&IMAPG(imap_sfolders));
       IMAPG(imap_sfolders) = IMAPG(imap_sfolders_tail) = NIL;
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_lsub_full  )

Definition at line 2192 of file php_imap.c.

{
       zval *streamind, *mboxob;
       char *ref, *pat;
       int ref_len, pat_len;
       pils *imap_le_struct;
       FOBJECTLIST *cur=NIL;
       char *delim=NIL;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rss", &streamind, &ref, &ref_len, &pat, &pat_len) == FAILURE) {
              return;
       }

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

       /* set flag for new, improved array of objects list */
       IMAPG(folderlist_style) = FLIST_OBJECT;

       IMAPG(imap_sfolder_objects) = IMAPG(imap_sfolder_objects_tail) = NIL;
       mail_lsub(imap_le_struct->imap_stream, ref, pat);
       if (IMAPG(imap_sfolder_objects) == NIL) {
              RETURN_FALSE;
       }

       array_init(return_value);
       delim = safe_emalloc(2, sizeof(char), 0);
       cur=IMAPG(imap_sfolder_objects);
       while (cur != NIL) {
              MAKE_STD_ZVAL(mboxob);
              object_init(mboxob);
              add_property_string(mboxob, "name", cur->LTEXT, 1);
              add_property_long(mboxob, "attributes", cur->attributes);
#ifdef IMAP41
              delim[0] = (char)cur->delimiter;
              delim[1] = 0;
              add_property_string(mboxob, "delimiter", delim, 1);
#else
              add_property_string(mboxob, "delimiter", cur->delimiter, 1);
#endif
              add_next_index_object(return_value, mboxob TSRMLS_CC);
              cur=cur->next;
       }
       mail_free_foblist (&IMAPG(imap_sfolder_objects), &IMAPG(imap_sfolder_objects_tail));
       efree(delim);
       IMAPG(folderlist_style) = FLIST_ARRAY; /* reset to default */
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_subscribe  )

Definition at line 2242 of file php_imap.c.

{
       zval *streamind;
       char *folder;
       int folder_len;
       pils *imap_le_struct;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &streamind, &folder, &folder_len) == FAILURE) {
              return;
       }

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

       if (mail_subscribe(imap_le_struct->imap_stream, folder) == T) {
              RETURN_TRUE;
       } else {
              RETURN_FALSE;
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_unsubscribe  )

Definition at line 2265 of file php_imap.c.

{
       zval *streamind;
       char *folder;
       int folder_len;
       pils *imap_le_struct;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &streamind, &folder, &folder_len) == FAILURE) {
              return;
       }

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

       if (mail_unsubscribe(imap_le_struct->imap_stream, folder) == T) {
              RETURN_TRUE;
       } else {
              RETURN_FALSE;
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_fetchstructure  )

Definition at line 2288 of file php_imap.c.

{
       zval *streamind;
       long msgno, flags = 0;
       pils *imap_le_struct;
       BODY *body;
       int msgindex, argc = ZEND_NUM_ARGS();

       if (zend_parse_parameters(argc TSRMLS_CC, "rl|l", &streamind, &msgno, &flags) == FAILURE) {
              return;
       }

       if (flags && ((flags & ~FT_UID) != 0)) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid value for the options parameter");
              RETURN_FALSE;
       }

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

       if (msgno < 1) {
              RETURN_FALSE;
       }

       object_init(return_value);

       if ((argc == 3) && (flags & FT_UID)) {
              /* This should be cached; if it causes an extra RTT to the
                 IMAP server, then that's the price we pay for making
                 sure we don't crash. */
              msgindex = mail_msgno(imap_le_struct->imap_stream, msgno);
       } else {
              msgindex = msgno;
       }
       PHP_IMAP_CHECK_MSGNO(msgindex);

       mail_fetchstructure_full(imap_le_struct->imap_stream, msgno, &body , (argc == 3 ? flags : NIL));

       if (!body) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "No body information available");
              RETURN_FALSE;
       }

       _php_imap_add_body(return_value, body TSRMLS_CC);
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_fetchbody  )

Definition at line 2336 of file php_imap.c.

{
       zval *streamind;
       long msgno, flags = 0;
       pils *imap_le_struct;
       char *body, *sec;
       int sec_len;
       unsigned long len;
       int argc = ZEND_NUM_ARGS();

       if (zend_parse_parameters(argc TSRMLS_CC, "rls|l", &streamind, &msgno, &sec, &sec_len, &flags) == FAILURE) {
              return;
       }

       if (flags && ((flags & ~(FT_UID|FT_PEEK|FT_INTERNAL)) != 0)) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid value for the options parameter");
              RETURN_FALSE;
       }

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

       if (argc < 4 || !(flags & FT_UID)) {
              /* only perform the check if the msgno is a message number and not a UID */
              PHP_IMAP_CHECK_MSGNO(msgno);
       }

       body = mail_fetchbody_full(imap_le_struct->imap_stream, msgno, sec, &len, (argc == 4 ? flags : NIL));

       if (!body) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "No body information available");
              RETURN_FALSE;
       }
       RETVAL_STRINGL(body, len, 1);
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_fetchmime  )

Definition at line 2376 of file php_imap.c.

{
       zval *streamind;
       long msgno, flags = 0;
       pils *imap_le_struct;
       char *body, *sec;
       int sec_len;
       unsigned long len;
       int argc = ZEND_NUM_ARGS();

       if (zend_parse_parameters(argc TSRMLS_CC, "rls|l", &streamind, &msgno, &sec, &sec_len, &flags) == FAILURE) {
              return;
       }

       if (flags && ((flags & ~(FT_UID|FT_PEEK|FT_INTERNAL)) != 0)) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid value for the options parameter");
              RETURN_FALSE;
       }

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

       if (argc < 4 || !(flags & FT_UID)) {
              /* only perform the check if the msgno is a message number and not a UID */
              PHP_IMAP_CHECK_MSGNO(msgno);
       }

       body = mail_fetch_mime(imap_le_struct->imap_stream, msgno, sec, &len, (argc == 4 ? flags : NIL));

       if (!body) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "No body MIME information available");
              RETURN_FALSE;
       }
       RETVAL_STRINGL(body, len, 1);
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_savebody  )

Definition at line 2415 of file php_imap.c.

{
       zval *stream, **out;
       pils *imap_ptr = NULL;
       php_stream *writer = NULL;
       char *section = "";
       int section_len = 0, close_stream = 1;
       long msgno, flags = 0;

       if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZl|sl", &stream, &out, &msgno, &section, &section_len, &flags)) {
              RETURN_FALSE;
       }

       ZEND_FETCH_RESOURCE(imap_ptr, pils *, &stream, -1, "imap", le_imap);

       if (!imap_ptr) {
              RETURN_FALSE;
       }

       switch (Z_TYPE_PP(out))
       {
              case IS_LONG:
              case IS_RESOURCE:
                     close_stream = 0;
                     php_stream_from_zval(writer, out);
              break;

              default:
                     convert_to_string_ex(out);
                     writer = php_stream_open_wrapper(Z_STRVAL_PP(out), "wb", REPORT_ERRORS|ENFORCE_SAFE_MODE, NULL);
              break;
       }

       if (!writer) {
              RETURN_FALSE;
       }

       IMAPG(gets_stream) = writer;
       mail_parameters(NIL, SET_GETS, (void *) php_mail_gets);
       mail_fetchbody_full(imap_ptr->imap_stream, msgno, section, NULL, flags);
       mail_parameters(NIL, SET_GETS, (void *) NULL);
       IMAPG(gets_stream) = NULL;

       if (close_stream) {
              php_stream_close(writer);
       }

       RETURN_TRUE;
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_base64  )

Definition at line 2468 of file php_imap.c.

{
       char *text, *decode;
       int text_len;
       unsigned long newlength;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &text, &text_len) == FAILURE) {
              return;
       }

       decode = (char *) rfc822_base64((unsigned char *) text, text_len, &newlength);

       if (decode == NULL) {
              RETURN_FALSE;
       }

       RETVAL_STRINGL(decode, newlength, 1);
       fs_give((void**) &decode);
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_qprint  )

Definition at line 2491 of file php_imap.c.

{
       char *text, *decode;
       int text_len;
       unsigned long newlength;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &text, &text_len) == FAILURE) {
              return;
       }

       decode = (char *) rfc822_qprint((unsigned char *) text, text_len, &newlength);

       if (decode == NULL) {
              RETURN_FALSE;
       }

       RETVAL_STRINGL(decode, newlength, 1);
       fs_give((void**) &decode);
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_8bit  )

Definition at line 2514 of file php_imap.c.

{
       char *text, *decode;
       int text_len;
       unsigned long newlength;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &text, &text_len) == FAILURE) {
              return;
       }

       decode = (char *) rfc822_8bit((unsigned char *) text, text_len, &newlength);

       if (decode == NULL) {
              RETURN_FALSE;
       }

       RETVAL_STRINGL(decode, newlength, 1);
       fs_give((void**) &decode);
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_binary  )

Definition at line 2537 of file php_imap.c.

{
       char *text, *decode;
       int text_len;
       unsigned long newlength;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &text, &text_len) == FAILURE) {
              return;
       }

       decode = rfc822_binary(text, text_len, &newlength);

       if (decode == NULL) {
              RETURN_FALSE;
       }

       RETVAL_STRINGL(decode, newlength, 1);
       fs_give((void**) &decode);
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_mailboxmsginfo  )

Definition at line 2560 of file php_imap.c.

{
       zval *streamind;
       pils *imap_le_struct;
       char date[100];
       unsigned int msgno, unreadmsg, deletedmsg, msize;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &streamind) == FAILURE) {
              return;
       }

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

       /* Initialize return object */
       object_init(return_value);

       unreadmsg = 0;
       deletedmsg = 0;
       msize = 0;

       for (msgno = 1; msgno <= imap_le_struct->imap_stream->nmsgs; msgno++) {
              MESSAGECACHE * cache = mail_elt (imap_le_struct->imap_stream, msgno);
              mail_fetchstructure (imap_le_struct->imap_stream, msgno, NIL);

              if (!cache->seen || cache->recent) {
                     unreadmsg++;
              }

              if (cache->deleted) {
                     deletedmsg++;
              }
              msize = msize + cache->rfc822_size;
       }
       add_property_long(return_value, "Unread", unreadmsg);
       add_property_long(return_value, "Deleted", deletedmsg);
       add_property_long(return_value, "Nmsgs", imap_le_struct->imap_stream->nmsgs);
       add_property_long(return_value, "Size", msize);
       rfc822_date(date);
       add_property_string(return_value, "Date", date, 1);
       add_property_string(return_value, "Driver", imap_le_struct->imap_stream->dtb->name, 1);
       add_property_string(return_value, "Mailbox", imap_le_struct->imap_stream->mailbox, 1);
       add_property_long(return_value, "Recent", imap_le_struct->imap_stream->recent);
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_rfc822_write_address  )

Definition at line 2607 of file php_imap.c.

{
       char *mailbox, *host, *personal;
       int mailbox_len, host_len, personal_len;
       ADDRESS *addr;
       char *string;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sss", &mailbox, &mailbox_len, &host, &host_len, &personal, &personal_len) == FAILURE) {
              return;
       }

       addr=mail_newaddr();

       if (mailbox) {
              addr->mailbox = cpystr(mailbox);
       }

       if (host) {
              addr->host = cpystr(host);
       }

       if (personal) {
              addr->personal = cpystr(personal);
       }

       addr->next=NIL;
       addr->error=NIL;
       addr->adl=NIL;

       string = _php_rfc822_write_address(addr TSRMLS_CC);
       if (string) {
              RETVAL_STRING(string, 0);
       } else {
              RETURN_FALSE;
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_rfc822_parse_adrlist  )

Definition at line 2647 of file php_imap.c.

{
       zval *tovals;
       char *str, *defaulthost, *str_copy;
       int str_len, defaulthost_len;
       ADDRESS *addresstmp;
       ENVELOPE *env;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &str, &str_len, &defaulthost, &defaulthost_len) == FAILURE) {
              return;
       }

       env = mail_newenvelope();

       /* rfc822_parse_adrlist() modifies passed string. Copy it. */
       str_copy = estrndup(str, str_len);
       rfc822_parse_adrlist(&env->to, str_copy, defaulthost);
       efree(str_copy);

       array_init(return_value);

       addresstmp = env->to;

       if (addresstmp) do {
              MAKE_STD_ZVAL(tovals);
              object_init(tovals);
              if (addresstmp->mailbox) {
                     add_property_string(tovals, "mailbox", addresstmp->mailbox, 1);
              }
              if (addresstmp->host) {
                     add_property_string(tovals, "host", addresstmp->host, 1);
              }
              if (addresstmp->personal) {
                     add_property_string(tovals, "personal", addresstmp->personal, 1);
              }
              if (addresstmp->adl) {
                     add_property_string(tovals, "adl", addresstmp->adl, 1);
              }
              add_next_index_object(return_value, tovals TSRMLS_CC);
       } while ((addresstmp = addresstmp->next));

       mail_free_envelope(&env);
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_utf8  )

Definition at line 2694 of file php_imap.c.

{
       char *str;
       int str_len;
       SIZEDTEXT src, dest;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {
              return;
       }

       src.data  = NULL;
       src.size  = 0;
       dest.data = NULL;
       dest.size = 0;

       cpytxt(&src, str, str_len);

#ifndef HAVE_NEW_MIME2TEXT
       utf8_mime2text(&src, &dest);
#else
       utf8_mime2text(&src, &dest, U8T_DECOMPOSE);
#endif
       RETVAL_STRINGL(dest.data, dest.size, 1);
       if (dest.data) {
              free(dest.data);
       }
       if (src.data && src.data != dest.data) {
              free(src.data);
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_utf7_decode  )

Definition at line 2748 of file php_imap.c.

{
       /* author: Andrew Skalski <askalski@chek.com> */
       char *arg;
       const unsigned char *in, *inp, *endp;
       unsigned char *out, *outp;
       unsigned char c;
       int arg_len, inlen, outlen;
       enum {
              ST_NORMAL,    /* printable text */
              ST_DECODE0,   /* encoded text rotation... */
              ST_DECODE1,
              ST_DECODE2,
              ST_DECODE3
       } state;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &arg, &arg_len) == FAILURE) {
              return;
       }

       in = (const unsigned char *) arg;
       inlen = arg_len;

       /* validate and compute length of output string */
       outlen = 0;
       state = ST_NORMAL;
       for (endp = (inp = in) + inlen; inp < endp; inp++) {
              if (state == ST_NORMAL) {
                     /* process printable character */
                     if (SPECIAL(*inp)) {
                            php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid modified UTF-7 character: `%c'", *inp);
                            RETURN_FALSE;
                     } else if (*inp != '&') {
                            outlen++;
                     } else if (inp + 1 == endp) {
                            php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unexpected end of string");
                            RETURN_FALSE;
                     } else if (inp[1] != '-') {
                            state = ST_DECODE0;
                     } else {
                            outlen++;
                            inp++;
                     }
              } else if (*inp == '-') {
                     /* return to NORMAL mode */
                     if (state == ST_DECODE1) {
                            php_error_docref(NULL TSRMLS_CC, E_WARNING, "Stray modified base64 character: `%c'", *--inp);
                            RETURN_FALSE;
                     }
                     state = ST_NORMAL;
              } else if (!B64CHAR(*inp)) {
                     php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid modified base64 character: `%c'", *inp);
                     RETURN_FALSE;
              } else {
                     switch (state) {
                            case ST_DECODE3:
                                   outlen++;
                                   state = ST_DECODE0;
                                   break;
                            case ST_DECODE2:
                            case ST_DECODE1:
                                   outlen++;
                            case ST_DECODE0:
                                   state++;
                            case ST_NORMAL:
                                   break;
                     }
              }
       }

       /* enforce end state */
       if (state != ST_NORMAL) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unexpected end of string");
              RETURN_FALSE;
       }

       /* allocate output buffer */
       out = emalloc(outlen + 1);

       /* decode input string */
       outp = out;
       state = ST_NORMAL;
       for (endp = (inp = in) + inlen; inp < endp; inp++) {
              if (state == ST_NORMAL) {
                     if (*inp == '&' && inp[1] != '-') {
                            state = ST_DECODE0;
                     }
                     else if ((*outp++ = *inp) == '&') {
                            inp++;
                     }
              }
              else if (*inp == '-') {
                     state = ST_NORMAL;
              }
              else {
                     /* decode input character */
                     switch (state) {
                     case ST_DECODE0:
                            *outp = UNB64(*inp) << 2;
                            state = ST_DECODE1;
                            break;
                     case ST_DECODE1:
                            outp[1] = UNB64(*inp);
                            c = outp[1] >> 4;
                            *outp++ |= c;
                            *outp <<= 4;
                            state = ST_DECODE2;
                            break;
                     case ST_DECODE2:
                            outp[1] = UNB64(*inp);
                            c = outp[1] >> 2;
                            *outp++ |= c;
                            *outp <<= 6;
                            state = ST_DECODE3;
                            break;
                     case ST_DECODE3:
                            *outp++ |= UNB64(*inp);
                            state = ST_DECODE0;
                     case ST_NORMAL:
                            break;
                     }
              }
       }

       *outp = 0;

#if PHP_DEBUG
       /* warn if we computed outlen incorrectly */
       if (outp - out != outlen) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "outp - out [%ld] != outlen [%d]", outp - out, outlen);
       }
#endif

       RETURN_STRINGL(out, outlen, 0);
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_utf7_encode  )

Definition at line 2887 of file php_imap.c.

{
       /* author: Andrew Skalski <askalski@chek.com> */
       char *arg;
       const unsigned char *in, *inp, *endp;
       unsigned char *out, *outp;
       unsigned char c;
       int arg_len, inlen, outlen;
       enum {
              ST_NORMAL,    /* printable text */
              ST_ENCODE0,   /* encoded text rotation... */
              ST_ENCODE1,
              ST_ENCODE2
       } state;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &arg, &arg_len) == FAILURE) {
              return;
       }

       in = (const unsigned char *) arg;
       inlen = arg_len;

       /* compute the length of the result string */
       outlen = 0;
       state = ST_NORMAL;
       endp = (inp = in) + inlen;
       while (inp < endp) {
              if (state == ST_NORMAL) {
                     if (SPECIAL(*inp)) {
                            state = ST_ENCODE0;
                            outlen++;
                     } else if (*inp++ == '&') {
                            outlen++;
                     }
                     outlen++;
              } else if (!SPECIAL(*inp)) {
                     state = ST_NORMAL;
              } else {
                     /* ST_ENCODE0 -> ST_ENCODE1 - two chars
                      * ST_ENCODE1 -> ST_ENCODE2 - one char
                      * ST_ENCODE2 -> ST_ENCODE0 - one char
                      */
                     if (state == ST_ENCODE2) {
                            state = ST_ENCODE0;
                     }
                     else if (state++ == ST_ENCODE0) {
                            outlen++;
                     }
                     outlen++;
                     inp++;
              }
       }

       /* allocate output buffer */
       out = emalloc(outlen + 1);

       /* encode input string */
       outp = out;
       state = ST_NORMAL;
       endp = (inp = in) + inlen;
       while (inp < endp || state != ST_NORMAL) {
              if (state == ST_NORMAL) {
                     if (SPECIAL(*inp)) {
                            /* begin encoding */
                            *outp++ = '&';
                            state = ST_ENCODE0;
                     } else if ((*outp++ = *inp++) == '&') {
                            *outp++ = '-';
                     }
              } else if (inp == endp || !SPECIAL(*inp)) {
                     /* flush overflow and terminate region */
                     if (state != ST_ENCODE0) {
                            c = B64(*outp);
                            *outp++ = c;
                     }
                     *outp++ = '-';
                     state = ST_NORMAL;
              } else {
                     /* encode input character */
                     switch (state) {
                            case ST_ENCODE0:
                                   *outp++ = B64(*inp >> 2);
                                   *outp = *inp++ << 4;
                                   state = ST_ENCODE1;
                                   break;
                            case ST_ENCODE1:
                                   c = B64(*outp | *inp >> 4);
                                   *outp++ = c;
                                   *outp = *inp++ << 2;
                                   state = ST_ENCODE2;
                                   break;
                            case ST_ENCODE2:
                                   c = B64(*outp | *inp >> 6);
                                   *outp++ = c;
                                   *outp++ = B64(*inp++);
                                   state = ST_ENCODE0;
                            case ST_NORMAL:
                                   break;
                     }
              }
       }

       *outp = 0;

#if PHP_DEBUG
       /* warn if we computed outlen incorrectly */
       if (outp - out != outlen) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "outp - out [%ld] != outlen [%d]", outp - out, outlen);
       }
#endif

       RETURN_STRINGL(out, outlen, 0);
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_setflag_full  )

Definition at line 3055 of file php_imap.c.

{
       zval *streamind;
       char *sequence, *flag;
       int sequence_len, flag_len;
       long flags = 0;
       pils *imap_le_struct;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rss|l", &streamind, &sequence, &sequence_len, &flag, &flag_len, &flags) == FAILURE) {
              return;
       }

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

       mail_setflag_full(imap_le_struct->imap_stream, sequence, flag, (flags ? flags : NIL));
       RETURN_TRUE;
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_clearflag_full  )

Definition at line 3076 of file php_imap.c.

{
       zval *streamind;
       char *sequence, *flag;
       int sequence_len, flag_len;
       long flags = 0;
       pils *imap_le_struct;
       int argc = ZEND_NUM_ARGS();

       if (zend_parse_parameters(argc TSRMLS_CC, "rss|l", &streamind, &sequence, &sequence_len, &flag, &flag_len, &flags) ==FAILURE) {
              return;
       }

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

       mail_clearflag_full(imap_le_struct->imap_stream, sequence, flag, (argc == 4 ? flags : NIL));
       RETURN_TRUE;
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_sort  )

Definition at line 3098 of file php_imap.c.

{
       zval *streamind;
       char *criteria = NULL, *charset = NULL;
       int criteria_len, charset_len;
       long pgm, rev, flags = 0;
       pils *imap_le_struct;
       unsigned long *slst, *sl;
       char *search_criteria;
       SORTPGM *mypgm=NIL;
       SEARCHPGM *spg=NIL;
       int argc = ZEND_NUM_ARGS();

       if (zend_parse_parameters(argc TSRMLS_CC, "rll|lss", &streamind, &pgm, &rev, &flags, &criteria, &criteria_len, &charset, &charset_len) == FAILURE) {
              return;
       }

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

       if (pgm > SORTSIZE) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unrecognized sort criteria");
              RETURN_FALSE;
       }
       if (argc >= 4) {
              if (flags < 0) {
                     php_error_docref(NULL TSRMLS_CC, E_WARNING, "Search options parameter has to be greater than or equal to 0");
                     RETURN_FALSE;
              }
       }
       if (argc >= 5) {
              search_criteria = estrndup(criteria, criteria_len);
              spg = mail_criteria(search_criteria);
              efree(search_criteria);
       } else {
              spg = mail_newsearchpgm();
       }

       mypgm = mail_newsortpgm();
       mypgm->reverse = rev;
       mypgm->function = (short) pgm;
       mypgm->next = NIL;

       slst = mail_sort(imap_le_struct->imap_stream, (argc == 6 ? charset : NIL), spg, mypgm, (argc >= 4 ? flags : NIL));

       if (spg && !(flags & SE_FREE)) {
              mail_free_searchpgm(&spg);
       }

       array_init(return_value);
       if (slst != NIL && slst != 0) {
              for (sl = slst; *sl; sl++) {
                     add_next_index_long(return_value, *sl);
              }
              fs_give ((void **) &slst);
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_fetchheader  )

Definition at line 3158 of file php_imap.c.

{
       zval *streamind;
       long msgno, flags=0L;
       pils *imap_le_struct;
       int msgindex, argc = ZEND_NUM_ARGS();

       if (zend_parse_parameters(argc TSRMLS_CC, "rl|l", &streamind, &msgno, &flags) == FAILURE) {
              return;
       }

       if (flags && ((flags & ~(FT_UID|FT_INTERNAL|FT_PREFETCHTEXT)) != 0)) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid value for the options parameter");
              RETURN_FALSE;
       }

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

       if ((argc == 3) && (flags & FT_UID)) {
              /* This should be cached; if it causes an extra RTT to the
                 IMAP server, then that's the price we pay for making sure
                 we don't crash. */
              msgindex = mail_msgno(imap_le_struct->imap_stream, msgno);
       } else {
              msgindex = msgno;
       }

       PHP_IMAP_CHECK_MSGNO(msgindex);

       RETVAL_STRING(mail_fetchheader_full(imap_le_struct->imap_stream, msgno, NIL, NIL, (argc == 3 ? flags : NIL)), 1);
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_uid  )

Definition at line 3193 of file php_imap.c.

{
       zval *streamind;
       long msgno;
       pils *imap_le_struct;
       int msgindex;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &streamind, &msgno) == FAILURE) {
              return;
       }

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

       msgindex = msgno;
       if ((msgindex < 1) || ((unsigned) msgindex > imap_le_struct->imap_stream->nmsgs)) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "Bad message number");
              RETURN_FALSE;
       }

       RETURN_LONG(mail_uid(imap_le_struct->imap_stream, msgno));
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_msgno  )

Definition at line 3218 of file php_imap.c.

{
       zval *streamind;
       long msgno;
       pils *imap_le_struct;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &streamind, &msgno) == FAILURE) {
              return;
       }

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

       RETURN_LONG(mail_msgno(imap_le_struct->imap_stream, msgno));
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_status  )

Definition at line 3236 of file php_imap.c.

{
       zval *streamind;
       char *mbx;
       int mbx_len;
       long flags;
       pils *imap_le_struct;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsl", &streamind, &mbx, &mbx_len, &flags) == FAILURE) {
              return;
       }

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

       object_init(return_value);

       if (mail_status(imap_le_struct->imap_stream, mbx, flags)) {
              add_property_long(return_value, "flags", IMAPG(status_flags));
              if (IMAPG(status_flags) & SA_MESSAGES) {
                     add_property_long(return_value, "messages", IMAPG(status_messages));
              }
              if (IMAPG(status_flags) & SA_RECENT) {
                     add_property_long(return_value, "recent", IMAPG(status_recent));
              }
              if (IMAPG(status_flags) & SA_UNSEEN) {
                     add_property_long(return_value, "unseen", IMAPG(status_unseen));
              }
              if (IMAPG(status_flags) & SA_UIDNEXT) {
                     add_property_long(return_value, "uidnext", IMAPG(status_uidnext));
              }
              if (IMAPG(status_flags) & SA_UIDVALIDITY) {
                     add_property_long(return_value, "uidvalidity", IMAPG(status_uidvalidity));
              }
       } else {
              RETURN_FALSE;
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_bodystruct  )

Definition at line 3277 of file php_imap.c.

{
       zval *streamind;
       long msg;
       char *section;
       int section_len;
       pils *imap_le_struct;
       zval *parametres, *param, *dparametres, *dparam;
       PARAMETER *par, *dpar;
       BODY *body;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rls", &streamind, &msg, &section, &section_len) == FAILURE) {
              return;
       }

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

       if (!msg || msg < 1 || (unsigned) msg > imap_le_struct->imap_stream->nmsgs) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "Bad message number");
              RETURN_FALSE;
       }

       object_init(return_value);

       body=mail_body(imap_le_struct->imap_stream, msg, section);
       if (body == NULL) {
              zval_dtor(return_value);
              RETURN_FALSE;
       }
       if (body->type <= TYPEMAX) {
              add_property_long(return_value, "type", body->type);
       }
       if (body->encoding <= ENCMAX) {
              add_property_long(return_value, "encoding", body->encoding);
       }

       if (body->subtype) {
              add_property_long(return_value, "ifsubtype", 1);
              add_property_string(return_value, "subtype", body->subtype, 1);
       } else {
              add_property_long(return_value, "ifsubtype", 0);
       }

       if (body->description) {
              add_property_long(return_value, "ifdescription", 1);
              add_property_string(return_value, "description", body->description, 1);
       } else {
              add_property_long(return_value, "ifdescription", 0);
       }
       if (body->id) {
              add_property_long(return_value, "ifid", 1);
              add_property_string(return_value, "id", body->id, 1);
       } else {
              add_property_long(return_value, "ifid", 0);
       }

       if (body->size.lines) {
              add_property_long(return_value, "lines", body->size.lines);
       }
       if (body->size.bytes) {
              add_property_long(return_value, "bytes", body->size.bytes);
       }
#ifdef IMAP41
       if (body->disposition.type) {
              add_property_long(return_value, "ifdisposition", 1);
              add_property_string(return_value, "disposition", body->disposition.type, 1);
       } else {
              add_property_long(return_value, "ifdisposition", 0);
       }

       if (body->disposition.parameter) {
              dpar = body->disposition.parameter;
              add_property_long(return_value, "ifdparameters", 1);
              MAKE_STD_ZVAL(dparametres);
              array_init(dparametres);
              do {
                     MAKE_STD_ZVAL(dparam);
                     object_init(dparam);
                     add_property_string(dparam, "attribute", dpar->attribute, 1);
                     add_property_string(dparam, "value", dpar->value, 1);
                     add_next_index_object(dparametres, dparam TSRMLS_CC);
              } while ((dpar = dpar->next));
              add_assoc_object(return_value, "dparameters", dparametres TSRMLS_CC);
       } else {
              add_property_long(return_value, "ifdparameters", 0);
       }
#endif

       if ((par = body->parameter)) {
              add_property_long(return_value, "ifparameters", 1);

              MAKE_STD_ZVAL(parametres);
              array_init(parametres);
              do {
                     MAKE_STD_ZVAL(param);
                     object_init(param);
                     if (par->attribute) {
                            add_property_string(param, "attribute", par->attribute, 1);
                     }
                     if (par->value) {
                            add_property_string(param, "value", par->value, 1);
                     }

                     add_next_index_object(parametres, param TSRMLS_CC);
              } while ((par = par->next));
       } else {
              MAKE_STD_ZVAL(parametres);
              object_init(parametres);
              add_property_long(return_value, "ifparameters", 0);
       }
       add_assoc_object(return_value, "parameters", parametres TSRMLS_CC);
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_fetch_overview  )

Definition at line 3394 of file php_imap.c.

{
       zval *streamind;
       char *sequence;
       int sequence_len;
       pils *imap_le_struct;
       zval *myoverview;
       char *address;
       long status, flags = 0L;
       int argc = ZEND_NUM_ARGS();

       if (zend_parse_parameters(argc TSRMLS_CC, "rs|l", &streamind, &sequence, &sequence_len, &flags) == FAILURE) {
              return;
       }

       if (flags && ((flags & ~FT_UID) != 0)) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid value for the options parameter");
              RETURN_FALSE;
       }

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

       array_init(return_value);

       status = (flags & FT_UID)
              ? mail_uid_sequence(imap_le_struct->imap_stream, sequence)
              : mail_sequence(imap_le_struct->imap_stream, sequence);

       if (status) {
              MESSAGECACHE *elt;
              ENVELOPE *env;
              unsigned long i;

              for (i = 1; i <= imap_le_struct->imap_stream->nmsgs; i++) {
                     if (((elt = mail_elt (imap_le_struct->imap_stream, i))->sequence) &&
                            (env = mail_fetch_structure (imap_le_struct->imap_stream, i, NIL, NIL))) {
                            MAKE_STD_ZVAL(myoverview);
                            object_init(myoverview);
                            if (env->subject) {
                                   add_property_string(myoverview, "subject", env->subject, 1);
                            }
                            if (env->from) {
                                   env->from->next=NULL;
                                   address =_php_rfc822_write_address(env->from TSRMLS_CC);
                                   if (address) {
                                          add_property_string(myoverview, "from", address, 0);
                                   }
                            }
                            if (env->to) {
                                   env->to->next = NULL;
                                   address = _php_rfc822_write_address(env->to TSRMLS_CC);
                                   if (address) {
                                          add_property_string(myoverview, "to", address, 0);
                                   }
                            }
                            if (env->date) {
                                   add_property_string(myoverview, "date", env->date, 1);
                            }
                            if (env->message_id) {
                                   add_property_string(myoverview, "message_id", env->message_id, 1);
                            }
                            if (env->references) {
                                   add_property_string(myoverview, "references", env->references, 1);
                            }
                            if (env->in_reply_to) {
                                   add_property_string(myoverview, "in_reply_to", env->in_reply_to, 1);
                            }
                            add_property_long(myoverview, "size", elt->rfc822_size);
                            add_property_long(myoverview, "uid", mail_uid(imap_le_struct->imap_stream, i));
                            add_property_long(myoverview, "msgno", i);
                            add_property_long(myoverview, "recent", elt->recent);
                            add_property_long(myoverview, "flagged", elt->flagged);
                            add_property_long(myoverview, "answered", elt->answered);
                            add_property_long(myoverview, "deleted", elt->deleted);
                            add_property_long(myoverview, "seen", elt->seen);
                            add_property_long(myoverview, "draft", elt->draft);
                            add_property_long(myoverview, "udate", mail_longdate(elt));
                            add_next_index_object(return_value, myoverview TSRMLS_CC);
                     }
              }
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_mail_compose  )

Definition at line 3480 of file php_imap.c.

{
       zval *envelope, *body;
       char *key;
       zval **data, **pvalue, **disp_data, **env_data;
       ulong ind;
       char *cookie = NIL;
       ENVELOPE *env;
       BODY *bod=NULL, *topbod=NULL;
       PART *mypart=NULL, *part;
       PARAMETER *param, *disp_param = NULL, *custom_headers_param = NULL, *tmp_param = NULL;
       char *tmp=NULL, *mystring=NULL, *t=NULL, *tempstring=NULL, *str_copy = NULL;
       int toppart = 0;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "aa", &envelope, &body) == FAILURE) {
              return;
       }

#define PHP_RFC822_PARSE_ADRLIST(target, value) \
       str_copy = estrndup(Z_STRVAL_PP(value), Z_STRLEN_PP(value)); \
       rfc822_parse_adrlist(target, str_copy, "NO HOST"); \
       efree(str_copy);

       env = mail_newenvelope();
       if (zend_hash_find(Z_ARRVAL_P(envelope), "remail", sizeof("remail"), (void **) &pvalue)== SUCCESS) {
              convert_to_string_ex(pvalue);
              env->remail = cpystr(Z_STRVAL_PP(pvalue));
       }
       if (zend_hash_find(Z_ARRVAL_P(envelope), "return_path", sizeof("return_path"), (void **) &pvalue)== SUCCESS) {
              convert_to_string_ex(pvalue);
              PHP_RFC822_PARSE_ADRLIST(&env->return_path, pvalue);
       }
       if (zend_hash_find(Z_ARRVAL_P(envelope), "date", sizeof("date"), (void **) &pvalue)== SUCCESS) {
              convert_to_string_ex(pvalue);
              env->date = cpystr(Z_STRVAL_PP(pvalue));
       }
       if (zend_hash_find(Z_ARRVAL_P(envelope), "from", sizeof("from"), (void **) &pvalue)== SUCCESS) {
              convert_to_string_ex(pvalue);
              PHP_RFC822_PARSE_ADRLIST(&env->from, pvalue);
       }
       if (zend_hash_find(Z_ARRVAL_P(envelope), "reply_to", sizeof("reply_to"), (void **) &pvalue)== SUCCESS) {
              convert_to_string_ex(pvalue);
              PHP_RFC822_PARSE_ADRLIST(&env->reply_to, pvalue);
       }
       if (zend_hash_find(Z_ARRVAL_P(envelope), "in_reply_to", sizeof("in_reply_to"), (void **) &pvalue)== SUCCESS) {
              convert_to_string_ex(pvalue);
              env->in_reply_to = cpystr(Z_STRVAL_PP(pvalue));
       }
       if (zend_hash_find(Z_ARRVAL_P(envelope), "subject", sizeof("subject"), (void **) &pvalue)== SUCCESS) {
              convert_to_string_ex(pvalue);
              env->subject = cpystr(Z_STRVAL_PP(pvalue));
       }
       if (zend_hash_find(Z_ARRVAL_P(envelope), "to", sizeof("to"), (void **) &pvalue)== SUCCESS) {
              convert_to_string_ex(pvalue);
              PHP_RFC822_PARSE_ADRLIST(&env->to, pvalue);
       }
       if (zend_hash_find(Z_ARRVAL_P(envelope), "cc", sizeof("cc"), (void **) &pvalue)== SUCCESS) {
              convert_to_string_ex(pvalue);
              PHP_RFC822_PARSE_ADRLIST(&env->cc, pvalue);
       }
       if (zend_hash_find(Z_ARRVAL_P(envelope), "bcc", sizeof("bcc"), (void **) &pvalue)== SUCCESS) {
              convert_to_string_ex(pvalue);
              PHP_RFC822_PARSE_ADRLIST(&env->bcc, pvalue);
       }
       if (zend_hash_find(Z_ARRVAL_P(envelope), "message_id", sizeof("message_id"), (void **) &pvalue)== SUCCESS) {
              convert_to_string_ex(pvalue);
              env->message_id=cpystr(Z_STRVAL_PP(pvalue));
       }

       if (zend_hash_find(Z_ARRVAL_P(envelope), "custom_headers", sizeof("custom_headers"), (void **) &pvalue)== SUCCESS) {
              if (Z_TYPE_PP(pvalue) == IS_ARRAY) {
                     custom_headers_param = tmp_param = NULL;
                     while (zend_hash_get_current_data(Z_ARRVAL_PP(pvalue), (void **) &env_data) == SUCCESS) {
                            custom_headers_param = mail_newbody_parameter();
                            convert_to_string_ex(env_data);
                            custom_headers_param->value = (char *) fs_get(Z_STRLEN_PP(env_data) + 1);
                            custom_headers_param->attribute = NULL;
                            memcpy(custom_headers_param->value, Z_STRVAL_PP(env_data), Z_STRLEN_PP(env_data) + 1);
                            zend_hash_move_forward(Z_ARRVAL_PP(pvalue));
                            custom_headers_param->next = tmp_param;
                            tmp_param = custom_headers_param;
                     }
              }
       }

       zend_hash_internal_pointer_reset(Z_ARRVAL_P(body));
       if (zend_hash_get_current_data(Z_ARRVAL_P(body), (void **) &data) != SUCCESS || Z_TYPE_PP(data) != IS_ARRAY) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "body parameter must be a non-empty array");
              RETURN_FALSE;
       }

       if (Z_TYPE_PP(data) == IS_ARRAY) {
              bod = mail_newbody();
              topbod = bod;

              if (zend_hash_find(Z_ARRVAL_PP(data), "type", sizeof("type"), (void **) &pvalue)== SUCCESS) {
                     convert_to_long_ex(pvalue);
                     bod->type = (short) Z_LVAL_PP(pvalue);
              }
              if (zend_hash_find(Z_ARRVAL_PP(data), "encoding", sizeof("encoding"), (void **) &pvalue)== SUCCESS) {
                     convert_to_long_ex(pvalue);
                     bod->encoding = (short) Z_LVAL_PP(pvalue);
              }
              if (zend_hash_find(Z_ARRVAL_PP(data), "charset", sizeof("charset"), (void **) &pvalue)== SUCCESS) {
                     convert_to_string_ex(pvalue);
                     tmp_param = mail_newbody_parameter();
                     tmp_param->value = cpystr(Z_STRVAL_PP(pvalue));
                     tmp_param->attribute = cpystr("CHARSET");
                     tmp_param->next = bod->parameter;
                     bod->parameter = tmp_param;
              }
              if (zend_hash_find(Z_ARRVAL_PP(data), "type.parameters", sizeof("type.parameters"), (void **) &pvalue)== SUCCESS) {
                     if(Z_TYPE_PP(pvalue) == IS_ARRAY) {
                            disp_param = tmp_param = NULL;
                            while (zend_hash_get_current_data(Z_ARRVAL_PP(pvalue), (void **) &disp_data) == SUCCESS) {
                                   disp_param = mail_newbody_parameter();
                                   zend_hash_get_current_key(Z_ARRVAL_PP(pvalue), &key, &ind, 0);
                                   disp_param->attribute = cpystr(key);
                                   convert_to_string_ex(disp_data);
                                   disp_param->value = (char *) fs_get(Z_STRLEN_PP(disp_data) + 1);
                                   memcpy(disp_param->value, Z_STRVAL_PP(disp_data), Z_STRLEN_PP(disp_data) + 1);
                                   zend_hash_move_forward(Z_ARRVAL_PP(pvalue));
                                   disp_param->next = tmp_param;
                                   tmp_param = disp_param;
                            }
                     bod->parameter = disp_param;
                     }
              }
              if (zend_hash_find(Z_ARRVAL_PP(data), "subtype", sizeof("subtype"), (void **) &pvalue)== SUCCESS) {
                     convert_to_string_ex(pvalue);
                     bod->subtype = cpystr(Z_STRVAL_PP(pvalue));
              }
              if (zend_hash_find(Z_ARRVAL_PP(data), "id", sizeof("id"), (void **) &pvalue)== SUCCESS) {
                     convert_to_string_ex(pvalue);
                     bod->id = cpystr(Z_STRVAL_PP(pvalue));
              }
              if (zend_hash_find(Z_ARRVAL_PP(data), "description", sizeof("description"), (void **) &pvalue)== SUCCESS) {
                     convert_to_string_ex(pvalue);
                     bod->description = cpystr(Z_STRVAL_PP(pvalue));
              }
              if (zend_hash_find(Z_ARRVAL_PP(data), "disposition.type", sizeof("disposition.type"), (void **) &pvalue)== SUCCESS) {
                     convert_to_string_ex(pvalue);
                     bod->disposition.type = (char *) fs_get(Z_STRLEN_PP(pvalue) + 1);
                     memcpy(bod->disposition.type, Z_STRVAL_PP(pvalue), Z_STRLEN_PP(pvalue)+1);
              }
              if (zend_hash_find(Z_ARRVAL_PP(data), "disposition", sizeof("disposition"), (void **) &pvalue)== SUCCESS) {
                     if (Z_TYPE_PP(pvalue) == IS_ARRAY) {
                            disp_param = tmp_param = NULL;
                            while (zend_hash_get_current_data(Z_ARRVAL_PP(pvalue), (void **) &disp_data) == SUCCESS) {
                                   disp_param = mail_newbody_parameter();
                                   zend_hash_get_current_key(Z_ARRVAL_PP(pvalue), &key, &ind, 0);
                                   disp_param->attribute = cpystr(key);
                                   convert_to_string_ex(disp_data);
                                   disp_param->value = (char *) fs_get(Z_STRLEN_PP(disp_data) + 1);
                                   memcpy(disp_param->value, Z_STRVAL_PP(disp_data), Z_STRLEN_PP(disp_data) + 1);
                                   zend_hash_move_forward(Z_ARRVAL_PP(pvalue));
                                   disp_param->next = tmp_param;
                                   tmp_param = disp_param;
                            }
                            bod->disposition.parameter = disp_param;
                     }
              }
              if (zend_hash_find(Z_ARRVAL_PP(data), "contents.data", sizeof("contents.data"), (void **) &pvalue)== SUCCESS) {
                     convert_to_string_ex(pvalue);
                     bod->contents.text.data = (char *) fs_get(Z_STRLEN_PP(pvalue) + 1);
                     memcpy(bod->contents.text.data, Z_STRVAL_PP(pvalue), Z_STRLEN_PP(pvalue)+1);
                     bod->contents.text.size = Z_STRLEN_PP(pvalue);
              } else {
                     bod->contents.text.data = (char *) fs_get(1);
                     memcpy(bod->contents.text.data, "", 1);
                     bod->contents.text.size = 0;
              }
              if (zend_hash_find(Z_ARRVAL_PP(data), "lines", sizeof("lines"), (void **) &pvalue)== SUCCESS) {
                     convert_to_long_ex(pvalue);
                     bod->size.lines = Z_LVAL_PP(pvalue);
              }
              if (zend_hash_find(Z_ARRVAL_PP(data), "bytes", sizeof("bytes"), (void **) &pvalue)== SUCCESS) {
                     convert_to_long_ex(pvalue);
                     bod->size.bytes = Z_LVAL_PP(pvalue);
              }
              if (zend_hash_find(Z_ARRVAL_PP(data), "md5", sizeof("md5"), (void **) &pvalue)== SUCCESS) {
                     convert_to_string_ex(pvalue);
                     bod->md5 = cpystr(Z_STRVAL_PP(pvalue));
              }
       }

       zend_hash_move_forward(Z_ARRVAL_P(body));

       while (zend_hash_get_current_data(Z_ARRVAL_P(body), (void **) &data) == SUCCESS) {
              if (Z_TYPE_PP(data) == IS_ARRAY) {
                     short type = -1;
                     if (zend_hash_find(Z_ARRVAL_PP(data), "type", sizeof("type"), (void **) &pvalue)== SUCCESS) {
                            convert_to_long_ex(pvalue);
                            type = (short) Z_LVAL_PP(pvalue);
                     }

                     if (!toppart) {
                            bod->nested.part = mail_newbody_part();
                            mypart = bod->nested.part;
                            toppart = 1;
                     } else {
                            mypart->next = mail_newbody_part();
                            mypart = mypart->next;
                     }

                     bod = &mypart->body;

                     if (type != TYPEMULTIPART) {
                            bod->type = type;
                     }

                     if (zend_hash_find(Z_ARRVAL_PP(data), "encoding", sizeof("encoding"), (void **) &pvalue)== SUCCESS) {
                            convert_to_long_ex(pvalue);
                            bod->encoding = (short) Z_LVAL_PP(pvalue);
                     }
                     if (zend_hash_find(Z_ARRVAL_PP(data), "charset", sizeof("charset"), (void **) &pvalue)== SUCCESS) {
                            convert_to_string_ex(pvalue);
                            tmp_param = mail_newbody_parameter();
                            tmp_param->value = (char *) fs_get(Z_STRLEN_PP(pvalue) + 1);
                            memcpy(tmp_param->value, Z_STRVAL_PP(pvalue), Z_STRLEN_PP(pvalue) + 1);
                            tmp_param->attribute = cpystr("CHARSET");
                            tmp_param->next = bod->parameter;
                            bod->parameter = tmp_param;
                     }
                     if (zend_hash_find(Z_ARRVAL_PP(data), "type.parameters", sizeof("type.parameters"), (void **) &pvalue)== SUCCESS) {
                            if(Z_TYPE_PP(pvalue) == IS_ARRAY) {
                                   disp_param = tmp_param = NULL;
                                   while (zend_hash_get_current_data(Z_ARRVAL_PP(pvalue), (void **) &disp_data) == SUCCESS) {
                                          disp_param = mail_newbody_parameter();
                                          zend_hash_get_current_key(Z_ARRVAL_PP(pvalue), &key, &ind, 0);
                                          disp_param->attribute = cpystr(key);
                                          convert_to_string_ex(disp_data);
                                          disp_param->value = (char *) fs_get(Z_STRLEN_PP(disp_data) + 1);
                                          memcpy(disp_param->value, Z_STRVAL_PP(disp_data), Z_STRLEN_PP(disp_data) + 1);
                                          zend_hash_move_forward(Z_ARRVAL_PP(pvalue));
                                          disp_param->next = tmp_param;
                                          tmp_param = disp_param;
                                   }
                                   bod->parameter = disp_param;
                            }
                     }
                     if (zend_hash_find(Z_ARRVAL_PP(data), "subtype", sizeof("subtype"), (void **) &pvalue)== SUCCESS) {
                            convert_to_string_ex(pvalue);
                            bod->subtype = cpystr(Z_STRVAL_PP(pvalue));
                     }
                     if (zend_hash_find(Z_ARRVAL_PP(data), "id", sizeof("id"), (void **) &pvalue)== SUCCESS) {
                            convert_to_string_ex(pvalue);
                            bod->id = cpystr(Z_STRVAL_PP(pvalue));
                     }
                     if (zend_hash_find(Z_ARRVAL_PP(data), "description", sizeof("description"), (void **) &pvalue)== SUCCESS) {
                            convert_to_string_ex(pvalue);
                            bod->description = cpystr(Z_STRVAL_PP(pvalue));
                     }
                     if (zend_hash_find(Z_ARRVAL_PP(data), "disposition.type", sizeof("disposition.type"), (void **) &pvalue)== SUCCESS) {
                            convert_to_string_ex(pvalue);
                            bod->disposition.type = (char *) fs_get(Z_STRLEN_PP(pvalue) + 1);
                            memcpy(bod->disposition.type, Z_STRVAL_PP(pvalue), Z_STRLEN_PP(pvalue)+1);
                     }
                     if (zend_hash_find(Z_ARRVAL_PP(data), "disposition", sizeof("disposition"), (void **) &pvalue)== SUCCESS) {
                            if (Z_TYPE_PP(pvalue) == IS_ARRAY) {
                                   disp_param = tmp_param = NULL;
                                   while (zend_hash_get_current_data(Z_ARRVAL_PP(pvalue), (void **) &disp_data) == SUCCESS) {
                                          disp_param = mail_newbody_parameter();
                                          zend_hash_get_current_key(Z_ARRVAL_PP(pvalue), &key, &ind, 0);
                                          disp_param->attribute = cpystr(key);
                                          convert_to_string_ex(disp_data);
                                          disp_param->value = (char *) fs_get(Z_STRLEN_PP(disp_data) + 1);
                                          memcpy(disp_param->value, Z_STRVAL_PP(disp_data), Z_STRLEN_PP(disp_data) + 1);
                                          zend_hash_move_forward(Z_ARRVAL_PP(pvalue));
                                          disp_param->next = tmp_param;
                                          tmp_param = disp_param;
                                   }
                                   bod->disposition.parameter = disp_param;
                            }
                     }
                     if (zend_hash_find(Z_ARRVAL_PP(data), "contents.data", sizeof("contents.data"), (void **) &pvalue)== SUCCESS) {
                            convert_to_string_ex(pvalue);
                            bod->contents.text.data = (char *) fs_get(Z_STRLEN_PP(pvalue) + 1);
                            memcpy(bod->contents.text.data, Z_STRVAL_PP(pvalue), Z_STRLEN_PP(pvalue) + 1);
                            bod->contents.text.size = Z_STRLEN_PP(pvalue);
                     } else {
                            bod->contents.text.data = (char *) fs_get(1);
                            memcpy(bod->contents.text.data, "", 1);
                            bod->contents.text.size = 0;
                     }
                     if (zend_hash_find(Z_ARRVAL_PP(data), "lines", sizeof("lines"), (void **) &pvalue)== SUCCESS) {
                            convert_to_long_ex(pvalue);
                            bod->size.lines = Z_LVAL_PP(pvalue);
                     }
                     if (zend_hash_find(Z_ARRVAL_PP(data), "bytes", sizeof("bytes"), (void **) &pvalue)== SUCCESS) {
                            convert_to_long_ex(pvalue);
                            bod->size.bytes = Z_LVAL_PP(pvalue);
                     }
                     if (zend_hash_find(Z_ARRVAL_PP(data), "md5", sizeof("md5"), (void **) &pvalue)== SUCCESS) {
                            convert_to_string_ex(pvalue);
                            bod->md5 = cpystr(Z_STRVAL_PP(pvalue));
                     }
              }
              zend_hash_move_forward(Z_ARRVAL_P(body));
       }

       if (bod && bod->type == TYPEMULTIPART && (!bod->nested.part || !bod->nested.part->next)) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "cannot generate multipart e-mail without components.");
              RETVAL_FALSE;
              goto done;
       }

       rfc822_encode_body_7bit(env, topbod);

       tmp = emalloc(SENDBUFLEN + 1);

       rfc822_header(tmp, env, topbod);

       /* add custom envelope headers */
       if (custom_headers_param) {
              int l = strlen(tmp) - 2, l2;
              PARAMETER *tp = custom_headers_param;

              /* remove last CRLF from tmp */
              tmp[l] = '\0';
              tempstring = emalloc(l);
              memcpy(tempstring, tmp, l);

              do {
                     l2 = strlen(custom_headers_param->value);
                     tempstring = erealloc(tempstring, l + l2 + CRLF_LEN + 1);
                     memcpy(tempstring + l, custom_headers_param->value, l2);
                     memcpy(tempstring + l + l2, CRLF, CRLF_LEN);
                     l += l2 + CRLF_LEN;
              } while ((custom_headers_param = custom_headers_param->next));

              mail_free_body_parameter(&tp);

              mystring = emalloc(l + CRLF_LEN + 1);
              memcpy(mystring, tempstring, l);
              memcpy(mystring + l , CRLF, CRLF_LEN);
              mystring[l + CRLF_LEN] = '\0';

              efree(tempstring);
       } else {
              mystring = estrdup(tmp);
       }

       bod = topbod;

       if (bod && bod->type == TYPEMULTIPART) {

              /* first body part */
                     part = bod->nested.part;

              /* find cookie */
                     for (param = bod->parameter; param && !cookie; param = param->next) {
                            if (!strcmp (param->attribute, "BOUNDARY")) {
                                   cookie = param->value;
                            }
                     }

              /* yucky default */
                     if (!cookie) {
                            cookie = "-";
                     } else if (strlen(cookie) > (SENDBUFLEN - 2 - 2 - 2)) { /* validate cookie length -- + CRLF * 2 */
                            php_error_docref(NULL TSRMLS_CC, E_WARNING, "The boundary should be no longer than 4kb");
                            RETVAL_FALSE;
                            goto done;
                     }

              /* for each part */
                     do {
                            t = tmp;

                     /* append mini-header */
                            *t = '\0';
                            rfc822_write_body_header(&t, &part->body);

                     /* output cookie, mini-header, and contents */
                            spprintf(&tempstring, 0, "%s--%s%s%s%s", mystring, cookie, CRLF, tmp, CRLF);
                            efree(mystring);
                            mystring=tempstring;

                            bod=&part->body;

                            spprintf(&tempstring, 0, "%s%s%s", mystring, bod->contents.text.data, CRLF);
                            efree(mystring);
                            mystring=tempstring;
                     } while ((part = part->next)); /* until done */

                     /* output trailing cookie */
                     spprintf(&tempstring, 0, "%s--%s--%s", mystring, cookie, CRLF);
                     efree(mystring);
                     mystring=tempstring;
       } else if (bod) {
              spprintf(&tempstring, 0, "%s%s%s", mystring, bod->contents.text.data, CRLF);
              efree(mystring);
              mystring=tempstring;
       } else {
              efree(mystring);
              RETVAL_FALSE;
              goto done;
       }

       RETVAL_STRING(tempstring, 0);
done:
       if (tmp) {
              efree(tmp);
       }
       mail_free_body(&topbod);
       mail_free_envelope(&env);
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_mail  )

Definition at line 4055 of file php_imap.c.

{
       char *to=NULL, *message=NULL, *headers=NULL, *subject=NULL, *cc=NULL, *bcc=NULL, *rpath=NULL;
       int to_len, message_len, headers_len, subject_len, cc_len, bcc_len, rpath_len, argc = ZEND_NUM_ARGS();

       if (zend_parse_parameters(argc TSRMLS_CC, "sss|ssss", &to, &to_len, &subject, &subject_len, &message, &message_len,
              &headers, &headers_len, &cc, &cc_len, &bcc, &bcc_len, &rpath, &rpath_len) == FAILURE) {
              return;
       }

       /* To: */
       if (!to_len) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "No to field in mail command");
              RETURN_FALSE;
       }

       /* Subject: */
       if (!subject_len) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "No subject field in mail command");
              RETURN_FALSE;
       }

       /* message body */
       if (!message_len) {
              /* this is not really an error, so it is allowed. */
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "No message string in mail command");
              message = NULL;
       }

       if (_php_imap_mail(to, subject, message, headers, cc, bcc, rpath TSRMLS_CC)) {
              RETURN_TRUE;
       } else {
              RETURN_FALSE;
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_search  )

Definition at line 4094 of file php_imap.c.

{
       zval *streamind;
       char *criteria, *charset = NULL;
       int criteria_len, charset_len = 0;
       long flags = SE_FREE;
       pils *imap_le_struct;
       char *search_criteria;
       MESSAGELIST *cur;
       int argc = ZEND_NUM_ARGS();
       SEARCHPGM *pgm = NIL;

       if (zend_parse_parameters(argc TSRMLS_CC, "rs|ls", &streamind, &criteria, &criteria_len, &flags, &charset, &charset_len) == FAILURE) {
              return;
       }

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

       search_criteria = estrndup(criteria, criteria_len);

       IMAPG(imap_messages) = IMAPG(imap_messages_tail) = NIL;
       pgm = mail_criteria(search_criteria);

       mail_search_full(imap_le_struct->imap_stream, (argc == 4 ? charset : NIL), pgm, flags);

       if (pgm && !(flags & SE_FREE)) {
              mail_free_searchpgm(&pgm);
       }

       if (IMAPG(imap_messages) == NIL) {
              efree(search_criteria);
              RETURN_FALSE;
       }

       array_init(return_value);

       cur = IMAPG(imap_messages);
       while (cur != NIL) {
              add_next_index_long(return_value, cur->msgid);
              cur = cur->next;
       }
       mail_free_messagelist(&IMAPG(imap_messages), &IMAPG(imap_messages_tail));
       efree(search_criteria);
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_alerts  )

Definition at line 4143 of file php_imap.c.

{
       STRINGLIST *cur=NIL;

       if (zend_parse_parameters_none() == FAILURE) {
              return;
       }

       if (IMAPG(imap_alertstack) == NIL) {
              RETURN_FALSE;
       }

       array_init(return_value);

       cur = IMAPG(imap_alertstack);
       while (cur != NIL) {
              add_next_index_string(return_value, cur->LTEXT, 1);
              cur = cur->next;
       }
       mail_free_stringlist(&IMAPG(imap_alertstack));
       IMAPG(imap_alertstack) = NIL;
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_errors  )

Definition at line 4170 of file php_imap.c.

{
       ERRORLIST *cur=NIL;

       if (zend_parse_parameters_none() == FAILURE) {
              return;
       }

       if (IMAPG(imap_errorstack) == NIL) {
              RETURN_FALSE;
       }

       array_init(return_value);

       cur = IMAPG(imap_errorstack);
       while (cur != NIL) {
              add_next_index_string(return_value, cur->LTEXT, 1);
              cur = cur->next;
       }
       mail_free_errorlist(&IMAPG(imap_errorstack));
       IMAPG(imap_errorstack) = NIL;
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_last_error  )

Definition at line 4197 of file php_imap.c.

{
       ERRORLIST *cur=NIL;

       if (zend_parse_parameters_none() == FAILURE) {
              return;
       }

       if (IMAPG(imap_errorstack) == NIL) {
              RETURN_FALSE;
       }

       cur = IMAPG(imap_errorstack);
       while (cur != NIL) {
              if (cur->next == NIL) {
                     RETURN_STRING(cur->LTEXT, 1);
              }
              cur = cur->next;
       }
}
PHP_FUNCTION ( imap_mime_header_decode  )

Definition at line 4221 of file php_imap.c.

{
       /* Author: Ted Parnefors <ted@mtv.se> */
       zval *myobject;
       char *str, *string, *charset, encoding, *text, *decode;
       int str_len;
       long charset_token, encoding_token, end_token, end, offset=0, i;
       unsigned long newlength;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {
              return;
       }

       array_init(return_value);

       string = str;
       end = str_len;

       charset = (char *) safe_emalloc((end + 1), 2, 0);
       text = &charset[end + 1];
       while (offset < end) {      /* Reached end of the string? */
              if ((charset_token = (long)php_memnstr(&string[offset], "=?", 2, string + end))) {  /* Is there anything encoded in the string? */
                     charset_token -= (long)string;
                     if (offset != charset_token) {     /* Is there anything before the encoded data? */
                            /* Retrieve unencoded data that is found before encoded data */
                            memcpy(text, &string[offset], charset_token-offset);
                            text[charset_token - offset] = 0x00;
                            MAKE_STD_ZVAL(myobject);
                            object_init(myobject);
                            add_property_string(myobject, "charset", "default", 1);
                            add_property_string(myobject, "text", text, 1);
                            zend_hash_next_index_insert(Z_ARRVAL_P(return_value), (void *)&myobject, sizeof(zval *), NULL);
                     }
                     if ((encoding_token = (long)php_memnstr(&string[charset_token+2], "?", 1, string+end))) {         /* Find token for encoding */
                            encoding_token -= (long)string;
                            if ((end_token = (long)php_memnstr(&string[encoding_token+3], "?=", 2, string+end))) {     /* Find token for end of encoded data */
                                   end_token -= (long)string;
                                   memcpy(charset, &string[charset_token + 2], encoding_token - (charset_token + 2));  /* Extract charset encoding */
                                   charset[encoding_token-(charset_token + 2)] = 0x00;
                                   encoding=string[encoding_token + 1];      /* Extract encoding from string */
                                   memcpy(text, &string[encoding_token + 3], end_token - (encoding_token + 3)); /* Extract text */
                                   text[end_token - (encoding_token + 3)] = 0x00;
                                   decode = text;
                                   if (encoding == 'q' || encoding == 'Q') { /* Decode 'q' encoded data */
                                          for(i=0; text[i] != 0x00; i++) if (text[i] == '_') text[i] = ' ';     /* Replace all *_' with space. */
                                          decode = (char *)rfc822_qprint((unsigned char *) text, strlen(text), &newlength);
                                   } else if (encoding == 'b' || encoding == 'B') {
                                          decode = (char *)rfc822_base64((unsigned char *) text, strlen(text), &newlength); /* Decode 'B' encoded data */
                                   }
                                   if (decode == NULL) {
                                          efree(charset);
                                          zval_dtor(return_value);
                                          RETURN_FALSE;
                                   }
                                   MAKE_STD_ZVAL(myobject);
                                   object_init(myobject);
                                   add_property_string(myobject, "charset", charset, 1);
                                   add_property_string(myobject, "text", decode, 1);
                                   zend_hash_next_index_insert(Z_ARRVAL_P(return_value), (void *)&myobject, sizeof(zval *), NULL);

                                   /* only free decode if it was allocated by rfc822_qprint or rfc822_base64 */
                                   if (decode != text) {
                                          fs_give((void**)&decode);
                                   }

                                   offset = end_token+2;
                                   for (i = 0; (string[offset + i] == ' ') || (string[offset + i] == 0x0a) || (string[offset + i] == 0x0d) || (string[offset + i] == '\t'); i++);
                                   if ((string[offset + i] == '=') && (string[offset + i + 1] == '?') && (offset + i < end)) {
                                          offset += i;
                                   }
                                   continue;     /*/ Iterate the loop again please. */
                            }
                     }
              } else {
                     /* Just some tweaking to optimize the code, and get the end statements work in a general manner.
                      * If we end up here we didn't find a position for "charset_token",
                      * so we need to set it to the start of the yet unextracted data.
                      */
                     charset_token = offset;
              }
              /* Return the rest of the data as unencoded, as it was either unencoded or was missing separators
                 which rendered the remainder of the string impossible for us to decode. */
              memcpy(text, &string[charset_token], end - charset_token);     /* Extract unencoded text from string */
              text[end - charset_token] = 0x00;
              MAKE_STD_ZVAL(myobject);
              object_init(myobject);
              add_property_string(myobject, "charset", "default", 1);
              add_property_string(myobject, "text", text, 1);
              zend_hash_next_index_insert(Z_ARRVAL_P(return_value), (void *)&myobject, sizeof(zval *), NULL);

              offset = end; /* We have reached the end of the string. */
       }
       efree(charset);
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_thread  )

Definition at line 4717 of file php_imap.c.

{
       zval *streamind;
       pils *imap_le_struct;
       long flags = SE_FREE;
       char criteria[] = "ALL";
       THREADNODE *top;
       int argc = ZEND_NUM_ARGS();
       SEARCHPGM *pgm = NIL;

       if (zend_parse_parameters(argc TSRMLS_CC, "r|l", &streamind, &flags) == FAILURE) {
              return;
       }

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

       pgm = mail_criteria(criteria);
       top = mail_thread(imap_le_struct->imap_stream, "REFERENCES", NIL, pgm, flags);
       if (pgm && !(flags & SE_FREE)) {
              mail_free_searchpgm(&pgm);
       }

       if(top == NIL) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "Function returned an empty tree");
              RETURN_FALSE;
       }

       /* Populate our return value data structure here. */
       if(build_thread_tree(top, &return_value) == FAILURE) {
              mail_free_threadnode(&top);
              RETURN_FALSE;
       }
       mail_free_threadnode(&top);
}

Here is the call graph for this function:

PHP_FUNCTION ( imap_timeout  )

Definition at line 4755 of file php_imap.c.

{
       long ttype, timeout=-1;
       int timeout_type;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|l", &ttype, &timeout) == FAILURE) {
              RETURN_FALSE;
       }

       if (timeout == -1) {
              switch (ttype) {
                     case 1:
                            timeout_type = GET_OPENTIMEOUT;
                            break;
                     case 2:
                            timeout_type = GET_READTIMEOUT;
                            break;
                     case 3:
                            timeout_type = GET_WRITETIMEOUT;
                            break;
                     case 4:
                            timeout_type = GET_CLOSETIMEOUT;
                            break;
                     default:
                            RETURN_FALSE;
                            break;
              }

              timeout = (long) mail_parameters(NIL, timeout_type, NIL);
              RETURN_LONG(timeout);
       } else if (timeout >= 0) {
              switch (ttype) {
                     case 1:
                            timeout_type = SET_OPENTIMEOUT;
                            break;
                     case 2:
                            timeout_type = SET_READTIMEOUT;
                            break;
                     case 3:
                            timeout_type = SET_WRITETIMEOUT;
                            break;
                     case 4:
                            timeout_type = SET_CLOSETIMEOUT;
                            break;
                     default:
                            RETURN_FALSE;
                            break;
              }

              timeout = (long) mail_parameters(NIL, timeout_type, (void *) timeout);
              RETURN_TRUE;
       } else {
              RETURN_FALSE;
       }
}

Here is the call graph for this function:

static PHP_GINIT_FUNCTION ( imap  ) [static]

Definition at line 804 of file php_imap.c.

{
       imap_globals->imap_user = NIL;
       imap_globals->imap_password = NIL;

       imap_globals->imap_alertstack = NIL;
       imap_globals->imap_errorstack = NIL;

       imap_globals->imap_folders = NIL;
       imap_globals->imap_folders_tail = NIL;
       imap_globals->imap_sfolders = NIL;
       imap_globals->imap_sfolders_tail = NIL;
       imap_globals->imap_messages = NIL;
       imap_globals->imap_messages_tail = NIL;
       imap_globals->imap_folder_objects = NIL;
       imap_globals->imap_folder_objects_tail = NIL;
       imap_globals->imap_sfolder_objects = NIL;
       imap_globals->imap_sfolder_objects_tail = NIL;

       imap_globals->folderlist_style = FLIST_ARRAY;
#if defined(HAVE_IMAP2000) || defined(HAVE_IMAP2001)
       imap_globals->quota_return = NIL;
       imap_globals->imap_acl_list = NIL;
#endif
       imap_globals->gets_stream = NIL;
}
static void php_imap_do_open ( INTERNAL_FUNCTION_PARAMETERS  ,
int  persistent 
) [static]

Definition at line 1146 of file php_imap.c.

{
       char *mailbox, *user, *passwd;
       int mailbox_len, user_len, passwd_len;
       long retries = 0, flags = NIL, cl_flags = NIL;
       MAILSTREAM *imap_stream;
       pils *imap_le_struct;
       zval *params = NULL;
       int argc = ZEND_NUM_ARGS();

       if (zend_parse_parameters(argc TSRMLS_CC, "sss|lla", &mailbox, &mailbox_len, &user, &user_len,
              &passwd, &passwd_len, &flags, &retries, &params) == FAILURE) {
              return;
       }

       if (argc >= 4) {
              if (flags & PHP_EXPUNGE) {
                     cl_flags = CL_EXPUNGE;
                     flags ^= PHP_EXPUNGE;
              }
              if (flags & OP_PROTOTYPE) {
                     cl_flags |= OP_PROTOTYPE;
              }
       }

       if (params) {
              zval **disabled_auth_method;

              if (zend_hash_find(HASH_OF(params), "DISABLE_AUTHENTICATOR", sizeof("DISABLE_AUTHENTICATOR"), (void **)&disabled_auth_method) == SUCCESS) {
                     switch (Z_TYPE_PP(disabled_auth_method)) {
                            case IS_STRING:
                                   if (Z_STRLEN_PP(disabled_auth_method) > 1) {
                                          mail_parameters (NIL, DISABLE_AUTHENTICATOR, (void *)Z_STRVAL_PP(disabled_auth_method));
                                   }
                                   break;
                            case IS_ARRAY:
                                   {
                                          zval **z_auth_method;
                                          int i;
                                          int nelems = zend_hash_num_elements(Z_ARRVAL_PP(disabled_auth_method));

                                          if (nelems == 0 ) {
                                                 break;
                                          }
                                          for (i = 0; i < nelems; i++) {
                                                 if (zend_hash_index_find(Z_ARRVAL_PP(disabled_auth_method), i, (void **) &z_auth_method) == SUCCESS) {
                                                        if (Z_TYPE_PP(z_auth_method) == IS_STRING) {
                                                               if (Z_STRLEN_PP(z_auth_method) > 1) {
                                                                      mail_parameters (NIL, DISABLE_AUTHENTICATOR, (void *)Z_STRVAL_PP(disabled_auth_method));
                                                               }
                                                        } else {
                                                               php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid argument, expect string or array of strings");
                                                        }
                                                 }
                                          }
                                   }
                                   break;
                            case IS_LONG:
                            default:
                                   php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid argument, expect string or array of strings");
                                   break;
                     }
              }
       }

       if (IMAPG(imap_user)) {
              efree(IMAPG(imap_user));
              IMAPG(imap_user) = 0;
       }

       if (IMAPG(imap_password)) {
              efree(IMAPG(imap_password));
              IMAPG(imap_password) = 0;
       }

       /* local filename, need to perform open_basedir and safe_mode checks */
       if (mailbox[0] != '{') {
              if (strlen(mailbox) != mailbox_len) {
                     RETURN_FALSE;
              }
              if (php_check_open_basedir(mailbox TSRMLS_CC) ||
                     (PG(safe_mode) && !php_checkuid(mailbox, NULL, CHECKUID_CHECK_FILE_AND_DIR))) {
                     RETURN_FALSE;
              }
       }

       IMAPG(imap_user)     = estrndup(user, user_len);
       IMAPG(imap_password) = estrndup(passwd, passwd_len);

#ifdef SET_MAXLOGINTRIALS
       if (argc >= 5) {
              if (retries < 0) {
                     php_error_docref(NULL TSRMLS_CC, E_WARNING ,"Retries must be greater or equal to 0");
              } else {
                     mail_parameters(NIL, SET_MAXLOGINTRIALS, (void *) retries);
              }
       }
#endif

       imap_stream = mail_open(NIL, mailbox, flags);

       if (imap_stream == NIL) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "Couldn't open stream %s", mailbox);
              efree(IMAPG(imap_user)); IMAPG(imap_user) = 0;
              efree(IMAPG(imap_password)); IMAPG(imap_password) = 0;
              RETURN_FALSE;
       }

       imap_le_struct = emalloc(sizeof(pils));
       imap_le_struct->imap_stream = imap_stream;
       imap_le_struct->flags = cl_flags;

       ZEND_REGISTER_RESOURCE(return_value, imap_le_struct, le_imap);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static char * php_mail_gets ( readfn_t  f,
void *  stream,
unsigned long  size,
GETS_DATA *  md 
) [static]

Definition at line 4813 of file php_imap.c.

{
       TSRMLS_FETCH();

       /*     write to the gets stream if it is set,
              otherwise forward to c-clients gets */
       if (IMAPG(gets_stream)) {
              char buf[GETS_FETCH_SIZE];

              while (size) {
                     unsigned long read;

                     if (size > GETS_FETCH_SIZE) {
                            read = GETS_FETCH_SIZE;
                            size -=GETS_FETCH_SIZE;
                     } else {
                            read = size;
                            size = 0;
                     }

                     if (!f(stream, read, buf)) {
                            php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to read from socket");
                            break;
                     } else if (read != php_stream_write(IMAPG(gets_stream), buf, read)) {
                            php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to write to stream");
                            break;
                     }
              }
              return NULL;
       } else {
              char *buf = pemalloc(size + 1, 1);

              if (f(stream, size, buf)) {
                     buf[size] = '\0';
              } else {
                     php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to read from socket");
                     free(buf);
                     buf = NULL;
              }
              return buf;
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

PHP_MINFO_FUNCTION ( imap  )

Definition at line 1130 of file php_imap.c.

{
       php_info_print_table_start();
       php_info_print_table_row(2, "IMAP c-Client Version", CCLIENTVERSION);
#if HAVE_IMAP_SSL
       php_info_print_table_row(2, "SSL Support", "enabled");
#endif
#if HAVE_IMAP_KRB && HAVE_IMAP_AUTH_GSS
       php_info_print_table_row(2, "Kerberos Support", "enabled");
#endif
       php_info_print_table_end();
}

Here is the call graph for this function:

PHP_MINIT_FUNCTION ( imap  )

Definition at line 834 of file php_imap.c.

{
       unsigned long sa_all =      SA_MESSAGES | SA_RECENT | SA_UNSEEN | SA_UIDNEXT | SA_UIDVALIDITY;

#ifndef PHP_WIN32
       mail_link(&unixdriver);            /* link in the unix driver */
       mail_link(&mhdriver);              /* link in the mh driver */
       /* mail_link(&mxdriver); */ /* According to c-client docs (internal.txt) this shouldn't be used. */
       mail_link(&mmdfdriver);            /* link in the mmdf driver */
       mail_link(&newsdriver);            /* link in the news driver */
       mail_link(&philedriver);    /* link in the phile driver */
#endif
       mail_link(&imapdriver);            /* link in the imap driver */
       mail_link(&nntpdriver);            /* link in the nntp driver */
       mail_link(&pop3driver);            /* link in the pop3 driver */
       mail_link(&mbxdriver);             /* link in the mbx driver */
       mail_link(&tenexdriver);    /* link in the tenex driver */
       mail_link(&mtxdriver);             /* link in the mtx driver */
       mail_link(&dummydriver);    /* link in the dummy driver */

#ifndef PHP_WIN32
       auth_link(&auth_log);              /* link in the log authenticator */
       auth_link(&auth_md5);              /* link in the cram-md5 authenticator */
#if HAVE_IMAP_KRB && defined(HAVE_IMAP_AUTH_GSS)
       auth_link(&auth_gss);              /* link in the gss authenticator */
#endif
       auth_link(&auth_pla);              /* link in the plain authenticator */
#endif

#ifdef HAVE_IMAP_SSL
       ssl_onceonlyinit ();
#endif

       /* lets allow NIL */
       REGISTER_LONG_CONSTANT("NIL", NIL, CONST_PERSISTENT | CONST_CS);

       /* plug in our gets */
       mail_parameters(NIL, SET_GETS, (void *) NIL);

       /* set default timeout values */
       mail_parameters(NIL, SET_OPENTIMEOUT, (void *) FG(default_socket_timeout));
       mail_parameters(NIL, SET_READTIMEOUT, (void *) FG(default_socket_timeout));
       mail_parameters(NIL, SET_WRITETIMEOUT, (void *) FG(default_socket_timeout));
       mail_parameters(NIL, SET_CLOSETIMEOUT, (void *) FG(default_socket_timeout));

       /* timeout constants */
       REGISTER_LONG_CONSTANT("IMAP_OPENTIMEOUT", 1, CONST_PERSISTENT | CONST_CS);
       REGISTER_LONG_CONSTANT("IMAP_READTIMEOUT", 2, CONST_PERSISTENT | CONST_CS);
       REGISTER_LONG_CONSTANT("IMAP_WRITETIMEOUT", 3, CONST_PERSISTENT | CONST_CS);
       REGISTER_LONG_CONSTANT("IMAP_CLOSETIMEOUT", 4, CONST_PERSISTENT | CONST_CS);

       /* Open Options */

       REGISTER_LONG_CONSTANT("OP_DEBUG", OP_DEBUG, CONST_PERSISTENT | CONST_CS);
       /* debug protocol negotiations */
       REGISTER_LONG_CONSTANT("OP_READONLY", OP_READONLY, CONST_PERSISTENT | CONST_CS);
       /* read-only open */
       REGISTER_LONG_CONSTANT("OP_ANONYMOUS", OP_ANONYMOUS, CONST_PERSISTENT | CONST_CS);
       /* anonymous open of newsgroup */
       REGISTER_LONG_CONSTANT("OP_SHORTCACHE", OP_SHORTCACHE, CONST_PERSISTENT | CONST_CS);
       /* short (elt-only) caching */
       REGISTER_LONG_CONSTANT("OP_SILENT", OP_SILENT, CONST_PERSISTENT | CONST_CS);
       /* don't pass up events (internal use) */
       REGISTER_LONG_CONSTANT("OP_PROTOTYPE", OP_PROTOTYPE, CONST_PERSISTENT | CONST_CS);
       /* return driver prototype */
       REGISTER_LONG_CONSTANT("OP_HALFOPEN", OP_HALFOPEN, CONST_PERSISTENT | CONST_CS);
       /* half-open (IMAP connect but no select) */
       REGISTER_LONG_CONSTANT("OP_EXPUNGE", OP_EXPUNGE, CONST_PERSISTENT | CONST_CS);
       /* silently expunge recycle stream */
       REGISTER_LONG_CONSTANT("OP_SECURE", OP_SECURE, CONST_PERSISTENT | CONST_CS);
       /* don't do non-secure authentication */

       /*
       PHP re-assigns CL_EXPUNGE a custom value that can be used as part of the imap_open() bitfield
       because it seems like a good idea to be able to indicate that the mailbox should be
       automatically expunged during imap_open in case the script get interrupted and it doesn't get
       to the imap_close() where this option is normally placed.  If the c-client library adds other
       options and the value for this one conflicts, simply make PHP_EXPUNGE higher at the top of
       this file
       */
       REGISTER_LONG_CONSTANT("CL_EXPUNGE", PHP_EXPUNGE, CONST_PERSISTENT | CONST_CS);
       /* expunge silently */

       /* Fetch options */

       REGISTER_LONG_CONSTANT("FT_UID", FT_UID, CONST_PERSISTENT | CONST_CS);
       /* argument is a UID */
       REGISTER_LONG_CONSTANT("FT_PEEK", FT_PEEK, CONST_PERSISTENT | CONST_CS);
       /* peek at data */
       REGISTER_LONG_CONSTANT("FT_NOT", FT_NOT, CONST_PERSISTENT | CONST_CS);
       /* NOT flag for header lines fetch */
       REGISTER_LONG_CONSTANT("FT_INTERNAL", FT_INTERNAL, CONST_PERSISTENT | CONST_CS);
       /* text can be internal strings */
       REGISTER_LONG_CONSTANT("FT_PREFETCHTEXT", FT_PREFETCHTEXT, CONST_PERSISTENT | CONST_CS);
       /* IMAP prefetch text when fetching header */

       /* Flagging options */

       REGISTER_LONG_CONSTANT("ST_UID", ST_UID, CONST_PERSISTENT | CONST_CS);
       /* argument is a UID sequence */
       REGISTER_LONG_CONSTANT("ST_SILENT", ST_SILENT, CONST_PERSISTENT | CONST_CS);
       /* don't return results */
       REGISTER_LONG_CONSTANT("ST_SET", ST_SET, CONST_PERSISTENT | CONST_CS);
       /* set vs. clear */

       /* Copy options */

       REGISTER_LONG_CONSTANT("CP_UID", CP_UID, CONST_PERSISTENT | CONST_CS);
       /* argument is a UID sequence */
       REGISTER_LONG_CONSTANT("CP_MOVE", CP_MOVE, CONST_PERSISTENT | CONST_CS);
       /* delete from source after copying */

       /* Search/sort options */

       REGISTER_LONG_CONSTANT("SE_UID", SE_UID, CONST_PERSISTENT | CONST_CS);
       /* return UID */
       REGISTER_LONG_CONSTANT("SE_FREE", SE_FREE, CONST_PERSISTENT | CONST_CS);
       /* free search program after finished */
       REGISTER_LONG_CONSTANT("SE_NOPREFETCH", SE_NOPREFETCH, CONST_PERSISTENT | CONST_CS);
       /* no search prefetching */
       REGISTER_LONG_CONSTANT("SO_FREE", SO_FREE, CONST_PERSISTENT | CONST_CS);
       /* free sort program after finished */
       REGISTER_LONG_CONSTANT("SO_NOSERVER", SO_NOSERVER, CONST_PERSISTENT | CONST_CS);
       /* don't do server-based sort */

       /* Status options */

       REGISTER_LONG_CONSTANT("SA_MESSAGES", SA_MESSAGES , CONST_PERSISTENT | CONST_CS);
       /* number of messages */
       REGISTER_LONG_CONSTANT("SA_RECENT", SA_RECENT, CONST_PERSISTENT | CONST_CS);
       /* number of recent messages */
       REGISTER_LONG_CONSTANT("SA_UNSEEN", SA_UNSEEN , CONST_PERSISTENT | CONST_CS);
       /* number of unseen messages */
       REGISTER_LONG_CONSTANT("SA_UIDNEXT", SA_UIDNEXT, CONST_PERSISTENT | CONST_CS);
       /* next UID to be assigned */
       REGISTER_LONG_CONSTANT("SA_UIDVALIDITY", SA_UIDVALIDITY , CONST_PERSISTENT | CONST_CS);
       /* UID validity value */
       REGISTER_LONG_CONSTANT("SA_ALL", sa_all, CONST_PERSISTENT | CONST_CS);
       /* get all status information */

       /* Bits for mm_list() and mm_lsub() */

       REGISTER_LONG_CONSTANT("LATT_NOINFERIORS", LATT_NOINFERIORS , CONST_PERSISTENT | CONST_CS);
       REGISTER_LONG_CONSTANT("LATT_NOSELECT", LATT_NOSELECT, CONST_PERSISTENT | CONST_CS);
       REGISTER_LONG_CONSTANT("LATT_MARKED", LATT_MARKED, CONST_PERSISTENT | CONST_CS);
       REGISTER_LONG_CONSTANT("LATT_UNMARKED", LATT_UNMARKED , CONST_PERSISTENT | CONST_CS);

#ifdef LATT_REFERRAL
       REGISTER_LONG_CONSTANT("LATT_REFERRAL", LATT_REFERRAL, CONST_PERSISTENT | CONST_CS);
#endif

#ifdef LATT_HASCHILDREN
       REGISTER_LONG_CONSTANT("LATT_HASCHILDREN", LATT_HASCHILDREN, CONST_PERSISTENT | CONST_CS);
#endif

#ifdef LATT_HASNOCHILDREN
       REGISTER_LONG_CONSTANT("LATT_HASNOCHILDREN", LATT_HASNOCHILDREN, CONST_PERSISTENT | CONST_CS);
#endif

       /* Sort functions */

       REGISTER_LONG_CONSTANT("SORTDATE", SORTDATE , CONST_PERSISTENT | CONST_CS);
       /* date */
       REGISTER_LONG_CONSTANT("SORTARRIVAL", SORTARRIVAL , CONST_PERSISTENT | CONST_CS);
       /* arrival date */
       REGISTER_LONG_CONSTANT("SORTFROM", SORTFROM , CONST_PERSISTENT | CONST_CS);
       /* from */
       REGISTER_LONG_CONSTANT("SORTSUBJECT", SORTSUBJECT , CONST_PERSISTENT | CONST_CS);
       /* subject */
       REGISTER_LONG_CONSTANT("SORTTO", SORTTO , CONST_PERSISTENT | CONST_CS);
       /* to */
       REGISTER_LONG_CONSTANT("SORTCC", SORTCC , CONST_PERSISTENT | CONST_CS);
       /* cc */
       REGISTER_LONG_CONSTANT("SORTSIZE", SORTSIZE , CONST_PERSISTENT | CONST_CS);
       /* size */

       REGISTER_LONG_CONSTANT("TYPETEXT", TYPETEXT , CONST_PERSISTENT | CONST_CS);
       REGISTER_LONG_CONSTANT("TYPEMULTIPART", TYPEMULTIPART , CONST_PERSISTENT | CONST_CS);
       REGISTER_LONG_CONSTANT("TYPEMESSAGE", TYPEMESSAGE , CONST_PERSISTENT | CONST_CS);
       REGISTER_LONG_CONSTANT("TYPEAPPLICATION", TYPEAPPLICATION , CONST_PERSISTENT | CONST_CS);
       REGISTER_LONG_CONSTANT("TYPEAUDIO", TYPEAUDIO , CONST_PERSISTENT | CONST_CS);
       REGISTER_LONG_CONSTANT("TYPEIMAGE", TYPEIMAGE , CONST_PERSISTENT | CONST_CS);
       REGISTER_LONG_CONSTANT("TYPEVIDEO", TYPEVIDEO , CONST_PERSISTENT | CONST_CS);
       REGISTER_LONG_CONSTANT("TYPEMODEL", TYPEMODEL , CONST_PERSISTENT | CONST_CS);
       REGISTER_LONG_CONSTANT("TYPEOTHER", TYPEOTHER , CONST_PERSISTENT | CONST_CS);
       /*
       TYPETEXT                unformatted text
       TYPEMULTIPART           multiple part
       TYPEMESSAGE             encapsulated message
       TYPEAPPLICATION         application data
       TYPEAUDIO               audio
       TYPEIMAGE               static image (GIF, JPEG, etc.)
       TYPEVIDEO               video
       TYPEMODEL               model
       TYPEOTHER               unknown
       */

       REGISTER_LONG_CONSTANT("ENC7BIT", ENC7BIT , CONST_PERSISTENT | CONST_CS);
       REGISTER_LONG_CONSTANT("ENC8BIT", ENC8BIT , CONST_PERSISTENT | CONST_CS);
       REGISTER_LONG_CONSTANT("ENCBINARY", ENCBINARY , CONST_PERSISTENT | CONST_CS);
       REGISTER_LONG_CONSTANT("ENCBASE64", ENCBASE64, CONST_PERSISTENT | CONST_CS);
       REGISTER_LONG_CONSTANT("ENCQUOTEDPRINTABLE", ENCQUOTEDPRINTABLE , CONST_PERSISTENT | CONST_CS);
       REGISTER_LONG_CONSTANT("ENCOTHER", ENCOTHER , CONST_PERSISTENT | CONST_CS);
       /*
       ENC7BIT                 7 bit SMTP semantic data
       ENC8BIT                 8 bit SMTP semantic data
       ENCBINARY               8 bit binary data
       ENCBASE64               base-64 encoded data
       ENCQUOTEDPRINTABLE      human-readable 8-as-7 bit data
       ENCOTHER                unknown
       */

       REGISTER_LONG_CONSTANT("IMAP_GC_ELT", GC_ELT , CONST_PERSISTENT | CONST_CS);
       REGISTER_LONG_CONSTANT("IMAP_GC_ENV", GC_ENV , CONST_PERSISTENT | CONST_CS);
       REGISTER_LONG_CONSTANT("IMAP_GC_TEXTS", GC_TEXTS , CONST_PERSISTENT | CONST_CS);
       /*
       GC_ELT                 message cache elements
       GC_ENV                 ENVELOPEs and BODYs
       GC_TEXTS               texts
       */

       le_imap = zend_register_list_destructors_ex(mail_close_it, NULL, "imap", module_number);
       return SUCCESS;
}

Here is the call graph for this function:

PHP_RINIT_FUNCTION ( imap  )

Definition at line 1062 of file php_imap.c.

{
       IMAPG(imap_errorstack) = NIL;
       IMAPG(imap_alertstack) = NIL;
       IMAPG(gets_stream) = NIL;
       return SUCCESS;
}

Definition at line 1073 of file php_imap.c.

{
       ERRORLIST *ecur = NIL;
       STRINGLIST *acur = NIL;

       if (IMAPG(imap_errorstack) != NIL) {
              /* output any remaining errors at their original error level */
              if (EG(error_reporting) & E_NOTICE) {
                     ecur = IMAPG(imap_errorstack);
                     while (ecur != NIL) {
                            php_error_docref(NULL TSRMLS_CC, E_NOTICE, "%s (errflg=%ld)", ecur->LTEXT, ecur->errflg);
                            ecur = ecur->next;
                     }
              }
              mail_free_errorlist(&IMAPG(imap_errorstack));
       }

       if (IMAPG(imap_alertstack) != NIL) {
              /* output any remaining alerts at E_NOTICE level */
              if (EG(error_reporting) & E_NOTICE) {
                     acur = IMAPG(imap_alertstack);
                     while (acur != NIL) {
                            php_error_docref(NULL TSRMLS_CC, E_NOTICE, "%s", acur->LTEXT);
                            acur = acur->next;
                     }
              }
              mail_free_stringlist(&IMAPG(imap_alertstack));
              IMAPG(imap_alertstack) = NIL;
       }
       return SUCCESS;
}

Here is the call graph for this function:

void rfc822_date ( char *  date)

Here is the caller graph for this function:

long utf8_mime2text ( SIZEDTEXT *  src,
SIZEDTEXT *  dst 
)

Here is the caller graph for this function:


Variable Documentation

const zend_module_dep imap_deps[] [static]
Initial value:

Definition at line 559 of file php_imap.c.

Definition at line 471 of file php_imap.c.

zend_module_entry imap_module_entry
int le_imap [static]

Definition at line 591 of file php_imap.c.