src/v2l_vcard.c

   1 /*
   2  *  This program is free software; you can redistribute it and/or modify
   3  *  it under the terms of the GNU General Public License as published by
   4  *  the Free Software Foundation; either version 2 of the License, or
   5  *  (at your option) any later version.
   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  *  You should have received a copy of the GNU General Public License
  13  *  along with this program; if not, write to the Free Software
  14  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  15  */
  16
  17 /*! \file v2l_vcard.c
  18     \brief XML vCard's to/from LDAP objects translation functions.
  19     Implementation
  20 */
  21
  22 #include <stdlib.h>
  23
  24 #ifndef _V2L_JABBER2
  25 #include <jabberd.h>
  26 #else
  27 #include "../util/util.h"
  28 #include <xmlnode.h>
  29
  30 #define log_warn log_debug
  31 #define log_error log_debug
  32
  33 #endif
  34 #include <v2l_vcard.h>
  35
  36 #define LOG_ERROR_MEM log_error (ZONE, "Unable to allocate memory")
  37
  38 /*! \brief vCard template item.
  39     SLL. All of relations tag<->LDAP attr read from template
  40 */
  41 typedef struct v2l_vCardItem
  42 {
  43   char *vcard;  /*!< tag name */
  44   char *ldap;   /*!< LDAP attribute */
  45   char *group;  /*!< XML parent of the tag */
  46   struct v2l_vCardItem *next;
  47 } v2l_vCardItem;
  48
  49 /*! \brief Gets the translation map.
  50     If it is not initilized yet, the function reads the template from disk
  51     and sets the map.
  52     \param self Module config, if map is initialized can be NULL.
  53     \return The map, NULL if error.
  54 */
  55 static v2l_vCardItem *_v2l_vcard_map (v2l_Config *self);
  56
  57 /*! \brief Creates the FN tag
  58     Creates FN tag from GIVEN and FAMILY tags.
  59     \param vcard The vCard.
  60     \return 1 if no error, otherwise 0.
  61 */
  62 static int _v2l_create_fn (xmlnode vcard);
  63
  64 /*! \brief Sets sn1 and sn2 from sn
  65     Hack. IrisPerson has two surnames: first surname and mother's maiden name.
  66     This function splits sn in two. Should be called when the list of request
  67     are complete and before program excutes them.
  68     \param req The SLL of LDAP requests.
  69 */
  70 static v2l_LdapRequest *_v2l_set_sn12 (v2l_LdapRequest *req);
  71
  72 /*! \brief Map function from LDAP to XML vCard
  73     \param item Info about the tag (name, parent group and attribute associated)
  74     \param vals array of values for the attribe.
  75     \param[in,out] res The vCard, output is appended here.
  76     \return res + new tag or res if error.
  77 */
  78 static xmlnode _v2l_ldap2vcard_generic (v2l_vCardItem *item, const char **vals,
  79   xmlnode res);
  80
  81 /*! \brief Function for maps PHOTO tag.
  82     Hack. InetOrgPerson has a jpegphoto attribute so PHOTO/MIMETYPE tag can be
  83     only "image/jpeg"
  84     \warning The module doesn't support storing avatars in another format (png)
  85 */
  86 static xmlnode _v2l_ldap2vcard_photo (v2l_vCardItem *item, const char **vals,
  87   xmlnode res);
  88
  89 /*! \brief Map function from XML Vcard to LDAP
  90     \param item Info about the tag (name, parent group and attribute associated)
  91     \param data Thhe vCard.
  92     \param[in,out] req List of requests, the new request is appended here.
  93     \return req + new request or req if error.
  94 */
  95 static v2l_LdapRequest *_v2l_vcard2ldap_generic (v2l_vCardItem *item,
  96   xmlnode data, v2l_LdapRequest *req);
  97
  98 /*! \brief Finds tag linked to attr
  99     Parses the translation map since 'item' node.
 100     \param item Where the search starts.
 101     \param attr The attribute;
 102     \return node with tag<->attr association or NULL if error or not found.
 103 */
 104 static v2l_vCardItem *_v2l_vcard_find_attr (v2l_vCardItem *item,
 105   const char *attr);
 106
 107 /*! \brief Is LDAP object attribute linked to any tag?
 108     Utility function.
 109     \param attr The attribute.
 110     \param[out] shrdata Contents the address of any map's node. NULL if no match
 111     \return true if attr is linked to any tag, otherwise false
 112 */
 113 static int _v2l_vcard_attr_match (const char *attr, void **shrdata);
 114
 115 /*! \brief Function applied to all attrs.
 116     Utility function, walker function.
 117     \param attr The attribute.
 118     \param vals Values of attribute.
 119     \param pointer Deferenced pointer to vCard.
 120     \param shrdata Data shared with the match function.
 121 */
 122 static void _v2l_vcard_attr_value (const char *attr, const char **vals,
 123   void *pointer, void *shrdata);
 124
 125 #if 0
 126 static v2l_vCardItem *
 127   _v2l_vcard_find_tag (v2l_vCardItem *item, char *tag);
 128 #endif
 129
 130 /*! List of all XML vCard tags supported */
 131 static const char *_V2L_MAP_VCARD [] = {
 132     "FN",
 133     "NICKNAME",
 134     "URL",
 135     "TEL/NUMBER",
 136     "EMAIL/USERID",
 137     "TITLE",
 138     "ROLE",
 139     "BDAY",
 140     "DESC",
 141     "N/FAMILY",
 142     "N/GIVEN",
 143     "N/MIDDLE",
 144     "N/PREFIX",
 145     "N/SUFFIX",
 146     "ADR/STREET",
 147     "ADR/POBOX",
 148     "ADR/EXTADD",
 149     "ADR/LOCALITY",
 150     "ADR/REGION",
 151     "ADR/PCODE",
 152     "ADR/CTRY",
 153     "ORG/ORGNAME",
 154     "ORG/ORGUNIT",
 155
 156     "TZ",
 157     "GEO/LAT",
 158     "GEO/LON",
 159     "AGENT/EXTVAL",
 160     "NOTE",
 161     "REV",
 162     "SORT-STRING",
 163
 164     "KEY/TYPE",
 165     "KEY/CRED",
 166
 167     "PHOTO/TYPE",
 168     "PHOTO/BINVAL",
 169     "PHOTO/EXTVAL",
 170
 171     "LOGO/TYPE",
 172     "LOGO/BINVAL",
 173     "LOGO/EXTVAL",
 174
 175     "SOUND/PHONETIC",
 176     "SOUND/BINVAL",
 177     "SOUND/EXTVAL",
 178
 179     NULL
 180 };
 181
 182 /* public api */
 183
 184 xmlnode
 185 v2l_vcard_get (v2l_Config *self, v2l_LdapConn *curr_conn)
 186 {
 187   xmlnode vcard;
 188   v2l_LdapEvt *evt_res;
 189
 190   if (_v2l_vcard_map (self) == NULL)
 191     {
 192       log_error (ZONE, "Unreadable/malformed vCard template!");
 193       return NULL;
 194     }
 195
 196   /* get user info from LDAP */
 197   evt_res = v2l_ldap_get_entry (self, curr_conn);
 198
 199   if (evt_res == NULL)
 200     {
 201       return NULL;
 202     }
 203
 204   /* prepare the XML result */
 205   vcard = xmlnode_new_tag ("vCard");
 206   xmlnode_put_attrib (vcard, "xmlns", "vcard-temp");
 207
 208   v2l_ldap_for_all_attrs (_v2l_vcard_attr_value, _v2l_vcard_attr_match, vcard,
 209     evt_res);
 210
 211   free (evt_res);
 212   _v2l_create_fn (vcard);
 213
 214   return vcard;
 215 }
 216
 217 int
 218 v2l_vcard_set (v2l_Config *self, v2l_LdapConn *curr_conn, xmlnode data)
 219 {
 220   xmlnode node;
 221   v2l_LdapRequest *ldap_req = NULL;
 222   v2l_vCardItem *item;
 223
 224   if (data == NULL)
 225     {
 226       log_warn (ZONE, "vCard data is NULL?");
 227       return 0;
 228     }
 229
 230   item = _v2l_vcard_map (self);
 231
 232   if (item == NULL)
 233     {
 234       log_error (ZONE, "Unreadable/Malformed vCard template!");
 235       return 0;
 236     }
 237
 238   do
 239     {
 240       if (strcmp (item->vcard, "FN") == 0) /* FIXME: ugly */
 241         {
 242           goto is_fn;
 243         }
 244
 245       if (item->group != NULL)
 246         {
 247           char tag[30];
 248
 249           sprintf (tag, "%s/%s", item->group, item->vcard);
 250           node = xmlnode_get_tag (data, tag);
 251         }
 252       else
 253         {
 254           node = xmlnode_get_tag (data, item->vcard);
 255         }
 256
 257       if (node != NULL)
 258         {
 259           ldap_req = _v2l_vcard2ldap_generic (item, node, ldap_req);
 260         }
 261 is_fn:
 262       item = item->next;
 263     } while (item != NULL);
 264
 265   ldap_req = _v2l_set_sn12 (ldap_req);
 266
 267   return v2l_request_record (self, curr_conn, ldap_req);
 268 }
 269
 270 /* public api ends here */
 271
 272 static v2l_vCardItem *
 273 _v2l_vcard_map (v2l_Config *self)
 274 {
 275   static v2l_vCardItem *_V2L_TPL = NULL;
 276   xmlnode tpl, tag;
 277   char **stag, *tmp, group[10];
 278   v2l_vCardItem *item;
 279
 280   if (_V2L_TPL == NULL && self != NULL && self->confpath != NULL)
 281     {
 282       tpl = xmlnode_file (self->confpath);
 283
 284       if (tpl == NULL)
 285         {
 286           return NULL;
 287         }
 288
 289       for (stag = (char **) _V2L_MAP_VCARD; *stag != NULL; stag++)
 290         {
 291           tmp = strchr (*stag, '/');
 292
 293           if (tmp == NULL)
 294             {
 295               group[0] = 0;
 296               tmp = *stag;
 297             }
 298           else
 299             {
 300               sprintf (group, "%.*s", tmp - *stag, *stag);
 301               tmp++;
 302             }
 303
 304           tag = xmlnode_get_tag (tpl, *stag);
 305
 306           if (xmlnode_get_data (tag) != NULL)
 307             {
 308               int ntags = 0;
 309               char find_attr[30];
 310
 311               do
 312                 {
 313                   v2l_vCardItem *ptr;
 314
 315                   ptr = (v2l_vCardItem *) pmalloc (self->poolref,
 316                     sizeof (v2l_vCardItem));
 317
 318                   ptr->vcard = tmp;
 319                   ptr->ldap  = pstrdup (self->poolref, xmlnode_get_data (tag));
 320                   ptr->next  = NULL;
 321                   ptr->group = group[0] == 0 ? NULL :
 322                   pstrdup (self->poolref, group);
 323
 324                   if (_V2L_TPL == NULL)
 325                     {
 326                       _V2L_TPL = ptr;
 327                       item = ptr;
 328                     }
 329                   else
 330                     {
 331                       item->next = ptr;
 332                       item = item->next;
 333                     }
 334
 335                   sprintf (find_attr, "%s?v2ln=%d", *stag, ++ntags);
 336                   tag = xmlnode_get_tag (tpl, find_attr);
 337                 } while (tag && xmlnode_get_data (tag) != NULL && ntags < 10);
 338             }/* xmlnode_get_data (tag) != NULL */
 339         }  /* for loop, all tags in template */
 340
 341       xmlnode_free (tpl);
 342     }
 343
 344   return _V2L_TPL;
 345 }
 346
 347 #if 0
 348 static v2l_vCardItem *
 349 _v2l_vcard_find_tag (v2l_vCardItem *item, char *tag)
 350 {
 351   v2l_vCardItem *res = NULL;
 352
 353   while (item != NULL)
 354     {
 355       if (strcmp (item->vcard, tag) == 0)
 356         {
 357           res = item;
 358           break;
 359         }
 360
 361         item = item->next;
 362     }
 363
 364   return res;
 365 }
 366 #endif
 367
 368 static v2l_vCardItem *
 369 _v2l_vcard_find_attr (v2l_vCardItem *item, const char *attr)
 370 {
 371   v2l_vCardItem *res = NULL;
 372
 373   while (item != NULL)
 374     {
 375       if (strcmp (item->ldap, attr) == 0)
 376         {
 377           res = item;
 378           break;
 379         }
 380
 381         item = item->next;
 382     }
 383
 384   return res;
 385 }
 386
 387 static int
 388 _v2l_vcard_attr_match (const char *attr, void **shrdata)
 389 {
 390   *shrdata = _v2l_vcard_find_attr (_v2l_vcard_map (NULL), attr);
 391
 392   return *shrdata != NULL;
 393 }
 394
 395 static void
 396 _v2l_vcard_attr_value (const char *attr, const char **vals, void *pointer,
 397   void *shrdata)
 398 {
 399   xmlnode vcard;
 400   v2l_vCardItem *match;
 401
 402   vcard = (xmlnode) pointer;
 403   match = (v2l_vCardItem *) shrdata;
 404
 405   if (vals != NULL)
 406     {
 407       /* FIXME: ugly */
 408       if (match->group != NULL && (strcmp (match->group, "PHOTO") == 0))
 409         {
 410           _v2l_ldap2vcard_photo (match, vals, vcard);
 411         }
 412       else
 413         {
 414           _v2l_ldap2vcard_generic (match, vals, vcard);
 415         }
 416     }
 417 }
 418
 419 static int
 420 _v2l_create_fn (xmlnode vcard)
 421 {
 422   xmlnode n, fn;
 423   char *family, *given, *fn_str;
 424   int len;
 425
 426   fn = xmlnode_insert_tag (vcard, "FN");
 427   n  = xmlnode_get_tag (vcard, "N");
 428   family = xmlnode_get_tag_data (n, "FAMILY");
 429   given  = xmlnode_get_tag_data (n, "GIVEN");
 430
 431   len = 0;
 432   len += (family != NULL) ? strlen (family) : 0;
 433   len += (given  != NULL) ? strlen (given)  : 0;
 434
 435   if (len == 0)
 436     {
 437       log_debug (ZONE, "<fn><n>...</n></fn> is empty, returning");
 438       return 1;
 439     }
 440
 441   fn_str = (char *) malloc (sizeof (char) * (len + 2));
 442
 443   if (fn_str == NULL)
 444     {
 445       LOG_ERROR_MEM;
 446       return 0;
 447     }
 448
 449   fn_str[0] = 0;
 450
 451   if (family != NULL)
 452     {
 453       sprintf (fn_str, "%s ", family);
 454     }
 455
 456   if (given != NULL)
 457     {
 458       strcat (fn_str, given);
 459     }
 460
 461   xmlnode_insert_cdata (fn, fn_str, len + 1);
 462   free (fn_str);
 463
 464   return 1;
 465 }
 466
 467 /* LDAP -> vCard */
 468
 469 static xmlnode
 470 _v2l_ldap2vcard_generic (v2l_vCardItem *item, const char **vals, xmlnode res)
 471 {
 472   xmlnode node;
 473
 474   if (item->group != NULL)
 475     {
 476       node = xmlnode_get_tag (res, item->group);
 477
 478       if (node == NULL)
 479         {
 480           node = xmlnode_insert_tag (res, item->group);
 481         }
 482     }
 483   else
 484     {
 485       node = res;
 486     }
 487
 488   node = xmlnode_insert_tag (node, item->vcard);
 489   xmlnode_insert_cdata (node, vals[0], strlen (vals[0]));
 490
 491   return res;
 492 }
 493
 494 static xmlnode
 495 _v2l_ldap2vcard_photo (v2l_vCardItem *item, const char **vals, xmlnode res)
 496 {
 497   xmlnode mimetype, photo;
 498
 499   res = _v2l_ldap2vcard_generic (item, vals, res);
 500
 501   /* FIXME: mimetype is hardcoded */
 502   photo = xmlnode_get_tag (res, "PHOTO");
 503   mimetype = xmlnode_insert_tag (photo, "TYPE");
 504   xmlnode_insert_cdata (mimetype, "image/jpeg", sizeof ("image/jpeg"));
 505
 506   return res;
 507 }
 508
 509 /*  vCard -> LDAP */
 510
 511 static v2l_LdapRequest *
 512 _v2l_vcard2ldap_generic (v2l_vCardItem *item, xmlnode data,
 513   v2l_LdapRequest *req)
 514 {
 515   const char *str;
 516
 517   str = xmlnode_get_data (data);
 518
 519   return str == NULL ? req : v2l_add_attr_str (req, item->ldap, str);
 520 }
 521
 522 static v2l_LdapRequest *
 523 _v2l_set_sn12 (v2l_LdapRequest *req)
 524 {
 525   if (req != NULL)
 526     {
 527       v2l_LdapRequest *ptr;
 528       char *sn;
 529
 530       for (ptr = req, sn = NULL; ptr != NULL; ptr = ptr->next)
 531         {
 532           if (strcmp (ptr->attr->mod_type, "sn") == 0)
 533             {
 534               sn = ptr->attr->mod_values[0];
 535               break;
 536             }
 537         }
 538
 539       if (sn != NULL)
 540         {
 541           char *sit, *sn1, *sn2;
 542
 543           for (sit = sn; *sit != ' ' && *sit != 0; sit++);
 544
 545           sn1 = (char *) malloc (sizeof (char) * (sit - sn + 1));
 546
 547           if (sn1 == NULL)
 548             {
 549               return req;
 550             }
 551
 552           strncpy (sn1, sn, sizeof (char) * (sit - sn));
 553           sn1[sit - sn] = 0;
 554           ptr = v2l_add_attr_str (req, "sn1", sn1);
 555           free (sn1);
 556
 557           if (ptr == NULL)
 558             {
 559               return req;
 560             }
 561
 562           req = ptr;
 563
 564           if (sit - sn != strlen (sn))
 565             {
 566               sn2 = (char *) malloc (strlen (sit) + 1);
 567
 568               if (sn2 == NULL)
 569                 {
 570                   LOG_ERROR_MEM;
 571                   return req;
 572                 }
 573
 574               strcpy (sn2, sit);
 575               ptr = v2l_add_attr_str (req, "sn2", sn2);
 576               free (sn2);
 577
 578               if (ptr == NULL)
 579                 {
 580                   return req;
 581                 }
 582
 583               req = ptr;
 584             }
 585         }  /* sn != NULL */
 586     }  /* req != NULL */
 587
 588   return req;
 589 }