+
+wc_mime_attachment *load_vcard(message_summary *Msg)
+{
+ HashPos *it;
+ StrBuf *FoundCharset = NewStrBuf();
+ StrBuf *Error;
+ void *vMime;
+ const char *Key;
+ long len;
+ wc_mime_attachment *Mime;
+ wc_mime_attachment *VCMime = NULL;
+
+ Msg->MsgBody = (wc_mime_attachment*) malloc(sizeof(wc_mime_attachment));
+ memset(Msg->MsgBody, 0, sizeof(wc_mime_attachment));
+ Msg->MsgBody->msgnum = Msg->msgnum;
+
+ load_message(Msg, FoundCharset, &Error);
+
+ FreeStrBuf(&FoundCharset);
+ /* look up the vcard... */
+ it = GetNewHashPos(Msg->AllAttach, 0);
+ while (GetNextHashPos(Msg->AllAttach, it, &len, &Key, &vMime) &&
+ (vMime != NULL))
+ {
+ Mime = (wc_mime_attachment*) vMime;
+ if ((strcmp(ChrPtr(Mime->ContentType),
+ "text/x-vcard") == 0) ||
+ (strcmp(ChrPtr(Mime->ContentType),
+ "text/vcard") == 0))
+ {
+ VCMime = Mime;
+ break;
+ }
+ }
+ DeleteHashPos(&it);
+ if (VCMime == NULL)
+ return NULL;
+
+ if (VCMime->Data == NULL)
+ MimeLoadData(VCMime);
+ return VCMime;
+}
+
+/*
+ * fetch the display name off a vCard
+ */
+void fetch_ab_name(message_summary *Msg, char **namebuf) {
+ long len;
+ int i;
+ wc_mime_attachment *VCMime = NULL;
+
+ if (namebuf == NULL) return;
+
+ VCMime = load_vcard(Msg);
+ if (VCMime == NULL)
+ return;
+
+ /* Grab the name off the card */
+ display_vcard(WC->WBuf, VCMime, 0, 0, namebuf, Msg->msgnum);
+
+ if (*namebuf != NULL) {
+ lastfirst_firstlast(*namebuf);
+ striplt(*namebuf);
+ len = strlen(*namebuf);
+ for (i=0; i<len; ++i) {
+ if ((*namebuf)[i] != ';') return;
+ }
+ free (*namebuf);
+ (*namebuf) = strdup(_("(no name)"));
+ }
+ else {
+ (*namebuf) = strdup(_("(no name)"));
+ }
+}
+
+
+
+/*
+ * Turn a vCard "n" (name) field into something displayable.
+ */
+void vcard_n_prettyize(char *name)
+{
+ char *original_name;
+ int i, j, len;
+
+ original_name = strdup(name);
+ len = strlen(original_name);
+ for (i=0; i<5; ++i) {
+ if (len > 0) {
+ if (original_name[len-1] == ' ') {
+ original_name[--len] = 0;
+ }
+ if (original_name[len-1] == ';') {
+ original_name[--len] = 0;
+ }
+ }
+ }
+ strcpy(name, "");
+ j=0;
+ for (i=0; i<len; ++i) {
+ if (original_name[i] == ';') {
+ name[j++] = ',';
+ name[j++] = ' ';
+ }
+ else {
+ name[j++] = original_name[i];
+ }
+ }
+ name[j] = '\0';
+ free(original_name);
+}
+
+
+
+
+/*
+ * preparse a vcard name
+ * display_vcard() calls this after parsing the textual vCard into
+ * our 'struct vCard' data object.
+ * This gets called instead of display_parsed_vcard() if we are only looking
+ * to extract the person's name instead of displaying the card.
+ */
+void fetchname_parsed_vcard(struct vCard *v, char **storename) {
+ char *name;
+ char *prop;
+ char buf[SIZ];
+ int j, n, len;
+ int is_qp = 0;
+ int is_b64 = 0;
+
+ *storename = NULL;
+
+ name = vcard_get_prop(v, "n", 1, 0, 0);
+ if (name != NULL) {
+ len = strlen(name);
+ prop = vcard_get_prop(v, "n", 1, 0, 1);
+ n = num_tokens(prop, ';');
+
+ for (j=0; j<n; ++j) {
+ extract_token(buf, prop, j, ';', sizeof buf);
+ if (!strcasecmp(buf, "encoding=quoted-printable")) {
+ is_qp = 1;
+ }
+ if (!strcasecmp(buf, "encoding=base64")) {
+ is_b64 = 1;
+ }
+ }
+ if (is_qp) {
+ /* %ff can become 6 bytes in utf8 */
+ *storename = malloc(len * 2 + 3);
+ j = CtdlDecodeQuotedPrintable(
+ *storename, name,
+ len);
+ (*storename)[j] = 0;
+ }
+ else if (is_b64) {
+ /* ff will become one byte.. */
+ *storename = malloc(len + 50);
+ CtdlDecodeBase64(
+ *storename, name,
+ len);
+ }
+ else {
+ size_t len;
+
+ len = strlen (name);
+
+ *storename = malloc(len + 3); /* \0 + eventualy missing ', '*/
+ memcpy(*storename, name, len + 1);
+ }
+ /* vcard_n_prettyize(storename); */
+ }
+
+}
+
+
+
+
+void PutVcardItem(HashList *thisVC, vcField *thisField, StrBuf *ThisFieldStr, int is_qp, StrBuf *Swap)
+{
+ /* if we have some untagged QP, detect it here. */
+ if (is_qp || (strstr(ChrPtr(ThisFieldStr), "=?")!=NULL)){
+ StrBuf *b;
+ StrBuf_RFC822_to_Utf8(Swap, ThisFieldStr, NULL, NULL); /* default charset, current charset */
+ b = ThisFieldStr;
+ ThisFieldStr = Swap;
+ Swap = b;
+ FlushStrBuf(Swap);
+ }
+ Put(thisVC, LKEY(thisField->cval), ThisFieldStr, HFreeStrBuf);
+}
+/*
+ * html print a vcard
+ * display_vcard() calls this after parsing the textual vCard into
+ * our 'struct vCard' data object.
+ *
+ * Set 'full' to nonzero to display the full card, otherwise it will only
+ * show a summary line.
+ *
+ * This code is a bit ugly, so perhaps an explanation is due: we do this
+ * in two passes through the vCard fields. On the first pass, we process
+ * fields we understand, and then render them in a pretty fashion at the
+ * end. Then we make a second pass, outputting all the fields we don't
+ * understand in a simple two-column name/value format.
+ * v the vCard to display
+ * full display all items of the vcard?
+ * msgnum Citadel message pointer
+ */
+void parse_vcard(StrBuf *Target, struct vCard *v, HashList *VC, int full, wc_mime_attachment *Mime)
+{
+ StrBuf *Val = NULL;
+ StrBuf *Swap = NULL;
+ int i, j, k;
+ char buf[20]; //SIZ];
+ int is_qp = 0;
+ int is_b64 = 0;
+ int ntokens, len;
+ StrBuf *thisname = NULL;
+ char firsttoken[20]; ///SIZ];
+ //void *V;
+ StrBuf *thisVCToken;
+ void *vField = NULL;
+
+ Swap = NewStrBuf ();
+ thisname = NewStrBuf();
+ thisVCToken = NewStrBufPlain(NULL, 63);
+ for (i=0; i<(v->numprops); ++i) {
+ FlushStrBuf(thisVCToken);
+ is_qp = 0;
+ is_b64 = 0;
+ syslog(LOG_DEBUG, "i: %d oneprop: %s - value: %s", i, v->prop[i].name, v->prop[i].value);
+ StrBufPlain(thisname, v->prop[i].name, -1);
+ StrBufLowerCase(thisname);
+
+ /*len = */extract_token(firsttoken, ChrPtr(thisname), 0, ';', sizeof firsttoken);
+ ntokens = num_tokens(ChrPtr(thisname), ';');
+ for (j=0, k=0; j < ntokens && k < 10; ++j) {
+ ///int evc[10];
+
+ len = extract_token(buf, ChrPtr(thisname), j, ';', sizeof buf);
+ if (!strcasecmp(buf, "encoding=quoted-printable")) {
+ is_qp = 1;
+/* remove_token(thisname, j, ';');*/
+ }
+ else if (!strcasecmp(buf, "encoding=base64")) {
+ is_b64 = 1;
+/* remove_token(thisname, j, ';');*/
+ }
+ else{
+ if (StrLength(thisVCToken) > 0) {
+ StrBufAppendBufPlain(thisVCToken, HKEY(";"), 0);
+ }
+ StrBufAppendBufPlain(thisVCToken, buf, len, 0);
+ /*
+ if (GetHash(VCToEnum, buf, len, &V))
+ {
+ evc[k] = (int) V;
+
+ Put(VC, IKEY(evc), Val, HFreeStrBuf);
+
+ syslog(LOG_DEBUG, "[%ul] -> k: %d %s - %s", evc, k, buf, VCStr[evc[k]].Key);
+ k++;
+ }
+*/
+
+ }
+ }
+
+ vField = NULL;
+ if ((StrLength(thisVCToken) > 0) &&
+ GetHash(VCTokenToDefine, SKEY(thisVCToken), &vField) &&
+ (vField != NULL)) {
+ vcField *thisField = (vcField *)vField;
+ StrBuf *ThisFieldStr = NULL;
+ syslog(LOG_DEBUG, "got this token: %s, found: %s", ChrPtr(thisVCToken), thisField->STR.Key);
+ switch (thisField->Type) {
+ case StringCluster: {
+ int j = 0;
+ const char *Pos = NULL;
+ StrBuf *thisArray = NewStrBufPlain(v->prop[i].value, -1);
+ StrBuf *Buf = NewStrBufPlain(NULL, StrLength(thisArray));
+ while (thisField->Sub[j].STR.len > 0) {
+ StrBufExtract_NextToken(Buf, thisArray, &Pos, ';');
+ ThisFieldStr = NewStrBufDup(Buf);
+
+ PutVcardItem(VC, &thisField->Sub[j], ThisFieldStr, is_qp, Swap);
+ j++;
+ }
+ FreeStrBuf(&thisArray);
+ FreeStrBuf(&Buf);
+ }
+ break;
+ case Address:
+ case FlatString:
+ case PhoneNumber:
+ case EmailAddr:
+ case Street:
+ case Number:
+ case AliasFor:
+ /* copy over the payload into a StrBuf */
+ ThisFieldStr = NewStrBufPlain(v->prop[i].value, -1);
+ PutVcardItem(VC, thisField, ThisFieldStr, is_qp, Swap);
+
+ break;
+ case Base64BinaryAttachment:
+ case TerminateList:
+ break;
+ }
+
+ }
+ /* copy over the payload into a StrBuf */
+ Val = NewStrBufPlain(v->prop[i].value, -1);
+
+ /* if we have some untagged QP, detect it here. */
+ if (is_qp || (strstr(v->prop[i].value, "=?")!=NULL)){
+ StrBuf *b;
+ StrBuf_RFC822_to_Utf8(Swap, Val, NULL, NULL); /* default charset, current charset */
+ b = Val;
+ Val = Swap;
+ Swap = b;
+ FlushStrBuf(Swap);
+ }
+ else if (is_b64) {
+ StrBufDecodeBase64(Val);
+
+ }
+#if 0
+ syslog(LOG_DEBUG, "-> firsttoken: %s thisname: %s Value: [%s][%s]",
+ firsttoken,
+ ChrPtr(thisname),
+ ChrPtr(Val),
+ v->prop[i].value);
+ if (GetHash(VCToEnum, firsttoken, strlen(firsttoken), &V))
+ {
+ eVC evc = (eVC) V;
+ Put(VC, IKEY(evc), Val, HFreeStrBuf);
+ syslog(LOG_DEBUG, "[%ul]\n", evc);
+ Val = NULL;
+ }
+ else
+ syslog(LOG_DEBUG, "[]\n");
+/*
+TODO: check for layer II
+ else
+ {
+ long max = num_tokens(thisname, ';');
+ firsttoken[len] = '_';
+
+ for (j = 0; j < max; j++) {
+// firsttoken[len]
+
+ extract_token(buf, thisname, j, ';', sizeof (buf));
+ if (!strcasecmp(buf, "tel"))
+ strcat(phone, "");
+ else if (!strcasecmp(buf, "work"))
+ strcat(phone, _(" (work)"));
+ else if (!strcasecmp(buf, "home"))
+ strcat(phone, _(" (home)"));
+ else if (!strcasecmp(buf, "cell"))
+ strcat(phone, _(" (cell)"));
+ else {
+ strcat(phone, " (");
+ strcat(phone, buf);
+ strcat(phone, ")");
+ }
+ }
+ }
+
+ }
+*/
+#endif
+ FreeStrBuf(&Val);
+ ////free(thisname);
+ /// thisname = NULL;
+ }
+ FreeStrBuf(&thisname);
+ FreeStrBuf(&Swap);
+ FreeStrBuf(&thisVCToken);
+}
+
+void tmplput_VCARD_ITEM(StrBuf *Target, WCTemplputParams *TP)
+{
+ HashList *VC = CTX(CTX_VCARD);
+ int evc;
+ void *vStr;
+
+ evc = GetTemplateTokenNumber(Target, TP, 0, -1);
+ if (evc != -1)
+ {
+ if (GetHash(VC, IKEY(evc), &vStr))
+ {
+ StrBufAppendTemplate(Target, TP,
+ (StrBuf*) vStr,
+ 1);
+ }
+ }
+
+}
+
+void display_one_vcard (StrBuf *Target, struct vCard *v, int full, wc_mime_attachment *Mime)
+{
+ HashList *VC; WCTemplputParams SubTP;
+
+ memset(&SubTP, 0, sizeof(WCTemplputParams));
+
+
+ VC = NewHash(0, lFlathash);
+ parse_vcard(Target, v, VC, full, Mime);
+
+ {
+ WCTemplputParams *TP = NULL;
+ WCTemplputParams SubTP;
+ StackContext(TP, &SubTP, VC, CTX_VCARD, 0, NULL);
+
+ DoTemplate(HKEY("vcard_msg_display"), Target, &SubTP);
+ UnStackContext(&SubTP);
+ }
+ DeleteHash(&VC);
+}
+
+
+
+/*
+ * Display a textual vCard
+ * (Converts to a vCard object and then calls the actual display function)
+ * Set 'full' to nonzero to display the whole card instead of a one-liner.
+ * Or, if "storename" is non-NULL, just store the person's name in that
+ * buffer instead of displaying the card at all.
+ *
+ * vcard_source the buffer containing the vcard text
+ * alpha Display only if name begins with this letter of the alphabet
+ * full Display the full vCard (otherwise just the display name)
+ * storename If not NULL, also store the display name here
+ * msgnum Citadel message pointer
+ */
+void display_vcard(StrBuf *Target,
+ wc_mime_attachment *Mime,
+ char alpha,
+ int full,
+ char **storename,
+ long msgnum)
+{
+ struct vCard *v;
+ char *name;
+ StrBuf *Buf;
+ StrBuf *Buf2;
+ char this_alpha = 0;
+
+ v = VCardLoad(Mime->Data);
+
+ if (v == NULL) return;
+
+ name = vcard_get_prop(v, "n", 1, 0, 0);
+ if (name != NULL) {
+ Buf = NewStrBufPlain(name, -1);
+ Buf2 = NewStrBufPlain(NULL, StrLength(Buf));
+ StrBuf_RFC822_to_Utf8(Buf2, Buf, WC->DefaultCharset, NULL);
+ this_alpha = ChrPtr(Buf)[0];
+ FreeStrBuf(&Buf);
+ FreeStrBuf(&Buf2);
+ }
+
+ if (storename != NULL) {
+ fetchname_parsed_vcard(v, storename);
+ }
+ else if ((alpha == 0) ||
+ ((isalpha(alpha)) && (tolower(alpha) == tolower(this_alpha))) ||
+ ((!isalpha(alpha)) && (!isalpha(this_alpha)))
+ )
+ {
+ display_one_vcard (Target, v, full, Mime);
+ }
+
+ vcard_free(v);
+}
+
+
+
+/*
+ * Render the address book using info we gathered during the scan
+ *
+ * addrbook the addressbook to render
+ * num_ab the number of the addressbook
+ */
+void do_addrbook_view(addrbookent *addrbook, int num_ab) {
+ int i = 0;
+ int displayed = 0;
+ int bg = 0;
+ static int NAMESPERPAGE = 60;
+ int num_pages = 0;
+ int tabfirst = 0;
+ char tabfirst_label[64];
+ int tablast = 0;
+ char tablast_label[64];
+ char this_tablabel[64];
+ int page = 0;
+ char **tablabels;
+
+ if (num_ab == 0) {
+ wc_printf("<br><br><br><div align=\"center\"><i>");
+ wc_printf(_("This address book is empty."));
+ wc_printf("</i></div>\n");
+ return;
+ }
+
+ if (num_ab > 1) {
+ qsort(addrbook, num_ab, sizeof(addrbookent), abcmp);
+ }
+
+ num_pages = (num_ab / NAMESPERPAGE) + 1;
+
+ tablabels = malloc(num_pages * sizeof (char *));
+ if (tablabels == NULL) {
+ wc_printf("<br><br><br><div align=\"center\"><i>");
+ wc_printf(_("An internal error has occurred."));
+ wc_printf("</i></div>\n");
+ return;
+ }
+
+ for (i=0; i<num_pages; ++i) {
+ tabfirst = i * NAMESPERPAGE;
+ tablast = tabfirst + NAMESPERPAGE - 1;
+ if (tablast > (num_ab - 1)) tablast = (num_ab - 1);
+ nametab(tabfirst_label, 64, addrbook[tabfirst].ab_name);
+ nametab(tablast_label, 64, addrbook[tablast].ab_name);
+ sprintf(this_tablabel, "%s - %s", tabfirst_label, tablast_label);
+ tablabels[i] = strdup(this_tablabel);
+ }
+
+ tabbed_dialog(num_pages, tablabels);
+ page = (-1);
+
+ for (i=0; i<num_ab; ++i) {
+
+ if ((i / NAMESPERPAGE) != page) { /* New tab */
+ page = (i / NAMESPERPAGE);
+ if (page > 0) {
+ wc_printf("</tr></table>\n");
+ end_tab(page-1, num_pages);
+ }
+ begin_tab(page, num_pages);
+ wc_printf("<table border=\"0\" cellspacing=\"0\" cellpadding=\"3\" width=\"100%%\">\n");
+ displayed = 0;
+ }
+
+ if ((displayed % 4) == 0) {
+ if (displayed > 0) {
+ wc_printf("</tr>\n");
+ }
+ bg = 1 - bg;
+ wc_printf("<tr bgcolor=\"#%s\">",
+ (bg ? "dddddd" : "ffffff")
+ );
+ }
+
+ wc_printf("<td>");
+
+ wc_printf("<a href=\"readfwd?startmsg=%ld?is_singlecard=1",
+ addrbook[i].ab_msgnum);
+ wc_printf("?maxmsgs=1?is_summary=0?alpha=%s\">", bstr("alpha"));
+ vcard_n_prettyize(addrbook[i].ab_name);
+ escputs(addrbook[i].ab_name);
+ wc_printf("</a></td>\n");
+ ++displayed;
+ }
+
+ /* Placeholders for empty columns at end */
+ if ((num_ab % 4) != 0) {
+ for (i=0; i<(4-(num_ab % 4)); ++i) {
+ wc_printf("<td> </td>");
+ }
+ }
+
+ wc_printf("</tr></table>\n");
+ end_tab((num_pages-1), num_pages);
+
+ begin_tab(num_pages, num_pages);
+ /* FIXME there ought to be something here */
+ end_tab(num_pages, num_pages);
+
+ for (i=0; i<num_pages; ++i) {
+ free(tablabels[i]);
+ }
+ free(tablabels);
+}
+
+
+
+
+/*
+ * Edit the vCard component of a MIME message.