citadel/modules/ldap/serv_ldap.c

   1 /*
   2  * $Id$
   3  *
   4  * A module which implements the LDAP connector for Citadel.
   5  *
   6  */
   7
   8 #include "sysdep.h"
   9 #include <stdlib.h>
  10 #include <unistd.h>
  11 #include <stdio.h>
  12 #include <fcntl.h>
  13 #include <signal.h>
  14 #include <pwd.h>
  15 #include <errno.h>
  16 #include <sys/types.h>
  17
  18 #if TIME_WITH_SYS_TIME
  19 # include <sys/time.h>
  20 # include <time.h>
  21 #else
  22 # if HAVE_SYS_TIME_H
  23 #  include <sys/time.h>
  24 # else
  25 #  include <time.h>
  26 # endif
  27 #endif
  28
  29 #include <sys/wait.h>
  30 #include <string.h>
  31 #include <limits.h>
  32 #include "citadel.h"
  33 #include "server.h"
  34 #include "citserver.h"
  35 #include "support.h"
  36 #include "config.h"
  37 #include "room_ops.h"
  38 #include "policy.h"
  39 #include "database.h"
  40 #include "msgbase.h"
  41 #include "serv_ldap.h"
  42 #include "tools.h"
  43
  44
  45 #include "ctdl_module.h"
  46
  47
  48
  49 #ifdef HAVE_LDAP
  50
  51 #define LDAP_DEPRECATED 1       /* to stop warnings with newer libraries */
  52
  53 #include <ldap.h>
  54
  55 LDAP *dirserver = NULL;
  56 int ldap_time_disconnect = 0;
  57
  58
  59 /*
  60  * LDAP connector cleanup function
  61  */
  62 void serv_ldap_cleanup(void)
  63 {
  64         if (dirserver)
  65         {
  66                 lprintf(CTDL_INFO, "LDAP: Unbinding from directory server\n");
  67                 ldap_unbind(dirserver);
  68         }
  69         dirserver = NULL;
  70         ldap_time_disconnect=0;
  71 }
  72
  73
  74
  75
  76
  77 int CtdlConnectToLdap(void) {
  78         int i;
  79         int ldap_version = 3;
  80
  81         if (ldap_time_disconnect && dirserver)
  82         {       // Already connected
  83                 ldap_time_disconnect=5; // reset the timer.
  84                 return 0;
  85         }
  86
  87         lprintf(CTDL_INFO, "LDAP: Connecting to LDAP server %s:%d...\n",
  88         config.c_ldap_host, config.c_ldap_port);
  89
  90         dirserver = ldap_init(config.c_ldap_host, config.c_ldap_port);
  91         if (dirserver == NULL) {
  92                 lprintf(CTDL_CRIT, "LDAP: Could not connect to %s:%d : %s\n",
  93                         config.c_ldap_host,
  94                         config.c_ldap_port,
  95                         strerror(errno));
  96                 aide_message(strerror(errno), "LDAP: Could not connect to server.");
  97                 return -1;
  98         }
  99
 100         ldap_set_option(dirserver, LDAP_OPT_PROTOCOL_VERSION, &ldap_version);
 101
 102         lprintf(CTDL_INFO, "LDAP: Binding to %s\n", config.c_ldap_bind_dn);
 103
 104         i = ldap_simple_bind_s(dirserver,
 105                                 config.c_ldap_bind_dn,
 106                                 config.c_ldap_bind_pw
 107         );
 108         if (i != LDAP_SUCCESS) {
 109                 lprintf(CTDL_CRIT, "LDAP: Cannot bind: %s (%d)\n", ldap_err2string(i), i);
 110                 dirserver = NULL;       /* FIXME disconnect from ldap */
 111                 aide_message(ldap_err2string(i), "LDAP: Cannot bind to server");
 112                 return -1;
 113         }
 114         ldap_time_disconnect=5;
 115         return 0;
 116 }
 117
 118
 119
 120 /*
 121  * Create the root node.  If it's already there, so what?
 122  */
 123 void CtdlCreateLdapRoot(void) {
 124         char *dc_values[2];
 125         char *objectClass_values[3];
 126         LDAPMod dc, objectClass;
 127         LDAPMod *mods[3];
 128         char topdc[SIZ];
 129         int i;
 130
 131         /* We just want the top-level dc, not the whole hierarchy */
 132         strcpy(topdc, config.c_ldap_base_dn);
 133         for (i=0; topdc[i]; ++i) {
 134                 if (topdc[i] == ',') {
 135                         topdc[i] = 0;
 136                         break;
 137                 }
 138         }
 139         for (i=0; topdc[i]; ++i) {
 140                 if (topdc[i] == '=') strcpy(topdc, &topdc[i+1]);
 141         }
 142
 143         /* Set up the transaction */
 144         dc.mod_op               = LDAP_MOD_ADD;
 145         dc.mod_type             = "dc";
 146         dc_values[0]            = topdc;
 147         dc_values[1]            = NULL;
 148         dc.mod_values           = dc_values;
 149         objectClass.mod_op      = LDAP_MOD_ADD;
 150         objectClass.mod_type    = "objectClass";
 151         objectClass_values[0]   = "top";
 152         objectClass_values[1]   = "domain";
 153         objectClass_values[2]   = NULL;
 154         objectClass.mod_values  = objectClass_values;
 155         mods[0] = &dc;
 156         mods[1] = &objectClass;
 157         mods[2] = NULL;
 158
 159         /* Perform the transaction */
 160         lprintf(CTDL_DEBUG, "LDAP: Setting up Base DN node...\n");
 161
 162         begin_critical_section(S_LDAP);
 163         if (CtdlConnectToLdap())
 164         {
 165                 end_critical_section(S_LDAP);
 166                 return;
 167         }
 168         i = ldap_add_s(dirserver, config.c_ldap_base_dn, mods);
 169         end_critical_section(S_LDAP);
 170
 171         if (i == LDAP_ALREADY_EXISTS) {
 172                 lprintf(CTDL_INFO, "LDAP: Base DN is already present in the directory; no need to add it again.\n");
 173         }
 174         else if (i != LDAP_SUCCESS) {
 175                 lprintf(CTDL_CRIT, "LDAP: ldap_add_s() failed: %s (%d)\n",
 176                         ldap_err2string(i), i);
 177         }
 178 }
 179
 180
 181 /*
 182  * Create an OU node representing a Citadel host.
 183  * parameter cn is not used, its just there to keep the hook interface consistant
 184  * parameter object not used here, present for interface compatability
 185  */
 186 int CtdlCreateLdapHostOU(char *cn, char *host, void **object) {
 187         char *dc_values[2];
 188         char *objectClass_values[3];
 189         LDAPMod dc, objectClass;
 190         LDAPMod *mods[3];
 191         int i;
 192         char dn[SIZ];
 193
 194         /* The DN is this OU plus the base. */
 195         snprintf(dn, sizeof dn, "ou=%s,%s", host, config.c_ldap_base_dn);
 196
 197         /* Set up the transaction */
 198         dc.mod_op               = LDAP_MOD_ADD;
 199         dc.mod_type             = "ou";
 200         dc_values[0]            = host;
 201         dc_values[1]            = NULL;
 202         dc.mod_values           = dc_values;
 203         objectClass.mod_op      = LDAP_MOD_ADD;
 204         objectClass.mod_type    = "objectClass";
 205         objectClass_values[0]   = "top";
 206         objectClass_values[1]   = "organizationalUnit";
 207         objectClass_values[2]   = NULL;
 208         objectClass.mod_values  = objectClass_values;
 209         mods[0] = &dc;
 210         mods[1] = &objectClass;
 211         mods[2] = NULL;
 212
 213         /* Perform the transaction */
 214         lprintf(CTDL_DEBUG, "LDAP: Setting up Host OU node...\n");
 215
 216         begin_critical_section(S_LDAP);
 217         if (CtdlConnectToLdap())
 218         {
 219                 end_critical_section(S_LDAP);
 220                 return -1;
 221         }
 222         i = ldap_add_s(dirserver, dn, mods);
 223         end_critical_section(S_LDAP);
 224
 225         if (i == LDAP_ALREADY_EXISTS) {
 226                 lprintf(CTDL_INFO, "LDAP: Host OU is already present in the directory; no need to add it again.\n");
 227         }
 228         else if (i != LDAP_SUCCESS) {
 229                 lprintf(CTDL_CRIT, "LDAP: ldap_add_s() failed: %s (%d)\n",
 230                         ldap_err2string(i), i);
 231                 return -1;
 232         }
 233         return 0;
 234 }
 235
 236
 237
 238
 239
 240
 241 /*
 242  * Create a base LDAP object for the interface
 243  */
 244
 245 int CtdlCreateLdapObject(char *cn, char *ou, void **object)
 246 {
 247         // We do nothing here, this just gets the base structure created by the interface.
 248         lprintf (CTDL_DEBUG, "LDAP: Created ldap object\n");
 249         return 0;
 250 }
 251
 252
 253 /*
 254  * Add an attribute to the ldap object
 255  */
 256
 257 int CtdlAddLdapAttr(char *cn, char *ou, void **object)
 258 {
 259         LDAPMod **attrs ;
 260         int num_attrs = 0;
 261         int num_values = 0;
 262         int cur_attr;
 263
 264
 265         lprintf (CTDL_DEBUG, "LDAP: Adding ldap attribute name:\"%s\" value:\"%s\"\n", cn, ou);
 266
 267         attrs = *object;
 268         if (attrs)
 269         {
 270                 while (attrs[num_attrs])
 271                         num_attrs++;
 272         }
 273
 274         for (cur_attr = 0; cur_attr < num_attrs ; cur_attr++)
 275         {
 276                 if (!strcmp(attrs[cur_attr]->mod_type, cn))
 277                 {       // Adding a value to the attribute
 278                         if (attrs[cur_attr]->mod_values)
 279                         {
 280                                 while (attrs[cur_attr]->mod_values[num_values])
 281                                         num_values++;
 282                         }
 283                         attrs[cur_attr]->mod_values = realloc(attrs[cur_attr]->mod_values, (num_values + 2) * (sizeof(char *)));
 284                         attrs[cur_attr]->mod_values[num_values] = strdup(ou);
 285                         attrs[cur_attr]->mod_values[num_values+1] = NULL;
 286                         return 0;
 287                 }
 288         }
 289         if (num_attrs)
 290                 attrs = realloc(attrs, (sizeof(LDAPMod *)) * (num_attrs + 2));
 291         else
 292                 attrs = malloc((sizeof(LDAPMod *)) * (num_attrs + 2));
 293         attrs[num_attrs] = malloc(sizeof(LDAPMod));
 294         memset(attrs[num_attrs], 0, sizeof(LDAPMod));
 295         attrs[num_attrs+1] = NULL;
 296         attrs[num_attrs]->mod_op        = LDAP_MOD_ADD;
 297         attrs[num_attrs]->mod_type      = strdup(cn);
 298         attrs[num_attrs]->mod_values    = malloc(2 * sizeof(char *));
 299         attrs[num_attrs]->mod_values[0] = strdup(ou);
 300         attrs[num_attrs]->mod_values[1] = NULL;
 301         *object = attrs;
 302         return 0;
 303 }
 304
 305
 306 /*
 307  * SAve the object to the LDAP server
 308  */
 309 int CtdlSaveLdapObject(char *cn, char *ou, void **object)
 310 {
 311         int i, j;
 312
 313         char this_dn[SIZ];
 314         LDAPMod **attrs ;
 315         int num_attrs = 0;
 316         int count = 0;
 317
 318         if (dirserver == NULL) return -1;
 319         if (cn == NULL) return -1;
 320
 321         sprintf(this_dn, "%s,%s", cn, config.c_ldap_base_dn);
 322
 323         lprintf(CTDL_INFO, "LDAP: Calling ldap_add_s() for dn of '%s'\n", this_dn);
 324
 325         /* The last attribute must be a NULL one. */
 326         attrs = (LDAPMod **)*object;
 327         if (attrs)
 328         {
 329                 while (attrs[num_attrs])
 330                 {
 331                         count = 0;
 332                         while (attrs[num_attrs]->mod_values[count])
 333                         {
 334                                 lprintf (CTDL_DEBUG, "LDAP: attribute %d, value %d = \'%s=%s\'\n", num_attrs, count, attrs[num_attrs]->mod_type, attrs[num_attrs]->mod_values[count]);
 335                                 count++;
 336                         }
 337                         num_attrs++;
 338                 }
 339         }
 340         else
 341         {
 342                 lprintf(CTDL_ERR, "LDAP: no attributes in CtdlSaveLdapObject\n");
 343                 return -1;
 344         }
 345
 346         begin_critical_section(S_LDAP);
 347         if (CtdlConnectToLdap())
 348         {
 349                 end_critical_section(S_LDAP);
 350                 return -1;
 351         }
 352
 353         i = ldap_add_s(dirserver, this_dn, attrs);
 354
 355         if (i == LDAP_SERVER_DOWN)
 356         {
 357                 aide_message("The LDAP server appears to be down.\nThe save to LDAP did not occurr.\n", "LDAP: save failed");
 358                 end_critical_section(S_LDAP);
 359                 return -1;
 360         }
 361
 362         /* If the entry already exists, repopulate it instead */
 363         if (i == LDAP_ALREADY_EXISTS) {
 364                 for (j=0; j<(num_attrs); ++j) {
 365                         attrs[j]->mod_op = LDAP_MOD_REPLACE;
 366                 }
 367                 lprintf(CTDL_INFO, "LDAP: Calling ldap_modify_s() for dn of '%s'\n", this_dn);
 368                 i = ldap_modify_s(dirserver, this_dn, attrs);
 369         }
 370
 371         if (i != LDAP_SUCCESS) {
 372                 lprintf(CTDL_ERR, "LDAP: ldap_add_s() failed: %s (%d)\n",
 373                         ldap_err2string(i), i);
 374                 aide_message("The LDAP server refused the save command.\nDid you update the schema?\n", "LDAP: save failed (schema?)");
 375                 end_critical_section(S_LDAP);
 376                 return -1;
 377         }
 378         end_critical_section(S_LDAP);
 379         return 0;
 380 }
 381
 382
 383 /*
 384  * Free the object
 385  */
 386 int CtdlFreeLdapObject(char *cn, char *ou, void **object)
 387 {
 388         int i, j;
 389
 390         LDAPMod **attrs ;
 391         int num_attrs = 0;
 392
 393         attrs = (LDAPMod **)*object;
 394         if (attrs)
 395         {
 396                 while (attrs[num_attrs])
 397                         num_attrs++;
 398         }
 399
 400         lprintf(CTDL_DEBUG, "LDAP: Freeing attributes\n");
 401         /* Free the attributes */
 402         for (i=0; i<num_attrs; ++i) {
 403                 if (attrs[i] != NULL) {
 404
 405                         /* First, free the value strings */
 406                         if (attrs[i]->mod_values != NULL) {
 407                                 for (j=0; attrs[i]->mod_values[j] != NULL; ++j) {
 408                                         free(attrs[i]->mod_values[j]);
 409                                 }
 410                         }
 411
 412                         /* Free the value strings pointer list */
 413                         if (attrs[i]->mod_values != NULL) {
 414                                 free(attrs[i]->mod_values);
 415                         }
 416
 417                         /* Now free the LDAPMod struct itself. */
 418                         free(attrs[i]);
 419                 }
 420         }
 421         free(attrs[i]);
 422         free(attrs);
 423         *object = NULL;
 424         return 0;
 425 }
 426
 427
 428 /*
 429  * Delete a record from the LDAP
 430  *
 431  * parameter object not used here, present for hook interface compatability
 432  */
 433 int CtdlDeleteFromLdap(char *cn, char *ou, void **object)
 434 {
 435         int i;
 436
 437         char this_dn[SIZ];
 438
 439         if (dirserver == NULL) return -1;
 440         if (ou == NULL) return -1;
 441         if (cn == NULL) return -1;
 442
 443         sprintf(this_dn, "%s,%s", cn, config.c_ldap_base_dn);
 444
 445         lprintf(CTDL_DEBUG, "LDAP: Calling ldap_delete_s()\n");
 446
 447         begin_critical_section(S_LDAP);
 448         if (CtdlConnectToLdap())
 449         {
 450                 end_critical_section(S_LDAP);
 451                 return -1;
 452         }
 453
 454         i = ldap_delete_s(dirserver, this_dn);
 455
 456         if (i == LDAP_SERVER_DOWN)
 457         {
 458                 end_critical_section(S_LDAP);
 459                 aide_message("The LDAP server appears to be down.\nThe delete from LDAP did not occurr.\n", "LDAP: delete failed");
 460                 return -1;
 461         }
 462
 463         if (i != LDAP_SUCCESS) {
 464                 lprintf(CTDL_ERR, "LDAP: ldap_delete_s() failed: %s (%d)\n",
 465                         ldap_err2string(i), i);
 466                 end_critical_section(S_LDAP);
 467                 aide_message(ldap_err2string(i), "LDAP: delete failed");
 468                 return -1;
 469         }
 470         end_critical_section(S_LDAP);
 471         return 0;
 472 }
 473
 474
 475
 476
 477 void ldap_disconnect_timer(void)
 478 {
 479         begin_critical_section(S_LDAP);
 480         if(ldap_time_disconnect)
 481         {
 482                 ldap_time_disconnect--;
 483                 end_critical_section(S_LDAP);
 484                 return;
 485         }
 486         serv_ldap_cleanup();
 487         end_critical_section(S_LDAP);
 488 }
 489
 490
 491 #endif                          /* HAVE_LDAP */
 492
 493
 494 /*
 495  * Initialize the LDAP connector module ... or don't, if we don't have LDAP.
 496  */
 497 CTDL_MODULE_INIT(ldap)
 498 {
 499 #ifdef HAVE_LDAP
 500         if (!IsEmptyStr(config.c_ldap_base_dn))
 501         {
 502                 CtdlRegisterCleanupHook(serv_ldap_cleanup);
 503                 CtdlRegisterSessionHook(ldap_disconnect_timer, EVT_TIMER);
 504                 CtdlRegisterDirectoryServiceFunc(CtdlDeleteFromLdap, DIRECTORY_USER_DEL, "ldap");
 505                 CtdlRegisterDirectoryServiceFunc(CtdlCreateLdapHostOU, DIRECTORY_CREATE_HOST, "ldap");
 506                 CtdlRegisterDirectoryServiceFunc(CtdlCreateLdapObject, DIRECTORY_CREATE_OBJECT, "ldap");
 507                 CtdlRegisterDirectoryServiceFunc(CtdlAddLdapAttr, DIRECTORY_ATTRIB_ADD, "ldap");
 508                 CtdlRegisterDirectoryServiceFunc(CtdlSaveLdapObject, DIRECTORY_SAVE_OBJECT, "ldap");
 509                 CtdlRegisterDirectoryServiceFunc(CtdlFreeLdapObject, DIRECTORY_FREE_OBJECT, "ldap");
 510                 CtdlCreateLdapRoot();
 511         }
 512
 513 #endif                          /* HAVE_LDAP */
 514
 515         /* return our Subversion id for the Log */
 516         return "$Id$";
 517 }