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