lib: Remove global xfile.h includes
[samba.git] / source3 / auth / user_util.c
1 /*
2    Unix SMB/CIFS implementation.
3    Username handling
4    Copyright (C) Andrew Tridgell 1992-1998
5    Copyright (C) Jeremy Allison 1997-2001.
6    Copyright (C) Volker Lendecke 2006
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 3 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, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "includes.h"
23 #include "system/filesys.h"
24 #include "auth.h"
25 #include "lib/util/xfile.h"
26
27 /*******************************************************************
28  Map a username from a dos name to a unix name by looking in the username
29  map. Note that this modifies the name in place.
30  This is the main function that should be called *once* on
31  any incoming or new username - in order to canonicalize the name.
32  This is being done to de-couple the case conversions from the user mapping
33  function. Previously, the map_username was being called
34  every time Get_Pwnam_alloc was called.
35  Returns True if username was changed, false otherwise.
36 ********************************************************************/
37
38 static char *last_from = NULL;
39 static char *last_to = NULL;
40
41 static const char *get_last_from(void)
42 {
43         if (!last_from) {
44                 return "";
45         }
46         return last_from;
47 }
48
49 static const char *get_last_to(void)
50 {
51         if (!last_to) {
52                 return "";
53         }
54         return last_to;
55 }
56
57 static bool set_last_from_to(const char *from, const char *to)
58 {
59         char *orig_from = last_from;
60         char *orig_to = last_to;
61
62         last_from = SMB_STRDUP(from);
63         last_to = SMB_STRDUP(to);
64
65         SAFE_FREE(orig_from);
66         SAFE_FREE(orig_to);
67
68         if (!last_from || !last_to) {
69                 SAFE_FREE(last_from);
70                 SAFE_FREE(last_to);
71                 return false;
72         }
73         return true;
74 }
75
76 static char *skip_space(char *s)
77 {
78         while (isspace((int)(*s))) {
79                 s += 1;
80         }
81         return s;
82 }
83
84 static bool fetch_map_from_gencache(TALLOC_CTX *ctx,
85                         const char *user_in,
86                         char **p_user_out)
87 {
88         char *key, *value;
89         bool found;
90
91         if (lp_username_map_cache_time() == 0) {
92                 return false;
93         }
94
95         key = talloc_asprintf_strupper_m(ctx, "USERNAME_MAP/%s",
96                                          user_in);
97         if (key == NULL) {
98                 return false;
99         }
100         found = gencache_get(key, ctx, &value, NULL);
101         TALLOC_FREE(key);
102         if (!found) {
103                 return false;
104         }
105         TALLOC_FREE(*p_user_out);
106         *p_user_out = value;
107         if (!*p_user_out) {
108                 return false;
109         }
110         return true;
111 }
112
113 static void store_map_in_gencache(TALLOC_CTX *ctx, const char *from, const char *to)
114 {
115         char *key;
116         int cache_time = lp_username_map_cache_time();
117
118         if (cache_time == 0) {
119                 return;
120         }
121
122         key = talloc_asprintf_strupper_m(ctx, "USERNAME_MAP/%s",
123                                          from);
124         if (key == NULL) {
125                 return;
126         }
127         gencache_set(key, to, cache_time + time(NULL));
128         TALLOC_FREE(key);
129 }
130
131 /****************************************************************************
132  Check if a user is in a netgroup user list. If at first we don't succeed,
133  try lower case.
134 ****************************************************************************/
135
136 bool user_in_netgroup(TALLOC_CTX *ctx, const char *user, const char *ngname)
137 {
138 #ifdef HAVE_NETGROUP
139         static char *my_yp_domain = NULL;
140         char *lowercase_user = NULL;
141
142         if (my_yp_domain == NULL) {
143                 yp_get_default_domain(&my_yp_domain);
144         }
145
146         if (my_yp_domain == NULL) {
147                 DEBUG(5,("Unable to get default yp domain, "
148                         "let's try without specifying it\n"));
149         }
150
151         DEBUG(5,("looking for user %s of domain %s in netgroup %s\n",
152                 user, my_yp_domain?my_yp_domain:"(ANY)", ngname));
153
154         if (innetgr(ngname, NULL, user, my_yp_domain)) {
155                 DEBUG(5,("user_in_netgroup: Found\n"));
156                 return true;
157         }
158
159         /*
160          * Ok, innetgr is case sensitive. Try once more with lowercase
161          * just in case. Attempt to fix #703. JRA.
162          */
163         lowercase_user = talloc_strdup(ctx, user);
164         if (!lowercase_user) {
165                 return false;
166         }
167         if (!strlower_m(lowercase_user)) {
168                 return false;
169         }
170
171         if (strcmp(user,lowercase_user) == 0) {
172                 /* user name was already lower case! */
173                 return false;
174         }
175
176         DEBUG(5,("looking for user %s of domain %s in netgroup %s\n",
177                 lowercase_user, my_yp_domain?my_yp_domain:"(ANY)", ngname));
178
179         if (innetgr(ngname, NULL, lowercase_user, my_yp_domain)) {
180                 DEBUG(5,("user_in_netgroup: Found\n"));
181                 return true;
182         }
183 #endif /* HAVE_NETGROUP */
184         return false;
185 }
186
187 /****************************************************************************
188  Check if a user is in a user list - can check combinations of UNIX
189  and netgroup lists.
190 ****************************************************************************/
191
192 bool user_in_list(TALLOC_CTX *ctx, const char *user, const char * const *list)
193 {
194         if (!list || !*list)
195                 return False;
196
197         DEBUG(10,("user_in_list: checking user %s in list\n", user));
198
199         while (*list) {
200
201                 DEBUG(10,("user_in_list: checking user |%s| against |%s|\n",
202                           user, *list));
203
204                 /*
205                  * Check raw username.
206                  */
207                 if (strequal(user, *list))
208                         return(True);
209
210                 /*
211                  * Now check to see if any combination
212                  * of UNIX and netgroups has been specified.
213                  */
214
215                 if(**list == '@') {
216                         /*
217                          * Old behaviour. Check netgroup list
218                          * followed by UNIX list.
219                          */
220                         if(user_in_netgroup(ctx, user, *list +1))
221                                 return True;
222                         if(user_in_group(user, *list +1))
223                                 return True;
224                 } else if (**list == '+') {
225
226                         if((*(*list +1)) == '&') {
227                                 /*
228                                  * Search UNIX list followed by netgroup.
229                                  */
230                                 if(user_in_group(user, *list +2))
231                                         return True;
232                                 if(user_in_netgroup(ctx, user, *list +2))
233                                         return True;
234
235                         } else {
236
237                                 /*
238                                  * Just search UNIX list.
239                                  */
240
241                                 if(user_in_group(user, *list +1))
242                                         return True;
243                         }
244
245                 } else if (**list == '&') {
246
247                         if(*(*list +1) == '+') {
248                                 /*
249                                  * Search netgroup list followed by UNIX list.
250                                  */
251                                 if(user_in_netgroup(ctx, user, *list +2))
252                                         return True;
253                                 if(user_in_group(user, *list +2))
254                                         return True;
255                         } else {
256                                 /*
257                                  * Just search netgroup list.
258                                  */
259                                 if(user_in_netgroup(ctx, user, *list +1))
260                                         return True;
261                         }
262                 }
263
264                 list++;
265         }
266         return(False);
267 }
268
269 bool map_username(TALLOC_CTX *ctx, const char *user_in, char **p_user_out)
270 {
271         XFILE *f;
272         char *mapfile = lp_username_map(talloc_tos());
273         char *s;
274         char buf[512];
275         bool mapped_user = False;
276         char *cmd = lp_username_map_script(talloc_tos());
277
278         *p_user_out = NULL;
279
280         if (!user_in)
281                 return false;
282
283         /* Initially make a copy of the incoming name. */
284         *p_user_out = talloc_strdup(ctx, user_in);
285         if (!*p_user_out) {
286                 return false;
287         }
288
289         if (strequal(user_in,get_last_to()))
290                 return false;
291
292         if (strequal(user_in,get_last_from())) {
293                 DEBUG(3,("Mapped user %s to %s\n",user_in,get_last_to()));
294                 TALLOC_FREE(*p_user_out);
295                 *p_user_out = talloc_strdup(ctx, get_last_to());
296                 return true;
297         }
298
299         if (fetch_map_from_gencache(ctx, user_in, p_user_out)) {
300                 return true;
301         }
302
303         /* first try the username map script */
304
305         if ( *cmd ) {
306                 char **qlines;
307                 char *command = NULL;
308                 int numlines, ret, fd;
309
310                 command = talloc_asprintf(ctx,
311                                         "%s \"%s\"",
312                                         cmd,
313                                         user_in);
314                 if (!command) {
315                         return false;
316                 }
317
318                 DEBUG(10,("Running [%s]\n", command));
319                 ret = smbrun(command, &fd, NULL);
320                 DEBUGADD(10,("returned [%d]\n", ret));
321
322                 TALLOC_FREE(command);
323
324                 if ( ret != 0 ) {
325                         if (fd != -1)
326                                 close(fd);
327                         return False;
328                 }
329
330                 numlines = 0;
331                 qlines = fd_lines_load(fd, &numlines, 0, ctx);
332                 DEBUGADD(10,("Lines returned = [%d]\n", numlines));
333                 close(fd);
334
335                 /* should be either no lines or a single line with the mapped username */
336
337                 if (numlines && qlines) {
338                         DEBUG(3,("Mapped user %s to %s\n", user_in, qlines[0] ));
339                         set_last_from_to(user_in, qlines[0]);
340                         store_map_in_gencache(ctx, user_in, qlines[0]);
341                         TALLOC_FREE(*p_user_out);
342                         *p_user_out = talloc_strdup(ctx, qlines[0]);
343                         if (!*p_user_out) {
344                                 return false;
345                         }
346                 }
347
348                 TALLOC_FREE(qlines);
349
350                 return numlines != 0;
351         }
352
353         /* ok.  let's try the mapfile */
354         if (!*mapfile)
355                 return False;
356
357         f = x_fopen(mapfile,O_RDONLY, 0);
358         if (!f) {
359                 DEBUG(0,("can't open username map %s. Error %s\n",mapfile, strerror(errno) ));
360                 return False;
361         }
362
363         DEBUG(4,("Scanning username map %s\n",mapfile));
364
365         while((s=x_fgets_slash(buf,sizeof(buf),f))!=NULL) {
366                 char *unixname = s;
367                 char *dosname = strchr_m(unixname,'=');
368                 char **dosuserlist;
369                 bool return_if_mapped = False;
370
371                 if (!dosname)
372                         continue;
373
374                 *dosname++ = 0;
375
376                 unixname = skip_space(unixname);
377
378                 if ('!' == *unixname) {
379                         return_if_mapped = True;
380                         unixname = skip_space(unixname+1);
381                 }
382
383                 if (!*unixname || strchr_m("#;",*unixname))
384                         continue;
385
386                 {
387                         int l = strlen(unixname);
388                         while (l && isspace((int)unixname[l-1])) {
389                                 unixname[l-1] = 0;
390                                 l--;
391                         }
392                 }
393
394                 /* skip lines like 'user = ' */
395
396                 dosuserlist = str_list_make_v3(ctx, dosname, NULL);
397                 if (!dosuserlist) {
398                         DEBUG(0,("Bad username map entry.  Unable to build user list.  Ignoring.\n"));
399                         continue;
400                 }
401
402                 if (strchr_m(dosname,'*') ||
403                     user_in_list(ctx, user_in, (const char * const *)dosuserlist)) {
404                         DEBUG(3,("Mapped user %s to %s\n",user_in,unixname));
405                         mapped_user = True;
406
407                         set_last_from_to(user_in, unixname);
408                         store_map_in_gencache(ctx, user_in, unixname);
409                         TALLOC_FREE(*p_user_out);
410                         *p_user_out = talloc_strdup(ctx, unixname);
411                         if (!*p_user_out) {
412                                 TALLOC_FREE(dosuserlist);
413                                 x_fclose(f);
414                                 return false;
415                         }
416
417                         if ( return_if_mapped ) {
418                                 TALLOC_FREE(dosuserlist);
419                                 x_fclose(f);
420                                 return True;
421                         }
422                 }
423
424                 TALLOC_FREE(dosuserlist);
425         }
426
427         x_fclose(f);
428
429         /*
430          * If we didn't successfully map a user in the loop above,
431          * setup the last_from and last_to as an optimization so
432          * that we don't scan the file again for the same user.
433          */
434         if (!mapped_user) {
435                 DEBUG(8, ("The user '%s' has no mapping. "
436                           "Skip it next time.\n", user_in));
437                 set_last_from_to(user_in, user_in);
438                 store_map_in_gencache(ctx, user_in, user_in);
439         }
440
441         return mapped_user;
442 }