mail.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "pi-macros.h"
#include "pi-mail.h"

Include dependency graph for mail.c:

Go to the source code of this file.

Functions

void free_Mail (Mail_t *mail)
void free_MailAppInfo (MailAppInfo_t *appinfo)
void free_MailSyncPref (MailSyncPref_t *pref)
void free_MailSignaturePref (MailSignaturePref_t *pref)
int unpack_Mail (Mail_t *mail, unsigned char *buffer, size_t len)
int pack_Mail (struct Mail *mail, unsigned char *buffer, size_t len)
int unpack_MailAppInfo (MailAppInfo_t *appinfo, unsigned char *record, size_t len)
int pack_MailAppInfo (struct MailAppInfo *appinfo, unsigned char *record, size_t len)
int unpack_MailSyncPref (MailSyncPref_t *pref, unsigned char *record, size_t len)
int pack_MailSyncPref (MailSyncPref_t *pref, unsigned char *record, size_t len)
int unpack_MailSignaturePref (MailSignaturePref_t *pref, unsigned char *record, size_t len)
int pack_MailSignaturePref (struct MailSignaturePref *pref, unsigned char *record, size_t len)

Variables

char * MailSortTypeNames [] = { "Date", "Type", NULL }
char * MailSyncTypeNames [] = { "All", "Send", "Filter", NULL }

Function Documentation

void free_Mail ( Mail_t *  mail  ) 

Definition at line 56 of file mail.c.

References Mail::bcc, Mail::body, Mail::cc, Mail::from, Mail::replyTo, Mail::sentTo, Mail::subject, and Mail::to.

00057 {
00058         if (mail->from != NULL) {
00059                 free(mail->from);
00060                 mail->from = NULL;
00061         }
00062 
00063         if (mail->to != NULL) {
00064                 free(mail->to);
00065                 mail->to = NULL;
00066         }
00067 
00068         if (mail->subject != NULL) {
00069                 free(mail->subject);
00070                 mail->to = NULL;
00071         }
00072 
00073         if (mail->cc != NULL) {
00074                 free(mail->cc);
00075                 mail->cc = NULL;
00076         }
00077 
00078         if (mail->bcc != NULL) {
00079                 free(mail->bcc);
00080                 mail->bcc = NULL;
00081         }
00082 
00083         if (mail->replyTo) {
00084                 free(mail->replyTo);
00085                 mail->replyTo = NULL;
00086         }
00087 
00088         if (mail->sentTo) {
00089                 free(mail->sentTo);
00090                 mail->sentTo = NULL;
00091         }
00092 
00093         if (mail->body != NULL) {
00094                 free(mail->body);
00095                 mail->body = NULL;
00096         }
00097 }

void free_MailAppInfo ( MailAppInfo_t *  appinfo  ) 

Definition at line 112 of file mail.c.

00113 {
00114         /* if (appinfo->signature)
00115            free(appinfo->signature); */
00116 }

void free_MailSignaturePref ( MailSignaturePref_t *  pref  ) 

Definition at line 162 of file mail.c.

References MailSignaturePref::signature.

00163 {
00164         if (pref->signature != NULL) {
00165                 free(pref->signature);
00166                 pref->signature = NULL;
00167         }
00168 }

void free_MailSyncPref ( MailSyncPref_t *  pref  ) 

Definition at line 131 of file mail.c.

References MailSyncPref::filterFrom, MailSyncPref::filterSubject, and MailSyncPref::filterTo.

00132 {
00133         if (pref->filterTo != NULL) {
00134                 free(pref->filterTo);
00135                 pref->filterTo = NULL;
00136         }
00137 
00138         if (pref->filterFrom != NULL) {
00139                 free(pref->filterFrom);
00140                 pref->filterFrom = NULL;
00141         }
00142 
00143         if (pref->filterSubject != NULL) {
00144                 free(pref->filterSubject);
00145                 pref->filterSubject = NULL;
00146         }
00147 }

int pack_Mail ( struct Mail *  mail,
unsigned char *  buffer,
size_t  len 
)

Definition at line 316 of file mail.c.

