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_TYPE = CTX_NONE;
  19 long VCEnumCounter = 0;
  20
  21 typedef enum _VCStrEnum {
  22         FlatString,
  23         StringCluster,
  24         PhoneNumber,
  25         EmailAddr,
  26         Address,
  27         Street,
  28         Number,
  29         AliasFor,
  30         Base64BinaryAttachment,
  31         TerminateList
  32 }VCStrEnum;
  33 typedef struct vcField vcField;
  34 struct vcField {
  35         ConstStr STR;
  36         VCStrEnum Type;
  37         vcField *Sub;
  38         long cval;
  39         ConstStr Name;
  40 };
  41
  42 vcField VCStr_Ns [] = {
  43         {{HKEY("last")},   FlatString,    NULL, 0, {HKEY("Last Name")}},
  44         {{HKEY("first")},  FlatString,    NULL, 0, {HKEY("First Name")}},
  45         {{HKEY("middle")}, FlatString,    NULL, 0, {HKEY("Middle Name")}},
  46         {{HKEY("prefix")}, FlatString,    NULL, 0, {HKEY("Prefix")}},
  47         {{HKEY("suffix")}, FlatString,    NULL, 0, {HKEY("Suffix")}},
  48         {{HKEY("")},       TerminateList, NULL, 0, {HKEY("")}}
  49 };
  50
  51 vcField VCStr_Addrs [] = {
  52         {{HKEY("POBox")},    Address,    NULL, 0, {HKEY("PO box")}},
  53         {{HKEY("address")},  Address,    NULL, 0, {HKEY("Address")}},
  54         {{HKEY("address2")}, Address,    NULL, 0, {HKEY("")}},
  55         {{HKEY("city")},     Address,    NULL, 0, {HKEY("City")}},
  56         {{HKEY("state")},    Address,    NULL, 0, {HKEY("State")}},
  57         {{HKEY("zip")},      Address,    NULL, 0, {HKEY("ZIP code")}},
  58         {{HKEY("country")},  Address,    NULL, 0, {HKEY("Country")}},
  59         {{HKEY("")},         TerminateList, NULL, 0, {HKEY("")}}
  60 };
  61
  62 vcField VCStrE [] = {
  63         {{HKEY("version")},         Number,                 NULL,        0, {HKEY("")}},
  64         {{HKEY("rev")},             Number,                 NULL,        0, {HKEY("")}},
  65         {{HKEY("label")},           FlatString,             NULL,        0, {HKEY("")}},
  66         {{HKEY("uid")},             FlatString,             NULL,        0, {HKEY("")}},
  67         {{HKEY("n")},               StringCluster,          VCStr_Ns,    0, {HKEY("")}}, /* N is name, but only if there's no FN already there */
  68         {{HKEY("fn")},              FlatString,             NULL,        0, {HKEY("")}}, /* FN (full name) is a true 'display name' field */
  69         {{HKEY("title")},           FlatString,             NULL,        0, {HKEY("Title:")}},
  70         {{HKEY("org")},             FlatString,             NULL,        0, {HKEY("Organization:")}},/* organization */
  71         {{HKEY("email")},           EmailAddr,              NULL,        0, {HKEY("E-mail:")}},
  72         {{HKEY("tel")},             PhoneNumber,            NULL,        0, {HKEY("Telephone:")}},
  73         {{HKEY("adr")},             StringCluster,          VCStr_Addrs, 0, {HKEY("Address:")}},
  74         {{HKEY("photo")},           Base64BinaryAttachment, NULL,        0, {HKEY("Photo:")}},
  75         {{HKEY("tel;home")},        PhoneNumber,            NULL,        0, {HKEY(" (home)")}},
  76         {{HKEY("tel;work")},        PhoneNumber,            NULL,        0, {HKEY(" (work)")}},
  77         {{HKEY("tel;fax")},         PhoneNumber,            NULL,        0, {HKEY(" (fax)")}},
  78         {{HKEY("tel;cell")},        PhoneNumber,            NULL,        0, {HKEY(" (cell)")}},
  79         {{HKEY("email;internet")},  EmailAddr,              NULL,        0, {HKEY("E-mail:")}},
  80         {{HKEY("")},                TerminateList,          NULL,        0, {HKEY("")}}
  81 };
  82
  83 ConstStr VCStr [] = {
  84         {HKEY("")},
  85         {HKEY("n")}, /* N is name, but only if there's no FN already there */
  86         {HKEY("fn")}, /* FN (full name) is a true 'display name' field */
  87         {HKEY("title")},   /* title */
  88         {HKEY("org")},    /* organization */
  89         {HKEY("email")},
  90         {HKEY("tel")},
  91         {HKEY("work")},
  92         {HKEY("home")},
  93         {HKEY("cell")},
  94         {HKEY("adr")},
  95         {HKEY("photo")},
  96         {HKEY("version")},
  97         {HKEY("rev")},
  98         {HKEY("label")},
  99         {HKEY("uid")}
 100 };
 101
 102
 103 HashList *DefineToToken = NULL;
 104 HashList *VCTokenToDefine = NULL;
 105 HashList *vcNames = NULL; /* todo: fill with the name strings */
 106
 107
 108 void RegisterVCardToken(vcField* vf, StrBuf *name, int inTokenCount)
 109 {
 110         RegisterTokenParamDefine(SKEY(name), vf->cval);
 111         Put(DefineToToken, LKEY(vf->cval), vf, reference_free_handler);
 112         Put(vcNames, LKEY(vf->cval), NewStrBufPlain(CKEY(vf->Name)), HFreeStrBuf);
 113
 114         syslog(LOG_DEBUG, "Token: %s -> %ld, %d",
 115                ChrPtr(name),
 116                vf->cval,
 117                inTokenCount);
 118
 119 }
 120
 121 void autoRegisterTokens(long *enumCounter, vcField* vf, StrBuf *BaseStr, int layer)
 122 {
 123         int i = 0;
 124         StrBuf *subStr = NewStrBuf();
 125         while (vf[i].STR.len > 0) {
 126                 FlushStrBuf(subStr);
 127                 vf[i].cval = (*enumCounter) ++;
 128                 StrBufAppendBuf(subStr, BaseStr, 0);
 129                 if (StrLength(subStr) > 0) {
 130                         StrBufAppendBufPlain(subStr, HKEY("."), 0);
 131                 }
 132                 StrBufAppendBufPlain(subStr, CKEY(vf[i].STR), 0);
 133                 if (layer == 0) {
 134                         Put(VCTokenToDefine, CKEY(vf[i].STR), &vf[i], reference_free_handler);
 135                 }
 136                 switch (vf[i].Type) {
 137                 case FlatString:
 138                         break;
 139                 case StringCluster:
 140                 {
 141                         autoRegisterTokens(enumCounter, vf[i].Sub, subStr, 1);
 142                         i++;
 143                         continue;
 144                 }
 145                 break;
 146                 case PhoneNumber:
 147                         break;
 148                 case EmailAddr:
 149                         break;
 150                 case Street:
 151                         break;
 152                 case Number:
 153                         break;
 154                 case AliasFor:
 155                         break;
 156                 case Base64BinaryAttachment:
 157                         break;
 158                 case TerminateList:
 159                         break;
 160                 case Address:
 161                         break;
 162                 }
 163                 RegisterVCardToken(&vf[i], subStr, i);
 164                 i++;
 165         }
 166         FreeStrBuf(&subStr);
 167 }
 168
 169 int preeval_vcard_item(WCTemplateToken *Token)
 170 {
 171         WCTemplputParams TPP;
 172         WCTemplputParams *TP;
 173         int searchFieldNo;
 174         StrBuf *Target = NULL;
 175
 176         memset(&TPP, 0, sizeof(WCTemplputParams));
 177         TP = &TPP;
 178         TP->Tokens = Token;
 179         searchFieldNo = GetTemplateTokenNumber(Target, TP, 0, 0);
 180         if (searchFieldNo >= VCEnumCounter) {
 181                 LogTemplateError(NULL, "VCardItem", ERR_PARM1, TP,
 182                                  "Invalid define");
 183                 return 0;
 184         }
 185         return 1;
 186 }
 187
 188 void tmpl_vcard_item(StrBuf *Target, WCTemplputParams *TP)
 189 {
 190         void *vItem;
 191         long searchFieldNo = GetTemplateTokenNumber(Target, TP, 0, 0);
 192         HashList *vc = (HashList*) CTX(CTX_VCARD);
 193         if (GetHash(vc, LKEY(searchFieldNo), &vItem) && (vItem != NULL)) {
 194                 StrBufAppendTemplate(Target, TP, (StrBuf*) vItem, 1);
 195         }
 196 }
 197
 198 void tmpl_vcard_context_item(StrBuf *Target, WCTemplputParams *TP)
 199 {
 200         void *vItem;
 201         vcField *t = (vcField*) CTX(CTX_VCARD_TYPE);
 202         HashList *vc = (HashList*) CTX(CTX_VCARD);
 203
 204         if (t == NULL) {
 205                 LogTemplateError(NULL, "VCard item", ERR_NAME, TP,
 206                                  "Missing context");
 207                 return;
 208         }
 209
 210         if (GetHash(vc, LKEY(t->cval), &vItem) && (vItem != NULL)) {
 211                 StrBufAppendTemplate(Target, TP, (StrBuf*) vItem, 0);
 212         }
 213         else {
 214                 LogTemplateError(NULL, "VCard item", ERR_NAME, TP,
 215                                  "Doesn't have that key - did you miss to filter in advance?");
 216         }
 217 }
 218 int preeval_vcard_name_str(WCTemplateToken *Token)
 219 {
 220         WCTemplputParams TPP;
 221         WCTemplputParams *TP;
 222         int searchFieldNo;
 223         StrBuf *Target = NULL;
 224
 225         memset(&TPP, 0, sizeof(WCTemplputParams));
 226         TP = &TPP;
 227         TP->Tokens = Token;
 228         searchFieldNo = GetTemplateTokenNumber(Target, TP, 0, 0);
 229         if (searchFieldNo >= VCEnumCounter) {
 230                 LogTemplateError(NULL, "VCardName", ERR_PARM1, TP,
 231                                  "Invalid define");
 232                 return 0;
 233         }
 234         return 1;
 235 }
 236
 237 void tmpl_vcard_name_str(StrBuf *Target, WCTemplputParams *TP)
 238 {
 239         void *vItem;
 240         long searchFieldNo = GetTemplateTokenNumber(Target, TP, 0, 0);
 241         /* todo: get descriptive string for this vcard type */
 242         if (GetHash(vcNames, LKEY(searchFieldNo), &vItem) && (vItem != NULL)) {
 243                 StrBufAppendTemplate(Target, TP, (StrBuf*) vItem, 1);
 244         }
 245         else {
 246                 LogTemplateError(NULL, "VCard item type", ERR_NAME, TP,
 247                                  "No i18n string for this.");
 248                 return;
 249         }
 250 }
 251
 252 void tmpl_vcard_context_name_str(StrBuf *Target, WCTemplputParams *TP)
 253 {
 254         void *vItem;
 255         vcField *t = (vcField*) CTX(CTX_VCARD_TYPE);
 256
 257         if (t == NULL) {
 258                 LogTemplateError(NULL, "VCard item type", ERR_NAME, TP,
 259                                  "Missing context");
 260                 return;
 261         }
 262
 263         if (GetHash(vcNames, LKEY(t->cval), &vItem) && (vItem != NULL)) {
 264                 StrBufAppendTemplate(Target, TP, (StrBuf*) vItem, 1);
 265         }
 266         else {
 267                 LogTemplateError(NULL, "VCard item type", ERR_NAME, TP,
 268                                  "No i18n string for this.");
 269                 return;
 270         }
 271 }
 272
 273 int filter_VC_ByType(const char* key, long len, void *Context, StrBuf *Target, WCTemplputParams *TP)
 274 {
 275         long searchType;
 276         long type = 0;
 277         void *v;
 278         int rc = 0;
 279         vcField *vf = (vcField*) Context;
 280
 281         memcpy(&type, key, sizeof(long));
 282         searchType = GetTemplateTokenNumber(Target, TP, IT_ADDT_PARAM(0), 0);
 283
 284         if (vf->Type == searchType) {
 285                 HashList *vc = (HashList*) CTX(CTX_VCARD);
 286                 if (GetHash(vc, LKEY(vf->cval), &v) && v != NULL)
 287                         return 1;
 288         }
 289         return rc;
 290 }
 291
 292
 293
 294
 295 HashList *getContextVcard(StrBuf *Target, WCTemplputParams *TP)
 296 {
 297         vcField *vf = (vcField*) CTX(CTX_VCARD_TYPE);
 298         HashList *vc = (HashList*) CTX(CTX_VCARD);
 299
 300         if ((vf == NULL) || (vc == NULL)) {
 301                 LogTemplateError(NULL, "VCard item type", ERR_NAME, TP,
 302                                  "Need VCard and Vcard type in context");
 303
 304                 return NULL;
 305         }
 306         return vc;
 307 }
 308
 309 int filter_VC_ByContextType(const char* key, long len, void *Context, StrBuf *Target, WCTemplputParams *TP)
 310 {
 311         long searchType;
 312         vcField *vf = (vcField*) CTX(CTX_VCARD_TYPE);
 313
 314         memcpy(&searchType, key, sizeof(long));
 315
 316         if (vf->cval == searchType) {
 317                 return 1;
 318         }
 319         else {
 320                 return 0;
 321         }
 322 }
 323
 324
 325 int conditional_VC_Havetype(StrBuf *Target, WCTemplputParams *TP)
 326 {
 327         HashList *vc = (HashList*) CTX(CTX_VCARD);
 328         long HaveFieldType = GetTemplateTokenNumber(Target, TP, 2, 0);
 329         int rc = 0;
 330         void *vVCitem;
 331         const char *Key;
 332         long len;
 333         HashPos *it = GetNewHashPos(vc, 0);
 334         while (GetNextHashPos(vc, it, &len, &Key, &vVCitem) &&
 335                (vVCitem != NULL))
 336         {
 337                 void *vvcField;
 338                 long type = 0;
 339                 memcpy(&type, Key, sizeof(long));
 340                 if (GetHash(DefineToToken, LKEY(type), &vvcField) &&
 341                     (vvcField != NULL))
 342                 {
 343                         vcField *t = (vcField*) vvcField;
 344                         if (t && t->Type == HaveFieldType) {
 345                                 rc = 1;
 346                                 break;
 347                         }
 348                 }
 349         }
 350         DeleteHashPos(&it);
 351         return rc;
 352 }
 353
 354 /*
 355  * Record compare function for sorting address book indices
 356  */
 357 int abcmp(const void *ab1, const void *ab2) {
 358         return(strcasecmp(
 359                 (((const addrbookent *)ab1)->ab_name),
 360                 (((const addrbookent *)ab2)->ab_name)
 361         ));
 362 }
 363
 364
 365 /*
 366  * Helper function for do_addrbook_view()
 367  * Converts a name into a three-letter tab label
 368  */
 369 void nametab(char *tabbuf, long len, char *name) {
 370         stresc(tabbuf, len, name, 0, 0);
 371         tabbuf[0] = toupper(tabbuf[0]);
 372         tabbuf[1] = tolower(tabbuf[1]);
 373         tabbuf[2] = tolower(tabbuf[2]);
 374         tabbuf[3] = 0;
 375 }
 376
 377
 378 /*
 379  * If it's an old "Firstname Lastname" style record, try to convert it.
 380  */
 381 void lastfirst_firstlast(char *namebuf) {
 382         char firstname[SIZ];
 383         char lastname[SIZ];
 384         int i;
 385
 386         if (namebuf == NULL) return;
 387         if (strchr(namebuf, ';') != NULL) return;
 388
 389         i = num_tokens(namebuf, ' ');
 390         if (i < 2) return;
 391
 392         extract_token(lastname, namebuf, i-1, ' ', sizeof lastname);
 393         remove_token(namebuf, i-1, ' ');
 394         strcpy(firstname, namebuf);
 395         sprintf(namebuf, "%s; %s", lastname, firstname);
 396 }
 397
 398
 399
 400 wc_mime_attachment *load_vcard(message_summary *Msg)
 401 {
 402         HashPos  *it;
 403         StrBuf *FoundCharset = NewStrBuf();
 404         StrBuf *Error;
 405         void *vMime;
 406         const char *Key;
 407         long len;
 408         wc_mime_attachment *Mime;
 409         wc_mime_attachment *VCMime = NULL;
 410
 411         Msg->MsgBody =  (wc_mime_attachment*) malloc(sizeof(wc_mime_attachment));
 412         memset(Msg->MsgBody, 0, sizeof(wc_mime_attachment));
 413         Msg->MsgBody->msgnum = Msg->msgnum;
 414
 415         load_message(Msg, FoundCharset, &Error);
 416
 417         FreeStrBuf(&FoundCharset);
 418         /* look up the vcard... */
 419         it = GetNewHashPos(Msg->AllAttach, 0);
 420         while (GetNextHashPos(Msg->AllAttach, it, &len, &Key, &vMime) &&
 421                (vMime != NULL))
 422         {
 423                 Mime = (wc_mime_attachment*) vMime;
 424                 if ((strcmp(ChrPtr(Mime->ContentType),
 425                            "text/x-vcard") == 0) ||
 426                     (strcmp(ChrPtr(Mime->ContentType),
 427                             "text/vcard") == 0))
 428                 {
 429                         VCMime = Mime;
 430                         break;
 431                 }
 432         }
 433         DeleteHashPos(&it);
 434         if (VCMime == NULL)
 435                 return NULL;
 436
 437         if (VCMime->Data == NULL)
 438                 MimeLoadData(VCMime);
 439         return VCMime;
 440 }
 441
 442 /*
 443  * fetch the display name off a vCard
 444  */
 445 void fetch_ab_name(message_summary *Msg, char **namebuf) {
 446         long len;
 447         int i;
 448         wc_mime_attachment *VCMime = NULL;
 449
 450         if (namebuf == NULL) return;
 451
 452         VCMime = load_vcard(Msg);
 453         if (VCMime == NULL)
 454                 return;
 455
 456         /* Grab the name off the card */
 457         display_vcard(WC->WBuf, VCMime, 0, 0, namebuf, Msg->msgnum);
 458
 459         if (*namebuf != NULL) {
 460                 lastfirst_firstlast(*namebuf);
 461                 striplt(*namebuf);
 462                 len = strlen(*namebuf);
 463                 for (i=0; i<len; ++i) {
 464                         if ((*namebuf)[i] != ';') return;
 465                 }
 466                 free (*namebuf);
 467                 (*namebuf) = strdup(_("(no name)"));
 468         }
 469         else {
 470                 (*namebuf) = strdup(_("(no name)"));
 471         }
 472 }
 473
 474
 475
 476 /*
 477  * Turn a vCard "n" (name) field into something displayable.
 478  */
 479 void vcard_n_prettyize(char *name)
 480 {
 481         char *original_name;
 482         int i, j, len;
 483
 484         original_name = strdup(name);
 485         len = strlen(original_name);
 486         for (i=0; i<5; ++i) {
 487                 if (len > 0) {
 488                         if (original_name[len-1] == ' ') {
 489                                 original_name[--len] = 0;
 490                         }
 491                         if (original_name[len-1] == ';') {
 492                                 original_name[--len] = 0;
 493                         }
 494                 }
 495         }
 496         strcpy(name, "");
 497         j=0;
 498         for (i=0; i<len; ++i) {
 499                 if (original_name[i] == ';') {
 500                         name[j++] = ',';
 501                         name[j++] = ' ';
 502                 }
 503                 else {
 504                         name[j++] = original_name[i];
 505                 }
 506         }
 507         name[j] = '\0';
 508         free(original_name);
 509 }
 510
 511
 512
 513
 514 /*
 515  * preparse a vcard name
 516  * display_vcard() calls this after parsing the textual vCard into
 517  * our 'struct vCard' data object.
 518  * This gets called instead of display_parsed_vcard() if we are only looking
 519  * to extract the person's name instead of displaying the card.
 520  */
 521 void fetchname_parsed_vcard(struct vCard *v, char **storename) {
 522         char *name;
 523         char *prop;
 524         char buf[SIZ];
 525         int j, n, len;
 526         int is_qp = 0;
 527         int is_b64 = 0;
 528
 529         *storename = NULL;
 530
 531         name = vcard_get_prop(v, "n", 1, 0, 0);
 532         if (name != NULL) {
 533                 len = strlen(name);
 534                 prop = vcard_get_prop(v, "n", 1, 0, 1);
 535                 n = num_tokens(prop, ';');
 536
 537                 for (j=0; j<n; ++j) {
 538                         extract_token(buf, prop, j, ';', sizeof buf);
 539                         if (!strcasecmp(buf, "encoding=quoted-printable")) {
 540                                 is_qp = 1;
 541                         }
 542                         if (!strcasecmp(buf, "encoding=base64")) {
 543                                 is_b64 = 1;
 544                         }
 545                 }
 546                 if (is_qp) {
 547                         /* %ff can become 6 bytes in utf8  */
 548                         *storename = malloc(len * 2 + 3);
 549                         j = CtdlDecodeQuotedPrintable(
 550                                 *storename, name,
 551                                 len);
 552                         (*storename)[j] = 0;
 553                 }
 554                 else if (is_b64) {
 555                         /* ff will become one byte.. */
 556                         *storename = malloc(len + 50);
 557                         CtdlDecodeBase64(
 558                                 *storename, name,
 559                                 len);
 560                 }
 561                 else {
 562                         size_t len;
 563
 564                         len = strlen (name);
 565
 566                         *storename = malloc(len + 3); /* \0 + eventualy missing ', '*/
 567                         memcpy(*storename, name, len + 1);
 568                 }
 569                 /* vcard_n_prettyize(storename); */
 570         }
 571
 572 }
 573
 574
 575
 576
 577 void PutVcardItem(HashList *thisVC, vcField *thisField, StrBuf *ThisFieldStr, int is_qp, StrBuf *Swap)
 578 {
 579         /* if we have some untagged QP, detect it here. */
 580         if (is_qp || (strstr(ChrPtr(ThisFieldStr), "=?")!=NULL)){
 581                 StrBuf *b;
 582                 StrBuf_RFC822_to_Utf8(Swap, ThisFieldStr, NULL, NULL); /* default charset, current charset */
 583                 b = ThisFieldStr;
 584                 ThisFieldStr = Swap;
 585                 Swap = b;
 586                 FlushStrBuf(Swap);
 587         }
 588         Put(thisVC, LKEY(thisField->cval), ThisFieldStr, HFreeStrBuf);
 589 }
 590 /*
 591  * html print a vcard
 592  * display_vcard() calls this after parsing the textual vCard into
 593  * our 'struct vCard' data object.
 594  *
 595  * Set 'full' to nonzero to display the full card, otherwise it will only
 596  * show a summary line.
 597  *
 598  * This code is a bit ugly, so perhaps an explanation is due: we do this
 599  * in two passes through the vCard fields.  On the first pass, we process
 600  * fields we understand, and then render them in a pretty fashion at the
 601  * end.  Then we make a second pass, outputting all the fields we don't
 602  * understand in a simple two-column name/value format.
 603  * v            the vCard to display
 604  * full         display all items of the vcard?
 605  * msgnum       Citadel message pointer
 606  */
 607 void parse_vcard(StrBuf *Target, struct vCard *v, HashList *VC, int full, wc_mime_attachment *Mime)
 608 {
 609         StrBuf *Val = NULL;
 610         StrBuf *Swap = NULL;
 611         int i, j, k;
 612         char buf[20]; //SIZ];
 613         int is_qp = 0;
 614         int is_b64 = 0;
 615         int ntokens, len;
 616         StrBuf *thisname = NULL;
 617         char firsttoken[20]; ///SIZ];
 618         //void *V;
 619         StrBuf *thisVCToken;
 620         void *vField = NULL;
 621
 622         Swap = NewStrBuf ();
 623         thisname = NewStrBuf();
 624         thisVCToken = NewStrBufPlain(NULL, 63);
 625         for (i=0; i<(v->numprops); ++i) {
 626                 FlushStrBuf(thisVCToken);
 627                 is_qp = 0;
 628                 is_b64 = 0;
 629                 syslog(LOG_DEBUG, "i: %d oneprop: %s - value: %s", i, v->prop[i].name, v->prop[i].value);
 630                 StrBufPlain(thisname, v->prop[i].name, -1);
 631                 StrBufLowerCase(thisname);
 632
 633                 /*len = */extract_token(firsttoken, ChrPtr(thisname), 0, ';', sizeof firsttoken);
 634                 ntokens = num_tokens(ChrPtr(thisname), ';');
 635                 for (j=0, k=0; j < ntokens && k < 10; ++j) {
 636                         ///int evc[10];
 637
 638                         len = extract_token(buf, ChrPtr(thisname), j, ';', sizeof buf);
 639                         if (!strcasecmp(buf, "encoding=quoted-printable")) {
 640                                 is_qp = 1;
 641 /*                              remove_token(thisname, j, ';');*/
 642                         }
 643                         else if (!strcasecmp(buf, "encoding=base64")) {
 644                                 is_b64 = 1;
 645 /*                              remove_token(thisname, j, ';');*/
 646                         }
 647                         else{
 648                                 if (StrLength(thisVCToken) > 0) {
 649                                         StrBufAppendBufPlain(thisVCToken, HKEY(";"), 0);
 650                                 }
 651                                 StrBufAppendBufPlain(thisVCToken, buf, len, 0);
 652                                 /*
 653                                 if (GetHash(VCToEnum, buf, len, &V))
 654                                 {
 655                                         evc[k] = (int) V;
 656
 657                                         Put(VC, IKEY(evc), Val, HFreeStrBuf);
 658
 659                                         syslog(LOG_DEBUG, "[%ul] -> k: %d %s - %s", evc, k, buf, VCStr[evc[k]].Key);
 660                                         k++;
 661                                 }
 662 */
 663
 664                         }
 665                 }
 666
 667                 vField = NULL;
 668                 if ((StrLength(thisVCToken) > 0) &&
 669                     GetHash(VCTokenToDefine, SKEY(thisVCToken), &vField) &&
 670                     (vField != NULL)) {
 671                         vcField *thisField = (vcField *)vField;
 672                         StrBuf *ThisFieldStr = NULL;
 673                         syslog(LOG_DEBUG, "got this token: %s, found: %s", ChrPtr(thisVCToken), thisField->STR.Key);
 674                         switch (thisField->Type) {
 675                         case StringCluster: {
 676                                 int j = 0;
 677                                 const char *Pos = NULL;
 678                                 StrBuf *thisArray = NewStrBufPlain(v->prop[i].value, -1);
 679                                 StrBuf *Buf = NewStrBufPlain(NULL, StrLength(thisArray));
 680                                 while (thisField->Sub[j].STR.len > 0) {
 681                                         StrBufExtract_NextToken(Buf, thisArray, &Pos, ';');
 682                                         ThisFieldStr = NewStrBufDup(Buf);
 683
 684                                         PutVcardItem(VC, &thisField->Sub[j], ThisFieldStr, is_qp, Swap);
 685                                         j++;
 686                                 }
 687                                 FreeStrBuf(&thisArray);
 688                                 FreeStrBuf(&Buf);
 689                         }
 690                                 break;
 691                         case Address:
 692                         case FlatString:
 693                         case PhoneNumber:
 694                         case EmailAddr:
 695                         case Street:
 696                         case Number:
 697                         case AliasFor:
 698                                 /* copy over the payload into a StrBuf */
 699                                 ThisFieldStr = NewStrBufPlain(v->prop[i].value, -1);
 700                                 PutVcardItem(VC, thisField, ThisFieldStr, is_qp, Swap);
 701
 702                                 break;
 703                         case Base64BinaryAttachment:
 704                         case TerminateList:
 705                                 break;
 706                         }
 707
 708                 }
 709                 /* copy over the payload into a StrBuf */
 710                 Val = NewStrBufPlain(v->prop[i].value, -1);
 711
 712                 /* if we have some untagged QP, detect it here. */
 713                 if (is_qp || (strstr(v->prop[i].value, "=?")!=NULL)){
 714                         StrBuf *b;
 715                         StrBuf_RFC822_to_Utf8(Swap, Val, NULL, NULL); /* default charset, current charset */
 716                         b = Val;
 717                         Val = Swap;
 718                         Swap = b;
 719                         FlushStrBuf(Swap);
 720                 }
 721                 else if (is_b64) {
 722                         StrBufDecodeBase64(Val);
 723
 724                 }
 725 #if 0
 726                 syslog(LOG_DEBUG, "-> firsttoken: %s thisname: %s Value: [%s][%s]",
 727                         firsttoken,
 728                        ChrPtr(thisname),
 729                         ChrPtr(Val),
 730                         v->prop[i].value);
 731                 if (GetHash(VCToEnum, firsttoken, strlen(firsttoken), &V))
 732                 {
 733                         eVC evc = (eVC) V;
 734                         Put(VC, IKEY(evc), Val, HFreeStrBuf);
 735                         syslog(LOG_DEBUG, "[%ul]\n", evc);
 736                         Val = NULL;
 737                 }
 738                 else
 739                         syslog(LOG_DEBUG, "[]\n");
 740 /*
 741 TODO: check for layer II
 742                 else
 743                 {
 744                         long max = num_tokens(thisname, ';');
 745                         firsttoken[len] = '_';
 746
 747                         for (j = 0; j < max; j++) {
 748 //                      firsttoken[len]
 749
 750                                 extract_token(buf, thisname, j, ';', sizeof (buf));
 751                                         if (!strcasecmp(buf, "tel"))
 752                                                 strcat(phone, "");
 753                                         else if (!strcasecmp(buf, "work"))
 754                                                 strcat(phone, _(" (work)"));
 755                                         else if (!strcasecmp(buf, "home"))
 756                                                 strcat(phone, _(" (home)"));
 757                                         else if (!strcasecmp(buf, "cell"))
 758                                                 strcat(phone, _(" (cell)"));
 759                                         else {
 760                                                 strcat(phone, " (");
 761                                                 strcat(phone, buf);
 762                                                 strcat(phone, ")");
 763                                         }
 764                                 }
 765                         }
 766
 767                 }
 768 */
 769 #endif
 770                 FreeStrBuf(&Val);
 771                 ////free(thisname);
 772                 /// thisname = NULL;
 773         }
 774         FreeStrBuf(&thisname);
 775         FreeStrBuf(&Swap);
 776         FreeStrBuf(&thisVCToken);
 777 }
 778
 779 void tmplput_VCARD_ITEM(StrBuf *Target, WCTemplputParams *TP)
 780 {
 781         HashList *VC = CTX(CTX_VCARD);
 782         int evc;
 783         void *vStr;
 784
 785         evc = GetTemplateTokenNumber(Target, TP, 0, -1);
 786         if (evc != -1)
 787         {
 788                 if (GetHash(VC, IKEY(evc), &vStr))
 789                 {
 790                         StrBufAppendTemplate(Target, TP,
 791                                              (StrBuf*) vStr,
 792                                              1);
 793                 }
 794         }
 795
 796 }
 797
 798 void display_one_vcard (StrBuf *Target, struct vCard *v, int full, wc_mime_attachment *Mime)
 799 {
 800         HashList *VC;   WCTemplputParams SubTP;
 801
 802         memset(&SubTP, 0, sizeof(WCTemplputParams));
 803
 804
 805         VC = NewHash(0, lFlathash);
 806         parse_vcard(Target, v, VC, full, Mime);
 807
 808         {
 809                 WCTemplputParams *TP = NULL;
 810                 WCTemplputParams SubTP;
 811                 StackContext(TP, &SubTP, VC, CTX_VCARD, 0, NULL);
 812
 813                 DoTemplate(HKEY("vcard_msg_display"), Target, &SubTP);
 814                 UnStackContext(&SubTP);
 815         }
 816         DeleteHash(&VC);
 817 }
 818
 819
 820
 821 /*
 822  * Display a textual vCard
 823  * (Converts to a vCard object and then calls the actual display function)
 824  * Set 'full' to nonzero to display the whole card instead of a one-liner.
 825  * Or, if "storename" is non-NULL, just store the person's name in that
 826  * buffer instead of displaying the card at all.
 827  *
 828  * vcard_source the buffer containing the vcard text
 829  * alpha        Display only if name begins with this letter of the alphabet
 830  * full         Display the full vCard (otherwise just the display name)
 831  * storename    If not NULL, also store the display name here
 832  * msgnum       Citadel message pointer
 833  */
 834 void display_vcard(StrBuf *Target,
 835                    wc_mime_attachment *Mime,
 836                    char alpha,
 837                    int full,
 838                    char **storename,
 839                    long msgnum)
 840 {
 841         struct vCard *v;
 842         char *name;
 843         StrBuf *Buf;
 844         StrBuf *Buf2;
 845         char this_alpha = 0;
 846
 847         v = VCardLoad(Mime->Data);
 848
 849         if (v == NULL) return;
 850
 851         name = vcard_get_prop(v, "n", 1, 0, 0);
 852         if (name != NULL) {
 853                 Buf = NewStrBufPlain(name, -1);
 854                 Buf2 = NewStrBufPlain(NULL, StrLength(Buf));
 855                 StrBuf_RFC822_to_Utf8(Buf2, Buf, WC->DefaultCharset, NULL);
 856                 this_alpha = ChrPtr(Buf)[0];
 857                 FreeStrBuf(&Buf);
 858                 FreeStrBuf(&Buf2);
 859         }
 860
 861         if (storename != NULL) {
 862                 fetchname_parsed_vcard(v, storename);
 863         }
 864         else if ((alpha == 0) ||
 865                  ((isalpha(alpha)) && (tolower(alpha) == tolower(this_alpha))) ||
 866                  ((!isalpha(alpha)) && (!isalpha(this_alpha)))
 867                 )
 868         {
 869                 display_one_vcard (Target, v, full, Mime);
 870         }
 871
 872         vcard_free(v);
 873 }
 874
 875
 876
 877 /*
 878  * Render the address book using info we gathered during the scan
 879  *
 880  * addrbook     the addressbook to render
 881  * num_ab       the number of the addressbook
 882  */
 883 void do_addrbook_view(addrbookent *addrbook, int num_ab) {
 884         int i = 0;
 885         int displayed = 0;
 886         int bg = 0;
 887         static int NAMESPERPAGE = 60;
 888         int num_pages = 0;
 889         int tabfirst = 0;
 890         char tabfirst_label[64];
 891         int tablast = 0;
 892         char tablast_label[64];
 893         char this_tablabel[64];
 894         int page = 0;
 895         char **tablabels;
 896
 897         if (num_ab == 0) {
 898                 wc_printf("<br><br><br><div align=\"center\"><i>");
 899                 wc_printf(_("This address book is empty."));
 900                 wc_printf("</i></div>\n");
 901                 return;
 902         }
 903
 904         if (num_ab > 1) {
 905                 qsort(addrbook, num_ab, sizeof(addrbookent), abcmp);
 906         }
 907
 908         num_pages = (num_ab / NAMESPERPAGE) + 1;
 909
 910         tablabels = malloc(num_pages * sizeof (char *));
 911         if (tablabels == NULL) {
 912                 wc_printf("<br><br><br><div align=\"center\"><i>");
 913                 wc_printf(_("An internal error has occurred."));
 914                 wc_printf("</i></div>\n");
 915                 return;
 916         }
 917
 918         for (i=0; i<num_pages; ++i) {
 919                 tabfirst = i * NAMESPERPAGE;
 920                 tablast = tabfirst + NAMESPERPAGE - 1;
 921                 if (tablast > (num_ab - 1)) tablast = (num_ab - 1);
 922                 nametab(tabfirst_label, 64, addrbook[tabfirst].ab_name);
 923                 nametab(tablast_label, 64, addrbook[tablast].ab_name);
 924                 sprintf(this_tablabel, "%s&nbsp;-&nbsp;%s", tabfirst_label, tablast_label);
 925                 tablabels[i] = strdup(this_tablabel);
 926         }
 927
 928         tabbed_dialog(num_pages, tablabels);
 929         page = (-1);
 930
 931         for (i=0; i<num_ab; ++i) {
 932
 933                 if ((i / NAMESPERPAGE) != page) {       /* New tab */
 934                         page = (i / NAMESPERPAGE);
 935                         if (page > 0) {
 936                                 wc_printf("</tr></table>\n");
 937                                 end_tab(page-1, num_pages);
 938                         }
 939                         begin_tab(page, num_pages);
 940                         wc_printf("<table border=\"0\" cellspacing=\"0\" cellpadding=\"3\" width=\"100%%\">\n");
 941                         displayed = 0;
 942                 }
 943
 944                 if ((displayed % 4) == 0) {
 945                         if (displayed > 0) {
 946                                 wc_printf("</tr>\n");
 947                         }
 948                         bg = 1 - bg;
 949                         wc_printf("<tr bgcolor=\"#%s\">",
 950                                 (bg ? "dddddd" : "ffffff")
 951                         );
 952                 }
 953
 954                 wc_printf("<td>");
 955
 956                 wc_printf("<a href=\"readfwd?startmsg=%ld?is_singlecard=1",
 957                         addrbook[i].ab_msgnum);
 958                 wc_printf("?maxmsgs=1?is_summary=0?alpha=%s\">", bstr("alpha"));
 959                 vcard_n_prettyize(addrbook[i].ab_name);
 960                 escputs(addrbook[i].ab_name);
 961                 wc_printf("</a></td>\n");
 962                 ++displayed;
 963         }
 964
 965         /* Placeholders for empty columns at end */
 966         if ((num_ab % 4) != 0) {
 967                 for (i=0; i<(4-(num_ab % 4)); ++i) {
 968                         wc_printf("<td>&nbsp;</td>");
 969                 }
 970         }
 971
 972         wc_printf("</tr></table>\n");
 973         end_tab((num_pages-1), num_pages);
 974
 975         begin_tab(num_pages, num_pages);
 976         /* FIXME there ought to be something here */
 977         end_tab(num_pages, num_pages);
 978
 979         for (i=0; i<num_pages; ++i) {
 980                 free(tablabels[i]);
 981         }
 982         free(tablabels);
 983 }
 984
 985
 986
 987
 988 /*
 989  * Edit the vCard component of a MIME message.
 990  * Supply the message number
 991  * and MIME part number to fetch.  Or, specify -1 for the message number
 992  * to start with a blank card.
 993  */
 994 void do_edit_vcard(long msgnum, char *partnum,
 995                    message_summary *VCMsg,
 996                    wc_mime_attachment *VCAtt,
 997                    const char *return_to,
 998                    const char *force_room) {
 999         wcsession *WCC = WC;
1000         message_summary *Msg = NULL;
1001         wc_mime_attachment *VCMime = NULL;
1002         struct vCard *v;
1003         int i;
1004         char *key, *value;
1005         char whatuser[256];
1006
1007         char lastname[256];
1008         char firstname[256];
1009         char middlename[256];
1010         char prefix[256];
1011         char suffix[256];
1012         char pobox[256];
1013         char extadr[256];
1014         char street[256];
1015         char city[256];
1016         char state[256];
1017         char zipcode[256];
1018         char country[256];
1019         char hometel[256];
1020         char worktel[256];
1021         char faxtel[256];
1022         char mobiletel[256];
1023         char primary_inetemail[256];
1024         char other_inetemail[SIZ];
1025         char extrafields[SIZ];
1026         char fullname[256];
1027         char title[256];
1028         char org[256];
1029
1030         lastname[0] = 0;
1031         firstname[0] = 0;
1032         middlename[0] = 0;
1033         prefix[0] = 0;
1034         suffix[0] = 0;
1035         pobox[0] = 0;
1036         extadr[0] = 0;
1037         street[0] = 0;
1038         city[0] = 0;
1039         state[0] = 0;
1040         zipcode[0] = 0;
1041         country[0] = 0;
1042         hometel[0] = 0;
1043         worktel[0] = 0;
1044         faxtel[0] = 0;
1045         mobiletel[0] = 0;
1046         primary_inetemail[0] = 0;
1047         other_inetemail[0] = 0;
1048         title[0] = 0;
1049         org[0] = 0;
1050         extrafields[0] = 0;
1051         fullname[0] = 0;
1052
1053         safestrncpy(whatuser, "", sizeof whatuser);
1054
1055         if ((msgnum >= 0) ||
1056             ((VCMsg != NULL) && (VCAtt != NULL)))
1057         {
1058                 if ((VCMsg == NULL) && (VCAtt == NULL)) {
1059
1060                         Msg = (message_summary *) malloc(sizeof(message_summary));
1061                         memset(Msg, 0, sizeof(message_summary));
1062                         Msg->msgnum = msgnum;
1063                         VCMime = load_vcard(Msg);
1064                         if (VCMime == NULL) {
1065                                 convenience_page("770000", _("Error"), "");///TODO: important message
1066                                 DestroyMessageSummary(Msg);
1067                                 return;
1068                         }
1069
1070                         v = VCardLoad(VCMime->Data);
1071                 }
1072                 else {
1073                         v = VCardLoad(VCAtt->Data);
1074                 }
1075
1076                 /* Populate the variables for our form */
1077                 i = 0;
1078                 while (key = vcard_get_prop(v, "", 0, i, 1), key != NULL) {
1079                         char prp[256];  /* property name */
1080                         char prm[256];  /* parameters */
1081
1082                         value = vcard_get_prop(v, "", 0, i++, 0);
1083
1084
1085                         extract_token(prp, key, 0, ';', sizeof prp);
1086                         safestrncpy(prm, key, sizeof prm);
1087                         remove_token(prm, 0, ';');
1088
1089                         if (!strcasecmp(prp, "n")) {
1090                                 extract_token(lastname, value, 0, ';', sizeof lastname);
1091                                 extract_token(firstname, value, 1, ';', sizeof firstname);
1092                                 extract_token(middlename, value, 2, ';', sizeof middlename);
1093                                 extract_token(prefix, value, 3, ';', sizeof prefix);
1094                                 extract_token(suffix, value, 4, ';', sizeof suffix);
1095                         }
1096
1097                         else if (!strcasecmp(prp, "fn")) {
1098                                 safestrncpy(fullname, value, sizeof fullname);
1099                         }
1100
1101                         else if (!strcasecmp(prp, "title")) {
1102                                 safestrncpy(title, value, sizeof title);
1103                         }
1104
1105                         else if (!strcasecmp(prp, "org")) {
1106                                 safestrncpy(org, value, sizeof org);
1107                         }
1108
1109                         else if (!strcasecmp(prp, "adr")) {
1110                                 extract_token(pobox, value, 0, ';', sizeof pobox);
1111                                 extract_token(extadr, value, 1, ';', sizeof extadr);
1112                                 extract_token(street, value, 2, ';', sizeof street);
1113                                 extract_token(city, value, 3, ';', sizeof city);
1114                                 extract_token(state, value, 4, ';', sizeof state);
1115                                 extract_token(zipcode, value, 5, ';', sizeof zipcode);
1116                                 extract_token(country, value, 6, ';', sizeof country);
1117                         }
1118
1119                         else if (!strcasecmp(prp, "tel")) {
1120
1121                                 if (bmstrcasestr(prm, "home")) {
1122                                         extract_token(hometel, value, 0, ';', sizeof hometel);
1123                                 }
1124                                 else if (bmstrcasestr(prm, "work")) {
1125                                         extract_token(worktel, value, 0, ';', sizeof worktel);
1126                                 }
1127                                 else if (bmstrcasestr(prm, "fax")) {
1128                                         extract_token(faxtel, value, 0, ';', sizeof faxtel);
1129                                 }
1130                                 else if (bmstrcasestr(prm, "cell")) {
1131                                         extract_token(mobiletel, value, 0, ';', sizeof mobiletel);
1132                                 }
1133                                 else {  /* Missing or unknown type; put it in the home phone */
1134                                         extract_token(hometel, value, 0, ';', sizeof hometel);
1135                                 }
1136                         }
1137
1138                         else if ( (!strcasecmp(prp, "email")) && (bmstrcasestr(prm, "internet")) ) {
1139                                 if (primary_inetemail[0] == 0) {
1140                                         safestrncpy(primary_inetemail, value, sizeof primary_inetemail);
1141                                 }
1142                                 else {
1143                                         if (other_inetemail[0] != 0) {
1144                                                 strcat(other_inetemail, "\n");
1145                                         }
1146                                         strcat(other_inetemail, value);
1147                                 }
1148                         }
1149
1150                         /* Unrecognized properties are preserved here so we don't discard them
1151                          * just because the vCard was edited with WebCit.
1152                          */
1153                         else {
1154                                 strcat(extrafields, key);
1155                                 strcat(extrafields, ":");
1156                                 strcat(extrafields, value);
1157                                 strcat(extrafields, "\n");
1158                         }
1159
1160                 }
1161
1162                 vcard_free(v);
1163         }
1164
1165         /* Display the form */
1166         output_headers(1, 1, 1, 0, 0, 0);
1167
1168         do_template("box_begin_1");
1169         StrBufAppendBufPlain(WC->WBuf, _("Edit contact information"), -1, 0);
1170         do_template("box_begin_2");
1171
1172         wc_printf("<form method=\"POST\" action=\"submit_vcard\">\n");
1173         wc_printf("<input type=\"hidden\" name=\"nonce\" value=\"%d\">\n", WC->nonce);
1174
1175         if (force_room != NULL) {
1176                 wc_printf("<input type=\"hidden\" name=\"force_room\" value=\"");
1177                 escputs(force_room);
1178                 wc_printf("\">\n");
1179         }
1180         else
1181         {
1182                 wc_printf("<input type=\"hidden\" name=\"go\" value=\"");
1183                 StrEscAppend(WCC->WBuf, WCC->CurRoom.name, NULL, 0, 0);
1184                 wc_printf("\">\n");
1185         }
1186
1187         wc_printf("<table class=\"vcard_edit_background\"><tr><td>\n");
1188
1189         wc_printf("<table border=\"0\"><tr>"
1190                 "<td>%s</td>"
1191                 "<td>%s</td>"
1192                 "<td>%s</td>"
1193                 "<td>%s</td>"
1194                 "<td>%s</td></tr>\n",
1195                 _("Prefix"), _("First Name"), _("Middle Name"), _("Last Name"), _("Suffix")
1196         );
1197         wc_printf("<tr><td><input type=\"text\" name=\"prefix\" "
1198                 "value=\"%s\" maxlength=\"5\" size=\"5\"></td>",
1199                 prefix);
1200         wc_printf("<td><input type=\"text\" name=\"firstname\" "
1201                 "value=\"%s\" maxlength=\"29\"></td>",
1202                 firstname);
1203         wc_printf("<td><input type=\"text\" name=\"middlename\" "
1204                 "value=\"%s\" maxlength=\"29\"></td>",
1205                 middlename);
1206         wc_printf("<td><input type=\"text\" name=\"lastname\" "
1207                 "value=\"%s\" maxlength=\"29\"></td>",
1208                 lastname);
1209         wc_printf("<td><input type=\"text\" name=\"suffix\" "
1210                 "value=\"%s\" maxlength=\"10\" size=\"10\"></td></tr></table>\n",
1211                 suffix);
1212
1213         wc_printf("<table  class=\"vcard_edit_background_alt\">");
1214         wc_printf("<tr><td>");
1215
1216         wc_printf(_("Display name:"));
1217         wc_printf("<br>"
1218                 "<input type=\"text\" name=\"fullname\" "
1219                 "value=\"%s\" maxlength=\"40\"><br><br>\n",
1220                 fullname
1221         );
1222
1223         wc_printf(_("Title:"));
1224         wc_printf("<br>"
1225                 "<input type=\"text\" name=\"title\" "
1226                 "value=\"%s\" maxlength=\"40\"><br><br>\n",
1227                 title
1228         );
1229
1230         wc_printf(_("Organization:"));
1231         wc_printf("<br>"
1232                 "<input type=\"text\" name=\"org\" "
1233                 "value=\"%s\" maxlength=\"40\"><br><br>\n",
1234                 org
1235         );
1236
1237         wc_printf("</td><td>");
1238
1239         wc_printf("<table border=\"0\">");
1240         wc_printf("<tr><td>");
1241         wc_printf(_("PO box:"));
1242         wc_printf("</td><td>"
1243                 "<input type=\"text\" name=\"pobox\" "
1244                 "value=\"%s\" maxlength=\"29\"></td></tr>\n",
1245                 pobox);
1246         wc_printf("<tr><td>");
1247         wc_printf(_("Address:"));
1248         wc_printf("</td><td>"
1249                 "<input type=\"text\" name=\"extadr\" "
1250                 "value=\"%s\" maxlength=\"29\"></td></tr>\n",
1251                 extadr);
1252         wc_printf("<tr><td> </td><td>"
1253                 "<input type=\"text\" name=\"street\" "
1254                 "value=\"%s\" maxlength=\"29\"></td></tr>\n",
1255                 street);
1256         wc_printf("<tr><td>");
1257         wc_printf(_("City:"));
1258         wc_printf("</td><td>"
1259                 "<input type=\"text\" name=\"city\" "
1260                 "value=\"%s\" maxlength=\"29\"></td></tr>\n",
1261                 city);
1262         wc_printf("<tr><td>");
1263         wc_printf(_("State:"));
1264         wc_printf("</td><td>"
1265                 "<input type=\"text\" name=\"state\" "
1266                 "value=\"%s\" maxlength=\"29\"></td></tr>\n",
1267                 state);
1268         wc_printf("<tr><td>");
1269         wc_printf(_("ZIP code:"));
1270         wc_printf("</td><td>"
1271                 "<input type=\"text\" name=\"zipcode\" "
1272                 "value=\"%s\" maxlength=\"10\"></td></tr>\n",
1273                 zipcode);
1274         wc_printf("<tr><td>");
1275         wc_printf(_("Country:"));
1276         wc_printf("</td><td>"
1277                 "<input type=\"text\" name=\"country\" "
1278                 "value=\"%s\" maxlength=\"29\" width=\"5\"></td></tr>\n",
1279                 country);
1280         wc_printf("</table>\n");
1281
1282         wc_printf("</table>\n");
1283
1284         wc_printf("<table border=0><tr><td>");
1285         wc_printf(_("Home telephone:"));
1286         wc_printf("</td>"
1287                 "<td><input type=\"text\" name=\"hometel\" "
1288                 "value=\"%s\" maxlength=\"29\"></td>\n",
1289                 hometel);
1290         wc_printf("<td>");
1291         wc_printf(_("Work telephone:"));
1292         wc_printf("</td>"
1293                 "<td><input type=\"text\" name=\"worktel\" "
1294                 "value=\"%s\" maxlength=\"29\"></td></tr>\n",
1295                 worktel);
1296         wc_printf("<tr><td>");
1297         wc_printf(_("Mobile telephone:"));
1298         wc_printf("</td>"
1299                 "<td><input type=\"text\" name=\"mobiletel\" "
1300                 "value=\"%s\" maxlength=\"29\"></td>\n",
1301                 mobiletel);
1302         wc_printf("<td>");
1303         wc_printf(_("Fax number:"));
1304         wc_printf("</td>"
1305                 "<td><input type=\"text\" name=\"faxtel\" "
1306                 "value=\"%s\" maxlength=\"29\"></td></tr></table>\n",
1307                 faxtel);
1308
1309         wc_printf("<table class=\"vcard_edit_background_alt\">");
1310         wc_printf("<tr><td>");
1311
1312         wc_printf("<table border=0><TR>"
1313                 "<td valign=top>");
1314         wc_printf(_("Primary Internet e-mail address"));
1315         wc_printf("<br>"
1316                 "<input type=\"text\" name=\"primary_inetemail\" "
1317                 "size=40 maxlength=60 value=\"");
1318         escputs(primary_inetemail);
1319         wc_printf("\"><br>"
1320                 "</td><td valign=top>");
1321         wc_printf(_("Internet e-mail aliases"));
1322         wc_printf("<br>"
1323                 "<textarea name=\"other_inetemail\" rows=5 cols=40 width=40>");
1324         escputs(other_inetemail);
1325         wc_printf("</textarea></td></tr></table>\n");
1326
1327         wc_printf("</td></tr></table>\n");
1328
1329         wc_printf("<input type=\"hidden\" name=\"extrafields\" value=\"");
1330         escputs(extrafields);
1331         wc_printf("\">\n");
1332
1333         wc_printf("<input type=\"hidden\" name=\"return_to\" value=\"");
1334         escputs(return_to);
1335         wc_printf("\">\n");
1336
1337         wc_printf("<div class=\"buttons\">\n"
1338                 "<input type=\"submit\" name=\"ok_button\" value=\"%s\">"
1339                 "&nbsp;"
1340                 "<input type=\"submit\" name=\"cancel_button\" value=\"%s\">"
1341                 "</div></form>\n",
1342                 _("Save changes"),
1343                 _("Cancel")
1344         );
1345
1346         wc_printf("</td></tr></table>\n");
1347         do_template("box_end");
1348         wDumpContent(1);
1349         if (Msg != NULL) {
1350                 DestroyMessageSummary(Msg);
1351         }
1352 }
1353
1354
1355 /*
1356  *  commit the edits to the citadel server
1357  */
1358 void edit_vcard(void) {
1359         long msgnum;
1360         char *partnum;
1361
1362         msgnum = lbstr("msgnum");
1363         partnum = bstr("partnum");
1364         do_edit_vcard(msgnum, partnum, NULL, NULL, "", NULL);
1365 }
1366
1367
1368
1369 /*
1370  *  parse edited vcard from the browser
1371  */
1372 void submit_vcard(void) {
1373         struct vCard *v;
1374         char *serialized_vcard;
1375         char buf[SIZ];
1376         StrBuf *Buf;
1377         const StrBuf *ForceRoom;
1378         int i;
1379
1380         if (!havebstr("ok_button")) {
1381                 readloop(readnew, eUseDefault);
1382                 return;
1383         }
1384
1385         if (havebstr("force_room")) {
1386                 ForceRoom = sbstr("force_room");
1387                 if (gotoroom(ForceRoom) != 200) {
1388                         AppendImportantMessage(_("Unable to enter the room to save your message"), -1);
1389                         AppendImportantMessage(HKEY(": "));
1390                         AppendImportantMessage(SKEY(ForceRoom));
1391                         AppendImportantMessage(HKEY("; "));
1392                         AppendImportantMessage(_("Aborting."), -1);
1393
1394                         if (!strcmp(bstr("return_to"), "select_user_to_edit")) {
1395                                 select_user_to_edit(NULL);
1396                         }
1397                         else if (!strcmp(bstr("return_to"), "do_welcome")) {
1398                                 do_welcome();
1399                         }
1400                         else if (!IsEmptyStr(bstr("return_to"))) {
1401                                 http_redirect(bstr("return_to"));
1402                         }
1403                         else {
1404                                 readloop(readnew, eUseDefault);
1405                         }
1406                         return;
1407                 }
1408         }
1409
1410         Buf = NewStrBuf();
1411         serv_write(HKEY("ENT0 1|||4\n"));
1412         if (!StrBuf_ServGetln(Buf) && (GetServerStatus(Buf, NULL) != 4))
1413         {
1414                 edit_vcard();
1415                 return;
1416         }
1417
1418         /* Make a vCard structure out of the data supplied in the form */
1419         StrBufPrintf(Buf, "begin:vcard\r\n%s\r\nend:vcard\r\n",
1420                      bstr("extrafields")
1421         );
1422         v = VCardLoad(Buf);     /* Start with the extra fields */
1423         if (v == NULL) {
1424                 AppendImportantMessage(_("An error has occurred."), -1);
1425                 edit_vcard();
1426                 FreeStrBuf(&Buf);
1427                 return;
1428         }
1429
1430         snprintf(buf, sizeof buf, "%s;%s;%s;%s;%s",
1431                 bstr("lastname"),
1432                 bstr("firstname"),
1433                 bstr("middlename"),
1434                 bstr("prefix"),
1435                 bstr("suffix") );
1436         vcard_add_prop(v, "n", buf);
1437
1438         vcard_add_prop(v, "title", bstr("title"));
1439         vcard_add_prop(v, "fn", bstr("fullname"));
1440         vcard_add_prop(v, "org", bstr("org"));
1441
1442         snprintf(buf, sizeof buf, "%s;%s;%s;%s;%s;%s;%s",
1443                 bstr("pobox"),
1444                 bstr("extadr"),
1445                 bstr("street"),
1446                 bstr("city"),
1447                 bstr("state"),
1448                 bstr("zipcode"),
1449                 bstr("country") );
1450         vcard_add_prop(v, "adr", buf);
1451
1452         vcard_add_prop(v, "tel;home", bstr("hometel"));
1453         vcard_add_prop(v, "tel;work", bstr("worktel"));
1454         vcard_add_prop(v, "tel;fax", bstr("faxtel"));
1455         vcard_add_prop(v, "tel;cell", bstr("mobiletel"));
1456         vcard_add_prop(v, "email;internet", bstr("primary_inetemail"));
1457
1458         for (i=0; i<num_tokens(bstr("other_inetemail"), '\n'); ++i) {
1459                 extract_token(buf, bstr("other_inetemail"), i, '\n', sizeof buf);
1460                 if (!IsEmptyStr(buf)) {
1461                         vcard_add_prop(v, "email;internet", buf);
1462                 }
1463         }
1464
1465         serialized_vcard = vcard_serialize(v);
1466         vcard_free(v);
1467         if (serialized_vcard == NULL) {
1468                 AppendImportantMessage(_("An error has occurred."), -1);
1469                 edit_vcard();
1470                 FreeStrBuf(&Buf);
1471                 return;
1472         }
1473
1474         serv_write(HKEY("Content-type: text/x-vcard; charset=UTF-8\n"));
1475         serv_write(HKEY("\n"));
1476         serv_printf("%s\r\n", serialized_vcard);
1477         serv_write(HKEY("000\n"));
1478         free(serialized_vcard);
1479
1480         if (!strcmp(bstr("return_to"), "select_user_to_edit")) {
1481                 select_user_to_edit(NULL);
1482         }
1483         else if (!strcmp(bstr("return_to"), "do_welcome")) {
1484                 do_welcome();
1485         }
1486         else if (!IsEmptyStr(bstr("return_to"))) {
1487                 http_redirect(bstr("return_to"));
1488         }
1489         else {
1490                 readloop(readnew, eUseDefault);
1491         }
1492         FreeStrBuf(&Buf);
1493 }
1494
1495
1496
1497 /*
1498  * Extract an embedded photo from a vCard for display on the client
1499  */
1500 void display_vcard_photo_img(void)
1501 {
1502         long msgnum = 0L;
1503         StrBuf *vcard;
1504         struct vCard *v;
1505         char *photosrc;
1506         const char *contentType;
1507         wcsession *WCC = WC;
1508
1509         msgnum = StrBufExtract_long(WCC->Hdr->HR.ReqLine, 0, '/');
1510
1511         vcard = load_mimepart(msgnum,"1");
1512         v = VCardLoad(vcard);
1513
1514         photosrc = vcard_get_prop(v, "PHOTO", 1,0,0);
1515         FlushStrBuf(WCC->WBuf);
1516         StrBufAppendBufPlain(WCC->WBuf, photosrc, -1, 0);
1517         if (StrBufDecodeBase64(WCC->WBuf) <= 0) {
1518                 FlushStrBuf(WCC->WBuf);
1519
1520                 hprintf("HTTP/1.1 500 %s\n","Unable to get photo");
1521                 output_headers(0, 0, 0, 0, 0, 0);
1522                 hprintf("Content-Type: text/plain\r\n");
1523                 begin_burst();
1524                 wc_printf(_("Could Not decode vcard photo\n"));
1525                 end_burst();
1526                 return;
1527         }
1528         contentType = GuessMimeType(ChrPtr(WCC->WBuf), StrLength(WCC->WBuf));
1529         http_transmit_thing(contentType, 0);
1530         free(v);
1531         free(photosrc);
1532 }
1533
1534 typedef struct _vcardview_struct {
1535         long is_singlecard;
1536         addrbookent *addrbook;
1537         long num_ab;
1538
1539 } vcardview_struct;
1540
1541 int vcard_GetParamsGetServerCall(SharedMessageStatus *Stat,
1542                                  void **ViewSpecific,
1543                                  long oper,
1544                                  char *cmd,
1545                                  long len,
1546                                  char *filter,
1547                                  long flen)
1548 {
1549         vcardview_struct *VS;
1550
1551         VS = (vcardview_struct*) malloc (sizeof(vcardview_struct));
1552         memset(VS, 0, sizeof(vcardview_struct));
1553         *ViewSpecific = (void*)VS;
1554
1555         VS->is_singlecard = ibstr("is_singlecard");
1556         if (VS->is_singlecard != 1) {
1557                 if (oper == do_search) {
1558                         snprintf(cmd, len, "MSGS SEARCH|%s", bstr("query"));
1559                 }
1560                 else {
1561                         strcpy(cmd, "MSGS ALL");
1562                 }
1563                 Stat->maxmsgs = 9999999;
1564         }
1565         return 200;
1566 }
1567
1568 int vcard_LoadMsgFromServer(SharedMessageStatus *Stat,
1569                             void **ViewSpecific,
1570                             message_summary* Msg,
1571                             int is_new,
1572                             int i)
1573 {
1574         vcardview_struct *VS;
1575         char *ab_name;
1576
1577         VS = (vcardview_struct*) *ViewSpecific;
1578
1579         ab_name = NULL;
1580         fetch_ab_name(Msg, &ab_name);
1581         if (ab_name == NULL)
1582                 return 0;
1583         ++VS->num_ab;
1584         VS->addrbook = realloc(VS->addrbook,
1585                                (sizeof(addrbookent) * VS->num_ab) );
1586         safestrncpy(VS->addrbook[VS->num_ab-1].ab_name, ab_name,
1587                     sizeof(VS->addrbook[VS->num_ab-1].ab_name));
1588         VS->addrbook[VS->num_ab-1].ab_msgnum = Msg->msgnum;
1589         free(ab_name);
1590         return 0;
1591 }
1592
1593
1594 int vcard_RenderView_or_Tail(SharedMessageStatus *Stat, void **ViewSpecific, long oper)
1595 {
1596         const StrBuf *Mime;
1597         vcardview_struct *VS;
1598
1599         VS = (vcardview_struct*) *ViewSpecific;
1600         if (VS->is_singlecard)
1601                 read_message(WC->WBuf, HKEY("view_message"), lbstr("startmsg"), NULL, &Mime);
1602         else
1603                 do_addrbook_view(VS->addrbook, VS->num_ab);     /* Render the address book */
1604         return 0;
1605 }
1606
1607 int vcard_Cleanup(void **ViewSpecific)
1608 {
1609         vcardview_struct *VS;
1610
1611         VS = (vcardview_struct*) *ViewSpecific;
1612         wDumpContent(1);
1613         if ((VS != NULL) &&
1614             (VS->addrbook != NULL))
1615                 free(VS->addrbook);
1616         if (VS != NULL)
1617                 free(VS);
1618         return 0;
1619 }
1620
1621 void
1622 ServerStartModule_VCARD
1623 (void)
1624 {
1625         ///VCToEnum = NewHash(0, NULL);
1626
1627 }
1628
1629 void
1630 ServerShutdownModule_VCARD
1631 (void)
1632 {
1633         DeleteHash(&DefineToToken);
1634         DeleteHash(&vcNames);
1635         DeleteHash(&VCTokenToDefine);
1636         /// DeleteHash(&VCToEnum);
1637 }
1638
1639 void
1640 InitModule_VCARD
1641 (void)
1642 {
1643         RegisterCTX(CTX_VCARD);
1644         RegisterCTX(CTX_VCARD_TYPE);
1645         RegisterReadLoopHandlerset(
1646                 VIEW_ADDRESSBOOK,
1647                 vcard_GetParamsGetServerCall,
1648                 NULL,
1649                 NULL,
1650                 NULL,
1651                 vcard_LoadMsgFromServer,
1652                 vcard_RenderView_or_Tail,
1653                 vcard_Cleanup);
1654         WebcitAddUrlHandler(HKEY("edit_vcard"), "", 0, edit_vcard, 0);
1655         WebcitAddUrlHandler(HKEY("submit_vcard"), "", 0, submit_vcard, 0);
1656         WebcitAddUrlHandler(HKEY("vcardphoto"), "", 0, display_vcard_photo_img, NEED_URL);
1657 /*
1658         Put(VCToEnum, HKEY("n"), (void*)VC_n, reference_free_handler);
1659         Put(VCToEnum, HKEY("fn"), (void*)VC_fn, reference_free_handler);
1660         Put(VCToEnum, HKEY("title"), (void*)VC_title, reference_free_handler);
1661         Put(VCToEnum, HKEY("org"), (void*)VC_org, reference_free_handler);
1662         Put(VCToEnum, HKEY("email"), (void*)VC_email, reference_free_handler);
1663         Put(VCToEnum, HKEY("tel"), (void*)VC_tel, reference_free_handler);
1664         Put(VCToEnum, HKEY("work"), (void*)VC_work, reference_free_handler);
1665         Put(VCToEnum, HKEY("home"), (void*)VC_home, reference_free_handler);
1666         Put(VCToEnum, HKEY("cell"), (void*)VC_cell, reference_free_handler);
1667         Put(VCToEnum, HKEY("adr"), (void*)VC_adr, reference_free_handler);
1668         Put(VCToEnum, HKEY("photo"), (void*)VC_photo, reference_free_handler);
1669         Put(VCToEnum, HKEY("version"), (void*)VC_version, reference_free_handler);
1670         Put(VCToEnum, HKEY("rev"), (void*)VC_rev, reference_free_handler);
1671         Put(VCToEnum, HKEY("label"), (void*)VC_label, reference_free_handler);
1672 */
1673 /*
1674         RegisterNamespace("VC", 1, 2, tmplput_VCARD_ITEM, NULL, CTX_VCARD);
1675
1676         REGISTERTokenParamDefine(VC_n);
1677         REGISTERTokenParamDefine(VC_fn);
1678         REGISTERTokenParamDefine(VC_title);
1679         REGISTERTokenParamDefine(VC_org);
1680         REGISTERTokenParamDefine(VC_email);
1681         REGISTERTokenParamDefine(VC_tel);
1682         REGISTERTokenParamDefine(VC_work);
1683         REGISTERTokenParamDefine(VC_home);
1684         REGISTERTokenParamDefine(VC_cell);
1685         REGISTERTokenParamDefine(VC_adr);
1686         REGISTERTokenParamDefine(VC_photo);
1687         REGISTERTokenParamDefine(VC_version);
1688         REGISTERTokenParamDefine(VC_rev);
1689         REGISTERTokenParamDefine(VC_label);
1690 */
1691
1692         {
1693                 StrBuf *Prefix  = NewStrBufPlain(HKEY("VC:"));
1694                 DefineToToken   = NewHash(1, lFlathash);
1695                 vcNames         = NewHash(1, lFlathash);
1696                 VCTokenToDefine = NewHash(1, NULL);
1697                 autoRegisterTokens(&VCEnumCounter, VCStrE, Prefix, 0);
1698                 FreeStrBuf(&Prefix);
1699         }
1700         RegisterCTX(CTX_VCARD);
1701         RegisterNamespace("VC:ITEM", 2, 2, tmpl_vcard_item, preeval_vcard_item, CTX_VCARD);
1702         RegisterNamespace("VC:CTXITEM", 1, 1, tmpl_vcard_context_item, NULL, CTX_VCARD_TYPE);
1703         RegisterNamespace("VC:NAME", 1, 1, tmpl_vcard_name_str, preeval_vcard_name_str, CTX_VCARD);
1704         RegisterNamespace("VC:CTXNAME", 1, 1, tmpl_vcard_context_name_str, NULL, CTX_VCARD_TYPE);
1705         REGISTERTokenParamDefine(FlatString);
1706         REGISTERTokenParamDefine(StringCluster);
1707         REGISTERTokenParamDefine(PhoneNumber);
1708         REGISTERTokenParamDefine(EmailAddr);
1709         REGISTERTokenParamDefine(Street);
1710         REGISTERTokenParamDefine(Number);
1711         REGISTERTokenParamDefine(AliasFor);
1712         REGISTERTokenParamDefine(Base64BinaryAttachment);
1713         REGISTERTokenParamDefine(TerminateList);
1714         REGISTERTokenParamDefine(Address);
1715
1716         RegisterConditional("VC:HAVE:TYPE",      1, conditional_VC_Havetype, CTX_VCARD);
1717         RegisterFilteredIterator("VC:TYPE", 1, DefineToToken, NULL, NULL, NULL, filter_VC_ByType, CTX_VCARD_TYPE, CTX_VCARD, IT_NOFLAG);
1718         RegisterFilteredIterator("VC:TYPE:ITEMS", 0, NULL, getContextVcard, NULL, NULL, filter_VC_ByContextType, CTX_STRBUF, CTX_VCARD_TYPE, IT_NOFLAG);
1719 }
1720