s3-lib: Do not set an empty string in split_domain_user()
[samba.git] / source3 / lib / util.c
1 /* 
2    Unix SMB/CIFS implementation.
3    Samba utility functions
4    Copyright (C) Andrew Tridgell 1992-1998
5    Copyright (C) Jeremy Allison 2001-2007
6    Copyright (C) Simo Sorce 2001
7    Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2003
8    Copyright (C) James Peach 2006
9
10    This program is free software; you can redistribute it and/or modify
11    it under the terms of the GNU General Public License as published by
12    the Free Software Foundation; either version 3 of the License, or
13    (at your option) any later version.
14
15    This program is distributed in the hope that it will be useful,
16    but WITHOUT ANY WARRANTY; without even the implied warranty of
17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18    GNU General Public License for more details.
19
20    You should have received a copy of the GNU General Public License
21    along with this program.  If not, see <http://www.gnu.org/licenses/>.
22 */
23
24 #include "includes.h"
25 #include "system/passwd.h"
26 #include "system/filesys.h"
27 #include "util_tdb.h"
28 #include "ctdbd_conn.h"
29 #include "../lib/util/util_pw.h"
30 #include "messages.h"
31 #include "messages_dgm.h"
32 #include "libcli/security/security.h"
33 #include "serverid.h"
34 #include "lib/util/sys_rw.h"
35 #include "lib/util/sys_rw_data.h"
36 #include "lib/util/util_process.h"
37
38 #ifdef HAVE_SYS_PRCTL_H
39 #include <sys/prctl.h>
40 #endif
41
42 /* Max allowable allococation - 256mb - 0x10000000 */
43 #define MAX_ALLOC_SIZE (1024*1024*256)
44
45 #if (defined(HAVE_NETGROUP) && defined (WITH_AUTOMOUNT))
46 #ifdef WITH_NISPLUS_HOME
47 #ifdef BROKEN_NISPLUS_INCLUDE_FILES
48 /*
49  * The following lines are needed due to buggy include files
50  * in Solaris 2.6 which define GROUP in both /usr/include/sys/acl.h and
51  * also in /usr/include/rpcsvc/nis.h. The definitions conflict. JRA.
52  * Also GROUP_OBJ is defined as 0x4 in /usr/include/sys/acl.h and as
53  * an enum in /usr/include/rpcsvc/nis.h.
54  */
55
56 #if defined(GROUP)
57 #undef GROUP
58 #endif
59
60 #if defined(GROUP_OBJ)
61 #undef GROUP_OBJ
62 #endif
63
64 #endif /* BROKEN_NISPLUS_INCLUDE_FILES */
65
66 #include <rpcsvc/nis.h>
67
68 #endif /* WITH_NISPLUS_HOME */
69 #endif /* HAVE_NETGROUP && WITH_AUTOMOUNT */
70
71 static enum protocol_types Protocol = PROTOCOL_COREPLUS;
72
73 enum protocol_types get_Protocol(void)
74 {
75         return Protocol;
76 }
77
78 void set_Protocol(enum protocol_types  p)
79 {
80         Protocol = p;
81 }
82
83 static enum remote_arch_types ra_type = RA_UNKNOWN;
84
85 void gfree_all( void )
86 {
87         gfree_names();
88         gfree_loadparm();
89         gfree_charcnv();
90         gfree_interfaces();
91         gfree_debugsyms();
92 }
93
94 /*******************************************************************
95  Check if a file exists - call vfs_file_exist for samba files.
96 ********************************************************************/
97
98 bool file_exist_stat(const char *fname,SMB_STRUCT_STAT *sbuf,
99                      bool fake_dir_create_times)
100 {
101         SMB_STRUCT_STAT st;
102         if (!sbuf)
103                 sbuf = &st;
104
105         if (sys_stat(fname, sbuf, fake_dir_create_times) != 0)
106                 return(False);
107
108         return((S_ISREG(sbuf->st_ex_mode)) || (S_ISFIFO(sbuf->st_ex_mode)));
109 }
110
111 /*******************************************************************
112  Check if a unix domain socket exists - call vfs_file_exist for samba files.
113 ********************************************************************/
114
115 bool socket_exist(const char *fname)
116 {
117         SMB_STRUCT_STAT st;
118         if (sys_stat(fname, &st, false) != 0)
119                 return(False);
120
121         return S_ISSOCK(st.st_ex_mode);
122 }
123
124 /*******************************************************************
125  Returns the size in bytes of the named given the stat struct.
126 ********************************************************************/
127
128 uint64_t get_file_size_stat(const SMB_STRUCT_STAT *sbuf)
129 {
130         return sbuf->st_ex_size;
131 }
132
133 /****************************************************************************
134  Check two stats have identical dev and ino fields.
135 ****************************************************************************/
136
137 bool check_same_dev_ino(const SMB_STRUCT_STAT *sbuf1,
138                         const SMB_STRUCT_STAT *sbuf2)
139 {
140         if (sbuf1->st_ex_dev != sbuf2->st_ex_dev ||
141                         sbuf1->st_ex_ino != sbuf2->st_ex_ino) {
142                 return false;
143         }
144         return true;
145 }
146
147 /****************************************************************************
148  Check if a stat struct is identical for use.
149 ****************************************************************************/
150
151 bool check_same_stat(const SMB_STRUCT_STAT *sbuf1,
152                         const SMB_STRUCT_STAT *sbuf2)
153 {
154         if (sbuf1->st_ex_uid != sbuf2->st_ex_uid ||
155                         sbuf1->st_ex_gid != sbuf2->st_ex_gid ||
156                         !check_same_dev_ino(sbuf1, sbuf2)) {
157                 return false;
158         }
159         return true;
160 }
161
162 /*******************************************************************
163  Show a smb message structure.
164 ********************************************************************/
165
166 void show_msg(const char *buf)
167 {
168         int i;
169         int bcc=0;
170
171         if (!DEBUGLVL(5))
172                 return;
173
174         DEBUG(5,("size=%d\nsmb_com=0x%x\nsmb_rcls=%d\nsmb_reh=%d\nsmb_err=%d\nsmb_flg=%d\nsmb_flg2=%d\n",
175                         smb_len(buf),
176                         (int)CVAL(buf,smb_com),
177                         (int)CVAL(buf,smb_rcls),
178                         (int)CVAL(buf,smb_reh),
179                         (int)SVAL(buf,smb_err),
180                         (int)CVAL(buf,smb_flg),
181                         (int)SVAL(buf,smb_flg2)));
182         DEBUGADD(5,("smb_tid=%d\nsmb_pid=%d\nsmb_uid=%d\nsmb_mid=%d\n",
183                         (int)SVAL(buf,smb_tid),
184                         (int)SVAL(buf,smb_pid),
185                         (int)SVAL(buf,smb_uid),
186                         (int)SVAL(buf,smb_mid)));
187         DEBUGADD(5,("smt_wct=%d\n",(int)CVAL(buf,smb_wct)));
188
189         for (i=0;i<(int)CVAL(buf,smb_wct);i++)
190                 DEBUGADD(5,("smb_vwv[%2d]=%5d (0x%X)\n",i,
191                         SVAL(buf,smb_vwv+2*i),SVAL(buf,smb_vwv+2*i)));
192
193         bcc = (int)SVAL(buf,smb_vwv+2*(CVAL(buf,smb_wct)));
194
195         DEBUGADD(5,("smb_bcc=%d\n",bcc));
196
197         if (DEBUGLEVEL < 10)
198                 return;
199
200         if (DEBUGLEVEL < 50)
201                 bcc = MIN(bcc, 512);
202
203         dump_data(10, (const uint8_t *)smb_buf_const(buf), bcc);
204 }
205
206 /*******************************************************************
207  Setup only the byte count for a smb message.
208 ********************************************************************/
209
210 int set_message_bcc(char *buf,int num_bytes)
211 {
212         int num_words = CVAL(buf,smb_wct);
213         SSVAL(buf,smb_vwv + num_words*SIZEOFWORD,num_bytes);
214         _smb_setlen(buf,smb_size + num_words*2 + num_bytes - 4);
215         return (smb_size + num_words*2 + num_bytes);
216 }
217
218 /*******************************************************************
219  Add a data blob to the end of a smb_buf, adjusting bcc and smb_len.
220  Return the bytes added
221 ********************************************************************/
222
223 ssize_t message_push_blob(uint8_t **outbuf, DATA_BLOB blob)
224 {
225         size_t newlen = smb_len(*outbuf) + 4 + blob.length;
226         uint8_t *tmp;
227
228         if (!(tmp = talloc_realloc(NULL, *outbuf, uint8_t, newlen))) {
229                 DEBUG(0, ("talloc failed\n"));
230                 return -1;
231         }
232         *outbuf = tmp;
233
234         memcpy(tmp + smb_len(tmp) + 4, blob.data, blob.length);
235         set_message_bcc((char *)tmp, smb_buflen(tmp) + blob.length);
236         return blob.length;
237 }
238
239 /*******************************************************************
240  Reduce a file name, removing .. elements.
241 ********************************************************************/
242
243 static char *dos_clean_name(TALLOC_CTX *ctx, const char *s)
244 {
245         char *p = NULL;
246         char *str = NULL;
247
248         DEBUG(3,("dos_clean_name [%s]\n",s));
249
250         /* remove any double slashes */
251         str = talloc_all_string_sub(ctx, s, "\\\\", "\\");
252         if (!str) {
253                 return NULL;
254         }
255
256         /* Remove leading .\\ characters */
257         if(strncmp(str, ".\\", 2) == 0) {
258                 trim_string(str, ".\\", NULL);
259                 if(*str == 0) {
260                         str = talloc_strdup(ctx, ".\\");
261                         if (!str) {
262                                 return NULL;
263                         }
264                 }
265         }
266
267         while ((p = strstr_m(str,"\\..\\")) != NULL) {
268                 char *s1;
269
270                 *p = 0;
271                 s1 = p+3;
272
273                 if ((p=strrchr_m(str,'\\')) != NULL) {
274                         *p = 0;
275                 } else {
276                         *str = 0;
277                 }
278                 str = talloc_asprintf(ctx,
279                                 "%s%s",
280                                 str,
281                                 s1);
282                 if (!str) {
283                         return NULL;
284                 }
285         }
286
287         trim_string(str,NULL,"\\..");
288         return talloc_all_string_sub(ctx, str, "\\.\\", "\\");
289 }
290
291 /*******************************************************************
292  Reduce a file name, removing .. elements.
293 ********************************************************************/
294
295 char *unix_clean_name(TALLOC_CTX *ctx, const char *s)
296 {
297         char *p = NULL;
298         char *str = NULL;
299
300         DEBUG(3,("unix_clean_name [%s]\n",s));
301
302         /* remove any double slashes */
303         str = talloc_all_string_sub(ctx, s, "//","/");
304         if (!str) {
305                 return NULL;
306         }
307
308         /* Remove leading ./ characters */
309         if(strncmp(str, "./", 2) == 0) {
310                 trim_string(str, "./", NULL);
311                 if(*str == 0) {
312                         str = talloc_strdup(ctx, "./");
313                         if (!str) {
314                                 return NULL;
315                         }
316                 }
317         }
318
319         while ((p = strstr_m(str,"/../")) != NULL) {
320                 char *s1;
321
322                 *p = 0;
323                 s1 = p+3;
324
325                 if ((p=strrchr_m(str,'/')) != NULL) {
326                         *p = 0;
327                 } else {
328                         *str = 0;
329                 }
330                 str = talloc_asprintf(ctx,
331                                 "%s%s",
332                                 str,
333                                 s1);
334                 if (!str) {
335                         return NULL;
336                 }
337         }
338
339         trim_string(str,NULL,"/..");
340         return talloc_all_string_sub(ctx, str, "/./", "/");
341 }
342
343 char *clean_name(TALLOC_CTX *ctx, const char *s)
344 {
345         char *str = dos_clean_name(ctx, s);
346         if (!str) {
347                 return NULL;
348         }
349         return unix_clean_name(ctx, str);
350 }
351
352 /*******************************************************************
353  Write data into an fd at a given offset. Ignore seek errors.
354 ********************************************************************/
355
356 ssize_t write_data_at_offset(int fd, const char *buffer, size_t N, off_t pos)
357 {
358         size_t total=0;
359         ssize_t ret;
360
361         if (pos == (off_t)-1) {
362                 return write_data(fd, buffer, N);
363         }
364 #if defined(HAVE_PWRITE) || defined(HAVE_PRWITE64)
365         while (total < N) {
366                 ret = sys_pwrite(fd,buffer + total,N - total, pos);
367                 if (ret == -1 && errno == ESPIPE) {
368                         return write_data(fd, buffer + total,N - total);
369                 }
370                 if (ret == -1) {
371                         DEBUG(0,("write_data_at_offset: write failure. Error = %s\n", strerror(errno) ));
372                         return -1;
373                 }
374                 if (ret == 0) {
375                         return total;
376                 }
377                 total += ret;
378                 pos += ret;
379         }
380         return (ssize_t)total;
381 #else
382         /* Use lseek and write_data. */
383         if (lseek(fd, pos, SEEK_SET) == -1) {
384                 if (errno != ESPIPE) {
385                         return -1;
386                 }
387         }
388         return write_data(fd, buffer, N);
389 #endif
390 }
391
392 static int reinit_after_fork_pipe[2] = { -1, -1 };
393
394 NTSTATUS init_before_fork(void)
395 {
396         int ret;
397
398         ret = pipe(reinit_after_fork_pipe);
399         if (ret == -1) {
400                 NTSTATUS status;
401
402                 status = map_nt_error_from_unix_common(errno);
403
404                 DEBUG(0, ("Error creating child_pipe: %s\n",
405                           nt_errstr(status)));
406
407                 return status;
408         }
409
410         return NT_STATUS_OK;
411 }
412
413 /**
414  * Detect died parent by detecting EOF on the pipe
415  */
416 static void reinit_after_fork_pipe_handler(struct tevent_context *ev,
417                                            struct tevent_fd *fde,
418                                            uint16_t flags,
419                                            void *private_data)
420 {
421         char c;
422
423         if (sys_read(reinit_after_fork_pipe[0], &c, 1) != 1) {
424                 /*
425                  * we have reached EOF on stdin, which means the
426                  * parent has exited. Shutdown the server
427                  */
428                 (void)kill(getpid(), SIGTERM);
429         }
430 }
431
432
433 NTSTATUS reinit_after_fork(struct messaging_context *msg_ctx,
434                            struct tevent_context *ev_ctx,
435                            bool parent_longlived,
436                            const char *comment)
437 {
438         NTSTATUS status = NT_STATUS_OK;
439
440         if (reinit_after_fork_pipe[1] != -1) {
441                 close(reinit_after_fork_pipe[1]);
442                 reinit_after_fork_pipe[1] = -1;
443         }
444
445         /* tdb needs special fork handling */
446         if (tdb_reopen_all(parent_longlived ? 1 : 0) != 0) {
447                 DEBUG(0,("tdb_reopen_all failed.\n"));
448                 status = NT_STATUS_OPEN_FAILED;
449                 goto done;
450         }
451
452         if (ev_ctx != NULL) {
453                 tevent_set_trace_callback(ev_ctx, NULL, NULL);
454                 if (tevent_re_initialise(ev_ctx) != 0) {
455                         smb_panic(__location__ ": Failed to re-initialise event context");
456                 }
457         }
458
459         if (reinit_after_fork_pipe[0] != -1) {
460                 struct tevent_fd *fde;
461
462                 fde = tevent_add_fd(ev_ctx, ev_ctx /* TALLOC_CTX */,
463                                     reinit_after_fork_pipe[0], TEVENT_FD_READ,
464                                     reinit_after_fork_pipe_handler, NULL);
465                 if (fde == NULL) {
466                         smb_panic(__location__ ": Failed to add reinit_after_fork pipe event");
467                 }
468         }
469
470         if (msg_ctx) {
471                 /*
472                  * For clustering, we need to re-init our ctdbd connection after the
473                  * fork
474                  */
475                 status = messaging_reinit(msg_ctx);
476                 if (!NT_STATUS_IS_OK(status)) {
477                         DEBUG(0,("messaging_reinit() failed: %s\n",
478                                  nt_errstr(status)));
479                 }
480         }
481
482         if (comment) {
483                 prctl_set_comment(comment);
484         }
485
486  done:
487         return status;
488 }
489
490 /****************************************************************************
491  (Hopefully) efficient array append.
492 ****************************************************************************/
493
494 void add_to_large_array(TALLOC_CTX *mem_ctx, size_t element_size,
495                         void *element, void *_array, uint32_t *num_elements,
496                         ssize_t *array_size)
497 {
498         void **array = (void **)_array;
499
500         if (*array_size < 0) {
501                 return;
502         }
503
504         if (*array == NULL) {
505                 if (*array_size == 0) {
506                         *array_size = 128;
507                 }
508
509                 if (*array_size >= MAX_ALLOC_SIZE/element_size) {
510                         goto error;
511                 }
512
513                 *array = TALLOC(mem_ctx, element_size * (*array_size));
514                 if (*array == NULL) {
515                         goto error;
516                 }
517         }
518
519         if (*num_elements == *array_size) {
520                 *array_size *= 2;
521
522                 if (*array_size >= MAX_ALLOC_SIZE/element_size) {
523                         goto error;
524                 }
525
526                 *array = TALLOC_REALLOC(mem_ctx, *array,
527                                         element_size * (*array_size));
528
529                 if (*array == NULL) {
530                         goto error;
531                 }
532         }
533
534         memcpy((char *)(*array) + element_size*(*num_elements),
535                element, element_size);
536         *num_elements += 1;
537
538         return;
539
540  error:
541         *num_elements = 0;
542         *array_size = -1;
543 }
544
545 /****************************************************************************
546  Get my own domain name, or "" if we have none.
547 ****************************************************************************/
548
549 char *get_mydnsdomname(TALLOC_CTX *ctx)
550 {
551         const char *domname;
552         char *p;
553
554         domname = get_mydnsfullname();
555         if (!domname) {
556                 return NULL;
557         }
558
559         p = strchr_m(domname, '.');
560         if (p) {
561                 p++;
562                 return talloc_strdup(ctx, p);
563         } else {
564                 return talloc_strdup(ctx, "");
565         }
566 }
567
568 #if (defined(HAVE_NETGROUP) && defined(WITH_AUTOMOUNT))
569 /******************************************************************
570  Remove any mount options such as -rsize=2048,wsize=2048 etc.
571  Based on a fix from <Thomas.Hepper@icem.de>.
572  Returns a malloc'ed string.
573 *******************************************************************/
574
575 static char *strip_mount_options(TALLOC_CTX *ctx, const char *str)
576 {
577         if (*str == '-') {
578                 const char *p = str;
579                 while(*p && !isspace(*p))
580                         p++;
581                 while(*p && isspace(*p))
582                         p++;
583                 if(*p) {
584                         return talloc_strdup(ctx, p);
585                 }
586         }
587         return NULL;
588 }
589
590 /*******************************************************************
591  Patch from jkf@soton.ac.uk
592  Split Luke's automount_server into YP lookup and string splitter
593  so can easily implement automount_path().
594  Returns a malloc'ed string.
595 *******************************************************************/
596
597 #ifdef WITH_NISPLUS_HOME
598 char *automount_lookup(TALLOC_CTX *ctx, const char *user_name)
599 {
600         char *value = NULL;
601
602         char *nis_map = (char *)lp_homedir_map();
603
604         char buffer[NIS_MAXATTRVAL + 1];
605         nis_result *result;
606         nis_object *object;
607         entry_obj  *entry;
608
609         snprintf(buffer, sizeof(buffer), "[key=%s],%s", user_name, nis_map);
610         DEBUG(5, ("NIS+ querystring: %s\n", buffer));
611
612         if (result = nis_list(buffer, FOLLOW_PATH|EXPAND_NAME|HARD_LOOKUP, NULL, NULL)) {
613                 if (result->status != NIS_SUCCESS) {
614                         DEBUG(3, ("NIS+ query failed: %s\n", nis_sperrno(result->status)));
615                 } else {
616                         object = result->objects.objects_val;
617                         if (object->zo_data.zo_type == ENTRY_OBJ) {
618                                 entry = &object->zo_data.objdata_u.en_data;
619                                 DEBUG(5, ("NIS+ entry type: %s\n", entry->en_type));
620                                 DEBUG(3, ("NIS+ result: %s\n", entry->en_cols.en_cols_val[1].ec_value.ec_value_val));
621
622                                 value = talloc_strdup(ctx,
623                                                 entry->en_cols.en_cols_val[1].ec_value.ec_value_val);
624                                 if (!value) {
625                                         nis_freeresult(result);
626                                         return NULL;
627                                 }
628                                 value = talloc_string_sub(ctx,
629                                                 value,
630                                                 "&",
631                                                 user_name);
632                         }
633                 }
634         }
635         nis_freeresult(result);
636
637         if (value) {
638                 value = strip_mount_options(ctx, value);
639                 DEBUG(4, ("NIS+ Lookup: %s resulted in %s\n",
640                                         user_name, value));
641         }
642         return value;
643 }
644 #else /* WITH_NISPLUS_HOME */
645
646 char *automount_lookup(TALLOC_CTX *ctx, const char *user_name)
647 {
648         char *value = NULL;
649
650         int nis_error;        /* returned by yp all functions */
651         char *nis_result;     /* yp_match inits this */
652         int nis_result_len;  /* and set this */
653         char *nis_domain;     /* yp_get_default_domain inits this */
654         char *nis_map = lp_homedir_map(talloc_tos());
655
656         if ((nis_error = yp_get_default_domain(&nis_domain)) != 0) {
657                 DEBUG(3, ("YP Error: %s\n", yperr_string(nis_error)));
658                 return NULL;
659         }
660
661         DEBUG(5, ("NIS Domain: %s\n", nis_domain));
662
663         if ((nis_error = yp_match(nis_domain, nis_map, user_name,
664                                         strlen(user_name), &nis_result,
665                                         &nis_result_len)) == 0) {
666                 if (nis_result_len > 0 && nis_result[nis_result_len] == '\n') {
667                         nis_result[nis_result_len] = '\0';
668                 }
669                 value = talloc_strdup(ctx, nis_result);
670                 if (!value) {
671                         return NULL;
672                 }
673                 value = strip_mount_options(ctx, value);
674         } else if(nis_error == YPERR_KEY) {
675                 DEBUG(3, ("YP Key not found:  while looking up \"%s\" in map \"%s\"\n", 
676                                 user_name, nis_map));
677                 DEBUG(3, ("using defaults for server and home directory\n"));
678         } else {
679                 DEBUG(3, ("YP Error: \"%s\" while looking up \"%s\" in map \"%s\"\n", 
680                                 yperr_string(nis_error), user_name, nis_map));
681         }
682
683         if (value) {
684                 DEBUG(4, ("YP Lookup: %s resulted in %s\n", user_name, value));
685         }
686         return value;
687 }
688 #endif /* WITH_NISPLUS_HOME */
689 #endif
690
691 bool process_exists(const struct server_id pid)
692 {
693         return serverid_exists(&pid);
694 }
695
696 /*******************************************************************
697  Convert a uid into a user name.
698 ********************************************************************/
699
700 const char *uidtoname(uid_t uid)
701 {
702         TALLOC_CTX *ctx = talloc_tos();
703         char *name = NULL;
704         struct passwd *pass = NULL;
705
706         pass = getpwuid_alloc(ctx,uid);
707         if (pass) {
708                 name = talloc_strdup(ctx,pass->pw_name);
709                 TALLOC_FREE(pass);
710         } else {
711                 name = talloc_asprintf(ctx,
712                                 "%ld",
713                                 (long int)uid);
714         }
715         return name;
716 }
717
718 /*******************************************************************
719  Convert a gid into a group name.
720 ********************************************************************/
721
722 char *gidtoname(gid_t gid)
723 {
724         struct group *grp;
725
726         grp = getgrgid(gid);
727         if (grp) {
728                 return talloc_strdup(talloc_tos(), grp->gr_name);
729         }
730         else {
731                 return talloc_asprintf(talloc_tos(),
732                                         "%d",
733                                         (int)gid);
734         }
735 }
736
737 /*******************************************************************
738  Convert a user name into a uid.
739 ********************************************************************/
740
741 uid_t nametouid(const char *name)
742 {
743         struct passwd *pass;
744         char *p;
745         uid_t u;
746
747         pass = Get_Pwnam_alloc(talloc_tos(), name);
748         if (pass) {
749                 u = pass->pw_uid;
750                 TALLOC_FREE(pass);
751                 return u;
752         }
753
754         u = (uid_t)strtol(name, &p, 0);
755         if ((p != name) && (*p == '\0'))
756                 return u;
757
758         return (uid_t)-1;
759 }
760
761 /*******************************************************************
762  Convert a name to a gid_t if possible. Return -1 if not a group. 
763 ********************************************************************/
764
765 gid_t nametogid(const char *name)
766 {
767         struct group *grp;
768         char *p;
769         gid_t g;
770
771         g = (gid_t)strtol(name, &p, 0);
772         if ((p != name) && (*p == '\0'))
773                 return g;
774
775         grp = getgrnam(name);
776         if (grp)
777                 return(grp->gr_gid);
778         return (gid_t)-1;
779 }
780
781 /*******************************************************************
782  Something really nasty happened - panic !
783 ********************************************************************/
784
785 void smb_panic_s3(const char *why)
786 {
787         char *cmd;
788         int result;
789
790         DEBUG(0,("PANIC (pid %llu): %s\n",
791                     (unsigned long long)getpid(), why));
792         log_stack_trace();
793
794 #if defined(HAVE_PRCTL) && defined(PR_SET_PTRACER)
795         /*
796          * Make sure all children can attach a debugger.
797          */
798         prctl(PR_SET_PTRACER, getpid(), 0, 0, 0);
799 #endif
800
801         cmd = lp_panic_action(talloc_tos());
802         if (cmd && *cmd) {
803                 DEBUG(0, ("smb_panic(): calling panic action [%s]\n", cmd));
804                 result = system(cmd);
805
806                 if (result == -1)
807                         DEBUG(0, ("smb_panic(): fork failed in panic action: %s\n",
808                                           strerror(errno)));
809                 else
810                         DEBUG(0, ("smb_panic(): action returned status %d\n",
811                                           WEXITSTATUS(result)));
812         }
813
814         dump_core();
815 }
816
817 /*******************************************************************
818  Print a backtrace of the stack to the debug log. This function
819  DELIBERATELY LEAKS MEMORY. The expectation is that you should
820  exit shortly after calling it.
821 ********************************************************************/
822
823 #ifdef HAVE_LIBUNWIND_H
824 #include <libunwind.h>
825 #endif
826
827 #ifdef HAVE_EXECINFO_H
828 #include <execinfo.h>
829 #endif
830
831 #ifdef HAVE_LIBEXC_H
832 #include <libexc.h>
833 #endif
834
835 void log_stack_trace(void)
836 {
837 #ifdef HAVE_LIBUNWIND
838         /* Try to use libunwind before any other technique since on ia64
839          * libunwind correctly walks the stack in more circumstances than
840          * backtrace.
841          */ 
842         unw_cursor_t cursor;
843         unw_context_t uc;
844         unsigned i = 0;
845
846         char procname[256];
847         unw_word_t ip, sp, off;
848
849         procname[sizeof(procname) - 1] = '\0';
850
851         if (unw_getcontext(&uc) != 0) {
852                 goto libunwind_failed;
853         }
854
855         if (unw_init_local(&cursor, &uc) != 0) {
856                 goto libunwind_failed;
857         }
858
859         DEBUG(0, ("BACKTRACE:\n"));
860
861         do {
862             ip = sp = 0;
863             unw_get_reg(&cursor, UNW_REG_IP, &ip);
864             unw_get_reg(&cursor, UNW_REG_SP, &sp);
865
866             switch (unw_get_proc_name(&cursor,
867                         procname, sizeof(procname) - 1, &off) ) {
868             case 0:
869                     /* Name found. */
870             case -UNW_ENOMEM:
871                     /* Name truncated. */
872                     DEBUGADD(0, (" #%u %s + %#llx [ip=%#llx] [sp=%#llx]\n",
873                             i, procname, (long long)off,
874                             (long long)ip, (long long) sp));
875                     break;
876             default:
877             /* case -UNW_ENOINFO: */
878             /* case -UNW_EUNSPEC: */
879                     /* No symbol name found. */
880                     DEBUGADD(0, (" #%u %s [ip=%#llx] [sp=%#llx]\n",
881                             i, "<unknown symbol>",
882                             (long long)ip, (long long) sp));
883             }
884             ++i;
885         } while (unw_step(&cursor) > 0);
886
887         return;
888
889 libunwind_failed:
890         DEBUG(0, ("unable to produce a stack trace with libunwind\n"));
891
892 #elif HAVE_BACKTRACE_SYMBOLS
893         void *backtrace_stack[BACKTRACE_STACK_SIZE];
894         size_t backtrace_size;
895         char **backtrace_strings;
896
897         /* get the backtrace (stack frames) */
898         backtrace_size = backtrace(backtrace_stack,BACKTRACE_STACK_SIZE);
899         backtrace_strings = backtrace_symbols(backtrace_stack, backtrace_size);
900
901         DEBUG(0, ("BACKTRACE: %lu stack frames:\n", 
902                   (unsigned long)backtrace_size));
903
904         if (backtrace_strings) {
905                 int i;
906
907                 for (i = 0; i < backtrace_size; i++)
908                         DEBUGADD(0, (" #%u %s\n", i, backtrace_strings[i]));
909
910                 /* Leak the backtrace_strings, rather than risk what free() might do */
911         }
912
913 #elif HAVE_LIBEXC
914
915         /* The IRIX libexc library provides an API for unwinding the stack. See
916          * libexc(3) for details. Apparantly trace_back_stack leaks memory, but
917          * since we are about to abort anyway, it hardly matters.
918          */
919
920 #define NAMESIZE 32 /* Arbitrary */
921
922         __uint64_t      addrs[BACKTRACE_STACK_SIZE];
923         char *          names[BACKTRACE_STACK_SIZE];
924         char            namebuf[BACKTRACE_STACK_SIZE * NAMESIZE];
925
926         int             i;
927         int             levels;
928
929         ZERO_ARRAY(addrs);
930         ZERO_ARRAY(names);
931         ZERO_ARRAY(namebuf);
932
933         /* We need to be root so we can open our /proc entry to walk
934          * our stack. It also helps when we want to dump core.
935          */
936         become_root();
937
938         for (i = 0; i < BACKTRACE_STACK_SIZE; i++) {
939                 names[i] = namebuf + (i * NAMESIZE);
940         }
941
942         levels = trace_back_stack(0, addrs, names,
943                         BACKTRACE_STACK_SIZE, NAMESIZE - 1);
944
945         DEBUG(0, ("BACKTRACE: %d stack frames:\n", levels));
946         for (i = 0; i < levels; i++) {
947                 DEBUGADD(0, (" #%d 0x%llx %s\n", i, addrs[i], names[i]));
948         }
949 #undef NAMESIZE
950
951 #else
952         DEBUG(0, ("unable to produce a stack trace on this platform\n"));
953 #endif
954 }
955
956 /*******************************************************************
957   A readdir wrapper which just returns the file name.
958  ********************************************************************/
959
960 const char *readdirname(DIR *p)
961 {
962         struct dirent *ptr;
963         char *dname;
964
965         if (!p)
966                 return(NULL);
967
968         ptr = (struct dirent *)readdir(p);
969         if (!ptr)
970                 return(NULL);
971
972         dname = ptr->d_name;
973
974 #ifdef NEXT2
975         if (telldir(p) < 0)
976                 return(NULL);
977 #endif
978
979 #ifdef HAVE_BROKEN_READDIR_NAME
980         /* using /usr/ucb/cc is BAD */
981         dname = dname - 2;
982 #endif
983
984         return talloc_strdup(talloc_tos(), dname);
985 }
986
987 /*******************************************************************
988  Utility function used to decide if the last component 
989  of a path matches a (possibly wildcarded) entry in a namelist.
990 ********************************************************************/
991
992 bool is_in_path(const char *name, name_compare_entry *namelist, bool case_sensitive)
993 {
994         const char *last_component;
995
996         /* if we have no list it's obviously not in the path */
997         if((namelist == NULL ) || ((namelist != NULL) && (namelist[0].name == NULL))) {
998                 return False;
999         }
1000
1001         DEBUG(8, ("is_in_path: %s\n", name));
1002
1003         /* Get the last component of the unix name. */
1004         last_component = strrchr_m(name, '/');
1005         if (!last_component) {
1006                 last_component = name;
1007         } else {
1008                 last_component++; /* Go past '/' */
1009         }
1010
1011         for(; namelist->name != NULL; namelist++) {
1012                 if(namelist->is_wild) {
1013                         if (mask_match(last_component, namelist->name, case_sensitive)) {
1014                                 DEBUG(8,("is_in_path: mask match succeeded\n"));
1015                                 return True;
1016                         }
1017                 } else {
1018                         if((case_sensitive && (strcmp(last_component, namelist->name) == 0))||
1019                                                 (!case_sensitive && (strcasecmp_m(last_component, namelist->name) == 0))) {
1020                                 DEBUG(8,("is_in_path: match succeeded\n"));
1021                                 return True;
1022                         }
1023                 }
1024         }
1025         DEBUG(8,("is_in_path: match not found\n"));
1026         return False;
1027 }
1028
1029 /*******************************************************************
1030  Strip a '/' separated list into an array of 
1031  name_compare_enties structures suitable for 
1032  passing to is_in_path(). We do this for
1033  speed so we can pre-parse all the names in the list 
1034  and don't do it for each call to is_in_path().
1035  We also check if the entry contains a wildcard to
1036  remove a potentially expensive call to mask_match
1037  if possible.
1038 ********************************************************************/
1039
1040 void set_namearray(name_compare_entry **ppname_array, const char *namelist_in)
1041 {
1042         char *name_end;
1043         char *namelist;
1044         char *namelist_end;
1045         char *nameptr;
1046         int num_entries = 0;
1047         int i;
1048
1049         (*ppname_array) = NULL;
1050
1051         if((namelist_in == NULL ) || ((namelist_in != NULL) && (*namelist_in == '\0'))) 
1052                 return;
1053
1054         namelist = talloc_strdup(talloc_tos(), namelist_in);
1055         if (namelist == NULL) {
1056                 DEBUG(0,("set_namearray: talloc fail\n"));
1057                 return;
1058         }
1059         nameptr = namelist;
1060
1061         namelist_end = &namelist[strlen(namelist)];
1062
1063         /* We need to make two passes over the string. The
1064                 first to count the number of elements, the second
1065                 to split it.
1066         */
1067
1068         while(nameptr <= namelist_end) {
1069                 if ( *nameptr == '/' ) {
1070                         /* cope with multiple (useless) /s) */
1071                         nameptr++;
1072                         continue;
1073                 }
1074                 /* anything left? */
1075                 if ( *nameptr == '\0' )
1076                         break;
1077
1078                 /* find the next '/' or consume remaining */
1079                 name_end = strchr_m(nameptr, '/');
1080                 if (name_end == NULL) {
1081                         /* Point nameptr at the terminating '\0' */
1082                         nameptr += strlen(nameptr);
1083                 } else {
1084                         /* next segment please */
1085                         nameptr = name_end + 1;
1086                 }
1087                 num_entries++;
1088         }
1089
1090         if(num_entries == 0) {
1091                 talloc_free(namelist);
1092                 return;
1093         }
1094
1095         if(( (*ppname_array) = SMB_MALLOC_ARRAY(name_compare_entry, num_entries + 1)) == NULL) {
1096                 DEBUG(0,("set_namearray: malloc fail\n"));
1097                 talloc_free(namelist);
1098                 return;
1099         }
1100
1101         /* Now copy out the names */
1102         nameptr = namelist;
1103         i = 0;
1104         while(nameptr <= namelist_end) {
1105                 if ( *nameptr == '/' ) {
1106                         /* cope with multiple (useless) /s) */
1107                         nameptr++;
1108                         continue;
1109                 }
1110                 /* anything left? */
1111                 if ( *nameptr == '\0' )
1112                         break;
1113
1114                 /* find the next '/' or consume remaining */
1115                 name_end = strchr_m(nameptr, '/');
1116                 if (name_end != NULL) {
1117                         *name_end = '\0';
1118                 }
1119
1120                 (*ppname_array)[i].is_wild = ms_has_wild(nameptr);
1121                 if(((*ppname_array)[i].name = SMB_STRDUP(nameptr)) == NULL) {
1122                         DEBUG(0,("set_namearray: malloc fail (1)\n"));
1123                         talloc_free(namelist);
1124                         return;
1125                 }
1126
1127                 if (name_end == NULL) {
1128                         /* Point nameptr at the terminating '\0' */
1129                         nameptr += strlen(nameptr);
1130                 } else {
1131                         /* next segment please */
1132                         nameptr = name_end + 1;
1133                 }
1134                 i++;
1135         }
1136
1137         (*ppname_array)[i].name = NULL;
1138
1139         talloc_free(namelist);
1140         return;
1141 }
1142
1143 #undef DBGC_CLASS
1144 #define DBGC_CLASS DBGC_LOCKING
1145
1146 /****************************************************************************
1147  Simple routine to query existing file locks. Cruft in NFS and 64->32 bit mapping
1148  is dealt with in posix.c
1149  Returns True if we have information regarding this lock region (and returns
1150  F_UNLCK in *ptype if the region is unlocked). False if the call failed.
1151 ****************************************************************************/
1152
1153 bool fcntl_getlock(int fd, int op, off_t *poffset, off_t *pcount, int *ptype, pid_t *ppid)
1154 {
1155         struct flock lock;
1156         int ret;
1157
1158         DEBUG(8,("fcntl_getlock fd=%d op=%d offset=%.0f count=%.0f type=%d\n",
1159                     fd,op,(double)*poffset,(double)*pcount,*ptype));
1160
1161         lock.l_type = *ptype;
1162         lock.l_whence = SEEK_SET;
1163         lock.l_start = *poffset;
1164         lock.l_len = *pcount;
1165         lock.l_pid = 0;
1166
1167         ret = sys_fcntl_ptr(fd,op,&lock);
1168
1169         if (ret == -1) {
1170                 int sav = errno;
1171                 DEBUG(3,("fcntl_getlock: lock request failed at offset %.0f count %.0f type %d (%s)\n",
1172                         (double)*poffset,(double)*pcount,*ptype,strerror(errno)));
1173                 errno = sav;
1174                 return False;
1175         }
1176
1177         *ptype = lock.l_type;
1178         *poffset = lock.l_start;
1179         *pcount = lock.l_len;
1180         *ppid = lock.l_pid;
1181
1182         DEBUG(3,("fcntl_getlock: fd %d is returned info %d pid %u\n",
1183                         fd, (int)lock.l_type, (unsigned int)lock.l_pid));
1184         return True;
1185 }
1186
1187 #if defined(HAVE_OFD_LOCKS)
1188 int map_process_lock_to_ofd_lock(int op, bool *use_ofd_locks)
1189 {
1190         switch (op) {
1191         case F_GETLK:
1192         case F_OFD_GETLK:
1193                 op = F_OFD_GETLK;
1194                 break;
1195         case F_SETLK:
1196         case F_OFD_SETLK:
1197                 op = F_OFD_SETLK;
1198                 break;
1199         case F_SETLKW:
1200         case F_OFD_SETLKW:
1201                 op = F_OFD_SETLKW;
1202                 break;
1203         default:
1204                 *use_ofd_locks = false;
1205                 return -1;
1206         }
1207         *use_ofd_locks = true;
1208         return op;
1209 }
1210 #else /* HAVE_OFD_LOCKS */
1211 int map_process_lock_to_ofd_lock(int op, bool *use_ofd_locks)
1212 {
1213         *use_ofd_locks = false;
1214         return op;
1215 }
1216 #endif /* HAVE_OFD_LOCKS */
1217
1218 #undef DBGC_CLASS
1219 #define DBGC_CLASS DBGC_ALL
1220
1221 /*******************************************************************
1222  Is the name specified one of my netbios names.
1223  Returns true if it is equal, false otherwise.
1224 ********************************************************************/
1225
1226 bool is_myname(const char *s)
1227 {
1228         int n;
1229         bool ret = False;
1230
1231         for (n=0; my_netbios_names(n); n++) {
1232                 const char *nbt_name = my_netbios_names(n);
1233
1234                 if (strncasecmp_m(nbt_name, s, MAX_NETBIOSNAME_LEN-1) == 0) {
1235                         ret=True;
1236                         break;
1237                 }
1238         }
1239         DEBUG(8, ("is_myname(\"%s\") returns %d\n", s, ret));
1240         return(ret);
1241 }
1242
1243 /*******************************************************************
1244  we distinguish between 2K and XP by the "Native Lan Manager" string
1245    WinXP => "Windows 2002 5.1"
1246    WinXP 64bit => "Windows XP 5.2"
1247    Win2k => "Windows 2000 5.0"
1248    NT4   => "Windows NT 4.0"
1249    Win9x => "Windows 4.0"
1250  Windows 2003 doesn't set the native lan manager string but
1251  they do set the domain to "Windows 2003 5.2" (probably a bug).
1252 ********************************************************************/
1253
1254 void ra_lanman_string( const char *native_lanman )
1255 {
1256         if ( strcmp( native_lanman, "Windows 2002 5.1" ) == 0 )
1257                 set_remote_arch( RA_WINXP );
1258         else if ( strcmp( native_lanman, "Windows XP 5.2" ) == 0 )
1259                 set_remote_arch( RA_WINXP64 );
1260         else if ( strcmp( native_lanman, "Windows Server 2003 5.2" ) == 0 )
1261                 set_remote_arch( RA_WIN2K3 );
1262 }
1263
1264 static const char *remote_arch_strings[] = {
1265         [RA_UNKNOWN] =  "UNKNOWN",
1266         [RA_WFWG] =     "WfWg",
1267         [RA_OS2] =      "OS2",
1268         [RA_WIN95] =    "Win95",
1269         [RA_WINNT] =    "WinNT",
1270         [RA_WIN2K] =    "Win2K",
1271         [RA_WINXP] =    "WinXP",
1272         [RA_WIN2K3] =   "Win2K3",
1273         [RA_VISTA] =    "Vista",
1274         [RA_SAMBA] =    "Samba",
1275         [RA_CIFSFS] =   "CIFSFS",
1276         [RA_WINXP64] =  "WinXP64",
1277         [RA_OSX] =      "OSX",
1278 };
1279
1280 const char *get_remote_arch_str(void)
1281 {
1282         if (ra_type >= ARRAY_SIZE(remote_arch_strings)) {
1283                 /*
1284                  * set_remote_arch() already checks this so ra_type
1285                  * should be in the allowed range, but anyway, let's
1286                  * do another bound check here.
1287                  */
1288                 DBG_ERR("Remote arch info out of sync [%d] missing\n", ra_type);
1289                 ra_type = RA_UNKNOWN;
1290         }
1291         return remote_arch_strings[ra_type];
1292 }
1293
1294 enum remote_arch_types get_remote_arch_from_str(const char *remote_arch_string)
1295 {
1296         int i;
1297
1298         for (i = 0; i < ARRAY_SIZE(remote_arch_strings); i++) {
1299                 if (strcmp(remote_arch_string, remote_arch_strings[i]) == 0) {
1300                         return i;
1301                 }
1302         }
1303         return RA_UNKNOWN;
1304 }
1305
1306 /*******************************************************************
1307  Set the horrid remote_arch string based on an enum.
1308 ********************************************************************/
1309
1310 void set_remote_arch(enum remote_arch_types type)
1311 {
1312         if (ra_type >= ARRAY_SIZE(remote_arch_strings)) {
1313                 /*
1314                  * This protects against someone adding values to enum
1315                  * remote_arch_types without updating
1316                  * remote_arch_strings array.
1317                  */
1318                 DBG_ERR("Remote arch info out of sync [%d] missing\n", ra_type);
1319                 ra_type = RA_UNKNOWN;
1320                 return;
1321         }
1322
1323         ra_type = type;
1324         DEBUG(10,("set_remote_arch: Client arch is \'%s\'\n",
1325                   get_remote_arch_str()));
1326 }
1327
1328 /*******************************************************************
1329  Get the remote_arch type.
1330 ********************************************************************/
1331
1332 enum remote_arch_types get_remote_arch(void)
1333 {
1334         return ra_type;
1335 }
1336
1337 #define RA_CACHE_TTL 7*24*3600
1338
1339 static bool remote_arch_cache_key(const struct GUID *client_guid,
1340                                   fstring key)
1341 {
1342         struct GUID_txt_buf guid_buf;
1343         const char *guid_string = NULL;
1344
1345         guid_string = GUID_buf_string(client_guid, &guid_buf);
1346         if (guid_string == NULL) {
1347                 return false;
1348         }
1349
1350         fstr_sprintf(key, "RA/%s", guid_string);
1351         return true;
1352 }
1353
1354 struct ra_parser_state {
1355         bool found;
1356         enum remote_arch_types ra;
1357 };
1358
1359 static void ra_parser(time_t timeout, DATA_BLOB blob, void *priv_data)
1360 {
1361         struct ra_parser_state *state = (struct ra_parser_state *)priv_data;
1362         const char *ra_str = NULL;
1363
1364         if (timeout <= time(NULL)) {
1365                 return;
1366         }
1367
1368         if ((blob.length == 0) || (blob.data[blob.length-1] != '\0')) {
1369                 DBG_ERR("Remote arch cache key not a string\n");
1370                 return;
1371         }
1372
1373         ra_str = (const char *)blob.data;
1374         DBG_INFO("Got remote arch [%s] from cache\n", ra_str);
1375
1376         state->ra = get_remote_arch_from_str(ra_str);
1377         state->found = true;
1378         return;
1379 }
1380
1381 static bool remote_arch_cache_get(const struct GUID *client_guid)
1382 {
1383         bool ok;
1384         fstring ra_key;
1385         struct ra_parser_state state = (struct ra_parser_state) {
1386                 .found = false,
1387                 .ra = RA_UNKNOWN,
1388         };
1389
1390         ok = remote_arch_cache_key(client_guid, ra_key);
1391         if (!ok) {
1392                 return false;
1393         }
1394
1395         ok = gencache_parse(ra_key, ra_parser, &state);
1396         if (!ok || !state.found) {
1397                 return true;
1398         }
1399
1400         if (state.ra == RA_UNKNOWN) {
1401                 return true;
1402         }
1403
1404         set_remote_arch(state.ra);
1405         return true;
1406 }
1407
1408 static bool remote_arch_cache_set(const struct GUID *client_guid)
1409 {
1410         bool ok;
1411         fstring ra_key;
1412         const char *ra_str = NULL;
1413
1414         if (get_remote_arch() == RA_UNKNOWN) {
1415                 return true;
1416         }
1417
1418         ok = remote_arch_cache_key(client_guid, ra_key);
1419         if (!ok) {
1420                 return false;
1421         }
1422
1423         ra_str = get_remote_arch_str();
1424         if (ra_str == NULL) {
1425                 return false;
1426         }
1427
1428         ok = gencache_set(ra_key, ra_str, time(NULL) + RA_CACHE_TTL);
1429         if (!ok) {
1430                 return false;
1431         }
1432
1433         return true;
1434 }
1435
1436 bool remote_arch_cache_update(const struct GUID *client_guid)
1437 {
1438         bool ok;
1439
1440         if (get_remote_arch() == RA_UNKNOWN) {
1441
1442                 become_root();
1443                 ok = remote_arch_cache_get(client_guid);
1444                 unbecome_root();
1445
1446                 return ok;
1447         }
1448
1449         become_root();
1450         ok = remote_arch_cache_set(client_guid);
1451         unbecome_root();
1452
1453         return ok;
1454 }
1455
1456 bool remote_arch_cache_delete(const struct GUID *client_guid)
1457 {
1458         bool ok;
1459         fstring ra_key;
1460
1461         ok = remote_arch_cache_key(client_guid, ra_key);
1462         if (!ok) {
1463                 return false;
1464         }
1465
1466         become_root();
1467         ok = gencache_del(ra_key);
1468         unbecome_root();
1469
1470         if (!ok) {
1471                 return false;
1472         }
1473
1474         return true;
1475 }
1476
1477 const char *tab_depth(int level, int depth)
1478 {
1479         if( CHECK_DEBUGLVL(level) ) {
1480                 dbgtext("%*s", depth*4, "");
1481         }
1482         return "";
1483 }
1484
1485 /*****************************************************************************
1486  Provide a checksum on a string
1487
1488  Input:  s - the null-terminated character string for which the checksum
1489              will be calculated.
1490
1491   Output: The checksum value calculated for s.
1492 *****************************************************************************/
1493
1494 int str_checksum(const char *s)
1495 {
1496         TDB_DATA key;
1497         if (s == NULL)
1498                 return 0;
1499
1500         key = (TDB_DATA) { .dptr = discard_const_p(uint8_t, s),
1501                            .dsize = strlen(s) };
1502
1503         return tdb_jenkins_hash(&key);
1504 }
1505
1506 /*****************************************************************
1507  Zero a memory area then free it. Used to catch bugs faster.
1508 *****************************************************************/  
1509
1510 void zero_free(void *p, size_t size)
1511 {
1512         memset(p, 0, size);
1513         SAFE_FREE(p);
1514 }
1515
1516 /*****************************************************************
1517  Set our open file limit to a requested max and return the limit.
1518 *****************************************************************/  
1519
1520 int set_maxfiles(int requested_max)
1521 {
1522 #if (defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE))
1523         struct rlimit rlp;
1524         int saved_current_limit;
1525
1526         if(getrlimit(RLIMIT_NOFILE, &rlp)) {
1527                 DEBUG(0,("set_maxfiles: getrlimit (1) for RLIMIT_NOFILE failed with error %s\n",
1528                         strerror(errno) ));
1529                 /* just guess... */
1530                 return requested_max;
1531         }
1532
1533         /* 
1534          * Set the fd limit to be real_max_open_files + MAX_OPEN_FUDGEFACTOR to
1535          * account for the extra fd we need 
1536          * as well as the log files and standard
1537          * handles etc. Save the limit we want to set in case
1538          * we are running on an OS that doesn't support this limit (AIX)
1539          * which always returns RLIM_INFINITY for rlp.rlim_max.
1540          */
1541
1542         /* Try raising the hard (max) limit to the requested amount. */
1543
1544 #if defined(RLIM_INFINITY)
1545         if (rlp.rlim_max != RLIM_INFINITY) {
1546                 int orig_max = rlp.rlim_max;
1547
1548                 if ( rlp.rlim_max < requested_max )
1549                         rlp.rlim_max = requested_max;
1550
1551                 /* This failing is not an error - many systems (Linux) don't
1552                         support our default request of 10,000 open files. JRA. */
1553
1554                 if(setrlimit(RLIMIT_NOFILE, &rlp)) {
1555                         DEBUG(3,("set_maxfiles: setrlimit for RLIMIT_NOFILE for %d max files failed with error %s\n", 
1556                                 (int)rlp.rlim_max, strerror(errno) ));
1557
1558                         /* Set failed - restore original value from get. */
1559                         rlp.rlim_max = orig_max;
1560                 }
1561         }
1562 #endif
1563
1564         /* Now try setting the soft (current) limit. */
1565
1566         saved_current_limit = rlp.rlim_cur = MIN(requested_max,rlp.rlim_max);
1567
1568         if(setrlimit(RLIMIT_NOFILE, &rlp)) {
1569                 DEBUG(0,("set_maxfiles: setrlimit for RLIMIT_NOFILE for %d files failed with error %s\n", 
1570                         (int)rlp.rlim_cur, strerror(errno) ));
1571                 /* just guess... */
1572                 return saved_current_limit;
1573         }
1574
1575         if(getrlimit(RLIMIT_NOFILE, &rlp)) {
1576                 DEBUG(0,("set_maxfiles: getrlimit (2) for RLIMIT_NOFILE failed with error %s\n",
1577                         strerror(errno) ));
1578                 /* just guess... */
1579                 return saved_current_limit;
1580     }
1581
1582 #if defined(RLIM_INFINITY)
1583         if(rlp.rlim_cur == RLIM_INFINITY)
1584                 return saved_current_limit;
1585 #endif
1586
1587         if((int)rlp.rlim_cur > saved_current_limit)
1588                 return saved_current_limit;
1589
1590         return rlp.rlim_cur;
1591 #else /* !defined(HAVE_GETRLIMIT) || !defined(RLIMIT_NOFILE) */
1592         /*
1593          * No way to know - just guess...
1594          */
1595         return requested_max;
1596 #endif
1597 }
1598
1599 /*****************************************************************
1600  malloc that aborts with smb_panic on fail or zero size.
1601  *****************************************************************/  
1602
1603 void *smb_xmalloc_array(size_t size, unsigned int count)
1604 {
1605         void *p;
1606         if (size == 0) {
1607                 smb_panic("smb_xmalloc_array: called with zero size");
1608         }
1609         if (count >= MAX_ALLOC_SIZE/size) {
1610                 smb_panic("smb_xmalloc_array: alloc size too large");
1611         }
1612         if ((p = SMB_MALLOC(size*count)) == NULL) {
1613                 DEBUG(0, ("smb_xmalloc_array failed to allocate %lu * %lu bytes\n",
1614                         (unsigned long)size, (unsigned long)count));
1615                 smb_panic("smb_xmalloc_array: malloc failed");
1616         }
1617         return p;
1618 }
1619
1620 /*
1621   vasprintf that aborts on malloc fail
1622 */
1623
1624  int smb_xvasprintf(char **ptr, const char *format, va_list ap)
1625 {
1626         int n;
1627         va_list ap2;
1628
1629         va_copy(ap2, ap);
1630
1631         n = vasprintf(ptr, format, ap2);
1632         va_end(ap2);
1633         if (n == -1 || ! *ptr) {
1634                 smb_panic("smb_xvasprintf: out of memory");
1635         }
1636         return n;
1637 }
1638
1639 /*****************************************************************
1640  Get local hostname and cache result.
1641 *****************************************************************/
1642
1643 char *myhostname(void)
1644 {
1645         static char *ret;
1646         if (ret == NULL) {
1647                 ret = get_myname(NULL);
1648         }
1649         return ret;
1650 }
1651
1652 /*****************************************************************
1653  Get local hostname and cache result.
1654 *****************************************************************/
1655
1656 char *myhostname_upper(void)
1657 {
1658         static char *ret;
1659         if (ret == NULL) {
1660                 char *name = get_myname(NULL);
1661                 if (name == NULL) {
1662                         return NULL;
1663                 }
1664                 ret = strupper_talloc(NULL, name);
1665                 talloc_free(name);
1666         }
1667         return ret;
1668 }
1669
1670 /*******************************************************************
1671  Given a filename - get its directory name
1672 ********************************************************************/
1673
1674 bool parent_dirname(TALLOC_CTX *mem_ctx, const char *dir, char **parent,
1675                     const char **name)
1676 {
1677         char *p;
1678         ptrdiff_t len;
1679
1680         p = strrchr_m(dir, '/'); /* Find final '/', if any */
1681
1682         if (p == NULL) {
1683                 if (!(*parent = talloc_strdup(mem_ctx, "."))) {
1684                         return False;
1685                 }
1686                 if (name) {
1687                         *name = dir;
1688                 }
1689                 return True;
1690         }
1691
1692         len = p-dir;
1693
1694         if (!(*parent = (char *)talloc_memdup(mem_ctx, dir, len+1))) {
1695                 return False;
1696         }
1697         (*parent)[len] = '\0';
1698
1699         if (name) {
1700                 *name = p+1;
1701         }
1702         return True;
1703 }
1704
1705 /*******************************************************************
1706  Determine if a pattern contains any Microsoft wildcard characters.
1707 *******************************************************************/
1708
1709 bool ms_has_wild(const char *s)
1710 {
1711         char c;
1712
1713         while ((c = *s++)) {
1714                 switch (c) {
1715                 case '*':
1716                 case '?':
1717                 case '<':
1718                 case '>':
1719                 case '"':
1720                         return True;
1721                 }
1722         }
1723         return False;
1724 }
1725
1726 bool ms_has_wild_w(const smb_ucs2_t *s)
1727 {
1728         smb_ucs2_t c;
1729         if (!s) return False;
1730         while ((c = *s++)) {
1731                 switch (c) {
1732                 case UCS2_CHAR('*'):
1733                 case UCS2_CHAR('?'):
1734                 case UCS2_CHAR('<'):
1735                 case UCS2_CHAR('>'):
1736                 case UCS2_CHAR('"'):
1737                         return True;
1738                 }
1739         }
1740         return False;
1741 }
1742
1743 /*******************************************************************
1744  A wrapper that handles case sensitivity and the special handling
1745  of the ".." name.
1746 *******************************************************************/
1747
1748 bool mask_match(const char *string, const char *pattern, bool is_case_sensitive)
1749 {
1750         if (ISDOTDOT(string))
1751                 string = ".";
1752         if (ISDOT(pattern))
1753                 return False;
1754
1755         return ms_fnmatch(pattern, string, Protocol <= PROTOCOL_LANMAN2, is_case_sensitive) == 0;
1756 }
1757
1758 /*******************************************************************
1759  A wrapper that handles case sensitivity and the special handling
1760  of the ".." name. Varient that is only called by old search code which requires
1761  pattern translation.
1762 *******************************************************************/
1763
1764 bool mask_match_search(const char *string, const char *pattern, bool is_case_sensitive)
1765 {
1766         if (ISDOTDOT(string))
1767                 string = ".";
1768         if (ISDOT(pattern))
1769                 return False;
1770
1771         return ms_fnmatch(pattern, string, True, is_case_sensitive) == 0;
1772 }
1773
1774 /*******************************************************************
1775  A wrapper that handles a list of patters and calls mask_match()
1776  on each.  Returns True if any of the patterns match.
1777 *******************************************************************/
1778
1779 bool mask_match_list(const char *string, char **list, int listLen, bool is_case_sensitive)
1780 {
1781        while (listLen-- > 0) {
1782                if (mask_match(string, *list++, is_case_sensitive))
1783                        return True;
1784        }
1785        return False;
1786 }
1787
1788 /*********************************************************
1789  Recursive routine that is called by unix_wild_match.
1790 *********************************************************/
1791
1792 static bool unix_do_match(const char *regexp, const char *str)
1793 {
1794         const char *p;
1795
1796         for( p = regexp; *p && *str; ) {
1797
1798                 switch(*p) {
1799                         case '?':
1800                                 str++;
1801                                 p++;
1802                                 break;
1803
1804                         case '*':
1805
1806                                 /*
1807                                  * Look for a character matching 
1808                                  * the one after the '*'.
1809                                  */
1810                                 p++;
1811                                 if(!*p)
1812                                         return true; /* Automatic match */
1813                                 while(*str) {
1814
1815                                         while(*str && (*p != *str))
1816                                                 str++;
1817
1818                                         /*
1819                                          * Patch from weidel@multichart.de. In the case of the regexp
1820                                          * '*XX*' we want to ensure there are at least 2 'X' characters
1821                                          * in the string after the '*' for a match to be made.
1822                                          */
1823
1824                                         {
1825                                                 int matchcount=0;
1826
1827                                                 /*
1828                                                  * Eat all the characters that match, but count how many there were.
1829                                                  */
1830
1831                                                 while(*str && (*p == *str)) {
1832                                                         str++;
1833                                                         matchcount++;
1834                                                 }
1835
1836                                                 /*
1837                                                  * Now check that if the regexp had n identical characters that
1838                                                  * matchcount had at least that many matches.
1839                                                  */
1840
1841                                                 while ( *(p+1) && (*(p+1) == *p)) {
1842                                                         p++;
1843                                                         matchcount--;
1844                                                 }
1845
1846                                                 if ( matchcount <= 0 )
1847                                                         return false;
1848                                         }
1849
1850                                         str--; /* We've eaten the match char after the '*' */
1851
1852                                         if(unix_do_match(p, str))
1853                                                 return true;
1854
1855                                         if(!*str)
1856                                                 return false;
1857                                         else
1858                                                 str++;
1859                                 }
1860                                 return false;
1861
1862                         default:
1863                                 if(*str != *p)
1864                                         return false;
1865                                 str++;
1866                                 p++;
1867                                 break;
1868                 }
1869         }
1870
1871         if(!*p && !*str)
1872                 return true;
1873
1874         if (!*p && str[0] == '.' && str[1] == 0)
1875                 return true;
1876
1877         if (!*str && *p == '?') {
1878                 while (*p == '?')
1879                         p++;
1880                 return(!*p);
1881         }
1882
1883         if(!*str && (*p == '*' && p[1] == '\0'))
1884                 return true;
1885
1886         return false;
1887 }
1888
1889 /*******************************************************************
1890  Simple case insensitive interface to a UNIX wildcard matcher.
1891  Returns True if match, False if not.
1892 *******************************************************************/
1893
1894 bool unix_wild_match(const char *pattern, const char *string)
1895 {
1896         TALLOC_CTX *ctx = talloc_stackframe();
1897         char *p2;
1898         char *s2;
1899         char *p;
1900         bool ret = false;
1901
1902         p2 = talloc_strdup(ctx,pattern);
1903         s2 = talloc_strdup(ctx,string);
1904         if (!p2 || !s2) {
1905                 TALLOC_FREE(ctx);
1906                 return false;
1907         }
1908         if (!strlower_m(p2)) {
1909                 TALLOC_FREE(ctx);
1910                 return false;
1911         }
1912         if (!strlower_m(s2)) {
1913                 TALLOC_FREE(ctx);
1914                 return false;
1915         }
1916
1917         /* Remove any *? and ** from the pattern as they are meaningless */
1918         for(p = p2; *p; p++) {
1919                 while( *p == '*' && (p[1] == '?' ||p[1] == '*')) {
1920                         memmove(&p[1], &p[2], strlen(&p[2])+1);
1921                 }
1922         }
1923
1924         if (strequal(p2,"*")) {
1925                 TALLOC_FREE(ctx);
1926                 return true;
1927         }
1928
1929         ret = unix_do_match(p2, s2);
1930         TALLOC_FREE(ctx);
1931         return ret;
1932 }
1933
1934 /**********************************************************************
1935   Converts a name to a fully qualified domain name.
1936   Returns true if lookup succeeded, false if not (then fqdn is set to name)
1937   Uses getaddrinfo() with AI_CANONNAME flag to obtain the official
1938   canonical name of the host. getaddrinfo() may use a variety of sources
1939   including /etc/hosts to obtain the domainname. It expects aliases in
1940   /etc/hosts to NOT be the FQDN. The FQDN should come first.
1941 ************************************************************************/
1942
1943 bool name_to_fqdn(fstring fqdn, const char *name)
1944 {
1945         char *full = NULL;
1946         struct addrinfo hints;
1947         struct addrinfo *result;
1948         int s;
1949
1950         /* Configure hints to obtain canonical name */
1951
1952         memset(&hints, 0, sizeof(struct addrinfo));
1953         hints.ai_family = AF_UNSPEC;    /* Allow IPv4 or IPv6 */
1954         hints.ai_socktype = SOCK_DGRAM; /* Datagram socket */
1955         hints.ai_flags = AI_CANONNAME;  /* Get host's FQDN */
1956         hints.ai_protocol = 0;          /* Any protocol */
1957
1958         s = getaddrinfo(name, NULL, &hints, &result);
1959         if (s != 0) {
1960                 DEBUG(1, ("getaddrinfo: %s\n", gai_strerror(s)));
1961                 DEBUG(10,("name_to_fqdn: lookup for %s failed.\n", name));
1962                 fstrcpy(fqdn, name);
1963                 return false;
1964         }
1965         full = result->ai_canonname;
1966
1967         /* Find out if the FQDN is returned as an alias
1968          * to cope with /etc/hosts files where the first
1969          * name is not the FQDN but the short name.
1970          * getaddrinfo provides no easy way of handling aliases
1971          * in /etc/hosts. Users should make sure the FQDN
1972          * comes first in /etc/hosts. */
1973         if (full && (! strchr_m(full, '.'))) {
1974                 DEBUG(1, ("WARNING: your /etc/hosts file may be broken!\n"));
1975                 DEBUGADD(1, ("    Full qualified domain names (FQDNs) should not be specified\n"));
1976                 DEBUGADD(1, ("    as an alias in /etc/hosts. FQDN should be the first name\n"));
1977                 DEBUGADD(1, ("    prior to any aliases.\n"));
1978         }
1979         if (full && (strcasecmp_m(full, "localhost.localdomain") == 0)) {
1980                 DEBUG(1, ("WARNING: your /etc/hosts file may be broken!\n"));
1981                 DEBUGADD(1, ("    Specifying the machine hostname for address 127.0.0.1 may lead\n"));
1982                 DEBUGADD(1, ("    to Kerberos authentication problems as localhost.localdomain\n"));
1983                 DEBUGADD(1, ("    may end up being used instead of the real machine FQDN.\n"));
1984         }
1985
1986         DEBUG(10,("name_to_fqdn: lookup for %s -> %s.\n", name, full));
1987         fstrcpy(fqdn, full);
1988         freeaddrinfo(result);           /* No longer needed */
1989         return true;
1990 }
1991
1992 uint32_t map_share_mode_to_deny_mode(uint32_t share_access, uint32_t private_options)
1993 {
1994         switch (share_access & ~FILE_SHARE_DELETE) {
1995                 case FILE_SHARE_NONE:
1996                         return DENY_ALL;
1997                 case FILE_SHARE_READ:
1998                         return DENY_WRITE;
1999                 case FILE_SHARE_WRITE:
2000                         return DENY_READ;
2001                 case FILE_SHARE_READ|FILE_SHARE_WRITE:
2002                         return DENY_NONE;
2003         }
2004         if (private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS) {
2005                 return DENY_DOS;
2006         } else if (private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_FCB) {
2007                 return DENY_FCB;
2008         }
2009
2010         return (uint32_t)-1;
2011 }
2012
2013 struct server_id interpret_pid(const char *pid_string)
2014 {
2015         return server_id_from_string(get_my_vnn(), pid_string);
2016 }
2017
2018 /****************************************************************
2019  Check if an offset into a buffer is safe.
2020  If this returns True it's safe to indirect into the byte at
2021  pointer ptr+off.
2022 ****************************************************************/
2023
2024 bool is_offset_safe(const char *buf_base, size_t buf_len, char *ptr, size_t off)
2025 {
2026         const char *end_base = buf_base + buf_len;
2027         char *end_ptr = ptr + off;
2028
2029         if (!buf_base || !ptr) {
2030                 return False;
2031         }
2032
2033         if (end_base < buf_base || end_ptr < ptr) {
2034                 return False; /* wrap. */
2035         }
2036
2037         if (end_ptr < end_base) {
2038                 return True;
2039         }
2040         return False;
2041 }
2042
2043 /****************************************************************
2044  Return a safe pointer into a buffer, or NULL.
2045 ****************************************************************/
2046
2047 char *get_safe_ptr(const char *buf_base, size_t buf_len, char *ptr, size_t off)
2048 {
2049         return is_offset_safe(buf_base, buf_len, ptr, off) ?
2050                         ptr + off : NULL;
2051 }
2052
2053 /****************************************************************
2054  Return a safe pointer into a string within a buffer, or NULL.
2055 ****************************************************************/
2056
2057 char *get_safe_str_ptr(const char *buf_base, size_t buf_len, char *ptr, size_t off)
2058 {
2059         if (!is_offset_safe(buf_base, buf_len, ptr, off)) {
2060                 return NULL;
2061         }
2062         /* Check if a valid string exists at this offset. */
2063         if (skip_string(buf_base,buf_len, ptr + off) == NULL) {
2064                 return NULL;
2065         }
2066         return ptr + off;
2067 }
2068
2069 /****************************************************************
2070  Return an SVAL at a pointer, or failval if beyond the end.
2071 ****************************************************************/
2072
2073 int get_safe_SVAL(const char *buf_base, size_t buf_len, char *ptr, size_t off, int failval)
2074 {
2075         /*
2076          * Note we use off+1 here, not off+2 as SVAL accesses ptr[0] and ptr[1],
2077          * NOT ptr[2].
2078          */
2079         if (!is_offset_safe(buf_base, buf_len, ptr, off+1)) {
2080                 return failval;
2081         }
2082         return SVAL(ptr,off);
2083 }
2084
2085 /****************************************************************
2086  Return an IVAL at a pointer, or failval if beyond the end.
2087 ****************************************************************/
2088
2089 int get_safe_IVAL(const char *buf_base, size_t buf_len, char *ptr, size_t off, int failval)
2090 {
2091         /*
2092          * Note we use off+3 here, not off+4 as IVAL accesses 
2093          * ptr[0] ptr[1] ptr[2] ptr[3] NOT ptr[4].
2094          */
2095         if (!is_offset_safe(buf_base, buf_len, ptr, off+3)) {
2096                 return failval;
2097         }
2098         return IVAL(ptr,off);
2099 }
2100
2101 /****************************************************************
2102  Split DOM\user into DOM and user. Do not mix with winbind variants of that
2103  call (they take care of winbind separator and other winbind specific settings).
2104 ****************************************************************/
2105
2106 bool split_domain_user(TALLOC_CTX *mem_ctx,
2107                        const char *full_name,
2108                        char **domain,
2109                        char **user)
2110 {
2111         const char *p = NULL;
2112
2113         p = strchr_m(full_name, '\\');
2114
2115         if (p != NULL) {
2116                 *domain = talloc_strndup(mem_ctx, full_name,
2117                                          PTR_DIFF(p, full_name));
2118                 if (*domain == NULL) {
2119                         return false;
2120                 }
2121                 *user = talloc_strdup(mem_ctx, p+1);
2122                 if (*user == NULL) {
2123                         TALLOC_FREE(*domain);
2124                         return false;
2125                 }
2126         } else {
2127                 *domain = NULL;
2128                 *user = talloc_strdup(mem_ctx, full_name);
2129                 if (*user == NULL) {
2130                         return false;
2131                 }
2132         }
2133
2134         return true;
2135 }
2136
2137 /****************************************************************
2138  strip off leading '\\' from a hostname
2139 ****************************************************************/
2140
2141 const char *strip_hostname(const char *s)
2142 {
2143         if (!s) {
2144                 return NULL;
2145         }
2146
2147         if (strlen_m(s) < 3) {
2148                 return s;
2149         }
2150
2151         if (s[0] == '\\') s++;
2152         if (s[0] == '\\') s++;
2153
2154         return s;
2155 }
2156
2157 bool any_nt_status_not_ok(NTSTATUS err1, NTSTATUS err2, NTSTATUS *result)
2158 {
2159         if (!NT_STATUS_IS_OK(err1)) {
2160                 *result = err1;
2161                 return true;
2162         }
2163         if (!NT_STATUS_IS_OK(err2)) {
2164                 *result = err2;
2165                 return true;
2166         }
2167         return false;
2168 }
2169
2170 int timeval_to_msec(struct timeval t)
2171 {
2172         return t.tv_sec * 1000 + (t.tv_usec+999) / 1000;
2173 }
2174
2175 /*******************************************************************
2176  Check a given DOS pathname is valid for a share.
2177 ********************************************************************/
2178
2179 char *valid_share_pathname(TALLOC_CTX *ctx, const char *dos_pathname)
2180 {
2181         char *ptr = NULL;
2182
2183         if (!dos_pathname) {
2184                 return NULL;
2185         }
2186
2187         ptr = talloc_strdup(ctx, dos_pathname);
2188         if (!ptr) {
2189                 return NULL;
2190         }
2191         /* Convert any '\' paths to '/' */
2192         unix_format(ptr);
2193         ptr = unix_clean_name(ctx, ptr);
2194         if (!ptr) {
2195                 return NULL;
2196         }
2197
2198         /* NT is braindead - it wants a C: prefix to a pathname ! So strip it. */
2199         if (strlen(ptr) > 2 && ptr[1] == ':' && ptr[0] != '/')
2200                 ptr += 2;
2201
2202         /* Only absolute paths allowed. */
2203         if (*ptr != '/')
2204                 return NULL;
2205
2206         return ptr;
2207 }
2208
2209 /*******************************************************************
2210  Return True if the filename is one of the special executable types.
2211 ********************************************************************/
2212
2213 bool is_executable(const char *fname)
2214 {
2215         if ((fname = strrchr_m(fname,'.'))) {
2216                 if (strequal(fname,".com") ||
2217                     strequal(fname,".dll") ||
2218                     strequal(fname,".exe") ||
2219                     strequal(fname,".sym")) {
2220                         return True;
2221                 }
2222         }
2223         return False;
2224 }
2225
2226 /****************************************************************************
2227  Open a file with a share mode - old openX method - map into NTCreate.
2228 ****************************************************************************/
2229
2230 bool map_open_params_to_ntcreate(const char *smb_base_fname,
2231                                  int deny_mode, int open_func,
2232                                  uint32_t *paccess_mask,
2233                                  uint32_t *pshare_mode,
2234                                  uint32_t *pcreate_disposition,
2235                                  uint32_t *pcreate_options,
2236                                  uint32_t *pprivate_flags)
2237 {
2238         uint32_t access_mask;
2239         uint32_t share_mode;
2240         uint32_t create_disposition;
2241         uint32_t create_options = FILE_NON_DIRECTORY_FILE;
2242         uint32_t private_flags = 0;
2243
2244         DEBUG(10,("map_open_params_to_ntcreate: fname = %s, deny_mode = 0x%x, "
2245                   "open_func = 0x%x\n",
2246                   smb_base_fname, (unsigned int)deny_mode,
2247                   (unsigned int)open_func ));
2248
2249         /* Create the NT compatible access_mask. */
2250         switch (GET_OPENX_MODE(deny_mode)) {
2251                 case DOS_OPEN_EXEC: /* Implies read-only - used to be FILE_READ_DATA */
2252                 case DOS_OPEN_RDONLY:
2253                         access_mask = FILE_GENERIC_READ;
2254                         break;
2255                 case DOS_OPEN_WRONLY:
2256                         access_mask = FILE_GENERIC_WRITE;
2257                         break;
2258                 case DOS_OPEN_RDWR:
2259                 case DOS_OPEN_FCB:
2260                         access_mask = FILE_GENERIC_READ|FILE_GENERIC_WRITE;
2261                         break;
2262                 default:
2263                         DEBUG(10,("map_open_params_to_ntcreate: bad open mode = 0x%x\n",
2264                                   (unsigned int)GET_OPENX_MODE(deny_mode)));
2265                         return False;
2266         }
2267
2268         /* Create the NT compatible create_disposition. */
2269         switch (open_func) {
2270                 case OPENX_FILE_EXISTS_FAIL|OPENX_FILE_CREATE_IF_NOT_EXIST:
2271                         create_disposition = FILE_CREATE;
2272                         break;
2273
2274                 case OPENX_FILE_EXISTS_OPEN:
2275                         create_disposition = FILE_OPEN;
2276                         break;
2277
2278                 case OPENX_FILE_EXISTS_OPEN|OPENX_FILE_CREATE_IF_NOT_EXIST:
2279                         create_disposition = FILE_OPEN_IF;
2280                         break;
2281
2282                 case OPENX_FILE_EXISTS_TRUNCATE:
2283                         create_disposition = FILE_OVERWRITE;
2284                         break;
2285
2286                 case OPENX_FILE_EXISTS_TRUNCATE|OPENX_FILE_CREATE_IF_NOT_EXIST:
2287                         create_disposition = FILE_OVERWRITE_IF;
2288                         break;
2289
2290                 default:
2291                         /* From samba4 - to be confirmed. */
2292                         if (GET_OPENX_MODE(deny_mode) == DOS_OPEN_EXEC) {
2293                                 create_disposition = FILE_CREATE;
2294                                 break;
2295                         }
2296                         DEBUG(10,("map_open_params_to_ntcreate: bad "
2297                                   "open_func 0x%x\n", (unsigned int)open_func));
2298                         return False;
2299         }
2300
2301         /* Create the NT compatible share modes. */
2302         switch (GET_DENY_MODE(deny_mode)) {
2303                 case DENY_ALL:
2304                         share_mode = FILE_SHARE_NONE;
2305                         break;
2306
2307                 case DENY_WRITE:
2308                         share_mode = FILE_SHARE_READ;
2309                         break;
2310
2311                 case DENY_READ:
2312                         share_mode = FILE_SHARE_WRITE;
2313                         break;
2314
2315                 case DENY_NONE:
2316                         share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
2317                         break;
2318
2319                 case DENY_DOS:
2320                         private_flags |= NTCREATEX_OPTIONS_PRIVATE_DENY_DOS;
2321                         if (is_executable(smb_base_fname)) {
2322                                 share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
2323                         } else {
2324                                 if (GET_OPENX_MODE(deny_mode) == DOS_OPEN_RDONLY) {
2325                                         share_mode = FILE_SHARE_READ;
2326                                 } else {
2327                                         share_mode = FILE_SHARE_NONE;
2328                                 }
2329                         }
2330                         break;
2331
2332                 case DENY_FCB:
2333                         private_flags |= NTCREATEX_OPTIONS_PRIVATE_DENY_FCB;
2334                         share_mode = FILE_SHARE_NONE;
2335                         break;
2336
2337                 default:
2338                         DEBUG(10,("map_open_params_to_ntcreate: bad deny_mode 0x%x\n",
2339                                 (unsigned int)GET_DENY_MODE(deny_mode) ));
2340                         return False;
2341         }
2342
2343         DEBUG(10,("map_open_params_to_ntcreate: file %s, access_mask = 0x%x, "
2344                   "share_mode = 0x%x, create_disposition = 0x%x, "
2345                   "create_options = 0x%x private_flags = 0x%x\n",
2346                   smb_base_fname,
2347                   (unsigned int)access_mask,
2348                   (unsigned int)share_mode,
2349                   (unsigned int)create_disposition,
2350                   (unsigned int)create_options,
2351                   (unsigned int)private_flags));
2352
2353         if (paccess_mask) {
2354                 *paccess_mask = access_mask;
2355         }
2356         if (pshare_mode) {
2357                 *pshare_mode = share_mode;
2358         }
2359         if (pcreate_disposition) {
2360                 *pcreate_disposition = create_disposition;
2361         }
2362         if (pcreate_options) {
2363                 *pcreate_options = create_options;
2364         }
2365         if (pprivate_flags) {
2366                 *pprivate_flags = private_flags;
2367         }
2368
2369         return True;
2370
2371 }
2372
2373 /*************************************************************************
2374  Return a talloced copy of a struct security_unix_token. NULL on fail.
2375 *************************************************************************/
2376
2377 struct security_unix_token *copy_unix_token(TALLOC_CTX *ctx, const struct security_unix_token *tok)
2378 {
2379         struct security_unix_token *cpy;
2380
2381         cpy = talloc(ctx, struct security_unix_token);
2382         if (!cpy) {
2383                 return NULL;
2384         }
2385
2386         cpy->uid = tok->uid;
2387         cpy->gid = tok->gid;
2388         cpy->ngroups = tok->ngroups;
2389         if (tok->ngroups) {
2390                 /* Make this a talloc child of cpy. */
2391                 cpy->groups = (gid_t *)talloc_memdup(
2392                         cpy, tok->groups, tok->ngroups * sizeof(gid_t));
2393                 if (!cpy->groups) {
2394                         TALLOC_FREE(cpy);
2395                         return NULL;
2396                 }
2397         } else {
2398                 cpy->groups = NULL;
2399         }
2400         return cpy;
2401 }
2402
2403 /****************************************************************************
2404  Check that a file matches a particular file type.
2405 ****************************************************************************/
2406
2407 bool dir_check_ftype(uint32_t mode, uint32_t dirtype)
2408 {
2409         uint32_t mask;
2410
2411         /* Check the "may have" search bits. */
2412         if (((mode & ~dirtype) &
2413                         (FILE_ATTRIBUTE_HIDDEN |
2414                          FILE_ATTRIBUTE_SYSTEM |
2415                          FILE_ATTRIBUTE_DIRECTORY)) != 0) {
2416                 return false;
2417         }
2418
2419         /* Check the "must have" bits,
2420            which are the may have bits shifted eight */
2421         /* If must have bit is set, the file/dir can
2422            not be returned in search unless the matching
2423            file attribute is set */
2424         mask = ((dirtype >> 8) & (FILE_ATTRIBUTE_DIRECTORY|
2425                                     FILE_ATTRIBUTE_ARCHIVE|
2426                                    FILE_ATTRIBUTE_READONLY|
2427                                      FILE_ATTRIBUTE_HIDDEN|
2428                                      FILE_ATTRIBUTE_SYSTEM)); /* & 0x37 */
2429         if(mask) {
2430                 if((mask & (mode & (FILE_ATTRIBUTE_DIRECTORY|
2431                                       FILE_ATTRIBUTE_ARCHIVE|
2432                                      FILE_ATTRIBUTE_READONLY|
2433                                        FILE_ATTRIBUTE_HIDDEN|
2434                                         FILE_ATTRIBUTE_SYSTEM))) == mask) {
2435                         /* check if matching attribute present */
2436                         return true;
2437                 } else {
2438                         return false;
2439                 }
2440         }
2441
2442         return true;
2443 }