References Mail::addressing, Mail::bcc, Mail::body, Mail::cc, Mail::date, Mail::dated, Mail::from, Mail::priority, Mail::read, Mail::replyTo, Mail::sentTo, set_byte, set_long, set_short, Mail::signature, Mail::subject, and Mail::to.

Referenced by test_mail().

00317 {
00318         size_t  destlen = 6 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1;
00319         unsigned char *start = buffer;
00320 
00321         if (mail->subject)
00322                 destlen += strlen(mail->subject);
00323         if (mail->from)
00324                 destlen += strlen(mail->from);
00325         if (mail->to)
00326                 destlen += strlen(mail->to);
00327         if (mail->cc)
00328                 destlen += strlen(mail->cc);
00329         if (mail->bcc)
00330                 destlen += strlen(mail->bcc);
00331         if (mail->replyTo)
00332                 destlen += strlen(mail->replyTo);
00333         if (mail->sentTo)
00334                 destlen += strlen(mail->sentTo);
00335         if (mail->body)
00336                 destlen += strlen(mail->body);
00337 
00338         if (!buffer)
00339                 return destlen;
00340         if (len < destlen)
00341                 return 0;
00342 
00343         set_short(buffer,
00344                   ((mail->date.tm_year - 4) << 9) | ((mail->date.tm_mon +
00345                                                    1) << 5) | mail->date.
00346                   tm_mday);
00347         set_byte(buffer + 2, mail->date.tm_hour);
00348         set_byte(buffer + 3, mail->date.tm_min);
00349 
00350         if (!mail->dated)
00351                 set_long(buffer, 0);
00352 
00353         set_byte(buffer + 4, (mail->read ? (1 << 7) : 0) |
00354                  (mail->signature ? (1 << 6) : 0) | (mail->
00355                                                   confirmRead ? (1 << 5) :
00356                                                   0) | (mail->
00357                                                         confirmDelivery
00358                                                         ? (1 << 4) : 0) |
00359                  ((mail->priority & 3) << 2) | (mail->addressing & 3));
00360         set_byte(buffer + 5, 0);
00361 
00362         buffer += 6;
00363 
00364         if (mail->subject) {
00365                 strcpy((char *)buffer, mail->subject);
00366                 buffer += strlen((char *)buffer);
00367         } else
00368                 set_byte(buffer, 0);
00369         buffer++;
00370         if (mail->from) {
00371                 strcpy((char *)buffer, mail->from);
00372                 buffer += strlen((char *)buffer);
00373         } else
00374                 set_byte(buffer, 0);
00375         buffer++;
00376         if (mail->to) {
00377                 strcpy((char *)buffer, mail->to);
00378                 buffer += strlen((char *)buffer);
00379         } else
00380                 set_byte(buffer, 0);
00381         buffer++;
00382         if (mail->cc) {
00383                 strcpy((char *)buffer, mail->cc);
00384                 buffer += strlen((char *)buffer);
00385         } else
00386                 set_byte(buffer, 0);
00387         buffer++;
00388         if (mail->bcc) {
00389                 strcpy((char *)buffer, mail->bcc);
00390                 buffer += strlen((char *)buffer);
00391         } else
00392                 set_byte(buffer, 0);
00393         buffer++;
00394         if (mail->replyTo) {
00395                 strcpy((char *)buffer, mail->replyTo);
00396                 buffer += strlen((char *)buffer);
00397         } else
00398                 set_byte(buffer, 0);
00399         buffer++;
00400         if (mail->sentTo) {
00401                 strcpy((char *)buffer, mail->sentTo);
00402                 buffer += strlen((char *)buffer);
00403         } else
00404                 set_byte(buffer, 0);
00405         buffer++;
00406         if (mail->body) {
00407                 strcpy((char *)buffer, mail->body);
00408                 buffer += strlen((char *)buffer);
00409         } else
00410                 set_byte(buffer, 0);
00411         buffer++;
00412 
00413         return (buffer - start);
00414 }

int pack_MailAppInfo ( struct MailAppInfo *  appinfo,
unsigned char *  record,
size_t  len 
)

