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