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
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.
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.
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/>.
25 #include "system/passwd.h"
26 #include "system/filesys.h"
28 #include "ctdbd_conn.h"
29 #include "../lib/util/util_pw.h"
31 #include "libcli/security/security.h"
33 #include "lib/util/sys_rw.h"
34 #include "lib/util/sys_rw_data.h"
35 #include "lib/util/util_process.h"
37 #ifdef HAVE_SYS_PRCTL_H
38 #include <sys/prctl.h>
41 /* Max allowable allococation - 256mb - 0x10000000 */
42 #define MAX_ALLOC_SIZE (1024*1024*256)
44 #if (defined(HAVE_NETGROUP) && defined (WITH_AUTOMOUNT))
45 #ifdef WITH_NISPLUS_HOME
46 #ifdef BROKEN_NISPLUS_INCLUDE_FILES
48 * The following lines are needed due to buggy include files
49 * in Solaris 2.6 which define GROUP in both /usr/include/sys/acl.h and
50 * also in /usr/include/rpcsvc/nis.h. The definitions conflict. JRA.
51 * Also GROUP_OBJ is defined as 0x4 in /usr/include/sys/acl.h and as
52 * an enum in /usr/include/rpcsvc/nis.h.
59 #if defined(GROUP_OBJ)
63 #endif /* BROKEN_NISPLUS_INCLUDE_FILES */
65 #include <rpcsvc/nis.h>
67 #endif /* WITH_NISPLUS_HOME */
68 #endif /* HAVE_NETGROUP && WITH_AUTOMOUNT */
70 static enum protocol_types Protocol = PROTOCOL_COREPLUS;
72 enum protocol_types get_Protocol(void)
77 void set_Protocol(enum protocol_types p)
82 static enum remote_arch_types ra_type = RA_UNKNOWN;
84 void gfree_all( void )
93 /*******************************************************************
94 Check if a file exists - call vfs_file_exist for samba files.
95 ********************************************************************/
97 bool file_exist_stat(const char *fname,SMB_STRUCT_STAT *sbuf,
98 bool fake_dir_create_times)
104 if (sys_stat(fname, sbuf, fake_dir_create_times) != 0)
107 return((S_ISREG(sbuf->st_ex_mode)) || (S_ISFIFO(sbuf->st_ex_mode)));
110 /*******************************************************************
111 Check if a unix domain socket exists - call vfs_file_exist for samba files.
112 ********************************************************************/
114 bool socket_exist(const char *fname)
117 if (sys_stat(fname, &st, false) != 0)
120 return S_ISSOCK(st.st_ex_mode);
123 /*******************************************************************
124 Returns the size in bytes of the named given the stat struct.
125 ********************************************************************/
127 uint64_t get_file_size_stat(const SMB_STRUCT_STAT *sbuf)
129 return sbuf->st_ex_size;
132 /****************************************************************************
133 Check two stats have identical dev and ino fields.
134 ****************************************************************************/
136 bool check_same_dev_ino(const SMB_STRUCT_STAT *sbuf1,
137 const SMB_STRUCT_STAT *sbuf2)
139 if (sbuf1->st_ex_dev != sbuf2->st_ex_dev ||
140 sbuf1->st_ex_ino != sbuf2->st_ex_ino) {
146 /****************************************************************************
147 Check if a stat struct is identical for use.
148 ****************************************************************************/
150 bool check_same_stat(const SMB_STRUCT_STAT *sbuf1,
151 const SMB_STRUCT_STAT *sbuf2)
153 if (sbuf1->st_ex_uid != sbuf2->st_ex_uid ||
154 sbuf1->st_ex_gid != sbuf2->st_ex_gid ||
155 !check_same_dev_ino(sbuf1, sbuf2)) {
161 /*******************************************************************
162 Show a smb message structure.
163 ********************************************************************/
165 void show_msg(const char *buf)
173 DEBUG(5,("size=%d\nsmb_com=0x%x\nsmb_rcls=%d\nsmb_reh=%d\nsmb_err=%d\nsmb_flg=%d\nsmb_flg2=%d\n",
175 (int)CVAL(buf,smb_com),
176 (int)CVAL(buf,smb_rcls),
177 (int)CVAL(buf,smb_reh),
178 (int)SVAL(buf,smb_err),
179 (int)CVAL(buf,smb_flg),
180 (int)SVAL(buf,smb_flg2)));
181 DEBUGADD(5,("smb_tid=%d\nsmb_pid=%d\nsmb_uid=%d\nsmb_mid=%d\n",
182 (int)SVAL(buf,smb_tid),
183 (int)SVAL(buf,smb_pid),
184 (int)SVAL(buf,smb_uid),
185 (int)SVAL(buf,smb_mid)));
186 DEBUGADD(5,("smt_wct=%d\n",(int)CVAL(buf,smb_wct)));
188 for (i=0;i<(int)CVAL(buf,smb_wct);i++)
189 DEBUGADD(5,("smb_vwv[%2d]=%5d (0x%X)\n",i,
190 SVAL(buf,smb_vwv+2*i),SVAL(buf,smb_vwv+2*i)));
192 bcc = (int)SVAL(buf,smb_vwv+2*(CVAL(buf,smb_wct)));
194 DEBUGADD(5,("smb_bcc=%d\n",bcc));
202 dump_data(10, (const uint8_t *)smb_buf_const(buf), bcc);
205 /*******************************************************************
206 Setup only the byte count for a smb message.
207 ********************************************************************/
209 int set_message_bcc(char *buf,int num_bytes)
211 int num_words = CVAL(buf,smb_wct);
212 SSVAL(buf,smb_vwv + num_words*SIZEOFWORD,num_bytes);
213 _smb_setlen(buf,smb_size + num_words*2 + num_bytes - 4);
214 return (smb_size + num_words*2 + num_bytes);
217 /*******************************************************************
218 Add a data blob to the end of a smb_buf, adjusting bcc and smb_len.
219 Return the bytes added
220 ********************************************************************/
222 ssize_t message_push_blob(uint8_t **outbuf, DATA_BLOB blob)
224 size_t newlen = smb_len(*outbuf) + 4 + blob.length;
227 if (!(tmp = talloc_realloc(NULL, *outbuf, uint8_t, newlen))) {
228 DEBUG(0, ("talloc failed\n"));
233 memcpy(tmp + smb_len(tmp) + 4, blob.data, blob.length);
234 set_message_bcc((char *)tmp, smb_buflen(tmp) + blob.length);
238 /*******************************************************************
239 Reduce a file name, removing .. elements.
240 ********************************************************************/
242 static char *dos_clean_name(TALLOC_CTX *ctx, const char *s)
247 DEBUG(3,("dos_clean_name [%s]\n",s));
249 /* remove any double slashes */
250 str = talloc_all_string_sub(ctx, s, "\\\\", "\\");
255 /* Remove leading .\\ characters */
256 if(strncmp(str, ".\\", 2) == 0) {
257 trim_string(str, ".\\", NULL);
259 str = talloc_strdup(ctx, ".\\");
266 while ((p = strstr_m(str,"\\..\\")) != NULL) {
272 if ((p=strrchr_m(str,'\\')) != NULL) {
277 str = talloc_asprintf(ctx,
286 trim_string(str,NULL,"\\..");
287 return talloc_all_string_sub(ctx, str, "\\.\\", "\\");
290 /*******************************************************************
291 Reduce a file name, removing .. elements.
292 ********************************************************************/
294 char *unix_clean_name(TALLOC_CTX *ctx, const char *s)
299 DEBUG(3,("unix_clean_name [%s]\n",s));
301 /* remove any double slashes */
302 str = talloc_all_string_sub(ctx, s, "//","/");
307 /* Remove leading ./ characters */
308 if(strncmp(str, "./", 2) == 0) {
309 trim_string(str, "./", NULL);
311 str = talloc_strdup(ctx, "./");
318 while ((p = strstr_m(str,"/../")) != NULL) {
324 if ((p=strrchr_m(str,'/')) != NULL) {
329 str = talloc_asprintf(ctx,
338 trim_string(str,NULL,"/..");
339 return talloc_all_string_sub(ctx, str, "/./", "/");
342 char *clean_name(TALLOC_CTX *ctx, const char *s)
344 char *str = dos_clean_name(ctx, s);
348 return unix_clean_name(ctx, str);
351 /*******************************************************************
352 Write data into an fd at a given offset. Ignore seek errors.
353 ********************************************************************/
355 ssize_t write_data_at_offset(int fd, const char *buffer, size_t N, off_t pos)
360 if (pos == (off_t)-1) {
361 return write_data(fd, buffer, N);
363 #if defined(HAVE_PWRITE) || defined(HAVE_PRWITE64)
365 ret = sys_pwrite(fd,buffer + total,N - total, pos);
366 if (ret == -1 && errno == ESPIPE) {
367 return write_data(fd, buffer + total,N - total);
370 DEBUG(0,("write_data_at_offset: write failure. Error = %s\n", strerror(errno) ));
379 return (ssize_t)total;
381 /* Use lseek and write_data. */
382 if (lseek(fd, pos, SEEK_SET) == -1) {
383 if (errno != ESPIPE) {
387 return write_data(fd, buffer, N);
391 static int reinit_after_fork_pipe[2] = { -1, -1 };
393 NTSTATUS init_before_fork(void)
397 ret = pipe(reinit_after_fork_pipe);
401 status = map_nt_error_from_unix_common(errno);
403 DEBUG(0, ("Error creating child_pipe: %s\n",
413 * Detect died parent by detecting EOF on the pipe
415 static void reinit_after_fork_pipe_handler(struct tevent_context *ev,
416 struct tevent_fd *fde,
422 if (sys_read(reinit_after_fork_pipe[0], &c, 1) != 1) {
424 * we have reached EOF on stdin, which means the
425 * parent has exited. Shutdown the server
427 (void)kill(getpid(), SIGTERM);
432 NTSTATUS reinit_after_fork(struct messaging_context *msg_ctx,
433 struct tevent_context *ev_ctx,
434 bool parent_longlived,
437 NTSTATUS status = NT_STATUS_OK;
439 if (reinit_after_fork_pipe[1] != -1) {
440 close(reinit_after_fork_pipe[1]);
441 reinit_after_fork_pipe[1] = -1;
444 /* Reset the state of the random
445 * number generation system, so
446 * children do not get the same random
447 * numbers as each other */
448 set_need_random_reseed();
450 /* tdb needs special fork handling */
451 if (tdb_reopen_all(parent_longlived ? 1 : 0) != 0) {
452 DEBUG(0,("tdb_reopen_all failed.\n"));
453 status = NT_STATUS_OPEN_FAILED;
457 if (ev_ctx != NULL) {
458 tevent_set_trace_callback(ev_ctx, NULL, NULL);
459 if (tevent_re_initialise(ev_ctx) != 0) {
460 smb_panic(__location__ ": Failed to re-initialise event context");
464 if (reinit_after_fork_pipe[0] != -1) {
465 struct tevent_fd *fde;
467 fde = tevent_add_fd(ev_ctx, ev_ctx /* TALLOC_CTX */,
468 reinit_after_fork_pipe[0], TEVENT_FD_READ,
469 reinit_after_fork_pipe_handler, NULL);
471 smb_panic(__location__ ": Failed to add reinit_after_fork pipe event");
477 * For clustering, we need to re-init our ctdbd connection after the
480 status = messaging_reinit(msg_ctx);
481 if (!NT_STATUS_IS_OK(status)) {
482 DEBUG(0,("messaging_reinit() failed: %s\n",
488 prctl_set_comment(comment);
495 /****************************************************************************
496 (Hopefully) efficient array append.
497 ****************************************************************************/
499 void add_to_large_array(TALLOC_CTX *mem_ctx, size_t element_size,
500 void *element, void *_array, uint32_t *num_elements,
503 void **array = (void **)_array;
505 if (*array_size < 0) {
509 if (*array == NULL) {
510 if (*array_size == 0) {
514 if (*array_size >= MAX_ALLOC_SIZE/element_size) {
518 *array = TALLOC(mem_ctx, element_size * (*array_size));
519 if (*array == NULL) {
524 if (*num_elements == *array_size) {
527 if (*array_size >= MAX_ALLOC_SIZE/element_size) {
531 *array = TALLOC_REALLOC(mem_ctx, *array,
532 element_size * (*array_size));
534 if (*array == NULL) {
539 memcpy((char *)(*array) + element_size*(*num_elements),
540 element, element_size);
550 /****************************************************************************
551 Get my own domain name, or "" if we have none.
552 ****************************************************************************/
554 char *get_mydnsdomname(TALLOC_CTX *ctx)
559 domname = get_mydnsfullname();
564 p = strchr_m(domname, '.');
567 return talloc_strdup(ctx, p);
569 return talloc_strdup(ctx, "");
573 #if (defined(HAVE_NETGROUP) && defined(WITH_AUTOMOUNT))
574 /******************************************************************
575 Remove any mount options such as -rsize=2048,wsize=2048 etc.
576 Based on a fix from <Thomas.Hepper@icem.de>.
577 Returns a malloc'ed string.
578 *******************************************************************/
580 static char *strip_mount_options(TALLOC_CTX *ctx, const char *str)
584 while(*p && !isspace(*p))
586 while(*p && isspace(*p))
589 return talloc_strdup(ctx, p);
595 /*******************************************************************
596 Patch from jkf@soton.ac.uk
597 Split Luke's automount_server into YP lookup and string splitter
598 so can easily implement automount_path().
599 Returns a malloc'ed string.
600 *******************************************************************/
602 #ifdef WITH_NISPLUS_HOME
603 char *automount_lookup(TALLOC_CTX *ctx, const char *user_name)
607 char *nis_map = (char *)lp_homedir_map();
609 char buffer[NIS_MAXATTRVAL + 1];
614 snprintf(buffer, sizeof(buffer), "[key=%s],%s", user_name, nis_map);
615 DEBUG(5, ("NIS+ querystring: %s\n", buffer));
617 if (result = nis_list(buffer, FOLLOW_PATH|EXPAND_NAME|HARD_LOOKUP, NULL, NULL)) {
618 if (result->status != NIS_SUCCESS) {
619 DEBUG(3, ("NIS+ query failed: %s\n", nis_sperrno(result->status)));
621 object = result->objects.objects_val;
622 if (object->zo_data.zo_type == ENTRY_OBJ) {
623 entry = &object->zo_data.objdata_u.en_data;
624 DEBUG(5, ("NIS+ entry type: %s\n", entry->en_type));
625 DEBUG(3, ("NIS+ result: %s\n", entry->en_cols.en_cols_val[1].ec_value.ec_value_val));
627 value = talloc_strdup(ctx,
628 entry->en_cols.en_cols_val[1].ec_value.ec_value_val);
630 nis_freeresult(result);
633 value = talloc_string_sub(ctx,
640 nis_freeresult(result);
643 value = strip_mount_options(ctx, value);
644 DEBUG(4, ("NIS+ Lookup: %s resulted in %s\n",
649 #else /* WITH_NISPLUS_HOME */
651 char *automount_lookup(TALLOC_CTX *ctx, const char *user_name)
655 int nis_error; /* returned by yp all functions */
656 char *nis_result; /* yp_match inits this */
657 int nis_result_len; /* and set this */
658 char *nis_domain; /* yp_get_default_domain inits this */
659 char *nis_map = lp_homedir_map(talloc_tos());
661 if ((nis_error = yp_get_default_domain(&nis_domain)) != 0) {
662 DEBUG(3, ("YP Error: %s\n", yperr_string(nis_error)));
666 DEBUG(5, ("NIS Domain: %s\n", nis_domain));
668 if ((nis_error = yp_match(nis_domain, nis_map, user_name,
669 strlen(user_name), &nis_result,
670 &nis_result_len)) == 0) {
671 if (nis_result_len > 0 && nis_result[nis_result_len] == '\n') {
672 nis_result[nis_result_len] = '\0';
674 value = talloc_strdup(ctx, nis_result);
678 value = strip_mount_options(ctx, value);
679 } else if(nis_error == YPERR_KEY) {
680 DEBUG(3, ("YP Key not found: while looking up \"%s\" in map \"%s\"\n",
681 user_name, nis_map));
682 DEBUG(3, ("using defaults for server and home directory\n"));
684 DEBUG(3, ("YP Error: \"%s\" while looking up \"%s\" in map \"%s\"\n",
685 yperr_string(nis_error), user_name, nis_map));
689 DEBUG(4, ("YP Lookup: %s resulted in %s\n", user_name, value));
693 #endif /* WITH_NISPLUS_HOME */
696 bool process_exists(const struct server_id pid)
698 return serverid_exists(&pid);
701 /*******************************************************************
702 Convert a uid into a user name.
703 ********************************************************************/
705 const char *uidtoname(uid_t uid)
707 TALLOC_CTX *ctx = talloc_tos();
709 struct passwd *pass = NULL;
711 pass = getpwuid_alloc(ctx,uid);
713 name = talloc_strdup(ctx,pass->pw_name);
716 name = talloc_asprintf(ctx,
723 /*******************************************************************
724 Convert a gid into a group name.
725 ********************************************************************/
727 char *gidtoname(gid_t gid)
733 return talloc_strdup(talloc_tos(), grp->gr_name);
736 return talloc_asprintf(talloc_tos(),
742 /*******************************************************************
743 Convert a user name into a uid.
744 ********************************************************************/
746 uid_t nametouid(const char *name)
752 pass = Get_Pwnam_alloc(talloc_tos(), name);
759 u = (uid_t)strtol(name, &p, 0);
760 if ((p != name) && (*p == '\0'))
766 /*******************************************************************
767 Convert a name to a gid_t if possible. Return -1 if not a group.
768 ********************************************************************/
770 gid_t nametogid(const char *name)
776 g = (gid_t)strtol(name, &p, 0);
777 if ((p != name) && (*p == '\0'))
780 grp = getgrnam(name);
786 /*******************************************************************
787 Something really nasty happened - panic !
788 ********************************************************************/
790 void smb_panic_s3(const char *why)
795 DEBUG(0,("PANIC (pid %llu): %s\n",
796 (unsigned long long)getpid(), why));
799 #if defined(HAVE_PRCTL) && defined(PR_SET_PTRACER)
801 * Make sure all children can attach a debugger.
803 prctl(PR_SET_PTRACER, getpid(), 0, 0, 0);
806 cmd = lp_panic_action(talloc_tos());
808 DEBUG(0, ("smb_panic(): calling panic action [%s]\n", cmd));
809 result = system(cmd);
812 DEBUG(0, ("smb_panic(): fork failed in panic action: %s\n",
815 DEBUG(0, ("smb_panic(): action returned status %d\n",
816 WEXITSTATUS(result)));
822 /*******************************************************************
823 Print a backtrace of the stack to the debug log. This function
824 DELIBERATELY LEAKS MEMORY. The expectation is that you should
825 exit shortly after calling it.
826 ********************************************************************/
828 #ifdef HAVE_LIBUNWIND_H
829 #include <libunwind.h>
832 #ifdef HAVE_EXECINFO_H
833 #include <execinfo.h>
840 void log_stack_trace(void)
842 #ifdef HAVE_LIBUNWIND
843 /* Try to use libunwind before any other technique since on ia64
844 * libunwind correctly walks the stack in more circumstances than
852 unw_word_t ip, sp, off;
854 procname[sizeof(procname) - 1] = '\0';
856 if (unw_getcontext(&uc) != 0) {
857 goto libunwind_failed;
860 if (unw_init_local(&cursor, &uc) != 0) {
861 goto libunwind_failed;
864 DEBUG(0, ("BACKTRACE:\n"));
868 unw_get_reg(&cursor, UNW_REG_IP, &ip);
869 unw_get_reg(&cursor, UNW_REG_SP, &sp);
871 switch (unw_get_proc_name(&cursor,
872 procname, sizeof(procname) - 1, &off) ) {
876 /* Name truncated. */
877 DEBUGADD(0, (" #%u %s + %#llx [ip=%#llx] [sp=%#llx]\n",
878 i, procname, (long long)off,
879 (long long)ip, (long long) sp));
882 /* case -UNW_ENOINFO: */
883 /* case -UNW_EUNSPEC: */
884 /* No symbol name found. */
885 DEBUGADD(0, (" #%u %s [ip=%#llx] [sp=%#llx]\n",
886 i, "<unknown symbol>",
887 (long long)ip, (long long) sp));
890 } while (unw_step(&cursor) > 0);
895 DEBUG(0, ("unable to produce a stack trace with libunwind\n"));
897 #elif HAVE_BACKTRACE_SYMBOLS
898 void *backtrace_stack[BACKTRACE_STACK_SIZE];
899 size_t backtrace_size;
900 char **backtrace_strings;
902 /* get the backtrace (stack frames) */
903 backtrace_size = backtrace(backtrace_stack,BACKTRACE_STACK_SIZE);
904 backtrace_strings = backtrace_symbols(backtrace_stack, backtrace_size);
906 DEBUG(0, ("BACKTRACE: %lu stack frames:\n",
907 (unsigned long)backtrace_size));
909 if (backtrace_strings) {
912 for (i = 0; i < backtrace_size; i++)
913 DEBUGADD(0, (" #%u %s\n", i, backtrace_strings[i]));
915 /* Leak the backtrace_strings, rather than risk what free() might do */
920 /* The IRIX libexc library provides an API for unwinding the stack. See
921 * libexc(3) for details. Apparantly trace_back_stack leaks memory, but
922 * since we are about to abort anyway, it hardly matters.
925 #define NAMESIZE 32 /* Arbitrary */
927 __uint64_t addrs[BACKTRACE_STACK_SIZE];
928 char * names[BACKTRACE_STACK_SIZE];
929 char namebuf[BACKTRACE_STACK_SIZE * NAMESIZE];
938 /* We need to be root so we can open our /proc entry to walk
939 * our stack. It also helps when we want to dump core.
943 for (i = 0; i < BACKTRACE_STACK_SIZE; i++) {
944 names[i] = namebuf + (i * NAMESIZE);
947 levels = trace_back_stack(0, addrs, names,
948 BACKTRACE_STACK_SIZE, NAMESIZE - 1);
950 DEBUG(0, ("BACKTRACE: %d stack frames:\n", levels));
951 for (i = 0; i < levels; i++) {
952 DEBUGADD(0, (" #%d 0x%llx %s\n", i, addrs[i], names[i]));
957 DEBUG(0, ("unable to produce a stack trace on this platform\n"));
961 /*******************************************************************
962 A readdir wrapper which just returns the file name.
963 ********************************************************************/
965 const char *readdirname(DIR *p)
973 ptr = (struct dirent *)readdir(p);
984 #ifdef HAVE_BROKEN_READDIR_NAME
985 /* using /usr/ucb/cc is BAD */
989 return talloc_strdup(talloc_tos(), dname);
992 /*******************************************************************
993 Utility function used to decide if the last component
994 of a path matches a (possibly wildcarded) entry in a namelist.
995 ********************************************************************/
997 bool is_in_path(const char *name, name_compare_entry *namelist, bool case_sensitive)
999 const char *last_component;
1001 /* if we have no list it's obviously not in the path */
1002 if((namelist == NULL ) || ((namelist != NULL) && (namelist[0].name == NULL))) {
1006 DEBUG(8, ("is_in_path: %s\n", name));
1008 /* Get the last component of the unix name. */
1009 last_component = strrchr_m(name, '/');
1010 if (!last_component) {
1011 last_component = name;
1013 last_component++; /* Go past '/' */
1016 for(; namelist->name != NULL; namelist++) {
1017 if(namelist->is_wild) {
1018 if (mask_match(last_component, namelist->name, case_sensitive)) {
1019 DEBUG(8,("is_in_path: mask match succeeded\n"));
1023 if((case_sensitive && (strcmp(last_component, namelist->name) == 0))||
1024 (!case_sensitive && (strcasecmp_m(last_component, namelist->name) == 0))) {
1025 DEBUG(8,("is_in_path: match succeeded\n"));
1030 DEBUG(8,("is_in_path: match not found\n"));
1034 /*******************************************************************
1035 Strip a '/' separated list into an array of
1036 name_compare_enties structures suitable for
1037 passing to is_in_path(). We do this for
1038 speed so we can pre-parse all the names in the list
1039 and don't do it for each call to is_in_path().
1040 We also check if the entry contains a wildcard to
1041 remove a potentially expensive call to mask_match
1043 ********************************************************************/
1045 void set_namearray(name_compare_entry **ppname_array, const char *namelist_in)
1051 int num_entries = 0;
1054 (*ppname_array) = NULL;
1056 if((namelist_in == NULL ) || ((namelist_in != NULL) && (*namelist_in == '\0')))
1059 namelist = talloc_strdup(talloc_tos(), namelist_in);
1060 if (namelist == NULL) {
1061 DEBUG(0,("set_namearray: talloc fail\n"));
1066 namelist_end = &namelist[strlen(namelist)];
1068 /* We need to make two passes over the string. The
1069 first to count the number of elements, the second
1073 while(nameptr <= namelist_end) {
1074 if ( *nameptr == '/' ) {
1075 /* cope with multiple (useless) /s) */
1079 /* anything left? */
1080 if ( *nameptr == '\0' )
1083 /* find the next '/' or consume remaining */
1084 name_end = strchr_m(nameptr, '/');
1085 if (name_end == NULL) {
1086 /* Point nameptr at the terminating '\0' */
1087 nameptr += strlen(nameptr);
1089 /* next segment please */
1090 nameptr = name_end + 1;
1095 if(num_entries == 0) {
1096 talloc_free(namelist);
1100 if(( (*ppname_array) = SMB_MALLOC_ARRAY(name_compare_entry, num_entries + 1)) == NULL) {
1101 DEBUG(0,("set_namearray: malloc fail\n"));
1102 talloc_free(namelist);
1106 /* Now copy out the names */
1109 while(nameptr <= namelist_end) {
1110 if ( *nameptr == '/' ) {
1111 /* cope with multiple (useless) /s) */
1115 /* anything left? */
1116 if ( *nameptr == '\0' )
1119 /* find the next '/' or consume remaining */
1120 name_end = strchr_m(nameptr, '/');
1121 if (name_end != NULL) {
1125 (*ppname_array)[i].is_wild = ms_has_wild(nameptr);
1126 if(((*ppname_array)[i].name = SMB_STRDUP(nameptr)) == NULL) {
1127 DEBUG(0,("set_namearray: malloc fail (1)\n"));
1128 talloc_free(namelist);
1132 if (name_end == NULL) {
1133 /* Point nameptr at the terminating '\0' */
1134 nameptr += strlen(nameptr);
1136 /* next segment please */
1137 nameptr = name_end + 1;
1142 (*ppname_array)[i].name = NULL;
1144 talloc_free(namelist);
1149 #define DBGC_CLASS DBGC_LOCKING
1151 /****************************************************************************
1152 Simple routine to query existing file locks. Cruft in NFS and 64->32 bit mapping
1153 is dealt with in posix.c
1154 Returns True if we have information regarding this lock region (and returns
1155 F_UNLCK in *ptype if the region is unlocked). False if the call failed.
1156 ****************************************************************************/
1158 bool fcntl_getlock(int fd, off_t *poffset, off_t *pcount, int *ptype, pid_t *ppid)
1163 DEBUG(8,("fcntl_getlock fd=%d offset=%.0f count=%.0f type=%d\n",
1164 fd,(double)*poffset,(double)*pcount,*ptype));
1166 lock.l_type = *ptype;
1167 lock.l_whence = SEEK_SET;
1168 lock.l_start = *poffset;
1169 lock.l_len = *pcount;
1172 ret = sys_fcntl_ptr(fd,F_GETLK,&lock);
1176 DEBUG(3,("fcntl_getlock: lock request failed at offset %.0f count %.0f type %d (%s)\n",
1177 (double)*poffset,(double)*pcount,*ptype,strerror(errno)));
1182 *ptype = lock.l_type;
1183 *poffset = lock.l_start;
1184 *pcount = lock.l_len;
1187 DEBUG(3,("fcntl_getlock: fd %d is returned info %d pid %u\n",
1188 fd, (int)lock.l_type, (unsigned int)lock.l_pid));
1193 #define DBGC_CLASS DBGC_ALL
1195 /*******************************************************************
1196 Is the name specified one of my netbios names.
1197 Returns true if it is equal, false otherwise.
1198 ********************************************************************/
1200 bool is_myname(const char *s)
1205 for (n=0; my_netbios_names(n); n++) {
1206 const char *nbt_name = my_netbios_names(n);
1208 if (strncasecmp_m(nbt_name, s, MAX_NETBIOSNAME_LEN-1) == 0) {
1213 DEBUG(8, ("is_myname(\"%s\") returns %d\n", s, ret));
1217 /*******************************************************************
1218 we distinguish between 2K and XP by the "Native Lan Manager" string
1219 WinXP => "Windows 2002 5.1"
1220 WinXP 64bit => "Windows XP 5.2"
1221 Win2k => "Windows 2000 5.0"
1222 NT4 => "Windows NT 4.0"
1223 Win9x => "Windows 4.0"
1224 Windows 2003 doesn't set the native lan manager string but
1225 they do set the domain to "Windows 2003 5.2" (probably a bug).
1226 ********************************************************************/
1228 void ra_lanman_string( const char *native_lanman )
1230 if ( strcmp( native_lanman, "Windows 2002 5.1" ) == 0 )
1231 set_remote_arch( RA_WINXP );
1232 else if ( strcmp( native_lanman, "Windows XP 5.2" ) == 0 )
1233 set_remote_arch( RA_WINXP64 );
1234 else if ( strcmp( native_lanman, "Windows Server 2003 5.2" ) == 0 )
1235 set_remote_arch( RA_WIN2K3 );
1238 static const char *remote_arch_str;
1240 const char *get_remote_arch_str(void)
1242 if (!remote_arch_str) {
1245 return remote_arch_str;
1248 /*******************************************************************
1249 Set the horrid remote_arch string based on an enum.
1250 ********************************************************************/
1252 void set_remote_arch(enum remote_arch_types type)
1257 remote_arch_str = "WfWg";
1260 remote_arch_str = "OS2";
1263 remote_arch_str = "Win95";
1266 remote_arch_str = "WinNT";
1269 remote_arch_str = "Win2K";
1272 remote_arch_str = "WinXP";
1275 remote_arch_str = "WinXP64";
1278 remote_arch_str = "Win2K3";
1281 remote_arch_str = "Vista";
1284 remote_arch_str = "Samba";
1287 remote_arch_str = "CIFSFS";
1290 remote_arch_str = "OSX";
1293 ra_type = RA_UNKNOWN;
1294 remote_arch_str = "UNKNOWN";
1298 DEBUG(10,("set_remote_arch: Client arch is \'%s\'\n",
1302 /*******************************************************************
1303 Get the remote_arch type.
1304 ********************************************************************/
1306 enum remote_arch_types get_remote_arch(void)
1311 const char *tab_depth(int level, int depth)
1313 if( CHECK_DEBUGLVL(level) ) {
1314 dbgtext("%*s", depth*4, "");
1319 /*****************************************************************************
1320 Provide a checksum on a string
1322 Input: s - the null-terminated character string for which the checksum
1325 Output: The checksum value calculated for s.
1326 *****************************************************************************/
1328 int str_checksum(const char *s)
1334 key = (TDB_DATA) { .dptr = discard_const_p(uint8_t, s),
1335 .dsize = strlen(s) };
1337 return tdb_jenkins_hash(&key);
1340 /*****************************************************************
1341 Zero a memory area then free it. Used to catch bugs faster.
1342 *****************************************************************/
1344 void zero_free(void *p, size_t size)
1350 /*****************************************************************
1351 Set our open file limit to a requested max and return the limit.
1352 *****************************************************************/
1354 int set_maxfiles(int requested_max)
1356 #if (defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE))
1358 int saved_current_limit;
1360 if(getrlimit(RLIMIT_NOFILE, &rlp)) {
1361 DEBUG(0,("set_maxfiles: getrlimit (1) for RLIMIT_NOFILE failed with error %s\n",
1364 return requested_max;
1368 * Set the fd limit to be real_max_open_files + MAX_OPEN_FUDGEFACTOR to
1369 * account for the extra fd we need
1370 * as well as the log files and standard
1371 * handles etc. Save the limit we want to set in case
1372 * we are running on an OS that doesn't support this limit (AIX)
1373 * which always returns RLIM_INFINITY for rlp.rlim_max.
1376 /* Try raising the hard (max) limit to the requested amount. */
1378 #if defined(RLIM_INFINITY)
1379 if (rlp.rlim_max != RLIM_INFINITY) {
1380 int orig_max = rlp.rlim_max;
1382 if ( rlp.rlim_max < requested_max )
1383 rlp.rlim_max = requested_max;
1385 /* This failing is not an error - many systems (Linux) don't
1386 support our default request of 10,000 open files. JRA. */
1388 if(setrlimit(RLIMIT_NOFILE, &rlp)) {
1389 DEBUG(3,("set_maxfiles: setrlimit for RLIMIT_NOFILE for %d max files failed with error %s\n",
1390 (int)rlp.rlim_max, strerror(errno) ));
1392 /* Set failed - restore original value from get. */
1393 rlp.rlim_max = orig_max;
1398 /* Now try setting the soft (current) limit. */
1400 saved_current_limit = rlp.rlim_cur = MIN(requested_max,rlp.rlim_max);
1402 if(setrlimit(RLIMIT_NOFILE, &rlp)) {
1403 DEBUG(0,("set_maxfiles: setrlimit for RLIMIT_NOFILE for %d files failed with error %s\n",
1404 (int)rlp.rlim_cur, strerror(errno) ));
1406 return saved_current_limit;
1409 if(getrlimit(RLIMIT_NOFILE, &rlp)) {
1410 DEBUG(0,("set_maxfiles: getrlimit (2) for RLIMIT_NOFILE failed with error %s\n",
1413 return saved_current_limit;
1416 #if defined(RLIM_INFINITY)
1417 if(rlp.rlim_cur == RLIM_INFINITY)
1418 return saved_current_limit;
1421 if((int)rlp.rlim_cur > saved_current_limit)
1422 return saved_current_limit;
1424 return rlp.rlim_cur;
1425 #else /* !defined(HAVE_GETRLIMIT) || !defined(RLIMIT_NOFILE) */
1427 * No way to know - just guess...
1429 return requested_max;
1433 /*****************************************************************
1434 malloc that aborts with smb_panic on fail or zero size.
1435 *****************************************************************/
1437 void *smb_xmalloc_array(size_t size, unsigned int count)
1441 smb_panic("smb_xmalloc_array: called with zero size");
1443 if (count >= MAX_ALLOC_SIZE/size) {
1444 smb_panic("smb_xmalloc_array: alloc size too large");
1446 if ((p = SMB_MALLOC(size*count)) == NULL) {
1447 DEBUG(0, ("smb_xmalloc_array failed to allocate %lu * %lu bytes\n",
1448 (unsigned long)size, (unsigned long)count));
1449 smb_panic("smb_xmalloc_array: malloc failed");
1455 vasprintf that aborts on malloc fail
1458 int smb_xvasprintf(char **ptr, const char *format, va_list ap)
1465 n = vasprintf(ptr, format, ap2);
1467 if (n == -1 || ! *ptr) {
1468 smb_panic("smb_xvasprintf: out of memory");
1473 /*****************************************************************
1474 Get local hostname and cache result.
1475 *****************************************************************/
1477 char *myhostname(void)
1481 ret = get_myname(NULL);
1486 /*****************************************************************
1487 Get local hostname and cache result.
1488 *****************************************************************/
1490 char *myhostname_upper(void)
1494 char *name = get_myname(NULL);
1498 ret = strupper_talloc(NULL, name);
1505 * @brief Returns an absolute path to a file concatenating the provided
1506 * @a rootpath and @a basename
1508 * @param name Filename, relative to @a rootpath
1510 * @retval Pointer to a string containing the full path.
1513 static char *xx_path(const char *name, const char *rootpath)
1517 fname = talloc_strdup(talloc_tos(), rootpath);
1521 trim_string(fname,"","/");
1523 if (!directory_exist(fname)) {
1524 if (mkdir(fname,0755) == -1) {
1525 /* Did someone else win the race ? */
1526 if (errno != EEXIST) {
1527 DEBUG(1, ("Unable to create directory %s for file %s. "
1528 "Error was %s\n", fname, name, strerror(errno)));
1534 return talloc_asprintf_append(fname, "/%s", name);
1538 * @brief Returns an absolute path to a file in the Samba lock directory.
1540 * @param name File to find, relative to LOCKDIR.
1542 * @retval Pointer to a talloc'ed string containing the full path.
1545 char *lock_path(const char *name)
1547 return xx_path(name, lp_lock_directory());
1551 * @brief Returns an absolute path to a file in the Samba state directory.
1553 * @param name File to find, relative to STATEDIR.
1555 * @retval Pointer to a talloc'ed string containing the full path.
1558 char *state_path(const char *name)
1560 return xx_path(name, lp_state_directory());
1564 * @brief Returns an absolute path to a file in the Samba cache directory.
1566 * @param name File to find, relative to CACHEDIR.
1568 * @retval Pointer to a talloc'ed string containing the full path.
1571 char *cache_path(const char *name)
1573 return xx_path(name, lp_cache_directory());
1576 /*******************************************************************
1577 Given a filename - get its directory name
1578 ********************************************************************/
1580 bool parent_dirname(TALLOC_CTX *mem_ctx, const char *dir, char **parent,
1586 p = strrchr_m(dir, '/'); /* Find final '/', if any */
1589 if (!(*parent = talloc_strdup(mem_ctx, "."))) {
1600 if (!(*parent = (char *)talloc_memdup(mem_ctx, dir, len+1))) {
1603 (*parent)[len] = '\0';
1611 /*******************************************************************
1612 Determine if a pattern contains any Microsoft wildcard characters.
1613 *******************************************************************/
1615 bool ms_has_wild(const char *s)
1619 if (lp_posix_pathnames()) {
1620 /* With posix pathnames no characters are wild. */
1624 while ((c = *s++)) {
1637 bool ms_has_wild_w(const smb_ucs2_t *s)
1640 if (!s) return False;
1641 while ((c = *s++)) {
1643 case UCS2_CHAR('*'):
1644 case UCS2_CHAR('?'):
1645 case UCS2_CHAR('<'):
1646 case UCS2_CHAR('>'):
1647 case UCS2_CHAR('"'):
1654 /*******************************************************************
1655 A wrapper that handles case sensitivity and the special handling
1657 *******************************************************************/
1659 bool mask_match(const char *string, const char *pattern, bool is_case_sensitive)
1661 if (ISDOTDOT(string))
1666 return ms_fnmatch(pattern, string, Protocol <= PROTOCOL_LANMAN2, is_case_sensitive) == 0;
1669 /*******************************************************************
1670 A wrapper that handles case sensitivity and the special handling
1671 of the ".." name. Varient that is only called by old search code which requires
1672 pattern translation.
1673 *******************************************************************/
1675 bool mask_match_search(const char *string, const char *pattern, bool is_case_sensitive)
1677 if (ISDOTDOT(string))
1682 return ms_fnmatch(pattern, string, True, is_case_sensitive) == 0;
1685 /*******************************************************************
1686 A wrapper that handles a list of patters and calls mask_match()
1687 on each. Returns True if any of the patterns match.
1688 *******************************************************************/
1690 bool mask_match_list(const char *string, char **list, int listLen, bool is_case_sensitive)
1692 while (listLen-- > 0) {
1693 if (mask_match(string, *list++, is_case_sensitive))
1699 /*********************************************************
1700 Recursive routine that is called by unix_wild_match.
1701 *********************************************************/
1703 static bool unix_do_match(const char *regexp, const char *str)
1707 for( p = regexp; *p && *str; ) {
1718 * Look for a character matching
1719 * the one after the '*'.
1723 return true; /* Automatic match */
1726 while(*str && (*p != *str))
1730 * Patch from weidel@multichart.de. In the case of the regexp
1731 * '*XX*' we want to ensure there are at least 2 'X' characters
1732 * in the string after the '*' for a match to be made.
1739 * Eat all the characters that match, but count how many there were.
1742 while(*str && (*p == *str)) {
1748 * Now check that if the regexp had n identical characters that
1749 * matchcount had at least that many matches.
1752 while ( *(p+1) && (*(p+1) == *p)) {
1757 if ( matchcount <= 0 )
1761 str--; /* We've eaten the match char after the '*' */
1763 if(unix_do_match(p, str))
1785 if (!*p && str[0] == '.' && str[1] == 0)
1788 if (!*str && *p == '?') {
1794 if(!*str && (*p == '*' && p[1] == '\0'))
1800 /*******************************************************************
1801 Simple case insensitive interface to a UNIX wildcard matcher.
1802 Returns True if match, False if not.
1803 *******************************************************************/
1805 bool unix_wild_match(const char *pattern, const char *string)
1807 TALLOC_CTX *ctx = talloc_stackframe();
1813 p2 = talloc_strdup(ctx,pattern);
1814 s2 = talloc_strdup(ctx,string);
1819 if (!strlower_m(p2)) {
1823 if (!strlower_m(s2)) {
1828 /* Remove any *? and ** from the pattern as they are meaningless */
1829 for(p = p2; *p; p++) {
1830 while( *p == '*' && (p[1] == '?' ||p[1] == '*')) {
1831 memmove(&p[1], &p[2], strlen(&p[2])+1);
1835 if (strequal(p2,"*")) {
1840 ret = unix_do_match(p2, s2);
1845 /**********************************************************************
1846 Converts a name to a fully qualified domain name.
1847 Returns true if lookup succeeded, false if not (then fqdn is set to name)
1848 Uses getaddrinfo() with AI_CANONNAME flag to obtain the official
1849 canonical name of the host. getaddrinfo() may use a variety of sources
1850 including /etc/hosts to obtain the domainname. It expects aliases in
1851 /etc/hosts to NOT be the FQDN. The FQDN should come first.
1852 ************************************************************************/
1854 bool name_to_fqdn(fstring fqdn, const char *name)
1857 struct addrinfo hints;
1858 struct addrinfo *result;
1861 /* Configure hints to obtain canonical name */
1863 memset(&hints, 0, sizeof(struct addrinfo));
1864 hints.ai_family = AF_UNSPEC; /* Allow IPv4 or IPv6 */
1865 hints.ai_socktype = SOCK_DGRAM; /* Datagram socket */
1866 hints.ai_flags = AI_CANONNAME; /* Get host's FQDN */
1867 hints.ai_protocol = 0; /* Any protocol */
1869 s = getaddrinfo(name, NULL, &hints, &result);
1871 DEBUG(1, ("getaddrinfo: %s\n", gai_strerror(s)));
1872 DEBUG(10,("name_to_fqdn: lookup for %s failed.\n", name));
1873 fstrcpy(fqdn, name);
1876 full = result->ai_canonname;
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 * getaddrinfo provides no easy way of handling aliases
1882 * in /etc/hosts. Users should make sure the FQDN
1883 * comes first in /etc/hosts. */
1884 if (full && (! strchr_m(full, '.'))) {
1885 DEBUG(1, ("WARNING: your /etc/hosts file may be broken!\n"));
1886 DEBUGADD(1, (" Full qualified domain names (FQDNs) should not be specified\n"));
1887 DEBUGADD(1, (" as an alias in /etc/hosts. FQDN should be the first name\n"));
1888 DEBUGADD(1, (" prior to any aliases.\n"));
1890 if (full && (strcasecmp_m(full, "localhost.localdomain") == 0)) {
1891 DEBUG(1, ("WARNING: your /etc/hosts file may be broken!\n"));
1892 DEBUGADD(1, (" Specifying 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"));
1897 DEBUG(10,("name_to_fqdn: lookup for %s -> %s.\n", name, full));
1898 fstrcpy(fqdn, full);
1899 freeaddrinfo(result); /* No longer needed */
1903 /**********************************************************************
1904 Append a DATA_BLOB to a talloc'ed object
1905 ***********************************************************************/
1907 void *talloc_append_blob(TALLOC_CTX *mem_ctx, void *buf, DATA_BLOB blob)
1909 size_t old_size = 0;
1912 if (blob.length == 0) {
1917 old_size = talloc_get_size(buf);
1920 result = (char *)TALLOC_REALLOC(mem_ctx, buf, old_size + blob.length);
1921 if (result == NULL) {
1925 memcpy(result + old_size, blob.data, blob.length);
1929 uint32_t map_share_mode_to_deny_mode(uint32_t share_access, uint32_t private_options)
1931 switch (share_access & ~FILE_SHARE_DELETE) {
1932 case FILE_SHARE_NONE:
1934 case FILE_SHARE_READ:
1936 case FILE_SHARE_WRITE:
1938 case FILE_SHARE_READ|FILE_SHARE_WRITE:
1941 if (private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS) {
1943 } else if (private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_FCB) {
1947 return (uint32_t)-1;
1950 pid_t procid_to_pid(const struct server_id *proc)
1955 static uint32_t my_vnn = NONCLUSTER_VNN;
1957 void set_my_vnn(uint32_t vnn)
1959 DEBUG(10, ("vnn pid %d = %u\n", (int)getpid(), (unsigned int)vnn));
1963 uint32_t get_my_vnn(void)
1968 static uint64_t my_unique_id = 0;
1970 void set_my_unique_id(uint64_t unique_id)
1972 my_unique_id = unique_id;
1975 struct server_id pid_to_procid(pid_t pid)
1977 struct server_id result;
1980 result.unique_id = my_unique_id;
1981 result.vnn = my_vnn;
1985 struct server_id procid_self(void)
1987 return pid_to_procid(getpid());
1990 bool procid_is_me(const struct server_id *pid)
1992 if (pid->pid != getpid())
1994 if (pid->task_id != 0)
1996 if (pid->vnn != my_vnn)
2001 struct server_id interpret_pid(const char *pid_string)
2003 return server_id_from_string(get_my_vnn(), pid_string);
2006 bool procid_valid(const struct server_id *pid)
2008 return (pid->pid != (uint64_t)-1);
2011 bool procid_is_local(const struct server_id *pid)
2013 return pid->vnn == my_vnn;
2016 /****************************************************************
2017 Check if an offset into a buffer is safe.
2018 If this returns True it's safe to indirect into the byte at
2020 ****************************************************************/
2022 bool is_offset_safe(const char *buf_base, size_t buf_len, char *ptr, size_t off)
2024 const char *end_base = buf_base + buf_len;
2025 char *end_ptr = ptr + off;
2027 if (!buf_base || !ptr) {
2031 if (end_base < buf_base || end_ptr < ptr) {
2032 return False; /* wrap. */
2035 if (end_ptr < end_base) {
2041 /****************************************************************
2042 Return a safe pointer into a buffer, or NULL.
2043 ****************************************************************/
2045 char *get_safe_ptr(const char *buf_base, size_t buf_len, char *ptr, size_t off)
2047 return is_offset_safe(buf_base, buf_len, ptr, off) ?
2051 /****************************************************************
2052 Return a safe pointer into a string within a buffer, or NULL.
2053 ****************************************************************/
2055 char *get_safe_str_ptr(const char *buf_base, size_t buf_len, char *ptr, size_t off)
2057 if (!is_offset_safe(buf_base, buf_len, ptr, off)) {
2060 /* Check if a valid string exists at this offset. */
2061 if (skip_string(buf_base,buf_len, ptr + off) == NULL) {
2067 /****************************************************************
2068 Return an SVAL at a pointer, or failval if beyond the end.
2069 ****************************************************************/
2071 int get_safe_SVAL(const char *buf_base, size_t buf_len, char *ptr, size_t off, int failval)
2074 * Note we use off+1 here, not off+2 as SVAL accesses ptr[0] and ptr[1],
2077 if (!is_offset_safe(buf_base, buf_len, ptr, off+1)) {
2080 return SVAL(ptr,off);
2083 /****************************************************************
2084 Return an IVAL at a pointer, or failval if beyond the end.
2085 ****************************************************************/
2087 int get_safe_IVAL(const char *buf_base, size_t buf_len, char *ptr, size_t off, int failval)
2090 * Note we use off+3 here, not off+4 as IVAL accesses
2091 * ptr[0] ptr[1] ptr[2] ptr[3] NOT ptr[4].
2093 if (!is_offset_safe(buf_base, buf_len, ptr, off+3)) {
2096 return IVAL(ptr,off);
2099 /****************************************************************
2100 Split DOM\user into DOM and user. Do not mix with winbind variants of that
2101 call (they take care of winbind separator and other winbind specific settings).
2102 ****************************************************************/
2104 void split_domain_user(TALLOC_CTX *mem_ctx,
2105 const char *full_name,
2109 const char *p = NULL;
2111 p = strchr_m(full_name, '\\');
2114 *domain = talloc_strndup(mem_ctx, full_name,
2115 PTR_DIFF(p, full_name));
2116 *user = talloc_strdup(mem_ctx, p+1);
2118 *domain = talloc_strdup(mem_ctx, "");
2119 *user = talloc_strdup(mem_ctx, full_name);
2123 /****************************************************************
2124 strip off leading '\\' from a hostname
2125 ****************************************************************/
2127 const char *strip_hostname(const char *s)
2133 if (strlen_m(s) < 3) {
2137 if (s[0] == '\\') s++;
2138 if (s[0] == '\\') s++;
2143 bool any_nt_status_not_ok(NTSTATUS err1, NTSTATUS err2, NTSTATUS *result)
2145 if (!NT_STATUS_IS_OK(err1)) {
2149 if (!NT_STATUS_IS_OK(err2)) {
2156 int timeval_to_msec(struct timeval t)
2158 return t.tv_sec * 1000 + (t.tv_usec+999) / 1000;
2161 /*******************************************************************
2162 Check a given DOS pathname is valid for a share.
2163 ********************************************************************/
2165 char *valid_share_pathname(TALLOC_CTX *ctx, const char *dos_pathname)
2169 if (!dos_pathname) {
2173 ptr = talloc_strdup(ctx, dos_pathname);
2177 /* Convert any '\' paths to '/' */
2179 ptr = unix_clean_name(ctx, ptr);
2184 /* NT is braindead - it wants a C: prefix to a pathname ! So strip it. */
2185 if (strlen(ptr) > 2 && ptr[1] == ':' && ptr[0] != '/')
2188 /* Only absolute paths allowed. */
2195 /*******************************************************************
2196 Return True if the filename is one of the special executable types.
2197 ********************************************************************/
2199 bool is_executable(const char *fname)
2201 if ((fname = strrchr_m(fname,'.'))) {
2202 if (strequal(fname,".com") ||
2203 strequal(fname,".dll") ||
2204 strequal(fname,".exe") ||
2205 strequal(fname,".sym")) {
2212 /****************************************************************************
2213 Open a file with a share mode - old openX method - map into NTCreate.
2214 ****************************************************************************/
2216 bool map_open_params_to_ntcreate(const char *smb_base_fname,
2217 int deny_mode, int open_func,
2218 uint32_t *paccess_mask,
2219 uint32_t *pshare_mode,
2220 uint32_t *pcreate_disposition,
2221 uint32_t *pcreate_options,
2222 uint32_t *pprivate_flags)
2224 uint32_t access_mask;
2225 uint32_t share_mode;
2226 uint32_t create_disposition;
2227 uint32_t create_options = FILE_NON_DIRECTORY_FILE;
2228 uint32_t private_flags = 0;
2230 DEBUG(10,("map_open_params_to_ntcreate: fname = %s, deny_mode = 0x%x, "
2231 "open_func = 0x%x\n",
2232 smb_base_fname, (unsigned int)deny_mode,
2233 (unsigned int)open_func ));
2235 /* Create the NT compatible access_mask. */
2236 switch (GET_OPENX_MODE(deny_mode)) {
2237 case DOS_OPEN_EXEC: /* Implies read-only - used to be FILE_READ_DATA */
2238 case DOS_OPEN_RDONLY:
2239 access_mask = FILE_GENERIC_READ;
2241 case DOS_OPEN_WRONLY:
2242 access_mask = FILE_GENERIC_WRITE;
2246 access_mask = FILE_GENERIC_READ|FILE_GENERIC_WRITE;
2249 DEBUG(10,("map_open_params_to_ntcreate: bad open mode = 0x%x\n",
2250 (unsigned int)GET_OPENX_MODE(deny_mode)));
2254 /* Create the NT compatible create_disposition. */
2255 switch (open_func) {
2256 case OPENX_FILE_EXISTS_FAIL|OPENX_FILE_CREATE_IF_NOT_EXIST:
2257 create_disposition = FILE_CREATE;
2260 case OPENX_FILE_EXISTS_OPEN:
2261 create_disposition = FILE_OPEN;
2264 case OPENX_FILE_EXISTS_OPEN|OPENX_FILE_CREATE_IF_NOT_EXIST:
2265 create_disposition = FILE_OPEN_IF;
2268 case OPENX_FILE_EXISTS_TRUNCATE:
2269 create_disposition = FILE_OVERWRITE;
2272 case OPENX_FILE_EXISTS_TRUNCATE|OPENX_FILE_CREATE_IF_NOT_EXIST:
2273 create_disposition = FILE_OVERWRITE_IF;
2277 /* From samba4 - to be confirmed. */
2278 if (GET_OPENX_MODE(deny_mode) == DOS_OPEN_EXEC) {
2279 create_disposition = FILE_CREATE;
2282 DEBUG(10,("map_open_params_to_ntcreate: bad "
2283 "open_func 0x%x\n", (unsigned int)open_func));
2287 /* Create the NT compatible share modes. */
2288 switch (GET_DENY_MODE(deny_mode)) {
2290 share_mode = FILE_SHARE_NONE;
2294 share_mode = FILE_SHARE_READ;
2298 share_mode = FILE_SHARE_WRITE;
2302 share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
2306 private_flags |= NTCREATEX_OPTIONS_PRIVATE_DENY_DOS;
2307 if (is_executable(smb_base_fname)) {
2308 share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
2310 if (GET_OPENX_MODE(deny_mode) == DOS_OPEN_RDONLY) {
2311 share_mode = FILE_SHARE_READ;
2313 share_mode = FILE_SHARE_NONE;
2319 private_flags |= NTCREATEX_OPTIONS_PRIVATE_DENY_FCB;
2320 share_mode = FILE_SHARE_NONE;
2324 DEBUG(10,("map_open_params_to_ntcreate: bad deny_mode 0x%x\n",
2325 (unsigned int)GET_DENY_MODE(deny_mode) ));
2329 DEBUG(10,("map_open_params_to_ntcreate: file %s, access_mask = 0x%x, "
2330 "share_mode = 0x%x, create_disposition = 0x%x, "
2331 "create_options = 0x%x private_flags = 0x%x\n",
2333 (unsigned int)access_mask,
2334 (unsigned int)share_mode,
2335 (unsigned int)create_disposition,
2336 (unsigned int)create_options,
2337 (unsigned int)private_flags));
2340 *paccess_mask = access_mask;
2343 *pshare_mode = share_mode;
2345 if (pcreate_disposition) {
2346 *pcreate_disposition = create_disposition;
2348 if (pcreate_options) {
2349 *pcreate_options = create_options;
2351 if (pprivate_flags) {
2352 *pprivate_flags = private_flags;
2359 /*************************************************************************
2360 Return a talloced copy of a struct security_unix_token. NULL on fail.
2361 *************************************************************************/
2363 struct security_unix_token *copy_unix_token(TALLOC_CTX *ctx, const struct security_unix_token *tok)
2365 struct security_unix_token *cpy;
2367 cpy = talloc(ctx, struct security_unix_token);
2372 cpy->uid = tok->uid;
2373 cpy->gid = tok->gid;
2374 cpy->ngroups = tok->ngroups;
2376 /* Make this a talloc child of cpy. */
2377 cpy->groups = (gid_t *)talloc_memdup(
2378 cpy, tok->groups, tok->ngroups * sizeof(gid_t));
2389 /****************************************************************************
2390 Check that a file matches a particular file type.
2391 ****************************************************************************/
2393 bool dir_check_ftype(uint32_t mode, uint32_t dirtype)
2397 /* Check the "may have" search bits. */
2398 if (((mode & ~dirtype) &
2399 (FILE_ATTRIBUTE_HIDDEN |
2400 FILE_ATTRIBUTE_SYSTEM |
2401 FILE_ATTRIBUTE_DIRECTORY)) != 0) {
2405 /* Check the "must have" bits,
2406 which are the may have bits shifted eight */
2407 /* If must have bit is set, the file/dir can
2408 not be returned in search unless the matching
2409 file attribute is set */
2410 mask = ((dirtype >> 8) & (FILE_ATTRIBUTE_DIRECTORY|
2411 FILE_ATTRIBUTE_ARCHIVE|
2412 FILE_ATTRIBUTE_READONLY|
2413 FILE_ATTRIBUTE_HIDDEN|
2414 FILE_ATTRIBUTE_SYSTEM)); /* & 0x37 */
2416 if((mask & (mode & (FILE_ATTRIBUTE_DIRECTORY|
2417 FILE_ATTRIBUTE_ARCHIVE|
2418 FILE_ATTRIBUTE_READONLY|
2419 FILE_ATTRIBUTE_HIDDEN|
2420 FILE_ATTRIBUTE_SYSTEM))) == mask) {
2421 /* check if matching attribute present */