Definition at line 468 of file mail.c.

References MailAppInfo::category, MailAppInfo::dirty, pack_CategoryAppInfo(), set_byte, set_long, set_short, MailAppInfo::sortOrder, and MailAppInfo::unsentMessage.

Referenced by test_mail().

00469 {
00470         int     i;
00471         unsigned char *start = record;
00472 
00473         i = pack_CategoryAppInfo(&appinfo->category, record, len);
00474         if (!record)
00475                 return i + 11;
00476         if (!i)
00477                 return i;
00478         record += i;
00479         len -= i;
00480         if (len < 8)
00481                 return 0;
00482         set_short(record, appinfo->dirty);
00483         record += 2;
00484         set_short(record, 0);   /* gapfill */
00485         set_byte(record, appinfo->sortOrder);
00486         record += 2;
00487         set_long(record, appinfo->unsentMessage);
00488         record += 4;
00489 
00490         set_short(record, (record - start + 2));
00491         record += 2;
00492 
00493         /* if (appinfo->signature)
00494            strcpy(record, appinfo->signature);
00495            else
00496            set_byte(record, 0);
00497            record += strlen(record); */
00498         set_byte(record, 0);
00499         record++;
00500 
00501         return (record - start);
00502 }

Here is the call graph for this function:

int pack_MailSignaturePref ( struct MailSignaturePref *  pref,
unsigned char *  record,
size_t  len 
)

Definition at line 655 of file mail.c.

References MailSignaturePref::signature.

Referenced by test_mail().

00657 {
00658         size_t  destlen = 1;
00659         unsigned char *start = record;
00660 
00661         if (pref->signature)
00662                 destlen += strlen(pref->signature);
00663 
00664         if (!record)
00665                 return destlen;
00666         if (len < destlen)
00667                 return 0;
00668         if (pref->signature) {
00669                 strcpy((char *)record, pref->signature);
00670                 record += strlen(pref->signature);
00671         }
00672         *record = 0;
00673         record++;
00674 
00675         return (record - start);
00676 }

int pack_MailSyncPref ( MailSyncPref_t *  pref,
unsigned char *  record,
size_t  len 
)

Definition at line 565 of file mail.c.

References MailSyncPref::filterFrom, MailSyncPref::filterSubject, MailSyncPref::filterTo, MailSyncPref::getContaining, MailSyncPref::getHigh, set_byte, set_short, MailSyncPref::syncType, and MailSyncPref::truncate.

Referenced by test_mail().

00566 {
00567         size_t  destlen = 6 + 1 + 1 + 1;
00568         unsigned char *start = record;
00569 
00570         if (pref->filterTo)
00571                 destlen += strlen(pref->filterTo);
00572         if (pref->filterSubject)
00573                 destlen += strlen(pref->filterSubject);
00574         if (pref->filterFrom)
00575                 destlen += strlen(pref->filterFrom);
00576 
00577         if (!record)
00578                 return destlen;
00579         if (len < destlen)
00580                 return 0;
00581 
00582         set_byte(record, pref->syncType);
00583         record++;
00584         set_byte(record, pref->getHigh);
00585         record++;
00586         set_byte(record, pref->getContaining);
00587         record++;
00588         set_byte(record, 0);
00589         record++;               /* gapfill */
00590         set_short(record, pref->truncate);
00591         record += 2;
00592 
00593         if (pref->filterTo) {
00594                 strcpy((char *)record, pref->filterTo);
00595                 record += strlen(pref->filterTo);
00596         }
00597         *record++ = 0;
00598 
00599         if (pref->filterFrom) {
00600                 strcpy((char *)record, pref->filterFrom);
00601                 record += strlen(pref->filterFrom);
00602         }
00603         *record++ = 0;
00604 
00605         if (pref->filterSubject) {
00606                 strcpy((char *)record, pref->filterSubject);
00607                 record += strlen(pref->filterSubject);
00608         }
00609         *record++ = 0;
00610 
00611         return (record - start);
00612 }

int unpack_Mail ( Mail_t *  mail,
unsigned char *  buffer,
size_t  len 
)

