Back to index

libcitadel  8.12
Functions
vcard.c File Reference
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <fcntl.h>
#include <signal.h>
#include <time.h>
#include <ctype.h>
#include <string.h>
#include <errno.h>
#include <limits.h>
#include <libcitadel.h>

Go to the source code of this file.

Functions

struct vCardvcard_new ()
void remove_charset_attribute (char *strbuf)
void vcard_add_prop (struct vCard *v, char *propname, char *propvalue)
struct vCardVCardLoad (StrBuf *vbtext)
struct vCardvcard_load (char *vtext)
char * vcard_get_prop (struct vCard *v, char *propname, int is_partial, int instance, int get_propname)
void vcard_free (struct vCard *v)
void vcard_set_prop (struct vCard *v, char *name, char *value, int append)
char * vcard_serialize (struct vCard *v)
void vcard_fn_to_n (char *vname, char *n, size_t vname_size)

Function Documentation

void remove_charset_attribute ( char *  strbuf)

Definition at line 68 of file vcard.c.

{
       int i, t;
       char compare[256];

       t = num_tokens(strbuf, ';');
       for (i=0; i<t; ++i) {
              extract_token(compare, strbuf, i, ';', sizeof compare);
              striplt(compare);
              if (!strncasecmp(compare, "charset=", 8)) {
                     remove_token(strbuf, i, ';');
              }
       }
       if (!IsEmptyStr(strbuf)) {
              if (strbuf[strlen(strbuf)-1] == ';') {
                     strbuf[strlen(strbuf)-1] = 0;
              }
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void vcard_add_prop ( struct vCard v,
char *  propname,
char *  propvalue 
)

Definition at line 96 of file vcard.c.

                                                                      {
       ++v->numprops;
       v->prop = realloc(v->prop,
              (v->numprops * sizeof(struct vCardProp)) );
       v->prop[v->numprops-1].name = strdup(propname);
       v->prop[v->numprops-1].value = strdup(propvalue);
}
void vcard_fn_to_n ( char *  vname,
char *  n,
size_t  vname_size 
)

Definition at line 352 of file vcard.c.

                                                            {
       char lastname[256];
       char firstname[256];
       char middlename[256];
       char honorific_prefixes[256];
       char honorific_suffixes[256];
       char buf[256];

       safestrncpy(buf, n, sizeof buf);

       /* Try to intelligently convert the screen name to a
        * fully expanded vCard name based on the number of
        * words in the name
        */
       safestrncpy(lastname, "", sizeof lastname);
       safestrncpy(firstname, "", sizeof firstname);
       safestrncpy(middlename, "", sizeof middlename);
       safestrncpy(honorific_prefixes, "", sizeof honorific_prefixes);
       safestrncpy(honorific_suffixes, "", sizeof honorific_suffixes);

       /* Honorific suffixes */
       if (num_tokens(buf, ',') > 1) {
              extract_token(honorific_suffixes, buf, (num_tokens(buf, ' ') - 1), ',',
                     sizeof honorific_suffixes);
              remove_token(buf, (num_tokens(buf, ',') - 1), ',');
       }

       /* Find a last name */
       extract_token(lastname, buf, (num_tokens(buf, ' ') - 1), ' ', sizeof lastname);
       remove_token(buf, (num_tokens(buf, ' ') - 1), ' ');

       /* Find honorific prefixes */
       if (num_tokens(buf, ' ') > 2) {
              extract_token(honorific_prefixes, buf, 0, ' ', sizeof honorific_prefixes);
              remove_token(buf, 0, ' ');
       }

       /* Find a middle name */
       if (num_tokens(buf, ' ') > 1) {
              extract_token(middlename, buf, (num_tokens(buf, ' ') - 1), ' ', sizeof middlename);
              remove_token(buf, (num_tokens(buf, ' ') - 1), ' ');
       }

       /* Anything left is probably the first name */
       safestrncpy(firstname, buf, sizeof firstname);
       striplt(firstname);

       /* Compose the structured name */
       snprintf(vname, vname_size, "%s;%s;%s;%s;%s", lastname, firstname, middlename,
              honorific_prefixes, honorific_suffixes);
}

Here is the call graph for this function:

void vcard_free ( struct vCard v)

Definition at line 240 of file vcard.c.

                                 {
       int i;
       
       if (v->magic != CTDL_VCARD_MAGIC) return; /* Self-check */
       
       if (v->numprops) for (i=0; i<(v->numprops); ++i) {
              free(v->prop[i].name);
              free(v->prop[i].value);
       }

       if (v->prop != NULL) free(v->prop);
       
       memset(v, 0, sizeof(struct vCard));
       free(v);
}
char* vcard_get_prop ( struct vCard v,
char *  propname,
int  is_partial,
int  instance,
int  get_propname 
)

Definition at line 208 of file vcard.c.

                                                                     {
       int i;
       int found_instance = 0;

       if (v->numprops) for (i=0; i<(v->numprops); ++i) {
              if ( (!strcasecmp(v->prop[i].name, propname))
                 || (propname[0] == 0)
                 || (  (!strncasecmp(v->prop[i].name,
                                   propname, strlen(propname)))
                      && (v->prop[i].name[strlen(propname)] == ';')
                      && (is_partial) ) ) {
                     if (instance == found_instance++) {
                            if (get_propname) {
                                   return(v->prop[i].name);
                            }
                            else {
                                   return(v->prop[i].value);
                            }
                     }
              }
       }

       return NULL;
}
struct vCard* vcard_load ( char *  vtext) [read]

Definition at line 114 of file vcard.c.

                                      {
       struct vCard *v;
       int valid = 0;
       char *mycopy, *ptr;
       char *namebuf, *valuebuf;
       int i;
       int colonpos, nlpos;

       if (vtext == NULL) return vcard_new();
       mycopy = strdup(vtext);
       if (mycopy == NULL) return NULL;

       /*
        * First, fix this big pile o' vCard to make it more parseable.
        * To make it easier to parse, we convert CRLF to LF, and unfold any
        * multi-line fields into single lines.
        */
       for (i=0; !IsEmptyStr(&mycopy[i]); ++i) {
              if (!strncmp(&mycopy[i], "\r\n", 2)) {
                     strcpy(&mycopy[i], &mycopy[i+1]);
              }
              if ( (mycopy[i]=='\n') && (isspace(mycopy[i+1])) ) {
                     strcpy(&mycopy[i], &mycopy[i+1]);
              }
       }

       v = vcard_new();
       if (v == NULL) return v;

       ptr = mycopy;
       while (!IsEmptyStr(ptr)) {
              colonpos = pattern2(ptr, ":");
              nlpos = pattern2(ptr, "\n");

              if ((nlpos > colonpos) && (colonpos > 0)) {
                     namebuf = malloc(colonpos + 1);
                     valuebuf = malloc(nlpos - colonpos + 1);
                     memcpy(namebuf, ptr, colonpos);
                     namebuf[colonpos] = '\0';
                     memcpy(valuebuf, &ptr[colonpos+1], nlpos-colonpos-1);
                     valuebuf[nlpos-colonpos-1] = '\0';

                     if (!strcasecmp(namebuf, "end")) {
                            valid = 0;
                     }
                     if (   (!strcasecmp(namebuf, "begin"))
                            && (!strcasecmp(valuebuf, "vcard"))
                     ) {
                            valid = 1;
                     }

                     if ( (valid) && (strcasecmp(namebuf, "begin")) ) {
                            remove_charset_attribute(namebuf);
                            ++v->numprops;
                            v->prop = realloc(v->prop,
                                   (v->numprops * sizeof(struct vCardProp))
                            );
                            v->prop[v->numprops-1].name = namebuf;
                            v->prop[v->numprops-1].value = valuebuf;
                     } 
                     else {
                            free(namebuf);
                            free(valuebuf);
                     }

              }

              while ( (*ptr != '\n') && (!IsEmptyStr(ptr)) ) {
                     ++ptr;
              }
              if (*ptr == '\n') ++ptr;
       }

       free(mycopy);
       return v;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct vCard* vcard_new ( void  ) [read]

Definition at line 51 of file vcard.c.

                          {
       struct vCard *v;

       v = (struct vCard *) malloc(sizeof(struct vCard));
       if (v == NULL) return v;

       v->magic = CTDL_VCARD_MAGIC;
       v->numprops = 0;
       v->prop = NULL;

       return v;
}

Here is the caller graph for this function:

char* vcard_serialize ( struct vCard v)

Definition at line 296 of file vcard.c.

{
       char *ser;
       int i, j;
       size_t len;
       int is_utf8 = 0;

       if (v == NULL) return NULL;               /* self check */
       if (v->magic != CTDL_VCARD_MAGIC) return NULL;   /* self check */

       /* Set the vCard version number to 2.1 at this time. */
       vcard_set_prop(v, "VERSION", "2.1", 0);

       /* Figure out how big a buffer we need to allocate */
       len = 64;     /* for begin, end, and a little padding for safety */
       if (v->numprops) for (i=0; i<(v->numprops); ++i) {
              len = len +
                     strlen(v->prop[i].name) +
                     strlen(v->prop[i].value) + 16;
       }

       ser = malloc(len);
       if (ser == NULL) return NULL;

       safestrncpy(ser, "begin:vcard\r\n", len);
       if (v->numprops) for (i=0; i<(v->numprops); ++i) {
              if ( (strcasecmp(v->prop[i].name, "end")) && (v->prop[i].value != NULL) ) {
                     is_utf8 = 0;
                     for (j=0; !IsEmptyStr(&v->prop[i].value[j]); ++j) {
                            if ( (v->prop[i].value[j] < 32) || (v->prop[i].value[j] > 126) ) {
                                   is_utf8 = 1;
                            }
                     }
                     strcat(ser, v->prop[i].name);
                     if (is_utf8) {
                            strcat(ser, ";charset=UTF-8");
                     }
                     strcat(ser, ":");
                     strcat(ser, v->prop[i].value);
                     strcat(ser, "\r\n");
              }
       }
       strcat(ser, "end:vcard\r\n");

       return ser;
}

Here is the call graph for this function:

void vcard_set_prop ( struct vCard v,
char *  name,
char *  value,
int  append 
)

Definition at line 266 of file vcard.c.

                                                                          {
       int i;

       if (v->magic != CTDL_VCARD_MAGIC) return; /* Self-check */

       /* If this key is already present, replace it */
       if (!append) if (v->numprops) for (i=0; i<(v->numprops); ++i) {
              if (!strcasecmp(v->prop[i].name, name)) {
                     free(v->prop[i].name);
                     free(v->prop[i].value);
                     v->prop[i].name = strdup(name);
                     v->prop[i].value = strdup(value);
                     return;
              }
       }

       /* Otherwise, append it */
       ++v->numprops;
       v->prop = realloc(v->prop,
              (v->numprops * sizeof(struct vCardProp)) );
       v->prop[v->numprops-1].name = strdup(name);
       v->prop[v->numprops-1].value = strdup(value);
}

Here is the caller graph for this function:

struct vCard* VCardLoad ( StrBuf vbtext) [read]

Definition at line 107 of file vcard.c.

                                        {
       return vcard_load((char*)ChrPtr(vbtext));
}

Here is the call graph for this function: