Merge from vendor branch CVS:
[dragonfly.git] / contrib / libpam / libpamc / pamc_load.c
1 /*
2  * $Id: pamc_load.c,v 1.1.1.1 2000/06/20 22:11:26 agmorgan Exp $
3  *
4  * Copyright (c) 1999 Andrew G. Morgan <morgan@ftp.kernel.org>
5  *
6  * pamc_load
7  */
8
9 #include "libpamc.h"
10
11 static int __pamc_exec_agent(pamc_handle_t pch, pamc_agent_t *agent)
12 {
13     char *full_path;
14     int found_agent, length, reset_length, to_agent[2], from_agent[2];
15     int return_code = PAM_BPC_FAIL;
16
17     if (agent->id[agent->id_length] != '\0') {
18         PAM_BP_ASSERT("libpamc: internal error agent_id not terminated");
19     }
20
21     for (length=0; (length < agent->id_length); ++length) {
22         switch (agent->id[length]) {
23         case '/':
24             D(("ill formed agent id"));
25             return PAM_BPC_FAIL;
26         }
27     }
28     
29     /* enough memory for any path + this agent */
30     reset_length = 3 + pch->max_path + agent->id_length;
31     D(("reset_length = %d (3+%d+%d)",
32        reset_length, pch->max_path, agent->id_length));
33     full_path = malloc(reset_length);
34     if (full_path == NULL) {
35         D(("no memory for agent path"));
36         return PAM_BPC_FAIL;
37     }
38
39     found_agent = 0;
40     for (length=0; pch->agent_paths[length]; ++length) {
41         struct stat buf;
42
43         D(("path: [%s]", pch->agent_paths[length]));
44         D(("agent id: [%s]", agent->id));
45
46         sprintf(full_path, "%s/%s", pch->agent_paths[length], agent->id);
47
48         D(("looking for agent here: [%s]\n", full_path));
49         if (stat(full_path, &buf) == 0) {
50             D(("file existis"));
51             found_agent = 1;
52             break;
53         }
54     }
55
56     if (! found_agent) {
57         D(("no agent was found"));
58         goto free_and_return;
59     }
60         
61     if (pipe(to_agent)) {
62         D(("failed to open pipe to agent"));
63         goto free_and_return;
64     }
65
66     if (pipe(from_agent)) {
67         D(("failed to open pipe from agent"));
68         goto close_the_agent;
69     }
70
71     agent->pid = fork();
72     if (agent->pid == -1) {
73
74         D(("failed to fork for agent"));
75         goto close_both_pipes;
76
77     } else if (agent->pid == 0) {
78
79         int i;
80
81         dup2(from_agent[1], STDOUT_FILENO);
82         dup2(to_agent[0], STDIN_FILENO);
83
84         /* we close all of the files that have filedescriptors lower
85            and equal to twice the highest we have seen, The idea is
86            that we don't want to leak filedescriptors to agents from a
87            privileged client application.
88
89            XXX - this is a heuristic at this point. There is a growing
90             need for an extra 'set param' libpamc function, that could
91             be used to supply info like the highest fd to close etc..
92         */
93
94         if (from_agent[1] > pch->highest_fd_to_close) {
95             pch->highest_fd_to_close = 2*from_agent[1];
96         }
97
98         for (i=0; i <= pch->highest_fd_to_close; ++i) {
99             switch (i) {
100             case STDOUT_FILENO:
101             case STDERR_FILENO:
102             case STDIN_FILENO:
103                 /* only these three remain open */
104                 break;
105             default:
106                 (void) close(i); /* don't care if its not open */
107             }
108         }
109
110         /* we make no attempt to drop other privileges - this library
111            has no idea how that would be done in the general case. It
112            is up to the client application (when calling
113            pamc_converse) to make sure no privilege will leak into an
114            (untrusted) agent. */
115
116         /* we propogate no environment - future versions of this
117            library may have the ability to audit all agent
118            transactions. */
119
120         D(("exec'ing agent %s", full_path));
121         execle(full_path, "pam-agent", NULL, NULL);
122
123         D(("exec failed"));
124         exit(1);
125
126     }
127
128     close(to_agent[0]);
129     close(from_agent[1]);
130
131     agent->writer = to_agent[1];
132     agent->reader = from_agent[0];
133
134     return_code = PAM_BPC_TRUE;
135     goto free_and_return;
136
137 close_both_pipes:
138     close(from_agent[0]);
139     close(from_agent[1]);
140
141 close_the_agent:
142     close(to_agent[0]);
143     close(to_agent[1]);
144
145 free_and_return:
146     memset(full_path, 0, reset_length);
147     free(full_path);
148
149     D(("returning %d", return_code));
150
151     return return_code;
152 }
153
154 /*
155  * has the named agent been loaded?
156  */
157
158 static int __pamc_agent_is_enabled(pamc_handle_t pch, const char *agent_id)
159 {
160     pamc_agent_t *agent;
161
162     for (agent = pch->chain; agent; agent = agent->next) {
163         if (!strcmp(agent->id, agent_id)) {
164             D(("agent already loaded"));
165             return PAM_BPC_TRUE;
166         }
167     }
168
169     D(("agent is not loaded"));
170     return PAM_BPC_FALSE;
171 }
172
173 /*
174  * has the named agent been disabled?
175  */
176
177 static int __pamc_agent_is_disabled(pamc_handle_t pch, const char *agent_id)
178 {
179     pamc_blocked_t *blocked;
180
181     for (blocked=pch->blocked_agents; blocked; blocked = blocked->next) {
182         if (!strcmp(agent_id, blocked->id)) {
183             D(("agent is disabled"));
184             return PAM_BPC_TRUE;
185         }
186     }
187
188     D(("agent is not disabled"));
189     return PAM_BPC_FALSE;
190 }
191
192 /*
193  * disable an agent
194  */
195
196 int pamc_disable(pamc_handle_t pch, const char *agent_id)
197 {
198     pamc_blocked_t *block;
199
200     if (pch == NULL) {
201         D(("pch is NULL"));
202         return PAM_BPC_FALSE;
203     }
204
205     if (agent_id == NULL) {
206         D(("agent_id is NULL"));
207         return PAM_BPC_FALSE;
208     }
209
210     if (__pamc_agent_is_enabled(pch, agent_id) != PAM_BPC_FALSE) {
211         D(("agent is already loaded"));
212         return PAM_BPC_FALSE;
213     }
214
215     if (__pamc_agent_is_disabled(pch, agent_id) != PAM_BPC_FALSE) {
216         D(("agent is already disabled"));
217         return PAM_BPC_TRUE;
218     }
219
220     block = calloc(1, sizeof(pamc_blocked_t));
221     if (block == NULL) {
222         D(("no memory for new blocking structure"));
223         return PAM_BPC_FALSE;
224     }
225
226     block->id = malloc(1 + strlen(agent_id));
227     if (block->id == NULL) {
228         D(("no memory for agent id"));
229         free(block);
230         return PAM_BPC_FALSE;
231     }
232
233     strcpy(block->id, agent_id);
234     block->next = pch->blocked_agents;
235     pch->blocked_agents = block;
236
237     return PAM_BPC_TRUE;
238 }
239
240 /*
241  * force the loading of a particular agent
242  */
243
244 int pamc_load(pamc_handle_t pch, const char *agent_id)
245 {
246     pamc_agent_t *agent;
247     int length;
248
249     /* santity checking */
250
251     if (pch == NULL) {
252         D(("pch is NULL"));
253         return PAM_BPC_FALSE;
254     }
255
256     if (agent_id == NULL) {
257         D(("agent_id is NULL"));
258         return PAM_BPC_FALSE;
259     }
260
261     if (__pamc_agent_is_disabled(pch, agent_id) != PAM_BPC_FALSE) {
262         D(("sorry agent is disabled"));
263         return PAM_BPC_FALSE;
264     }
265     
266     length = strlen(agent_id);
267
268     /* scan list to see if agent is loaded */
269
270     if (__pamc_agent_is_enabled(pch, agent_id) == PAM_BPC_TRUE) {
271         D(("no need to load an already loaded agent (%s)", agent_id));
272         return PAM_BPC_TRUE;
273     }
274
275     /* not in the list, so we need to load it and add it to the head
276        of the chain */
277
278     agent = calloc(1, sizeof(pamc_agent_t));
279     if (agent == NULL) {
280         D(("no memory for new agent"));
281         return PAM_BPC_FALSE;
282     }
283     agent->id = calloc(1, 1+length);
284     if (agent->id == NULL) {
285         D(("no memory for new agent's id"));
286         goto fail_free_agent;
287     }
288     memcpy(agent->id, agent_id, length);
289     agent->id[length] = '\0';
290     agent->id_length = length;
291
292     if (__pamc_exec_agent(pch, agent) != PAM_BPC_TRUE) {
293         D(("unable to exec agent"));
294         goto fail_free_agent_id;
295     }
296
297     agent->next = pch->chain;
298     pch->chain = agent;
299     
300     return PAM_BPC_TRUE;
301
302 fail_free_agent_id:
303
304     memset(agent->id, 0, agent->id_length);
305     free(agent->id);
306
307     memset(agent, 0, sizeof(*agent));
308
309 fail_free_agent:
310
311     free(agent);
312     return PAM_BPC_FALSE;
313 }
314
315 /*
316  * what's a valid agent name?
317  */
318
319 int __pamc_valid_agent_id(int id_length, const char *id)
320 {
321     int post, i;
322
323     for (i=post=0 ; i < id_length; ++i) {
324         int ch = id[i++];
325
326         if (isalpha(ch) || isdigit(ch) || (ch == '_')) {
327             continue;
328         } else if (post && (ch == '.')) {
329             continue;
330         } else if ((i > 1) && (!post) && (ch == '@')) {
331             post = 1;
332         } else {
333             D(("id=%s contains '%c' which is illegal", id, ch));
334             return 0;
335         }
336     }
337
338     if (!i) {
339         D(("length of id is 0"));
340         return 0;
341     } else {
342         return 1;                       /* id is valid */
343     }
344 }
345
346 /*
347  * building a tree of available agent names
348  */
349
350 static pamc_id_node_t *__pamc_add_node(pamc_id_node_t *root, const char *id,
351                                        int *counter)
352 {
353     if (root) {
354
355         int cmp;
356
357         if ((cmp = strcmp(id, root->agent_id))) {
358             if (cmp > 0) {
359                 root->right = __pamc_add_node(root->right, id,
360                                               &(root->child_count));
361             } else {
362                 root->left = __pamc_add_node(root->left, id,
363                                              &(root->child_count));
364             }
365         }
366
367         return root;
368
369     } else {
370
371         pamc_id_node_t *node = calloc(1, sizeof(pamc_id_node_t));
372
373         if (node) {
374             node->agent_id = malloc(1+strlen(id));
375             if (node->agent_id) {
376                 strcpy(node->agent_id, id);
377             } else {
378                 free(node);
379                 node = NULL;
380             }
381         }
382
383         (*counter)++;
384         return node;
385     }
386 }
387
388 /*
389  * drop all of the tree and any remaining ids
390  */
391
392 static pamc_id_node_t *__pamc_liberate_nodes(pamc_id_node_t *tree)
393 {
394     if (tree) {
395         if (tree->agent_id) {
396             free(tree->agent_id);
397             tree->agent_id = NULL;
398         }
399
400         tree->left = __pamc_liberate_nodes(tree->left);
401         tree->right = __pamc_liberate_nodes(tree->right);
402
403         tree->child_count = 0;
404         free(tree);
405     }
406
407     return NULL;
408 }
409
410 /*
411  * fill a list with the contents of the tree (in ascii order)
412  */
413
414 static void __pamc_fill_list_from_tree(pamc_id_node_t *tree, char **agent_list,
415                                        int *counter)
416 {
417     if (tree) {
418         __pamc_fill_list_from_tree(tree->left, agent_list, counter);
419         agent_list[(*counter)++] = tree->agent_id;
420         tree->agent_id = NULL;
421         __pamc_fill_list_from_tree(tree->right, agent_list, counter);
422     }
423 }
424
425 /*
426  * get a list of the available agents
427  */
428
429 char **pamc_list_agents(pamc_handle_t pch)
430 {
431     int i, total_agent_count=0;
432     pamc_id_node_t *tree = NULL;
433     char **agent_list;
434
435     /* loop over agent paths */
436
437     for (i=0; pch->agent_paths[i]; ++i) {
438         DIR *dir;
439
440         dir = opendir(pch->agent_paths[i]);
441         if (dir) {
442             struct dirent *item;
443
444             while ((item = readdir(dir))) {
445
446                 /* this is a cheat on recognizing agent_ids */
447                 if (!__pamc_valid_agent_id(strlen(item->d_name),
448                                            item->d_name)) {
449                     continue;
450                 }
451
452                 tree = __pamc_add_node(tree, item->d_name, &total_agent_count);
453             }
454
455             closedir(dir);
456         }
457     }
458
459     /* now, we build a list of ids */
460     D(("total of %d available agents\n", total_agent_count));
461
462     agent_list = calloc(total_agent_count+1, sizeof(char *));
463     if (agent_list) {
464         int counter=0;
465
466         __pamc_fill_list_from_tree(tree, agent_list, &counter);
467         if (counter != total_agent_count) {
468             PAM_BP_ASSERT("libpamc: internal error transcribing tree");
469         }
470     } else {
471         D(("no memory for agent list"));
472     }
473
474     __pamc_liberate_nodes(tree);
475
476     return agent_list;
477 }