Back to index

citadel  8.12
Classes | Enumerations | Functions | Variables
internet_addressing.h File Reference
#include "server.h"

Go to the source code of this file.

Classes

struct  internet_address_list
struct  spamstrings_t

Enumerations

enum  {
  hostalias_nomatch, hostalias_localhost, hostalias_gatewaydomain, hostalias_directory,
  hostalias_masq
}

Functions

int fuzzy_match (struct ctdluser *us, char *matchstring)
void process_rfc822_addr (const char *rfc822, char *user, char *node, char *name)
char * rfc822_fetch_field (const char *rfc822, const char *fieldname)
int IsDirectory (char *addr, int allow_masq_domains)
void CtdlDirectoryInit (void)
int CtdlDirectoryAddUser (char *internet_addr, char *citadel_addr)
int CtdlDirectoryDelUser (char *internet_addr, char *citadel_addr)
int CtdlDirectoryLookup (char *target, char *internet_addr, size_t targbuflen)
struct CtdlMessageconvert_internet_message (char *rfc822)
struct CtdlMessageconvert_internet_message_buf (StrBuf **rfc822)
int CtdlHostAlias (char *fqdn)
char * harvest_collected_addresses (struct CtdlMessage *msg)

Variables

char * inetcfg
struct spamstrings_tspamstrings

Class Documentation

struct internet_address_list

Definition at line 4 of file internet_addressing.h.

Collaboration diagram for internet_address_list:
Class Members
char ial_name
char ial_node
char ial_user
struct internet_address_list * next
struct spamstrings_t

Definition at line 41 of file internet_addressing.h.

Collaboration diagram for spamstrings_t:
Class Members
struct spamstrings_t * next
char * string

Enumeration Type Documentation

anonymous enum
Enumerator:
hostalias_nomatch 
hostalias_localhost 
hostalias_gatewaydomain 
hostalias_directory 
hostalias_masq 

Definition at line 30 of file internet_addressing.h.


Function Documentation

struct CtdlMessage* convert_internet_message ( char *  rfc822) [read]

