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