Variant f_imap_open(const String& mailbox, const String& username,
const String& password,
int64_t options /* = 0 */, int64_t retries /* = 0 */) {
String filename = mailbox;
if (filename[0] != '{') {
filename = File::TranslatePath(filename);
if (filename.empty()) {
return false;
}
}
if (retries < 0) {
Logger::Warning("Retries must be greater or equal to 0");
} else {
mail_parameters(NIL, SET_MAXLOGINTRIALS, (void *) retries);
}
IMAPG(user) = std::string(username.data(), username.size());
IMAPG(password) = std::string(password.data(), password.size());
MAILSTREAM *stream = mail_open(NIL, (char*)filename.data(), options);
if (stream == NIL) {
Logger::Warning("Couldn't open stream %s", filename.data());
IMAPG(user).clear();
IMAPG(password).clear();
return false;
}
return NEWOBJ(ImapStream)(stream, (options & PHP_EXPUNGE) ? CL_EXPUNGE : NIL);
}
void mm_login(NETMBX *mb, char *user, char *pwd, long trial) {
if (*mb->user) {
string_copy(user, mb->user, MAILTMPLEN);
} else {
string_copy(user, IMAPG(user).c_str(), MAILTMPLEN);
}
string_copy(pwd, IMAPG(password).c_str(), MAILTMPLEN);
}
void ImapStream::close() {
if (m_stream) {
mail_close_full(m_stream, m_flag);
IMAPG(user).clear();
IMAPG(password).clear();
m_stream = NULL;
}
}
Variant f_imap_last_error() {
if (IMAPG(errorstack) == NIL) {
return false;
}
for (ERRORLIST *cur = IMAPG(errorstack); cur != NIL;
cur = cur->next) {
if (cur->next == NIL) {
return String((const char *)cur->text.data, CopyString);
}
}
return uninit_null();
}
Variant f_imap_errors() {
if (IMAPG(errorstack) == NIL) {
return false;
}
Array ret(Array::Create());
for (ERRORLIST *cur = IMAPG(errorstack); cur != NIL;
cur = cur->next) {
ret.append(String((const char *)cur->text.data, CopyString));
}
IMAPG(errorstack) = NIL;
return ret;
}
static Variant HHVM_FUNCTION(imap_alerts) {
if (IMAPG(alertstack) == NIL) {
return false;
}
Array ret(Array::Create());
for (STRINGLIST *cur = IMAPG(alertstack); cur != NIL;
cur = cur->next) {
ret.append(String((const char *)cur->text.data, CopyString));
}
mail_free_stringlist(&IMAPG(alertstack));
IMAPG(alertstack) = NIL;
return ret;
}
void mm_log(char *str, long errflg) {
ERRORLIST *cur = NIL;
/* Author: CJH */
if (errflg != NIL) { /* CJH: maybe put these into a more comprehensive
log for debugging purposes? */
if (IMAPG(errorstack) == NIL) {
IMAPG(errorstack) = mail_newerrorlist();
IMAPG(errorstack)->text.size =
mm_strlen(IMAPG(errorstack)->text.data = mm_cpystr(str));
IMAPG(errorstack)->errflg = errflg;
IMAPG(errorstack)->next = NIL;
} else {
cur = IMAPG(errorstack);
while (cur->next != NIL) {
cur = cur->next;
}
cur->next = mail_newerrorlist();
cur = cur->next;
cur->text.size = mm_strlen(cur->text.data = mm_cpystr(str));
cur->errflg = errflg;
cur->next = NIL;
}
}
}
Variant f_imap_search(const Resource& imap_stream, const String& criteria,
int64_t options /* = 0 */,
const String& charset /* = "" */) {
ImapStream *obj = imap_stream.getTyped<ImapStream>();
char *search_criteria = (char*)criteria.data();
IMAPG(messages) = IMAPG(messages_tail) = NIL;
SEARCHPGM *pgm = mail_criteria(search_criteria);
mail_search_full(obj->m_stream,
(charset.empty() ? NIL : (char*)charset.data()),
pgm,
options);
if (pgm && !(options & SE_FREE)) {
mail_free_searchpgm(&pgm);
}
if (IMAPG(messages) == NIL) {
return false;
}
Array ret(Array::Create());
MESSAGELIST *cur = IMAPG(messages);
while (cur != NIL) {
ret.append((int64_t)cur->msgid);
cur = cur->next;
}
mail_free_messagelist(&IMAPG(messages), &IMAPG(messages_tail));
return ret;
}
void mm_searched(MAILSTREAM *stream, unsigned long number) {
MESSAGELIST *cur = NIL;
if (IMAPG(messages) == NIL) {
IMAPG(messages) = mail_newmessagelist();
IMAPG(messages)->msgid = number;
IMAPG(messages)->next = NIL;
IMAPG(messages_tail) = IMAPG(messages);
} else {
cur = IMAPG(messages_tail);
cur->next = mail_newmessagelist();
cur = cur->next;
cur->msgid = number;
cur->next = NIL;
IMAPG(messages_tail) = cur;
}
}
Variant f_imap_list(const Resource& imap_stream, const String& ref,
const String& pattern) {
ImapStream *obj = imap_stream.getTyped<ImapStream>();
/* set flag for normal, old mailbox list */
IMAPG(folderlist_style) = FLIST_ARRAY;
IMAPG(folders) = IMAPG(folders_tail) = NIL;
mail_list(obj->m_stream, (char*)ref.data(), (char*)pattern.data());
if (IMAPG(folders) == NIL) {
return false;
}
Array ret(Array::Create());
for (STRINGLIST *cur = IMAPG(folders); cur != NIL; cur = cur->next) {
ret.append(String((const char *)cur->text.data, CopyString));
}
mail_free_stringlist(&IMAPG(folders));
IMAPG(folders) = IMAPG(folders_tail) = NIL;
return ret;
}
/* Author: CJH */
void mm_notify(MAILSTREAM *stream, char *str, long errflg) {
STRINGLIST *cur = NIL;
if (strncmp(str, "[ALERT] ", 8) == 0) {
if (IMAPG(alertstack) == NIL) {
IMAPG(alertstack) = mail_newstringlist();
IMAPG(alertstack)->text.size =
mm_strlen((IMAPG(alertstack)->text.data = mm_cpystr(str)));
IMAPG(alertstack)->next = NIL;
} else {
cur = IMAPG(alertstack);
while (cur->next != NIL) {
cur = cur->next;
}
cur->next = mail_newstringlist ();
cur = cur->next;
cur->text.size = mm_strlen(cur->text.data = mm_cpystr(str));
cur->next = NIL;
}
}
}
void mm_status(MAILSTREAM *stream, char *mailbox, MAILSTATUS *status) {
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;
}
}
void mm_lsub(MAILSTREAM *stream, int delimiter, char *mailbox,
long attributes) {
STRINGLIST *cur=NIL;
FOBJECTLIST *ocur=NIL;
if (IMAPG(folderlist_style) == FLIST_OBJECT) {
/* build the array of objects */
/* Author: CJH */
if (IMAPG(sfolder_objects) == NIL) {
IMAPG(sfolder_objects) = mail_newfolderobjectlist();
IMAPG(sfolder_objects)->text.size =
mm_strlen(IMAPG(sfolder_objects)->text.data=mm_cpystr(mailbox));
IMAPG(sfolder_objects)->delimiter = delimiter;
IMAPG(sfolder_objects)->attributes = attributes;
IMAPG(sfolder_objects)->next = NIL;
IMAPG(sfolder_objects_tail) = IMAPG(sfolder_objects);
} else {
ocur=IMAPG(sfolder_objects_tail);
ocur->next=mail_newfolderobjectlist();
ocur=ocur->next;
ocur->text.size=mm_strlen(ocur->text.data = mm_cpystr(mailbox));
ocur->delimiter = delimiter;
ocur->attributes = attributes;
ocur->next = NIL;
IMAPG(sfolder_objects_tail) = ocur;
}
} else {
/* build the old simple array for imap_listsubscribed() */
if (IMAPG(sfolders) == NIL) {
IMAPG(sfolders)=mail_newstringlist();
IMAPG(sfolders)->text.size =
mm_strlen(IMAPG(sfolders)->text.data=mm_cpystr(mailbox));
IMAPG(sfolders)->next=NIL;
IMAPG(sfolders_tail) = IMAPG(sfolders);
} else {
cur=IMAPG(sfolders_tail);
cur->next=mail_newstringlist ();
cur=cur->next;
cur->text.size = mm_strlen (cur->text.data = mm_cpystr (mailbox));
cur->next = NIL;
IMAPG(sfolders_tail) = cur;
}
}
}
void mm_list(MAILSTREAM *stream, int delimiter, char *mailbox,
long attributes) {
STRINGLIST *cur=NIL;
FOBJECTLIST *ocur=NIL;
if (IMAPG(folderlist_style) == FLIST_OBJECT) {
/* build up a the new array of objects */
/* Author: CJH */
if (IMAPG(folder_objects) == NIL) {
IMAPG(folder_objects) = mail_newfolderobjectlist();
IMAPG(folder_objects)->text.size =
mm_strlen(IMAPG(folder_objects)->text.data=mm_cpystr(mailbox));
IMAPG(folder_objects)->delimiter = delimiter;
IMAPG(folder_objects)->attributes = attributes;
IMAPG(folder_objects)->next = NIL;
IMAPG(folder_objects_tail) = IMAPG(folder_objects);
} else {
ocur=IMAPG(folder_objects_tail);
ocur->next=mail_newfolderobjectlist();
ocur=ocur->next;
ocur->text.size = mm_strlen(ocur->text.data = mm_cpystr(mailbox));
ocur->delimiter = delimiter;
ocur->attributes = attributes;
ocur->next = NIL;
IMAPG(folder_objects_tail) = ocur;
}
} else {
/* build the old IMAPG(folders) variable to allow old
imap_listmailbox() to work */
if (!(attributes & LATT_NOSELECT)) {
if (IMAPG(folders) == NIL) {
IMAPG(folders)=mail_newstringlist();
IMAPG(folders)->text.size =
mm_strlen(IMAPG(folders)->text.data=mm_cpystr(mailbox));
IMAPG(folders)->next=NIL;
IMAPG(folders_tail) = IMAPG(folders);
} else {
cur=IMAPG(folders_tail);
cur->next=mail_newstringlist ();
cur=cur->next;
cur->text.size = mm_strlen (cur->text.data = mm_cpystr (mailbox));
cur->next = NIL;
IMAPG(folders_tail) = cur;
}
}
}
}
Variant f_imap_status(const Resource& imap_stream, const String& mailbox,
int64_t options /* = 0 */) {
ImapStream *obj = imap_stream.getTyped<ImapStream>();
Object ret(SystemLib::AllocStdClassObject());
if (mail_status(obj->m_stream, (char *)mailbox.data(), options)) {
ret.o_set("flags", (int64_t)IMAPG(status_flags));
if (IMAPG(status_flags) & SA_MESSAGES) {
ret.o_set("messages", (int64_t)IMAPG(status_messages));
}
if (IMAPG(status_flags) & SA_RECENT) {
ret.o_set("recent", (int64_t)IMAPG(status_recent));
}
if (IMAPG(status_flags) & SA_UNSEEN) {
ret.o_set("unseen", (int64_t)IMAPG(status_unseen));
}
if (IMAPG(status_flags) & SA_UIDNEXT) {
ret.o_set("uidnext", (int64_t)IMAPG(status_uidnext));
}
if (IMAPG(status_flags) & SA_UIDVALIDITY) {
ret.o_set("uidvalidity", (int64_t)IMAPG(status_uidvalidity));
}
} else {
return false;
}
return ret;
}
