49f7e1d13a1b565d01c62fe6cecfbd3c85dca63a
[samba.git] / source3 / passdb / ldap.c
1 /* 
2    Unix SMB/Netbios implementation.
3    Version 2.0.
4    LDAP protocol helper functions for SAMBA
5    Copyright (C) Jean Fran├žois Micouleau 1998
6    Copyright (C) Matthew Chapman 1998
7    
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 2 of the License, or
11    (at your option) any later version.
12    
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17    
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21    
22 */
23
24 #include "includes.h"
25
26 #ifdef WITH_LDAP
27
28 #include <lber.h>
29 #include <ldap.h>
30
31 extern int DEBUGLEVEL;
32
33 /* Internal state */
34 LDAP *ldap_struct;
35 LDAPMessage *ldap_results;
36 LDAPMessage *ldap_entry;
37
38 /* LDAP password */
39 static pstring ldap_secret;
40
41
42 /*******************************************************************
43   Open connections to the LDAP server.
44  ******************************************************************/    
45
46 BOOL ldap_open_connection(BOOL modify)
47 {
48         int err;
49
50         if (!(ldap_struct = ldap_open(lp_ldap_server(), lp_ldap_port()))) {
51                 DEBUG(0, ("open: %s\n", strerror(errno)));
52                 return (False);
53         }
54
55         err = ldap_simple_bind_s(ldap_struct, lp_ldap_bind_as(), ldap_secret);
56         if (err != LDAP_SUCCESS) {
57                 DEBUG(0, ("bind: %s\n", ldap_err2string(err)));
58                 return (False);
59         }
60
61         DEBUG(2,("Connected to LDAP server\n"));
62         return (True);
63 }
64
65 /*******************************************************************
66   close connections to the LDAP server.
67  ******************************************************************/    
68
69 void ldap_close_connection(void)
70 {
71         if(!ldap_struct)
72                 return;
73
74         if(ldap_results) {
75                 ldap_msgfree(ldap_results);
76                 ldap_results = NULL; }
77
78         ldap_unbind(ldap_struct);
79         ldap_struct = NULL;
80         
81         DEBUG(2,("Connection closed\n"));
82 }
83
84
85 /*******************************************************************
86   Search the directory using a given filter.
87  ******************************************************************/    
88
89 BOOL ldap_search_for(char *filter)
90 {
91         int err;
92
93         DEBUG(2,("Searching in [%s] for [%s]\n", lp_ldap_suffix(), filter));
94
95         err = ldap_search_s(ldap_struct, lp_ldap_suffix(), LDAP_SCOPE_ONELEVEL,
96                           filter, NULL, 0, &ldap_results);
97
98         if(err != LDAP_SUCCESS) {
99                 DEBUG(0, ("search: %s\n", ldap_err2string(err)));
100         }
101
102         DEBUG(2, ("%d matching entries found\n",
103                   ldap_count_entries(ldap_struct, ldap_results)));
104
105         ldap_entry = ldap_first_entry(ldap_struct, ldap_results);
106         return (True);
107 }
108
109 BOOL ldap_search_by_name(const char *user)
110 {
111         fstring filter;
112
113         slprintf(filter, sizeof(filter)-1,
114                  "(&(uid=%s)(objectclass=sambaAccount))", user);
115         return ldap_search_for(filter);
116 }
117
118 BOOL ldap_search_by_uid(int uid)
119 {
120         fstring filter;
121         
122         slprintf(filter, sizeof(filter)-1, 
123                  "(&(uidNumber=%d)(objectclass=sambaAccount))", uid);
124         return ldap_search_for(filter);
125 }
126
127
128 /*******************************************************************
129   Get the first value of an attribute.
130  ******************************************************************/
131
132 BOOL ldap_get_attribute(char *attribute, char *value)
133 {
134         char **values;
135         
136         if(!(values = ldap_get_values(ldap_struct, ldap_entry, attribute)))
137                 return (False);
138
139         pstrcpy(value, values[0]);
140         ldap_value_free(values);
141         DEBUG(3, ("get: [%s] = [%s]\n", attribute, value));
142         
143         return (True);
144 }
145
146
147 /*******************************************************************
148   Construct an smb_passwd structure
149  ******************************************************************/
150 struct smb_passwd *ldap_getpw(void)
151 {
152         static struct smb_passwd smbpw;
153         static pstring unix_name;
154         static pstring nt_name;
155         static unsigned char smblmpwd[16];
156         static unsigned char smbntpwd[16];
157         pstring temp;
158
159         if(!ldap_entry)
160                 return NULL;
161
162         if(!ldap_get_attribute("uid", unix_name)) {
163                 DEBUG(0,("Missing uid\n"));
164                 return NULL; }
165         smbpw.unix_name = unix_name;
166
167         DEBUG(2,("Retrieving account [%s]\n",unix_name));
168
169         if(!ldap_get_attribute("uidNumber", temp)) {
170                 DEBUG(0,("Missing uidNumber\n"));
171                 return NULL; }
172         smbpw.unix_uid = atoi(temp);
173
174         if(ldap_get_attribute("ntuid", nt_name)) {
175                 DEBUG(0,("Missing ntuid\n"));
176                 return NULL; }
177         smbpw.nt_name = nt_name;
178
179         if(!ldap_get_attribute("rid", temp)) {
180                 DEBUG(0,("Missing rid\n"));
181                 return NULL; }
182         smbpw.user_rid = atoi(temp);
183
184         if(ldap_get_attribute("acctFlags", temp))
185                 smbpw.acct_ctrl = pwdb_decode_acct_ctrl(temp);
186         else
187                 smbpw.acct_ctrl = ACB_NORMAL;
188
189         if(ldap_get_attribute("lmPassword", temp)) {
190                 pwdb_gethexpwd(temp, smblmpwd);
191                 smbpw.smb_passwd = smblmpwd;
192         } else {
193                 smbpw.smb_passwd = NULL;
194                 smbpw.acct_ctrl |= ACB_DISABLED;
195         }
196
197         if(ldap_get_attribute("ntPassword", temp)) {
198                 pwdb_gethexpwd(temp, smbntpwd);
199                 smbpw.smb_nt_passwd = smbntpwd;
200         } else {
201                 smbpw.smb_nt_passwd = NULL;
202         }
203
204         if(ldap_get_attribute("pwdLastSet", temp))
205                 smbpw.pass_last_set_time = (time_t)strtol(temp, NULL, 16);
206         else
207                 smbpw.pass_last_set_time = (time_t)(-1);
208
209         ldap_entry = ldap_next_entry(ldap_struct, ldap_entry);
210         return &smbpw;
211 }
212
213
214 /************************************************************************
215   Adds a modification to a LDAPMod queue.
216  ************************************************************************/
217
218  void ldap_make_mod(LDAPMod ***modlist,int modop, char *attribute, char *value)
219 {
220         LDAPMod **mods;
221         int i;
222         int j;
223
224         DEBUG(3, ("set: [%s] = [%s]\n", attribute, value));
225         
226         mods = *modlist;
227         
228         if (mods == NULL) {
229                 mods = (LDAPMod **)malloc(sizeof(LDAPMod *));
230                 mods[0] = NULL;
231         }
232         
233         for (i = 0; mods[i] != NULL; ++i) {
234                 if (mods[i]->mod_op == modop && 
235                     !strcasecmp(mods[i]->mod_type, attribute)) {
236                         break;
237                 }
238         }
239         
240         if (mods[i] == NULL) {
241                 mods = (LDAPMod **)realloc(mods, (i+2) * sizeof(LDAPMod *));
242                 mods[i] = (LDAPMod *)malloc(sizeof(LDAPMod));
243                 mods[i]->mod_op = modop;
244                 mods[i]->mod_values = NULL;
245                 mods[i]->mod_type = strdup(attribute);
246                 mods[i+1] = NULL;
247         }
248
249         if (value) {
250                 j = 0;
251                 if (mods[i]->mod_values) {
252                         for (; mods[i]->mod_values[j]; j++);
253                 }
254                 mods[i]->mod_values = (char **)realloc(mods[i]->mod_values,
255                                                   (j+2) * sizeof(char *));
256                 mods[i]->mod_values[j] = strdup(value);
257                 mods[i]->mod_values[j+1] = NULL;
258         }
259
260         *modlist = mods;
261 }
262
263
264 /************************************************************************
265   Queues the necessary modifications to save a smb_passwd structure
266  ************************************************************************/
267
268  void ldap_smbpwmods(struct smb_passwd *newpwd, LDAPMod ***mods, int operation)
269 {
270         fstring temp;
271         int i;
272
273         *mods = NULL;
274         if(operation == LDAP_MOD_ADD) { /* immutable attributes */
275               ldap_make_mod(mods, LDAP_MOD_ADD, "objectclass", "sambaAccount");
276
277               ldap_make_mod(mods, LDAP_MOD_ADD, "uid", newpwd->unix_name);
278               slprintf(temp, sizeof(temp)-1, "%d", newpwd->unix_uid);
279               ldap_make_mod(mods, LDAP_MOD_ADD, "uidNumber", temp);
280
281               ldap_make_mod(mods, LDAP_MOD_ADD, "ntuid", newpwd->nt_name);
282               slprintf(temp, sizeof(temp)-1, "%d", newpwd->user_rid);
283               ldap_make_mod(mods, LDAP_MOD_ADD, "rid", temp);
284         }
285
286         if (newpwd->smb_passwd) {
287               for( i = 0; i < 16; i++) {
288                      slprintf(&temp[2*i], 3, "%02X", newpwd->smb_passwd[i]);
289               }
290               ldap_make_mod(mods, operation, "lmPassword", temp);
291         }
292
293         if (newpwd->smb_nt_passwd) {
294               for( i = 0; i < 16; i++) {
295                      slprintf(&temp[2*i], 3, "%02X", newpwd->smb_nt_passwd[i]);
296               }
297               ldap_make_mod(mods, operation, "ntPassword", temp);
298         }
299
300         newpwd->pass_last_set_time = time(NULL);
301         slprintf(temp, sizeof(temp)-1, "%08X", newpwd->pass_last_set_time);
302         ldap_make_mod(mods, operation, "pwdLastSet", temp);
303
304         ldap_make_mod(mods, operation, "acctFlags",
305                             pwdb_encode_acct_ctrl(newpwd->acct_ctrl,
306                                    NEW_PW_FORMAT_SPACE_PADDED_LEN));
307 }
308
309
310 /************************************************************************
311   Commit changes to a directory entry.
312  *************************************************************************/
313  BOOL ldap_makemods(char *attribute, char *value, LDAPMod **mods, BOOL add)
314 {
315         pstring dn;
316         int entries;
317         int err = 0;
318         BOOL rc;
319
320         slprintf(dn, sizeof(dn)-1, "%s=%s, %s", attribute, value,
321                  lp_ldap_suffix());
322
323         if(!ldap_open_connection(True))
324                 return (False);
325
326         if(add)
327                 err = ldap_add_s(ldap_struct, dn, mods);
328
329         if(!add || (err = LDAP_ALREADY_EXISTS))
330                 err = ldap_modify_s(ldap_struct, dn, mods);
331
332         if(err == LDAP_SUCCESS) {
333                 DEBUG(2,("Updated entry [%s]\n",value));
334                 rc = True;
335         } else {
336                 DEBUG(0,("update: %s\n", ldap_err2string(err)));
337                 rc = False;
338         }
339
340         ldap_close_connection();
341         ldap_mods_free(mods, 1);
342         return rc;
343 }
344
345
346 /***************************************************************
347   Begin/end account enumeration.
348  ****************************************************************/
349
350 static void *ldap_enumfirst(BOOL update)
351 {
352         if (!ldap_open_connection(False))
353                 return NULL;
354
355         ldap_search_for("objectclass=sambaAccount");
356
357         return ldap_struct;
358 }
359
360 static void ldap_enumclose(void *vp)
361 {
362         ldap_close_connection();
363 }
364
365
366 /*************************************************************************
367   Save/restore the current position in a query
368  *************************************************************************/
369
370 static SMB_BIG_UINT ldap_getdbpos(void *vp)
371 {
372         return (SMB_BIG_UINT)((ulong)ldap_entry);
373 }
374
375 static BOOL ldap_setdbpos(void *vp, SMB_BIG_UINT tok)
376 {
377         ldap_entry = (LDAPMessage *)((ulong)tok);
378         return (True);
379 }
380
381
382 /*************************************************************************
383   Return smb_passwd information.
384  *************************************************************************/
385
386 static struct smb_passwd *ldap_getpwbynam(const char *name)
387 {
388         struct smb_passwd *ret;
389
390         if(!ldap_open_connection(False))
391                 return NULL;
392
393         ldap_search_by_name(name);
394         ret = ldap_getpw();
395
396         ldap_close_connection();
397         return ret;
398 }
399
400 static struct smb_passwd *ldap_getpwbyuid(uid_t userid)
401 {
402         struct smb_passwd *ret;
403
404         if(!ldap_open_connection(False))
405                 return NULL;
406
407         ldap_search_by_uid(userid);
408         ret = ldap_getpw();
409
410         ldap_close_connection();
411         return ret;
412 }
413
414 static struct smb_passwd *ldap_getcurrentpw(void *vp)
415 {
416         return ldap_getpw();
417 }
418
419
420 /************************************************************************
421   Modify user information given an smb_passwd struct.
422  *************************************************************************/
423 static BOOL ldap_addpw(struct smb_passwd *newpwd)
424 {
425         LDAPMod **mods;
426
427         ldap_smbpwmods(newpwd, &mods, LDAP_MOD_ADD);
428         return ldap_makemods("uid", newpwd->unix_name, mods, True);
429 }
430
431 static BOOL ldap_modpw(struct smb_passwd *pwd, BOOL override)
432 {
433         LDAPMod **mods;
434
435         ldap_smbpwmods(pwd, &mods, LDAP_MOD_REPLACE);
436         return ldap_makemods("uid", pwd->unix_name, mods, False);
437 }
438
439
440 static struct smb_passdb_ops ldap_ops =
441 {
442         ldap_enumfirst,
443         ldap_enumclose,
444         ldap_getdbpos,
445         ldap_setdbpos,
446
447         ldap_getpwbynam,
448         ldap_getpwbyuid,
449         ldap_getcurrentpw,
450         ldap_addpw,
451         ldap_modpw
452 };
453
454 struct smb_passdb_ops *ldap_initialise_password_db(void)
455 {
456         FILE *pwdfile;
457         char *pwdfilename;
458         char *p;
459
460         pwdfilename = lp_ldap_passwd_file();
461
462         if(pwdfilename[0]) {
463                 if(pwdfile = sys_fopen(pwdfilename, "r")) {
464                         fgets(ldap_secret, sizeof(ldap_secret), pwdfile);
465                         if(p = strchr(ldap_secret, '\n'))
466                                 *p = 0;
467                         fclose(pwdfile);
468                 } else {
469                         DEBUG(0,("Failed to open LDAP passwd file\n"));
470                 }
471         }
472
473         return &ldap_ops;
474 }
475
476 #else
477  void ldap_dummy_function(void);
478  void ldap_dummy_function(void) { } /* stop some compilers complaining */
479 #endif