Back to index

courier  0.68.2
Classes | Functions | Variables
rfc2047u.c File Reference
#include "rfc822.h"
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include "rfc822hdr.h"
#include "rfc2047.h"
#include "../unicode/unicode.h"

Go to the source code of this file.

Classes

struct  decode_unicode_s
struct  rfc822_display_name_s
struct  rfc822_display_hdrvalue_s
struct  rfc822_display_hdrvalue_tobuf_s

Functions

static ssize_t rfc822_decode_rfc2047_atom (const char *str, size_t cnt, void(*callback)(const char *, const char *, const char *, size_t, void *), void *ptr)
static int rfc2047_decode_unicode (const char *text, const char *chset, void(*callback)(const char *, size_t, void *), void *ptr)
static void save_unicode_text (const char *p, size_t l, void *ptr)
static void unknown_charset (const char *chset, const char *tochset, void(*print_func)(const char *, size_t, void *), void *ptr)
static void rfc822_display_addr_cb (const char *chset, const char *lang, const char *content, size_t cnt, void *dummy)
static int rfc822_display_name_int (const struct rfc822a *rfcp, int index, const char *chset, void(*print_func)(const char *, size_t, void *), void *ptr)
int rfc822_display_name (const struct rfc822a *rfcp, int index, const char *chset, void(*print_func)(const char *, size_t, void *), void *ptr)
char * rfc822_display_name_tobuf (const struct rfc822a *rfcp, int index, const char *chset)
int rfc822_display_namelist (const struct rfc822a *rfcp, const char *chset, void(*print_func)(const char *, size_t, void *), void *ptr)
int rfc822_display_addr_str (const char *tok, const char *chset, void(*print_func)(const char *, size_t, void *), void *ptr)
int rfc822_display_addr (const struct rfc822a *rfcp, int index, const char *chset, void(*print_func)(const char *, size_t, void *), void *ptr)
int rfc2047_print_unicodeaddr (const struct rfc822a *a, const char *charset, void(*print_func)(char, void *), void(*print_separator)(const char *, void *), void *ptr)
static int rfc2047_print_unicode_addrstr (const char *addrheader, const char *charset, void(*print_func)(char, void *), void(*print_separator)(const char *, void *), void(*err_func)(const char *, int, void *), void *ptr)
static void rfc822_display_hdrvalue_print_func (char c, void *ptr)
static void rfc822_display_hdrvalue_print_separator (const char *cp, void *ptr)
int rfc822_display_hdrvalue (const char *hdrname, const char *hdrvalue, const char *charset, void(*display_func)(const char *, size_t, void *), void(*err_func)(const char *, int, void *), void *ptr)
static void rfc822_display_hdrvalue_tobuf_cnt (const char *ptr, size_t cnt, void *s)
static void rfc822_display_hdrvalue_tobuf_save (const char *ptr, size_t cnt, void *s)
static void rfc822_display_hdrvalue_tobuf_errfunc (const char *ptr, int index, void *s)
char * rfc822_display_addr_tobuf (const struct rfc822a *rfcp, int index, const char *chset)
char * rfc822_display_hdrvalue_tobuf (const char *hdrname, const char *hdrvalue, const char *charset, void(*err_func)(const char *, int, void *), void *ptr)
char * rfc822_display_addr_str_tobuf (const char *tok, const char *chset)
static int nyb (int c)
static size_t decodebase64 (const char *ptr, size_t cnt, char *dec_buf)
int rfc2047_decoder (const char *text, void(*callback)(const char *chset, const char *lang, const char *content, size_t cnt, void *dummy), void *ptr)

Variables

static const char xdigit [] = "0123456789ABCDEFabcdef"
static const unsigned char decode64tab []

Class Documentation

struct decode_unicode_s

Definition at line 39 of file rfc2047u.c.

Class Members
char * bufptr
size_t bufsize
const char * mychset

Function Documentation

static size_t decodebase64 ( const char *  ptr,
size_t  cnt,
char *  dec_buf 
) [static]

Definition at line 798 of file rfc2047u.c.