Definition at line 746 of file internet_addressing.c.

                                                           {
       StrBuf *RFCBuf = NewStrBufPlain(rfc822, -1);
       free (rfc822);
       return convert_internet_message_buf(&RFCBuf);
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct CtdlMessage* convert_internet_message_buf ( StrBuf **  rfc822) [read]

Definition at line 754 of file internet_addressing.c.

{
       struct CtdlMessage *msg;
       const char *pos, *beg, *end, *totalend;
       int done, alldone = 0;
       char buf[SIZ];
       int converted;
       StrBuf *OtherHeaders;

       msg = malloc(sizeof(struct CtdlMessage));
       if (msg == NULL) return msg;

       memset(msg, 0, sizeof(struct CtdlMessage));
       msg->cm_magic = CTDLMESSAGE_MAGIC; /* self check */
       msg->cm_anon_type = 0;                    /* never anonymous */
       msg->cm_format_type = FMT_RFC822;  /* internet message */

       pos = ChrPtr(*rfc822);
       totalend = pos + StrLength(*rfc822);
       done = 0;
       OtherHeaders = NewStrBufPlain(NULL, StrLength(*rfc822));

       while (!alldone) {

              /* Locate beginning and end of field, keeping in mind that
               * some fields might be multiline
               */
              end = beg = pos;

              while ((end < totalend) && 
                     (end == beg) && 
                     (done == 0) ) 
              {

                     if ( (*pos=='\n') && ((*(pos+1))!=0x20) && ((*(pos+1))!=0x09) )
                     {
                            end = pos;
                     }

                     /* done with headers? */
                     if ((*pos=='\n') &&
                         ( (*(pos+1)=='\n') ||
                           (*(pos+1)=='\r')) ) 
                     {
                            alldone = 1;
                     }

                     if (pos >= (totalend - 1) )
                     {
                            end = pos;
                            done = 1;
                     }

                     ++pos;

              }

              /* At this point we have a field.  Are we interested in it? */
              converted = convert_field(msg, beg, end);

              /* Strip the field out of the RFC822 header if we used it */
              if (!converted) {
                     StrBufAppendBufPlain(OtherHeaders, beg, end - beg, 0);
                     StrBufAppendBufPlain(OtherHeaders, HKEY("\n"), 0);
              }

              /* If we've hit the end of the message, bail out */
              if (pos >= totalend)
                     alldone = 1;
       }
       StrBufAppendBufPlain(OtherHeaders, HKEY("\n"), 0);
       if (pos < totalend)
              StrBufAppendBufPlain(OtherHeaders, pos, totalend - pos, 0);
       FreeStrBuf(rfc822);
       msg->cm_fields['M'] = SmashStrBuf(&OtherHeaders);

       /* Follow-up sanity checks... */

       /* If there's no timestamp on this message, set it to now. */
       if (msg->cm_fields['T'] == NULL) {
              snprintf(buf, sizeof buf, "%ld", (long)time(NULL));
              msg->cm_fields['T'] = strdup(buf);
       }

       /* If a W (references, or rather, Wefewences) field is present, we
        * have to convert it from RFC822 format to Citadel format.
        */
       if (msg->cm_fields['W'] != NULL) {
              convert_references_to_wefewences(msg->cm_fields['W']);
       }

       return msg;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CtdlDirectoryAddUser ( char *  internet_addr,
char *  citadel_addr 
)

Definition at line 961 of file internet_addressing.c.

                                                                  {
       char key[SIZ];

       if (IsDirectory(internet_addr, 0) == 0) 
              return 0;
       syslog(LOG_DEBUG, "Create directory entry: %s --> %s\n", internet_addr, citadel_addr);
       directory_key(key, internet_addr);
       cdb_store(CDB_DIRECTORY, key, strlen(key), citadel_addr, strlen(citadel_addr)+1 );
       return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CtdlDirectoryDelUser ( char *  internet_addr,
char *  citadel_addr 
)

Definition at line 979 of file internet_addressing.c.

                                                                  {
       char key[SIZ];

       syslog(LOG_DEBUG, "Delete directory entry: %s --> %s\n", internet_addr, citadel_addr);
       directory_key(key, internet_addr);
       return cdb_delete(CDB_DIRECTORY, key, strlen(key) ) == 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CtdlDirectoryInit ( void  )

Definition at line 953 of file internet_addressing.c.

Here is the call graph for this function:

Here is the caller graph for this function:

int CtdlDirectoryLookup ( char *  target,
char *  internet_addr,
size_t  targbuflen 
)

Definition at line 993 of file internet_addressing.c.

                                                                              {
       struct cdbdata *cdbrec;
       char key[SIZ];

       /* Dump it in there unchanged, just for kicks */
       safestrncpy(target, internet_addr, targbuflen);

       /* Only do lookups for addresses with hostnames in them */
       if (num_tokens(internet_addr, '@') != 2) return(-1);

       /* Only do lookups for domains in the directory */
       if (IsDirectory(internet_addr, 0) == 0) return(-1);

       directory_key(key, internet_addr);
       cdbrec = cdb_fetch(CDB_DIRECTORY, key, strlen(key) );
       if (cdbrec != NULL) {
              safestrncpy(target, cdbrec->ptr, targbuflen);
              cdb_free(cdbrec);
              return(0);
       }

       return(-1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CtdlHostAlias ( char *  fqdn)

Definition at line 292 of file internet_addressing.c.

                              {
       int config_lines;
       int i;
       char buf[256];
       char host[256], type[256];
       int found = 0;

       if (fqdn == NULL) return(hostalias_nomatch);
       if (IsEmptyStr(fqdn)) return(hostalias_nomatch);
       if (!strcasecmp(fqdn, "localhost")) return(hostalias_localhost);
       if (!strcasecmp(fqdn, config.c_fqdn)) return(hostalias_localhost);
       if (!strcasecmp(fqdn, config.c_nodename)) return(hostalias_localhost);
       if (inetcfg == NULL) return(hostalias_nomatch);

       config_lines = num_tokens(inetcfg, '\n');
       for (i=0; i<config_lines; ++i) {
              extract_token(buf, inetcfg, i, '\n', sizeof buf);
              extract_token(host, buf, 0, '|', sizeof host);
              extract_token(type, buf, 1, '|', sizeof type);

              found = 0;

              /* Process these in a specific order, in case there are multiple matches.
               * We want directory to override masq, for example.
               */

              if ( (!strcasecmp(type, "masqdomain")) && (!strcasecmp(fqdn, host))) {
                     found = hostalias_masq;
              }
              if ( (!strcasecmp(type, "localhost")) && (!strcasecmp(fqdn, host))) {
                     found = hostalias_localhost;
              }
              if ( (!strcasecmp(type, "directory")) && (!strcasecmp(fqdn, host))) {
                     found = hostalias_directory;
              }

              if (found) return(found);
       }

       return(hostalias_nomatch);
}

Here is the caller graph for this function:

int fuzzy_match ( struct ctdluser us,
char *  matchstring 
)

Definition at line 345 of file internet_addressing.c.

                                                        {
       int a;
       long len;

       if ( (!strncasecmp(matchstring, "cit", 3)) 
          && (atol(&matchstring[3]) == us->usernum)) {
              return 0;
       }

       len = strlen(matchstring);
       for (a=0; !IsEmptyStr(&us->fullname[a]); ++a) {
              if (!strncasecmp(&us->fullname[a],
                 matchstring, len)) {
                     return 0;
              }
       }
       return -1;
}
char* harvest_collected_addresses ( struct CtdlMessage msg)

Definition at line 1022 of file internet_addressing.c.

                                                           {
       char *coll = NULL;
       char addr[256];
       char user[256], node[256], name[256];
       int is_harvestable;
       int i, j, h;
       int field = 0;

       if (msg == NULL) return(NULL);

       is_harvestable = 1;
       strcpy(addr, "");    
       if (msg->cm_fields['A'] != NULL) {
              strcat(addr, msg->cm_fields['A']);
       }
       if (msg->cm_fields['F'] != NULL) {
              strcat(addr, " <");
              strcat(addr, msg->cm_fields['F']);
              strcat(addr, ">");
              if (IsDirectory(msg->cm_fields['F'], 0)) {
                     is_harvestable = 0;
              }
       }

       if (is_harvestable) {
              coll = strdup(addr);
       }
       else {
              coll = strdup("");
       }

       if (coll == NULL) return(NULL);

       /* Scan both the R (To) and Y (CC) fields */
       for (i = 0; i < 2; ++i) {
              if (i == 0) field = 'R' ;
              if (i == 1) field = 'Y' ;

              if (msg->cm_fields[field] != NULL) {
                     for (j=0; j<num_tokens(msg->cm_fields[field], ','); ++j) {
                            extract_token(addr, msg->cm_fields[field], j, ',', sizeof addr);
                            if (strstr(addr, "=?") != NULL)
                                   utf8ify_rfc822_string(addr);
                            process_rfc822_addr(addr, user, node, name);
                            h = CtdlHostAlias(node);
                            if ( (h != hostalias_localhost) && (h != hostalias_directory) ) {
                                   coll = realloc(coll, strlen(coll) + strlen(addr) + 4);
                                   if (coll == NULL) return(NULL);
                                   if (!IsEmptyStr(coll)) {
                                          strcat(coll, ",");
                                   }
                                   striplt(addr);
                                   strcat(coll, addr);
                            }
                     }
              }
       }

       if (IsEmptyStr(coll)) {
              free(coll);
              return(NULL);
       }
       return(coll);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int IsDirectory ( char *  addr,
int  allow_masq_domains 
)

Definition at line 929 of file internet_addressing.c.

                                                    {
       char domain[256];
       int h;

       extract_token(domain, addr, 1, '@', sizeof domain);
       striplt(domain);

       h = CtdlHostAlias(domain);

       if ( (h == hostalias_masq) && allow_masq_domains)
              return(1);
       
       if ( (h == hostalias_localhost) || (h == hostalias_directory) ) {
              return(1);
       }
       else {
              return(0);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void process_rfc822_addr ( const char *  rfc822,
char *  user,
char *  node,
char *  name 
)

Definition at line 424 of file internet_addressing.c.

{
       int a;

       strcpy(user, "");
       strcpy(node, config.c_fqdn);
       strcpy(name, "");

       if (rfc822 == NULL) return;

       /* extract full name - first, it's From minus <userid> */
       strcpy(name, rfc822);
       stripout(name, '<', '>');

       /* strip anything to the left of a bang */
       while ((!IsEmptyStr(name)) && (haschar(name, '!') > 0))
              strcpy(name, &name[1]);

       /* and anything to the right of a @ or % */
       for (a = 0; a < strlen(name); ++a) {
              if (name[a] == '@')
                     name[a] = 0;
              if (name[a] == '%')
                     name[a] = 0;
       }

       /* but if there are parentheses, that changes the rules... */
       if ((haschar(rfc822, '(') == 1) && (haschar(rfc822, ')') == 1)) {
              strcpy(name, rfc822);
              stripallbut(name, '(', ')');
       }

       /* but if there are a set of quotes, that supersedes everything */
       if (haschar(rfc822, 34) == 2) {
              strcpy(name, rfc822);
              while ((!IsEmptyStr(name)) && (name[0] != 34)) {
                     strcpy(&name[0], &name[1]);
              }
              strcpy(&name[0], &name[1]);
              for (a = 0; a < strlen(name); ++a)
                     if (name[a] == 34)
                            name[a] = 0;
       }
       /* extract user id */
       strcpy(user, rfc822);

       /* first get rid of anything in parens */
       stripout(user, '(', ')');

       /* if there's a set of angle brackets, strip it down to that */
       if ((haschar(user, '<') == 1) && (haschar(user, '>') == 1)) {
              stripallbut(user, '<', '>');
       }

       /* strip anything to the left of a bang */
       while ((!IsEmptyStr(user)) && (haschar(user, '!') > 0))
              strcpy(user, &user[1]);

       /* and anything to the right of a @ or % */
       for (a = 0; a < strlen(user); ++a) {
              if (user[a] == '@')
                     user[a] = 0;
              if (user[a] == '%')
                     user[a] = 0;
       }


       /* extract node name */
       strcpy(node, rfc822);

       /* first get rid of anything in parens */
       stripout(node, '(', ')');

       /* if there's a set of angle brackets, strip it down to that */
       if ((haschar(node, '<') == 1) && (haschar(node, '>') == 1)) {
              stripallbut(node, '<', '>');
       }

       /* If no node specified, tack ours on instead */
       if (
              (haschar(node, '@')==0)
              && (haschar(node, '%')==0)
              && (haschar(node, '!')==0)
       ) {
              strcpy(node, config.c_nodename);
       }

       else {

              /* strip anything to the left of a @ */
              while ((!IsEmptyStr(node)) && (haschar(node, '@') > 0))
                     strcpy(node, &node[1]);
       
              /* strip anything to the left of a % */
              while ((!IsEmptyStr(node)) && (haschar(node, '%') > 0))
                     strcpy(node, &node[1]);
       
              /* reduce multiple system bang paths to node!user */
              while ((!IsEmptyStr(node)) && (haschar(node, '!') > 1))
                     strcpy(node, &node[1]);
       
              /* now get rid of the user portion of a node!user string */
              for (a = 0; a < strlen(node); ++a)
                     if (node[a] == '!')
                            node[a] = 0;
       }

       /* strip leading and trailing spaces in all strings */
       striplt(user);
       striplt(node);
       striplt(name);

       /* If we processed a string that had the address in angle brackets
        * but no name outside the brackets, we now have an empty name.  In
        * this case, use the user portion of the address as the name.
        */
       if ((IsEmptyStr(name)) && (!IsEmptyStr(user))) {
              strcpy(name, user);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

char* rfc822_fetch_field ( const char *  rfc822,
const char *  fieldname 
)

Definition at line 857 of file internet_addressing.c.

                                                                    {
       char *fieldbuf = NULL;
       const char *end_of_headers;
       const char *field_start;
       const char *ptr;
       char *cont;
       char fieldhdr[SIZ];

       /* Should never happen, but sometimes we get stupid */
       if (rfc822 == NULL) return(NULL);
       if (fieldname == NULL) return(NULL);

       snprintf(fieldhdr, sizeof fieldhdr, "%s:", fieldname);

       /* Locate the end of the headers, so we don't run past that point */
       end_of_headers = cbmstrcasestr(rfc822, "\n\r\n");
       if (end_of_headers == NULL) {
              end_of_headers = cbmstrcasestr(rfc822, "\n\n");
       }
       if (end_of_headers == NULL) return (NULL);

       field_start = cbmstrcasestr(rfc822, fieldhdr);
       if (field_start == NULL) return(NULL);
       if (field_start > end_of_headers) return(NULL);

       fieldbuf = malloc(SIZ);
       strcpy(fieldbuf, "");

       ptr = field_start;
       ptr = cmemreadline(ptr, fieldbuf, SIZ-strlen(fieldbuf) );
       while ( (isspace(ptr[0])) && (ptr < end_of_headers) ) {
              strcat(fieldbuf, " ");
              cont = &fieldbuf[strlen(fieldbuf)];
              ptr = cmemreadline(ptr, cont, SIZ-strlen(fieldbuf) );
              striplt(cont);
       }

       strcpy(fieldbuf, &fieldbuf[strlen(fieldhdr)]);
       striplt(fieldbuf);

       return(fieldbuf);
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

char* inetcfg

Definition at line 285 of file internet_addressing.c.

Definition at line 286 of file internet_addressing.c.