Definition at line 183 of file mail.c.

References Mail::addressing, Mail::bcc, Mail::body, Mail::cc, Mail::confirmDelivery, Mail::confirmRead, Mail::date, Mail::dated, flags, Mail::from, get_byte, get_short, Mail::priority, Mail::read, Mail::replyTo, Mail::sentTo, Mail::signature, strdup(), Mail::subject, and Mail::to.

Referenced by test_mail().

00184 {
00185         int     flags;
00186         unsigned long d;
00187         unsigned char *start = buffer;
00188 
00189         if (len < 6)
00190                 return 0;
00191 
00192         d = (unsigned short int) get_short(buffer);
00193         mail->date.tm_year      = (d >> 9) + 4;
00194         mail->date.tm_mon       = ((d >> 5) & 15) - 1;
00195         mail->date.tm_mday      = d & 31;
00196         mail->date.tm_hour      = get_byte(buffer + 2);
00197         mail->date.tm_min       = get_byte(buffer + 3);
00198         mail->date.tm_sec       = 0;
00199         mail->date.tm_isdst     = -1;
00200         mktime(&mail->date);
00201 
00202         if (d)
00203                 mail->dated = 1;
00204         else
00205                 mail->dated = 0;
00206 
00207         flags = get_byte(buffer + 4);
00208 
00209         mail->read              = (flags & (1 << 7)) ? 1 : 0;
00210         mail->signature                 = (flags & (1 << 6)) ? 1 : 0;
00211         mail->confirmRead               = (flags & (1 << 5)) ? 1 : 0;
00212         mail->confirmDelivery   = (flags & (1 << 4)) ? 1 : 0;
00213         mail->priority          = (flags & (3 << 2)) >> 2;
00214         mail->addressing                = (flags & 3);
00215 
00216         buffer  += 6;
00217         len     -= 6;
00218 
00219         if (len < 1)
00220                 return 0;
00221         if (get_byte(buffer)) {
00222                 mail->subject = strdup((char *)buffer);
00223                 buffer += strlen((char *)buffer);
00224                 len -= strlen((char *)buffer);
00225         } else
00226                 mail->subject = 0;
00227         buffer++;
00228         len--;
00229         if (len < 1)
00230                 return 0;
00231         if (get_byte(buffer)) {
00232                 mail->from = strdup((char *)buffer);
00233                 buffer += strlen((char *)buffer);
00234                 len -= strlen((char *)buffer);
00235         } else
00236                 mail->from = 0;
00237         buffer++;
00238         len--;
00239         if (len < 1)
00240                 return 0;
00241         if (get_byte(buffer)) {
00242                 mail->to = strdup((char *)buffer);
00243                 buffer += strlen((char *)buffer);
00244                 len -= strlen((char *)buffer);
00245         } else
00246                 mail->to = 0;
00247         buffer++;
00248         len--;
00249         if (len < 1)
00250                 return 0;
00251         if (get_byte(buffer)) {
00252                 mail->cc = strdup((char *)buffer);
00253                 buffer += strlen((char *)buffer);
00254                 len -= strlen((char *)buffer);
00255         } else
00256                 mail->cc = 0;
00257         buffer++;
00258         len--;
00259         if (len < 1)
00260                 return 0;
00261         if (get_byte(buffer)) {
00262                 mail->bcc = strdup((char *)buffer);
00263                 buffer += strlen((char *)buffer);
00264                 len -= strlen((char *)buffer);
00265         } else
00266                 mail->bcc = 0;
00267         buffer++;
00268         len--;
00269         if (len < 1)
00270                 return 0;
00271         if (get_byte(buffer)) {
00272                 mail->replyTo = strdup((char *)buffer);
00273                 buffer += strlen((char *)buffer);
00274                 len -= strlen((char *)buffer);
00275         } else
00276                 mail->replyTo = 0;
00277         buffer++;
00278         len--;
00279         if (len < 1)
00280                 return 0;
00281         if (get_byte(buffer)) {
00282                 mail->sentTo = strdup((char *)buffer);
00283                 buffer += strlen((char *)buffer);
00284                 len -= strlen((char *)buffer);
00285         } else
00286                 mail->sentTo = 0;
00287         buffer++;
00288         len--;
00289         if (len < 1)
00290                 return 0;
00291         if (get_byte(buffer)) {
00292                 mail->body = strdup((char *)buffer);
00293                 buffer += strlen((char *)buffer);
00294                 len -= strlen((char *)buffer);
00295         } else
00296                 mail->body = 0;
00297         buffer++;
00298         len--;
00299 
00300         return (buffer - start);
00301 }