{
       size_t  i, j;
       char    a,b,c;
       size_t  k;

       i=cnt / 4;
       i=i*4;
       k=0;
       for (j=0; j<i; j += 4)
       {
              int     w=decode64tab[(int)(unsigned char)ptr[j]];
              int     x=decode64tab[(int)(unsigned char)ptr[j+1]];
              int     y=decode64tab[(int)(unsigned char)ptr[j+2]];
              int     z=decode64tab[(int)(unsigned char)ptr[j+3]];

              a= (w << 2) | (x >> 4);
              b= (x << 4) | (y >> 2);
              c= (y << 6) | z;
              dec_buf[k++]=a;
              if ( ptr[j+2] != '=')
                     dec_buf[k++]=b;
              if ( ptr[j+3] != '=')
                     dec_buf[k++]=c;
       }
       return (k);
}

Here is the caller graph for this function:

static int nyb ( int  c) [static]

Definition at line 780 of file rfc2047u.c.

{
       const char    *p;
       int n;

       p=strchr(xdigit, c);

       if (!p)
              return 0;

       n=p-xdigit;

       if (n > 15)
              n -= 6;

       return n;
}

Here is the caller graph for this function:

static int rfc2047_decode_unicode ( const char *  text,
const char *  chset,
void(*)(const char *, size_t, void *)  callback,
void *  ptr 
) [static]

Definition at line 1021 of file rfc2047u.c.

