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"
32 /* Max allowable allococation - 256mb - 0x10000000 */
33 #define MAX_ALLOC_SIZE (1024*1024*256)
35 #if (defined(HAVE_NETGROUP) && defined (WITH_AUTOMOUNT))
36 #ifdef WITH_NISPLUS_HOME
37 #ifdef BROKEN_NISPLUS_INCLUDE_FILES
39 * The following lines are needed due to buggy include files
40 * in Solaris 2.6 which define GROUP in both /usr/include/sys/acl.h and
41 * also in /usr/include/rpcsvc/nis.h. The definitions conflict. JRA.
42 * Also GROUP_OBJ is defined as 0x4 in /usr/include/sys/acl.h and as
43 * an enum in /usr/include/rpcsvc/nis.h.
50 #if defined(GROUP_OBJ)
54 #endif /* BROKEN_NISPLUS_INCLUDE_FILES */
56 #include <rpcsvc/nis.h>
58 #endif /* WITH_NISPLUS_HOME */
59 #endif /* HAVE_NETGROUP && WITH_AUTOMOUNT */
61 static enum protocol_types Protocol = PROTOCOL_COREPLUS;
63 enum protocol_types get_Protocol(void)
68 void set_Protocol(enum protocol_types p)
73 static enum remote_arch_types ra_type = RA_UNKNOWN;
75 void gfree_all( void )
84 /*******************************************************************
85 Check if a file exists - call vfs_file_exist for samba files.
86 ********************************************************************/
88 bool file_exist_stat(const char *fname,SMB_STRUCT_STAT *sbuf,
89 bool fake_dir_create_times)
95 if (sys_stat(fname, sbuf, fake_dir_create_times) != 0)
98 return((S_ISREG(sbuf->st_ex_mode)) || (S_ISFIFO(sbuf->st_ex_mode)));
101 /*******************************************************************
102 Check if a unix domain socket exists - call vfs_file_exist for samba files.
103 ********************************************************************/
105 bool socket_exist(const char *fname)
108 if (sys_stat(fname, &st, false) != 0)
111 return S_ISSOCK(st.st_ex_mode);
114 /*******************************************************************
115 Returns the size in bytes of the named given the stat struct.
116 ********************************************************************/
118 uint64_t get_file_size_stat(const SMB_STRUCT_STAT *sbuf)
120 return sbuf->st_ex_size;
123 /*******************************************************************
124 Returns the size in bytes of the named file.
125 ********************************************************************/
127 SMB_OFF_T get_file_size(char *file_name)
131 if (sys_stat(file_name, &buf, false) != 0)
132 return (SMB_OFF_T)-1;
133 return get_file_size_stat(&buf);
136 /*******************************************************************
137 Show a smb message structure.
138 ********************************************************************/
140 void show_msg(const char *buf)
148 DEBUG(5,("size=%d\nsmb_com=0x%x\nsmb_rcls=%d\nsmb_reh=%d\nsmb_err=%d\nsmb_flg=%d\nsmb_flg2=%d\n",
150 (int)CVAL(buf,smb_com),
151 (int)CVAL(buf,smb_rcls),
152 (int)CVAL(buf,smb_reh),
153 (int)SVAL(buf,smb_err),
154 (int)CVAL(buf,smb_flg),
155 (int)SVAL(buf,smb_flg2)));
156 DEBUGADD(5,("smb_tid=%d\nsmb_pid=%d\nsmb_uid=%d\nsmb_mid=%d\n",
157 (int)SVAL(buf,smb_tid),
158 (int)SVAL(buf,smb_pid),
159 (int)SVAL(buf,smb_uid),
160 (int)SVAL(buf,smb_mid)));
161 DEBUGADD(5,("smt_wct=%d\n",(int)CVAL(buf,smb_wct)));
163 for (i=0;i<(int)CVAL(buf,smb_wct);i++)
164 DEBUGADD(5,("smb_vwv[%2d]=%5d (0x%X)\n",i,
165 SVAL(buf,smb_vwv+2*i),SVAL(buf,smb_vwv+2*i)));
167 bcc = (int)SVAL(buf,smb_vwv+2*(CVAL(buf,smb_wct)));
169 DEBUGADD(5,("smb_bcc=%d\n",bcc));
177 dump_data(10, (const uint8 *)smb_buf_const(buf), bcc);
180 /*******************************************************************
181 Set the length and marker of an encrypted smb packet.
182 ********************************************************************/
184 void smb_set_enclen(char *buf,int len,uint16 enc_ctx_num)
186 _smb_setlen(buf,len);
190 SSVAL(buf,6,enc_ctx_num);
193 /*******************************************************************
194 Set the length and marker of an smb packet.
195 ********************************************************************/
197 void smb_setlen(char *buf,int len)
199 _smb_setlen(buf,len);
207 /*******************************************************************
208 Setup only the byte count for a smb message.
209 ********************************************************************/
211 int set_message_bcc(char *buf,int num_bytes)
213 int num_words = CVAL(buf,smb_wct);
214 SSVAL(buf,smb_vwv + num_words*SIZEOFWORD,num_bytes);
215 _smb_setlen(buf,smb_size + num_words*2 + num_bytes - 4);
216 return (smb_size + num_words*2 + num_bytes);
219 /*******************************************************************
220 Add a data blob to the end of a smb_buf, adjusting bcc and smb_len.
221 Return the bytes added
222 ********************************************************************/
224 ssize_t message_push_blob(uint8 **outbuf, DATA_BLOB blob)
226 size_t newlen = smb_len(*outbuf) + 4 + blob.length;
229 if (!(tmp = TALLOC_REALLOC_ARRAY(NULL, *outbuf, uint8, newlen))) {
230 DEBUG(0, ("talloc failed\n"));
235 memcpy(tmp + smb_len(tmp) + 4, blob.data, blob.length);
236 set_message_bcc((char *)tmp, smb_buflen(tmp) + blob.length);
240 /*******************************************************************
241 Reduce a file name, removing .. elements.
242 ********************************************************************/
244 static char *dos_clean_name(TALLOC_CTX *ctx, const char *s)
249 DEBUG(3,("dos_clean_name [%s]\n",s));
251 /* remove any double slashes */
252 str = talloc_all_string_sub(ctx, s, "\\\\", "\\");
257 /* Remove leading .\\ characters */
258 if(strncmp(str, ".\\", 2) == 0) {
259 trim_string(str, ".\\", NULL);
261 str = talloc_strdup(ctx, ".\\");
268 while ((p = strstr_m(str,"\\..\\")) != NULL) {
274 if ((p=strrchr_m(str,'\\')) != NULL) {
279 str = talloc_asprintf(ctx,
288 trim_string(str,NULL,"\\..");
289 return talloc_all_string_sub(ctx, str, "\\.\\", "\\");
292 /*******************************************************************
293 Reduce a file name, removing .. elements.
294 ********************************************************************/
296 char *unix_clean_name(TALLOC_CTX *ctx, const char *s)
301 DEBUG(3,("unix_clean_name [%s]\n",s));
303 /* remove any double slashes */
304 str = talloc_all_string_sub(ctx, s, "//","/");
309 /* Remove leading ./ characters */
310 if(strncmp(str, "./", 2) == 0) {
311 trim_string(str, "./", NULL);
313 str = talloc_strdup(ctx, "./");
320 while ((p = strstr_m(str,"/../")) != NULL) {
326 if ((p=strrchr_m(str,'/')) != NULL) {
331 str = talloc_asprintf(ctx,
340 trim_string(str,NULL,"/..");
341 return talloc_all_string_sub(ctx, str, "/./", "/");
344 char *clean_name(TALLOC_CTX *ctx, const char *s)
346 char *str = dos_clean_name(ctx, s);
350 return unix_clean_name(ctx, str);
353 /*******************************************************************
354 Write data into an fd at a given offset. Ignore seek errors.
355 ********************************************************************/
357 ssize_t write_data_at_offset(int fd, const char *buffer, size_t N, SMB_OFF_T pos)
362 if (pos == (SMB_OFF_T)-1) {
363 return write_data(fd, buffer, N);
365 #if defined(HAVE_PWRITE) || defined(HAVE_PRWITE64)
367 ret = sys_pwrite(fd,buffer + total,N - total, pos);
368 if (ret == -1 && errno == ESPIPE) {
369 return write_data(fd, buffer + total,N - total);
372 DEBUG(0,("write_data_at_offset: write failure. Error = %s\n", strerror(errno) ));
381 return (ssize_t)total;
383 /* Use lseek and write_data. */
384 if (sys_lseek(fd, pos, SEEK_SET) == -1) {
385 if (errno != ESPIPE) {
389 return write_data(fd, buffer, N);
394 NTSTATUS reinit_after_fork(struct messaging_context *msg_ctx,
395 struct event_context *ev_ctx,
397 bool parent_longlived)
399 NTSTATUS status = NT_STATUS_OK;
401 /* Reset the state of the random
402 * number generation system, so
403 * children do not get the same random
404 * numbers as each other */
405 set_need_random_reseed();
407 /* tdb needs special fork handling */
408 if (tdb_reopen_all(parent_longlived ? 1 : 0) == -1) {
409 DEBUG(0,("tdb_reopen_all failed.\n"));
410 status = NT_STATUS_OPEN_FAILED;
414 if (ev_ctx && tevent_re_initialise(ev_ctx) != 0) {
415 smb_panic(__location__ ": Failed to re-initialise event context");
420 * For clustering, we need to re-init our ctdbd connection after the
423 status = messaging_reinit(msg_ctx, id);
424 if (!NT_STATUS_IS_OK(status)) {
425 DEBUG(0,("messaging_reinit() failed: %s\n",
433 /****************************************************************************
434 (Hopefully) efficient array append.
435 ****************************************************************************/
437 void add_to_large_array(TALLOC_CTX *mem_ctx, size_t element_size,
438 void *element, void *_array, uint32 *num_elements,
441 void **array = (void **)_array;
443 if (*array_size < 0) {
447 if (*array == NULL) {
448 if (*array_size == 0) {
452 if (*array_size >= MAX_ALLOC_SIZE/element_size) {
456 *array = TALLOC(mem_ctx, element_size * (*array_size));
457 if (*array == NULL) {
462 if (*num_elements == *array_size) {
465 if (*array_size >= MAX_ALLOC_SIZE/element_size) {
469 *array = TALLOC_REALLOC(mem_ctx, *array,
470 element_size * (*array_size));
472 if (*array == NULL) {
477 memcpy((char *)(*array) + element_size*(*num_elements),
478 element, element_size);
488 /****************************************************************************
489 Get my own domain name, or "" if we have none.
490 ****************************************************************************/
492 char *get_mydnsdomname(TALLOC_CTX *ctx)
497 domname = get_mydnsfullname();
502 p = strchr_m(domname, '.');
505 return talloc_strdup(ctx, p);
507 return talloc_strdup(ctx, "");
511 /****************************************************************************
512 Interpret a protocol description string, with a default.
513 ****************************************************************************/
515 int interpret_protocol(const char *str,int def)
517 if (strequal(str,"NT1"))
518 return(PROTOCOL_NT1);
519 if (strequal(str,"LANMAN2"))
520 return(PROTOCOL_LANMAN2);
521 if (strequal(str,"LANMAN1"))
522 return(PROTOCOL_LANMAN1);
523 if (strequal(str,"CORE"))
524 return(PROTOCOL_CORE);
525 if (strequal(str,"COREPLUS"))
526 return(PROTOCOL_COREPLUS);
527 if (strequal(str,"CORE+"))
528 return(PROTOCOL_COREPLUS);
530 DEBUG(0,("Unrecognised protocol level %s\n",str));
536 #if (defined(HAVE_NETGROUP) && defined(WITH_AUTOMOUNT))
537 /******************************************************************
538 Remove any mount options such as -rsize=2048,wsize=2048 etc.
539 Based on a fix from <Thomas.Hepper@icem.de>.
540 Returns a malloc'ed string.
541 *******************************************************************/
543 static char *strip_mount_options(TALLOC_CTX *ctx, const char *str)
547 while(*p && !isspace(*p))
549 while(*p && isspace(*p))
552 return talloc_strdup(ctx, p);
558 /*******************************************************************
559 Patch from jkf@soton.ac.uk
560 Split Luke's automount_server into YP lookup and string splitter
561 so can easily implement automount_path().
562 Returns a malloc'ed string.
563 *******************************************************************/
565 #ifdef WITH_NISPLUS_HOME
566 char *automount_lookup(TALLOC_CTX *ctx, const char *user_name)
570 char *nis_map = (char *)lp_nis_home_map_name();
572 char buffer[NIS_MAXATTRVAL + 1];
577 snprintf(buffer, sizeof(buffer), "[key=%s],%s", user_name, nis_map);
578 DEBUG(5, ("NIS+ querystring: %s\n", buffer));
580 if (result = nis_list(buffer, FOLLOW_PATH|EXPAND_NAME|HARD_LOOKUP, NULL, NULL)) {
581 if (result->status != NIS_SUCCESS) {
582 DEBUG(3, ("NIS+ query failed: %s\n", nis_sperrno(result->status)));
584 object = result->objects.objects_val;
585 if (object->zo_data.zo_type == ENTRY_OBJ) {
586 entry = &object->zo_data.objdata_u.en_data;
587 DEBUG(5, ("NIS+ entry type: %s\n", entry->en_type));
588 DEBUG(3, ("NIS+ result: %s\n", entry->en_cols.en_cols_val[1].ec_value.ec_value_val));
590 value = talloc_strdup(ctx,
591 entry->en_cols.en_cols_val[1].ec_value.ec_value_val);
593 nis_freeresult(result);
596 value = talloc_string_sub(ctx,
603 nis_freeresult(result);
606 value = strip_mount_options(ctx, value);
607 DEBUG(4, ("NIS+ Lookup: %s resulted in %s\n",
612 #else /* WITH_NISPLUS_HOME */
614 char *automount_lookup(TALLOC_CTX *ctx, const char *user_name)
618 int nis_error; /* returned by yp all functions */
619 char *nis_result; /* yp_match inits this */
620 int nis_result_len; /* and set this */
621 char *nis_domain; /* yp_get_default_domain inits this */
622 char *nis_map = (char *)lp_nis_home_map_name();
624 if ((nis_error = yp_get_default_domain(&nis_domain)) != 0) {
625 DEBUG(3, ("YP Error: %s\n", yperr_string(nis_error)));
629 DEBUG(5, ("NIS Domain: %s\n", nis_domain));
631 if ((nis_error = yp_match(nis_domain, nis_map, user_name,
632 strlen(user_name), &nis_result,
633 &nis_result_len)) == 0) {
634 if (nis_result_len > 0 && nis_result[nis_result_len] == '\n') {
635 nis_result[nis_result_len] = '\0';
637 value = talloc_strdup(ctx, nis_result);
641 value = strip_mount_options(ctx, value);
642 } else if(nis_error == YPERR_KEY) {
643 DEBUG(3, ("YP Key not found: while looking up \"%s\" in map \"%s\"\n",
644 user_name, nis_map));
645 DEBUG(3, ("using defaults for server and home directory\n"));
647 DEBUG(3, ("YP Error: \"%s\" while looking up \"%s\" in map \"%s\"\n",
648 yperr_string(nis_error), user_name, nis_map));
652 DEBUG(4, ("YP Lookup: %s resulted in %s\n", user_name, value));
656 #endif /* WITH_NISPLUS_HOME */
659 /****************************************************************************
660 Check if a process exists. Does this work on all unixes?
661 ****************************************************************************/
663 bool process_exists(const struct server_id pid)
665 if (procid_is_me(&pid)) {
669 if (procid_is_local(&pid)) {
670 return (kill(pid.pid,0) == 0 || errno != ESRCH);
673 #ifdef CLUSTER_SUPPORT
674 return ctdbd_process_exists(messaging_ctdbd_connection(),
681 /*******************************************************************
682 Convert a uid into a user name.
683 ********************************************************************/
685 const char *uidtoname(uid_t uid)
687 TALLOC_CTX *ctx = talloc_tos();
689 struct passwd *pass = NULL;
691 pass = getpwuid_alloc(ctx,uid);
693 name = talloc_strdup(ctx,pass->pw_name);
696 name = talloc_asprintf(ctx,
703 /*******************************************************************
704 Convert a gid into a group name.
705 ********************************************************************/
707 char *gidtoname(gid_t gid)
713 return talloc_strdup(talloc_tos(), grp->gr_name);
716 return talloc_asprintf(talloc_tos(),
722 /*******************************************************************
723 Convert a user name into a uid.
724 ********************************************************************/
726 uid_t nametouid(const char *name)
732 pass = Get_Pwnam_alloc(talloc_tos(), name);
739 u = (uid_t)strtol(name, &p, 0);
740 if ((p != name) && (*p == '\0'))
746 /*******************************************************************
747 Convert a name to a gid_t if possible. Return -1 if not a group.
748 ********************************************************************/
750 gid_t nametogid(const char *name)
756 g = (gid_t)strtol(name, &p, 0);
757 if ((p != name) && (*p == '\0'))
760 grp = sys_getgrnam(name);
766 /*******************************************************************
767 Something really nasty happened - panic !
768 ********************************************************************/
770 void smb_panic_s3(const char *why)
775 DEBUG(0,("PANIC (pid %llu): %s\n",
776 (unsigned long long)sys_getpid(), why));
779 cmd = lp_panic_action();
781 DEBUG(0, ("smb_panic(): calling panic action [%s]\n", cmd));
782 result = system(cmd);
785 DEBUG(0, ("smb_panic(): fork failed in panic action: %s\n",
788 DEBUG(0, ("smb_panic(): action returned status %d\n",
789 WEXITSTATUS(result)));
795 /*******************************************************************
796 Print a backtrace of the stack to the debug log. This function
797 DELIBERATELY LEAKS MEMORY. The expectation is that you should
798 exit shortly after calling it.
799 ********************************************************************/
801 #ifdef HAVE_LIBUNWIND_H
802 #include <libunwind.h>
805 #ifdef HAVE_EXECINFO_H
806 #include <execinfo.h>
813 void log_stack_trace(void)
815 #ifdef HAVE_LIBUNWIND
816 /* Try to use libunwind before any other technique since on ia64
817 * libunwind correctly walks the stack in more circumstances than
825 unw_word_t ip, sp, off;
827 procname[sizeof(procname) - 1] = '\0';
829 if (unw_getcontext(&uc) != 0) {
830 goto libunwind_failed;
833 if (unw_init_local(&cursor, &uc) != 0) {
834 goto libunwind_failed;
837 DEBUG(0, ("BACKTRACE:\n"));
841 unw_get_reg(&cursor, UNW_REG_IP, &ip);
842 unw_get_reg(&cursor, UNW_REG_SP, &sp);
844 switch (unw_get_proc_name(&cursor,
845 procname, sizeof(procname) - 1, &off) ) {
849 /* Name truncated. */
850 DEBUGADD(0, (" #%u %s + %#llx [ip=%#llx] [sp=%#llx]\n",
851 i, procname, (long long)off,
852 (long long)ip, (long long) sp));
855 /* case -UNW_ENOINFO: */
856 /* case -UNW_EUNSPEC: */
857 /* No symbol name found. */
858 DEBUGADD(0, (" #%u %s [ip=%#llx] [sp=%#llx]\n",
859 i, "<unknown symbol>",
860 (long long)ip, (long long) sp));
863 } while (unw_step(&cursor) > 0);
868 DEBUG(0, ("unable to produce a stack trace with libunwind\n"));
870 #elif HAVE_BACKTRACE_SYMBOLS
871 void *backtrace_stack[BACKTRACE_STACK_SIZE];
872 size_t backtrace_size;
873 char **backtrace_strings;
875 /* get the backtrace (stack frames) */
876 backtrace_size = backtrace(backtrace_stack,BACKTRACE_STACK_SIZE);
877 backtrace_strings = backtrace_symbols(backtrace_stack, backtrace_size);
879 DEBUG(0, ("BACKTRACE: %lu stack frames:\n",
880 (unsigned long)backtrace_size));
882 if (backtrace_strings) {
885 for (i = 0; i < backtrace_size; i++)
886 DEBUGADD(0, (" #%u %s\n", i, backtrace_strings[i]));
888 /* Leak the backtrace_strings, rather than risk what free() might do */
893 /* The IRIX libexc library provides an API for unwinding the stack. See
894 * libexc(3) for details. Apparantly trace_back_stack leaks memory, but
895 * since we are about to abort anyway, it hardly matters.
898 #define NAMESIZE 32 /* Arbitrary */
900 __uint64_t addrs[BACKTRACE_STACK_SIZE];
901 char * names[BACKTRACE_STACK_SIZE];
902 char namebuf[BACKTRACE_STACK_SIZE * NAMESIZE];
911 /* We need to be root so we can open our /proc entry to walk
912 * our stack. It also helps when we want to dump core.
916 for (i = 0; i < BACKTRACE_STACK_SIZE; i++) {
917 names[i] = namebuf + (i * NAMESIZE);
920 levels = trace_back_stack(0, addrs, names,
921 BACKTRACE_STACK_SIZE, NAMESIZE - 1);
923 DEBUG(0, ("BACKTRACE: %d stack frames:\n", levels));
924 for (i = 0; i < levels; i++) {
925 DEBUGADD(0, (" #%d 0x%llx %s\n", i, addrs[i], names[i]));
930 DEBUG(0, ("unable to produce a stack trace on this platform\n"));
934 /*******************************************************************
935 A readdir wrapper which just returns the file name.
936 ********************************************************************/
938 const char *readdirname(SMB_STRUCT_DIR *p)
940 SMB_STRUCT_DIRENT *ptr;
946 ptr = (SMB_STRUCT_DIRENT *)sys_readdir(p);
957 #ifdef HAVE_BROKEN_READDIR_NAME
958 /* using /usr/ucb/cc is BAD */
962 return talloc_strdup(talloc_tos(), dname);
965 /*******************************************************************
966 Utility function used to decide if the last component
967 of a path matches a (possibly wildcarded) entry in a namelist.
968 ********************************************************************/
970 bool is_in_path(const char *name, name_compare_entry *namelist, bool case_sensitive)
972 const char *last_component;
974 /* if we have no list it's obviously not in the path */
975 if((namelist == NULL ) || ((namelist != NULL) && (namelist[0].name == NULL))) {
979 DEBUG(8, ("is_in_path: %s\n", name));
981 /* Get the last component of the unix name. */
982 last_component = strrchr_m(name, '/');
983 if (!last_component) {
984 last_component = name;
986 last_component++; /* Go past '/' */
989 for(; namelist->name != NULL; namelist++) {
990 if(namelist->is_wild) {
991 if (mask_match(last_component, namelist->name, case_sensitive)) {
992 DEBUG(8,("is_in_path: mask match succeeded\n"));
996 if((case_sensitive && (strcmp(last_component, namelist->name) == 0))||
997 (!case_sensitive && (strcasecmp_m(last_component, namelist->name) == 0))) {
998 DEBUG(8,("is_in_path: match succeeded\n"));
1003 DEBUG(8,("is_in_path: match not found\n"));
1007 /*******************************************************************
1008 Strip a '/' separated list into an array of
1009 name_compare_enties structures suitable for
1010 passing to is_in_path(). We do this for
1011 speed so we can pre-parse all the names in the list
1012 and don't do it for each call to is_in_path().
1013 We also check if the entry contains a wildcard to
1014 remove a potentially expensive call to mask_match
1016 ********************************************************************/
1018 void set_namearray(name_compare_entry **ppname_array, const char *namelist_in)
1023 int num_entries = 0;
1026 (*ppname_array) = NULL;
1028 if((namelist_in == NULL ) || ((namelist_in != NULL) && (*namelist_in == '\0')))
1031 namelist = talloc_strdup(talloc_tos(), namelist_in);
1032 if (namelist == NULL) {
1033 DEBUG(0,("set_namearray: talloc fail\n"));
1038 /* We need to make two passes over the string. The
1039 first to count the number of elements, the second
1044 if ( *nameptr == '/' ) {
1045 /* cope with multiple (useless) /s) */
1049 /* anything left? */
1050 if ( *nameptr == '\0' )
1053 /* find the next '/' or consume remaining */
1054 name_end = strchr_m(nameptr, '/');
1055 if (name_end == NULL)
1056 name_end = (char *)nameptr + strlen(nameptr);
1058 /* next segment please */
1059 nameptr = name_end + 1;
1063 if(num_entries == 0) {
1064 talloc_free(namelist);
1068 if(( (*ppname_array) = SMB_MALLOC_ARRAY(name_compare_entry, num_entries + 1)) == NULL) {
1069 DEBUG(0,("set_namearray: malloc fail\n"));
1070 talloc_free(namelist);
1074 /* Now copy out the names */
1078 if ( *nameptr == '/' ) {
1079 /* cope with multiple (useless) /s) */
1083 /* anything left? */
1084 if ( *nameptr == '\0' )
1087 /* find the next '/' or consume remaining */
1088 name_end = strchr_m(nameptr, '/');
1092 name_end = nameptr + strlen(nameptr);
1094 (*ppname_array)[i].is_wild = ms_has_wild(nameptr);
1095 if(((*ppname_array)[i].name = SMB_STRDUP(nameptr)) == NULL) {
1096 DEBUG(0,("set_namearray: malloc fail (1)\n"));
1097 talloc_free(namelist);
1101 /* next segment please */
1102 nameptr = name_end + 1;
1106 (*ppname_array)[i].name = NULL;
1108 talloc_free(namelist);
1113 #define DBGC_CLASS DBGC_LOCKING
1115 /****************************************************************************
1116 Simple routine to query existing file locks. Cruft in NFS and 64->32 bit mapping
1117 is dealt with in posix.c
1118 Returns True if we have information regarding this lock region (and returns
1119 F_UNLCK in *ptype if the region is unlocked). False if the call failed.
1120 ****************************************************************************/
1122 bool fcntl_getlock(int fd, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype, pid_t *ppid)
1124 SMB_STRUCT_FLOCK lock;
1127 DEBUG(8,("fcntl_getlock fd=%d offset=%.0f count=%.0f type=%d\n",
1128 fd,(double)*poffset,(double)*pcount,*ptype));
1130 lock.l_type = *ptype;
1131 lock.l_whence = SEEK_SET;
1132 lock.l_start = *poffset;
1133 lock.l_len = *pcount;
1136 ret = sys_fcntl_ptr(fd,SMB_F_GETLK,&lock);
1140 DEBUG(3,("fcntl_getlock: lock request failed at offset %.0f count %.0f type %d (%s)\n",
1141 (double)*poffset,(double)*pcount,*ptype,strerror(errno)));
1146 *ptype = lock.l_type;
1147 *poffset = lock.l_start;
1148 *pcount = lock.l_len;
1151 DEBUG(3,("fcntl_getlock: fd %d is returned info %d pid %u\n",
1152 fd, (int)lock.l_type, (unsigned int)lock.l_pid));
1157 #define DBGC_CLASS DBGC_ALL
1159 /*******************************************************************
1160 Is the name specified one of my netbios names.
1161 Returns true if it is equal, false otherwise.
1162 ********************************************************************/
1164 bool is_myname(const char *s)
1169 for (n=0; my_netbios_names(n); n++) {
1170 if (strequal(my_netbios_names(n), s)) {
1175 DEBUG(8, ("is_myname(\"%s\") returns %d\n", s, ret));
1179 /*******************************************************************
1180 Is the name specified our workgroup/domain.
1181 Returns true if it is equal, false otherwise.
1182 ********************************************************************/
1184 bool is_myworkgroup(const char *s)
1188 if (strequal(s, lp_workgroup())) {
1192 DEBUG(8, ("is_myworkgroup(\"%s\") returns %d\n", s, ret));
1196 /*******************************************************************
1197 we distinguish between 2K and XP by the "Native Lan Manager" string
1198 WinXP => "Windows 2002 5.1"
1199 WinXP 64bit => "Windows XP 5.2"
1200 Win2k => "Windows 2000 5.0"
1201 NT4 => "Windows NT 4.0"
1202 Win9x => "Windows 4.0"
1203 Windows 2003 doesn't set the native lan manager string but
1204 they do set the domain to "Windows 2003 5.2" (probably a bug).
1205 ********************************************************************/
1207 void ra_lanman_string( const char *native_lanman )
1209 if ( strcmp( native_lanman, "Windows 2002 5.1" ) == 0 )
1210 set_remote_arch( RA_WINXP );
1211 else if ( strcmp( native_lanman, "Windows XP 5.2" ) == 0 )
1212 set_remote_arch( RA_WINXP64 );
1213 else if ( strcmp( native_lanman, "Windows Server 2003 5.2" ) == 0 )
1214 set_remote_arch( RA_WIN2K3 );
1217 static const char *remote_arch_str;
1219 const char *get_remote_arch_str(void)
1221 if (!remote_arch_str) {
1224 return remote_arch_str;
1227 /*******************************************************************
1228 Set the horrid remote_arch string based on an enum.
1229 ********************************************************************/
1231 void set_remote_arch(enum remote_arch_types type)
1236 remote_arch_str = "WfWg";
1239 remote_arch_str = "OS2";
1242 remote_arch_str = "Win95";
1245 remote_arch_str = "WinNT";
1248 remote_arch_str = "Win2K";
1251 remote_arch_str = "WinXP";
1254 remote_arch_str = "WinXP64";
1257 remote_arch_str = "Win2K3";
1260 remote_arch_str = "Vista";
1263 remote_arch_str = "Samba";
1266 remote_arch_str = "CIFSFS";
1269 remote_arch_str = "OSX";
1272 ra_type = RA_UNKNOWN;
1273 remote_arch_str = "UNKNOWN";
1277 DEBUG(10,("set_remote_arch: Client arch is \'%s\'\n",
1281 /*******************************************************************
1282 Get the remote_arch type.
1283 ********************************************************************/
1285 enum remote_arch_types get_remote_arch(void)
1290 const char *tab_depth(int level, int depth)
1292 if( CHECK_DEBUGLVL(level) ) {
1293 dbgtext("%*s", depth*4, "");
1298 /*****************************************************************************
1299 Provide a checksum on a string
1301 Input: s - the null-terminated character string for which the checksum
1304 Output: The checksum value calculated for s.
1305 *****************************************************************************/
1307 int str_checksum(const char *s)
1309 TDB_DATA key = string_tdb_data(s);
1310 return tdb_jenkins_hash(&key);
1313 /*****************************************************************
1314 Zero a memory area then free it. Used to catch bugs faster.
1315 *****************************************************************/
1317 void zero_free(void *p, size_t size)
1323 /*****************************************************************
1324 Set our open file limit to a requested max and return the limit.
1325 *****************************************************************/
1327 int set_maxfiles(int requested_max)
1329 #if (defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE))
1331 int saved_current_limit;
1333 if(getrlimit(RLIMIT_NOFILE, &rlp)) {
1334 DEBUG(0,("set_maxfiles: getrlimit (1) for RLIMIT_NOFILE failed with error %s\n",
1337 return requested_max;
1341 * Set the fd limit to be real_max_open_files + MAX_OPEN_FUDGEFACTOR to
1342 * account for the extra fd we need
1343 * as well as the log files and standard
1344 * handles etc. Save the limit we want to set in case
1345 * we are running on an OS that doesn't support this limit (AIX)
1346 * which always returns RLIM_INFINITY for rlp.rlim_max.
1349 /* Try raising the hard (max) limit to the requested amount. */
1351 #if defined(RLIM_INFINITY)
1352 if (rlp.rlim_max != RLIM_INFINITY) {
1353 int orig_max = rlp.rlim_max;
1355 if ( rlp.rlim_max < requested_max )
1356 rlp.rlim_max = requested_max;
1358 /* This failing is not an error - many systems (Linux) don't
1359 support our default request of 10,000 open files. JRA. */
1361 if(setrlimit(RLIMIT_NOFILE, &rlp)) {
1362 DEBUG(3,("set_maxfiles: setrlimit for RLIMIT_NOFILE for %d max files failed with error %s\n",
1363 (int)rlp.rlim_max, strerror(errno) ));
1365 /* Set failed - restore original value from get. */
1366 rlp.rlim_max = orig_max;
1371 /* Now try setting the soft (current) limit. */
1373 saved_current_limit = rlp.rlim_cur = MIN(requested_max,rlp.rlim_max);
1375 if(setrlimit(RLIMIT_NOFILE, &rlp)) {
1376 DEBUG(0,("set_maxfiles: setrlimit for RLIMIT_NOFILE for %d files failed with error %s\n",
1377 (int)rlp.rlim_cur, strerror(errno) ));
1379 return saved_current_limit;
1382 if(getrlimit(RLIMIT_NOFILE, &rlp)) {
1383 DEBUG(0,("set_maxfiles: getrlimit (2) for RLIMIT_NOFILE failed with error %s\n",
1386 return saved_current_limit;
1389 #if defined(RLIM_INFINITY)
1390 if(rlp.rlim_cur == RLIM_INFINITY)
1391 return saved_current_limit;
1394 if((int)rlp.rlim_cur > saved_current_limit)
1395 return saved_current_limit;
1397 return rlp.rlim_cur;
1398 #else /* !defined(HAVE_GETRLIMIT) || !defined(RLIMIT_NOFILE) */
1400 * No way to know - just guess...
1402 return requested_max;
1406 /*****************************************************************
1407 malloc that aborts with smb_panic on fail or zero size.
1408 *****************************************************************/
1410 void *smb_xmalloc_array(size_t size, unsigned int count)
1414 smb_panic("smb_xmalloc_array: called with zero size");
1416 if (count >= MAX_ALLOC_SIZE/size) {
1417 smb_panic("smb_xmalloc_array: alloc size too large");
1419 if ((p = SMB_MALLOC(size*count)) == NULL) {
1420 DEBUG(0, ("smb_xmalloc_array failed to allocate %lu * %lu bytes\n",
1421 (unsigned long)size, (unsigned long)count));
1422 smb_panic("smb_xmalloc_array: malloc failed");
1428 vasprintf that aborts on malloc fail
1431 int smb_xvasprintf(char **ptr, const char *format, va_list ap)
1438 n = vasprintf(ptr, format, ap2);
1440 if (n == -1 || ! *ptr) {
1441 smb_panic("smb_xvasprintf: out of memory");
1446 /*****************************************************************
1447 Get local hostname and cache result.
1448 *****************************************************************/
1450 char *myhostname(void)
1454 ret = get_myname(NULL);
1460 * @brief Returns an absolute path to a file concatenating the provided
1461 * @a rootpath and @a basename
1463 * @param name Filename, relative to @a rootpath
1465 * @retval Pointer to a string containing the full path.
1468 static char *xx_path(const char *name, const char *rootpath)
1472 fname = talloc_strdup(talloc_tos(), rootpath);
1476 trim_string(fname,"","/");
1478 if (!directory_exist(fname)) {
1479 if (!mkdir(fname,0755))
1480 DEBUG(1, ("Unable to create directory %s for file %s. "
1481 "Error was %s\n", fname, name, strerror(errno)));
1484 return talloc_asprintf(talloc_tos(),
1491 * @brief Returns an absolute path to a file in the Samba lock directory.
1493 * @param name File to find, relative to LOCKDIR.
1495 * @retval Pointer to a talloc'ed string containing the full path.
1498 char *lock_path(const char *name)
1500 return xx_path(name, lp_lockdir());
1504 * @brief Returns an absolute path to a file in the Samba pid directory.
1506 * @param name File to find, relative to PIDDIR.
1508 * @retval Pointer to a talloc'ed string containing the full path.
1511 char *pid_path(const char *name)
1513 return xx_path(name, lp_piddir());
1517 * @brief Returns an absolute path to a file in the Samba modules directory.
1519 * @param name File to find, relative to MODULESDIR.
1521 * @retval Pointer to a string containing the full path.
1524 char *modules_path(const char *name)
1526 return talloc_asprintf(talloc_tos(), "%s/%s", get_dyn_MODULESDIR(), name);
1530 * @brief Returns an absolute path to a file in the Samba data directory.
1532 * @param name File to find, relative to CODEPAGEDIR.
1534 * @retval Pointer to a talloc'ed string containing the full path.
1537 char *data_path(const char *name)
1539 return talloc_asprintf(talloc_tos(), "%s/%s", get_dyn_CODEPAGEDIR(), name);
1543 * @brief Returns an absolute path to a file in the Samba state directory.
1545 * @param name File to find, relative to STATEDIR.
1547 * @retval Pointer to a talloc'ed string containing the full path.
1550 char *state_path(const char *name)
1552 return xx_path(name, lp_statedir());
1556 * @brief Returns an absolute path to a file in the Samba cache directory.
1558 * @param name File to find, relative to CACHEDIR.
1560 * @retval Pointer to a talloc'ed string containing the full path.
1563 char *cache_path(const char *name)
1565 return xx_path(name, lp_cachedir());
1569 * @brief Returns the platform specific shared library extension.
1571 * @retval Pointer to a const char * containing the extension.
1574 const char *shlib_ext(void)
1576 return get_dyn_SHLIBEXT();
1579 /*******************************************************************
1580 Given a filename - get its directory name
1581 ********************************************************************/
1583 bool parent_dirname(TALLOC_CTX *mem_ctx, const char *dir, char **parent,
1589 p = strrchr_m(dir, '/'); /* Find final '/', if any */
1592 if (!(*parent = talloc_strdup(mem_ctx, "."))) {
1603 if (!(*parent = (char *)TALLOC_MEMDUP(mem_ctx, dir, len+1))) {
1606 (*parent)[len] = '\0';
1614 /*******************************************************************
1615 Determine if a pattern contains any Microsoft wildcard characters.
1616 *******************************************************************/
1618 bool ms_has_wild(const char *s)
1622 if (lp_posix_pathnames()) {
1623 /* With posix pathnames no characters are wild. */
1627 while ((c = *s++)) {
1640 bool ms_has_wild_w(const smb_ucs2_t *s)
1643 if (!s) return False;
1644 while ((c = *s++)) {
1646 case UCS2_CHAR('*'):
1647 case UCS2_CHAR('?'):
1648 case UCS2_CHAR('<'):
1649 case UCS2_CHAR('>'):
1650 case UCS2_CHAR('"'):
1657 /*******************************************************************
1658 A wrapper that handles case sensitivity and the special handling
1660 *******************************************************************/
1662 bool mask_match(const char *string, const char *pattern, bool is_case_sensitive)
1664 if (ISDOTDOT(string))
1669 return ms_fnmatch(pattern, string, Protocol <= PROTOCOL_LANMAN2, is_case_sensitive) == 0;
1672 /*******************************************************************
1673 A wrapper that handles case sensitivity and the special handling
1674 of the ".." name. Varient that is only called by old search code which requires
1675 pattern translation.
1676 *******************************************************************/
1678 bool mask_match_search(const char *string, const char *pattern, bool is_case_sensitive)
1680 if (ISDOTDOT(string))
1685 return ms_fnmatch(pattern, string, True, is_case_sensitive) == 0;
1688 /*******************************************************************
1689 A wrapper that handles a list of patters and calls mask_match()
1690 on each. Returns True if any of the patterns match.
1691 *******************************************************************/
1693 bool mask_match_list(const char *string, char **list, int listLen, bool is_case_sensitive)
1695 while (listLen-- > 0) {
1696 if (mask_match(string, *list++, is_case_sensitive))
1702 /*********************************************************
1703 Recursive routine that is called by unix_wild_match.
1704 *********************************************************/
1706 static bool unix_do_match(const char *regexp, const char *str)
1710 for( p = regexp; *p && *str; ) {
1721 * Look for a character matching
1722 * the one after the '*'.
1726 return true; /* Automatic match */
1729 while(*str && (*p != *str))
1733 * Patch from weidel@multichart.de. In the case of the regexp
1734 * '*XX*' we want to ensure there are at least 2 'X' characters
1735 * in the string after the '*' for a match to be made.
1742 * Eat all the characters that match, but count how many there were.
1745 while(*str && (*p == *str)) {
1751 * Now check that if the regexp had n identical characters that
1752 * matchcount had at least that many matches.
1755 while ( *(p+1) && (*(p+1) == *p)) {
1760 if ( matchcount <= 0 )
1764 str--; /* We've eaten the match char after the '*' */
1766 if(unix_do_match(p, str))
1788 if (!*p && str[0] == '.' && str[1] == 0)
1791 if (!*str && *p == '?') {
1797 if(!*str && (*p == '*' && p[1] == '\0'))
1803 /*******************************************************************
1804 Simple case insensitive interface to a UNIX wildcard matcher.
1805 Returns True if match, False if not.
1806 *******************************************************************/
1808 bool unix_wild_match(const char *pattern, const char *string)
1810 TALLOC_CTX *ctx = talloc_stackframe();
1816 p2 = talloc_strdup(ctx,pattern);
1817 s2 = talloc_strdup(ctx,string);
1825 /* Remove any *? and ** from the pattern as they are meaningless */
1826 for(p = p2; *p; p++) {
1827 while( *p == '*' && (p[1] == '?' ||p[1] == '*')) {
1828 memmove(&p[1], &p[2], strlen(&p[2])+1);
1832 if (strequal(p2,"*")) {
1837 ret = unix_do_match(p2, s2);
1842 /**********************************************************************
1843 Converts a name to a fully qualified domain name.
1844 Returns true if lookup succeeded, false if not (then fqdn is set to name)
1845 Note we deliberately use gethostbyname here, not getaddrinfo as we want
1846 to examine the h_aliases and I don't know how to do that with getaddrinfo.
1847 ***********************************************************************/
1849 bool name_to_fqdn(fstring fqdn, const char *name)
1852 struct hostent *hp = gethostbyname(name);
1854 if (!hp || !hp->h_name || !*hp->h_name) {
1855 DEBUG(10,("name_to_fqdn: lookup for %s failed.\n", name));
1856 fstrcpy(fqdn, name);
1860 /* Find out if the fqdn is returned as an alias
1861 * to cope with /etc/hosts files where the first
1862 * name is not the fqdn but the short name */
1863 if (hp->h_aliases && (! strchr_m(hp->h_name, '.'))) {
1865 for (i = 0; hp->h_aliases[i]; i++) {
1866 if (strchr_m(hp->h_aliases[i], '.')) {
1867 full = hp->h_aliases[i];
1872 if (full && (strcasecmp_m(full, "localhost.localdomain") == 0)) {
1873 DEBUG(1, ("WARNING: your /etc/hosts file may be broken!\n"));
1874 DEBUGADD(1, (" Specifing the machine hostname for address 127.0.0.1 may lead\n"));
1875 DEBUGADD(1, (" to Kerberos authentication problems as localhost.localdomain\n"));
1876 DEBUGADD(1, (" may end up being used instead of the real machine FQDN.\n"));
1883 DEBUG(10,("name_to_fqdn: lookup for %s -> %s.\n", name, full));
1884 fstrcpy(fqdn, full);
1888 /**********************************************************************
1889 Append a DATA_BLOB to a talloc'ed object
1890 ***********************************************************************/
1892 void *talloc_append_blob(TALLOC_CTX *mem_ctx, void *buf, DATA_BLOB blob)
1894 size_t old_size = 0;
1897 if (blob.length == 0) {
1902 old_size = talloc_get_size(buf);
1905 result = (char *)TALLOC_REALLOC(mem_ctx, buf, old_size + blob.length);
1906 if (result == NULL) {
1910 memcpy(result + old_size, blob.data, blob.length);
1914 uint32 map_share_mode_to_deny_mode(uint32 share_access, uint32 private_options)
1916 switch (share_access & ~FILE_SHARE_DELETE) {
1917 case FILE_SHARE_NONE:
1919 case FILE_SHARE_READ:
1921 case FILE_SHARE_WRITE:
1923 case FILE_SHARE_READ|FILE_SHARE_WRITE:
1926 if (private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS) {
1928 } else if (private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_FCB) {
1935 pid_t procid_to_pid(const struct server_id *proc)
1940 static uint32 my_vnn = NONCLUSTER_VNN;
1942 void set_my_vnn(uint32 vnn)
1944 DEBUG(10, ("vnn pid %d = %u\n", (int)sys_getpid(), (unsigned int)vnn));
1948 uint32 get_my_vnn(void)
1953 static uint64_t my_unique_id = 0;
1955 void set_my_unique_id(uint64_t unique_id)
1957 my_unique_id = unique_id;
1960 struct server_id pid_to_procid(pid_t pid)
1962 struct server_id result;
1964 result.unique_id = my_unique_id;
1965 result.vnn = my_vnn;
1969 struct server_id procid_self(void)
1971 return pid_to_procid(sys_getpid());
1974 bool procid_equal(const struct server_id *p1, const struct server_id *p2)
1976 if (p1->pid != p2->pid)
1978 if (p1->vnn != p2->vnn)
1983 bool cluster_id_equal(const struct server_id *id1,
1984 const struct server_id *id2)
1986 return procid_equal(id1, id2);
1989 bool procid_is_me(const struct server_id *pid)
1991 if (pid->pid != sys_getpid())
1993 if (pid->vnn != my_vnn)
1998 struct server_id interpret_pid(const char *pid_string)
2000 struct server_id result;
2003 if (sscanf(pid_string, "%u:%d", &vnn, &pid) == 2) {
2007 else if (sscanf(pid_string, "%d", &pid) == 1) {
2008 result.vnn = get_my_vnn();
2012 result.vnn = NONCLUSTER_VNN;
2015 /* Assigning to result.pid may have overflowed
2016 Map negative pid to -1: i.e. error */
2017 if (result.pid < 0) {
2020 result.unique_id = 0;
2024 char *procid_str(TALLOC_CTX *mem_ctx, const struct server_id *pid)
2026 if (pid->vnn == NONCLUSTER_VNN) {
2027 return talloc_asprintf(mem_ctx,
2032 return talloc_asprintf(mem_ctx,
2039 char *procid_str_static(const struct server_id *pid)
2041 return procid_str(talloc_tos(), pid);
2044 bool procid_valid(const struct server_id *pid)
2046 return (pid->pid != -1);
2049 bool procid_is_local(const struct server_id *pid)
2051 return pid->vnn == my_vnn;
2054 /****************************************************************
2055 Check if offset/length fit into bufsize. Should probably be
2056 merged with is_offset_safe, but this would require a rewrite
2057 of lanman.c. Later :-)
2058 ****************************************************************/
2060 bool trans_oob(uint32_t bufsize, uint32_t offset, uint32_t length)
2062 if ((offset + length < offset) || (offset + length < length)) {
2066 if ((offset > bufsize) || (offset + length > bufsize)) {
2073 /****************************************************************
2074 Check if an offset into a buffer is safe.
2075 If this returns True it's safe to indirect into the byte at
2077 ****************************************************************/
2079 bool is_offset_safe(const char *buf_base, size_t buf_len, char *ptr, size_t off)
2081 const char *end_base = buf_base + buf_len;
2082 char *end_ptr = ptr + off;
2084 if (!buf_base || !ptr) {
2088 if (end_base < buf_base || end_ptr < ptr) {
2089 return False; /* wrap. */
2092 if (end_ptr < end_base) {
2098 /****************************************************************
2099 Return a safe pointer into a buffer, or NULL.
2100 ****************************************************************/
2102 char *get_safe_ptr(const char *buf_base, size_t buf_len, char *ptr, size_t off)
2104 return is_offset_safe(buf_base, buf_len, ptr, off) ?
2108 /****************************************************************
2109 Return a safe pointer into a string within a buffer, or NULL.
2110 ****************************************************************/
2112 char *get_safe_str_ptr(const char *buf_base, size_t buf_len, char *ptr, size_t off)
2114 if (!is_offset_safe(buf_base, buf_len, ptr, off)) {
2117 /* Check if a valid string exists at this offset. */
2118 if (skip_string(buf_base,buf_len, ptr + off) == NULL) {
2124 /****************************************************************
2125 Return an SVAL at a pointer, or failval if beyond the end.
2126 ****************************************************************/
2128 int get_safe_SVAL(const char *buf_base, size_t buf_len, char *ptr, size_t off, int failval)
2131 * Note we use off+1 here, not off+2 as SVAL accesses ptr[0] and ptr[1],
2134 if (!is_offset_safe(buf_base, buf_len, ptr, off+1)) {
2137 return SVAL(ptr,off);
2140 /****************************************************************
2141 Return an IVAL at a pointer, or failval if beyond the end.
2142 ****************************************************************/
2144 int get_safe_IVAL(const char *buf_base, size_t buf_len, char *ptr, size_t off, int failval)
2147 * Note we use off+3 here, not off+4 as IVAL accesses
2148 * ptr[0] ptr[1] ptr[2] ptr[3] NOT ptr[4].
2150 if (!is_offset_safe(buf_base, buf_len, ptr, off+3)) {
2153 return IVAL(ptr,off);
2156 /****************************************************************
2157 Split DOM\user into DOM and user. Do not mix with winbind variants of that
2158 call (they take care of winbind separator and other winbind specific settings).
2159 ****************************************************************/
2161 void split_domain_user(TALLOC_CTX *mem_ctx,
2162 const char *full_name,
2166 const char *p = NULL;
2168 p = strchr_m(full_name, '\\');
2171 *domain = talloc_strndup(mem_ctx, full_name,
2172 PTR_DIFF(p, full_name));
2173 *user = talloc_strdup(mem_ctx, p+1);
2175 *domain = talloc_strdup(mem_ctx, "");
2176 *user = talloc_strdup(mem_ctx, full_name);
2182 Disable these now we have checked all code paths and ensured
2183 NULL returns on zero request. JRA.
2185 /****************************************************************
2186 talloc wrapper functions that guarentee a null pointer return
2188 ****************************************************************/
2190 #ifndef MAX_TALLOC_SIZE
2191 #define MAX_TALLOC_SIZE 0x10000000
2195 * talloc and zero memory.
2196 * - returns NULL if size is zero.
2199 void *_talloc_zero_zeronull(const void *ctx, size_t size, const char *name)
2207 p = talloc_named_const(ctx, size, name);
2210 memset(p, '\0', size);
2217 * memdup with a talloc.
2218 * - returns NULL if size is zero.
2221 void *_talloc_memdup_zeronull(const void *t, const void *p, size_t size, const char *name)
2229 newp = talloc_named_const(t, size, name);
2231 memcpy(newp, p, size);
2238 * alloc an array, checking for integer overflow in the array size.
2239 * - returns NULL if count or el_size are zero.
2242 void *_talloc_array_zeronull(const void *ctx, size_t el_size, unsigned count, const char *name)
2244 if (count >= MAX_TALLOC_SIZE/el_size) {
2248 if (el_size == 0 || count == 0) {
2252 return talloc_named_const(ctx, el_size * count, name);
2256 * alloc an zero array, checking for integer overflow in the array size
2257 * - returns NULL if count or el_size are zero.
2260 void *_talloc_zero_array_zeronull(const void *ctx, size_t el_size, unsigned count, const char *name)
2262 if (count >= MAX_TALLOC_SIZE/el_size) {
2266 if (el_size == 0 || count == 0) {
2270 return _talloc_zero(ctx, el_size * count, name);
2274 * Talloc wrapper that returns NULL if size == 0.
2276 void *talloc_zeronull(const void *context, size_t size, const char *name)
2281 return talloc_named_const(context, size, name);
2285 /****************************************************************
2286 strip off leading '\\' from a hostname
2287 ****************************************************************/
2289 const char *strip_hostname(const char *s)
2295 if (strlen_m(s) < 3) {
2299 if (s[0] == '\\') s++;
2300 if (s[0] == '\\') s++;
2305 bool tevent_req_poll_ntstatus(struct tevent_req *req,
2306 struct tevent_context *ev,
2309 bool ret = tevent_req_poll(req, ev);
2311 *status = map_nt_error_from_unix(errno);
2316 bool any_nt_status_not_ok(NTSTATUS err1, NTSTATUS err2, NTSTATUS *result)
2318 if (!NT_STATUS_IS_OK(err1)) {
2322 if (!NT_STATUS_IS_OK(err2)) {
2329 int timeval_to_msec(struct timeval t)
2331 return t.tv_sec * 1000 + (t.tv_usec+999) / 1000;
2334 /*******************************************************************
2335 Check a given DOS pathname is valid for a share.
2336 ********************************************************************/
2338 char *valid_share_pathname(TALLOC_CTX *ctx, const char *dos_pathname)
2342 if (!dos_pathname) {
2346 ptr = talloc_strdup(ctx, dos_pathname);
2350 /* Convert any '\' paths to '/' */
2352 ptr = unix_clean_name(ctx, ptr);
2357 /* NT is braindead - it wants a C: prefix to a pathname ! So strip it. */
2358 if (strlen(ptr) > 2 && ptr[1] == ':' && ptr[0] != '/')
2361 /* Only absolute paths allowed. */