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