Updates for LDAP-backed Kerberos
[mspang/pyceo.git] / src / ldap.c
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <pwd.h>
4 #include <grp.h>
5 #include <sasl/sasl.h>
6 #include <krb5.h>
7
8 #define LDAP_DEPRECATED 1
9 #include <ldap.h>
10
11 #include "ldap.h"
12 #include "krb5.h"
13 #include "config.h"
14 #include "util.h"
15
16 extern char *prog;
17
18 LDAP *ld;
19
20 static void ldap_fatal(char *msg) {
21     int errnum = 0;
22     char *errstr = NULL;
23     char *detail = NULL;
24
25     if (ldap_get_option(ld, LDAP_OPT_ERROR_NUMBER, &errnum) != LDAP_SUCCESS)
26         warn("ldap_get_option(LDAP_OPT_ERROR_NUMBER) failed");
27     if (ldap_get_option(ld, LDAP_OPT_ERROR_STRING, &detail) != LDAP_SUCCESS)
28         warn("ldap_get_option(LDAP_OPT_ERROR_STRING) failed");
29
30     errstr = ldap_err2string(errnum);
31
32     if (detail)
33         fatal("%s: %s (%d): %s", msg, errstr, errnum, detail);
34     else if (errnum)
35         fatal("%s: %s (%d)", msg, errstr, errnum);
36     else
37         fatal("%s", msg);
38 }
39
40 static void ldap_err(char *msg) {
41     int errnum = 0;
42     char *errstr = NULL;
43     char *detail = NULL;
44
45     if (ldap_get_option(ld, LDAP_OPT_ERROR_NUMBER, &errnum) != LDAP_SUCCESS)
46         warn("ldap_get_option(LDAP_OPT_ERROR_NUMBER) failed");
47     if (ldap_get_option(ld, LDAP_OPT_ERROR_STRING, &detail) != LDAP_SUCCESS)
48         warn("ldap_get_option(LDAP_OPT_ERROR_STRING) failed");
49
50     errstr = ldap_err2string(errnum);
51
52     if (detail)
53         error("%s: %s (%d): %s", msg, errstr, errnum, detail);
54     else if (errnum)
55         error("%s: %s (%d)", msg, errstr, errnum);
56     else
57         error("%s", msg);
58 }
59
60 int ceo_add_group(char *cn, char *basedn, int no) {
61     if (!cn || !basedn)
62         fatal("addgroup: Invalid argument");
63
64     LDAPMod *mods[8];
65     int i = -1;
66     int ret = 0;
67
68     mods[++i] = xmalloc(sizeof(LDAPMod));
69     mods[i]->mod_op = LDAP_MOD_ADD;
70     mods[i]->mod_type = "objectClass";
71     char *objectClasses[] = { "top", "group", "posixGroup", NULL };
72     mods[i]->mod_values = objectClasses;
73
74     mods[++i] = xmalloc(sizeof(LDAPMod));
75     mods[i]->mod_op = LDAP_MOD_ADD;
76     mods[i]->mod_type = "cn";
77     char *uids[] = { cn, NULL };
78     mods[i]->mod_values = uids;
79
80     mods[++i] = xmalloc(sizeof(LDAPMod));
81     mods[i]->mod_op = LDAP_MOD_ADD;
82     mods[i]->mod_type = "gidNumber";
83     char idno[16];
84     snprintf(idno, sizeof(idno), "%d", no);
85     char *gidNumbers[] = { idno, NULL };
86     mods[i]->mod_values = gidNumbers;
87
88     mods[++i] = NULL;
89
90     char dn[1024];
91     snprintf(dn, sizeof(dn), "cn=%s,%s", cn, basedn);
92
93     if (ldap_add_s(ld, dn, mods) != LDAP_SUCCESS) {
94         ldap_err("addgroup");
95         ret = -1;
96     }
97
98     for (i = 0; mods[i]; i++)
99         free(mods[i]);
100
101     return ret;
102 }
103
104 int ceo_add_group_sudo(char *group, char *basedn) {
105     if (!group || !basedn)
106         fatal("addgroup: Invalid argument");
107
108     LDAPMod *mods[8];
109     int i = -1;
110     int ret = 0;
111
112     char cn[17];
113     snprintf(cn, sizeof(cn), "%%%s", group);
114
115     mods[++i] = xmalloc(sizeof(LDAPMod));
116     mods[i]->mod_op = LDAP_MOD_ADD;
117     mods[i]->mod_type = "objectClass";
118     char *objectClasses[] = { "top", "sudoRole", NULL };
119     mods[i]->mod_values = objectClasses;
120
121     mods[++i] = xmalloc(sizeof(LDAPMod));
122     mods[i]->mod_op = LDAP_MOD_ADD;
123     mods[i]->mod_type = "cn";
124     char *uids[] = { cn, NULL };
125     mods[i]->mod_values = uids;
126
127     mods[++i] = xmalloc(sizeof(LDAPMod));
128     mods[i]->mod_op = LDAP_MOD_ADD;
129     mods[i]->mod_type = "sudoUser";
130     char *sudouser[] = { cn, NULL };
131     mods[i]->mod_values = sudouser;
132
133     mods[++i] = xmalloc(sizeof(LDAPMod));
134     mods[i]->mod_op = LDAP_MOD_ADD;
135     mods[i]->mod_type = "sudoHost";
136     char *sudohost[] = { "ALL", NULL };
137     mods[i]->mod_values = sudohost;
138
139     mods[++i] = xmalloc(sizeof(LDAPMod));
140     mods[i]->mod_op = LDAP_MOD_ADD;
141     mods[i]->mod_type = "sudoCommand";
142     char *sudocommand[] = { "ALL", NULL };
143     mods[i]->mod_values = sudocommand;
144
145     mods[++i] = xmalloc(sizeof(LDAPMod));
146     mods[i]->mod_op = LDAP_MOD_ADD;
147     mods[i]->mod_type = "sudoOption";
148     char *sudooption[] = { "!authenticate", NULL };
149     mods[i]->mod_values = sudooption;
150
151     mods[++i] = xmalloc(sizeof(LDAPMod));
152     mods[i]->mod_op = LDAP_MOD_ADD;
153     mods[i]->mod_type = "sudoRunAs";
154     char *sudorunas[] = { group, NULL };
155     mods[i]->mod_values = sudorunas;
156
157     char dn[1024];
158     snprintf(dn, sizeof(dn), "cn=%%%s,%s", group, basedn);
159
160     mods[++i] = NULL;
161
162     if (ldap_add_s(ld, dn, mods) != LDAP_SUCCESS) {
163         ldap_err("addgroup");
164         ret = -1;
165     }
166
167     for (i = 0; mods[i]; i++)
168         free(mods[i]);
169
170     return ret;
171 }
172
173 int ceo_add_user(char *uid, char *basedn, char *objclass, char *cn, char *home, char *principal, char *shell, int no, ...) {
174     va_list args;
175
176     if (!uid || !basedn || !cn || !home || !shell)
177         fatal("adduser: Invalid argument");
178
179     LDAPMod *mods[16];
180     int i = -1;
181     int ret = 0;
182     int classes = 4;
183
184     mods[++i] = xmalloc(sizeof(LDAPMod));
185     mods[i]->mod_op = LDAP_MOD_ADD;
186     mods[i]->mod_type = "objectClass";
187     char *objectClasses[] = { "top", "account", "posixAccount", "shadowAccount", NULL, NULL, NULL, NULL };
188     if (objclass != NULL)
189         objectClasses[classes++] = objclass;
190     if (principal) {
191         objectClasses[classes++] = "krbPrincipalAux";
192         objectClasses[classes++] = "krbTicketPolicyAux";
193
194     }
195     mods[i]->mod_values = objectClasses;
196
197     mods[++i] = xmalloc(sizeof(LDAPMod));
198     mods[i]->mod_op = LDAP_MOD_ADD;
199     mods[i]->mod_type = "uid";
200     char *uids[] = { uid, NULL };
201     mods[i]->mod_values = uids;
202
203     mods[++i] = xmalloc(sizeof(LDAPMod));
204     mods[i]->mod_op = LDAP_MOD_ADD;
205     mods[i]->mod_type = "cn";
206     char *cns[] = { cn, NULL };
207     mods[i]->mod_values = cns;
208
209     mods[++i] = xmalloc(sizeof(LDAPMod));
210     mods[i]->mod_op = LDAP_MOD_ADD;
211     mods[i]->mod_type = "loginShell";
212     char *shells[] = { shell, NULL };
213     mods[i]->mod_values = shells;
214
215     mods[++i] = xmalloc(sizeof(LDAPMod));
216     mods[i]->mod_op = LDAP_MOD_ADD;
217     mods[i]->mod_type = "uidNumber";
218     char idno[16];
219     snprintf(idno, sizeof(idno), "%d", no);
220     char *uidNumbers[] = { idno, NULL };
221     mods[i]->mod_values = uidNumbers;
222
223     mods[++i] = xmalloc(sizeof(LDAPMod));
224     mods[i]->mod_op = LDAP_MOD_ADD;
225     mods[i]->mod_type = "gidNumber";
226     mods[i]->mod_values = uidNumbers;
227
228     mods[++i] = xmalloc(sizeof(LDAPMod));
229     mods[i]->mod_op = LDAP_MOD_ADD;
230     mods[i]->mod_type = "homeDirectory";
231     char *homeDirectory[] = { home, NULL };
232     mods[i]->mod_values = homeDirectory;
233
234     if (principal) {
235         mods[++i] = xmalloc(sizeof(LDAPMod));
236         mods[i]->mod_op = LDAP_MOD_ADD;
237         mods[i]->mod_type = "krbPrincipalName";
238         char *krbPrincipalName[] = { principal, NULL };
239         mods[i]->mod_values = krbPrincipalName;
240     }
241
242     va_start(args, no);
243     char *attr;
244     while ((attr = va_arg(args, char *))) {
245         char *val = va_arg(args, char *);
246
247         if (!val || !*val)
248             continue;
249
250         if (i == sizeof(mods) / sizeof(*mods) - 2) {
251             error("too many attributes");
252             return -1;
253         }
254
255         mods[++i] = xmalloc(sizeof(LDAPMod));
256         mods[i]->mod_op = LDAP_MOD_ADD;
257         mods[i]->mod_type = attr;
258         char *vals[] = { val, NULL };
259         mods[i]->mod_values = vals;
260     }
261
262     mods[++i] = NULL;
263
264     char dn[1024];
265     snprintf(dn, sizeof(dn), "uid=%s,%s", uid, basedn);
266
267     if (ldap_add_s(ld, dn, mods) != LDAP_SUCCESS) {
268         ldap_err("adduser");
269         ret = -1;
270     }
271
272     for (i = 0; mods[i]; i++)
273         free(mods[i]);
274
275     return ret;
276 }
277
278 int ceo_new_uid(int min, int max) {
279     char filter[64];
280     char *attrs[] = { LDAP_NO_ATTRS, NULL };
281     LDAPMessage *res;
282     int i;
283
284     for (i = min; i <= max; i++) {
285         // id taken due to passwd
286         if (getpwuid(i) != NULL)
287             continue;
288
289         // id taken due to group
290         if (getgrgid(i) != NULL)
291             continue;
292
293         snprintf(filter, sizeof(filter), "(|(uidNumber=%d)(gidNumber=%d))", i, i);
294         if (ldap_search_s(ld, ldap_users_base, LDAP_SCOPE_SUBTREE, filter, attrs, 1, &res) != LDAP_SUCCESS) {
295             ldap_err("firstuid");
296             return -1;
297         }
298
299         int count = ldap_count_entries(ld, res);
300         ldap_msgfree(res);
301
302         // id taken due to LDAP
303         if (count)
304             continue;
305
306         return i;
307     }
308
309     return -1;
310 }
311
312 int ceo_user_exists(char *uid) {
313     char *attrs[] = { LDAP_NO_ATTRS, NULL };
314     LDAPMessage *msg = NULL;
315     char filter[128];
316     int count;
317
318     if (!uid)
319         fatal("null uid");
320
321     snprintf(filter, sizeof(filter), "uid=%s", uid);
322
323     if (ldap_search_s(ld, ldap_users_base, LDAP_SCOPE_SUBTREE, filter, attrs, 0, &msg) != LDAP_SUCCESS) {
324         ldap_err("user_exists");
325         return -1;
326     }
327
328     count = ldap_count_entries(ld, msg);
329     ldap_msgfree(msg);
330
331     return count > 0;
332 }
333
334 int ceo_group_exists(char *cn) {
335     char *attrs[] = { LDAP_NO_ATTRS, NULL };
336     LDAPMessage *msg = NULL;
337     char filter[128];
338     int count;
339
340     if (!cn)
341         fatal("null cd");
342
343     snprintf(filter, sizeof(filter), "cn=%s", cn);
344
345     if (ldap_search_s(ld, ldap_groups_base, LDAP_SCOPE_SUBTREE, filter, attrs, 0, &msg) != LDAP_SUCCESS) {
346         ldap_err("group_exists");
347         return -1;
348     }
349
350     count = ldap_count_entries(ld, msg);
351     ldap_msgfree(msg);
352
353     return count > 0;
354 }
355
356 static int ldap_sasl_interact(LDAP *ld, unsigned flags, void *defaults, void *in) {
357     sasl_interact_t *interact = in;
358
359     while (interact->id != SASL_CB_LIST_END) {
360         switch (interact->id) {
361
362             // GSSAPI doesn't require any callbacks
363
364             default:
365                 interact->result = "";
366                 interact->len = 0;
367         }
368
369         interact++;
370     }
371
372     return LDAP_SUCCESS;
373 }
374
375 void ceo_ldap_init() {
376     int proto = LDAP_DEFAULT_PROTOCOL;
377     const char *sasl_mech = "GSSAPI";
378
379     if (!ldap_admin_principal)
380         fatal("not configured");
381
382     if (ldap_initialize(&ld, ldap_server_url) != LDAP_SUCCESS)
383         ldap_fatal("ldap_initialize");
384
385     if (ldap_set_option(ld, LDAP_OPT_PROTOCOL_VERSION, &proto) != LDAP_OPT_SUCCESS)
386         ldap_fatal("ldap_set_option");
387
388     if (ldap_sasl_interactive_bind_s(ld, NULL, sasl_mech, NULL, NULL,
389                 LDAP_SASL_QUIET, &ldap_sasl_interact, NULL) != LDAP_SUCCESS)
390         ldap_fatal("Bind failed");
391 }
392
393 void ceo_ldap_cleanup() {
394     ldap_unbind(ld);
395 }