webcit/vcard_edit.c

   1 /*
   2  * Copyright (c) 1996-2012 by the citadel.org team
   3  *
   4  * This program is open source software.  You can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License, version 3.
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11  */
  12
  13 #include "webcit.h"
  14 #include "webserver.h"
  15 #include "calendar.h"
  16
  17 CtxType CTX_VCARD = CTX_NONE;
  18 CtxType CTX_VCARD_LIST = CTX_NONE;
  19 CtxType CTX_VCARD_TYPE = CTX_NONE;
  20 long VCEnumCounter = 0;
  21
  22 typedef enum _VCStrEnum {
  23         FlatString,
  24         StringCluster,
  25         PhoneNumber,
  26         EmailAddr,
  27         Address,
  28         Street,
  29         Number,
  30         AliasFor,
  31         Base64BinaryAttachment,
  32         UnKnown,
  33         TerminateList
  34 }VCStrEnum;
  35 typedef struct vcField vcField;
  36 struct vcField {
  37         ConstStr STR;
  38         VCStrEnum Type;
  39         vcField *Sub;
  40         long cval;
  41         long parentCVal;
  42         ConstStr Name;
  43 };
  44
  45 vcField VCStr_Ns [] = {
  46         {{HKEY("last")},   FlatString,    NULL, 0, 0, {HKEY("Last Name")}},
  47         {{HKEY("first")},  FlatString,    NULL, 0, 0, {HKEY("First Name")}},
  48         {{HKEY("middle")}, FlatString,    NULL, 0, 0, {HKEY("Middle Name")}},
  49         {{HKEY("prefix")}, FlatString,    NULL, 0, 0, {HKEY("Prefix")}},
  50         {{HKEY("suffix")}, FlatString,    NULL, 0, 0, {HKEY("Suffix")}},
  51         {{HKEY("")},       TerminateList, NULL, 0, 0, {HKEY("")}}
  52 };
  53
  54 vcField VCStr_Addrs [] = {
  55         {{HKEY("POBox")},    Address,       NULL, 0, 0, {HKEY("PO box")}},
  56         {{HKEY("extadr")},   Address,       NULL, 0, 0, {HKEY("Address")}},
  57         {{HKEY("street")},   Address,       NULL, 0, 0, {HKEY("")}},
  58         {{HKEY("city")},     Address,       NULL, 0, 0, {HKEY("City")}},
  59         {{HKEY("state")},    Address,       NULL, 0, 0, {HKEY("State")}},
  60         {{HKEY("zip")},      Address,       NULL, 0, 0, {HKEY("ZIP code")}},
  61         {{HKEY("country")},  Address,       NULL, 0, 0, {HKEY("Country")}},
  62         {{HKEY("")},         TerminateList, NULL, 0, 0, {HKEY("")}}
  63 };
  64
  65 vcField VCStrE [] = {
  66         {{HKEY("version")},         Number,                 NULL,        0, 0, {HKEY("")}},
  67         {{HKEY("rev")},             Number,                 NULL,        0, 0, {HKEY("")}},
  68         {{HKEY("label")},           FlatString,             NULL,        0, 0, {HKEY("")}},
  69         {{HKEY("uid")},             FlatString,             NULL,        0, 0, {HKEY("")}},
  70         {{HKEY("n")},               StringCluster,          VCStr_Ns,    0, 0, {HKEY("")}}, /* N is name, but only if there's no FN already there */
  71         {{HKEY("fn")},              FlatString,             NULL,        0, 0, {HKEY("")}}, /* FN (full name) is a true 'display name' field */
  72         {{HKEY("title")},           FlatString,             NULL,        0, 0, {HKEY("Title:")}},
  73         {{HKEY("org")},             FlatString,             NULL,        0, 0, {HKEY("Organization:")}},/* organization */
  74         {{HKEY("email")},           EmailAddr,              NULL,        0, 0, {HKEY("E-mail:")}},
  75         {{HKEY("tel")},             PhoneNumber,            NULL,        0, 0, {HKEY("Telephone:")}},
  76         {{HKEY("adr")},             StringCluster,          VCStr_Addrs, 0, 0, {HKEY("Address:")}},
  77         {{HKEY("photo")},           Base64BinaryAttachment, NULL,        0, 0, {HKEY("Photo:")}},
  78         {{HKEY("tel;home")},        PhoneNumber,            NULL,        0, 0, {HKEY(" (home)")}},
  79         {{HKEY("tel;work")},        PhoneNumber,            NULL,        0, 0, {HKEY(" (work)")}},
  80         {{HKEY("tel;fax")},         PhoneNumber,            NULL,        0, 0, {HKEY(" (fax)")}},
  81         {{HKEY("tel;cell")},        PhoneNumber,            NULL,        0, 0, {HKEY(" (cell)")}},
  82         {{HKEY("email;internet")},  EmailAddr,              NULL,        0, 0, {HKEY("E-mail:")}},
  83         {{HKEY("UNKNOWN")},         UnKnown,                NULL,        0, 0, {HKEY("")}},
  84         {{HKEY("")},                TerminateList,          NULL,        0, 0, {HKEY("")}}
  85 };
  86
  87 ConstStr VCStr [] = {
  88         {HKEY("")},
  89         {HKEY("n")}, /* N is name, but only if there's no FN already there */
  90         {HKEY("fn")}, /* FN (full name) is a true 'display name' field */
  91         {HKEY("title")},   /* title */
  92         {HKEY("org")},    /* organization */
  93         {HKEY("email")},
  94         {HKEY("tel")},
  95         {HKEY("work")},
  96         {HKEY("home")},
  97         {HKEY("cell")},
  98         {HKEY("adr")},
  99         {HKEY("photo")},
 100         {HKEY("version")},
 101         {HKEY("rev")},
 102         {HKEY("label")},
 103         {HKEY("uid")}
 104 };
 105
 106 /*
 107  * Address book entry (keep it short and sweet, it's just a quickie lookup
 108  * which we can use to get to the real meat and bones later)
 109  */
 110 typedef struct _addrbookent {
 111         StrBuf *name;
 112         HashList *VC;
 113         long ab_msgnum;         /* message number of address book entry */
 114         StrBuf *msgNoStr;
 115 } addrbookent;
 116
 117 void deleteAbEnt(void *v) {
 118         addrbookent *vc = (addrbookent*)v;
 119         DeleteHash(&vc->VC);
 120         FreeStrBuf(&vc->name);
 121         FreeStrBuf(&vc->msgNoStr);
 122         free(vc);
 123 }
 124
 125 HashList *DefineToToken = NULL;
 126 HashList *VCTokenToDefine = NULL;
 127 HashList *vcNames = NULL; /* todo: fill with the name strings */
 128 vcField* vcfUnknown = NULL;
 129
 130 void RegisterVCardToken(vcField* vf, StrBuf *name, int inTokenCount)
 131 {
 132         if (vf->Type == UnKnown) {
 133                 vcfUnknown = vf;
 134         }
 135         RegisterTokenParamDefine(SKEY(name), vf->cval);
 136         Put(DefineToToken, LKEY(vf->cval), vf, reference_free_handler);
 137         Put(vcNames, LKEY(vf->cval), NewStrBufPlain(CKEY(vf->Name)), HFreeStrBuf);
 138
 139         syslog(LOG_DEBUG, "Token: %s -> %ld, %d",
 140                ChrPtr(name),
 141                vf->cval,
 142                inTokenCount);
 143
 144 }
 145
 146 void autoRegisterTokens(long *enumCounter, vcField* vf, StrBuf *BaseStr, int layer, long parentCVal)
 147 {
 148         int i = 0;
 149         StrBuf *subStr = NewStrBuf();
 150         while (vf[i].STR.len > 0) {
 151                 FlushStrBuf(subStr);
 152                 vf[i].cval = (*enumCounter) ++;
 153                 vf[i].parentCVal = parentCVal;
 154                 StrBufAppendBuf(subStr, BaseStr, 0);
 155                 if (StrLength(subStr) > 0) {
 156                         StrBufAppendBufPlain(subStr, HKEY("."), 0);
 157                 }
 158                 StrBufAppendBufPlain(subStr, CKEY(vf[i].STR), 0);
 159                 if (layer == 0) {
 160                         Put(VCTokenToDefine, CKEY(vf[i].STR), &vf[i], reference_free_handler);
 161                 }
 162                 switch (vf[i].Type) {
 163                 case FlatString:
 164                         break;
 165                 case StringCluster:
 166                 {
 167                         autoRegisterTokens(enumCounter, vf[i].Sub, subStr, 1, vf[i].cval);
 168                 }
 169                 break;
 170                 case PhoneNumber:
 171                         break;
 172                 case EmailAddr:
 173                         break;
 174                 case Street:
 175                         break;
 176                 case Number:
 177                         break;
 178                 case AliasFor:
 179                         break;
 180                 case Base64BinaryAttachment:
 181                         break;
 182                 case TerminateList:
 183                         break;
 184                 case Address:
 185                         break;
 186                 case UnKnown:
 187                         break;
 188                 }
 189                 RegisterVCardToken(&vf[i], subStr, i);
 190                 i++;
 191         }
 192         FreeStrBuf(&subStr);
 193 }
 194
 195 int preeval_vcard_item(WCTemplateToken *Token)
 196 {
 197         WCTemplputParams TPP;
 198         WCTemplputParams *TP;
 199         int searchFieldNo;
 200         StrBuf *Target = NULL;
 201
 202         memset(&TPP, 0, sizeof(WCTemplputParams));
 203         TP = &TPP;
 204         TP->Tokens = Token;
 205         searchFieldNo = GetTemplateTokenNumber(Target, TP, 0, 0);
 206         if (searchFieldNo >= VCEnumCounter) {
 207                 LogTemplateError(NULL, "VCardItem", ERR_PARM1, TP,
 208                                  "Invalid define");
 209                 return 0;
 210         }
 211         return 1;
 212 }
 213
 214 void tmpl_vcard_item(StrBuf *Target, WCTemplputParams *TP)
 215 {
 216         void *vItem;
 217         long searchFieldNo = GetTemplateTokenNumber(Target, TP, 0, 0);
 218         addrbookent *ab = (addrbookent*) CTX(CTX_VCARD);
 219         if (GetHash(ab->VC, LKEY(searchFieldNo), &vItem) && (vItem != NULL)) {
 220                 StrBufAppendTemplate(Target, TP, (StrBuf*) vItem, 1);
 221         }
 222 }
 223
 224 void tmpl_vcard_context_item(StrBuf *Target, WCTemplputParams *TP)
 225 {
 226         void *vItem;
 227         vcField *t = (vcField*) CTX(CTX_VCARD_TYPE);
 228         addrbookent *ab = (addrbookent*) CTX(CTX_VCARD);
 229
 230         if (t == NULL) {
 231                 LogTemplateError(NULL, "VCard item", ERR_NAME, TP,
 232                                  "Missing context");
 233                 return;
 234         }
 235
 236         if (GetHash(ab->VC, LKEY(t->cval), &vItem) && (vItem != NULL)) {
 237                 StrBufAppendTemplate(Target, TP, (StrBuf*) vItem, 0);
 238         }
 239         else {
 240                 LogTemplateError(NULL, "VCard item", ERR_NAME, TP,
 241                                  "Doesn't have that key - did you miss to filter in advance?");
 242         }
 243 }
 244 int preeval_vcard_name_str(WCTemplateToken *Token)
 245 {
 246         WCTemplputParams TPP;
 247         WCTemplputParams *TP;
 248         int searchFieldNo;
 249         StrBuf *Target = NULL;
 250
 251         memset(&TPP, 0, sizeof(WCTemplputParams));
 252         TP = &TPP;
 253         TP->Tokens = Token;
 254         searchFieldNo = GetTemplateTokenNumber(Target, TP, 0, 0);
 255         if (searchFieldNo >= VCEnumCounter) {
 256                 LogTemplateError(NULL, "VCardName", ERR_PARM1, TP,
 257                                  "Invalid define");
 258                 return 0;
 259         }
 260         return 1;
 261 }
 262
 263 void tmpl_vcard_name_str(StrBuf *Target, WCTemplputParams *TP)
 264 {
 265         void *vItem;
 266         long searchFieldNo = GetTemplateTokenNumber(Target, TP, 0, 0);
 267         /* todo: get descriptive string for this vcard type */
 268         if (GetHash(vcNames, LKEY(searchFieldNo), &vItem) && (vItem != NULL)) {
 269                 StrBufAppendTemplate(Target, TP, (StrBuf*) vItem, 1);
 270         }
 271         else {
 272                 LogTemplateError(NULL, "VCard item type", ERR_NAME, TP,
 273                                  "No i18n string for this.");
 274                 return;
 275         }
 276 }
 277
 278 void tmpl_vcard_msgno(StrBuf *Target, WCTemplputParams *TP)
 279 {
 280         addrbookent *ab = (addrbookent*) CTX(CTX_VCARD);
 281         if (ab->msgNoStr == NULL) {
 282                 ab->msgNoStr = NewStrBufPlain(NULL, 64);
 283         }
 284         StrBufPrintf(ab->msgNoStr, "%ld", ab->ab_msgnum);
 285         StrBufAppendTemplate(Target, TP, ab->msgNoStr, 0);
 286 }
 287 void tmpl_vcard_context_name_str(StrBuf *Target, WCTemplputParams *TP)
 288 {
 289         void *vItem;
 290         vcField *t = (vcField*) CTX(CTX_VCARD_TYPE);
 291
 292         if (t == NULL) {
 293                 LogTemplateError(NULL, "VCard item type", ERR_NAME, TP,
 294                                  "Missing context");
 295                 return;
 296         }
 297
 298         if (GetHash(vcNames, LKEY(t->cval), &vItem) && (vItem != NULL)) {
 299                 StrBufAppendTemplate(Target, TP, (StrBuf*) vItem, 1);
 300         }
 301         else {
 302                 LogTemplateError(NULL, "VCard item type", ERR_NAME, TP,
 303                                  "No i18n string for this.");
 304                 return;
 305         }
 306 }
 307
 308 int filter_VC_ByType(const char* key, long len, void *Context, StrBuf *Target, WCTemplputParams *TP)
 309 {
 310         long searchType;
 311         long type = 0;
 312         void *v;
 313         int rc = 0;
 314         vcField *vf = (vcField*) Context;
 315
 316         memcpy(&type, key, sizeof(long));
 317         searchType = GetTemplateTokenNumber(Target, TP, IT_ADDT_PARAM(0), 0);
 318
 319         if (vf->Type == searchType) {
 320                 addrbookent *ab = (addrbookent*) CTX(CTX_VCARD);
 321                 if (GetHash(ab->VC, LKEY(vf->cval), &v) && v != NULL)
 322                         return 1;
 323         }
 324         return rc;
 325 }
 326
 327
 328
 329
 330 HashList *getContextVcard(StrBuf *Target, WCTemplputParams *TP)
 331 {
 332         vcField *vf = (vcField*) CTX(CTX_VCARD_TYPE);
 333         addrbookent *ab = (addrbookent*) CTX(CTX_VCARD);
 334
 335         if ((vf == NULL) || (ab == NULL)) {
 336                 LogTemplateError(NULL, "VCard item type", ERR_NAME, TP,
 337                                  "Need VCard and Vcard type in context");
 338
 339                 return NULL;
 340         }
 341         return ab->VC;
 342 }
 343
 344 int filter_VC_ByContextType(const char* key, long len, void *Context, StrBuf *Target, WCTemplputParams *TP)
 345 {
 346         long searchType;
 347         vcField *vf = (vcField*) CTX(CTX_VCARD_TYPE);
 348
 349         memcpy(&searchType, key, sizeof(long));
 350
 351         if (vf->cval == searchType) {
 352                 return 1;
 353         }
 354         else {
 355                 return 0;
 356         }
 357 }
 358
 359
 360 int conditional_VC_Havetype(StrBuf *Target, WCTemplputParams *TP)
 361 {
 362         addrbookent *ab = (addrbookent*) CTX(CTX_VCARD);
 363         long HaveFieldType = GetTemplateTokenNumber(Target, TP, 2, 0);
 364         int rc = 0;
 365         void *vVCitem;
 366         const char *Key;
 367         long len;
 368         HashPos *it = GetNewHashPos(ab->VC, 0);
 369         while (GetNextHashPos(ab->VC, it, &len, &Key, &vVCitem) &&
 370                (vVCitem != NULL))
 371         {
 372                 void *vvcField;
 373                 long type = 0;
 374                 memcpy(&type, Key, sizeof(long));
 375                 if (GetHash(DefineToToken, LKEY(type), &vvcField) &&
 376                     (vvcField != NULL))
 377                 {
 378                         vcField *t = (vcField*) vvcField;
 379                         if (t && t->Type == HaveFieldType) {
 380                                 rc = 1;
 381                                 break;
 382                         }
 383                 }
 384         }
 385         DeleteHashPos(&it);
 386         return rc;
 387 }
 388
 389
 390
 391 /*
 392  * Helper function for do_addrbook_view()
 393  * Converts a name into a three-letter tab label
 394  */
 395 void nametab(char *tabbuf, long len, char *name) {
 396         stresc(tabbuf, len, name, 0, 0);
 397         tabbuf[0] = toupper(tabbuf[0]);
 398         tabbuf[1] = tolower(tabbuf[1]);
 399         tabbuf[2] = tolower(tabbuf[2]);
 400         tabbuf[3] = 0;
 401 }
 402
 403 wc_mime_attachment *load_vcard(message_summary *Msg)
 404 {
 405         HashPos  *it;
 406         StrBuf *FoundCharset = NewStrBuf();
 407         StrBuf *Error;
 408         void *vMime;
 409         const char *Key;
 410         long len;
 411         wc_mime_attachment *Mime;
 412         wc_mime_attachment *VCMime = NULL;
 413
 414         Msg->MsgBody =  (wc_mime_attachment*) malloc(sizeof(wc_mime_attachment));
 415         memset(Msg->MsgBody, 0, sizeof(wc_mime_attachment));
 416         Msg->MsgBody->msgnum = Msg->msgnum;
 417
 418         load_message(Msg, FoundCharset, &Error);
 419
 420         FreeStrBuf(&FoundCharset);
 421         /* look up the vcard... */
 422         it = GetNewHashPos(Msg->AllAttach, 0);
 423         while (GetNextHashPos(Msg->AllAttach, it, &len, &Key, &vMime) &&
 424                (vMime != NULL))
 425         {
 426                 Mime = (wc_mime_attachment*) vMime;
 427                 if ((strcmp(ChrPtr(Mime->ContentType),
 428                            "text/x-vcard") == 0) ||
 429                     (strcmp(ChrPtr(Mime->ContentType),
 430                             "text/vcard") == 0))
 431                 {
 432                         VCMime = Mime;
 433                         break;
 434                 }
 435         }
 436         DeleteHashPos(&it);
 437         if (VCMime == NULL)
 438                 return NULL;
 439
 440         if (VCMime->Data == NULL)
 441                 MimeLoadData(VCMime);
 442         return VCMime;
 443 }
 444
 445
 446
 447 /*
 448  * Turn a vCard "n" (name) field into something displayable.
 449  */
 450 void vcard_n_prettyize(char *name)
 451 {
 452         char *original_name;
 453         int i, j, len;
 454
 455         original_name = strdup(name);
 456         len = strlen(original_name);
 457         for (i=0; i<5; ++i) {
 458                 if (len > 0) {
 459                         if (original_name[len-1] == ' ') {
 460                                 original_name[--len] = 0;
 461                         }
 462                         if (original_name[len-1] == ';') {
 463                                 original_name[--len] = 0;
 464                         }
 465                 }
 466         }
 467         strcpy(name, "");
 468         j=0;
 469         for (i=0; i<len; ++i) {
 470                 if (original_name[i] == ';') {
 471                         name[j++] = ',';
 472                         name[j++] = ' ';
 473                 }
 474                 else {
 475                         name[j++] = original_name[i];
 476                 }
 477         }
 478         name[j] = '\0';
 479         free(original_name);
 480 }
 481
 482
 483 void PutVcardItem(HashList *thisVC, vcField *thisField, StrBuf *ThisFieldStr, int is_qp, StrBuf *Swap)
 484 {
 485         /* if we have some untagged QP, detect it here. */
 486         if (is_qp || (strstr(ChrPtr(ThisFieldStr), "=?")!=NULL)){
 487                 StrBuf *b;
 488                 StrBuf_RFC822_to_Utf8(Swap, ThisFieldStr, NULL, NULL); /* default charset, current charset */
 489                 b = ThisFieldStr;
 490                 ThisFieldStr = Swap;
 491                 Swap = b;
 492                 FlushStrBuf(Swap);
 493         }
 494         Put(thisVC, LKEY(thisField->cval), ThisFieldStr, HFreeStrBuf);
 495 }
 496 /*
 497  * html print a vcard
 498  * display_vcard() calls this after parsing the textual vCard into
 499  * our 'struct vCard' data object.
 500  *
 501  * Set 'full' to nonzero to display the full card, otherwise it will only
 502  * show a summary line.
 503  *
 504  * This code is a bit ugly, so perhaps an explanation is due: we do this
 505  * in two passes through the vCard fields.  On the first pass, we process
 506  * fields we understand, and then render them in a pretty fashion at the
 507  * end.  Then we make a second pass, outputting all the fields we don't
 508  * understand in a simple two-column name/value format.
 509  * v            the vCard to parse
 510  * msgnum       Citadel message pointer
 511  */
 512 void parse_vcard(StrBuf *Target, struct vCard *v, HashList *VC, wc_mime_attachment *Mime)
 513 {
 514         StrBuf *Val = NULL;
 515         StrBuf *Swap = NULL;
 516         int i, j, k;
 517         char buf[SIZ];
 518         int is_qp = 0;
 519         int is_b64 = 0;
 520         int ntokens, len;
 521         StrBuf *thisname = NULL;
 522         char firsttoken[SIZ];
 523         StrBuf *thisVCToken;
 524         void *vField = NULL;
 525
 526         Swap = NewStrBuf ();
 527         thisname = NewStrBuf();
 528         thisVCToken = NewStrBufPlain(NULL, 63);
 529         for (i=0; i<(v->numprops); ++i) {
 530                 FlushStrBuf(thisVCToken);
 531                 is_qp = 0;
 532                 is_b64 = 0;
 533                 syslog(LOG_DEBUG, "i: %d oneprop: %s - value: %s", i, v->prop[i].name, v->prop[i].value);
 534                 StrBufPlain(thisname, v->prop[i].name, -1);
 535                 StrBufLowerCase(thisname);
 536
 537                 /*len = */extract_token(firsttoken, ChrPtr(thisname), 0, ';', sizeof firsttoken);
 538                 ntokens = num_tokens(ChrPtr(thisname), ';');
 539                 for (j=0, k=0; j < ntokens && k < 10; ++j) {
 540                         /*int evc[10];*/
 541
 542                         len = extract_token(buf, ChrPtr(thisname), j, ';', sizeof buf);
 543                         if (!strcasecmp(buf, "encoding=quoted-printable")) {
 544                                 is_qp = 1;
 545 /*                              remove_token(thisname, j, ';');*/
 546                         }
 547                         else if (!strcasecmp(buf, "encoding=base64")) {
 548                                 is_b64 = 1;
 549 /*                              remove_token(thisname, j, ';');*/
 550                         }
 551                         else{
 552                                 if (StrLength(thisVCToken) > 0) {
 553                                         StrBufAppendBufPlain(thisVCToken, HKEY(";"), 0);
 554                                 }
 555                                 StrBufAppendBufPlain(thisVCToken, buf, len, 0);
 556                                 /*
 557                                 if (GetHash(VCToEnum, buf, len, &V))
 558                                 {
 559                                         evc[k] = (int) V;
 560
 561                                         Put(VC, IKEY(evc), Val, HFreeStrBuf);
 562
 563                                         syslog(LOG_DEBUG, "[%ul] -> k: %d %s - %s", evc, k, buf, VCStr[evc[k]].Key);
 564                                         k++;
 565                                 }
 566 */
 567
 568                         }
 569                 }
 570
 571                 vField = NULL;
 572                 if ((StrLength(thisVCToken) > 0) &&
 573                     GetHash(VCTokenToDefine, SKEY(thisVCToken), &vField) &&
 574                     (vField != NULL)) {
 575                         vcField *thisField = (vcField *)vField;
 576                         StrBuf *ThisFieldStr = NULL;
 577                         syslog(LOG_DEBUG, "got this token: %s, found: %s", ChrPtr(thisVCToken), thisField->STR.Key);
 578                         switch (thisField->Type) {
 579                         case StringCluster: {
 580                                 int j = 0;
 581                                 const char *Pos = NULL;
 582                                 StrBuf *thisArray = NewStrBufPlain(v->prop[i].value, -1);
 583                                 StrBuf *Buf = NewStrBufPlain(NULL, StrLength(thisArray));
 584                                 while (thisField->Sub[j].STR.len > 0) {
 585                                         StrBufExtract_NextToken(Buf, thisArray, &Pos, ';');
 586                                         ThisFieldStr = NewStrBufDup(Buf);
 587
 588                                         PutVcardItem(VC, &thisField->Sub[j], ThisFieldStr, is_qp, Swap);
 589                                         j++;
 590                                 }
 591                                 FreeStrBuf(&thisArray);
 592                                 FreeStrBuf(&Buf);
 593                         }
 594                                 break;
 595                         case Address:
 596                         case FlatString:
 597                         case PhoneNumber:
 598                         case EmailAddr:
 599                         case Street:
 600                         case Number:
 601                         case AliasFor:
 602                                 /* copy over the payload into a StrBuf */
 603                                 ThisFieldStr = NewStrBufPlain(v->prop[i].value, -1);
 604                                 PutVcardItem(VC, thisField, ThisFieldStr, is_qp, Swap);
 605
 606                                 break;
 607                         case Base64BinaryAttachment:
 608                         case TerminateList:
 609                         case UnKnown:
 610                                 break;
 611                         }
 612
 613                 }
 614                 else if (StrLength(thisVCToken) > 0) {
 615                         /* Add it to the UNKNOWN field... */
 616                         void *pv = NULL;
 617                         StrBuf *oldVal;
 618                         GetHash(VC, IKEY(vcfUnknown->cval), &pv);
 619                         oldVal = (StrBuf*) pv;
 620                         if (oldVal == NULL) {
 621                                 oldVal = NewStrBuf();
 622                                 Put(VC, IKEY(vcfUnknown->cval), oldVal, HFreeStrBuf);
 623                         }
 624                         else {
 625                                 StrBufAppendBufPlain(oldVal, HKEY("\n"), 0);
 626                         }
 627
 628                         StrBufAppendBuf(oldVal, thisVCToken, 0);
 629                         StrBufAppendBufPlain(oldVal, HKEY(":"), 0);
 630                         StrBufAppendBufPlain(oldVal, v->prop[i].value, -1, 0);
 631                         continue;
 632                 }
 633
 634                 /* copy over the payload into a StrBuf */
 635                 Val = NewStrBufPlain(v->prop[i].value, -1);
 636
 637                 /* if we have some untagged QP, detect it here. */
 638                 if (is_qp || (strstr(v->prop[i].value, "=?")!=NULL)){
 639                         StrBuf *b;
 640                         StrBuf_RFC822_to_Utf8(Swap, Val, NULL, NULL); /* default charset, current charset */
 641                         b = Val;
 642                         Val = Swap;
 643                         Swap = b;
 644                         FlushStrBuf(Swap);
 645                 }
 646                 else if (is_b64) {
 647                         StrBufDecodeBase64(Val);
 648                 }
 649 #if 0
 650                 syslog(LOG_DEBUG, "-> firsttoken: %s thisname: %s Value: [%s][%s]",
 651                         firsttoken,
 652                        ChrPtr(thisname),
 653                         ChrPtr(Val),
 654                         v->prop[i].value);
 655 #endif
 656                 FreeStrBuf(&Val);
 657         }
 658         FreeStrBuf(&thisname);
 659         FreeStrBuf(&Swap);
 660         FreeStrBuf(&thisVCToken);
 661 }
 662
 663 void tmplput_VCARD_ITEM(StrBuf *Target, WCTemplputParams *TP)
 664 {
 665         addrbookent *ab = CTX(CTX_VCARD);
 666         int evc;
 667         void *vStr;
 668
 669         evc = GetTemplateTokenNumber(Target, TP, 0, -1);
 670         if (evc != -1)
 671         {
 672                 if (GetHash(ab->VC, IKEY(evc), &vStr))
 673                 {
 674                         StrBufAppendTemplate(Target, TP,
 675                                              (StrBuf*) vStr,
 676                                              1);
 677                 }
 678         }
 679
 680 }
 681
 682 HashList *CtxGetVcardList(StrBuf *Target, WCTemplputParams *TP)
 683 {
 684         HashList *pb = CTX(CTX_VCARD_LIST);
 685         return pb;
 686 }
 687
 688 void display_one_vcard (StrBuf *Target, addrbookent *ab, const char *tp_name, size_t tp_name_len)
 689 {
 690         WCTemplputParams *TP = NULL;
 691         WCTemplputParams SubTP;
 692
 693         memset(&SubTP, 0, sizeof(WCTemplputParams));
 694         StackContext(TP, &SubTP, ab, CTX_VCARD, 0, NULL);
 695
 696         DoTemplate(tp_name, tp_name_len, Target, &SubTP);
 697         UnStackContext(&SubTP);
 698 }
 699
 700 /*
 701  * Extract an embedded photo from a vCard for display on the client
 702  */
 703 void display_vcard_photo_img(void)
 704 {
 705         long msgnum = 0L;
 706         StrBuf *vcard;
 707         struct vCard *v;
 708         char *photosrc;
 709         const char *contentType;
 710         wcsession *WCC = WC;
 711
 712         msgnum = StrBufExtract_long(WCC->Hdr->HR.ReqLine, 0, '/');
 713
 714         vcard = load_mimepart(msgnum,"1");
 715         v = VCardLoad(vcard);
 716
 717         photosrc = vcard_get_prop(v, "PHOTO", 1,0,0);
 718         FlushStrBuf(WCC->WBuf);
 719         StrBufAppendBufPlain(WCC->WBuf, photosrc, -1, 0);
 720         if (StrBufDecodeBase64(WCC->WBuf) <= 0) {
 721                 FlushStrBuf(WCC->WBuf);
 722
 723                 hprintf("HTTP/1.1 500 %s\n","Unable to get photo");
 724                 output_headers(0, 0, 0, 0, 0, 0);
 725                 hprintf("Content-Type: text/plain\r\n");
 726                 begin_burst();
 727                 wc_printf(_("Could Not decode vcard photo\n"));
 728                 end_burst();
 729                 return;
 730         }
 731         contentType = GuessMimeType(ChrPtr(WCC->WBuf), StrLength(WCC->WBuf));
 732         http_transmit_thing(contentType, 0);
 733         free(v);
 734         free(photosrc);
 735 }
 736
 737 /*
 738  * Edit the vCard component of a MIME message.
 739  * Supply the message number
 740  * and MIME part number to fetch.  Or, specify -1 for the message number
 741  * to start with a blank card.
 742  */
 743 void do_edit_vcard(long msgnum, char *partnum,
 744                    message_summary *VCMsg,
 745                    wc_mime_attachment *VCAtt,
 746                    const char *return_to,
 747                    const char *force_room) {
 748         WCTemplputParams SubTP;
 749         wcsession *WCC = WC;
 750         message_summary *Msg = NULL;
 751         wc_mime_attachment *VCMime = NULL;
 752         struct vCard *v;
 753         char whatuser[256];
 754         addrbookent ab;
 755
 756         memset(&ab, 0, sizeof(addrbookent));
 757         ab.VC = NewHash(0, lFlathash);
 758         /* Display the form */
 759         output_headers(1, 1, 1, 0, 0, 0);
 760
 761         safestrncpy(whatuser, "", sizeof whatuser);
 762
 763         if ((msgnum >= 0) ||
 764             ((VCMsg != NULL) && (VCAtt != NULL)))
 765         {
 766                 if ((VCMsg == NULL) && (VCAtt == NULL)) {
 767
 768                         Msg = (message_summary *) malloc(sizeof(message_summary));
 769                         memset(Msg, 0, sizeof(message_summary));
 770                         Msg->msgnum = msgnum;
 771                         VCMime = load_vcard(Msg);
 772                         if (VCMime == NULL) {
 773                                 convenience_page("770000", _("Error"), "");/*TODO: important message*/
 774                                 DestroyMessageSummary(Msg);
 775                                 return;
 776                                 DeleteHash(&ab.VC);
 777                         }
 778
 779                         v = VCardLoad(VCMime->Data);
 780                 }
 781                 else {
 782                         v = VCardLoad(VCAtt->Data);
 783                 }
 784
 785                 parse_vcard(WCC->WBuf, v, ab.VC, NULL);
 786
 787
 788                 vcard_free(v);
 789         }
 790
 791         memset(&SubTP, 0, sizeof(WCTemplputParams));
 792         {
 793                 WCTemplputParams *TP = NULL;
 794                 WCTemplputParams SubTP;
 795
 796                 StackContext(TP, &SubTP, &ab, CTX_VCARD, 0, NULL);
 797
 798                 DoTemplate(HKEY("vcard_edit"), WCC->WBuf, &SubTP);
 799                 UnStackContext(&SubTP);
 800         }
 801         DeleteHash(&ab.VC);
 802
 803
 804         wDumpContent(1);
 805         if (Msg != NULL) {
 806                 DestroyMessageSummary(Msg);
 807         }
 808 }
 809
 810
 811 /*
 812  *  commit the edits to the citadel server
 813  */
 814 void edit_vcard(void) {
 815         long msgnum;
 816         char *partnum;
 817
 818         msgnum = lbstr("msgnum");
 819         partnum = bstr("partnum");
 820         do_edit_vcard(msgnum, partnum, NULL, NULL, "", NULL);
 821 }
 822
 823
 824
 825 /*
 826  *  parse edited vcard from the browser
 827  */
 828 void submit_vcard(void) {
 829         struct vCard *v;
 830         char *serialized_vcard;
 831         StrBuf *Buf;
 832         const StrBuf *ForceRoom;
 833         HashList* postVcard;
 834         HashPos *it, *itSub;
 835         const char *Key;
 836         long len;
 837         void *pv;
 838         StrBuf *SubStr;
 839         const StrBuf *s;
 840         const char *Pos = NULL;
 841
 842         if (!havebstr("ok_button")) {
 843                 readloop(readnew, eUseDefault);
 844                 return;
 845         }
 846
 847         if (havebstr("force_room")) {
 848                 ForceRoom = sbstr("force_room");
 849                 if (gotoroom(ForceRoom) != 200) {
 850                         AppendImportantMessage(_("Unable to enter the room to save your message"), -1);
 851                         AppendImportantMessage(HKEY(": "));
 852                         AppendImportantMessage(SKEY(ForceRoom));
 853                         AppendImportantMessage(HKEY("; "));
 854                         AppendImportantMessage(_("Aborting."), -1);
 855
 856                         if (!strcmp(bstr("return_to"), "select_user_to_edit")) {
 857                                 select_user_to_edit(NULL);
 858                         }
 859                         else if (!strcmp(bstr("return_to"), "do_welcome")) {
 860                                 do_welcome();
 861                         }
 862                         else if (!IsEmptyStr(bstr("return_to"))) {
 863                                 http_redirect(bstr("return_to"));
 864                         }
 865                         else {
 866                                 readloop(readnew, eUseDefault);
 867                         }
 868                         return;
 869                 }
 870         }
 871
 872         postVcard = getSubStruct(HKEY("VC"));
 873         if (postVcard == NULL) {
 874                 AppendImportantMessage(_("An error has occurred."), -1);
 875                 edit_vcard();
 876                 return;/*/// more details*/
 877         }
 878
 879         Buf = NewStrBuf();
 880         serv_write(HKEY("ENT0 1|||4\n"));
 881         if (!StrBuf_ServGetln(Buf) && (GetServerStatus(Buf, NULL) != 4))
 882         {
 883                 edit_vcard();
 884                 return;
 885         }
 886
 887         /* Make a vCard structure out of the data supplied in the form */
 888         StrBufPrintf(Buf, "begin:vcard\r\n%s\r\nend:vcard\r\n",
 889                      bstr("extrafields")
 890         );
 891         v = VCardLoad(Buf);     /* Start with the extra fields */
 892         if (v == NULL) {
 893                 AppendImportantMessage(_("An error has occurred."), -1);
 894                 edit_vcard();
 895                 FreeStrBuf(&Buf);
 896                 return;
 897         }
 898
 899         SubStr = NewStrBuf();
 900         it = GetNewHashPos(DefineToToken, 0);
 901         while (GetNextHashPos(DefineToToken, it, &len, &Key, &pv) &&
 902                (pv != NULL))
 903         {
 904                 char buf[32];
 905                 long blen;
 906                 vcField *t = (vcField*) pv;
 907
 908                 if (t->Sub != NULL){
 909                         vcField *Sub;
 910                         FlushStrBuf(SubStr);
 911                         itSub = GetNewHashPos(DefineToToken, 0);
 912                         while (GetNextHashPos(DefineToToken, itSub, &len, &Key, &pv) &&
 913                                (pv != NULL))
 914                         {
 915                                 Sub = (vcField*) pv;
 916                                 if (Sub->parentCVal == t->cval) {
 917                                         if (StrLength(SubStr) > 0)
 918                                                 StrBufAppendBufPlain(SubStr, HKEY(";"), 0);
 919
 920
 921
 922                                         blen = snprintf(buf, sizeof(buf), "%ld", Sub->cval);
 923                                         s = SSubBstr(postVcard, buf, blen);
 924
 925                                         if ((s != NULL) && (StrLength(s) > 0)) {
 926                                                 /// todo: utf8 qp
 927                                                 StrBufAppendBuf(SubStr, s, 0);
 928                                         }
 929                                 }
 930                         }
 931                         if (StrLength(SubStr) > 0) {
 932                                 vcard_add_prop(v, t->STR.Key, ChrPtr(SubStr));
 933                         }
 934                         DeleteHashPos(&itSub);
 935                 }
 936                 else if (t->parentCVal == 0) {
 937                         blen = snprintf(buf, sizeof(buf), "%ld", t->cval);
 938                         s = SSubBstr(postVcard, buf, blen);
 939
 940                         if ((s != NULL) && (StrLength(s) > 0)) {
 941                                 vcard_add_prop(v, t->STR.Key, ChrPtr(s));
 942                         }
 943                 }
 944         }
 945         DeleteHashPos(&it);
 946
 947         s = sbstr("other_inetemail");
 948         if (StrLength(s) > 0) {
 949                 FlushStrBuf(SubStr);
 950                 while (StrBufSipLine(SubStr, s, &Pos), ((Pos!=StrBufNOTNULL) && (Pos!=NULL)) ) {
 951                         if (StrLength(SubStr) > 0) {
 952                                 vcard_add_prop(v, "email;internet", ChrPtr(SubStr));
 953                         }
 954                 }
 955         }
 956
 957         FreeStrBuf(&SubStr);
 958
 959
 960         serialized_vcard = vcard_serialize(v);
 961         vcard_free(v);
 962         if (serialized_vcard == NULL) {
 963                 AppendImportantMessage(_("An error has occurred."), -1);
 964                 edit_vcard();
 965                 FreeStrBuf(&Buf);
 966                 return;
 967         }
 968
 969         printf("%s", serialized_vcard);
 970         serv_write(HKEY("Content-type: text/x-vcard; charset=UTF-8\n"));
 971         serv_write(HKEY("\n"));
 972         serv_printf("%s\r\n", serialized_vcard);
 973         serv_write(HKEY("000\n"));
 974         free(serialized_vcard);
 975
 976         if (!strcmp(bstr("return_to"), "select_user_to_edit")) {
 977                 select_user_to_edit(NULL);
 978         }
 979         else if (!strcmp(bstr("return_to"), "do_welcome")) {
 980                 do_welcome();
 981         }
 982         else if (!IsEmptyStr(bstr("return_to"))) {
 983                 http_redirect(bstr("return_to"));
 984         }
 985         else {
 986                 readloop(readnew, eUseDefault);
 987         }
 988         FreeStrBuf(&Buf);
 989 }
 990
 991
 992
 993 typedef struct _vcardview_struct {
 994         long is_singlecard;
 995         HashList *addrbook;
 996
 997 } vcardview_struct;
 998
 999 int vcard_GetParamsGetServerCall(SharedMessageStatus *Stat,
1000                                  void **ViewSpecific,
1001                                  long oper,
1002                                  char *cmd,
1003                                  long len,
1004                                  char *filter,
1005                                  long flen)
1006 {
1007         vcardview_struct *VS;
1008
1009         VS = (vcardview_struct*) malloc (sizeof(vcardview_struct));
1010         memset(VS, 0, sizeof(vcardview_struct));
1011         *ViewSpecific = (void*)VS;
1012
1013         VS->is_singlecard = ibstr("is_singlecard");
1014         if (VS->is_singlecard != 1) {
1015                 VS->addrbook = NewHash(0, NULL);
1016                 if (oper == do_search) {
1017                         snprintf(cmd, len, "MSGS SEARCH|%s", bstr("query"));
1018                 }
1019                 else {
1020                         strcpy(cmd, "MSGS ALL");
1021                 }
1022                 Stat->maxmsgs = 9999999;
1023         }
1024         return 200;
1025 }
1026
1027 int vcard_LoadMsgFromServer(SharedMessageStatus *Stat,
1028                             void **ViewSpecific,
1029                             message_summary* Msg,
1030                             int is_new,
1031                             int i)
1032 {
1033         vcardview_struct *VS;
1034         wc_mime_attachment *VCMime = NULL;
1035         struct vCard *v;
1036         addrbookent* abEntry;
1037
1038         VS = (vcardview_struct*) *ViewSpecific;
1039
1040         VCMime = load_vcard(Msg);
1041         if (VCMime == NULL)
1042                 return 0;
1043
1044         v = VCardLoad(VCMime->Data);
1045
1046         if (v == NULL) return 0;
1047
1048         abEntry = (addrbookent*) malloc(sizeof(addrbookent));
1049         memset(abEntry, 0, sizeof(addrbookent));
1050         abEntry->name = NewStrBuf();
1051         abEntry->VC = NewHash(0, lFlathash);
1052         abEntry->ab_msgnum = Msg->msgnum;
1053         parse_vcard(WC->WBuf, v, abEntry->VC, VCMime);
1054
1055         display_one_vcard(abEntry->name, abEntry, HKEY("vcard_list_name"));
1056
1057         if (StrLength(abEntry->name) == 0) {
1058                 StrBufPlain(abEntry->name, _("(no name)"), -1);
1059         }
1060
1061         vcard_free(v);
1062
1063         Put(VS->addrbook, SKEY(abEntry->name), abEntry, deleteAbEnt);
1064         return 0;
1065 }
1066
1067
1068 /*
1069  * Render the address book using info we gathered during the scan
1070  *
1071  * addrbook     the addressbook to render
1072  * num_ab       the number of the addressbook
1073  */
1074 static int NAMESPERPAGE = 60;
1075 void do_addrbook_view(vcardview_struct* VS) {
1076         long i = 0;
1077         int displayed = 0;
1078         int bg = 0;
1079         int num_pages = 0;
1080         int tabfirst = 0;
1081         int tablast = 0;
1082         int page = 0;
1083         const char **tablabels;
1084         int num_ab = GetCount(VS->addrbook);
1085         HashList *headlines;
1086         HashPos *it;
1087         wcsession *WCC = WC;
1088
1089         WCTemplputParams *TP = NULL;
1090         WCTemplputParams SubTP;
1091
1092         memset(&SubTP, 0, sizeof(WCTemplputParams));
1093
1094         if (num_ab == 0) {
1095                 do_template("vcard_list_empty");
1096                 return;
1097         }
1098
1099         if (num_ab > 1) {
1100                 ///SortByHashKey(VS->addrbook, 0);
1101         }
1102
1103         num_pages = (GetCount(VS->addrbook) / NAMESPERPAGE) + 1;
1104
1105         tablabels = malloc(num_pages * sizeof (char *));
1106         if (tablabels == NULL) {
1107                 return;
1108         }
1109
1110         headlines = NewHash(0, lFlathash);
1111         for (i=0; i<num_pages; ++i) {
1112                 void *v1 = NULL;
1113                 void *v2 = NULL;
1114                 long hklen1, hklen2;
1115                 const char *c1, *c2;
1116                 StrBuf *headline;
1117                 addrbookent *a1, *a2;
1118
1119                 tabfirst = i * NAMESPERPAGE;
1120                 tablast = tabfirst + NAMESPERPAGE - 1;
1121                 if (tablast > (num_ab - 1)) tablast = (num_ab - 1);
1122
1123                 headline = NewStrBufPlain(NULL, StrLength(v1) + StrLength(v2) + 10);
1124                 if (GetHashAt(VS->addrbook, tabfirst, &hklen1, &c1, &v1)) {
1125                         a1 = (addrbookent*) v1;
1126                         StrBufAppendBuf(headline, a1->name, 0);
1127
1128                         if (GetHashAt(VS->addrbook, tablast, &hklen2, &c2, &v2)) {
1129
1130                                 a2 = (addrbookent*) v2;
1131                                 StrBufAppendBufPlain(headline, HKEY(" - "), 0);
1132                                 StrBufAppendBuf(headline, a2->name, 0);
1133                         }
1134                 }
1135                 tablabels[i] = ChrPtr(headline);
1136                 Put(headlines, LKEY(i), headline, HFreeStrBuf);
1137         }
1138
1139         tabbed_dialog(num_pages, tablabels);
1140         page = (-1);
1141
1142
1143         StackContext(TP, &SubTP, VS->addrbook, CTX_VCARD_LIST, 0, NULL);
1144
1145         DoTemplate(HKEY("vcard_list"), WCC->WBuf, &SubTP);
1146         UnStackContext(&SubTP);
1147 /*
1148         it = GetNewHashPos(VS->addrbook, 0);
1149         for (i=0; i<num_ab; ++i) {
1150                 void *v;
1151                 long hklen;
1152                 const char *key;
1153                 addrbookent *abEnt;
1154                 GetNextHashPos(VS->addrbook, it, &hklen, &key, &v);
1155                 if (v == NULL)
1156                         continue;
1157                 abEnt = (addrbookent *) v;
1158                 if ((i / NAMESPERPAGE) != page) {       / * New tab * /
1159                         page = (i / NAMESPERPAGE);
1160                         if (page > 0) {
1161                                 do_template("vcard_list_section_end");
1162                                 end_tab(page-1, num_pages);
1163                         }
1164                         begin_tab(page, num_pages);
1165                         do_template("vcard_list_section_start");
1166                         displayed = 0;
1167                 }
1168
1169                 if ((displayed % 4) == 0) {
1170                         if (displayed > 0) {
1171                                 do_template("vcard_list_row_end");
1172                         }
1173                         do_template("vcard_list_row_start");
1174                         bg = 1 - bg;
1175                 }
1176
1177
1178                 StackContext(TP, &SubTP, abEnt, CTX_VCARD, 0, NULL);
1179
1180                 DoTemplate(HKEY("vcard_list_entry"), WCC->WBuf, &SubTP);
1181                 UnStackContext(&SubTP);
1182
1183                 ++displayed;
1184         }
1185         DeleteHashPos(&it);
1186 */
1187         /* Placeholders for empty columns at end */
1188         if ((num_ab % 4) != 0) {
1189                 for (i=0; i<(4-(num_ab % 4)); ++i) {
1190                         do_template("vcard_list_cell_end");
1191                 }
1192         }
1193
1194         do_template("vcard_list_section_end");
1195         end_tab((num_pages-1), num_pages);
1196
1197         begin_tab(num_pages, num_pages);
1198         /* FIXME there ought to be something here */
1199         end_tab(num_pages, num_pages);
1200
1201         DeleteHash(&headlines);
1202         free(tablabels);
1203         wDumpContent(1);
1204 }
1205
1206
1207
1208 int vcard_RenderView_or_Tail(SharedMessageStatus *Stat, void **ViewSpecific, long oper)
1209 {
1210         const StrBuf *Mime;
1211         vcardview_struct *VS;
1212
1213         VS = (vcardview_struct*) *ViewSpecific;
1214         if (VS->is_singlecard)
1215                 read_message(WC->WBuf, HKEY("view_message"), lbstr("startmsg"), NULL, &Mime);
1216         else
1217                 do_addrbook_view(VS);   /* Render the address book */
1218         return 0;
1219 }
1220
1221 int vcard_Cleanup(void **ViewSpecific)
1222 {
1223         vcardview_struct *VS;
1224
1225         VS = (vcardview_struct*) *ViewSpecific;
1226         wDumpContent(1);
1227         if ((VS != NULL) &&
1228             (VS->addrbook != NULL))
1229                 DeleteHash(&VS->addrbook);
1230         if (VS != NULL)
1231                 free(VS);
1232
1233         return 0;
1234 }
1235
1236 void render_MIME_VCard(StrBuf *Target, WCTemplputParams *TP, StrBuf *FoundCharset)
1237 {
1238         wc_mime_attachment *Mime = (wc_mime_attachment *) CTX(CTX_MIME_ATACH);
1239         wcsession *WCC = WC;
1240         if (StrLength(Mime->Data) == 0)
1241                 MimeLoadData(Mime);
1242         if (StrLength(Mime->Data) > 0) {
1243                 struct vCard *v;
1244                 StrBuf *Buf;
1245
1246                 Buf = NewStrBuf();
1247                 /** If it's my vCard I can edit it */
1248                 if (    (!strcasecmp(ChrPtr(WCC->CurRoom.name), USERCONFIGROOM))
1249                         || ((StrLength(WCC->CurRoom.name) > 11) &&
1250                             (!strcasecmp(&(ChrPtr(WCC->CurRoom.name)[11]), USERCONFIGROOM)))
1251                         || (WCC->CurRoom.view == VIEW_ADDRESSBOOK)
1252                         ) {
1253                         StrBufAppendPrintf(Buf, "<a href=\"edit_vcard?msgnum=%ld?partnum=%s\">",
1254                                 Mime->msgnum, ChrPtr(Mime->PartNum));
1255                         StrBufAppendPrintf(Buf, "[%s]</a>", _("edit"));
1256                 }
1257
1258                 /* In all cases, display the full card */
1259
1260                 v = VCardLoad(Mime->Data);
1261
1262                 if (v != NULL) {
1263                         HashList *VC;
1264                         addrbookent ab;
1265                         memset(&ab, 0, sizeof(addrbookent));
1266
1267                         ab.VC = NewHash(0, lFlathash);
1268                         ab.ab_msgnum = Mime->msgnum;
1269
1270                         parse_vcard(Target, v, VC, Mime);
1271                         display_one_vcard (Target, &ab, HKEY("vcard_msg_display"));
1272                         DeleteHash(&VC);
1273
1274                 }
1275                 else {
1276                         StrBufPlain(Buf, _("failed to load vcard"), -1);
1277                 }
1278                 FreeStrBuf(&Mime->Data);
1279                 Mime->Data = Buf;
1280         }
1281
1282 }
1283
1284 void
1285 ServerStartModule_VCARD
1286 (void)
1287 {
1288         ///VCToEnum = NewHash(0, NULL);
1289
1290 }
1291
1292 void
1293 ServerShutdownModule_VCARD
1294 (void)
1295 {
1296         DeleteHash(&DefineToToken);
1297         DeleteHash(&vcNames);
1298         DeleteHash(&VCTokenToDefine);
1299         /// DeleteHash(&VCToEnum);
1300 }
1301
1302 void
1303 InitModule_VCARD
1304 (void)
1305 {
1306         StrBuf *Prefix  = NewStrBufPlain(HKEY("VC:"));
1307         DefineToToken   = NewHash(1, lFlathash);
1308         vcNames         = NewHash(1, lFlathash);
1309         VCTokenToDefine = NewHash(1, NULL);
1310         autoRegisterTokens(&VCEnumCounter, VCStrE, Prefix, 0, 0);
1311         FreeStrBuf(&Prefix);
1312
1313         REGISTERTokenParamDefine(NAMESPERPAGE);
1314
1315
1316         RegisterCTX(CTX_VCARD);
1317         RegisterCTX(CTX_VCARD_LIST);
1318         RegisterCTX(CTX_VCARD_TYPE);
1319
1320         RegisterReadLoopHandlerset(
1321                 VIEW_ADDRESSBOOK,
1322                 vcard_GetParamsGetServerCall,
1323                 NULL,
1324                 NULL,
1325                 NULL,
1326                 vcard_LoadMsgFromServer,
1327                 vcard_RenderView_or_Tail,
1328                 vcard_Cleanup);
1329
1330         RegisterIterator("MAIL:VCARDS", 0, NULL, CtxGetVcardList, NULL, NULL, CTX_VCARD, CTX_VCARD_LIST, IT_NOFLAG);
1331
1332
1333         WebcitAddUrlHandler(HKEY("edit_vcard"), "", 0, edit_vcard, 0);
1334         WebcitAddUrlHandler(HKEY("submit_vcard"), "", 0, submit_vcard, 0);
1335         WebcitAddUrlHandler(HKEY("vcardphoto"), "", 0, display_vcard_photo_img, NEED_URL);
1336
1337         RegisterNamespace("VC:ITEM", 2, 2, tmpl_vcard_item, preeval_vcard_item, CTX_VCARD);
1338         RegisterNamespace("VC:CTXITEM", 1, 1, tmpl_vcard_context_item, NULL, CTX_VCARD_TYPE);
1339         RegisterNamespace("VC:NAME", 1, 1, tmpl_vcard_name_str, preeval_vcard_name_str, CTX_VCARD);
1340         RegisterNamespace("VC:MSGNO", 0, 1, tmpl_vcard_msgno, NULL, CTX_VCARD);
1341         RegisterNamespace("VC:CTXNAME", 1, 1, tmpl_vcard_context_name_str, NULL, CTX_VCARD_TYPE);
1342         REGISTERTokenParamDefine(FlatString);
1343         REGISTERTokenParamDefine(StringCluster);
1344         REGISTERTokenParamDefine(PhoneNumber);
1345         REGISTERTokenParamDefine(EmailAddr);
1346         REGISTERTokenParamDefine(Street);
1347         REGISTERTokenParamDefine(Number);
1348         REGISTERTokenParamDefine(AliasFor);
1349         REGISTERTokenParamDefine(Base64BinaryAttachment);
1350         REGISTERTokenParamDefine(TerminateList);
1351         REGISTERTokenParamDefine(Address);
1352
1353         RegisterConditional("VC:HAVE:TYPE",      1, conditional_VC_Havetype, CTX_VCARD);
1354         RegisterFilteredIterator("VC:TYPE", 1, DefineToToken, NULL, NULL, NULL, filter_VC_ByType, CTX_VCARD_TYPE, CTX_VCARD, IT_NOFLAG);
1355         RegisterFilteredIterator("VC:TYPE:ITEMS", 0, NULL, getContextVcard, NULL, NULL, filter_VC_ByContextType, CTX_STRBUF, CTX_VCARD_TYPE, IT_NOFLAG);
1356
1357         RegisterMimeRenderer(HKEY("text/x-vcard"), render_MIME_VCard, 1, 201);
1358         RegisterMimeRenderer(HKEY("text/vcard"), render_MIME_VCard, 1, 200);
1359 }