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