Use network log for LDAP operations output
[claws.git] / src / ldapupdate.c
1 /*
2  * Claws Mail -- a GTK+ based, lightweight, and fast e-mail client
3  * Copyright (C) 2003-2018 Michael Rasmussen and the Claws Mail team
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 3 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program. If not, see <http://www.gnu.org/licenses/>.
17  */
18
19 /*
20  * Functions necessary to access LDAP servers.
21  */
22
23 #ifdef HAVE_CONFIG_H
24 #  include "config.h"
25 #include "claws-features.h"
26 #endif
27
28 #ifdef USE_LDAP
29
30 #include <glib.h>
31 #include <glib/gi18n.h>
32 #include <sys/time.h>
33 #include <string.h>
34
35 #include "ldapupdate.h"
36 #include "mgutils.h"
37 #include "addritem.h"
38 #include "addrcache.h"
39 #include "ldapctrl.h"
40 #include "ldapquery.h"
41 #include "ldapserver.h"
42 #include "ldaputil.h"
43 #include "utils.h"
44 #include "adbookbase.h"
45 #include "editaddress_other_attributes_ldap.h"
46 #include "log.h"
47
48 /**
49  * Structure to hold user defined attributes
50  * from contacts
51  */
52 typedef struct _AttrKeyValue AttrKeyValue;
53 struct _AttrKeyValue {
54         gchar *key;
55         gchar *value;
56 };
57
58 /**
59  * Structure to hold contact information.
60  * Each addressbook will have 0..N contacts.
61  */
62 typedef struct _EmailKeyValue EmailKeyValue;
63 struct _EmailKeyValue {
64         gchar *mail;
65         gchar *alias;
66         gchar *remarks;
67 };
68
69 /**
70  * Structure to hold information about RDN.
71  */
72 typedef struct _Rdn Rdn;
73 struct _Rdn {
74         gchar *attribute;
75         gchar *value;
76         gchar *new_dn;
77 };
78
79 /**
80  * Retrieve address group item for update.
81  * \param group  Group to print.
82  * \param array  GHashTAble of item_group, or <i>NULL</i> if none created.
83  */
84 void ldapsvr_retrieve_item_group(ItemGroup *group, GHashTable *array) {
85         /* Not implemented in this release */
86         cm_return_if_fail(group != NULL);
87 }
88
89 /**
90  * Create an initial EmailKeyValue structure
91  * \return empty structure
92  */
93 EmailKeyValue *emailkeyvalue_create() {
94         EmailKeyValue *buf;
95
96         buf = g_new0(EmailKeyValue, 1);
97         buf->alias = NULL;
98         buf->mail = NULL;
99         buf->remarks = NULL;
100         return buf;
101 }
102
103 /**
104  * Create an initial AttrKeyValue structure
105  * \return empty structure
106  */
107 AttrKeyValue *attrkeyvalue_create() {
108         AttrKeyValue *buf;
109
110         buf = g_new0(AttrKeyValue, 1);
111         buf->key = NULL;
112         buf->value = NULL;
113         return buf;
114 }
115
116 /**
117  * Free created AttrKeyValue structure
118  * \param akv AttrKeyValue structure to free
119  */
120 void attrkeyvalue_free(AttrKeyValue *akv) {
121         if (akv->key) {
122                 g_free(akv->key);
123                 akv->key = NULL;
124         }
125         if (akv->value) {
126                 g_free(akv->value);
127                 akv->value = NULL;
128         }
129         g_free(akv);
130         akv = NULL;
131 }
132
133 /**
134  * Retrieve E-Mail address object for update.
135  * \param item   ItemEmail to update.
136  * \return object, or <i>NULL</i> if none created.
137  */
138 EmailKeyValue *ldapsvr_retrieve_item_email(ItemEMail *item) {
139         EmailKeyValue *newItem;
140         cm_return_val_if_fail(item != NULL, NULL);
141         newItem = emailkeyvalue_create();               
142         newItem->alias = g_strdup(ADDRITEM_NAME(item));
143         newItem->mail = g_strdup(item->address);
144         newItem->remarks = g_strdup(item->remarks);
145         return newItem;
146 }
147
148 /**
149  * Retrieve user attribute object for update.
150  * \param item   UserAttribute to update.
151  * \return object, or <i>NULL</i> if none created.
152  */
153 AttrKeyValue *ldapsvr_retrieve_attribute(UserAttribute *item) {
154         AttrKeyValue *newItem;
155         cm_return_val_if_fail(item != NULL, NULL);
156         newItem = attrkeyvalue_create();
157         newItem->key = g_strdup(item->name);
158         newItem->value = g_strdup(item->value);
159         return newItem;
160 }
161
162 /**
163  * Retrieve person object for update.
164  * \param person ItemPerson to update.
165  * \param array GHashTable with user input.
166  * \return false if update is not needed, or true if update is needed.
167  */
168 gboolean ldapsvr_retrieve_item_person(ItemPerson *person, GHashTable *array) {
169         GList *node, *attr;
170
171         cm_return_val_if_fail(person != NULL, FALSE);
172         switch (person->status) {
173                 case NONE: return FALSE;
174                 case ADD_ENTRY: g_hash_table_insert(array, "status", "new"); break;
175                 case UPDATE_ENTRY: g_hash_table_insert(array, "status", "update"); break;
176                 case DELETE_ENTRY: g_hash_table_insert(array, "status", "delete"); break;
177                 default: g_critical("ldapsvr_retrieve_item_person->Unknown status: %d", person->status);
178         }
179         g_hash_table_insert(array, "uid", ADDRITEM_ID(person));
180         g_hash_table_insert(array, "cn", ADDRITEM_NAME(person));
181         g_hash_table_insert(array, "givenName", person->firstName);
182         g_hash_table_insert(array, "sn", person->lastName);
183         g_hash_table_insert(array, "nickName", person->nickName);
184         g_hash_table_insert(array, "dn", person->externalID);
185         g_hash_table_insert(array, "person", person);
186         node = person->listEMail;
187         attr = NULL;
188         while (node) {
189                 EmailKeyValue *newEmail = ldapsvr_retrieve_item_email(node->data);
190                 if (newEmail)
191                         attr = g_list_append(attr, newEmail);
192                 node = g_list_next(node);
193         }
194         g_hash_table_insert(array, "mail", attr);
195         node = person->listAttrib;
196         attr = NULL;
197         while (node) {
198                 AttrKeyValue *newAttr = ldapsvr_retrieve_attribute(node->data);
199                 if (newAttr)
200                         attr = g_list_append(attr, newAttr);
201                 node = g_list_next(node);
202         }
203         g_hash_table_insert(array, "attribute", attr);
204         return TRUE;
205 }
206
207 /**
208  * Print contents of contacts hashtable for debug.
209  * This function must be called with g_hash_table_foreach.
210  * \param key Key to process.
211  * \param data Data to process.
212  * \param fd Output stream.
213  */
214 void ldapsvr_print_contacts_hashtable(gpointer key, gpointer data, gpointer fd) {
215         gchar *keyName = (gchar *) key;
216         GList *node;
217
218         if (g_ascii_strcasecmp("mail", keyName) == 0) {
219                 node = (GList *) data;
220                 while (node) {
221                         EmailKeyValue *item = node->data;
222                         if (debug_get_mode()) {
223                                 debug_print("\t\talias = %s\n", item->alias?item->alias:"null");
224                                 debug_print("\t\tmail = %s\n", item->mail?item->mail:"null");
225                                 debug_print("\t\tremarks = %s\n", item->remarks?item->remarks:"null");
226                         }
227                         else if (fd) {
228                                 FILE *stream = (FILE *) fd;
229                                 fprintf(stream, "\t\talias = %s\n", item->alias?item->alias:"null");
230                                 fprintf(stream, "\t\tmail = %s\n", item->mail?item->mail:"null");
231                                 fprintf(stream, "\t\tremarks = %s\n", item->remarks?item->remarks:"null");
232                         }
233                         node = g_list_next(node);
234                 }
235         }
236         else if (g_ascii_strcasecmp("attribute", keyName) == 0) {
237                 node = (GList *) data;
238                 while (node) {
239                         AttrKeyValue *item = node->data;
240                         if (debug_get_mode()) {
241                                 debug_print("\t\t%s = %s\n", item->key?item->key:"null",
242                                                 item->value?item->value:"null");
243                         }
244                         else if (fd) {
245                                 FILE *stream = (FILE *) fd;
246                                 fprintf(stream, "\t\t%s = %s\n", item->key?item->key:"null",
247                                                 item->value?item->value:"null");
248                         }
249                         node = g_list_next(node);
250                 }
251         }
252         else {
253                 if (debug_get_mode())
254                         debug_print("\t\t%s = %s\n", keyName?keyName:"null", data?(gchar *)data:"null");
255                 else if (fd) {
256                         FILE *stream = (FILE *) fd;
257                         fprintf(stream, "\t\t%s = %s\n", keyName?keyName:"null", data?(gchar *)data:"null");
258                 }
259         }
260 }
261
262 /**
263  * Free list of changed contacts
264  *
265  * \param list List of GHashTable
266  */
267 void ldapsvr_free_hashtable(GList *list) {
268         GList *tmp = list;
269         while (tmp) {
270                 g_hash_table_destroy(tmp->data);
271                 tmp->data = NULL;
272                 tmp = g_list_next(tmp);
273         }
274         g_list_free(list);
275         list = NULL;
276 }
277
278 /**
279  * Get person object from cache
280  *
281  * \param server Resource to LDAP
282  * \param uid PersonID in cache
283  * \return person object, or <i>NULL</i> if fail
284  */
285 ItemPerson *ldapsvr_get_contact(LdapServer *server, gchar *uid) {
286         AddrItemObject *aio;
287         cm_return_val_if_fail(server != NULL || uid != NULL, NULL);
288         aio = addrcache_get_object(server->addressCache, uid);
289         if (aio) {
290                 if(aio->type == ITEMTYPE_PERSON) {
291                         return (ItemPerson *) aio;
292                 }
293         }
294         return NULL;
295 }
296
297 /**
298  * Create an initial Rdn structure
299  *
300  * \return empty structure
301  */
302 Rdn *rdn_create() {
303         Rdn *buf;
304
305         buf = g_new0(Rdn, 1);
306         buf->attribute = NULL;
307         buf->value = NULL;
308         buf->new_dn = NULL;
309         return buf;
310 }
311
312 /**
313  * Free a created Rdn structure
314  * \param rdn Structure to free
315  */
316 void rdn_free(Rdn *rdn) {
317         if (rdn->attribute) {
318                 g_free(rdn->attribute);
319                 rdn->attribute = NULL;
320         }
321         if (rdn->value) {
322                 g_free(rdn->value);
323                 rdn->value = NULL;
324         }
325         if (rdn->new_dn) {
326                 g_free(rdn->new_dn);
327                 rdn->new_dn = NULL;
328         }
329         g_free(rdn);
330         rdn = NULL;
331 }
332
333 /**
334  * update Rdn structure
335  *
336  * \param rdn Rdn structure to update
337  * \param head Uniq part of dn
338  * \param tail Common part of dn
339  */
340 void update_rdn(Rdn *rdn, gchar *head, gchar *tail) {
341         rdn->value = g_strdup(head);
342         rdn->new_dn = g_strdup_printf("%s=%s%s", rdn->attribute, head, tail);
343 }
344
345 /**
346  * Deside if dn needs to be changed
347  *
348  * \param hash GHashTable with user input.
349  * \param dn dn for current object
350  * \return Rdn structure
351  */
352 Rdn *ldapsvr_modify_dn(GHashTable *hash, gchar *dn) {
353         Rdn *rdn;
354         gchar *pos, *compare;
355         gchar *rest;
356         gchar *val;
357         cm_return_val_if_fail(hash != NULL || dn != NULL, NULL);
358         
359         pos = g_strstr_len(dn, strlen(dn), "=");
360         if (!pos)
361                 return NULL;
362
363         compare = g_strndup(dn, pos - dn);
364
365         pos++;
366         rest = g_strstr_len(pos, strlen(pos), ",");
367         val = g_strndup(pos, rest - pos);
368         if (val == NULL) {
369                 if (compare)
370                         g_free(compare);
371                 return NULL;
372         }
373         rdn = rdn_create();
374         rdn->value = val;
375         rdn->attribute = compare;
376
377         if (strcmp("mail", rdn->attribute) == 0) {
378                 GList *list = g_hash_table_lookup(hash, rdn->attribute);
379                 while (list) {
380                         EmailKeyValue *item = list->data;
381                         compare = (gchar *) item->mail;
382                         if (strcmp(compare, rdn->value) == 0) {
383                                 update_rdn(rdn, compare, rest);
384                                 return rdn;
385                         }
386                         list = g_list_next(list);
387                 }
388                 /* if compare and rdn->attribute are equal then last email removed/empty  */
389                 if (strcmp(compare, rdn->attribute) != 0) {
390                         /* RDN changed. Find new */
391                         update_rdn(rdn, compare, rest);
392                         return rdn;
393                 }
394         }
395         else {
396                 compare = g_hash_table_lookup(hash, rdn->attribute);
397                 /* if compare and rdn->attribute are equal then dn removed/empty */
398                 if (compare != NULL && strcmp(compare, rdn->attribute) != 0) {
399                         update_rdn(rdn, compare, rest);
400                         return rdn;
401                 }
402         }
403         rdn_free(rdn);
404         return NULL;
405 }
406
407 /**
408  * This macro is borrowed from the Balsa project
409  * Creates a LDAPMod structure
410  *
411  * \param mods Empty LDAPMod structure
412  * \param modarr Array with values to insert
413  * \param op Operation to perform on LDAP
414  * \param attr Attribute to insert
415  * \param strv Empty array which is NULL terminated
416  * \param val Value for attribute
417  */
418 #define SETMOD(mods,modarr,op,attr,strv,val) \
419    do { (mods) = &(modarr); (modarr).mod_type=attr; (modarr).mod_op=op;\
420         (strv)[0]=(val); (modarr).mod_values=strv; \
421       } while(0)
422
423 /**
424  * Creates a LDAPMod structure
425  *
426  * \param mods Empty LDAPMod structure
427  * \param modarr Array with values to insert
428  * \param op Operation to perform on LDAP
429  * \param attr Attribute to insert
430  * \param strv Array with values to insert. Must be NULL terminated
431  */
432 #define SETMODS(mods,modarr,op,attr,strv) \
433    do { (mods) = &(modarr); (modarr).mod_type=attr; \
434                 (modarr).mod_op=op; (modarr).mod_values=strv; \
435       } while(0)
436 #define MODSIZE 10
437
438 /**
439  * Clean up, close LDAP connection, and refresh cache
440  *
441  * \param ld Resource to LDAP
442  * \param server AddressBook resource
443  * \param contact GHashTable with current changed object
444  */
445 void clean_up(LDAP *ld, LdapServer *server, GHashTable *contact) {
446         ItemPerson *person = 
447                 ldapsvr_get_contact(server, g_hash_table_lookup(contact , "uid"));
448         if (person) {
449                 gchar *displayName;
450                 person->status = NONE;
451                 displayName = g_hash_table_lookup(contact, "displayName");
452                 if (displayName)
453                         person->nickName = g_strdup(displayName);
454         }
455         if (server->retVal != LDAPRC_SUCCESS) {
456                 if (person) {
457                         ItemPerson *res = 
458                                 addrcache_remove_person(server->addressCache, person);
459                         if (!res)
460                                 g_critical("ldapsvr_update_book: Could not clean cache\n");
461                         else
462                                 addritem_free_item_person(res);
463                 }
464         }
465         if (ld)
466                 ldapsvr_disconnect(ld);
467 }
468
469 /**
470  * Get cn attribute from dn
471  *
472  * \param dn Distinguesh Name for current object
473  * \return AttrKeyValue, or <i>NULL</i> if none created
474  */
475 AttrKeyValue *get_cn(gchar *dn) {
476         AttrKeyValue *cn;
477         gchar *start;
478         gchar *end;
479         gchar *item;
480         gchar **key_value;
481         cm_return_val_if_fail(dn != NULL, NULL);
482         
483         cn = attrkeyvalue_create();
484         start = g_strstr_len(dn, strlen(dn), "cn");
485         if (start == NULL) {
486                 attrkeyvalue_free(cn);
487                 return NULL;
488         }
489         end = g_strstr_len(start, strlen(start), ",");
490         item = g_strndup(start, end - start);
491         if (item == NULL) {
492                 attrkeyvalue_free(cn);
493                 return NULL;
494         }
495         key_value = g_strsplit(item, "=", 2);
496         cn->key = g_strdup(key_value[0]);
497         cn->value = g_strdup(key_value[1]);
498         g_strfreev(key_value);
499         g_free(item);
500         return cn;
501 }
502
503 /**
504  * Get mail attribute from dn
505  *
506  * \param dn Distinguesh Name for current object
507  * \return AttrKeyValue, or <i>NULL</i> if none created
508  */
509 AttrKeyValue *get_mail(gchar *dn) {
510         AttrKeyValue *mail;
511         gchar *start;
512         gchar *end;
513         gchar *item;
514         gchar **key_value;
515         cm_return_val_if_fail(dn != NULL, NULL);
516         
517         mail = attrkeyvalue_create();
518         start = g_strstr_len(dn, strlen(dn), "mail");
519         if (start == NULL) {
520                 attrkeyvalue_free(mail);
521                 return NULL;
522         }
523         end = g_strstr_len(start, strlen(start), ",");
524         item = g_strndup(start, end - start);
525         if (item == NULL) {
526                 attrkeyvalue_free(mail);
527                 return NULL;
528         }
529         key_value = g_strsplit(item, "=", 2);
530         mail->key = g_strdup(key_value[0]);
531         mail->value = g_strdup(key_value[1]);
532         g_strfreev(key_value);
533         g_free(item);
534         return mail;
535 }
536
537 /**
538  * Get ou or o attribute from dn
539  *
540  * \param dn Distinguesh Name for current object
541  * \return AttrKeyValue, or <i>NULL</i> if none created
542  */
543 AttrKeyValue *get_ou(gchar *dn) {
544         AttrKeyValue *ou;
545         gchar *start;
546         gchar *end;
547         gchar *item;
548         gchar **key_value;
549         
550         cm_return_val_if_fail(dn != NULL, NULL);
551         ou = attrkeyvalue_create();
552         start = g_strstr_len(dn, strlen(dn), ",o=");
553         if (start == NULL)
554                 start = g_strstr_len(dn, strlen(dn), ",ou=");
555         if (start == NULL) {
556                 attrkeyvalue_free(ou);
557                 return NULL;
558         }
559         start++;
560         end = g_strstr_len(start, strlen(start), ",");
561         item = g_strndup(start, end - start);
562         if (item == NULL) {
563                 attrkeyvalue_free(ou);
564                 return NULL;
565         }
566         key_value = g_strsplit(item, "=", 2);
567         ou->key = g_strdup(key_value[0]);
568         ou->value = g_strdup(key_value[1]);
569         g_strfreev(key_value);
570         g_free(item);
571         return ou;
572 }
573
574 /**
575  * Print the contents of a LDAPMod structure for debuging purposes
576  *
577  * \param mods LDAPMod structure
578  */
579 void ldapsvr_print_ldapmod(LDAPMod *mods[]) {
580         gchar *mod_op;
581         int i;
582
583         cm_return_if_fail(mods != NULL);
584         g_printerr( "Type\n");
585         for (i = 0; NULL != mods[i]; i++) {
586                 LDAPMod *mod = (LDAPMod *) mods[i];
587                 gchar **vals;
588                 switch (mod->mod_op) {
589                         case LDAP_MOD_ADD: mod_op = g_strdup("ADD"); break;
590                         case LDAP_MOD_REPLACE: mod_op = g_strdup("MODIFY"); break;
591                         case LDAP_MOD_DELETE: mod_op = g_strdup("DELETE"); break;
592                         default: mod_op = g_strdup("UNKNOWN");
593                 }
594                 g_printerr( "Operation: %s\tType:%s\nValues:\n", mod_op, mod->mod_type);
595                 vals = mod->mod_vals.modv_strvals;
596                 while (*vals) {
597                         g_printerr( "\t%s\n", *vals++);
598                 }
599         }
600 }
601
602 /**
603  * Make a compare for every new value we want to store in the
604  * directory with the current values. Great tool for debugging
605  * against invalid syntax in attributes
606  *
607  * \param ld AddressBook resource
608  * \param dn dn for the entry
609  * \param cnt Number of attributes to compare
610  * \param  mods LDAPMod structure
611  */
612 void ldapsvr_compare_attr(LDAP *ld, gchar *dn, gint cnt, LDAPMod *mods[]) {
613         int i, rc;
614
615 #ifdef OPEN_LDAP_API_AT_LEAST_3000
616
617         struct berval val;
618
619 #endif
620
621         cm_return_if_fail(ld != NULL || dn != NULL || cnt >= 0 || mods != NULL);
622         for (i = 0; i < cnt; i++) {
623                 gchar *value = g_strdup(mods[i]->mod_vals.modv_strvals[0]);
624                 if (!value || strcmp(value, "") == 0)
625                         value = g_strdup("thisisonlyadummy");
626
627 #ifdef OPEN_LDAP_API_AT_LEAST_3000
628
629                 val.bv_val = value;
630                 val.bv_len = strlen(value);
631
632                 rc = ldap_compare_ext_s(ld, dn, mods[i]->mod_type, &val, NULL, NULL);
633
634 #else
635
636                 /* This is deprecated as of OpenLDAP-2.3.0 */
637                 rc = ldap_compare_s(ld, dn, mods[i]->mod_type, value);
638
639 #endif
640
641                 g_printerr("ldap_compare for (%s:%s)\" failed[0x%x]: %s\n",
642                 mods[i]->mod_type, value, rc, ldaputil_get_error(ld));
643                 g_free(value);
644         }
645 }
646
647 /**
648  * compare attribute to LDAP in case of LDAP_INAPPROPRIATE_MATCHING
649  *
650  * \param ld AddressBook resource
651  * \param server Reference to server
652  * \param dn dn for the entry
653  * \param attr Attribute
654  * \param value New value
655  * \return int, return will be LDAP_MOD_ADD, LDAP_MOD_REPLACE, or LDAP_MOD_DELETE
656  */
657 int ldapsvr_compare_manual_attr(LDAP *ld, LdapServer *server, gchar *dn, char *attr, char *value) {
658         LDAPMessage *res, *e = NULL;
659         BerElement *ber;
660         struct berval **vals;
661         int rc;
662         LdapControl *ctl;
663         gchar *filter;
664         gchar *attribute;
665         int retVal = -2, i;
666         AttrKeyValue *mail;
667
668         cm_return_val_if_fail(ld != NULL || server != NULL || attr != NULL, -1);
669         ctl = server->control;
670         mail = get_mail(dn);
671         if (! mail)
672                 return -2;
673         filter = g_strdup_printf("(&(mail=%s)(%s=*))", mail->value, attr);
674         attrkeyvalue_free(mail);
675         if (ctl) {
676
677                 rc = ldap_search_ext_s(ld, ctl->baseDN, LDAP_SCOPE_ONELEVEL, filter, NULL, 0, NULL, NULL, NULL, 0, &res);
678
679                 if (rc) {
680                         log_error(LOG_PROTOCOL, _("LDAP error (search): for attribute '%s': %d (%s)\n"),
681                                         attr, rc, ldaputil_get_error(ld));
682                         retVal = -2;
683                 }
684                 else {
685                         e = ldap_first_entry(ld, res);
686                         /* entry has this attribute */
687                         if (e) {
688                                 attribute = ldap_first_attribute( ld, e, &ber );
689                                 if (attribute) {
690                                         if (value) {
691                                                 if( ( vals = ldap_get_values_len( ld, e, attr ) ) != NULL ) {
692                                                         for( i = 0; vals[i] != NULL; i++ ) {
693                                                                 debug_print("Compare: %s=%s\n", attr, vals[i]->bv_val);
694                                                                 /* attribute has same value */
695                                                                 if (strcmp(vals[i]->bv_val, value) == 0)
696                                                                         retVal = -1;
697                                                                 /* attribute has new value */
698                                                                 else
699                                                                         retVal = LDAP_MOD_REPLACE;
700                                                         }
701                                                 }
702                                                 ldap_value_free_len(vals);
703                                         }
704                                         else
705                                                 retVal = LDAP_MOD_DELETE;
706                                 }
707                                 if( ber != NULL ) {
708                                         ber_free( ber, 0 );
709                                 }
710                                 ldap_memfree(attribute);
711                         }
712                         /* entry does not have this attribute */
713                         else {
714                                 /* Only add if this is a real attribute */
715                                 if (value)
716                                         retVal = LDAP_MOD_ADD;
717                                 /* This is dummy value used to avoid ldap_compare error */
718                                 else
719                                         retVal = -1;
720                         }
721                 }
722         }
723         else
724                 retVal = -2;
725         g_free(filter);
726         return retVal;
727 }
728
729 /**
730  * Deside which kind of operation is required to handle
731  * updating the specified attribute
732  *
733  * \param ld AddressBook resource
734  * \param server Reference to server
735  * \param dn dn for the entry
736  * \param attr Attribute
737  * \param value New value
738  * \return int, return will be LDAP_MOD_ADD, LDAP_MOD_REPLACE, or LDAP_MOD_DELETE
739  */
740 int ldapsvr_deside_operation(LDAP *ld, LdapServer *server, char *dn, char *attr, char *value) {
741         int rc;
742         gboolean dummy = FALSE;
743
744 #ifdef OPEN_LDAP_API_AT_LEAST_3000
745
746         struct berval val;
747
748 #endif
749
750         cm_return_val_if_fail(ld != NULL || server != NULL || dn != NULL || attr != NULL, -1);
751         if (value == NULL)
752                 return -1;
753         /* value containing empty string cause invalid syntax. A bug in
754          * the LDAP library? Therefore we add a dummy value
755          */
756         if (strcmp(value,"") == 0) {
757                 value = g_strdup("thisisonlyadummy");
758                 dummy = TRUE;
759         }
760
761 #ifdef OPEN_LDAP_API_AT_LEAST_3000
762
763         val.bv_val = value;
764         val.bv_len = strlen(value);
765
766         rc = ldap_compare_ext_s(ld, dn, attr, &val, NULL, NULL);
767
768 #else
769
770         /* This is deprecated as of OpenLDAP-2.3.0 */
771         rc = ldap_compare_s(ld, dn, attr, value);
772
773 #endif
774
775         debug_print("ldap_compare for (%s:%s)\" error_code[0x%x]: %s\n",
776         attr, value, rc, ldaputil_get_error(ld));
777         switch (rc) {
778                 case LDAP_COMPARE_FALSE: 
779                         if (dummy)
780                                 return LDAP_MOD_DELETE;
781                         else
782                                 return LDAP_MOD_REPLACE;
783                 case LDAP_COMPARE_TRUE: return -1;
784                 case LDAP_NO_SUCH_ATTRIBUTE: return LDAP_MOD_ADD;
785                 /* LDAP_INAPPROPRIATE_MATCHING needs extensive testing because I
786                  * am not aware off the condition causing this return value!
787                  */
788                 case LDAP_INAPPROPRIATE_MATCHING:
789                         if (dummy)
790                                 value = NULL;
791                         return ldapsvr_compare_manual_attr(ld, server, dn, attr, value);
792                 case LDAP_UNDEFINED_TYPE: return -2;
793                 case LDAP_INVALID_SYNTAX: return -2;
794                 default: return -2;
795         }
796 }
797
798 /**
799  * Check if attribute is part of the current search criteria
800  *
801  * \param list Array containing attributes in the current search criteria
802  * \param attr Attribute to check
803  * \result <i>TRUE</i> if attribute is found in the current search criteria
804  */
805 gboolean ldapsvr_check_search_attributes(char **list, char *attr) {
806         while (*list) {
807                 if (strcmp(*list++, attr) == 0)
808                         return TRUE;
809         }
810         return FALSE;
811 }
812
813 /**
814  * Deside which other attributes needs updating
815  *
816  * \param ld LDAP resource
817  * \param server AddressBook resource
818  * \param dn dn for the entry
819  * \param contact GHashTable with information for the current contact
820  */
821 void ldapsvr_handle_other_attributes(LDAP *ld, LdapServer *server, char *dn, GHashTable *contact) {
822         GList *node;
823         gboolean CHECKED_ATTRIBUTE[ATTRIBUTE_SIZE + 1];
824         LDAPMod *mods[ATTRIBUTE_SIZE + 1];
825         LDAPMod modarr[ATTRIBUTE_SIZE];
826         gint cnt = 0;
827         char *attr[ATTRIBUTE_SIZE + 1][2];
828         int mod_op, rc, i;
829
830         cm_return_if_fail(server != NULL || dn != NULL || contact != NULL);
831         for (i = 0; i <= ATTRIBUTE_SIZE; i++) {
832                 CHECKED_ATTRIBUTE[i] = FALSE;
833                 attr[i][0] = attr[i][1] = NULL;
834         }
835         node = g_hash_table_lookup(contact , "attribute");
836         while (node) {
837                 AttrKeyValue *item = node->data;
838                 if (item) {
839                         int index = get_attribute_index(item->key);
840                         if (index >= 0) {
841                                 debug_print("Found other attribute: %s = %s\n",
842                                                 item->key?item->key:"null", item->value?item->value:"null");
843                                 mod_op = ldapsvr_deside_operation(ld, server, dn, item->key, item->value);
844                                 /* Only consider attributes which we no how to handle.
845                                  * Set to TRUE in CHECKED_ATTRIBUTE array to indicate no further action
846                                  */
847                                 if (mod_op < 0) {
848                                         CHECKED_ATTRIBUTE[index] = TRUE;
849                                         node = g_list_next(node);
850                                         continue;
851                                 }
852                                 if (mod_op == LDAP_MOD_DELETE) {
853                                         /* Setting param to NULL instructs OpenLDAP to remove any
854                                         * value stored for this attribute and remove the attribute
855                                         * completely. Should multiple instances of an attribute be
856                                         * allowed in the future param is required to have the value
857                                         * store for the attribute which is going to be deleted
858                                         */
859                                         item->value = NULL;
860                                 }
861                                 if (mod_op == LDAP_MOD_REPLACE && strcmp(item->value, "") == 0) {
862                                         /* Having an empty string is considered a syntax error in
863                                         * ldap. E.g attributes with empty strings are not allowed
864                                         * in which case we treate this as a request for deleting
865                                         * the attribute.
866                                         */
867                                         mod_op = LDAP_MOD_DELETE;
868                                         item->value = NULL;
869                                 }
870                                 if (mod_op == LDAP_MOD_ADD && strcmp(item->value, "") == 0) {
871                                         /* Adding an empty string is considered a syntax error in
872                                         * ldap. E.g attributes with empty strings are not allowed
873                                         * in which case we silently refuse to add this entry
874                                         */
875                                 }
876                                 else {
877                                         SETMOD(mods[cnt], modarr[cnt], mod_op, g_strdup(item->key), attr[cnt], g_strdup(item->value));
878                                         cnt++;
879                                         CHECKED_ATTRIBUTE[index] = TRUE;
880                                 }
881                         }
882                 }
883                 node = g_list_next(node);
884         }
885         char **attribs = ldapctl_full_attribute_array(server->control);
886         for (i = 0; i < ATTRIBUTE_SIZE; i++) {
887                 /* Attributes which holds no information are to be removed */
888                 if (CHECKED_ATTRIBUTE[i] == FALSE) {
889                         /* Only consider those attributes which is currently part of the search criteria.
890                          * If attributes are not part of the search criteria they would seem to hold
891                          * no information since their values will not be populated in the GUI
892                          */
893                         if (!strcmp(ATTRIBUTE[i], "jpegPhoto")) {
894                                 debug_print("not updating jpegPhoto\n");
895                                 continue;
896                         }
897                         if (ldapsvr_check_search_attributes(attribs, (char *) ATTRIBUTE[i])) {
898                                 mod_op = ldapsvr_deside_operation(ld, server, dn, (char *) ATTRIBUTE[i], "");
899                                 if (mod_op == LDAP_MOD_DELETE) {
900                                         SETMOD(mods[cnt], modarr[cnt], LDAP_MOD_DELETE, g_strdup((char *) ATTRIBUTE[i]), attr[cnt], NULL);
901                                         cnt++;
902                                 }
903                         }
904                 }
905         }
906         ldapctl_free_attribute_array(attribs);
907         mods[cnt] = NULL;
908         if (debug_get_mode())
909                 ldapsvr_print_ldapmod(mods);
910         server->retVal = LDAPRC_SUCCESS;
911         rc = ldap_modify_ext_s(ld, dn, mods, NULL, NULL);
912         if (rc) {
913                 switch (rc) {
914                         case LDAP_ALREADY_EXISTS: 
915                                 server->retVal = LDAPRC_ALREADY_EXIST;
916                                 break;
917                         default:
918                                 log_error(LOG_PROTOCOL, _("LDAP error (modify): for DN '%s': %d (%s)\n"),
919                                                 dn, rc, ldaputil_get_error(ld));
920                                 if (rc == 0x8)
921                                         server->retVal = LDAPRC_STRONG_AUTH;
922                                 else
923                                         server->retVal = LDAPRC_NAMING_VIOLATION;
924                 }
925         }
926         else {
927                 char **attribs = ldapctl_full_attribute_array(server->control);
928                 for (i = 0; i < ATTRIBUTE_SIZE; i++) {
929                         if (!strcmp(ATTRIBUTE[i], "jpegPhoto")) {
930                                 debug_print("not updating jpegPhoto\n");
931                                 continue;
932                         }
933                         if (ldapsvr_check_search_attributes(attribs, (char *) ATTRIBUTE[i])) {
934                                 if (CHECKED_ATTRIBUTE[i] == FALSE) {
935                                         AddrItemObject *aio = addrcache_get_object(server->addressCache, g_hash_table_lookup(contact , "uid"));
936                                         ItemPerson *person = (ItemPerson *) aio;
937                                         addritem_person_remove_attribute(person, (const gchar *) ATTRIBUTE[i]);
938                                 }
939                         }
940                 }
941                 ldapctl_free_attribute_array(attribs);
942         }
943 }
944
945 /**
946  * Add new contact to LDAP
947  *
948  * \param server AddressBook resource
949  * \param contact GHashTable with object to add
950  */
951 void ldapsvr_add_contact(LdapServer *server, GHashTable *contact) {
952         gchar *email = NULL, *param = NULL;
953         LDAP *ld = NULL;
954         LDAPMod *mods[MODSIZE];
955         LDAPMod modarr[7];
956         gint cnt = 0;
957         char *cn[] = {NULL, NULL};
958         char *displayName[] = {NULL, NULL};
959         char *givenName[] = {NULL, NULL};
960         char **mail = NULL;
961         char *sn[] = {NULL, NULL};
962         char *org[] = {NULL, NULL};
963         char *obj[] = {/*"top",*/ "person", "organizationalPerson", "inetOrgPerson", NULL}; 
964         int rc=0;
965         GList *node;
966         AttrKeyValue *ou, *commonName;
967         ItemPerson *person;
968         gchar *base_dn;
969         GList *mailList;
970
971         cm_return_if_fail(server != NULL || contact != NULL);
972         node = g_hash_table_lookup(contact , "mail");
973         if (node) {
974                 EmailKeyValue *newEmail = node->data;
975                 email = g_strdup(newEmail->mail);
976         }
977         if (email == NULL) {
978                 server->retVal = LDAPRC_NODN;
979                 clean_up(ld, server, contact);
980                 return;
981         }
982         base_dn = g_strdup_printf("mail=%s,%s",
983                         email, server->control->baseDN?server->control->baseDN:"null");
984         g_free(email);
985         person = 
986                 ldapsvr_get_contact(server, g_hash_table_lookup(contact , "uid"));
987         person->externalID = g_strdup(base_dn);
988         debug_print("dn: %s\n", base_dn);
989         ld = ldapsvr_connect(server->control);
990         if (ld == NULL) {
991                 clean_up(ld, server, contact);
992                 debug_print("no ldap found\n");
993                 return;
994         }
995         SETMODS(mods[cnt], modarr[cnt], LDAP_MOD_ADD, "objectClass", obj);
996         cnt++;
997         ou = get_ou(base_dn);
998         if (ou != NULL) {
999                 SETMOD(mods[cnt], modarr[cnt], LDAP_MOD_ADD, g_strdup(ou->key), org, g_strdup(ou->value));
1000                 cnt++;
1001                 attrkeyvalue_free(ou);
1002         }
1003         
1004         commonName = get_cn(base_dn);
1005         if (commonName == NULL) {
1006                 param = g_hash_table_lookup(contact , "cn");
1007                 if (param) {
1008                         SETMOD(mods[cnt], modarr[cnt], LDAP_MOD_ADD, "cn", cn, param);
1009                 }
1010                 else {
1011                         clean_up(ld, server, contact);
1012                         debug_print("no CN found\n");
1013                         return;
1014                 }
1015         }
1016         else {
1017                 SETMOD(mods[cnt], modarr[cnt], LDAP_MOD_ADD, g_strdup(commonName->key), cn, g_strdup(commonName->value));
1018                 cnt++;
1019                 param = g_hash_table_lookup(contact , "cn");
1020                 SETMOD(mods[cnt], modarr[cnt], LDAP_MOD_ADD, "displayName", displayName, param);
1021                 g_hash_table_insert(contact, "displayName", param);
1022                 attrkeyvalue_free(commonName);
1023         }
1024         cnt++;
1025         param = g_hash_table_lookup(contact , "givenName");
1026         if (param) {
1027                 SETMOD(mods[cnt], modarr[cnt], LDAP_MOD_ADD, "givenName", givenName, param);
1028                 cnt++;
1029         }
1030         mailList = g_hash_table_lookup(contact , "mail");
1031         if (mailList) {
1032                 char **tmp;
1033                 tmp = g_malloc(sizeof(*tmp) * (g_list_length(mailList)+1));
1034                 mail = tmp;
1035                 while (mailList) {
1036                         EmailKeyValue *item = mailList->data;
1037                         *tmp++ = g_strdup((gchar *) item->mail);
1038                         mailList = g_list_next(mailList);
1039                 }
1040                 *tmp = NULL;
1041                 SETMODS(mods[cnt], modarr[cnt], LDAP_MOD_ADD, "mail", mail);
1042                 cnt++;
1043         }
1044         param = g_hash_table_lookup(contact, "sn");
1045         if (param == NULL)
1046                 param = g_strdup(N_("Some SN"));
1047         SETMOD(mods[cnt], modarr[cnt], LDAP_MOD_ADD, "sn", sn, param);
1048         cnt++;
1049         mods[cnt] = NULL;
1050         if (debug_get_mode()) {
1051                 ldapsvr_print_ldapmod(mods);
1052         }
1053         server->retVal = LDAPRC_SUCCESS;
1054         rc = ldap_add_ext_s(ld, base_dn, mods, NULL, NULL);
1055         if (rc) {
1056                 switch (rc) {
1057                         case LDAP_ALREADY_EXISTS: 
1058                                 server->retVal = LDAPRC_ALREADY_EXIST;
1059                                 break;
1060                         default:
1061                                 log_error(LOG_PROTOCOL, _("LDAP error (modify): for DN '%s': %d (%s)\n"),
1062                                                 base_dn, rc, ldaputil_get_error(ld));
1063                                 if (rc == 0x8)
1064                                         server->retVal = LDAPRC_STRONG_AUTH;
1065                                 else
1066                                         server->retVal = LDAPRC_NAMING_VIOLATION;
1067                 }
1068         }
1069         ldapsvr_handle_other_attributes(ld, server, base_dn, contact);
1070         g_free(base_dn);
1071         clean_up(ld, server, contact);
1072 }
1073
1074 /**
1075  * Update contact to LDAP
1076  *
1077  * \param server AddressBook resource
1078  * \param contact GHashTable with object to update
1079  */
1080 void ldapsvr_update_contact(LdapServer *server, GHashTable *contact) {
1081         LDAP *ld = NULL;
1082         LDAPMod *mods[MODSIZE];
1083         LDAPMod modarr[4];
1084         gint cnt = 0;
1085         gchar *param, *dn;
1086         Rdn *NoRemove = NULL;
1087         char *cn[] = {NULL, NULL};
1088         char *givenName[] = {NULL, NULL};
1089         char **mail = NULL;
1090         char *sn[] = {NULL, NULL};
1091         GList *mailList;
1092         int mod_op;
1093
1094         cm_return_if_fail(server != NULL || contact != NULL);
1095         ld = ldapsvr_connect(server->control);
1096         if (ld == NULL) {
1097                 clean_up(ld, server, contact);
1098                 return;
1099         }
1100         dn = g_hash_table_lookup(contact, "dn");
1101
1102         if (dn == NULL) {
1103                 clean_up(ld, server, contact);
1104                 return;
1105         }
1106         NoRemove = ldapsvr_modify_dn(contact, dn);
1107         if (NoRemove) {
1108                 /* We are trying to change RDN */
1109                 gchar *newRdn = g_strdup_printf("%s=%s", NoRemove->attribute, NoRemove->value);
1110
1111 #ifdef OPEN_LDAP_API_AT_LEAST_3000
1112
1113                 int rc = ldap_rename_s(ld, dn, newRdn, NULL, 1, NULL, NULL);
1114
1115 #else
1116
1117                 /* This is deprecated as of OpenLDAP-2.3.0 */
1118                 int rc = ldap_modrdn2_s(ld, dn, newRdn, 1);
1119
1120 #endif
1121
1122                 if(rc != LDAP_SUCCESS) {
1123                         if (rc ==  LDAP_ALREADY_EXISTS) {
1124                                 /* We are messing with a contact with more than one listed email
1125                                  * address and the email we are changing is not the one used for dn
1126                                  */
1127                                 /* It needs to be able to handle renaming errors to an already defined
1128                                  * dn. For now we just refuse the update. It will be caught later on as
1129                                  * a LDAPRC_NAMING_VIOLATION error.
1130                                  */
1131                         }
1132                         else {
1133                                 log_error(LOG_PROTOCOL, _("LDAP error (rename): from '%s' to '%s': %d (%s)\n"),
1134                                                 dn, newRdn, rc, ldaputil_get_error(ld));
1135                                 g_free(newRdn);
1136                                 clean_up(ld, server, contact);
1137                                 return;
1138                         }
1139                 }
1140                 else {
1141                         ItemPerson *person = g_hash_table_lookup(contact, "person");
1142                         g_free(newRdn);
1143                         dn = g_strdup(NoRemove->new_dn);
1144                         g_hash_table_replace(contact, "dn", dn);
1145                         if (person) {
1146                                 g_free(person->externalID);
1147                                 person->externalID = dn;
1148                         }
1149                 }
1150         }
1151         else {
1152                 server->retVal = LDAPRC_NODN;
1153                 clean_up(ld, server, contact);
1154                 return;
1155         }
1156         param = g_hash_table_lookup(contact , "cn");
1157         mod_op = ldapsvr_deside_operation(ld, server, dn, "displayName", param);
1158         if (mod_op >= 0 && (strcmp(param, NoRemove->value) != 0 && strcmp("cn", NoRemove->attribute) != 0)) {
1159                 if (mod_op == LDAP_MOD_DELETE) {
1160                         /* Setting param to NULL instructs OpenLDAP to remove any
1161                          * value stored for this attribute and remove the attribute
1162                          * completely. Should multiple instances of an attribute be
1163                          * allowed in the future param is required to have the value
1164                          * store for the attribute which is going to be deleted
1165                          */
1166                         param = NULL;
1167                 }
1168                 if (mod_op == LDAP_MOD_REPLACE && strcmp(param, "") == 0) {
1169                         /* Having an empty string is considered a syntax error in
1170                          * ldap. E.g attributes with empty strings are not allowed
1171                          * in which case we treate this as a request for deleting
1172                          * the attribute.
1173                          */
1174                         mod_op = LDAP_MOD_DELETE;
1175                         param = NULL;
1176                 }
1177                 if (mod_op == LDAP_MOD_ADD && strcmp(param, "") == 0) {
1178                         /* Adding an empty string is considered a syntax error in
1179                          * ldap. E.g attributes with empty strings are not allowed
1180                          * in which case we silently refuse to add this entry
1181                          */
1182                 }
1183                 else {
1184                         SETMOD(mods[cnt], modarr[cnt], mod_op, "displayName", cn, param);
1185                         cnt++;
1186                         g_hash_table_insert(contact, "displayName", param);
1187                 }
1188         }
1189         param = g_hash_table_lookup(contact , "givenName");
1190         mod_op = ldapsvr_deside_operation(ld, server, dn, "givenName", param);
1191         if (mod_op >= 0 && (strcmp(param, NoRemove->value) != 0 && strcmp("givenName", NoRemove->attribute) != 0)) {
1192                 if (mod_op == LDAP_MOD_DELETE) {
1193                         /* Setting param to NULL instructs OpenLDAP to remove any
1194                          * value stored for this attribute and remove the attribute
1195                          * completely. Should multiple instances of an attribute be
1196                          * allowed in the future param is required to have the value
1197                          * store for the attribute which is going to be deleted
1198                          */
1199                         param = NULL;
1200                 }
1201                 if (mod_op == LDAP_MOD_REPLACE && strcmp(param, "") == 0) {
1202                         /* Having an empty string is considered a syntax error in
1203                          * ldap. E.g attributes with empty strings are not allowed
1204                          * in which case we treate this as a request for deleting
1205                          * the attribute.
1206                          */
1207                         mod_op = LDAP_MOD_DELETE;
1208                         param = NULL;
1209                 }
1210                 if (mod_op == LDAP_MOD_ADD && strcmp(param, "") == 0) {
1211                         /* Adding an empty string is considered a syntax error in
1212                          * ldap. E.g attributes with empty strings are not allowed
1213                          * in which case we silently refuse to add this entry
1214                          */
1215                 }
1216                 else {
1217                         SETMOD(mods[cnt], modarr[cnt], mod_op, "givenName", givenName, param);
1218                         cnt++;
1219                 }
1220         }
1221         mailList = g_hash_table_lookup(contact , "mail");
1222         if (mailList) {
1223                 debug_print("# of mail: %d\n", g_list_length(mailList));
1224                 if (!(strcmp("mail", NoRemove->attribute) == 0 && g_list_length(mailList) == 1)) {
1225                         char **tmp;
1226                         tmp = g_malloc(sizeof(*tmp) * (g_list_length(mailList)+1));
1227                         mail = tmp;
1228                         while (mailList) {
1229                                 EmailKeyValue *item = mailList->data;
1230                                 *tmp++ = g_strdup((gchar *) item->mail);
1231                                 mailList = g_list_next(mailList);
1232                         }
1233                         *tmp = NULL;
1234                         /*
1235                          * At least one email address is required
1236                          * in which case it will always be a replace
1237                          */
1238                         SETMODS(mods[cnt], modarr[cnt], LDAP_MOD_REPLACE, "mail", mail);
1239                         cnt++;
1240                 }
1241         }
1242         else {
1243                 /*
1244                  * an error condition since at least one email adress
1245                  * is required. Should never occur though.
1246                  */
1247         }
1248         param = g_hash_table_lookup(contact , "sn");
1249         mod_op = ldapsvr_deside_operation(ld, server, dn, "sn", param);
1250         if (mod_op >= 0 && (strcmp(param, NoRemove->value) != 0 && strcmp("sn", NoRemove->attribute) != 0)) {
1251                 if (mod_op == LDAP_MOD_DELETE) {
1252                         /* Setting param to NULL instructs OpenLDAP to remove any
1253                          * value stored for this attribute and remove the attribute
1254                          * completely. Should multiple instances of an attribute be
1255                          * allowed in the future param is required to have the value
1256                          * store for the attribute which is going to be deleted
1257                          */
1258                         param = NULL;
1259                 }
1260                 if (mod_op == LDAP_MOD_REPLACE && strcmp(param, "") == 0) {
1261                         /* Having an empty string is considered a syntax error in
1262                          * ldap. E.g attributes with empty strings are not allowed
1263                          * in which case we treate this as a request for deleting
1264                          * the attribute.
1265                          */
1266                         mod_op = LDAP_MOD_DELETE;
1267                         param = NULL;
1268                 }
1269                 if (mod_op == LDAP_MOD_ADD && strcmp(param, "") == 0) {
1270                         /* Adding an empty string is considered a syntax error in
1271                          * ldap. E.g attributes with empty strings are not allowed
1272                          * in which case we silently refuse to add this entry
1273                          */
1274                 }
1275                 else {
1276                         SETMOD(mods[cnt], modarr[cnt], mod_op, "sn", sn, param);
1277                         cnt++;
1278                 }
1279         }
1280         debug_print("newDN: %s\n", dn);
1281         if (NoRemove)
1282                 rdn_free(NoRemove);
1283         server->retVal = LDAPRC_SUCCESS;
1284         if (cnt > 0) {
1285                 int rc;
1286                 mods[cnt] = NULL;
1287                 rc = ldap_modify_ext_s(ld, dn, mods, NULL, NULL);
1288                 if (rc) {
1289                         log_error(LOG_PROTOCOL, _("LDAP error (modify): for DN '%s': %d (%s)\n"),
1290                                         dn, rc, ldaputil_get_error(ld));
1291                         server->retVal = LDAPRC_NAMING_VIOLATION;
1292                 }
1293                 if (mail)
1294                         g_free(mail);
1295         }
1296         ldapsvr_handle_other_attributes(ld, server, dn, contact);
1297         /* If we do not make changes persistent at this point then changes
1298          * will be lost if the user makes new search on the same server since
1299          * changes are only present in Claws' internal cache. This issue has to
1300          * be solved in addressbook.c since this involves access to structures
1301          * which are only accessible in addressbook.c */
1302         clean_up(ld, server, contact);
1303 }
1304
1305 /**
1306  * Delete contact from LDAP
1307  *
1308  * \param server AddressBook resource
1309  * \param contact GHashTable with object to delete
1310  */
1311 void ldapsvr_delete_contact(LdapServer *server, GHashTable *contact) {
1312         LDAP *ld = NULL;
1313         gchar *dn;
1314         int rc;
1315
1316         cm_return_if_fail(server != NULL || contact != NULL);
1317         ld = ldapsvr_connect(server->control);
1318         if (ld == NULL) {
1319                 clean_up(ld, server, contact);
1320                 return;
1321         }
1322         dn = g_hash_table_lookup(contact, "dn");
1323         if (dn == NULL) {
1324                 clean_up(ld, server, contact);
1325                 return;
1326         }
1327         server->retVal = LDAPRC_SUCCESS;
1328         rc = ldap_delete_ext_s(ld, dn, NULL, NULL);
1329         if (rc) {
1330                 log_error(LOG_PROTOCOL, _("LDAP error (modify): for DN '%s': %d (%s)\n"),
1331                                 dn, rc, ldaputil_get_error(ld));
1332                 server->retVal = LDAPRC_NODN;
1333         }
1334         clean_up(ld, server, contact);
1335 }
1336
1337 /**
1338  * Update any changes to the server.
1339  *
1340  * \param server AddressBook resource.
1341  * \param person ItemPerson holding user input.
1342  */
1343 void ldapsvr_update_book(LdapServer *server, ItemPerson *item) {
1344         GList *node = NULL;
1345         GHashTable *contact = NULL;
1346         GList *contacts = NULL, *head = NULL;
1347
1348         cm_return_if_fail(server != NULL);
1349         debug_print("updating ldap addressbook\n");
1350
1351         contact = g_hash_table_new(g_str_hash, g_str_equal);
1352         if (item) {
1353                 gboolean result = ldapsvr_retrieve_item_person(item, contact);
1354                 debug_print("Found contact to update: %s\n", result? "Yes" : "No");
1355                 if (result) {
1356                         if (debug_get_mode()) {
1357                                 addritem_print_item_person(item, stdout);
1358                         }
1359                         contacts = g_list_append(contacts, contact);
1360                 }
1361         }
1362         else {
1363                 ItemFolder *folder = server->addressCache->rootFolder;
1364                 node = folder->listFolder;
1365                 if (node) {
1366                         while (node) {
1367                                 AddrItemObject *aio = node->data;
1368                                 if (aio) {
1369                                         if (aio->type == ITEMTYPE_FOLDER) {
1370                                                 ItemFolder *folder = (ItemFolder *) aio;
1371                                                 GList *persons = folder->listPerson;
1372                                                 while (persons) {
1373                                                         AddrItemObject *aio = persons->data;
1374                                                         if (aio) {
1375                                                                 if (aio->type == ITEMTYPE_PERSON) {
1376                                                                         ItemPerson *item = (ItemPerson *) aio;
1377                                                                         gboolean result = ldapsvr_retrieve_item_person(item, contact);
1378                                                                         debug_print("Found contact to update: %s\n", result? "Yes" : "No");
1379                                                                         if (result) {
1380                                                                                 if (debug_get_mode()) {
1381                                                                                         gchar *uid = g_hash_table_lookup(contact, "uid");
1382                                                                                         item = ldapsvr_get_contact(server, uid);
1383                                                                                         addritem_print_item_person(item, stdout);
1384                                                                                 }
1385                                                                                 contacts = g_list_append(contacts, contact);
1386                                                                         }
1387                                                                 }
1388                                                         }
1389                                                         persons = g_list_next(persons);
1390                                                 }
1391                                         }
1392                                 }
1393                                 else {
1394                                         g_printerr("\t\tpid : ???\n");
1395                                 }
1396                                 node = g_list_next(node);
1397                         }
1398                 }
1399         }
1400         head = contacts;
1401         if (debug_get_mode()) {
1402                 if (contacts)
1403                         debug_print("Contacts which must be updated in LDAP:\n");
1404                 while (contacts) {
1405                         debug_print("\tContact:\n");
1406                         g_hash_table_foreach(contacts->data, 
1407                                 ldapsvr_print_contacts_hashtable, stderr);
1408                         contacts = g_list_next(contacts);
1409                 }
1410         }
1411         if (contacts == NULL)
1412                 contacts = head;
1413         while (contacts) {
1414                 gchar *status;
1415                 contact = (GHashTable *) contacts->data;
1416                 status = (gchar *) g_hash_table_lookup(contact, "status");
1417                 if (status == NULL)
1418                         status = g_strdup("NULL");
1419                 if (g_ascii_strcasecmp(status, "new") == 0) {
1420                         ldapsvr_add_contact(server, contact);
1421                 }
1422                 else if (g_ascii_strcasecmp(status, "update") == 0) {
1423                         ldapsvr_update_contact(server, contact);
1424                 }
1425                 else if (g_ascii_strcasecmp(status, "delete") == 0) {
1426                         ldapsvr_delete_contact(server, contact);
1427                 }
1428                 else
1429                         g_critical("ldapsvr_update_book->Unknown status: %s\n", status);
1430                 contacts = g_list_next(contacts);
1431         }
1432         ldapsvr_free_hashtable(head);
1433 }
1434
1435 #endif  /* USE_LDAP */
1436
1437 /*
1438  * End of Source.
1439  */
1440