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/>.
26 extern char *global_clobber_region_function;
27 extern unsigned int global_clobber_region_line;
29 /* Max allowable allococation - 256mb - 0x10000000 */
30 #define MAX_ALLOC_SIZE (1024*1024*256)
32 #if (defined(HAVE_NETGROUP) && defined (WITH_AUTOMOUNT))
33 #ifdef WITH_NISPLUS_HOME
34 #ifdef BROKEN_NISPLUS_INCLUDE_FILES
36 * The following lines are needed due to buggy include files
37 * in Solaris 2.6 which define GROUP in both /usr/include/sys/acl.h and
38 * also in /usr/include/rpcsvc/nis.h. The definitions conflict. JRA.
39 * Also GROUP_OBJ is defined as 0x4 in /usr/include/sys/acl.h and as
40 * an enum in /usr/include/rpcsvc/nis.h.
47 #if defined(GROUP_OBJ)
51 #endif /* BROKEN_NISPLUS_INCLUDE_FILES */
53 #include <rpcsvc/nis.h>
55 #endif /* WITH_NISPLUS_HOME */
56 #endif /* HAVE_NETGROUP && WITH_AUTOMOUNT */
58 enum protocol_types Protocol = PROTOCOL_COREPLUS;
60 /* this is used by the chaining code */
65 static enum remote_arch_types ra_type = RA_UNKNOWN;
67 /***********************************************************************
68 Definitions for all names.
69 ***********************************************************************/
71 static char *smb_myname;
72 static char *smb_myworkgroup;
73 static char *smb_scope;
74 static int smb_num_netbios_names;
75 static char **smb_my_netbios_names;
77 /***********************************************************************
78 Allocate and set myname. Ensure upper case.
79 ***********************************************************************/
81 bool set_global_myname(const char *myname)
83 SAFE_FREE(smb_myname);
84 smb_myname = SMB_STRDUP(myname);
87 strupper_m(smb_myname);
91 const char *global_myname(void)
96 /***********************************************************************
97 Allocate and set myworkgroup. Ensure upper case.
98 ***********************************************************************/
100 bool set_global_myworkgroup(const char *myworkgroup)
102 SAFE_FREE(smb_myworkgroup);
103 smb_myworkgroup = SMB_STRDUP(myworkgroup);
104 if (!smb_myworkgroup)
106 strupper_m(smb_myworkgroup);
110 const char *lp_workgroup(void)
112 return smb_myworkgroup;
115 /***********************************************************************
116 Allocate and set scope. Ensure upper case.
117 ***********************************************************************/
119 bool set_global_scope(const char *scope)
121 SAFE_FREE(smb_scope);
122 smb_scope = SMB_STRDUP(scope);
125 strupper_m(smb_scope);
129 /*********************************************************************
130 Ensure scope is never null string.
131 *********************************************************************/
133 const char *global_scope(void)
136 set_global_scope("");
140 static void free_netbios_names_array(void)
144 for (i = 0; i < smb_num_netbios_names; i++)
145 SAFE_FREE(smb_my_netbios_names[i]);
147 SAFE_FREE(smb_my_netbios_names);
148 smb_num_netbios_names = 0;
151 static bool allocate_my_netbios_names_array(size_t number)
153 free_netbios_names_array();
155 smb_num_netbios_names = number + 1;
156 smb_my_netbios_names = SMB_MALLOC_ARRAY( char *, smb_num_netbios_names );
158 if (!smb_my_netbios_names)
161 memset(smb_my_netbios_names, '\0', sizeof(char *) * smb_num_netbios_names);
165 static bool set_my_netbios_names(const char *name, int i)
167 SAFE_FREE(smb_my_netbios_names[i]);
169 smb_my_netbios_names[i] = SMB_STRDUP(name);
170 if (!smb_my_netbios_names[i])
172 strupper_m(smb_my_netbios_names[i]);
176 /***********************************************************************
177 Free memory allocated to global objects
178 ***********************************************************************/
180 void gfree_names(void)
182 SAFE_FREE( smb_myname );
183 SAFE_FREE( smb_myworkgroup );
184 SAFE_FREE( smb_scope );
185 free_netbios_names_array();
186 free_local_machine_name();
189 void gfree_all( void )
198 /* release the talloc null_context memory last */
199 talloc_disable_null_tracking();
202 const char *my_netbios_names(int i)
204 return smb_my_netbios_names[i];
207 bool set_netbios_aliases(const char **str_array)
211 /* Work out the max number of netbios aliases that we have */
212 for( namecount=0; str_array && (str_array[namecount] != NULL); namecount++ )
215 if ( global_myname() && *global_myname())
218 /* Allocate space for the netbios aliases */
219 if (!allocate_my_netbios_names_array(namecount))
222 /* Use the global_myname string first */
224 if ( global_myname() && *global_myname()) {
225 set_my_netbios_names( global_myname(), namecount );
231 for ( i = 0; str_array[i] != NULL; i++) {
233 bool duplicate = False;
235 /* Look for duplicates */
236 for( n=0; n<namecount; n++ ) {
237 if( strequal( str_array[i], my_netbios_names(n) ) ) {
243 if (!set_my_netbios_names(str_array[i], namecount))
252 /****************************************************************************
253 Common name initialization code.
254 ****************************************************************************/
256 bool init_names(void)
260 if (global_myname() == NULL || *global_myname() == '\0') {
261 if (!set_global_myname(myhostname())) {
262 DEBUG( 0, ( "init_structs: malloc fail.\n" ) );
267 if (!set_netbios_aliases(lp_netbios_aliases())) {
268 DEBUG( 0, ( "init_structs: malloc fail.\n" ) );
272 set_local_machine_name(global_myname(),false);
274 DEBUG( 5, ("Netbios name list:-\n") );
275 for( n=0; my_netbios_names(n); n++ ) {
276 DEBUGADD( 5, ("my_netbios_names[%d]=\"%s\"\n",
277 n, my_netbios_names(n) ) );
283 /**************************************************************************n
284 Code to cope with username/password auth options from the commandline.
285 Used mainly in client tools.
286 ****************************************************************************/
288 static struct user_auth_info cmdline_auth_info = {
291 false, /* got_pass */
292 false, /* use_kerberos */
293 Undefined, /* signing state */
294 false /* smb_encrypt */
297 const char *get_cmdline_auth_info_username(void)
299 if (!cmdline_auth_info.username) {
302 return cmdline_auth_info.username;
305 void set_cmdline_auth_info_username(const char *username)
307 SAFE_FREE(cmdline_auth_info.username);
308 cmdline_auth_info.username = SMB_STRDUP(username);
309 if (!cmdline_auth_info.username) {
314 const char *get_cmdline_auth_info_password(void)
316 if (!cmdline_auth_info.password) {
319 return cmdline_auth_info.password;
322 void set_cmdline_auth_info_password(const char *password)
324 SAFE_FREE(cmdline_auth_info.password);
325 cmdline_auth_info.password = SMB_STRDUP(password);
326 if (!cmdline_auth_info.password) {
329 cmdline_auth_info.got_pass = true;
332 bool set_cmdline_auth_info_signing_state(const char *arg)
334 cmdline_auth_info.signing_state = -1;
335 if (strequal(arg, "off") || strequal(arg, "no") ||
336 strequal(arg, "false")) {
337 cmdline_auth_info.signing_state = false;
338 } else if (strequal(arg, "on") || strequal(arg, "yes") ||
339 strequal(arg, "true") || strequal(arg, "auto")) {
340 cmdline_auth_info.signing_state = true;
341 } else if (strequal(arg, "force") || strequal(arg, "required") ||
342 strequal(arg, "forced")) {
343 cmdline_auth_info.signing_state = Required;
350 int get_cmdline_auth_info_signing_state(void)
352 return cmdline_auth_info.signing_state;
355 bool get_cmdline_auth_info_use_kerberos(void)
357 return cmdline_auth_info.use_kerberos;
360 /* This should only be used by lib/popt_common.c JRA */
361 void set_cmdline_auth_info_use_krb5_ticket(void)
363 cmdline_auth_info.use_kerberos = true;
364 cmdline_auth_info.got_pass = true;
367 /* This should only be used by lib/popt_common.c JRA */
368 void set_cmdline_auth_info_smb_encrypt(void)
370 cmdline_auth_info.smb_encrypt = true;
373 bool get_cmdline_auth_info_got_pass(void)
375 return cmdline_auth_info.got_pass;
378 bool get_cmdline_auth_info_smb_encrypt(void)
380 return cmdline_auth_info.smb_encrypt;
383 bool get_cmdline_auth_info_copy(struct user_auth_info *info)
385 *info = cmdline_auth_info;
386 /* Now re-alloc the strings. */
387 info->username = SMB_STRDUP(get_cmdline_auth_info_username());
388 info->password = SMB_STRDUP(get_cmdline_auth_info_password());
389 if (!info->username || !info->password) {
395 /**************************************************************************n
396 Find a suitable temporary directory. The result should be copied immediately
397 as it may be overwritten by a subsequent call.
398 ****************************************************************************/
400 const char *tmpdir(void)
403 if ((p = getenv("TMPDIR")))
408 /****************************************************************************
409 Add a gid to an array of gids if it's not already there.
410 ****************************************************************************/
412 bool add_gid_to_array_unique(TALLOC_CTX *mem_ctx, gid_t gid,
413 gid_t **gids, size_t *num_gids)
417 if ((*num_gids != 0) && (*gids == NULL)) {
419 * A former call to this routine has failed to allocate memory
424 for (i=0; i<*num_gids; i++) {
425 if ((*gids)[i] == gid) {
430 *gids = TALLOC_REALLOC_ARRAY(mem_ctx, *gids, gid_t, *num_gids+1);
436 (*gids)[*num_gids] = gid;
441 /****************************************************************************
442 Like atoi but gets the value up to the separator character.
443 ****************************************************************************/
445 static const char *Atoic(const char *p, int *n, const char *c)
447 if (!isdigit((int)*p)) {
448 DEBUG(5, ("Atoic: malformed number\n"));
454 while ((*p) && isdigit((int)*p))
457 if (strchr_m(c, *p) == NULL) {
458 DEBUG(5, ("Atoic: no separator characters (%s) not found\n", c));
465 /*************************************************************************
466 Reads a list of numbers.
467 *************************************************************************/
469 const char *get_numlist(const char *p, uint32 **num, int *count)
473 if (num == NULL || count == NULL)
479 while ((p = Atoic(p, &val, ":,")) != NULL && (*p) != ':') {
480 *num = SMB_REALLOC_ARRAY((*num), uint32, (*count)+1);
484 (*num)[(*count)] = val;
492 /*******************************************************************
493 Check if a file exists - call vfs_file_exist for samba files.
494 ********************************************************************/
496 bool file_exist(const char *fname,SMB_STRUCT_STAT *sbuf)
502 if (sys_stat(fname,sbuf) != 0)
505 return((S_ISREG(sbuf->st_mode)) || (S_ISFIFO(sbuf->st_mode)));
508 /*******************************************************************
509 Check a files mod time.
510 ********************************************************************/
512 time_t file_modtime(const char *fname)
516 if (sys_stat(fname,&st) != 0)
522 /*******************************************************************
523 Check if a directory exists.
524 ********************************************************************/
526 bool directory_exist(char *dname,SMB_STRUCT_STAT *st)
534 if (sys_stat(dname,st) != 0)
537 ret = S_ISDIR(st->st_mode);
543 /*******************************************************************
544 Returns the size in bytes of the named file.
545 ********************************************************************/
547 SMB_OFF_T get_file_size(char *file_name)
551 if(sys_stat(file_name,&buf) != 0)
552 return (SMB_OFF_T)-1;
556 /*******************************************************************
557 Return a string representing an attribute for a file.
558 ********************************************************************/
560 char *attrib_string(uint16 mode)
566 if (mode & aVOLID) fstrcat(attrstr,"V");
567 if (mode & aDIR) fstrcat(attrstr,"D");
568 if (mode & aARCH) fstrcat(attrstr,"A");
569 if (mode & aHIDDEN) fstrcat(attrstr,"H");
570 if (mode & aSYSTEM) fstrcat(attrstr,"S");
571 if (mode & aRONLY) fstrcat(attrstr,"R");
573 return talloc_strdup(talloc_tos(), attrstr);
576 /*******************************************************************
577 Show a smb message structure.
578 ********************************************************************/
580 void show_msg(char *buf)
588 DEBUG(5,("size=%d\nsmb_com=0x%x\nsmb_rcls=%d\nsmb_reh=%d\nsmb_err=%d\nsmb_flg=%d\nsmb_flg2=%d\n",
590 (int)CVAL(buf,smb_com),
591 (int)CVAL(buf,smb_rcls),
592 (int)CVAL(buf,smb_reh),
593 (int)SVAL(buf,smb_err),
594 (int)CVAL(buf,smb_flg),
595 (int)SVAL(buf,smb_flg2)));
596 DEBUGADD(5,("smb_tid=%d\nsmb_pid=%d\nsmb_uid=%d\nsmb_mid=%d\n",
597 (int)SVAL(buf,smb_tid),
598 (int)SVAL(buf,smb_pid),
599 (int)SVAL(buf,smb_uid),
600 (int)SVAL(buf,smb_mid)));
601 DEBUGADD(5,("smt_wct=%d\n",(int)CVAL(buf,smb_wct)));
603 for (i=0;i<(int)CVAL(buf,smb_wct);i++)
604 DEBUGADD(5,("smb_vwv[%2d]=%5d (0x%X)\n",i,
605 SVAL(buf,smb_vwv+2*i),SVAL(buf,smb_vwv+2*i)));
607 bcc = (int)SVAL(buf,smb_vwv+2*(CVAL(buf,smb_wct)));
609 DEBUGADD(5,("smb_bcc=%d\n",bcc));
617 dump_data(10, (uint8 *)smb_buf(buf), bcc);
620 /*******************************************************************
621 Set the length and marker of an encrypted smb packet.
622 ********************************************************************/
624 void smb_set_enclen(char *buf,int len,uint16 enc_ctx_num)
626 _smb_setlen(buf,len);
630 SSVAL(buf,6,enc_ctx_num);
633 /*******************************************************************
634 Set the length and marker of an smb packet.
635 ********************************************************************/
637 void smb_setlen(char *buf,int len)
639 _smb_setlen(buf,len);
647 /*******************************************************************
648 Setup only the byte count for a smb message.
649 ********************************************************************/
651 int set_message_bcc(char *buf,int num_bytes)
653 int num_words = CVAL(buf,smb_wct);
654 SSVAL(buf,smb_vwv + num_words*SIZEOFWORD,num_bytes);
655 _smb_setlen(buf,smb_size + num_words*2 + num_bytes - 4);
656 return (smb_size + num_words*2 + num_bytes);
659 /*******************************************************************
660 Add a data blob to the end of a smb_buf, adjusting bcc and smb_len.
661 Return the bytes added
662 ********************************************************************/
664 ssize_t message_push_blob(uint8 **outbuf, DATA_BLOB blob)
666 size_t newlen = smb_len(*outbuf) + 4 + blob.length;
669 if (!(tmp = TALLOC_REALLOC_ARRAY(NULL, *outbuf, uint8, newlen))) {
670 DEBUG(0, ("talloc failed\n"));
675 memcpy(tmp + smb_len(tmp) + 4, blob.data, blob.length);
676 set_message_bcc((char *)tmp, smb_buflen(tmp) + blob.length);
680 /*******************************************************************
681 Reduce a file name, removing .. elements.
682 ********************************************************************/
684 static char *dos_clean_name(TALLOC_CTX *ctx, const char *s)
689 DEBUG(3,("dos_clean_name [%s]\n",s));
691 /* remove any double slashes */
692 str = talloc_all_string_sub(ctx, s, "\\\\", "\\");
697 /* Remove leading .\\ characters */
698 if(strncmp(str, ".\\", 2) == 0) {
699 trim_string(str, ".\\", NULL);
701 str = talloc_strdup(ctx, ".\\");
708 while ((p = strstr_m(str,"\\..\\")) != NULL) {
714 if ((p=strrchr_m(str,'\\')) != NULL) {
719 str = talloc_asprintf(ctx,
728 trim_string(str,NULL,"\\..");
729 return talloc_all_string_sub(ctx, str, "\\.\\", "\\");
732 /*******************************************************************
733 Reduce a file name, removing .. elements.
734 ********************************************************************/
736 char *unix_clean_name(TALLOC_CTX *ctx, const char *s)
741 DEBUG(3,("unix_clean_name [%s]\n",s));
743 /* remove any double slashes */
744 str = talloc_all_string_sub(ctx, s, "//","/");
749 /* Remove leading ./ characters */
750 if(strncmp(str, "./", 2) == 0) {
751 trim_string(str, "./", NULL);
753 str = talloc_strdup(ctx, "./");
760 while ((p = strstr_m(str,"/../")) != NULL) {
766 if ((p=strrchr_m(str,'/')) != NULL) {
771 str = talloc_asprintf(ctx,
780 trim_string(str,NULL,"/..");
781 return talloc_all_string_sub(ctx, str, "/./", "/");
784 char *clean_name(TALLOC_CTX *ctx, const char *s)
786 char *str = dos_clean_name(ctx, s);
790 return unix_clean_name(ctx, str);
793 /*******************************************************************
794 Close the low 3 fd's and open dev/null in their place.
795 ********************************************************************/
797 void close_low_fds(bool stderr_too)
809 /* try and use up these file descriptors, so silly
810 library routines writing to stdout etc won't cause havoc */
812 if (i == 2 && !stderr_too)
815 fd = sys_open("/dev/null",O_RDWR,0);
817 fd = sys_open("/dev/null",O_WRONLY,0);
819 DEBUG(0,("Can't open /dev/null\n"));
823 DEBUG(0,("Didn't get file descriptor %d\n",i));
830 /*******************************************************************
831 Write data into an fd at a given offset. Ignore seek errors.
832 ********************************************************************/
834 ssize_t write_data_at_offset(int fd, const char *buffer, size_t N, SMB_OFF_T pos)
839 if (pos == (SMB_OFF_T)-1) {
840 return write_data(fd, buffer, N);
842 #if defined(HAVE_PWRITE) || defined(HAVE_PRWITE64)
844 ret = sys_pwrite(fd,buffer + total,N - total, pos);
845 if (ret == -1 && errno == ESPIPE) {
846 return write_data(fd, buffer + total,N - total);
849 DEBUG(0,("write_data_at_offset: write failure. Error = %s\n", strerror(errno) ));
858 return (ssize_t)total;
860 /* Use lseek and write_data. */
861 if (sys_lseek(fd, pos, SEEK_SET) == -1) {
862 if (errno != ESPIPE) {
866 return write_data(fd, buffer, N);
870 /****************************************************************************
871 Set a fd into blocking/nonblocking mode. Uses POSIX O_NONBLOCK if available,
875 ****************************************************************************/
877 int set_blocking(int fd, bool set)
881 #define FLAG_TO_SET O_NONBLOCK
884 #define FLAG_TO_SET O_NDELAY
886 #define FLAG_TO_SET FNDELAY
890 if((val = sys_fcntl_long(fd, F_GETFL, 0)) == -1)
892 if(set) /* Turn blocking on - ie. clear nonblock flag */
896 return sys_fcntl_long( fd, F_SETFL, val);
900 /*******************************************************************
901 Sleep for a specified number of milliseconds.
902 ********************************************************************/
904 void smb_msleep(unsigned int t)
906 #if defined(HAVE_NANOSLEEP)
907 struct timespec tval;
910 tval.tv_sec = t/1000;
911 tval.tv_nsec = 1000000*(t%1000);
915 ret = nanosleep(&tval, &tval);
916 } while (ret < 0 && errno == EINTR && (tval.tv_sec > 0 || tval.tv_nsec > 0));
918 unsigned int tdiff=0;
919 struct timeval tval,t1,t2;
926 tval.tv_sec = (t-tdiff)/1000;
927 tval.tv_usec = 1000*((t-tdiff)%1000);
929 /* Never wait for more than 1 sec. */
930 if (tval.tv_sec > 1) {
937 sys_select_intr(0,&fds,NULL,NULL,&tval);
940 if (t2.tv_sec < t1.tv_sec) {
941 /* Someone adjusted time... */
945 tdiff = TvalDiff(&t1,&t2);
950 /****************************************************************************
951 Become a daemon, discarding the controlling terminal.
952 ****************************************************************************/
954 void become_daemon(bool Fork, bool no_process_group)
962 /* detach from the terminal */
964 if (!no_process_group) setsid();
965 #elif defined(TIOCNOTTY)
966 if (!no_process_group) {
967 int i = sys_open("/dev/tty", O_RDWR, 0);
969 ioctl(i, (int) TIOCNOTTY, (char *)0);
973 #endif /* HAVE_SETSID */
975 /* Close fd's 0,1,2. Needed if started by rsh */
976 close_low_fds(False); /* Don't close stderr, let the debug system
977 attach it to the logfile */
980 /****************************************************************************
981 Put up a yes/no prompt.
982 ****************************************************************************/
984 bool yesno(const char *p)
989 if (!fgets(ans,sizeof(ans)-1,stdin))
992 if (*ans == 'y' || *ans == 'Y')
998 #if defined(PARANOID_MALLOC_CHECKER)
1000 /****************************************************************************
1001 Internal malloc wrapper. Externally visible.
1002 ****************************************************************************/
1004 void *malloc_(size_t size)
1010 return malloc(size);
1011 #define malloc(s) __ERROR_DONT_USE_MALLOC_DIRECTLY
1014 /****************************************************************************
1015 Internal calloc wrapper. Not externally visible.
1016 ****************************************************************************/
1018 static void *calloc_(size_t count, size_t size)
1020 if (size == 0 || count == 0) {
1024 return calloc(count, size);
1025 #define calloc(n,s) __ERROR_DONT_USE_CALLOC_DIRECTLY
1028 /****************************************************************************
1029 Internal realloc wrapper. Not externally visible.
1030 ****************************************************************************/
1032 static void *realloc_(void *ptr, size_t size)
1035 return realloc(ptr, size);
1036 #define realloc(p,s) __ERROR_DONT_USE_RELLOC_DIRECTLY
1039 #endif /* PARANOID_MALLOC_CHECKER */
1041 /****************************************************************************
1043 ****************************************************************************/
1045 void *malloc_array(size_t el_size, unsigned int count)
1047 if (count >= MAX_ALLOC_SIZE/el_size) {
1051 if (el_size == 0 || count == 0) {
1054 #if defined(PARANOID_MALLOC_CHECKER)
1055 return malloc_(el_size*count);
1057 return malloc(el_size*count);
1061 /****************************************************************************
1063 ****************************************************************************/
1065 void *memalign_array(size_t el_size, size_t align, unsigned int count)
1067 if (count >= MAX_ALLOC_SIZE/el_size) {
1071 return sys_memalign(align, el_size*count);
1074 /****************************************************************************
1076 ****************************************************************************/
1078 void *calloc_array(size_t size, size_t nmemb)
1080 if (nmemb >= MAX_ALLOC_SIZE/size) {
1083 if (size == 0 || nmemb == 0) {
1086 #if defined(PARANOID_MALLOC_CHECKER)
1087 return calloc_(nmemb, size);
1089 return calloc(nmemb, size);
1093 /****************************************************************************
1094 Expand a pointer to be a particular size.
1095 Note that this version of Realloc has an extra parameter that decides
1096 whether to free the passed in storage on allocation failure or if the
1099 This is designed for use in the typical idiom of :
1101 p = SMB_REALLOC(p, size)
1106 and not to have to keep track of the old 'p' contents to free later, nor
1107 to worry if the size parameter was zero. In the case where NULL is returned
1108 we guarentee that p has been freed.
1110 If free later semantics are desired, then pass 'free_old_on_error' as False which
1111 guarentees that the old contents are not freed on error, even if size == 0. To use
1114 tmp = SMB_REALLOC_KEEP_OLD_ON_ERROR(p, size);
1122 Changes were instigated by Coverity error checking. JRA.
1123 ****************************************************************************/
1125 void *Realloc(void *p, size_t size, bool free_old_on_error)
1130 if (free_old_on_error) {
1133 DEBUG(2,("Realloc asked for 0 bytes\n"));
1137 #if defined(PARANOID_MALLOC_CHECKER)
1139 ret = (void *)malloc_(size);
1141 ret = (void *)realloc_(p,size);
1145 ret = (void *)malloc(size);
1147 ret = (void *)realloc(p,size);
1152 if (free_old_on_error && p) {
1155 DEBUG(0,("Memory allocation error: failed to expand to %d bytes\n",(int)size));
1161 /****************************************************************************
1163 ****************************************************************************/
1165 void *realloc_array(void *p, size_t el_size, unsigned int count, bool free_old_on_error)
1167 if (count >= MAX_ALLOC_SIZE/el_size) {
1168 if (free_old_on_error) {
1173 return Realloc(p, el_size*count, free_old_on_error);
1176 /****************************************************************************
1177 (Hopefully) efficient array append.
1178 ****************************************************************************/
1180 void add_to_large_array(TALLOC_CTX *mem_ctx, size_t element_size,
1181 void *element, void *_array, uint32 *num_elements,
1182 ssize_t *array_size)
1184 void **array = (void **)_array;
1186 if (*array_size < 0) {
1190 if (*array == NULL) {
1191 if (*array_size == 0) {
1195 if (*array_size >= MAX_ALLOC_SIZE/element_size) {
1199 *array = TALLOC(mem_ctx, element_size * (*array_size));
1200 if (*array == NULL) {
1205 if (*num_elements == *array_size) {
1208 if (*array_size >= MAX_ALLOC_SIZE/element_size) {
1212 *array = TALLOC_REALLOC(mem_ctx, *array,
1213 element_size * (*array_size));
1215 if (*array == NULL) {
1220 memcpy((char *)(*array) + element_size*(*num_elements),
1221 element, element_size);
1231 /****************************************************************************
1232 Free memory, checks for NULL.
1233 Use directly SAFE_FREE()
1234 Exists only because we need to pass a function pointer somewhere --SSS
1235 ****************************************************************************/
1237 void safe_free(void *p)
1242 /****************************************************************************
1243 Get my own name and IP.
1244 ****************************************************************************/
1246 char *get_myname(TALLOC_CTX *ctx)
1249 char hostname[HOST_NAME_MAX];
1253 /* get my host name */
1254 if (gethostname(hostname, sizeof(hostname)) == -1) {
1255 DEBUG(0,("gethostname failed\n"));
1259 /* Ensure null termination. */
1260 hostname[sizeof(hostname)-1] = '\0';
1262 /* split off any parts after an initial . */
1263 p = strchr_m(hostname,'.');
1268 return talloc_strdup(ctx, hostname);
1271 /****************************************************************************
1272 Get my own domain name, or "" if we have none.
1273 ****************************************************************************/
1275 char *get_mydnsdomname(TALLOC_CTX *ctx)
1277 const char *domname;
1280 domname = get_mydnsfullname();
1285 p = strchr_m(domname, '.');
1288 return talloc_strdup(ctx, p);
1290 return talloc_strdup(ctx, "");
1294 /****************************************************************************
1295 Interpret a protocol description string, with a default.
1296 ****************************************************************************/
1298 int interpret_protocol(const char *str,int def)
1300 if (strequal(str,"NT1"))
1301 return(PROTOCOL_NT1);
1302 if (strequal(str,"LANMAN2"))
1303 return(PROTOCOL_LANMAN2);
1304 if (strequal(str,"LANMAN1"))
1305 return(PROTOCOL_LANMAN1);
1306 if (strequal(str,"CORE"))
1307 return(PROTOCOL_CORE);
1308 if (strequal(str,"COREPLUS"))
1309 return(PROTOCOL_COREPLUS);
1310 if (strequal(str,"CORE+"))
1311 return(PROTOCOL_COREPLUS);
1313 DEBUG(0,("Unrecognised protocol level %s\n",str));
1319 #if (defined(HAVE_NETGROUP) && defined(WITH_AUTOMOUNT))
1320 /******************************************************************
1321 Remove any mount options such as -rsize=2048,wsize=2048 etc.
1322 Based on a fix from <Thomas.Hepper@icem.de>.
1323 Returns a malloc'ed string.
1324 *******************************************************************/
1326 static char *strip_mount_options(TALLOC_CTX *ctx, const char *str)
1329 const char *p = str;
1330 while(*p && !isspace(*p))
1332 while(*p && isspace(*p))
1335 return talloc_strdup(ctx, p);
1341 /*******************************************************************
1342 Patch from jkf@soton.ac.uk
1343 Split Luke's automount_server into YP lookup and string splitter
1344 so can easily implement automount_path().
1345 Returns a malloc'ed string.
1346 *******************************************************************/
1348 #ifdef WITH_NISPLUS_HOME
1349 char *automount_lookup(TALLOC_CTX *ctx, const char *user_name)
1353 char *nis_map = (char *)lp_nis_home_map_name();
1355 char buffer[NIS_MAXATTRVAL + 1];
1360 snprintf(buffer, sizeof(buffer), "[key=%s],%s", user_name, nis_map);
1361 DEBUG(5, ("NIS+ querystring: %s\n", buffer));
1363 if (result = nis_list(buffer, FOLLOW_PATH|EXPAND_NAME|HARD_LOOKUP, NULL, NULL)) {
1364 if (result->status != NIS_SUCCESS) {
1365 DEBUG(3, ("NIS+ query failed: %s\n", nis_sperrno(result->status)));
1367 object = result->objects.objects_val;
1368 if (object->zo_data.zo_type == ENTRY_OBJ) {
1369 entry = &object->zo_data.objdata_u.en_data;
1370 DEBUG(5, ("NIS+ entry type: %s\n", entry->en_type));
1371 DEBUG(3, ("NIS+ result: %s\n", entry->en_cols.en_cols_val[1].ec_value.ec_value_val));
1373 value = talloc_strdup(ctx,
1374 entry->en_cols.en_cols_val[1].ec_value.ec_value_val);
1376 nis_freeresult(result);
1379 value = talloc_string_sub(ctx,
1386 nis_freeresult(result);
1389 value = strip_mount_options(ctx, value);
1390 DEBUG(4, ("NIS+ Lookup: %s resulted in %s\n",
1395 #else /* WITH_NISPLUS_HOME */
1397 char *automount_lookup(TALLOC_CTX *ctx, const char *user_name)
1401 int nis_error; /* returned by yp all functions */
1402 char *nis_result; /* yp_match inits this */
1403 int nis_result_len; /* and set this */
1404 char *nis_domain; /* yp_get_default_domain inits this */
1405 char *nis_map = (char *)lp_nis_home_map_name();
1407 if ((nis_error = yp_get_default_domain(&nis_domain)) != 0) {
1408 DEBUG(3, ("YP Error: %s\n", yperr_string(nis_error)));
1412 DEBUG(5, ("NIS Domain: %s\n", nis_domain));
1414 if ((nis_error = yp_match(nis_domain, nis_map, user_name,
1415 strlen(user_name), &nis_result,
1416 &nis_result_len)) == 0) {
1417 value = talloc_strdup(ctx, nis_result);
1421 value = strip_mount_options(ctx, value);
1422 } else if(nis_error == YPERR_KEY) {
1423 DEBUG(3, ("YP Key not found: while looking up \"%s\" in map \"%s\"\n",
1424 user_name, nis_map));
1425 DEBUG(3, ("using defaults for server and home directory\n"));
1427 DEBUG(3, ("YP Error: \"%s\" while looking up \"%s\" in map \"%s\"\n",
1428 yperr_string(nis_error), user_name, nis_map));
1432 DEBUG(4, ("YP Lookup: %s resulted in %s\n", user_name, value));
1436 #endif /* WITH_NISPLUS_HOME */
1439 /****************************************************************************
1440 Check if a process exists. Does this work on all unixes?
1441 ****************************************************************************/
1443 bool process_exists(const struct server_id pid)
1445 if (procid_is_me(&pid)) {
1449 if (procid_is_local(&pid)) {
1450 return (kill(pid.pid,0) == 0 || errno != ESRCH);
1453 #ifdef CLUSTER_SUPPORT
1454 return ctdbd_process_exists(messaging_ctdbd_connection(), pid.vnn,
1461 bool process_exists_by_pid(pid_t pid)
1463 /* Doing kill with a non-positive pid causes messages to be
1464 * sent to places we don't want. */
1465 SMB_ASSERT(pid > 0);
1466 return(kill(pid,0) == 0 || errno != ESRCH);
1469 /*******************************************************************
1470 Convert a uid into a user name.
1471 ********************************************************************/
1473 const char *uidtoname(uid_t uid)
1475 TALLOC_CTX *ctx = talloc_tos();
1477 struct passwd *pass = NULL;
1479 pass = getpwuid_alloc(ctx,uid);
1481 name = talloc_strdup(ctx,pass->pw_name);
1484 name = talloc_asprintf(ctx,
1491 /*******************************************************************
1492 Convert a gid into a group name.
1493 ********************************************************************/
1495 char *gidtoname(gid_t gid)
1499 grp = getgrgid(gid);
1501 return talloc_strdup(talloc_tos(), grp->gr_name);
1504 return talloc_asprintf(talloc_tos(),
1510 /*******************************************************************
1511 Convert a user name into a uid.
1512 ********************************************************************/
1514 uid_t nametouid(const char *name)
1516 struct passwd *pass;
1520 pass = getpwnam_alloc(NULL, name);
1527 u = (uid_t)strtol(name, &p, 0);
1528 if ((p != name) && (*p == '\0'))
1534 /*******************************************************************
1535 Convert a name to a gid_t if possible. Return -1 if not a group.
1536 ********************************************************************/
1538 gid_t nametogid(const char *name)
1544 g = (gid_t)strtol(name, &p, 0);
1545 if ((p != name) && (*p == '\0'))
1548 grp = sys_getgrnam(name);
1550 return(grp->gr_gid);
1554 /*******************************************************************
1555 Something really nasty happened - panic !
1556 ********************************************************************/
1558 void smb_panic(const char *const why)
1566 if (global_clobber_region_function) {
1567 DEBUG(0,("smb_panic: clobber_region() last called from [%s(%u)]\n",
1568 global_clobber_region_function,
1569 global_clobber_region_line));
1574 DEBUG(0,("PANIC (pid %llu): %s\n",
1575 (unsigned long long)sys_getpid(), why));
1578 cmd = lp_panic_action();
1580 DEBUG(0, ("smb_panic(): calling panic action [%s]\n", cmd));
1581 result = system(cmd);
1584 DEBUG(0, ("smb_panic(): fork failed in panic action: %s\n",
1587 DEBUG(0, ("smb_panic(): action returned status %d\n",
1588 WEXITSTATUS(result)));
1594 /*******************************************************************
1595 Print a backtrace of the stack to the debug log. This function
1596 DELIBERATELY LEAKS MEMORY. The expectation is that you should
1597 exit shortly after calling it.
1598 ********************************************************************/
1600 #ifdef HAVE_LIBUNWIND_H
1601 #include <libunwind.h>
1604 #ifdef HAVE_EXECINFO_H
1605 #include <execinfo.h>
1608 #ifdef HAVE_LIBEXC_H
1612 void log_stack_trace(void)
1614 #ifdef HAVE_LIBUNWIND
1615 /* Try to use libunwind before any other technique since on ia64
1616 * libunwind correctly walks the stack in more circumstances than
1619 unw_cursor_t cursor;
1624 unw_word_t ip, sp, off;
1626 procname[sizeof(procname) - 1] = '\0';
1628 if (unw_getcontext(&uc) != 0) {
1629 goto libunwind_failed;
1632 if (unw_init_local(&cursor, &uc) != 0) {
1633 goto libunwind_failed;
1636 DEBUG(0, ("BACKTRACE:\n"));
1640 unw_get_reg(&cursor, UNW_REG_IP, &ip);
1641 unw_get_reg(&cursor, UNW_REG_SP, &sp);
1643 switch (unw_get_proc_name(&cursor,
1644 procname, sizeof(procname) - 1, &off) ) {
1648 /* Name truncated. */
1649 DEBUGADD(0, (" #%u %s + %#llx [ip=%#llx] [sp=%#llx]\n",
1650 i, procname, (long long)off,
1651 (long long)ip, (long long) sp));
1654 /* case -UNW_ENOINFO: */
1655 /* case -UNW_EUNSPEC: */
1656 /* No symbol name found. */
1657 DEBUGADD(0, (" #%u %s [ip=%#llx] [sp=%#llx]\n",
1658 i, "<unknown symbol>",
1659 (long long)ip, (long long) sp));
1662 } while (unw_step(&cursor) > 0);
1667 DEBUG(0, ("unable to produce a stack trace with libunwind\n"));
1669 #elif HAVE_BACKTRACE_SYMBOLS
1670 void *backtrace_stack[BACKTRACE_STACK_SIZE];
1671 size_t backtrace_size;
1672 char **backtrace_strings;
1674 /* get the backtrace (stack frames) */
1675 backtrace_size = backtrace(backtrace_stack,BACKTRACE_STACK_SIZE);
1676 backtrace_strings = backtrace_symbols(backtrace_stack, backtrace_size);
1678 DEBUG(0, ("BACKTRACE: %lu stack frames:\n",
1679 (unsigned long)backtrace_size));
1681 if (backtrace_strings) {
1684 for (i = 0; i < backtrace_size; i++)
1685 DEBUGADD(0, (" #%u %s\n", i, backtrace_strings[i]));
1687 /* Leak the backtrace_strings, rather than risk what free() might do */
1692 /* The IRIX libexc library provides an API for unwinding the stack. See
1693 * libexc(3) for details. Apparantly trace_back_stack leaks memory, but
1694 * since we are about to abort anyway, it hardly matters.
1697 #define NAMESIZE 32 /* Arbitrary */
1699 __uint64_t addrs[BACKTRACE_STACK_SIZE];
1700 char * names[BACKTRACE_STACK_SIZE];
1701 char namebuf[BACKTRACE_STACK_SIZE * NAMESIZE];
1708 ZERO_ARRAY(namebuf);
1710 /* We need to be root so we can open our /proc entry to walk
1711 * our stack. It also helps when we want to dump core.
1715 for (i = 0; i < BACKTRACE_STACK_SIZE; i++) {
1716 names[i] = namebuf + (i * NAMESIZE);
1719 levels = trace_back_stack(0, addrs, names,
1720 BACKTRACE_STACK_SIZE, NAMESIZE - 1);
1722 DEBUG(0, ("BACKTRACE: %d stack frames:\n", levels));
1723 for (i = 0; i < levels; i++) {
1724 DEBUGADD(0, (" #%d 0x%llx %s\n", i, addrs[i], names[i]));
1729 DEBUG(0, ("unable to produce a stack trace on this platform\n"));
1733 /*******************************************************************
1734 A readdir wrapper which just returns the file name.
1735 ********************************************************************/
1737 const char *readdirname(SMB_STRUCT_DIR *p)
1739 SMB_STRUCT_DIRENT *ptr;
1745 ptr = (SMB_STRUCT_DIRENT *)sys_readdir(p);
1749 dname = ptr->d_name;
1756 #ifdef HAVE_BROKEN_READDIR_NAME
1757 /* using /usr/ucb/cc is BAD */
1761 return talloc_strdup(talloc_tos(), dname);
1764 /*******************************************************************
1765 Utility function used to decide if the last component
1766 of a path matches a (possibly wildcarded) entry in a namelist.
1767 ********************************************************************/
1769 bool is_in_path(const char *name, name_compare_entry *namelist, bool case_sensitive)
1771 const char *last_component;
1773 /* if we have no list it's obviously not in the path */
1774 if((namelist == NULL ) || ((namelist != NULL) && (namelist[0].name == NULL))) {
1778 DEBUG(8, ("is_in_path: %s\n", name));
1780 /* Get the last component of the unix name. */
1781 last_component = strrchr_m(name, '/');
1782 if (!last_component) {
1783 last_component = name;
1785 last_component++; /* Go past '/' */
1788 for(; namelist->name != NULL; namelist++) {
1789 if(namelist->is_wild) {
1790 if (mask_match(last_component, namelist->name, case_sensitive)) {
1791 DEBUG(8,("is_in_path: mask match succeeded\n"));
1795 if((case_sensitive && (strcmp(last_component, namelist->name) == 0))||
1796 (!case_sensitive && (StrCaseCmp(last_component, namelist->name) == 0))) {
1797 DEBUG(8,("is_in_path: match succeeded\n"));
1802 DEBUG(8,("is_in_path: match not found\n"));
1806 /*******************************************************************
1807 Strip a '/' separated list into an array of
1808 name_compare_enties structures suitable for
1809 passing to is_in_path(). We do this for
1810 speed so we can pre-parse all the names in the list
1811 and don't do it for each call to is_in_path().
1812 namelist is modified here and is assumed to be
1813 a copy owned by the caller.
1814 We also check if the entry contains a wildcard to
1815 remove a potentially expensive call to mask_match
1817 ********************************************************************/
1819 void set_namearray(name_compare_entry **ppname_array, char *namelist)
1822 char *nameptr = namelist;
1823 int num_entries = 0;
1826 (*ppname_array) = NULL;
1828 if((nameptr == NULL ) || ((nameptr != NULL) && (*nameptr == '\0')))
1831 /* We need to make two passes over the string. The
1832 first to count the number of elements, the second
1837 if ( *nameptr == '/' ) {
1838 /* cope with multiple (useless) /s) */
1842 /* find the next / */
1843 name_end = strchr_m(nameptr, '/');
1845 /* oops - the last check for a / didn't find one. */
1846 if (name_end == NULL)
1849 /* next segment please */
1850 nameptr = name_end + 1;
1854 if(num_entries == 0)
1857 if(( (*ppname_array) = SMB_MALLOC_ARRAY(name_compare_entry, num_entries + 1)) == NULL) {
1858 DEBUG(0,("set_namearray: malloc fail\n"));
1862 /* Now copy out the names */
1866 if ( *nameptr == '/' ) {
1867 /* cope with multiple (useless) /s) */
1871 /* find the next / */
1872 if ((name_end = strchr_m(nameptr, '/')) != NULL)
1875 /* oops - the last check for a / didn't find one. */
1876 if(name_end == NULL)
1879 (*ppname_array)[i].is_wild = ms_has_wild(nameptr);
1880 if(((*ppname_array)[i].name = SMB_STRDUP(nameptr)) == NULL) {
1881 DEBUG(0,("set_namearray: malloc fail (1)\n"));
1885 /* next segment please */
1886 nameptr = name_end + 1;
1890 (*ppname_array)[i].name = NULL;
1895 /****************************************************************************
1896 Routine to free a namearray.
1897 ****************************************************************************/
1899 void free_namearray(name_compare_entry *name_array)
1903 if(name_array == NULL)
1906 for(i=0; name_array[i].name!=NULL; i++)
1907 SAFE_FREE(name_array[i].name);
1908 SAFE_FREE(name_array);
1912 #define DBGC_CLASS DBGC_LOCKING
1914 /****************************************************************************
1915 Simple routine to do POSIX file locking. Cruft in NFS and 64->32 bit mapping
1916 is dealt with in posix.c
1917 Returns True if the lock was granted, False otherwise.
1918 ****************************************************************************/
1920 bool fcntl_lock(int fd, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
1922 SMB_STRUCT_FLOCK lock;
1925 DEBUG(8,("fcntl_lock fd=%d op=%d offset=%.0f count=%.0f type=%d\n",
1926 fd,op,(double)offset,(double)count,type));
1929 lock.l_whence = SEEK_SET;
1930 lock.l_start = offset;
1934 ret = sys_fcntl_ptr(fd,op,&lock);
1938 DEBUG(3,("fcntl_lock: lock failed at offset %.0f count %.0f op %d type %d (%s)\n",
1939 (double)offset,(double)count,op,type,strerror(errno)));
1944 /* everything went OK */
1945 DEBUG(8,("fcntl_lock: Lock call successful\n"));
1950 /****************************************************************************
1951 Simple routine to query existing file locks. Cruft in NFS and 64->32 bit mapping
1952 is dealt with in posix.c
1953 Returns True if we have information regarding this lock region (and returns
1954 F_UNLCK in *ptype if the region is unlocked). False if the call failed.
1955 ****************************************************************************/
1957 bool fcntl_getlock(int fd, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype, pid_t *ppid)
1959 SMB_STRUCT_FLOCK lock;
1962 DEBUG(8,("fcntl_getlock fd=%d offset=%.0f count=%.0f type=%d\n",
1963 fd,(double)*poffset,(double)*pcount,*ptype));
1965 lock.l_type = *ptype;
1966 lock.l_whence = SEEK_SET;
1967 lock.l_start = *poffset;
1968 lock.l_len = *pcount;
1971 ret = sys_fcntl_ptr(fd,SMB_F_GETLK,&lock);
1975 DEBUG(3,("fcntl_getlock: lock request failed at offset %.0f count %.0f type %d (%s)\n",
1976 (double)*poffset,(double)*pcount,*ptype,strerror(errno)));
1981 *ptype = lock.l_type;
1982 *poffset = lock.l_start;
1983 *pcount = lock.l_len;
1986 DEBUG(3,("fcntl_getlock: fd %d is returned info %d pid %u\n",
1987 fd, (int)lock.l_type, (unsigned int)lock.l_pid));
1992 #define DBGC_CLASS DBGC_ALL
1994 /*******************************************************************
1995 Is the name specified one of my netbios names.
1996 Returns true if it is equal, false otherwise.
1997 ********************************************************************/
1999 bool is_myname(const char *s)
2004 for (n=0; my_netbios_names(n); n++) {
2005 if (strequal(my_netbios_names(n), s)) {
2010 DEBUG(8, ("is_myname(\"%s\") returns %d\n", s, ret));
2014 /*******************************************************************
2015 Is the name specified our workgroup/domain.
2016 Returns true if it is equal, false otherwise.
2017 ********************************************************************/
2019 bool is_myworkgroup(const char *s)
2023 if (strequal(s, lp_workgroup())) {
2027 DEBUG(8, ("is_myworkgroup(\"%s\") returns %d\n", s, ret));
2031 /*******************************************************************
2032 we distinguish between 2K and XP by the "Native Lan Manager" string
2033 WinXP => "Windows 2002 5.1"
2034 WinXP 64bit => "Windows XP 5.2"
2035 Win2k => "Windows 2000 5.0"
2036 NT4 => "Windows NT 4.0"
2037 Win9x => "Windows 4.0"
2038 Windows 2003 doesn't set the native lan manager string but
2039 they do set the domain to "Windows 2003 5.2" (probably a bug).
2040 ********************************************************************/
2042 void ra_lanman_string( const char *native_lanman )
2044 if ( strcmp( native_lanman, "Windows 2002 5.1" ) == 0 )
2045 set_remote_arch( RA_WINXP );
2046 else if ( strcmp( native_lanman, "Windows XP 5.2" ) == 0 )
2047 set_remote_arch( RA_WINXP );
2048 else if ( strcmp( native_lanman, "Windows Server 2003 5.2" ) == 0 )
2049 set_remote_arch( RA_WIN2K3 );
2052 static const char *remote_arch_str;
2054 const char *get_remote_arch_str(void)
2056 if (!remote_arch_str) {
2059 return remote_arch_str;
2062 /*******************************************************************
2063 Set the horrid remote_arch string based on an enum.
2064 ********************************************************************/
2066 void set_remote_arch(enum remote_arch_types type)
2071 remote_arch_str = "WfWg";
2074 remote_arch_str = "OS2";
2077 remote_arch_str = "Win95";
2080 remote_arch_str = "WinNT";
2083 remote_arch_str = "Win2K";
2086 remote_arch_str = "WinXP";
2089 remote_arch_str = "Win2K3";
2092 remote_arch_str = "Vista";
2095 remote_arch_str = "Samba";
2098 remote_arch_str = "CIFSFS";
2101 ra_type = RA_UNKNOWN;
2102 remote_arch_str = "UNKNOWN";
2106 DEBUG(10,("set_remote_arch: Client arch is \'%s\'\n",
2110 /*******************************************************************
2111 Get the remote_arch type.
2112 ********************************************************************/
2114 enum remote_arch_types get_remote_arch(void)
2119 void print_asc(int level, const unsigned char *buf,int len)
2123 DEBUG(level,("%c", isprint(buf[i])?buf[i]:'.'));
2126 void dump_data(int level, const unsigned char *buf1,int len)
2128 const unsigned char *buf = (const unsigned char *)buf1;
2132 if (!DEBUGLVL(level)) return;
2134 DEBUGADD(level,("[%03X] ",i));
2136 DEBUGADD(level,("%02X ",(int)buf[i]));
2138 if (i%8 == 0) DEBUGADD(level,(" "));
2140 print_asc(level,&buf[i-16],8); DEBUGADD(level,(" "));
2141 print_asc(level,&buf[i-8],8); DEBUGADD(level,("\n"));
2142 if (i<len) DEBUGADD(level,("[%03X] ",i));
2148 DEBUGADD(level,(" "));
2149 if (n>8) DEBUGADD(level,(" "));
2150 while (n--) DEBUGADD(level,(" "));
2152 print_asc(level,&buf[i-(i%16)],n); DEBUGADD(level,( " " ));
2154 if (n>0) print_asc(level,&buf[i-n],n);
2155 DEBUGADD(level,("\n"));
2159 void dump_data_pw(const char *msg, const uchar * data, size_t len)
2161 #ifdef DEBUG_PASSWORD
2162 DEBUG(11, ("%s", msg));
2163 if (data != NULL && len > 0)
2165 dump_data(11, data, len);
2170 const char *tab_depth(int level, int depth)
2172 if( DEBUGLVL(level) ) {
2173 dbgtext("%*s", depth*4, "");
2178 /*****************************************************************************
2179 Provide a checksum on a string
2181 Input: s - the null-terminated character string for which the checksum
2184 Output: The checksum value calculated for s.
2185 *****************************************************************************/
2187 int str_checksum(const char *s)
2195 res ^= (c << (i % 15)) ^ (c >> (15-(i%15)));
2202 /*****************************************************************
2203 Zero a memory area then free it. Used to catch bugs faster.
2204 *****************************************************************/
2206 void zero_free(void *p, size_t size)
2212 /*****************************************************************
2213 Set our open file limit to a requested max and return the limit.
2214 *****************************************************************/
2216 int set_maxfiles(int requested_max)
2218 #if (defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE))
2220 int saved_current_limit;
2222 if(getrlimit(RLIMIT_NOFILE, &rlp)) {
2223 DEBUG(0,("set_maxfiles: getrlimit (1) for RLIMIT_NOFILE failed with error %s\n",
2226 return requested_max;
2230 * Set the fd limit to be real_max_open_files + MAX_OPEN_FUDGEFACTOR to
2231 * account for the extra fd we need
2232 * as well as the log files and standard
2233 * handles etc. Save the limit we want to set in case
2234 * we are running on an OS that doesn't support this limit (AIX)
2235 * which always returns RLIM_INFINITY for rlp.rlim_max.
2238 /* Try raising the hard (max) limit to the requested amount. */
2240 #if defined(RLIM_INFINITY)
2241 if (rlp.rlim_max != RLIM_INFINITY) {
2242 int orig_max = rlp.rlim_max;
2244 if ( rlp.rlim_max < requested_max )
2245 rlp.rlim_max = requested_max;
2247 /* This failing is not an error - many systems (Linux) don't
2248 support our default request of 10,000 open files. JRA. */
2250 if(setrlimit(RLIMIT_NOFILE, &rlp)) {
2251 DEBUG(3,("set_maxfiles: setrlimit for RLIMIT_NOFILE for %d max files failed with error %s\n",
2252 (int)rlp.rlim_max, strerror(errno) ));
2254 /* Set failed - restore original value from get. */
2255 rlp.rlim_max = orig_max;
2260 /* Now try setting the soft (current) limit. */
2262 saved_current_limit = rlp.rlim_cur = MIN(requested_max,rlp.rlim_max);
2264 if(setrlimit(RLIMIT_NOFILE, &rlp)) {
2265 DEBUG(0,("set_maxfiles: setrlimit for RLIMIT_NOFILE for %d files failed with error %s\n",
2266 (int)rlp.rlim_cur, strerror(errno) ));
2268 return saved_current_limit;
2271 if(getrlimit(RLIMIT_NOFILE, &rlp)) {
2272 DEBUG(0,("set_maxfiles: getrlimit (2) for RLIMIT_NOFILE failed with error %s\n",
2275 return saved_current_limit;
2278 #if defined(RLIM_INFINITY)
2279 if(rlp.rlim_cur == RLIM_INFINITY)
2280 return saved_current_limit;
2283 if((int)rlp.rlim_cur > saved_current_limit)
2284 return saved_current_limit;
2286 return rlp.rlim_cur;
2287 #else /* !defined(HAVE_GETRLIMIT) || !defined(RLIMIT_NOFILE) */
2289 * No way to know - just guess...
2291 return requested_max;
2295 /*****************************************************************
2296 Possibly replace mkstemp if it is broken.
2297 *****************************************************************/
2299 int smb_mkstemp(char *name_template)
2301 #if HAVE_SECURE_MKSTEMP
2302 return mkstemp(name_template);
2304 /* have a reasonable go at emulating it. Hope that
2305 the system mktemp() isn't completly hopeless */
2306 char *p = mktemp(name_template);
2309 return open(p, O_CREAT|O_EXCL|O_RDWR, 0600);
2313 /*****************************************************************
2314 malloc that aborts with smb_panic on fail or zero size.
2315 *****************************************************************/
2317 void *smb_xmalloc_array(size_t size, unsigned int count)
2321 smb_panic("smb_xmalloc_array: called with zero size");
2323 if (count >= MAX_ALLOC_SIZE/size) {
2324 smb_panic("smb_xmalloc_array: alloc size too large");
2326 if ((p = SMB_MALLOC(size*count)) == NULL) {
2327 DEBUG(0, ("smb_xmalloc_array failed to allocate %lu * %lu bytes\n",
2328 (unsigned long)size, (unsigned long)count));
2329 smb_panic("smb_xmalloc_array: malloc failed");
2335 Memdup with smb_panic on fail.
2338 void *smb_xmemdup(const void *p, size_t size)
2341 p2 = SMB_XMALLOC_ARRAY(unsigned char,size);
2342 memcpy(p2, p, size);
2347 strdup that aborts on malloc fail.
2350 char *smb_xstrdup(const char *s)
2352 #if defined(PARANOID_MALLOC_CHECKER)
2359 #define strdup rep_strdup
2362 char *s1 = strdup(s);
2363 #if defined(PARANOID_MALLOC_CHECKER)
2367 #define strdup(s) __ERROR_DONT_USE_STRDUP_DIRECTLY
2370 smb_panic("smb_xstrdup: malloc failed");
2377 strndup that aborts on malloc fail.
2380 char *smb_xstrndup(const char *s, size_t n)
2382 #if defined(PARANOID_MALLOC_CHECKER)
2388 #if (defined(BROKEN_STRNDUP) || !defined(HAVE_STRNDUP))
2390 #define strndup rep_strndup
2393 char *s1 = strndup(s, n);
2394 #if defined(PARANOID_MALLOC_CHECKER)
2398 #define strndup(s,n) __ERROR_DONT_USE_STRNDUP_DIRECTLY
2401 smb_panic("smb_xstrndup: malloc failed");
2407 vasprintf that aborts on malloc fail
2410 int smb_xvasprintf(char **ptr, const char *format, va_list ap)
2417 n = vasprintf(ptr, format, ap2);
2418 if (n == -1 || ! *ptr) {
2419 smb_panic("smb_xvasprintf: out of memory");
2424 /*****************************************************************
2425 Like strdup but for memory.
2426 *****************************************************************/
2428 void *memdup(const void *p, size_t size)
2433 p2 = SMB_MALLOC(size);
2436 memcpy(p2, p, size);
2440 /*****************************************************************
2441 Get local hostname and cache result.
2442 *****************************************************************/
2444 char *myhostname(void)
2448 /* This is cached forever so
2449 * use NULL talloc ctx. */
2450 ret = get_myname(NULL);
2455 /*****************************************************************
2456 A useful function for returning a path in the Samba pid directory.
2457 *****************************************************************/
2459 static char *xx_path(const char *name, const char *rootpath)
2463 fname = talloc_strdup(talloc_tos(), rootpath);
2467 trim_string(fname,"","/");
2469 if (!directory_exist(fname,NULL)) {
2473 return talloc_asprintf(talloc_tos(),
2479 /*****************************************************************
2480 A useful function for returning a path in the Samba lock directory.
2481 *****************************************************************/
2483 char *lock_path(const char *name)
2485 return xx_path(name, lp_lockdir());
2488 /*****************************************************************
2489 A useful function for returning a path in the Samba pid directory.
2490 *****************************************************************/
2492 char *pid_path(const char *name)
2494 return xx_path(name, lp_piddir());
2498 * @brief Returns an absolute path to a file in the Samba lib directory.
2500 * @param name File to find, relative to LIBDIR.
2502 * @retval Pointer to a string containing the full path.
2505 char *lib_path(const char *name)
2507 return talloc_asprintf(talloc_tos(), "%s/%s", get_dyn_LIBDIR(), name);
2511 * @brief Returns an absolute path to a file in the Samba data directory.
2513 * @param name File to find, relative to CODEPAGEDIR.
2515 * @retval Pointer to a talloc'ed string containing the full path.
2518 char *data_path(const char *name)
2520 return talloc_asprintf(talloc_tos(), "%s/%s", get_dyn_CODEPAGEDIR(), name);
2523 /*****************************************************************
2524 a useful function for returning a path in the Samba state directory
2525 *****************************************************************/
2527 char *state_path(const char *name)
2529 return xx_path(name, get_dyn_STATEDIR());
2533 * @brief Returns the platform specific shared library extension.
2535 * @retval Pointer to a const char * containing the extension.
2538 const char *shlib_ext(void)
2540 return get_dyn_SHLIBEXT();
2543 /*******************************************************************
2544 Given a filename - get its directory name
2545 NB: Returned in static storage. Caveats:
2546 o If caller wishes to preserve, they should copy.
2547 ********************************************************************/
2549 char *parent_dirname(const char *path)
2553 if (!parent_dirname_talloc(talloc_tos(), path, &parent, NULL)) {
2560 bool parent_dirname_talloc(TALLOC_CTX *mem_ctx, const char *dir,
2561 char **parent, const char **name)
2566 p = strrchr_m(dir, '/'); /* Find final '/', if any */
2569 if (!(*parent = talloc_strdup(mem_ctx, "."))) {
2580 if (!(*parent = TALLOC_ARRAY(mem_ctx, char, len+1))) {
2583 memcpy(*parent, dir, len);
2584 (*parent)[len] = '\0';
2592 /*******************************************************************
2593 Determine if a pattern contains any Microsoft wildcard characters.
2594 *******************************************************************/
2596 bool ms_has_wild(const char *s)
2600 if (lp_posix_pathnames()) {
2601 /* With posix pathnames no characters are wild. */
2605 while ((c = *s++)) {
2618 bool ms_has_wild_w(const smb_ucs2_t *s)
2621 if (!s) return False;
2622 while ((c = *s++)) {
2624 case UCS2_CHAR('*'):
2625 case UCS2_CHAR('?'):
2626 case UCS2_CHAR('<'):
2627 case UCS2_CHAR('>'):
2628 case UCS2_CHAR('"'):
2635 /*******************************************************************
2636 A wrapper that handles case sensitivity and the special handling
2638 *******************************************************************/
2640 bool mask_match(const char *string, const char *pattern, bool is_case_sensitive)
2642 if (strcmp(string,"..") == 0)
2644 if (strcmp(pattern,".") == 0)
2647 return ms_fnmatch(pattern, string, Protocol <= PROTOCOL_LANMAN2, is_case_sensitive) == 0;
2650 /*******************************************************************
2651 A wrapper that handles case sensitivity and the special handling
2652 of the ".." name. Varient that is only called by old search code which requires
2653 pattern translation.
2654 *******************************************************************/
2656 bool mask_match_search(const char *string, const char *pattern, bool is_case_sensitive)
2658 if (strcmp(string,"..") == 0)
2660 if (strcmp(pattern,".") == 0)
2663 return ms_fnmatch(pattern, string, True, is_case_sensitive) == 0;
2666 /*******************************************************************
2667 A wrapper that handles a list of patters and calls mask_match()
2668 on each. Returns True if any of the patterns match.
2669 *******************************************************************/
2671 bool mask_match_list(const char *string, char **list, int listLen, bool is_case_sensitive)
2673 while (listLen-- > 0) {
2674 if (mask_match(string, *list++, is_case_sensitive))
2680 /*********************************************************
2681 Recursive routine that is called by unix_wild_match.
2682 *********************************************************/
2684 static bool unix_do_match(const char *regexp, const char *str)
2688 for( p = regexp; *p && *str; ) {
2699 * Look for a character matching
2700 * the one after the '*'.
2704 return true; /* Automatic match */
2707 while(*str && (*p != *str))
2711 * Patch from weidel@multichart.de. In the case of the regexp
2712 * '*XX*' we want to ensure there are at least 2 'X' characters
2713 * in the string after the '*' for a match to be made.
2720 * Eat all the characters that match, but count how many there were.
2723 while(*str && (*p == *str)) {
2729 * Now check that if the regexp had n identical characters that
2730 * matchcount had at least that many matches.
2733 while ( *(p+1) && (*(p+1) == *p)) {
2738 if ( matchcount <= 0 )
2742 str--; /* We've eaten the match char after the '*' */
2744 if(unix_do_match(p, str))
2766 if (!*p && str[0] == '.' && str[1] == 0)
2769 if (!*str && *p == '?') {
2775 if(!*str && (*p == '*' && p[1] == '\0'))
2781 /*******************************************************************
2782 Simple case insensitive interface to a UNIX wildcard matcher.
2783 Returns True if match, False if not.
2784 *******************************************************************/
2786 bool unix_wild_match(const char *pattern, const char *string)
2788 TALLOC_CTX *ctx = talloc_stackframe();
2794 p2 = talloc_strdup(ctx,pattern);
2795 s2 = talloc_strdup(ctx,string);
2803 /* Remove any *? and ** from the pattern as they are meaningless */
2804 for(p = p2; *p; p++) {
2805 while( *p == '*' && (p[1] == '?' ||p[1] == '*')) {
2806 memmove(&p[1], &p[2], strlen(&p[2])+1);
2810 if (strequal(p2,"*")) {
2815 ret = unix_do_match(p2, s2);
2820 /**********************************************************************
2821 Converts a name to a fully qualified domain name.
2822 Returns true if lookup succeeded, false if not (then fqdn is set to name)
2823 Note we deliberately use gethostbyname here, not getaddrinfo as we want
2824 to examine the h_aliases and I don't know how to do that with getaddrinfo.
2825 ***********************************************************************/
2827 bool name_to_fqdn(fstring fqdn, const char *name)
2830 struct hostent *hp = gethostbyname(name);
2832 if (!hp || !hp->h_name || !*hp->h_name) {
2833 DEBUG(10,("name_to_fqdn: lookup for %s failed.\n", name));
2834 fstrcpy(fqdn, name);
2838 /* Find out if the fqdn is returned as an alias
2839 * to cope with /etc/hosts files where the first
2840 * name is not the fqdn but the short name */
2841 if (hp->h_aliases && (! strchr_m(hp->h_name, '.'))) {
2843 for (i = 0; hp->h_aliases[i]; i++) {
2844 if (strchr_m(hp->h_aliases[i], '.')) {
2845 full = hp->h_aliases[i];
2850 if (full && (StrCaseCmp(full, "localhost.localdomain") == 0)) {
2851 DEBUG(1, ("WARNING: your /etc/hosts file may be broken!\n"));
2852 DEBUGADD(1, (" Specifing the machine hostname for address 127.0.0.1 may lead\n"));
2853 DEBUGADD(1, (" to Kerberos authentication problems as localhost.localdomain\n"));
2854 DEBUGADD(1, (" may end up being used instead of the real machine FQDN.\n"));
2861 DEBUG(10,("name_to_fqdn: lookup for %s -> %s.\n", name, full));
2862 fstrcpy(fqdn, full);
2866 /**********************************************************************
2867 Extension to talloc_get_type: Abort on type mismatch
2868 ***********************************************************************/
2870 void *talloc_check_name_abort(const void *ptr, const char *name)
2874 result = talloc_check_name(ptr, name);
2878 DEBUG(0, ("Talloc type mismatch, expected %s, got %s\n",
2879 name, talloc_get_name(ptr)));
2880 smb_panic("talloc type mismatch");
2881 /* Keep the compiler happy */
2885 uint32 map_share_mode_to_deny_mode(uint32 share_access, uint32 private_options)
2887 switch (share_access & ~FILE_SHARE_DELETE) {
2888 case FILE_SHARE_NONE:
2890 case FILE_SHARE_READ:
2892 case FILE_SHARE_WRITE:
2894 case FILE_SHARE_READ|FILE_SHARE_WRITE:
2897 if (private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS) {
2899 } else if (private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_FCB) {
2906 pid_t procid_to_pid(const struct server_id *proc)
2911 static uint32 my_vnn = NONCLUSTER_VNN;
2913 void set_my_vnn(uint32 vnn)
2915 DEBUG(10, ("vnn pid %d = %u\n", (int)sys_getpid(), (unsigned int)vnn));
2919 uint32 get_my_vnn(void)
2924 struct server_id pid_to_procid(pid_t pid)
2926 struct server_id result;
2928 #ifdef CLUSTER_SUPPORT
2929 result.vnn = my_vnn;
2934 struct server_id procid_self(void)
2936 return pid_to_procid(sys_getpid());
2939 struct server_id server_id_self(void)
2941 return procid_self();
2944 bool procid_equal(const struct server_id *p1, const struct server_id *p2)
2946 if (p1->pid != p2->pid)
2948 #ifdef CLUSTER_SUPPORT
2949 if (p1->vnn != p2->vnn)
2955 bool cluster_id_equal(const struct server_id *id1,
2956 const struct server_id *id2)
2958 return procid_equal(id1, id2);
2961 bool procid_is_me(const struct server_id *pid)
2963 if (pid->pid != sys_getpid())
2965 #ifdef CLUSTER_SUPPORT
2966 if (pid->vnn != my_vnn)
2972 struct server_id interpret_pid(const char *pid_string)
2974 #ifdef CLUSTER_SUPPORT
2975 unsigned int vnn, pid;
2976 struct server_id result;
2977 if (sscanf(pid_string, "%u:%u", &vnn, &pid) == 2) {
2981 else if (sscanf(pid_string, "%u", &pid) == 1) {
2982 result.vnn = NONCLUSTER_VNN;
2986 result.vnn = NONCLUSTER_VNN;
2991 return pid_to_procid(atoi(pid_string));
2995 char *procid_str(TALLOC_CTX *mem_ctx, const struct server_id *pid)
2997 #ifdef CLUSTER_SUPPORT
2998 if (pid->vnn == NONCLUSTER_VNN) {
2999 return talloc_asprintf(mem_ctx,
3004 return talloc_asprintf(mem_ctx,
3010 return talloc_asprintf(mem_ctx,
3016 char *procid_str_static(const struct server_id *pid)
3018 return procid_str(talloc_tos(), pid);
3021 bool procid_valid(const struct server_id *pid)
3023 return (pid->pid != -1);
3026 bool procid_is_local(const struct server_id *pid)
3028 #ifdef CLUSTER_SUPPORT
3029 return pid->vnn == my_vnn;
3035 int this_is_smp(void)
3037 #if defined(HAVE_SYSCONF)
3039 #if defined(SYSCONF_SC_NPROC_ONLN)
3040 return (sysconf(_SC_NPROC_ONLN) > 1) ? 1 : 0;
3041 #elif defined(SYSCONF_SC_NPROCESSORS_ONLN)
3042 return (sysconf(_SC_NPROCESSORS_ONLN) > 1) ? 1 : 0;
3052 /****************************************************************
3053 Check if an offset into a buffer is safe.
3054 If this returns True it's safe to indirect into the byte at
3056 ****************************************************************/
3058 bool is_offset_safe(const char *buf_base, size_t buf_len, char *ptr, size_t off)
3060 const char *end_base = buf_base + buf_len;
3061 char *end_ptr = ptr + off;
3063 if (!buf_base || !ptr) {
3067 if (end_base < buf_base || end_ptr < ptr) {
3068 return False; /* wrap. */
3071 if (end_ptr < end_base) {
3077 /****************************************************************
3078 Return a safe pointer into a buffer, or NULL.
3079 ****************************************************************/
3081 char *get_safe_ptr(const char *buf_base, size_t buf_len, char *ptr, size_t off)
3083 return is_offset_safe(buf_base, buf_len, ptr, off) ?
3087 /****************************************************************
3088 Return a safe pointer into a string within a buffer, or NULL.
3089 ****************************************************************/
3091 char *get_safe_str_ptr(const char *buf_base, size_t buf_len, char *ptr, size_t off)
3093 if (!is_offset_safe(buf_base, buf_len, ptr, off)) {
3096 /* Check if a valid string exists at this offset. */
3097 if (skip_string(buf_base,buf_len, ptr + off) == NULL) {
3103 /****************************************************************
3104 Return an SVAL at a pointer, or failval if beyond the end.
3105 ****************************************************************/
3107 int get_safe_SVAL(const char *buf_base, size_t buf_len, char *ptr, size_t off, int failval)
3110 * Note we use off+1 here, not off+2 as SVAL accesses ptr[0] and ptr[1],
3113 if (!is_offset_safe(buf_base, buf_len, ptr, off+1)) {
3116 return SVAL(ptr,off);
3119 /****************************************************************
3120 Return an IVAL at a pointer, or failval if beyond the end.
3121 ****************************************************************/
3123 int get_safe_IVAL(const char *buf_base, size_t buf_len, char *ptr, size_t off, int failval)
3126 * Note we use off+3 here, not off+4 as IVAL accesses
3127 * ptr[0] ptr[1] ptr[2] ptr[3] NOT ptr[4].
3129 if (!is_offset_safe(buf_base, buf_len, ptr, off+3)) {
3132 return IVAL(ptr,off);
3135 /****************************************************************
3136 Split DOM\user into DOM and user. Do not mix with winbind variants of that
3137 call (they take care of winbind separator and other winbind specific settings).
3138 ****************************************************************/
3140 void split_domain_user(TALLOC_CTX *mem_ctx,
3141 const char *full_name,
3145 const char *p = NULL;
3147 p = strchr_m(full_name, '\\');
3150 *domain = talloc_strndup(mem_ctx, full_name,
3151 PTR_DIFF(p, full_name));
3152 *user = talloc_strdup(mem_ctx, p+1);
3154 *domain = talloc_strdup(mem_ctx, "");
3155 *user = talloc_strdup(mem_ctx, full_name);
3161 Disable these now we have checked all code paths and ensured
3162 NULL returns on zero request. JRA.
3164 /****************************************************************
3165 talloc wrapper functions that guarentee a null pointer return
3167 ****************************************************************/
3169 #ifndef MAX_TALLOC_SIZE
3170 #define MAX_TALLOC_SIZE 0x10000000
3174 * talloc and zero memory.
3175 * - returns NULL if size is zero.
3178 void *_talloc_zero_zeronull(const void *ctx, size_t size, const char *name)
3186 p = talloc_named_const(ctx, size, name);
3189 memset(p, '\0', size);
3196 * memdup with a talloc.
3197 * - returns NULL if size is zero.
3200 void *_talloc_memdup_zeronull(const void *t, const void *p, size_t size, const char *name)
3208 newp = talloc_named_const(t, size, name);
3210 memcpy(newp, p, size);
3217 * alloc an array, checking for integer overflow in the array size.
3218 * - returns NULL if count or el_size are zero.
3221 void *_talloc_array_zeronull(const void *ctx, size_t el_size, unsigned count, const char *name)
3223 if (count >= MAX_TALLOC_SIZE/el_size) {
3227 if (el_size == 0 || count == 0) {
3231 return talloc_named_const(ctx, el_size * count, name);
3235 * alloc an zero array, checking for integer overflow in the array size
3236 * - returns NULL if count or el_size are zero.
3239 void *_talloc_zero_array_zeronull(const void *ctx, size_t el_size, unsigned count, const char *name)
3241 if (count >= MAX_TALLOC_SIZE/el_size) {
3245 if (el_size == 0 || count == 0) {
3249 return _talloc_zero(ctx, el_size * count, name);
3253 * Talloc wrapper that returns NULL if size == 0.
3255 void *talloc_zeronull(const void *context, size_t size, const char *name)
3260 return talloc_named_const(context, size, name);