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