Here is the call graph for this function:

int unpack_MailAppInfo ( MailAppInfo_t *  appinfo,
unsigned char *  record,
size_t  len 
)

Definition at line 429 of file mail.c.

References MailAppInfo::category, MailAppInfo::dirty, get_byte, get_long, get_short, MailAppInfo::sortOrder, unpack_CategoryAppInfo(), and MailAppInfo::unsentMessage.

Referenced by test_mail().

00430 {
00431         int     i;
00432         unsigned char *start = record;
00433 
00434         i = unpack_CategoryAppInfo(&appinfo->category, record, len);
00435         if (!i)
00436                 return i;
00437         record += i;
00438         len -= i;
00439         if (len < 11)
00440                 return 0;
00441         appinfo->dirty = get_short(record);
00442         record += 2;
00443         appinfo->sortOrder = get_byte(record);
00444         record += 2;
00445         appinfo->unsentMessage = get_long(record);
00446         record += 4;
00447 
00448 /* ai->signature = 0;                   */
00449 /* strdup(start + get_short(record));   */
00450         record += 3;
00451 
00452         return (record - start);
00453 }

Here is the call graph for this function:

int unpack_MailSignaturePref ( MailSignaturePref_t *  pref,
unsigned char *  record,
size_t  len 
)

Definition at line 627 of file mail.c.

References MailSignaturePref::signature, and strdup().

Referenced by test_mail().

00629 {
00630         unsigned char *start = record;
00631 
00632         if (len < 1)
00633                 return 0;
00634 
00635         pref->signature = strdup((char *)record);
00636 
00637         record += strlen(pref->signature) + 1;
00638 
00639         return (record - start);
00640 }

Here is the call graph for this function:

int unpack_MailSyncPref ( MailSyncPref_t *  pref,
unsigned char *  record,
size_t  len 
)

Definition at line 517 of file mail.c.

References MailSyncPref::filterFrom, MailSyncPref::filterSubject, MailSyncPref::filterTo, get_byte, get_short, MailSyncPref::getContaining, MailSyncPref::getHigh, strdup(), MailSyncPref::syncType, and MailSyncPref::truncate.

Referenced by test_mail().

00518 {
00519         unsigned char *start = record;
00520 
00521         pref->syncType = get_byte(record);
00522         record += 1;
00523         pref->getHigh = get_byte(record);
00524         record += 1;
00525         pref->getContaining = get_byte(record);
00526         record += 2;
00527         pref->truncate = get_short(record);
00528         record += 2;
00529 
00530         if (get_byte(record)) {
00531                 pref->filterTo = strdup((char *)record);
00532                 record += strlen((char *)record);
00533         } else
00534                 pref->filterTo = 0;
00535         record++;
00536         if (get_byte(record)) {
00537                 pref->filterFrom = strdup((char *)record);
00538                 record += strlen((char *)record);
00539         } else
00540                 pref->filterFrom = 0;
00541         record++;
00542         if (get_byte(record)) {
00543                 pref->filterSubject = strdup((char *)record);
00544                 record += strlen((char *)record);
00545         } else
00546                 pref->filterSubject = 0;
00547         record++;
00548 
00549         return (record - start);
00550 }

Here is the call graph for this function:

Variable Documentation

char* MailSortTypeNames[] = { "Date", "Type", NULL }

Definition at line 41 of file mail.c.

char* MailSyncTypeNames[] = { "All", "Send", "Filter", NULL }

Definition at line 42 of file mail.c.

© 1996-2007 by pilot-link.org. All rights reserved.