{
       struct rfc822_display_name_s s;

       s.chset=chset;
       s.print_func=callback;
       s.ptr=ptr;

       return rfc2047_decoder(text, rfc822_display_addr_cb, &s);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int rfc2047_decoder ( const char *  text,
void(*)(const char *chset, const char *lang, const char *content, size_t cnt, void *dummy callback,
void *  ptr 
)

Definition at line 957 of file rfc2047u.c.

{
       ssize_t rc;

       while (text && *text)
       {
              size_t i;

              for (i=0; text[i]; i++)
              {
                     if (text[i] == '=' && text[i+1] == '?')
                            break;
              }

              if (i)
                     (*callback)("iso-8859-1", "", text, i, ptr);

              text += i;

              if (!*text)
                     continue;

              rc=rfc822_decode_rfc2047_atom(text, strlen(text),
                                         callback, ptr);

              if (rc < 0)
                     return -1;

              if (rc == 0)
              {
                     (*callback)("iso-8859-1", "", text, 2, ptr);
                     text += 2;
                     continue;
              }

              text += rc;

              for (i=0; text[i]; i++)
              {
                     if (strchr(" \t\r\n", text[i]) == NULL)
                            break;
              }

              if (text[i] != '=' || text[i+1] != '?')
                     continue;

              rc=rfc822_decode_rfc2047_atom(text+i, strlen(text+i), NULL,
                                         NULL);

              if (rc < 0)
                     return -1;
              if (rc > 0)
                     text += i;
       }

       return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int rfc2047_print_unicode_addrstr ( const char *  addrheader,
const char *  charset,
void(*)(char, void *)  print_func,
void(*)(const char *, void *)  print_separator,
void(*)(const char *, int, void *)  err_func,
void *  ptr 
) [static]

Definition at line 538 of file rfc2047u.c.

{
       struct rfc822t *t;
       struct rfc822a *a;
       int rc;

       t=rfc822t_alloc_new(addrheader, err_func, ptr);

       if (!t)
              return -1;

       a=rfc822a_alloc(t);

       if (!a)
       {
              rfc822t_free(t);
              return -1;
       }
       rc=rfc2047_print_unicodeaddr(a, charset, print_func, print_separator,
                                 ptr);
       rfc822a_free(a);
       rfc822t_free(t);
       return (rc);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int rfc2047_print_unicodeaddr ( const struct rfc822a a,
const char *  charset,
void(*)(char, void *)  print_func,
void(*)(const char *, void *)  print_separator,
void *  ptr 
)

Definition at line 391 of file rfc2047u.c.

{
       const char *sep=NULL;
       int n;

       for (n=0; n<a->naddrs; ++n)
       {
              struct decode_unicode_s nbuf;
              const struct rfc822addr *addrs;
              size_t i=0;
              char *cpbuf;
              int need_braces=0;

              addrs=a->addrs+n;

              nbuf.bufptr=0;
              nbuf.bufsize=1;

              if (rfc822_display_name_int(a, n, charset,
                                       save_unicode_text, &nbuf) < 0)
                     return -1;

              nbuf.bufptr=malloc(nbuf.bufsize);
              nbuf.bufsize=0;
              if (!nbuf.bufptr)
                     return -1;

              if (rfc822_display_name_int(a, n, charset,
                                       save_unicode_text, &nbuf) < 0)
              {
                     free(nbuf.bufptr);
                     return -1;
              }
              nbuf.bufptr[nbuf.bufsize]=0;

              if (addrs->tokens == 0)
              {
                     size_t i;

                     if (nbuf.bufsize == 1) /* ; */
                            sep=0;

                     if (sep)
                            (*print_separator)(sep, ptr);

                     for (i=0; i<nbuf.bufsize; ++i)
                            (*print_func)(nbuf.bufptr[i], ptr);
                     free(nbuf.bufptr);
                     if (nbuf.bufsize > 1)
                            (*print_separator)(" ", ptr);
                     sep=NULL;
                     continue;
              }
              if (sep)
                     (*print_separator)(sep, ptr);

              if (!addrs->name)
              {
                     nbuf.bufsize=0;
                     nbuf.bufptr[0]=0;
              }

              for (i=0; i<nbuf.bufsize; i++)
                     if (strchr(RFC822_SPECIALS, nbuf.bufptr[i]))
                            break;

              cpbuf=libmail_u_convert_tobuf(nbuf.bufptr, "utf-8", charset,
                                         NULL);

              if (!cpbuf)
              {
                     const char *errmsg="\"(unknown character set)\"";

                     while (*errmsg)
                            (*print_func)(*errmsg++, ptr);
                     need_braces=1;
              }
              else
              {
                     if (i < nbuf.bufsize)
                     {
                            (*print_func)('"', ptr);

                            for (i=0; cpbuf[i]; ++i)
                            {
                                   if (cpbuf[i] == '\\' ||
                                       cpbuf[i] == '"')
                                          (*print_func)('\\', ptr);
                                   (*print_func)(cpbuf[i], ptr);
                            }
                            (*print_func)('"', ptr);
                            need_braces=1;
                     }
                        else
                        {
                                for (i=0; cpbuf[i]; ++i)
                            {
                                   need_braces=1;
                                        (*print_func)(cpbuf[i], ptr);
                            }
                        }

                     free(cpbuf);
              }
              free(nbuf.bufptr);

              if (need_braces)
              {
                     (*print_func)(' ', ptr);
                     (*print_func)('<', ptr);
              }

              nbuf.bufptr=0;
              nbuf.bufsize=1;

              if (rfc822_display_addr(a, n, charset,
                                   save_unicode_text, &nbuf) < 0)
                     return -1;

              nbuf.bufptr=malloc(nbuf.bufsize);
              nbuf.bufsize=0;
              if (!nbuf.bufptr)
                     return -1;

              if (rfc822_display_addr(a, n, charset,
                                   save_unicode_text, &nbuf) < 0)
              {
                     free(nbuf.bufptr);
                     return -1;
              }
              for (i=0; i<nbuf.bufsize; i++)
                     (*print_func)(nbuf.bufptr[i], ptr);

              free(nbuf.bufptr);

              if (need_braces)
                     (*print_func)('>', ptr);
              sep=", ";
       }

       return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static ssize_t rfc822_decode_rfc2047_atom ( const char *  str,
size_t  cnt,
void(*)(const char *, const char *, const char *, size_t, void *)  callback,
void *  ptr 
) [static]

Definition at line 828 of file rfc2047u.c.

{
       const char *chset_str;
       const char *enc_str;
       const char *content_str;

       char *chset;
       char *lang;

       char *content;

       size_t i;
       size_t j;
       size_t k;

       size_t content_len;

       if (cnt < 2 || str[0] != '=' || str[1] != '?')
              return 0;

       chset_str=str+2;

       for (i=2; i<cnt; i++)
              if (str[i] == '?')
                     break;

       if (i >= cnt)
              return 0;

       enc_str= str + ++i;

       for (; i < cnt; i++)
              if (str[i] == '?')
                     break;

       if (i >= cnt)
              return 0;

       content_str= str + ++i;

       while (1)
       {
              if (cnt-i < 2)
                     return 0;

              if (str[i] == '?' && str[i+1] == '=')
                     break;
              ++i;
       }

       for (j=0; chset_str[j] != '?'; ++j)
              ;

       chset=malloc(j+1);

       if (!chset)
              return -1;

       memcpy(chset, chset_str, j);
       chset[j]=0;

       lang=strchr(chset, '*');  /* RFC 2231 */

       if (lang)
              *lang++ = 0;
       else
              lang="";

       content_len=str + i - content_str;

       content=malloc(content_len+1);

       if (!content)
       {
              free(chset);
              return -1;
       }

       switch (*enc_str) {
       case 'q':
       case 'Q':

              k=0;
              for (j=0; j<content_len; j++)
              {
                     char c;

                     if (content_str[j] == '=' && i-j >= 3)
                     {
                            content[k]=(char)(nyb(content_str[j+1])*16 +
                                            nyb(content_str[j+2]));
                            ++k;
                            j += 2;
                            continue;
                     }

                     c=content_str[j];
                     if (c == '_')
                            c=' ';
                     content[k]=c;
                     ++k;
              }
              break;

       case 'b':
       case 'B':
              k=decodebase64(content_str, content_len, content);
              break;
       default:
              free(content);
              free(chset);
              return (0);
       }

       if (callback)
              (*callback)(chset, lang, content, k, ptr);
       free(content);
       free(chset);
       return i + 2;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int rfc822_display_addr ( const struct rfc822a rfcp,
int  index,
const char *  chset,
void(*)(const char *, size_t, void *)  print_func,
void *  ptr 
)

Definition at line 365 of file rfc2047u.c.

{
       const struct rfc822addr *addrs;
       char *tok;
       int rc;

       if (index < 0 || index >= rfcp->naddrs)   return 0;

       addrs=rfcp->addrs+index;

       if (!addrs->tokens)
              return 0;

       tok=rfc822_gettok(addrs->tokens);

       if (!tok)
              return 0;

       rc=rfc822_display_addr_str(tok, chset, print_func, ptr);
       free(tok);
       return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void rfc822_display_addr_cb ( const char *  chset,
const char *  lang,
const char *  content,
size_t  cnt,
void *  dummy 
) [static]

Definition at line 77 of file rfc2047u.c.

{
       struct rfc822_display_name_s *s=
              (struct rfc822_display_name_s *)dummy;
       char *ptr;
       char *buf;

       buf=malloc(cnt+1);

       if (!buf)
              return;

       memcpy(buf, content, cnt);
       buf[cnt]=0;

       ptr=libmail_u_convert_tobuf(buf, chset, s->chset, NULL);
       free(buf);

       if (ptr)
       {
              (*s->print_func)(ptr, strlen(ptr), s->ptr);
              free(ptr);
       }
       else
       {
              unknown_charset(chset, s->chset, s->print_func, s->ptr);
              return;
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

int rfc822_display_addr_str ( const char *  tok,
const char *  chset,
void(*)(const char *, size_t, void *)  print_func,
void *  ptr 
)

Definition at line 309 of file rfc2047u.c.

{
       const char *p;

       p=strchr(tok,'@');

       if (!p)
              p=tok;
       else
              ++p;

       if (chset != NULL)
       {
              int err=0;
              char *utf8_ptr;

              if (p > tok)
                     (*print_func)(tok, p-tok, ptr);

#if LIBIDN
              err=idna_to_unicode_8z8z(p, &utf8_ptr, 0);
              if (err != IDNA_SUCCESS)
                     utf8_ptr=0;
#else
              utf8_ptr=0;
#endif

              if (utf8_ptr == 0)
                     (*print_func)(p, strlen(p), ptr);
              else
              {
                     char *q=libmail_u_convert_tobuf(utf8_ptr,
                                                 "utf-8",
                                                 chset, NULL);
                     if (q)
                     {
                            (*print_func)(q, strlen(q), ptr);
                            free(q);
                     }
                     else
                     {
                            (*print_func)(p, strlen(p), ptr);
                     }
                     free(utf8_ptr);
              }
       }
       else
       {
              (*print_func)(tok, strlen(tok), ptr);
       }
       return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

char* rfc822_display_addr_str_tobuf ( const char *  tok,
const char *  chset 
)

Definition at line 726 of file rfc2047u.c.

{
       struct rfc822_display_hdrvalue_tobuf_s s;
       int errcode;
       char *bufptr;

       s.cnt=1;

       errcode=rfc822_display_addr_str(tok, chset,
                                   rfc822_display_hdrvalue_tobuf_cnt,
                                   &s);

       if (errcode < 0)
              return NULL;

       bufptr=s.buf=malloc(s.cnt);

       if (!bufptr)
              return NULL;

       errcode=rfc822_display_addr_str(tok, chset,
                                   rfc822_display_hdrvalue_tobuf_save,
                                   &s);
       if (errcode < 0)
       {
              free(bufptr);
              return NULL;
       }
       *s.buf=0;
       return bufptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

char* rfc822_display_addr_tobuf ( const struct rfc822a rfcp,
int  index,
const char *  chset 
)

Definition at line 652 of file rfc2047u.c.

{
       struct rfc822_display_hdrvalue_tobuf_s nbuf;
       int errcode;
       char *ptr;

       nbuf.buf=0;
       nbuf.cnt=1;

       errcode=rfc822_display_addr(rfcp, index, chset,
                                rfc822_display_hdrvalue_tobuf_cnt, &nbuf);

       if (errcode < 0)
              return NULL;

       ptr=nbuf.buf=malloc(nbuf.cnt);
       nbuf.cnt=0;
       if (!ptr)
              return NULL;

       errcode=rfc822_display_addr(rfcp, index, chset,
                                rfc822_display_hdrvalue_tobuf_save, &nbuf);

       if (errcode < 0)
       {
              free(nbuf.buf);
              return NULL;
       }
       *nbuf.buf=0;
       return ptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int rfc822_display_hdrvalue ( const char *  hdrname,
const char *  hdrvalue,
const char *  charset,
void(*)(const char *, size_t, void *)  display_func,
void(*)(const char *, int, void *)  err_func,
void *  ptr 
)

Definition at line 591 of file rfc2047u.c.

Here is the call graph for this function:

Here is the caller graph for this function:

static void rfc822_display_hdrvalue_print_func ( char  c,
void *  ptr 
) [static]

Definition at line 574 of file rfc2047u.c.

{
       struct rfc822_display_hdrvalue_s *s=
              (struct rfc822_display_hdrvalue_s *)ptr;

       (*s->display_func)(&c, 1, s->ptr);
}

Here is the caller graph for this function:

static void rfc822_display_hdrvalue_print_separator ( const char *  cp,
void *  ptr 
) [static]

Definition at line 582 of file rfc2047u.c.

{
       struct rfc822_display_hdrvalue_s *s=
              (struct rfc822_display_hdrvalue_s *)ptr;

       (*s->display_func)(cp, strlen(cp), s->ptr);
       (*s->display_func)("", 0, s->ptr); /* Signal wrap point */
}

Here is the caller graph for this function:

char* rfc822_display_hdrvalue_tobuf ( const char *  hdrname,
const char *  hdrvalue,
const char *  charset,
void(*)(const char *, int, void *)  err_func,
void *  ptr 
)

Definition at line 685 of file rfc2047u.c.

{
       struct rfc822_display_hdrvalue_tobuf_s s;
       int errcode;
       char *bufptr;

       s.orig_err_func=err_func;
       s.orig_ptr=ptr;
       s.cnt=1;

       errcode=rfc822_display_hdrvalue(hdrname, hdrvalue, charset,
                                   rfc822_display_hdrvalue_tobuf_cnt,
                                   rfc822_display_hdrvalue_tobuf_errfunc,
                                   &s);

       if (errcode < 0)
              return NULL;

       bufptr=s.buf=malloc(s.cnt);

       if (!bufptr)
              return NULL;

       errcode=rfc822_display_hdrvalue(hdrname, hdrvalue, charset,
                                   rfc822_display_hdrvalue_tobuf_save,
                                   rfc822_display_hdrvalue_tobuf_errfunc,
                                   &s);
       if (errcode)
       {
              free(bufptr);
              return NULL;
       }
       *s.buf=0;
       return bufptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void rfc822_display_hdrvalue_tobuf_cnt ( const char *  ptr,
size_t  cnt,
void *  s 
) [static]

Definition at line 625 of file rfc2047u.c.

{
       ((struct rfc822_display_hdrvalue_tobuf_s *)s)->cnt += cnt;
}

Here is the caller graph for this function:

static void rfc822_display_hdrvalue_tobuf_errfunc ( const char *  ptr,
int  index,
void *  s 
) [static]

Definition at line 641 of file rfc2047u.c.

{
       void (*f)(const char *, int, void *)=
              ((struct rfc822_display_hdrvalue_tobuf_s *)s)->orig_err_func;

       if (f)
              f(ptr, index,
                ((struct rfc822_display_hdrvalue_tobuf_s *)s)->orig_ptr);
}

Here is the caller graph for this function:

static void rfc822_display_hdrvalue_tobuf_save ( const char *  ptr,
size_t  cnt,
void *  s 
) [static]

Definition at line 631 of file rfc2047u.c.

{
       if (cnt)
              memcpy(((struct rfc822_display_hdrvalue_tobuf_s *)s)->buf,
                     ptr, cnt);

       ((struct rfc822_display_hdrvalue_tobuf_s *)s)->buf += cnt;
}

Here is the caller graph for this function:

int rfc822_display_name ( const struct rfc822a rfcp,
int  index,
const char *  chset,
void(*)(const char *, size_t, void *)  print_func,
void *  ptr 
)

Definition at line 242 of file rfc2047u.c.

{
       const struct rfc822addr *addrs;

       if (index < 0 || index >= rfcp->naddrs)   return 0;

       addrs=rfcp->addrs+index;

       if (!addrs->tokens)
              return 0;

       return rfc822_display_name_int(rfcp, index, chset,
                                   print_func, ptr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int rfc822_display_name_int ( const struct rfc822a rfcp,
int  index,
const char *  chset,
void(*)(const char *, size_t, void *)  print_func,
void *  ptr 
) [static]

Definition at line 112 of file rfc2047u.c.

{
       struct rfc822_display_name_s s;
       const struct rfc822addr *addrs;

       struct rfc822token *i;
       int    prev_isatom=0;
       int    isatom=0;
       ssize_t rc;

       if (index < 0 || index >= rfcp->naddrs)   return 0;

       addrs=rfcp->addrs+index;

       if (!addrs->name)
              return rfc822_display_addr(rfcp, index, chset, print_func, ptr);

       if (chset == NULL)
       {
              s.chset="iso-8859-1";
       }
       else
       {
              s.chset=chset;
       }

       s.print_func=print_func;
       s.ptr=ptr;

       for (i=addrs->name; i; i=i->next, prev_isatom=isatom)
       {
              isatom=rfc822_is_atom(i->token);
              if (isatom && prev_isatom)
                     (*print_func)(" ", 1, ptr);

              if (i->token == '"' || i->token == '(')
              {
                     size_t l=i->len;
                     char *p, *q, *r;

                     if (i->token == '(')
                     {
                            if (l > 2)
                                   l -= 2;
                            else
                                   l=0;
                     }

                     p=malloc(l+1);

                     if (!p)
                            return -1;

                     if (l)
                     {
                            if (i->token == '(')
                            {
                                   memcpy(p, i->ptr+1, l);
                            }
                            else
                            {
                                   memcpy(p, i->ptr, l);
                            }
                     }


                     p[l]=0;

                     for (q=r=p; *q; *r++ = *q++)
                            if (*q == '\\' && q[1])
                                   ++q;

                     *r=0;

                     if (chset == NULL)
                     {
                            (*print_func)(p, strlen(p), ptr);
                     }
                     else if (rfc822_display_hdrvalue("subject",
                                                  p, s.chset,
                                                  print_func,
                                                  NULL, ptr) < 0)
                     {
                            free(p);
                            return -1;
                     }
                     free(p);
                     continue;
              }

              if (i->token)
              {
                     char c= (char)i->token;

                     (*print_func)(&c, 1, ptr);
                     continue;
              }

              rc=chset ? rfc822_decode_rfc2047_atom(i->ptr, i->len,
                                                rfc822_display_addr_cb,
                                                &s):0;

              if (rc < 0)
                     return -1;

              if (rc == 0)
              {
                     (*print_func)(i->ptr, i->len, ptr);
                     continue;
              }

              if (i->next && i->next->token == 0)
              {
                     rc=rfc822_decode_rfc2047_atom(i->next->ptr,
                                                i->next->len,
                                                NULL, NULL);

                     if (rc < 0)
                            return -1;

                     if (rc > 0)
                            isatom=0; /* Suppress the separating space */
              }
       }
       return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

char* rfc822_display_name_tobuf ( const struct rfc822a rfcp,
int  index,
const char *  chset 
)

Definition at line 260 of file rfc2047u.c.

{
       struct decode_unicode_s s;
       char *p;

       s.bufptr=0;
       s.bufsize=1;

       if (rfc822_display_name(rfcp, index, chset, save_unicode_text, &s) < 0)
              return NULL;
       s.bufptr=p=malloc(s.bufsize);
       if (!p)
              return (0);

       s.bufsize=0;
       if (rfc822_display_name(rfcp, index, chset, save_unicode_text, &s) < 0)
       {
              free(s.bufptr);
              return (0);
       }
       save_unicode_text("", 1, &s);

       return (p);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int rfc822_display_namelist ( const struct rfc822a rfcp,
const char *  chset,
void(*)(const char *, size_t, void *)  print_func,
void *  ptr 
)

Definition at line 286 of file rfc2047u.c.

{
       int n;

       for (n=0; n<rfcp->naddrs; n++)
       {
              if (rfcp->addrs[n].tokens)
              {
                     int err=rfc822_display_name(rfcp, n, chset,
                                              print_func, ptr);

                     if (err < 0)
                            return err;

                     (*print_func)("\n", 1, ptr);
              }
       }
       return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void save_unicode_text ( const char *  p,
size_t  l,
void *  ptr 
) [static]

Definition at line 46 of file rfc2047u.c.

{
       struct decode_unicode_s *s=
              (struct decode_unicode_s *)ptr;

       if (s->bufptr)
              memcpy(s->bufptr+s->bufsize, p, l);

       s->bufsize += l;
}

Here is the caller graph for this function:

static void unknown_charset ( const char *  chset,
const char *  tochset,
void(*)(const char *, size_t, void *)  print_func,
void *  ptr 
) [static]

Definition at line 63 of file rfc2047u.c.

{
       static const char unknown[]="[unknown character set: ";

       (*print_func)(unknown, sizeof(unknown)-1, ptr);
       (*print_func)(chset, strlen(chset), ptr);
       (*print_func)(" -> ", 4, ptr);
       (*print_func)(tochset, strlen(tochset), ptr);
       (*print_func)("]", 1, ptr);
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

const unsigned char decode64tab[] [static]
Initial value:
{
        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 62,  0,  0,  0, 63,
       52, 53, 54, 55, 56, 57, 58, 59, 60, 61,  0,  0,  0, 99,  0,  0,
        0,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
       15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,  0,  0,  0,  0,  0,
        0, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
       41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,  0,  0,  0,  0,  0,
        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0
}

Definition at line 761 of file rfc2047u.c.

const char xdigit[] = "0123456789ABCDEFabcdef" [static]

Definition at line 759 of file rfc2047u.c.