libatalk/acl/ldap.c

   1 /*
   2   $Id: ldap.c,v 1.7 2010-04-23 11:37:06 franklahm Exp $
   3   Copyright (c) 2008,2009 Frank Lahm <franklahm@gmail.com>
   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 2 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
  16 #ifdef HAVE_CONFIG_H
  17 #include "config.h"
  18 #endif /* HAVE_CONFIG_H */
  19
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <sys/time.h>
  23 #include <string.h>
  24 #include <errno.h>
  25 #include <ldap.h>
  26
  27 #include <atalk/logger.h>
  28 #include <atalk/afp.h>
  29 #include <atalk/uuid.h>
  30 #include <atalk/ldapconfig.h>   /* For struct ldap_pref */
  31
  32 typedef enum {
  33     KEEPALIVE = 1
  34 } ldapcon_t;
  35
  36 /********************************************************
  37  * LDAP config stuff. Filled by libatalk/acl/ldap_config.c
  38  ********************************************************/
  39 int ldap_config_valid;
  40
  41 char *ldap_server;
  42 int  ldap_auth_method;
  43 char *ldap_auth_dn;
  44 char *ldap_auth_pw;
  45 char *ldap_userbase;
  46 int  ldap_userscope;
  47 char *ldap_groupbase;
  48 int  ldap_groupscope;
  49 char *ldap_uuid_attr;
  50 char *ldap_name_attr;
  51 char *ldap_group_attr;
  52 char *ldap_uid_attr;
  53
  54 struct ldap_pref ldap_prefs[] = {
  55     {&ldap_server,     "ldap_server",      0, 0, -1},
  56     {&ldap_auth_method,"ldap_auth_method", 1, 1, -1},
  57     {&ldap_auth_dn,    "ldap_auth_dn",     0, 0,  0},
  58     {&ldap_auth_pw,    "ldap_auth_pw",     0, 0,  0},
  59     {&ldap_userbase,   "ldap_userbase",    0, 0, -1},
  60     {&ldap_userscope,  "ldap_userscope",   1 ,1, -1},
  61     {&ldap_groupbase,  "ldap_groupbase",   0, 0, -1},
  62     {&ldap_groupscope, "ldap_groupscope",  1 ,1, -1},
  63     {&ldap_uuid_attr,  "ldap_uuid_attr",   0, 0, -1},
  64     {&ldap_name_attr,  "ldap_name_attr",   0, 0, -1},
  65     {&ldap_group_attr, "ldap_group_attr",  0, 0, -1},
  66     {&ldap_uid_attr,   "ldap_uid_attr",    0, 0,  0},
  67     {NULL,             NULL,               0, 0, -1}
  68 };
  69
  70 struct pref_array prefs_array[] = {
  71     {"ldap_auth_method", "none",   LDAP_AUTH_NONE},
  72     {"ldap_auth_method", "simple", LDAP_AUTH_SIMPLE},
  73     {"ldap_auth_method", "sasl",   LDAP_AUTH_SASL},
  74     {"ldap_userscope",   "base",   LDAP_SCOPE_BASE},
  75     {"ldap_userscope",   "one",    LDAP_SCOPE_ONELEVEL},
  76     {"ldap_userscope",   "sub",    LDAP_SCOPE_SUBTREE},
  77     {"ldap_groupscope",  "base",   LDAP_SCOPE_BASE},
  78     {"ldap_groupscope",  "one",    LDAP_SCOPE_ONELEVEL},
  79     {"ldap_groupscope",  "sub",    LDAP_SCOPE_SUBTREE},
  80     {NULL,               NULL,     0}
  81 };
  82
  83 /********************************************************
  84  * Static helper function
  85  ********************************************************/
  86
  87 /*
  88  * ldap_getattr_fromfilter_withbase_scope():
  89  *   conflags: KEEPALIVE
  90  *   scope: LDAP_SCOPE_BASE, LDAP_SCOPE_ONELEVEL, LDAP_SCOPE_SUBTREE
  91  *   result: return unique search result here, allocated here, caller must free
  92  *
  93  * returns: -1 on error
  94  *           0 nothing found
  95  *           1 successfull search, result int 'result'
  96  *
  97  * All connection managment to the LDAP server is done here. Just set KEEPALIVE if you know
  98  * you will be dispatching more than one search in a row, then don't set it with the last search.
  99  * You MUST dispatch the queries timely, otherwise the LDAP handle might timeout.
 100  */
 101 static int ldap_getattr_fromfilter_withbase_scope( const char *searchbase,
 102                                                    const char *filter,
 103                                                    char *attributes[],
 104                                                    int scope,
 105                                                    ldapcon_t conflags,
 106                                                    char **result) {
 107     int ret;
 108     int ldaperr;
 109     int retrycount = 0;
 110     int desired_version  = LDAP_VERSION3;
 111     static int ldapconnected = 0;
 112     static LDAP *ld     = NULL;
 113     LDAPMessage* msg    = NULL;
 114     LDAPMessage* entry  = NULL;
 115     char **attribute_values = NULL;
 116     struct timeval timeout;
 117
 118     LOG(log_maxdebug, logtype_afpd,"ldap_getattr_fromfilter_withbase_scope: BEGIN");
 119
 120     timeout.tv_sec = 3;
 121     timeout.tv_usec = 0;
 122
 123     /* init LDAP if necessary */
 124 retry:
 125     ret = 0;
 126
 127     if (ld == NULL) {
 128         LOG(log_maxdebug, logtype_default, "ldap_getattr_fromfilter_withbase_scope: LDAP server: \"%s\"",
 129             ldap_server);
 130         if ((ld = ldap_init(ldap_server, LDAP_PORT)) == NULL ) {
 131             LOG(log_error, logtype_default, "ldap_getattr_fromfilter_withbase_scope: ldap_init error: %s",
 132                 strerror(errno));
 133             return -1;
 134         }
 135         if (ldap_set_option(ld, LDAP_OPT_PROTOCOL_VERSION, &desired_version) != 0) {
 136             /* LDAP_OPT_SUCCESS is not in the proposed standard, so we check for 0
 137                http://tools.ietf.org/id/draft-ietf-ldapext-ldap-c-api-05.txt */
 138             LOG(log_error, logtype_default, "ldap_getattr_fromfilter_withbase_scope: ldap_set_option failed!");
 139             free(ld);
 140             ld = NULL;
 141             return -1;
 142         }
 143     }
 144
 145     /* connect */
 146     if (!ldapconnected) {
 147         if (LDAP_AUTH_NONE == ldap_auth_method) {
 148             if (ldap_bind_s(ld, "", "", LDAP_AUTH_SIMPLE) != LDAP_SUCCESS ) {
 149                 LOG(log_error, logtype_default, "ldap_getattr_fromfilter_withbase_scope: ldap_bind failed!");
 150                 LOG(log_error, logtype_default, "ldap_auth_method: \'%d\'", ldap_auth_method);
 151                 free(ld);
 152                 ld = NULL;
 153                 return -1;
 154             }
 155             ldapconnected = 1;
 156
 157         } else if (LDAP_AUTH_SIMPLE == ldap_auth_method) {
 158             if (ldap_bind_s(ld, ldap_auth_dn, ldap_auth_pw, ldap_auth_method) != LDAP_SUCCESS ) {
 159                 LOG(log_error, logtype_default, "ldap_getattr_fromfilter_withbase_scope: ldap_bind failed!");
 160                 LOG(log_error, logtype_default, "ldap_auth_dn: \'%s\', ldap_auth_pw: \'%s\', ldap_auth_method: \'%d\'",
 161                     ldap_auth_dn, ldap_auth_pw, ldap_auth_method);
 162                 free(ld);
 163                 ld = NULL;
 164                 return -1;
 165             }
 166             ldapconnected = 1;
 167         }
 168     }
 169     /* ldapconnected and ld are now always 1 and != NULL which is important when dealing w. errors*/
 170
 171     LOG(log_maxdebug, logtype_afpd, "LDAP start search: base: %s, filter: %s, attr: %s",
 172         searchbase, filter, attributes[0]);
 173
 174     /* start LDAP search */
 175     ldaperr = ldap_search_st(ld, searchbase, scope, filter, attributes, 0, &timeout, &msg);
 176     LOG(log_maxdebug, logtype_default, "ldap_getattr_fromfilter_withbase_scope: ldap_search_st returned: %s, %u",
 177         ldap_err2string(ldaperr), ldaperr);
 178     if (ldaperr != LDAP_SUCCESS) {
 179         if (retrycount >= 1)
 180             LOG(log_error, logtype_default, "ldap_getattr_fromfilter_withbase_scope: ldap_search_st failed: %s", ldap_err2string(ldaperr));
 181         ret = -1;
 182         goto cleanup;
 183     }
 184
 185     /* parse search result */
 186     LOG(log_maxdebug, logtype_default, "ldap_getuuidfromname: got %d entries from ldap search",
 187         ldap_count_entries(ld, msg));
 188     if (ldap_count_entries(ld, msg) != 1) {
 189         ret = 0;
 190         goto cleanup;
 191     }
 192
 193     entry = ldap_first_entry(ld, msg);
 194     if (entry == NULL) {
 195         LOG(log_error, logtype_default, "ldap_getattr_fromfilter_withbase_scope: error in ldap_first_entry");
 196         ret = -1;
 197         goto cleanup;
 198     }
 199     attribute_values = ldap_get_values(ld, entry, attributes[0]);
 200     if (attribute_values == NULL) {
 201         LOG(log_error, logtype_default, "ldap_getattr_fromfilter_withbase_scope: error in ldap_get_values");
 202         ret = -1;
 203         goto cleanup;
 204     }
 205
 206     LOG(log_maxdebug, logtype_afpd,"ldap: search result: %s: %s",
 207         attributes[0], attribute_values[0]);
 208
 209     /* allocate result */
 210     *result = strdup(attribute_values[0]);
 211     if (*result == NULL) {
 212         LOG(log_error, logtype_default, "ldap: strdup error: %s",strerror(errno));
 213         ret = -1;
 214         goto cleanup;
 215     }
 216
 217 cleanup:
 218     if (attribute_values)
 219         ldap_value_free(attribute_values);
 220     /* FIXME: is there another way to free entry ? */
 221     while (entry != NULL)
 222         entry = ldap_next_entry(ld, entry);
 223     if (msg)
 224         ldap_msgfree(msg);
 225
 226     if (ldapconnected) {
 227         if ((ret == -1) || !(conflags & KEEPALIVE)) {
 228             LOG(log_maxdebug, logtype_default,"ldap: unbind");
 229             if (ldap_unbind_s(ld) != 0) {
 230                 LOG(log_error, logtype_default, "ldap: unbind: %s\n", ldap_err2string(ldaperr));
 231                 return -1;
 232             }
 233             ld = NULL;
 234             ldapconnected = 0;
 235
 236             /* In case of error we try twice */
 237             if (ret == -1) {
 238                 retrycount++;
 239                 if (retrycount < 2)
 240                     goto retry;
 241             }
 242         }
 243     }
 244     return ret;
 245 }
 246
 247 /********************************************************
 248  * Interface
 249  ********************************************************/
 250
 251 /*
 252  * returns allocated storage in uuid_string, caller must free it
 253  * returns 0 on success, -1 on error or not found
 254  */
 255 int ldap_getuuidfromname( const char *name, uuidtype_t type, char **uuid_string) {
 256     int ret;
 257     int len;
 258     char filter[256];           /* this should really be enough. we dont want to malloc everything! */
 259     char *attributes[]  = { ldap_uuid_attr, NULL};
 260     char *ldap_attr;
 261
 262     /* make filter */
 263     if (type == UUID_GROUP)
 264         ldap_attr = ldap_group_attr;
 265     else /* type hopefully == UUID_USER */
 266         ldap_attr = ldap_name_attr;
 267     len = snprintf( filter, 256, "%s=%s", ldap_attr, name);
 268     if (len >= 256 || len == -1) {
 269         LOG(log_error, logtype_default, "ldap_getnamefromuuid: filter error:%d, \"%s\"", len, filter);
 270         return -1;
 271     }
 272
 273     if (type == UUID_GROUP) {
 274         ret = ldap_getattr_fromfilter_withbase_scope( ldap_groupbase, filter, attributes, ldap_groupscope, KEEPALIVE, uuid_string);
 275     } else  { /* type hopefully == UUID_USER */
 276         ret = ldap_getattr_fromfilter_withbase_scope( ldap_userbase, filter, attributes, ldap_userscope, KEEPALIVE, uuid_string);
 277     }
 278     if (ret != 1)
 279         return -1;
 280     return 0;
 281 }
 282
 283 /*
 284  * LDAP search wrapper
 285  * returns allocated storage in name, caller must free it
 286  * returns 0 on success, -1 on error or not found
 287  */
 288 int ldap_getnamefromuuid( char *uuidstr, char **name, uuidtype_t *type) {
 289     int ret;
 290     int len;
 291     char filter[256];       /* this should really be enough. we dont want to malloc everything! */
 292     char *attributes[]  = { NULL, NULL};
 293
 294     /* make filter */
 295     len = snprintf( filter, 256, "%s=%s", ldap_uuid_attr, uuidstr);
 296     if (len >= 256 || len == -1) {
 297         LOG(log_error, logtype_default, "ldap_getnamefromuuid: filter overflow:%d, \"%s\"", len, filter);
 298         return -1;
 299     }
 300     /* search groups first. group acls are probably used more often */
 301     attributes[0] = ldap_group_attr;
 302     ret = ldap_getattr_fromfilter_withbase_scope( ldap_groupbase, filter, attributes, ldap_groupscope, KEEPALIVE, name);
 303     if (ret == -1)
 304         return -1;
 305     if (ret == 1) {
 306         *type = UUID_GROUP;
 307         return 0;
 308     }
 309
 310     attributes[0] = ldap_name_attr;
 311     ret = ldap_getattr_fromfilter_withbase_scope( ldap_userbase, filter, attributes, ldap_userscope, KEEPALIVE, name);
 312     if (ret == 1) {
 313         *type = UUID_USER;
 314         return 0;
 315     }
 316
 317     return -1;
 318 }