?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ctdb-scripts: Organize global variables in nfs_ganesha_callout
[Samba.git] / source3 / lib / util.c
blobf64f6b56db15a7a0f979ac4303e8aa589d9c4f73
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, 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 offset=%.0f count=%.0f type=%d\n",
1159 fd,(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,F_GETLK,&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 #undef DBGC_CLASS
1188 #define DBGC_CLASS DBGC_ALL
1189
1190 /*******************************************************************
1191 Is the name specified one of my netbios names.
1192 Returns true if it is equal, false otherwise.
1193 ********************************************************************/
1194
1195 bool is_myname(const char *s)
1196 {
1197 int n;
1198 bool ret = False;
1199
1200 for (n=0; my_netbios_names(n); n++) {
1201 const char *nbt_name = my_netbios_names(n);
1202
1203 if (strncasecmp_m(nbt_name, s, MAX_NETBIOSNAME_LEN-1) == 0) {
1204 ret=True;
1205 break;
1206 }
1207 }
1208 DEBUG(8, ("is_myname(\"%s\") returns %d\n", s, ret));
1209 return(ret);
1210 }
1211
1212 /*******************************************************************
1213 we distinguish between 2K and XP by the "Native Lan Manager" string
1214 WinXP => "Windows 2002 5.1"
1215 WinXP 64bit => "Windows XP 5.2"
1216 Win2k => "Windows 2000 5.0"
1217 NT4 => "Windows NT 4.0"
1218 Win9x => "Windows 4.0"
1219 Windows 2003 doesn't set the native lan manager string but
1220 they do set the domain to "Windows 2003 5.2" (probably a bug).
1221 ********************************************************************/
1222
1223 void ra_lanman_string( const char *native_lanman )
1224 {
1225 if ( strcmp( native_lanman, "Windows 2002 5.1" ) == 0 )
1226 set_remote_arch( RA_WINXP );
1227 else if ( strcmp( native_lanman, "Windows XP 5.2" ) == 0 )
1228 set_remote_arch( RA_WINXP64 );
1229 else if ( strcmp( native_lanman, "Windows Server 2003 5.2" ) == 0 )
1230 set_remote_arch( RA_WIN2K3 );
1231 }
1232
1233 static const char *remote_arch_strings[] = {
1234 [RA_UNKNOWN] = "UNKNOWN",
1235 [RA_WFWG] = "WfWg",
1236 [RA_OS2] = "OS2",
1237 [RA_WIN95] = "Win95",
1238 [RA_WINNT] = "WinNT",
1239 [RA_WIN2K] = "Win2K",
1240 [RA_WINXP] = "WinXP",
1241 [RA_WIN2K3] = "Win2K3",
1242 [RA_VISTA] = "Vista",
1243 [RA_SAMBA] = "Samba",
1244 [RA_CIFSFS] = "CIFSFS",
1245 [RA_WINXP64] = "WinXP64",
1246 [RA_OSX] = "OSX",
1247 };
1248
1249 const char *get_remote_arch_str(void)
1250 {
1251 if (ra_type >= ARRAY_SIZE(remote_arch_strings)) {
1252 /*
1253 * set_remote_arch() already checks this so ra_type
1254 * should be in the allowed range, but anyway, let's
1255 * do another bound check here.
1256 */
1257 DBG_ERR("Remote arch info out of sync [%d] missing\n", ra_type);
1258 ra_type = RA_UNKNOWN;
1259 }
1260 return remote_arch_strings[ra_type];
1261 }
1262
1263 enum remote_arch_types get_remote_arch_from_str(const char *remote_arch_string)
1264 {
1265 int i;
1266
1267 for (i = 0; i < ARRAY_SIZE(remote_arch_strings); i++) {
1268 if (strcmp(remote_arch_string, remote_arch_strings[i]) == 0) {
1269 return i;
1270 }
1271 }
1272 return RA_UNKNOWN;
1273 }
1274
1275 /*******************************************************************
1276 Set the horrid remote_arch string based on an enum.
1277 ********************************************************************/
1278
1279 void set_remote_arch(enum remote_arch_types type)
1280 {
1281 if (ra_type >= ARRAY_SIZE(remote_arch_strings)) {
1282 /*
1283 * This protects against someone adding values to enum
1284 * remote_arch_types without updating
1285 * remote_arch_strings array.
1286 */
1287 DBG_ERR("Remote arch info out of sync [%d] missing\n", ra_type);
1288 ra_type = RA_UNKNOWN;
1289 return;
1290 }
1291
1292 ra_type = type;
1293 DEBUG(10,("set_remote_arch: Client arch is \'%s\'\n",
1294 get_remote_arch_str()));
1295 }
1296
1297 /*******************************************************************
1298 Get the remote_arch type.
1299 ********************************************************************/
1300
1301 enum remote_arch_types get_remote_arch(void)
1302 {
1303 return ra_type;
1304 }
1305
1306 #define RA_CACHE_TTL 7*24*3600
1307
1308 static bool remote_arch_cache_key(const struct GUID *client_guid,
1309 fstring key)
1310 {
1311 struct GUID_txt_buf guid_buf;
1312 const char *guid_string = NULL;
1313
1314 guid_string = GUID_buf_string(client_guid, &guid_buf);
1315 if (guid_string == NULL) {
1316 return false;
1317 }
1318
1319 fstr_sprintf(key, "RA/%s", guid_string);
1320 return true;
1321 }
1322
1323 struct ra_parser_state {
1324 bool found;
1325 enum remote_arch_types ra;
1326 };
1327
1328 static void ra_parser(time_t timeout, DATA_BLOB blob, void *priv_data)
1329 {
1330 struct ra_parser_state *state = (struct ra_parser_state *)priv_data;
1331 const char *ra_str = NULL;
1332
1333 if (timeout <= time(NULL)) {
1334 return;
1335 }
1336
1337 if ((blob.length == 0) || (blob.data[blob.length-1] != '\0')) {
1338 DBG_ERR("Remote arch cache key not a string\n");
1339 return;
1340 }
1341
1342 ra_str = (const char *)blob.data;
1343 DBG_INFO("Got remote arch [%s] from cache\n", ra_str);
1344
1345 state->ra = get_remote_arch_from_str(ra_str);
1346 state->found = true;
1347 return;
1348 }
1349
1350 static bool remote_arch_cache_get(const struct GUID *client_guid)
1351 {
1352 bool ok;
1353 fstring ra_key;
1354 struct ra_parser_state state = (struct ra_parser_state) {
1355 .found = false,
1356 .ra = RA_UNKNOWN,
1357 };
1358
1359 ok = remote_arch_cache_key(client_guid, ra_key);
1360 if (!ok) {
1361 return false;
1362 }
1363
1364 ok = gencache_parse(ra_key, ra_parser, &state);
1365 if (!ok || !state.found) {
1366 return true;
1367 }
1368
1369 if (state.ra == RA_UNKNOWN) {
1370 return true;
1371 }
1372
1373 set_remote_arch(state.ra);
1374 return true;
1375 }
1376
1377 static bool remote_arch_cache_set(const struct GUID *client_guid)
1378 {
1379 bool ok;
1380 fstring ra_key;
1381 const char *ra_str = NULL;
1382
1383 if (get_remote_arch() == RA_UNKNOWN) {
1384 return true;
1385 }
1386
1387 ok = remote_arch_cache_key(client_guid, ra_key);
1388 if (!ok) {
1389 return false;
1390 }
1391
1392 ra_str = get_remote_arch_str();
1393 if (ra_str == NULL) {
1394 return false;
1395 }
1396
1397 ok = gencache_set(ra_key, ra_str, time(NULL) + RA_CACHE_TTL);
1398 if (!ok) {
1399 return false;
1400 }
1401
1402 return true;
1403 }
1404
1405 bool remote_arch_cache_update(const struct GUID *client_guid)
1406 {
1407 bool ok;
1408
1409 if (get_remote_arch() == RA_UNKNOWN) {
1410
1411 become_root();
1412 ok = remote_arch_cache_get(client_guid);
1413 unbecome_root();
1414
1415 return ok;
1416 }
1417
1418 become_root();
1419 ok = remote_arch_cache_set(client_guid);
1420 unbecome_root();
1421
1422 return ok;
1423 }
1424
1425 bool remote_arch_cache_delete(const struct GUID *client_guid)
1426 {
1427 bool ok;
1428 fstring ra_key;
1429
1430 ok = remote_arch_cache_key(client_guid, ra_key);
1431 if (!ok) {
1432 return false;
1433 }
1434
1435 become_root();
1436 ok = gencache_del(ra_key);
1437 unbecome_root();
1438
1439 if (!ok) {
1440 return false;
1441 }
1442
1443 return true;
1444 }
1445
1446 const char *tab_depth(int level, int depth)
1447 {
1448 if( CHECK_DEBUGLVL(level) ) {
1449 dbgtext("%*s", depth*4, "");
1450 }
1451 return "";
1452 }
1453
1454 /*****************************************************************************
1455 Provide a checksum on a string
1456
1457 Input: s - the null-terminated character string for which the checksum
1458 will be calculated.
1459
1460 Output: The checksum value calculated for s.
1461 *****************************************************************************/
1462
1463 int str_checksum(const char *s)
1464 {
1465 TDB_DATA key;
1466 if (s == NULL)
1467 return 0;
1468
1469 key = (TDB_DATA) { .dptr = discard_const_p(uint8_t, s),
1470 .dsize = strlen(s) };
1471
1472 return tdb_jenkins_hash(&key);
1473 }
1474
1475 /*****************************************************************
1476 Zero a memory area then free it. Used to catch bugs faster.
1477 *****************************************************************/
1478
1479 void zero_free(void *p, size_t size)
1480 {
1481 memset(p, 0, size);
1482 SAFE_FREE(p);
1483 }
1484
1485 /*****************************************************************
1486 Set our open file limit to a requested max and return the limit.
1487 *****************************************************************/
1488
1489 int set_maxfiles(int requested_max)
1490 {
1491 #if (defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE))
1492 struct rlimit rlp;
1493 int saved_current_limit;
1494
1495 if(getrlimit(RLIMIT_NOFILE, &rlp)) {
1496 DEBUG(0,("set_maxfiles: getrlimit (1) for RLIMIT_NOFILE failed with error %s\n",
1497 strerror(errno) ));
1498 /* just guess... */
1499 return requested_max;
1500 }
1501
1502 /*
1503 * Set the fd limit to be real_max_open_files + MAX_OPEN_FUDGEFACTOR to
1504 * account for the extra fd we need
1505 * as well as the log files and standard
1506 * handles etc. Save the limit we want to set in case
1507 * we are running on an OS that doesn't support this limit (AIX)
1508 * which always returns RLIM_INFINITY for rlp.rlim_max.
1509 */
1510
1511 /* Try raising the hard (max) limit to the requested amount. */
1512
1513 #if defined(RLIM_INFINITY)
1514 if (rlp.rlim_max != RLIM_INFINITY) {
1515 int orig_max = rlp.rlim_max;
1516
1517 if ( rlp.rlim_max < requested_max )
1518 rlp.rlim_max = requested_max;
1519
1520 /* This failing is not an error - many systems (Linux) don't
1521 support our default request of 10,000 open files. JRA. */
1522
1523 if(setrlimit(RLIMIT_NOFILE, &rlp)) {
1524 DEBUG(3,("set_maxfiles: setrlimit for RLIMIT_NOFILE for %d max files failed with error %s\n",
1525 (int)rlp.rlim_max, strerror(errno) ));
1526
1527 /* Set failed - restore original value from get. */
1528 rlp.rlim_max = orig_max;
1529 }
1530 }
1531 #endif
1532
1533 /* Now try setting the soft (current) limit. */
1534
1535 saved_current_limit = rlp.rlim_cur = MIN(requested_max,rlp.rlim_max);
1536
1537 if(setrlimit(RLIMIT_NOFILE, &rlp)) {
1538 DEBUG(0,("set_maxfiles: setrlimit for RLIMIT_NOFILE for %d files failed with error %s\n",
1539 (int)rlp.rlim_cur, strerror(errno) ));
1540 /* just guess... */
1541 return saved_current_limit;
1542 }
1543
1544 if(getrlimit(RLIMIT_NOFILE, &rlp)) {
1545 DEBUG(0,("set_maxfiles: getrlimit (2) for RLIMIT_NOFILE failed with error %s\n",
1546 strerror(errno) ));
1547 /* just guess... */
1548 return saved_current_limit;
1549 }
1550
1551 #if defined(RLIM_INFINITY)
1552 if(rlp.rlim_cur == RLIM_INFINITY)
1553 return saved_current_limit;
1554 #endif
1555
1556 if((int)rlp.rlim_cur > saved_current_limit)
1557 return saved_current_limit;
1558
1559 return rlp.rlim_cur;
1560 #else /* !defined(HAVE_GETRLIMIT) || !defined(RLIMIT_NOFILE) */
1561 /*
1562 * No way to know - just guess...
1563 */
1564 return requested_max;
1565 #endif
1566 }
1567
1568 /*****************************************************************
1569 malloc that aborts with smb_panic on fail or zero size.
1570 *****************************************************************/
1571
1572 void *smb_xmalloc_array(size_t size, unsigned int count)
1573 {
1574 void *p;
1575 if (size == 0) {
1576 smb_panic("smb_xmalloc_array: called with zero size");
1577 }
1578 if (count >= MAX_ALLOC_SIZE/size) {
1579 smb_panic("smb_xmalloc_array: alloc size too large");
1580 }
1581 if ((p = SMB_MALLOC(size*count)) == NULL) {
1582 DEBUG(0, ("smb_xmalloc_array failed to allocate %lu * %lu bytes\n",
1583 (unsigned long)size, (unsigned long)count));
1584 smb_panic("smb_xmalloc_array: malloc failed");
1585 }
1586 return p;
1587 }
1588
1589 /*
1590 vasprintf that aborts on malloc fail
1591 */
1592
1593 int smb_xvasprintf(char **ptr, const char *format, va_list ap)
1594 {
1595 int n;
1596 va_list ap2;
1597
1598 va_copy(ap2, ap);
1599
1600 n = vasprintf(ptr, format, ap2);
1601 va_end(ap2);
1602 if (n == -1 || ! *ptr) {
1603 smb_panic("smb_xvasprintf: out of memory");
1604 }
1605 return n;
1606 }
1607
1608 /*****************************************************************
1609 Get local hostname and cache result.
1610 *****************************************************************/
1611
1612 char *myhostname(void)
1613 {
1614 static char *ret;
1615 if (ret == NULL) {
1616 ret = get_myname(NULL);
1617 }
1618 return ret;
1619 }
1620
1621 /*****************************************************************
1622 Get local hostname and cache result.
1623 *****************************************************************/
1624
1625 char *myhostname_upper(void)
1626 {
1627 static char *ret;
1628 if (ret == NULL) {
1629 char *name = get_myname(NULL);
1630 if (name == NULL) {
1631 return NULL;
1632 }
1633 ret = strupper_talloc(NULL, name);
1634 talloc_free(name);
1635 }
1636 return ret;
1637 }
1638
1639 /*******************************************************************
1640 Given a filename - get its directory name
1641 ********************************************************************/
1642
1643 bool parent_dirname(TALLOC_CTX *mem_ctx, const char *dir, char **parent,
1644 const char **name)
1645 {
1646 char *p;
1647 ptrdiff_t len;
1648
1649 p = strrchr_m(dir, '/'); /* Find final '/', if any */
1650
1651 if (p == NULL) {
1652 if (!(*parent = talloc_strdup(mem_ctx, "."))) {
1653 return False;
1654 }
1655 if (name) {
1656 *name = dir;
1657 }
1658 return True;
1659 }
1660
1661 len = p-dir;
1662
1663 if (!(*parent = (char *)talloc_memdup(mem_ctx, dir, len+1))) {
1664 return False;
1665 }
1666 (*parent)[len] = '\0';
1667
1668 if (name) {
1669 *name = p+1;
1670 }
1671 return True;
1672 }
1673
1674 /*******************************************************************
1675 Determine if a pattern contains any Microsoft wildcard characters.
1676 *******************************************************************/
1677
1678 bool ms_has_wild(const char *s)
1679 {
1680 char c;
1681
1682 while ((c = *s++)) {
1683 switch (c) {
1684 case '*':
1685 case '?':
1686 case '<':
1687 case '>':
1688 case '"':
1689 return True;
1690 }
1691 }
1692 return False;
1693 }
1694
1695 bool ms_has_wild_w(const smb_ucs2_t *s)
1696 {
1697 smb_ucs2_t c;
1698 if (!s) return False;
1699 while ((c = *s++)) {
1700 switch (c) {
1701 case UCS2_CHAR('*'):
1702 case UCS2_CHAR('?'):
1703 case UCS2_CHAR('<'):
1704 case UCS2_CHAR('>'):
1705 case UCS2_CHAR('"'):
1706 return True;
1707 }
1708 }
1709 return False;
1710 }
1711
1712 /*******************************************************************
1713 A wrapper that handles case sensitivity and the special handling
1714 of the ".." name.
1715 *******************************************************************/
1716
1717 bool mask_match(const char *string, const char *pattern, bool is_case_sensitive)
1718 {
1719 if (ISDOTDOT(string))
1720 string = ".";
1721 if (ISDOT(pattern))
1722 return False;
1723
1724 return ms_fnmatch(pattern, string, Protocol <= PROTOCOL_LANMAN2, is_case_sensitive) == 0;
1725 }
1726
1727 /*******************************************************************
1728 A wrapper that handles case sensitivity and the special handling
1729 of the ".." name. Varient that is only called by old search code which requires
1730 pattern translation.
1731 *******************************************************************/
1732
1733 bool mask_match_search(const char *string, const char *pattern, bool is_case_sensitive)
1734 {
1735 if (ISDOTDOT(string))
1736 string = ".";
1737 if (ISDOT(pattern))
1738 return False;
1739
1740 return ms_fnmatch(pattern, string, True, is_case_sensitive) == 0;
1741 }
1742
1743 /*******************************************************************
1744 A wrapper that handles a list of patters and calls mask_match()
1745 on each. Returns True if any of the patterns match.
1746 *******************************************************************/
1747
1748 bool mask_match_list(const char *string, char **list, int listLen, bool is_case_sensitive)
1749 {
1750 while (listLen-- > 0) {
1751 if (mask_match(string, *list++, is_case_sensitive))
1752 return True;
1753 }
1754 return False;
1755 }
1756
1757 /*********************************************************
1758 Recursive routine that is called by unix_wild_match.
1759 *********************************************************/
1760
1761 static bool unix_do_match(const char *regexp, const char *str)
1762 {
1763 const char *p;
1764
1765 for( p = regexp; *p && *str; ) {
1766
1767 switch(*p) {
1768 case '?':
1769 str++;
1770 p++;
1771 break;
1772
1773 case '*':
1774
1775 /*
1776 * Look for a character matching
1777 * the one after the '*'.
1778 */
1779 p++;
1780 if(!*p)
1781 return true; /* Automatic match */
1782 while(*str) {
1783
1784 while(*str && (*p != *str))
1785 str++;
1786
1787 /*
1788 * Patch from weidel@multichart.de. In the case of the regexp
1789 * '*XX*' we want to ensure there are at least 2 'X' characters
1790 * in the string after the '*' for a match to be made.
1791 */
1792
1793 {
1794 int matchcount=0;
1795
1796 /*
1797 * Eat all the characters that match, but count how many there were.
1798 */
1799
1800 while(*str && (*p == *str)) {
1801 str++;
1802 matchcount++;
1803 }
1804
1805 /*
1806 * Now check that if the regexp had n identical characters that
1807 * matchcount had at least that many matches.
1808 */
1809
1810 while ( *(p+1) && (*(p+1) == *p)) {
1811 p++;
1812 matchcount--;
1813 }
1814
1815 if ( matchcount <= 0 )
1816 return false;
1817 }
1818
1819 str--; /* We've eaten the match char after the '*' */
1820
1821 if(unix_do_match(p, str))
1822 return true;
1823
1824 if(!*str)
1825 return false;
1826 else
1827 str++;
1828 }
1829 return false;
1830
1831 default:
1832 if(*str != *p)
1833 return false;
1834 str++;
1835 p++;
1836 break;
1837 }
1838 }
1839
1840 if(!*p && !*str)
1841 return true;
1842
1843 if (!*p && str[0] == '.' && str[1] == 0)
1844 return true;
1845
1846 if (!*str && *p == '?') {
1847 while (*p == '?')
1848 p++;
1849 return(!*p);
1850 }
1851
1852 if(!*str && (*p == '*' && p[1] == '\0'))
1853 return true;
1854
1855 return false;
1856 }
1857
1858 /*******************************************************************
1859 Simple case insensitive interface to a UNIX wildcard matcher.
1860 Returns True if match, False if not.
1861 *******************************************************************/
1862
1863 bool unix_wild_match(const char *pattern, const char *string)
1864 {
1865 TALLOC_CTX *ctx = talloc_stackframe();
1866 char *p2;
1867 char *s2;
1868 char *p;
1869 bool ret = false;
1870
1871 p2 = talloc_strdup(ctx,pattern);
1872 s2 = talloc_strdup(ctx,string);
1873 if (!p2 || !s2) {
1874 TALLOC_FREE(ctx);
1875 return false;
1876 }
1877 if (!strlower_m(p2)) {
1878 TALLOC_FREE(ctx);
1879 return false;
1880 }
1881 if (!strlower_m(s2)) {
1882 TALLOC_FREE(ctx);
1883 return false;
1884 }
1885
1886 /* Remove any *? and ** from the pattern as they are meaningless */
1887 for(p = p2; *p; p++) {
1888 while( *p == '*' && (p[1] == '?' ||p[1] == '*')) {
1889 memmove(&p[1], &p[2], strlen(&p[2])+1);
1890 }
1891 }
1892
1893 if (strequal(p2,"*")) {
1894 TALLOC_FREE(ctx);
1895 return true;
1896 }
1897
1898 ret = unix_do_match(p2, s2);
1899 TALLOC_FREE(ctx);
1900 return ret;
1901 }
1902
1903 /**********************************************************************
1904 Converts a name to a fully qualified domain name.
1905 Returns true if lookup succeeded, false if not (then fqdn is set to name)
1906 Uses getaddrinfo() with AI_CANONNAME flag to obtain the official
1907 canonical name of the host. getaddrinfo() may use a variety of sources
1908 including /etc/hosts to obtain the domainname. It expects aliases in
1909 /etc/hosts to NOT be the FQDN. The FQDN should come first.
1910 ************************************************************************/
1911
1912 bool name_to_fqdn(fstring fqdn, const char *name)
1913 {
1914 char *full = NULL;
1915 struct addrinfo hints;
1916 struct addrinfo *result;
1917 int s;
1918
1919 /* Configure hints to obtain canonical name */
1920
1921 memset(&hints, 0, sizeof(struct addrinfo));
1922 hints.ai_family = AF_UNSPEC; /* Allow IPv4 or IPv6 */
1923 hints.ai_socktype = SOCK_DGRAM; /* Datagram socket */
1924 hints.ai_flags = AI_CANONNAME; /* Get host's FQDN */
1925 hints.ai_protocol = 0; /* Any protocol */
1926
1927 s = getaddrinfo(name, NULL, &hints, &result);
1928 if (s != 0) {
1929 DEBUG(1, ("getaddrinfo: %s\n", gai_strerror(s)));
1930 DEBUG(10,("name_to_fqdn: lookup for %s failed.\n", name));
1931 fstrcpy(fqdn, name);
1932 return false;
1933 }
1934 full = result->ai_canonname;
1935
1936 /* Find out if the FQDN is returned as an alias
1937 * to cope with /etc/hosts files where the first
1938 * name is not the FQDN but the short name.
1939 * getaddrinfo provides no easy way of handling aliases
1940 * in /etc/hosts. Users should make sure the FQDN
1941 * comes first in /etc/hosts. */
1942 if (full && (! strchr_m(full, '.'))) {
1943 DEBUG(1, ("WARNING: your /etc/hosts file may be broken!\n"));
1944 DEBUGADD(1, (" Full qualified domain names (FQDNs) should not be specified\n"));
1945 DEBUGADD(1, (" as an alias in /etc/hosts. FQDN should be the first name\n"));
1946 DEBUGADD(1, (" prior to any aliases.\n"));
1947 }
1948 if (full && (strcasecmp_m(full, "localhost.localdomain") == 0)) {
1949 DEBUG(1, ("WARNING: your /etc/hosts file may be broken!\n"));
1950 DEBUGADD(1, (" Specifying the machine hostname for address 127.0.0.1 may lead\n"));
1951 DEBUGADD(1, (" to Kerberos authentication problems as localhost.localdomain\n"));
1952 DEBUGADD(1, (" may end up being used instead of the real machine FQDN.\n"));
1953 }
1954
1955 DEBUG(10,("name_to_fqdn: lookup for %s -> %s.\n", name, full));
1956 fstrcpy(fqdn, full);
1957 freeaddrinfo(result); /* No longer needed */
1958 return true;
1959 }
1960
1961 uint32_t map_share_mode_to_deny_mode(uint32_t share_access, uint32_t private_options)
1962 {
1963 switch (share_access & ~FILE_SHARE_DELETE) {
1964 case FILE_SHARE_NONE:
1965 return DENY_ALL;
1966 case FILE_SHARE_READ:
1967 return DENY_WRITE;
1968 case FILE_SHARE_WRITE:
1969 return DENY_READ;
1970 case FILE_SHARE_READ|FILE_SHARE_WRITE:
1971 return DENY_NONE;
1972 }
1973 if (private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS) {
1974 return DENY_DOS;
1975 } else if (private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_FCB) {
1976 return DENY_FCB;
1977 }
1978
1979 return (uint32_t)-1;
1980 }
1981
1982 struct server_id interpret_pid(const char *pid_string)
1983 {
1984 return server_id_from_string(get_my_vnn(), pid_string);
1985 }
1986
1987 /****************************************************************
1988 Check if an offset into a buffer is safe.
1989 If this returns True it's safe to indirect into the byte at
1990 pointer ptr+off.
1991 ****************************************************************/
1992
1993 bool is_offset_safe(const char *buf_base, size_t buf_len, char *ptr, size_t off)
1994 {
1995 const char *end_base = buf_base + buf_len;
1996 char *end_ptr = ptr + off;
1997
1998 if (!buf_base || !ptr) {
1999 return False;
2000 }
2001
2002 if (end_base < buf_base || end_ptr < ptr) {
2003 return False; /* wrap. */
2004 }
2005
2006 if (end_ptr < end_base) {
2007 return True;
2008 }
2009 return False;
2010 }
2011
2012 /****************************************************************
2013 Return a safe pointer into a buffer, or NULL.
2014 ****************************************************************/
2015
2016 char *get_safe_ptr(const char *buf_base, size_t buf_len, char *ptr, size_t off)
2017 {
2018 return is_offset_safe(buf_base, buf_len, ptr, off) ?
2019 ptr + off : NULL;
2020 }
2021
2022 /****************************************************************
2023 Return a safe pointer into a string within a buffer, or NULL.
2024 ****************************************************************/
2025
2026 char *get_safe_str_ptr(const char *buf_base, size_t buf_len, char *ptr, size_t off)
2027 {
2028 if (!is_offset_safe(buf_base, buf_len, ptr, off)) {
2029 return NULL;
2030 }
2031 /* Check if a valid string exists at this offset. */
2032 if (skip_string(buf_base,buf_len, ptr + off) == NULL) {
2033 return NULL;
2034 }
2035 return ptr + off;
2036 }
2037
2038 /****************************************************************
2039 Return an SVAL at a pointer, or failval if beyond the end.
2040 ****************************************************************/
2041
2042 int get_safe_SVAL(const char *buf_base, size_t buf_len, char *ptr, size_t off, int failval)
2043 {
2044 /*
2045 * Note we use off+1 here, not off+2 as SVAL accesses ptr[0] and ptr[1],
2046 * NOT ptr[2].
2047 */
2048 if (!is_offset_safe(buf_base, buf_len, ptr, off+1)) {
2049 return failval;
2050 }
2051 return SVAL(ptr,off);
2052 }
2053
2054 /****************************************************************
2055 Return an IVAL at a pointer, or failval if beyond the end.
2056 ****************************************************************/
2057
2058 int get_safe_IVAL(const char *buf_base, size_t buf_len, char *ptr, size_t off, int failval)
2059 {
2060 /*
2061 * Note we use off+3 here, not off+4 as IVAL accesses
2062 * ptr[0] ptr[1] ptr[2] ptr[3] NOT ptr[4].
2063 */
2064 if (!is_offset_safe(buf_base, buf_len, ptr, off+3)) {
2065 return failval;
2066 }
2067 return IVAL(ptr,off);
2068 }
2069
2070 /****************************************************************
2071 Split DOM\user into DOM and user. Do not mix with winbind variants of that
2072 call (they take care of winbind separator and other winbind specific settings).
2073 ****************************************************************/
2074
2075 void split_domain_user(TALLOC_CTX *mem_ctx,
2076 const char *full_name,
2077 char **domain,
2078 char **user)
2079 {
2080 const char *p = NULL;
2081
2082 p = strchr_m(full_name, '\\');
2083
2084 if (p != NULL) {
2085 *domain = talloc_strndup(mem_ctx, full_name,
2086 PTR_DIFF(p, full_name));
2087 *user = talloc_strdup(mem_ctx, p+1);
2088 } else {
2089 *domain = talloc_strdup(mem_ctx, "");
2090 *user = talloc_strdup(mem_ctx, full_name);
2091 }
2092 }
2093
2094 /****************************************************************
2095 strip off leading '\\' from a hostname
2096 ****************************************************************/
2097
2098 const char *strip_hostname(const char *s)
2099 {
2100 if (!s) {
2101 return NULL;
2102 }
2103
2104 if (strlen_m(s) < 3) {
2105 return s;
2106 }
2107
2108 if (s[0] == '\\') s++;
2109 if (s[0] == '\\') s++;
2110
2111 return s;
2112 }
2113
2114 bool any_nt_status_not_ok(NTSTATUS err1, NTSTATUS err2, NTSTATUS *result)
2115 {
2116 if (!NT_STATUS_IS_OK(err1)) {
2117 *result = err1;
2118 return true;
2119 }
2120 if (!NT_STATUS_IS_OK(err2)) {
2121 *result = err2;
2122 return true;
2123 }
2124 return false;
2125 }
2126
2127 int timeval_to_msec(struct timeval t)
2128 {
2129 return t.tv_sec * 1000 + (t.tv_usec+999) / 1000;
2130 }
2131
2132 /*******************************************************************
2133 Check a given DOS pathname is valid for a share.
2134 ********************************************************************/
2135
2136 char *valid_share_pathname(TALLOC_CTX *ctx, const char *dos_pathname)
2137 {
2138 char *ptr = NULL;
2139
2140 if (!dos_pathname) {
2141 return NULL;
2142 }
2143
2144 ptr = talloc_strdup(ctx, dos_pathname);
2145 if (!ptr) {
2146 return NULL;
2147 }
2148 /* Convert any '\' paths to '/' */
2149 unix_format(ptr);
2150 ptr = unix_clean_name(ctx, ptr);
2151 if (!ptr) {
2152 return NULL;
2153 }
2154
2155 /* NT is braindead - it wants a C: prefix to a pathname ! So strip it. */
2156 if (strlen(ptr) > 2 && ptr[1] == ':' && ptr[0] != '/')
2157 ptr += 2;
2158
2159 /* Only absolute paths allowed. */
2160 if (*ptr != '/')
2161 return NULL;
2162
2163 return ptr;
2164 }
2165
2166 /*******************************************************************
2167 Return True if the filename is one of the special executable types.
2168 ********************************************************************/
2169
2170 bool is_executable(const char *fname)
2171 {
2172 if ((fname = strrchr_m(fname,'.'))) {
2173 if (strequal(fname,".com") ||
2174 strequal(fname,".dll") ||
2175 strequal(fname,".exe") ||
2176 strequal(fname,".sym")) {
2177 return True;
2178 }
2179 }
2180 return False;
2181 }
2182
2183 /****************************************************************************
2184 Open a file with a share mode - old openX method - map into NTCreate.
2185 ****************************************************************************/
2186
2187 bool map_open_params_to_ntcreate(const char *smb_base_fname,
2188 int deny_mode, int open_func,
2189 uint32_t *paccess_mask,
2190 uint32_t *pshare_mode,
2191 uint32_t *pcreate_disposition,
2192 uint32_t *pcreate_options,
2193 uint32_t *pprivate_flags)
2194 {
2195 uint32_t access_mask;
2196 uint32_t share_mode;
2197 uint32_t create_disposition;
2198 uint32_t create_options = FILE_NON_DIRECTORY_FILE;
2199 uint32_t private_flags = 0;
2200
2201 DEBUG(10,("map_open_params_to_ntcreate: fname = %s, deny_mode = 0x%x, "
2202 "open_func = 0x%x\n",
2203 smb_base_fname, (unsigned int)deny_mode,
2204 (unsigned int)open_func ));
2205
2206 /* Create the NT compatible access_mask. */
2207 switch (GET_OPENX_MODE(deny_mode)) {
2208 case DOS_OPEN_EXEC: /* Implies read-only - used to be FILE_READ_DATA */
2209 case DOS_OPEN_RDONLY:
2210 access_mask = FILE_GENERIC_READ;
2211 break;
2212 case DOS_OPEN_WRONLY:
2213 access_mask = FILE_GENERIC_WRITE;
2214 break;
2215 case DOS_OPEN_RDWR:
2216 case DOS_OPEN_FCB:
2217 access_mask = FILE_GENERIC_READ|FILE_GENERIC_WRITE;
2218 break;
2219 default:
2220 DEBUG(10,("map_open_params_to_ntcreate: bad open mode = 0x%x\n",
2221 (unsigned int)GET_OPENX_MODE(deny_mode)));
2222 return False;
2223 }
2224
2225 /* Create the NT compatible create_disposition. */
2226 switch (open_func) {
2227 case OPENX_FILE_EXISTS_FAIL|OPENX_FILE_CREATE_IF_NOT_EXIST:
2228 create_disposition = FILE_CREATE;
2229 break;
2230
2231 case OPENX_FILE_EXISTS_OPEN:
2232 create_disposition = FILE_OPEN;
2233 break;
2234
2235 case OPENX_FILE_EXISTS_OPEN|OPENX_FILE_CREATE_IF_NOT_EXIST:
2236 create_disposition = FILE_OPEN_IF;
2237 break;
2238
2239 case OPENX_FILE_EXISTS_TRUNCATE:
2240 create_disposition = FILE_OVERWRITE;
2241 break;
2242
2243 case OPENX_FILE_EXISTS_TRUNCATE|OPENX_FILE_CREATE_IF_NOT_EXIST:
2244 create_disposition = FILE_OVERWRITE_IF;
2245 break;
2246
2247 default:
2248 /* From samba4 - to be confirmed. */
2249 if (GET_OPENX_MODE(deny_mode) == DOS_OPEN_EXEC) {
2250 create_disposition = FILE_CREATE;
2251 break;
2252 }
2253 DEBUG(10,("map_open_params_to_ntcreate: bad "
2254 "open_func 0x%x\n", (unsigned int)open_func));
2255 return False;
2256 }
2257
2258 /* Create the NT compatible share modes. */
2259 switch (GET_DENY_MODE(deny_mode)) {
2260 case DENY_ALL:
2261 share_mode = FILE_SHARE_NONE;
2262 break;
2263
2264 case DENY_WRITE:
2265 share_mode = FILE_SHARE_READ;
2266 break;
2267
2268 case DENY_READ:
2269 share_mode = FILE_SHARE_WRITE;
2270 break;
2271
2272 case DENY_NONE:
2273 share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
2274 break;
2275
2276 case DENY_DOS:
2277 private_flags |= NTCREATEX_OPTIONS_PRIVATE_DENY_DOS;
2278 if (is_executable(smb_base_fname)) {
2279 share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
2280 } else {
2281 if (GET_OPENX_MODE(deny_mode) == DOS_OPEN_RDONLY) {
2282 share_mode = FILE_SHARE_READ;
2283 } else {
2284 share_mode = FILE_SHARE_NONE;
2285 }
2286 }
2287 break;
2288
2289 case DENY_FCB:
2290 private_flags |= NTCREATEX_OPTIONS_PRIVATE_DENY_FCB;
2291 share_mode = FILE_SHARE_NONE;
2292 break;
2293
2294 default:
2295 DEBUG(10,("map_open_params_to_ntcreate: bad deny_mode 0x%x\n",
2296 (unsigned int)GET_DENY_MODE(deny_mode) ));
2297 return False;
2298 }
2299
2300 DEBUG(10,("map_open_params_to_ntcreate: file %s, access_mask = 0x%x, "
2301 "share_mode = 0x%x, create_disposition = 0x%x, "
2302 "create_options = 0x%x private_flags = 0x%x\n",
2303 smb_base_fname,
2304 (unsigned int)access_mask,
2305 (unsigned int)share_mode,
2306 (unsigned int)create_disposition,
2307 (unsigned int)create_options,
2308 (unsigned int)private_flags));
2309
2310 if (paccess_mask) {
2311 *paccess_mask = access_mask;
2312 }
2313 if (pshare_mode) {
2314 *pshare_mode = share_mode;
2315 }
2316 if (pcreate_disposition) {
2317 *pcreate_disposition = create_disposition;
2318 }
2319 if (pcreate_options) {
2320 *pcreate_options = create_options;
2321 }
2322 if (pprivate_flags) {
2323 *pprivate_flags = private_flags;
2324 }
2325
2326 return True;
2327
2328 }
2329
2330 /*************************************************************************
2331 Return a talloced copy of a struct security_unix_token. NULL on fail.
2332 *************************************************************************/
2333
2334 struct security_unix_token *copy_unix_token(TALLOC_CTX *ctx, const struct security_unix_token *tok)
2335 {
2336 struct security_unix_token *cpy;
2337
2338 cpy = talloc(ctx, struct security_unix_token);
2339 if (!cpy) {
2340 return NULL;
2341 }
2342
2343 cpy->uid = tok->uid;
2344 cpy->gid = tok->gid;
2345 cpy->ngroups = tok->ngroups;
2346 if (tok->ngroups) {
2347 /* Make this a talloc child of cpy. */
2348 cpy->groups = (gid_t *)talloc_memdup(
2349 cpy, tok->groups, tok->ngroups * sizeof(gid_t));
2350 if (!cpy->groups) {
2351 TALLOC_FREE(cpy);
2352 return NULL;
2353 }
2354 } else {
2355 cpy->groups = NULL;
2356 }
2357 return cpy;
2358 }
2359
2360 /****************************************************************************
2361 Check that a file matches a particular file type.
2362 ****************************************************************************/
2363
2364 bool dir_check_ftype(uint32_t mode, uint32_t dirtype)
2365 {
2366 uint32_t mask;
2367
2368 /* Check the "may have" search bits. */
2369 if (((mode & ~dirtype) &
2370 (FILE_ATTRIBUTE_HIDDEN |
2371 FILE_ATTRIBUTE_SYSTEM |
2372 FILE_ATTRIBUTE_DIRECTORY)) != 0) {
2373 return false;
2374 }
2375
2376 /* Check the "must have" bits,
2377 which are the may have bits shifted eight */
2378 /* If must have bit is set, the file/dir can
2379 not be returned in search unless the matching
2380 file attribute is set */
2381 mask = ((dirtype >> 8) & (FILE_ATTRIBUTE_DIRECTORY|
2382 FILE_ATTRIBUTE_ARCHIVE|
2383 FILE_ATTRIBUTE_READONLY|
2384 FILE_ATTRIBUTE_HIDDEN|
2385 FILE_ATTRIBUTE_SYSTEM)); /* & 0x37 */
2386 if(mask) {
2387 if((mask & (mode & (FILE_ATTRIBUTE_DIRECTORY|
2388 FILE_ATTRIBUTE_ARCHIVE|
2389 FILE_ATTRIBUTE_READONLY|
2390 FILE_ATTRIBUTE_HIDDEN|
2391 FILE_ATTRIBUTE_SYSTEM))) == mask) {
2392 /* check if matching attribute present */
2393 return true;
2394 } else {
2395 return false;
2396 }
2397 }
2398
2399 return true;
2400 }
Samba GIT mirror