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 if a unix domain socket exists - call vfs_file_exist for samba files.
510 ********************************************************************/
512 bool socket_exist(const char *fname)
515 if (sys_stat(fname,&st) != 0)
518 return S_ISSOCK(st.st_mode);
521 /*******************************************************************
522 Check a files mod time.
523 ********************************************************************/
525 time_t file_modtime(const char *fname)
529 if (sys_stat(fname,&st) != 0)
535 /*******************************************************************
536 Check if a directory exists.
537 ********************************************************************/
539 bool directory_exist(char *dname,SMB_STRUCT_STAT *st)
547 if (sys_stat(dname,st) != 0)
550 ret = S_ISDIR(st->st_mode);
556 /*******************************************************************
557 Returns the size in bytes of the named file.
558 ********************************************************************/
560 SMB_OFF_T get_file_size(char *file_name)
564 if(sys_stat(file_name,&buf) != 0)
565 return (SMB_OFF_T)-1;
569 /*******************************************************************
570 Return a string representing an attribute for a file.
571 ********************************************************************/
573 char *attrib_string(uint16 mode)
579 if (mode & aVOLID) fstrcat(attrstr,"V");
580 if (mode & aDIR) fstrcat(attrstr,"D");
581 if (mode & aARCH) fstrcat(attrstr,"A");
582 if (mode & aHIDDEN) fstrcat(attrstr,"H");
583 if (mode & aSYSTEM) fstrcat(attrstr,"S");
584 if (mode & aRONLY) fstrcat(attrstr,"R");
586 return talloc_strdup(talloc_tos(), attrstr);
589 /*******************************************************************
590 Show a smb message structure.
591 ********************************************************************/
593 void show_msg(char *buf)
601 DEBUG(5,("size=%d\nsmb_com=0x%x\nsmb_rcls=%d\nsmb_reh=%d\nsmb_err=%d\nsmb_flg=%d\nsmb_flg2=%d\n",
603 (int)CVAL(buf,smb_com),
604 (int)CVAL(buf,smb_rcls),
605 (int)CVAL(buf,smb_reh),
606 (int)SVAL(buf,smb_err),
607 (int)CVAL(buf,smb_flg),
608 (int)SVAL(buf,smb_flg2)));
609 DEBUGADD(5,("smb_tid=%d\nsmb_pid=%d\nsmb_uid=%d\nsmb_mid=%d\n",
610 (int)SVAL(buf,smb_tid),
611 (int)SVAL(buf,smb_pid),
612 (int)SVAL(buf,smb_uid),
613 (int)SVAL(buf,smb_mid)));
614 DEBUGADD(5,("smt_wct=%d\n",(int)CVAL(buf,smb_wct)));
616 for (i=0;i<(int)CVAL(buf,smb_wct);i++)
617 DEBUGADD(5,("smb_vwv[%2d]=%5d (0x%X)\n",i,
618 SVAL(buf,smb_vwv+2*i),SVAL(buf,smb_vwv+2*i)));
620 bcc = (int)SVAL(buf,smb_vwv+2*(CVAL(buf,smb_wct)));
622 DEBUGADD(5,("smb_bcc=%d\n",bcc));
630 dump_data(10, (uint8 *)smb_buf(buf), bcc);
633 /*******************************************************************
634 Set the length and marker of an encrypted smb packet.
635 ********************************************************************/
637 void smb_set_enclen(char *buf,int len,uint16 enc_ctx_num)
639 _smb_setlen(buf,len);
643 SSVAL(buf,6,enc_ctx_num);
646 /*******************************************************************
647 Set the length and marker of an smb packet.
648 ********************************************************************/
650 void smb_setlen(char *buf,int len)
652 _smb_setlen(buf,len);
660 /*******************************************************************
661 Setup only the byte count for a smb message.
662 ********************************************************************/
664 int set_message_bcc(char *buf,int num_bytes)
666 int num_words = CVAL(buf,smb_wct);
667 SSVAL(buf,smb_vwv + num_words*SIZEOFWORD,num_bytes);
668 _smb_setlen(buf,smb_size + num_words*2 + num_bytes - 4);
669 return (smb_size + num_words*2 + num_bytes);
672 /*******************************************************************
673 Add a data blob to the end of a smb_buf, adjusting bcc and smb_len.
674 Return the bytes added
675 ********************************************************************/
677 ssize_t message_push_blob(uint8 **outbuf, DATA_BLOB blob)
679 size_t newlen = smb_len(*outbuf) + 4 + blob.length;
682 if (!(tmp = TALLOC_REALLOC_ARRAY(NULL, *outbuf, uint8, newlen))) {
683 DEBUG(0, ("talloc failed\n"));
688 memcpy(tmp + smb_len(tmp) + 4, blob.data, blob.length);
689 set_message_bcc((char *)tmp, smb_buflen(tmp) + blob.length);
693 /*******************************************************************
694 Reduce a file name, removing .. elements.
695 ********************************************************************/
697 static char *dos_clean_name(TALLOC_CTX *ctx, const char *s)
702 DEBUG(3,("dos_clean_name [%s]\n",s));
704 /* remove any double slashes */
705 str = talloc_all_string_sub(ctx, s, "\\\\", "\\");
710 /* Remove leading .\\ characters */
711 if(strncmp(str, ".\\", 2) == 0) {
712 trim_string(str, ".\\", NULL);
714 str = talloc_strdup(ctx, ".\\");
721 while ((p = strstr_m(str,"\\..\\")) != NULL) {
727 if ((p=strrchr_m(str,'\\')) != NULL) {
732 str = talloc_asprintf(ctx,
741 trim_string(str,NULL,"\\..");
742 return talloc_all_string_sub(ctx, str, "\\.\\", "\\");
745 /*******************************************************************
746 Reduce a file name, removing .. elements.
747 ********************************************************************/
749 char *unix_clean_name(TALLOC_CTX *ctx, const char *s)
754 DEBUG(3,("unix_clean_name [%s]\n",s));
756 /* remove any double slashes */
757 str = talloc_all_string_sub(ctx, s, "//","/");
762 /* Remove leading ./ characters */
763 if(strncmp(str, "./", 2) == 0) {
764 trim_string(str, "./", NULL);
766 str = talloc_strdup(ctx, "./");
773 while ((p = strstr_m(str,"/../")) != NULL) {
779 if ((p=strrchr_m(str,'/')) != NULL) {
784 str = talloc_asprintf(ctx,
793 trim_string(str,NULL,"/..");
794 return talloc_all_string_sub(ctx, str, "/./", "/");
797 char *clean_name(TALLOC_CTX *ctx, const char *s)
799 char *str = dos_clean_name(ctx, s);
803 return unix_clean_name(ctx, str);
806 /*******************************************************************
807 Close the low 3 fd's and open dev/null in their place.
808 ********************************************************************/
810 void close_low_fds(bool stderr_too)
822 /* try and use up these file descriptors, so silly
823 library routines writing to stdout etc won't cause havoc */
825 if (i == 2 && !stderr_too)
828 fd = sys_open("/dev/null",O_RDWR,0);
830 fd = sys_open("/dev/null",O_WRONLY,0);
832 DEBUG(0,("Can't open /dev/null\n"));
836 DEBUG(0,("Didn't get file descriptor %d\n",i));
843 /*******************************************************************
844 Write data into an fd at a given offset. Ignore seek errors.
845 ********************************************************************/
847 ssize_t write_data_at_offset(int fd, const char *buffer, size_t N, SMB_OFF_T pos)
852 if (pos == (SMB_OFF_T)-1) {
853 return write_data(fd, buffer, N);
855 #if defined(HAVE_PWRITE) || defined(HAVE_PRWITE64)
857 ret = sys_pwrite(fd,buffer + total,N - total, pos);
858 if (ret == -1 && errno == ESPIPE) {
859 return write_data(fd, buffer + total,N - total);
862 DEBUG(0,("write_data_at_offset: write failure. Error = %s\n", strerror(errno) ));
871 return (ssize_t)total;
873 /* Use lseek and write_data. */
874 if (sys_lseek(fd, pos, SEEK_SET) == -1) {
875 if (errno != ESPIPE) {
879 return write_data(fd, buffer, N);
883 /****************************************************************************
884 Set a fd into blocking/nonblocking mode. Uses POSIX O_NONBLOCK if available,
888 ****************************************************************************/
890 int set_blocking(int fd, bool set)
894 #define FLAG_TO_SET O_NONBLOCK
897 #define FLAG_TO_SET O_NDELAY
899 #define FLAG_TO_SET FNDELAY
903 if((val = sys_fcntl_long(fd, F_GETFL, 0)) == -1)
905 if(set) /* Turn blocking on - ie. clear nonblock flag */
909 return sys_fcntl_long( fd, F_SETFL, val);
913 /*******************************************************************
914 Sleep for a specified number of milliseconds.
915 ********************************************************************/
917 void smb_msleep(unsigned int t)
919 #if defined(HAVE_NANOSLEEP)
920 struct timespec tval;
923 tval.tv_sec = t/1000;
924 tval.tv_nsec = 1000000*(t%1000);
928 ret = nanosleep(&tval, &tval);
929 } while (ret < 0 && errno == EINTR && (tval.tv_sec > 0 || tval.tv_nsec > 0));
931 unsigned int tdiff=0;
932 struct timeval tval,t1,t2;
939 tval.tv_sec = (t-tdiff)/1000;
940 tval.tv_usec = 1000*((t-tdiff)%1000);
942 /* Never wait for more than 1 sec. */
943 if (tval.tv_sec > 1) {
950 sys_select_intr(0,&fds,NULL,NULL,&tval);
953 if (t2.tv_sec < t1.tv_sec) {
954 /* Someone adjusted time... */
958 tdiff = TvalDiff(&t1,&t2);
963 /****************************************************************************
964 Become a daemon, discarding the controlling terminal.
965 ****************************************************************************/
967 void become_daemon(bool Fork, bool no_process_group)
975 /* detach from the terminal */
977 if (!no_process_group) setsid();
978 #elif defined(TIOCNOTTY)
979 if (!no_process_group) {
980 int i = sys_open("/dev/tty", O_RDWR, 0);
982 ioctl(i, (int) TIOCNOTTY, (char *)0);
986 #endif /* HAVE_SETSID */
988 /* Close fd's 0,1,2. Needed if started by rsh */
989 close_low_fds(False); /* Don't close stderr, let the debug system
990 attach it to the logfile */
993 /****************************************************************************
994 Put up a yes/no prompt.
995 ****************************************************************************/
997 bool yesno(const char *p)
1002 if (!fgets(ans,sizeof(ans)-1,stdin))
1005 if (*ans == 'y' || *ans == 'Y')
1011 #if defined(PARANOID_MALLOC_CHECKER)
1013 /****************************************************************************
1014 Internal malloc wrapper. Externally visible.
1015 ****************************************************************************/
1017 void *malloc_(size_t size)
1023 return malloc(size);
1024 #define malloc(s) __ERROR_DONT_USE_MALLOC_DIRECTLY
1027 /****************************************************************************
1028 Internal calloc wrapper. Not externally visible.
1029 ****************************************************************************/
1031 static void *calloc_(size_t count, size_t size)
1033 if (size == 0 || count == 0) {
1037 return calloc(count, size);
1038 #define calloc(n,s) __ERROR_DONT_USE_CALLOC_DIRECTLY
1041 /****************************************************************************
1042 Internal realloc wrapper. Not externally visible.
1043 ****************************************************************************/
1045 static void *realloc_(void *ptr, size_t size)
1048 return realloc(ptr, size);
1049 #define realloc(p,s) __ERROR_DONT_USE_RELLOC_DIRECTLY
1052 #endif /* PARANOID_MALLOC_CHECKER */
1054 /****************************************************************************
1056 ****************************************************************************/
1058 void *malloc_array(size_t el_size, unsigned int count)
1060 if (count >= MAX_ALLOC_SIZE/el_size) {
1064 if (el_size == 0 || count == 0) {
1067 #if defined(PARANOID_MALLOC_CHECKER)
1068 return malloc_(el_size*count);
1070 return malloc(el_size*count);
1074 /****************************************************************************
1076 ****************************************************************************/
1078 void *memalign_array(size_t el_size, size_t align, unsigned int count)
1080 if (count >= MAX_ALLOC_SIZE/el_size) {
1084 return sys_memalign(align, el_size*count);
1087 /****************************************************************************
1089 ****************************************************************************/
1091 void *calloc_array(size_t size, size_t nmemb)
1093 if (nmemb >= MAX_ALLOC_SIZE/size) {
1096 if (size == 0 || nmemb == 0) {
1099 #if defined(PARANOID_MALLOC_CHECKER)
1100 return calloc_(nmemb, size);
1102 return calloc(nmemb, size);
1106 /****************************************************************************
1107 Expand a pointer to be a particular size.
1108 Note that this version of Realloc has an extra parameter that decides
1109 whether to free the passed in storage on allocation failure or if the
1112 This is designed for use in the typical idiom of :
1114 p = SMB_REALLOC(p, size)
1119 and not to have to keep track of the old 'p' contents to free later, nor
1120 to worry if the size parameter was zero. In the case where NULL is returned
1121 we guarentee that p has been freed.
1123 If free later semantics are desired, then pass 'free_old_on_error' as False which
1124 guarentees that the old contents are not freed on error, even if size == 0. To use
1127 tmp = SMB_REALLOC_KEEP_OLD_ON_ERROR(p, size);
1135 Changes were instigated by Coverity error checking. JRA.
1136 ****************************************************************************/
1138 void *Realloc(void *p, size_t size, bool free_old_on_error)
1143 if (free_old_on_error) {
1146 DEBUG(2,("Realloc asked for 0 bytes\n"));
1150 #if defined(PARANOID_MALLOC_CHECKER)
1152 ret = (void *)malloc_(size);
1154 ret = (void *)realloc_(p,size);
1158 ret = (void *)malloc(size);
1160 ret = (void *)realloc(p,size);
1165 if (free_old_on_error && p) {
1168 DEBUG(0,("Memory allocation error: failed to expand to %d bytes\n",(int)size));
1174 /****************************************************************************
1176 ****************************************************************************/
1178 void *realloc_array(void *p, size_t el_size, unsigned int count, bool free_old_on_error)
1180 if (count >= MAX_ALLOC_SIZE/el_size) {
1181 if (free_old_on_error) {
1186 return Realloc(p, el_size*count, free_old_on_error);
1189 /****************************************************************************
1190 (Hopefully) efficient array append.
1191 ****************************************************************************/
1193 void add_to_large_array(TALLOC_CTX *mem_ctx, size_t element_size,
1194 void *element, void *_array, uint32 *num_elements,
1195 ssize_t *array_size)
1197 void **array = (void **)_array;
1199 if (*array_size < 0) {
1203 if (*array == NULL) {
1204 if (*array_size == 0) {
1208 if (*array_size >= MAX_ALLOC_SIZE/element_size) {
1212 *array = TALLOC(mem_ctx, element_size * (*array_size));
1213 if (*array == NULL) {
1218 if (*num_elements == *array_size) {
1221 if (*array_size >= MAX_ALLOC_SIZE/element_size) {
1225 *array = TALLOC_REALLOC(mem_ctx, *array,
1226 element_size * (*array_size));
1228 if (*array == NULL) {
1233 memcpy((char *)(*array) + element_size*(*num_elements),
1234 element, element_size);
1244 /****************************************************************************
1245 Free memory, checks for NULL.
1246 Use directly SAFE_FREE()
1247 Exists only because we need to pass a function pointer somewhere --SSS
1248 ****************************************************************************/
1250 void safe_free(void *p)
1255 /****************************************************************************
1256 Get my own name and IP.
1257 ****************************************************************************/
1259 char *get_myname(TALLOC_CTX *ctx)
1262 char hostname[HOST_NAME_MAX];
1266 /* get my host name */
1267 if (gethostname(hostname, sizeof(hostname)) == -1) {
1268 DEBUG(0,("gethostname failed\n"));
1272 /* Ensure null termination. */
1273 hostname[sizeof(hostname)-1] = '\0';
1275 /* split off any parts after an initial . */
1276 p = strchr_m(hostname,'.');
1281 return talloc_strdup(ctx, hostname);
1284 /****************************************************************************
1285 Get my own domain name, or "" if we have none.
1286 ****************************************************************************/
1288 char *get_mydnsdomname(TALLOC_CTX *ctx)
1290 const char *domname;
1293 domname = get_mydnsfullname();
1298 p = strchr_m(domname, '.');
1301 return talloc_strdup(ctx, p);
1303 return talloc_strdup(ctx, "");
1307 /****************************************************************************
1308 Interpret a protocol description string, with a default.
1309 ****************************************************************************/
1311 int interpret_protocol(const char *str,int def)
1313 if (strequal(str,"NT1"))
1314 return(PROTOCOL_NT1);
1315 if (strequal(str,"LANMAN2"))
1316 return(PROTOCOL_LANMAN2);
1317 if (strequal(str,"LANMAN1"))
1318 return(PROTOCOL_LANMAN1);
1319 if (strequal(str,"CORE"))
1320 return(PROTOCOL_CORE);
1321 if (strequal(str,"COREPLUS"))
1322 return(PROTOCOL_COREPLUS);
1323 if (strequal(str,"CORE+"))
1324 return(PROTOCOL_COREPLUS);
1326 DEBUG(0,("Unrecognised protocol level %s\n",str));
1332 #if (defined(HAVE_NETGROUP) && defined(WITH_AUTOMOUNT))
1333 /******************************************************************
1334 Remove any mount options such as -rsize=2048,wsize=2048 etc.
1335 Based on a fix from <Thomas.Hepper@icem.de>.
1336 Returns a malloc'ed string.
1337 *******************************************************************/
1339 static char *strip_mount_options(TALLOC_CTX *ctx, const char *str)
1342 const char *p = str;
1343 while(*p && !isspace(*p))
1345 while(*p && isspace(*p))
1348 return talloc_strdup(ctx, p);
1354 /*******************************************************************
1355 Patch from jkf@soton.ac.uk
1356 Split Luke's automount_server into YP lookup and string splitter
1357 so can easily implement automount_path().
1358 Returns a malloc'ed string.
1359 *******************************************************************/
1361 #ifdef WITH_NISPLUS_HOME
1362 char *automount_lookup(TALLOC_CTX *ctx, const char *user_name)
1366 char *nis_map = (char *)lp_nis_home_map_name();
1368 char buffer[NIS_MAXATTRVAL + 1];
1373 snprintf(buffer, sizeof(buffer), "[key=%s],%s", user_name, nis_map);
1374 DEBUG(5, ("NIS+ querystring: %s\n", buffer));
1376 if (result = nis_list(buffer, FOLLOW_PATH|EXPAND_NAME|HARD_LOOKUP, NULL, NULL)) {
1377 if (result->status != NIS_SUCCESS) {
1378 DEBUG(3, ("NIS+ query failed: %s\n", nis_sperrno(result->status)));
1380 object = result->objects.objects_val;
1381 if (object->zo_data.zo_type == ENTRY_OBJ) {
1382 entry = &object->zo_data.objdata_u.en_data;
1383 DEBUG(5, ("NIS+ entry type: %s\n", entry->en_type));
1384 DEBUG(3, ("NIS+ result: %s\n", entry->en_cols.en_cols_val[1].ec_value.ec_value_val));
1386 value = talloc_strdup(ctx,
1387 entry->en_cols.en_cols_val[1].ec_value.ec_value_val);
1389 nis_freeresult(result);
1392 value = talloc_string_sub(ctx,
1399 nis_freeresult(result);
1402 value = strip_mount_options(ctx, value);
1403 DEBUG(4, ("NIS+ Lookup: %s resulted in %s\n",
1408 #else /* WITH_NISPLUS_HOME */
1410 char *automount_lookup(TALLOC_CTX *ctx, const char *user_name)
1414 int nis_error; /* returned by yp all functions */
1415 char *nis_result; /* yp_match inits this */
1416 int nis_result_len; /* and set this */
1417 char *nis_domain; /* yp_get_default_domain inits this */
1418 char *nis_map = (char *)lp_nis_home_map_name();
1420 if ((nis_error = yp_get_default_domain(&nis_domain)) != 0) {
1421 DEBUG(3, ("YP Error: %s\n", yperr_string(nis_error)));
1425 DEBUG(5, ("NIS Domain: %s\n", nis_domain));
1427 if ((nis_error = yp_match(nis_domain, nis_map, user_name,
1428 strlen(user_name), &nis_result,
1429 &nis_result_len)) == 0) {
1430 value = talloc_strdup(ctx, nis_result);
1434 value = strip_mount_options(ctx, value);
1435 } else if(nis_error == YPERR_KEY) {
1436 DEBUG(3, ("YP Key not found: while looking up \"%s\" in map \"%s\"\n",
1437 user_name, nis_map));
1438 DEBUG(3, ("using defaults for server and home directory\n"));
1440 DEBUG(3, ("YP Error: \"%s\" while looking up \"%s\" in map \"%s\"\n",
1441 yperr_string(nis_error), user_name, nis_map));
1445 DEBUG(4, ("YP Lookup: %s resulted in %s\n", user_name, value));
1449 #endif /* WITH_NISPLUS_HOME */
1452 /****************************************************************************
1453 Check if a process exists. Does this work on all unixes?
1454 ****************************************************************************/
1456 bool process_exists(const struct server_id pid)
1458 if (procid_is_me(&pid)) {
1462 if (procid_is_local(&pid)) {
1463 return (kill(pid.pid,0) == 0 || errno != ESRCH);
1466 #ifdef CLUSTER_SUPPORT
1467 return ctdbd_process_exists(messaging_ctdbd_connection(), pid.vnn,
1474 bool process_exists_by_pid(pid_t pid)
1476 /* Doing kill with a non-positive pid causes messages to be
1477 * sent to places we don't want. */
1478 SMB_ASSERT(pid > 0);
1479 return(kill(pid,0) == 0 || errno != ESRCH);
1482 /*******************************************************************
1483 Convert a uid into a user name.
1484 ********************************************************************/
1486 const char *uidtoname(uid_t uid)
1488 TALLOC_CTX *ctx = talloc_tos();
1490 struct passwd *pass = NULL;
1492 pass = getpwuid_alloc(ctx,uid);
1494 name = talloc_strdup(ctx,pass->pw_name);
1497 name = talloc_asprintf(ctx,
1504 /*******************************************************************
1505 Convert a gid into a group name.
1506 ********************************************************************/
1508 char *gidtoname(gid_t gid)
1512 grp = getgrgid(gid);
1514 return talloc_strdup(talloc_tos(), grp->gr_name);
1517 return talloc_asprintf(talloc_tos(),
1523 /*******************************************************************
1524 Convert a user name into a uid.
1525 ********************************************************************/
1527 uid_t nametouid(const char *name)
1529 struct passwd *pass;
1533 pass = getpwnam_alloc(NULL, name);
1540 u = (uid_t)strtol(name, &p, 0);
1541 if ((p != name) && (*p == '\0'))
1547 /*******************************************************************
1548 Convert a name to a gid_t if possible. Return -1 if not a group.
1549 ********************************************************************/
1551 gid_t nametogid(const char *name)
1557 g = (gid_t)strtol(name, &p, 0);
1558 if ((p != name) && (*p == '\0'))
1561 grp = sys_getgrnam(name);
1563 return(grp->gr_gid);
1567 /*******************************************************************
1568 Something really nasty happened - panic !
1569 ********************************************************************/
1571 void smb_panic(const char *const why)
1579 if (global_clobber_region_function) {
1580 DEBUG(0,("smb_panic: clobber_region() last called from [%s(%u)]\n",
1581 global_clobber_region_function,
1582 global_clobber_region_line));
1587 DEBUG(0,("PANIC (pid %llu): %s\n",
1588 (unsigned long long)sys_getpid(), why));
1591 cmd = lp_panic_action();
1593 DEBUG(0, ("smb_panic(): calling panic action [%s]\n", cmd));
1594 result = system(cmd);
1597 DEBUG(0, ("smb_panic(): fork failed in panic action: %s\n",
1600 DEBUG(0, ("smb_panic(): action returned status %d\n",
1601 WEXITSTATUS(result)));
1607 /*******************************************************************
1608 Print a backtrace of the stack to the debug log. This function
1609 DELIBERATELY LEAKS MEMORY. The expectation is that you should
1610 exit shortly after calling it.
1611 ********************************************************************/
1613 #ifdef HAVE_LIBUNWIND_H
1614 #include <libunwind.h>
1617 #ifdef HAVE_EXECINFO_H
1618 #include <execinfo.h>
1621 #ifdef HAVE_LIBEXC_H
1625 void log_stack_trace(void)
1627 #ifdef HAVE_LIBUNWIND
1628 /* Try to use libunwind before any other technique since on ia64
1629 * libunwind correctly walks the stack in more circumstances than
1632 unw_cursor_t cursor;
1637 unw_word_t ip, sp, off;
1639 procname[sizeof(procname) - 1] = '\0';
1641 if (unw_getcontext(&uc) != 0) {
1642 goto libunwind_failed;
1645 if (unw_init_local(&cursor, &uc) != 0) {
1646 goto libunwind_failed;
1649 DEBUG(0, ("BACKTRACE:\n"));
1653 unw_get_reg(&cursor, UNW_REG_IP, &ip);
1654 unw_get_reg(&cursor, UNW_REG_SP, &sp);
1656 switch (unw_get_proc_name(&cursor,
1657 procname, sizeof(procname) - 1, &off) ) {
1661 /* Name truncated. */
1662 DEBUGADD(0, (" #%u %s + %#llx [ip=%#llx] [sp=%#llx]\n",
1663 i, procname, (long long)off,
1664 (long long)ip, (long long) sp));
1667 /* case -UNW_ENOINFO: */
1668 /* case -UNW_EUNSPEC: */
1669 /* No symbol name found. */
1670 DEBUGADD(0, (" #%u %s [ip=%#llx] [sp=%#llx]\n",
1671 i, "<unknown symbol>",
1672 (long long)ip, (long long) sp));
1675 } while (unw_step(&cursor) > 0);
1680 DEBUG(0, ("unable to produce a stack trace with libunwind\n"));
1682 #elif HAVE_BACKTRACE_SYMBOLS
1683 void *backtrace_stack[BACKTRACE_STACK_SIZE];
1684 size_t backtrace_size;
1685 char **backtrace_strings;
1687 /* get the backtrace (stack frames) */
1688 backtrace_size = backtrace(backtrace_stack,BACKTRACE_STACK_SIZE);
1689 backtrace_strings = backtrace_symbols(backtrace_stack, backtrace_size);
1691 DEBUG(0, ("BACKTRACE: %lu stack frames:\n",
1692 (unsigned long)backtrace_size));
1694 if (backtrace_strings) {
1697 for (i = 0; i < backtrace_size; i++)
1698 DEBUGADD(0, (" #%u %s\n", i, backtrace_strings[i]));
1700 /* Leak the backtrace_strings, rather than risk what free() might do */
1705 /* The IRIX libexc library provides an API for unwinding the stack. See
1706 * libexc(3) for details. Apparantly trace_back_stack leaks memory, but
1707 * since we are about to abort anyway, it hardly matters.
1710 #define NAMESIZE 32 /* Arbitrary */
1712 __uint64_t addrs[BACKTRACE_STACK_SIZE];
1713 char * names[BACKTRACE_STACK_SIZE];
1714 char namebuf[BACKTRACE_STACK_SIZE * NAMESIZE];
1721 ZERO_ARRAY(namebuf);
1723 /* We need to be root so we can open our /proc entry to walk
1724 * our stack. It also helps when we want to dump core.
1728 for (i = 0; i < BACKTRACE_STACK_SIZE; i++) {
1729 names[i] = namebuf + (i * NAMESIZE);
1732 levels = trace_back_stack(0, addrs, names,
1733 BACKTRACE_STACK_SIZE, NAMESIZE - 1);
1735 DEBUG(0, ("BACKTRACE: %d stack frames:\n", levels));
1736 for (i = 0; i < levels; i++) {
1737 DEBUGADD(0, (" #%d 0x%llx %s\n", i, addrs[i], names[i]));
1742 DEBUG(0, ("unable to produce a stack trace on this platform\n"));
1746 /*******************************************************************
1747 A readdir wrapper which just returns the file name.
1748 ********************************************************************/
1750 const char *readdirname(SMB_STRUCT_DIR *p)
1752 SMB_STRUCT_DIRENT *ptr;
1758 ptr = (SMB_STRUCT_DIRENT *)sys_readdir(p);
1762 dname = ptr->d_name;
1769 #ifdef HAVE_BROKEN_READDIR_NAME
1770 /* using /usr/ucb/cc is BAD */
1774 return talloc_strdup(talloc_tos(), dname);
1777 /*******************************************************************
1778 Utility function used to decide if the last component
1779 of a path matches a (possibly wildcarded) entry in a namelist.
1780 ********************************************************************/
1782 bool is_in_path(const char *name, name_compare_entry *namelist, bool case_sensitive)
1784 const char *last_component;
1786 /* if we have no list it's obviously not in the path */
1787 if((namelist == NULL ) || ((namelist != NULL) && (namelist[0].name == NULL))) {
1791 DEBUG(8, ("is_in_path: %s\n", name));
1793 /* Get the last component of the unix name. */
1794 last_component = strrchr_m(name, '/');
1795 if (!last_component) {
1796 last_component = name;
1798 last_component++; /* Go past '/' */
1801 for(; namelist->name != NULL; namelist++) {
1802 if(namelist->is_wild) {
1803 if (mask_match(last_component, namelist->name, case_sensitive)) {
1804 DEBUG(8,("is_in_path: mask match succeeded\n"));
1808 if((case_sensitive && (strcmp(last_component, namelist->name) == 0))||
1809 (!case_sensitive && (StrCaseCmp(last_component, namelist->name) == 0))) {
1810 DEBUG(8,("is_in_path: match succeeded\n"));
1815 DEBUG(8,("is_in_path: match not found\n"));
1819 /*******************************************************************
1820 Strip a '/' separated list into an array of
1821 name_compare_enties structures suitable for
1822 passing to is_in_path(). We do this for
1823 speed so we can pre-parse all the names in the list
1824 and don't do it for each call to is_in_path().
1825 namelist is modified here and is assumed to be
1826 a copy owned by the caller.
1827 We also check if the entry contains a wildcard to
1828 remove a potentially expensive call to mask_match
1830 ********************************************************************/
1832 void set_namearray(name_compare_entry **ppname_array, char *namelist)
1835 char *nameptr = namelist;
1836 int num_entries = 0;
1839 (*ppname_array) = NULL;
1841 if((nameptr == NULL ) || ((nameptr != NULL) && (*nameptr == '\0')))
1844 /* We need to make two passes over the string. The
1845 first to count the number of elements, the second
1850 if ( *nameptr == '/' ) {
1851 /* cope with multiple (useless) /s) */
1855 /* find the next / */
1856 name_end = strchr_m(nameptr, '/');
1858 /* oops - the last check for a / didn't find one. */
1859 if (name_end == NULL)
1862 /* next segment please */
1863 nameptr = name_end + 1;
1867 if(num_entries == 0)
1870 if(( (*ppname_array) = SMB_MALLOC_ARRAY(name_compare_entry, num_entries + 1)) == NULL) {
1871 DEBUG(0,("set_namearray: malloc fail\n"));
1875 /* Now copy out the names */
1879 if ( *nameptr == '/' ) {
1880 /* cope with multiple (useless) /s) */
1884 /* find the next / */
1885 if ((name_end = strchr_m(nameptr, '/')) != NULL)
1888 /* oops - the last check for a / didn't find one. */
1889 if(name_end == NULL)
1892 (*ppname_array)[i].is_wild = ms_has_wild(nameptr);
1893 if(((*ppname_array)[i].name = SMB_STRDUP(nameptr)) == NULL) {
1894 DEBUG(0,("set_namearray: malloc fail (1)\n"));
1898 /* next segment please */
1899 nameptr = name_end + 1;
1903 (*ppname_array)[i].name = NULL;
1908 /****************************************************************************
1909 Routine to free a namearray.
1910 ****************************************************************************/
1912 void free_namearray(name_compare_entry *name_array)
1916 if(name_array == NULL)
1919 for(i=0; name_array[i].name!=NULL; i++)
1920 SAFE_FREE(name_array[i].name);
1921 SAFE_FREE(name_array);
1925 #define DBGC_CLASS DBGC_LOCKING
1927 /****************************************************************************
1928 Simple routine to do POSIX file locking. Cruft in NFS and 64->32 bit mapping
1929 is dealt with in posix.c
1930 Returns True if the lock was granted, False otherwise.
1931 ****************************************************************************/
1933 bool fcntl_lock(int fd, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
1935 SMB_STRUCT_FLOCK lock;
1938 DEBUG(8,("fcntl_lock fd=%d op=%d offset=%.0f count=%.0f type=%d\n",
1939 fd,op,(double)offset,(double)count,type));
1942 lock.l_whence = SEEK_SET;
1943 lock.l_start = offset;
1947 ret = sys_fcntl_ptr(fd,op,&lock);
1951 DEBUG(3,("fcntl_lock: lock failed at offset %.0f count %.0f op %d type %d (%s)\n",
1952 (double)offset,(double)count,op,type,strerror(errno)));
1957 /* everything went OK */
1958 DEBUG(8,("fcntl_lock: Lock call successful\n"));
1963 /****************************************************************************
1964 Simple routine to query existing file locks. Cruft in NFS and 64->32 bit mapping
1965 is dealt with in posix.c
1966 Returns True if we have information regarding this lock region (and returns
1967 F_UNLCK in *ptype if the region is unlocked). False if the call failed.
1968 ****************************************************************************/
1970 bool fcntl_getlock(int fd, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype, pid_t *ppid)
1972 SMB_STRUCT_FLOCK lock;
1975 DEBUG(8,("fcntl_getlock fd=%d offset=%.0f count=%.0f type=%d\n",
1976 fd,(double)*poffset,(double)*pcount,*ptype));
1978 lock.l_type = *ptype;
1979 lock.l_whence = SEEK_SET;
1980 lock.l_start = *poffset;
1981 lock.l_len = *pcount;
1984 ret = sys_fcntl_ptr(fd,SMB_F_GETLK,&lock);
1988 DEBUG(3,("fcntl_getlock: lock request failed at offset %.0f count %.0f type %d (%s)\n",
1989 (double)*poffset,(double)*pcount,*ptype,strerror(errno)));
1994 *ptype = lock.l_type;
1995 *poffset = lock.l_start;
1996 *pcount = lock.l_len;
1999 DEBUG(3,("fcntl_getlock: fd %d is returned info %d pid %u\n",
2000 fd, (int)lock.l_type, (unsigned int)lock.l_pid));
2005 #define DBGC_CLASS DBGC_ALL
2007 /*******************************************************************
2008 Is the name specified one of my netbios names.
2009 Returns true if it is equal, false otherwise.
2010 ********************************************************************/
2012 bool is_myname(const char *s)
2017 for (n=0; my_netbios_names(n); n++) {
2018 if (strequal(my_netbios_names(n), s)) {
2023 DEBUG(8, ("is_myname(\"%s\") returns %d\n", s, ret));
2027 /*******************************************************************
2028 Is the name specified our workgroup/domain.
2029 Returns true if it is equal, false otherwise.
2030 ********************************************************************/
2032 bool is_myworkgroup(const char *s)
2036 if (strequal(s, lp_workgroup())) {
2040 DEBUG(8, ("is_myworkgroup(\"%s\") returns %d\n", s, ret));
2044 /*******************************************************************
2045 we distinguish between 2K and XP by the "Native Lan Manager" string
2046 WinXP => "Windows 2002 5.1"
2047 WinXP 64bit => "Windows XP 5.2"
2048 Win2k => "Windows 2000 5.0"
2049 NT4 => "Windows NT 4.0"
2050 Win9x => "Windows 4.0"
2051 Windows 2003 doesn't set the native lan manager string but
2052 they do set the domain to "Windows 2003 5.2" (probably a bug).
2053 ********************************************************************/
2055 void ra_lanman_string( const char *native_lanman )
2057 if ( strcmp( native_lanman, "Windows 2002 5.1" ) == 0 )
2058 set_remote_arch( RA_WINXP );
2059 else if ( strcmp( native_lanman, "Windows XP 5.2" ) == 0 )
2060 set_remote_arch( RA_WINXP );
2061 else if ( strcmp( native_lanman, "Windows Server 2003 5.2" ) == 0 )
2062 set_remote_arch( RA_WIN2K3 );
2065 static const char *remote_arch_str;
2067 const char *get_remote_arch_str(void)
2069 if (!remote_arch_str) {
2072 return remote_arch_str;
2075 /*******************************************************************
2076 Set the horrid remote_arch string based on an enum.
2077 ********************************************************************/
2079 void set_remote_arch(enum remote_arch_types type)
2084 remote_arch_str = "WfWg";
2087 remote_arch_str = "OS2";
2090 remote_arch_str = "Win95";
2093 remote_arch_str = "WinNT";
2096 remote_arch_str = "Win2K";
2099 remote_arch_str = "WinXP";
2102 remote_arch_str = "Win2K3";
2105 remote_arch_str = "Vista";
2108 remote_arch_str = "Samba";
2111 remote_arch_str = "CIFSFS";
2114 ra_type = RA_UNKNOWN;
2115 remote_arch_str = "UNKNOWN";
2119 DEBUG(10,("set_remote_arch: Client arch is \'%s\'\n",
2123 /*******************************************************************
2124 Get the remote_arch type.
2125 ********************************************************************/
2127 enum remote_arch_types get_remote_arch(void)
2132 void print_asc(int level, const unsigned char *buf,int len)
2136 DEBUG(level,("%c", isprint(buf[i])?buf[i]:'.'));
2139 void dump_data(int level, const unsigned char *buf1,int len)
2141 const unsigned char *buf = (const unsigned char *)buf1;
2145 if (!DEBUGLVL(level)) return;
2147 DEBUGADD(level,("[%03X] ",i));
2149 DEBUGADD(level,("%02X ",(int)buf[i]));
2151 if (i%8 == 0) DEBUGADD(level,(" "));
2153 print_asc(level,&buf[i-16],8); DEBUGADD(level,(" "));
2154 print_asc(level,&buf[i-8],8); DEBUGADD(level,("\n"));
2155 if (i<len) DEBUGADD(level,("[%03X] ",i));
2161 DEBUGADD(level,(" "));
2162 if (n>8) DEBUGADD(level,(" "));
2163 while (n--) DEBUGADD(level,(" "));
2165 print_asc(level,&buf[i-(i%16)],n); DEBUGADD(level,( " " ));
2167 if (n>0) print_asc(level,&buf[i-n],n);
2168 DEBUGADD(level,("\n"));
2172 void dump_data_pw(const char *msg, const uchar * data, size_t len)
2174 #ifdef DEBUG_PASSWORD
2175 DEBUG(11, ("%s", msg));
2176 if (data != NULL && len > 0)
2178 dump_data(11, data, len);
2183 const char *tab_depth(int level, int depth)
2185 if( DEBUGLVL(level) ) {
2186 dbgtext("%*s", depth*4, "");
2191 /*****************************************************************************
2192 Provide a checksum on a string
2194 Input: s - the null-terminated character string for which the checksum
2197 Output: The checksum value calculated for s.
2198 *****************************************************************************/
2200 int str_checksum(const char *s)
2208 res ^= (c << (i % 15)) ^ (c >> (15-(i%15)));
2215 /*****************************************************************
2216 Zero a memory area then free it. Used to catch bugs faster.
2217 *****************************************************************/
2219 void zero_free(void *p, size_t size)
2225 /*****************************************************************
2226 Set our open file limit to a requested max and return the limit.
2227 *****************************************************************/
2229 int set_maxfiles(int requested_max)
2231 #if (defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE))
2233 int saved_current_limit;
2235 if(getrlimit(RLIMIT_NOFILE, &rlp)) {
2236 DEBUG(0,("set_maxfiles: getrlimit (1) for RLIMIT_NOFILE failed with error %s\n",
2239 return requested_max;
2243 * Set the fd limit to be real_max_open_files + MAX_OPEN_FUDGEFACTOR to
2244 * account for the extra fd we need
2245 * as well as the log files and standard
2246 * handles etc. Save the limit we want to set in case
2247 * we are running on an OS that doesn't support this limit (AIX)
2248 * which always returns RLIM_INFINITY for rlp.rlim_max.
2251 /* Try raising the hard (max) limit to the requested amount. */
2253 #if defined(RLIM_INFINITY)
2254 if (rlp.rlim_max != RLIM_INFINITY) {
2255 int orig_max = rlp.rlim_max;
2257 if ( rlp.rlim_max < requested_max )
2258 rlp.rlim_max = requested_max;
2260 /* This failing is not an error - many systems (Linux) don't
2261 support our default request of 10,000 open files. JRA. */
2263 if(setrlimit(RLIMIT_NOFILE, &rlp)) {
2264 DEBUG(3,("set_maxfiles: setrlimit for RLIMIT_NOFILE for %d max files failed with error %s\n",
2265 (int)rlp.rlim_max, strerror(errno) ));
2267 /* Set failed - restore original value from get. */
2268 rlp.rlim_max = orig_max;
2273 /* Now try setting the soft (current) limit. */
2275 saved_current_limit = rlp.rlim_cur = MIN(requested_max,rlp.rlim_max);
2277 if(setrlimit(RLIMIT_NOFILE, &rlp)) {
2278 DEBUG(0,("set_maxfiles: setrlimit for RLIMIT_NOFILE for %d files failed with error %s\n",
2279 (int)rlp.rlim_cur, strerror(errno) ));
2281 return saved_current_limit;
2284 if(getrlimit(RLIMIT_NOFILE, &rlp)) {
2285 DEBUG(0,("set_maxfiles: getrlimit (2) for RLIMIT_NOFILE failed with error %s\n",
2288 return saved_current_limit;
2291 #if defined(RLIM_INFINITY)
2292 if(rlp.rlim_cur == RLIM_INFINITY)
2293 return saved_current_limit;
2296 if((int)rlp.rlim_cur > saved_current_limit)
2297 return saved_current_limit;
2299 return rlp.rlim_cur;
2300 #else /* !defined(HAVE_GETRLIMIT) || !defined(RLIMIT_NOFILE) */
2302 * No way to know - just guess...
2304 return requested_max;
2308 /*****************************************************************
2309 Possibly replace mkstemp if it is broken.
2310 *****************************************************************/
2312 int smb_mkstemp(char *name_template)
2314 #if HAVE_SECURE_MKSTEMP
2315 return mkstemp(name_template);
2317 /* have a reasonable go at emulating it. Hope that
2318 the system mktemp() isn't completly hopeless */
2319 char *p = mktemp(name_template);
2322 return open(p, O_CREAT|O_EXCL|O_RDWR, 0600);
2326 /*****************************************************************
2327 malloc that aborts with smb_panic on fail or zero size.
2328 *****************************************************************/
2330 void *smb_xmalloc_array(size_t size, unsigned int count)
2334 smb_panic("smb_xmalloc_array: called with zero size");
2336 if (count >= MAX_ALLOC_SIZE/size) {
2337 smb_panic("smb_xmalloc_array: alloc size too large");
2339 if ((p = SMB_MALLOC(size*count)) == NULL) {
2340 DEBUG(0, ("smb_xmalloc_array failed to allocate %lu * %lu bytes\n",
2341 (unsigned long)size, (unsigned long)count));
2342 smb_panic("smb_xmalloc_array: malloc failed");
2348 Memdup with smb_panic on fail.
2351 void *smb_xmemdup(const void *p, size_t size)
2354 p2 = SMB_XMALLOC_ARRAY(unsigned char,size);
2355 memcpy(p2, p, size);
2360 strdup that aborts on malloc fail.
2363 char *smb_xstrdup(const char *s)
2365 #if defined(PARANOID_MALLOC_CHECKER)
2372 #define strdup rep_strdup
2375 char *s1 = strdup(s);
2376 #if defined(PARANOID_MALLOC_CHECKER)
2380 #define strdup(s) __ERROR_DONT_USE_STRDUP_DIRECTLY
2383 smb_panic("smb_xstrdup: malloc failed");
2390 strndup that aborts on malloc fail.
2393 char *smb_xstrndup(const char *s, size_t n)
2395 #if defined(PARANOID_MALLOC_CHECKER)
2401 #if (defined(BROKEN_STRNDUP) || !defined(HAVE_STRNDUP))
2403 #define strndup rep_strndup
2406 char *s1 = strndup(s, n);
2407 #if defined(PARANOID_MALLOC_CHECKER)
2411 #define strndup(s,n) __ERROR_DONT_USE_STRNDUP_DIRECTLY
2414 smb_panic("smb_xstrndup: malloc failed");
2420 vasprintf that aborts on malloc fail
2423 int smb_xvasprintf(char **ptr, const char *format, va_list ap)
2430 n = vasprintf(ptr, format, ap2);
2431 if (n == -1 || ! *ptr) {
2432 smb_panic("smb_xvasprintf: out of memory");
2437 /*****************************************************************
2438 Like strdup but for memory.
2439 *****************************************************************/
2441 void *memdup(const void *p, size_t size)
2446 p2 = SMB_MALLOC(size);
2449 memcpy(p2, p, size);
2453 /*****************************************************************
2454 Get local hostname and cache result.
2455 *****************************************************************/
2457 char *myhostname(void)
2461 /* This is cached forever so
2462 * use NULL talloc ctx. */
2463 ret = get_myname(NULL);
2468 /*****************************************************************
2469 A useful function for returning a path in the Samba pid directory.
2470 *****************************************************************/
2472 static char *xx_path(const char *name, const char *rootpath)
2476 fname = talloc_strdup(talloc_tos(), rootpath);
2480 trim_string(fname,"","/");
2482 if (!directory_exist(fname,NULL)) {
2486 return talloc_asprintf(talloc_tos(),
2492 /*****************************************************************
2493 A useful function for returning a path in the Samba lock directory.
2494 *****************************************************************/
2496 char *lock_path(const char *name)
2498 return xx_path(name, lp_lockdir());
2501 /*****************************************************************
2502 A useful function for returning a path in the Samba pid directory.
2503 *****************************************************************/
2505 char *pid_path(const char *name)
2507 return xx_path(name, lp_piddir());
2511 * @brief Returns an absolute path to a file in the Samba lib directory.
2513 * @param name File to find, relative to LIBDIR.
2515 * @retval Pointer to a string containing the full path.
2518 char *lib_path(const char *name)
2520 return talloc_asprintf(talloc_tos(), "%s/%s", get_dyn_LIBDIR(), name);
2524 * @brief Returns an absolute path to a file in the Samba data directory.
2526 * @param name File to find, relative to CODEPAGEDIR.
2528 * @retval Pointer to a talloc'ed string containing the full path.
2531 char *data_path(const char *name)
2533 return talloc_asprintf(talloc_tos(), "%s/%s", get_dyn_CODEPAGEDIR(), name);
2536 /*****************************************************************
2537 a useful function for returning a path in the Samba state directory
2538 *****************************************************************/
2540 char *state_path(const char *name)
2542 return xx_path(name, get_dyn_STATEDIR());
2546 * @brief Returns the platform specific shared library extension.
2548 * @retval Pointer to a const char * containing the extension.
2551 const char *shlib_ext(void)
2553 return get_dyn_SHLIBEXT();
2556 /*******************************************************************
2557 Given a filename - get its directory name
2558 NB: Returned in static storage. Caveats:
2559 o If caller wishes to preserve, they should copy.
2560 ********************************************************************/
2562 char *parent_dirname(const char *path)
2566 if (!parent_dirname_talloc(talloc_tos(), path, &parent, NULL)) {
2573 bool parent_dirname_talloc(TALLOC_CTX *mem_ctx, const char *dir,
2574 char **parent, const char **name)
2579 p = strrchr_m(dir, '/'); /* Find final '/', if any */
2582 if (!(*parent = talloc_strdup(mem_ctx, "."))) {
2593 if (!(*parent = TALLOC_ARRAY(mem_ctx, char, len+1))) {
2596 memcpy(*parent, dir, len);
2597 (*parent)[len] = '\0';
2605 /*******************************************************************
2606 Determine if a pattern contains any Microsoft wildcard characters.
2607 *******************************************************************/
2609 bool ms_has_wild(const char *s)
2613 if (lp_posix_pathnames()) {
2614 /* With posix pathnames no characters are wild. */
2618 while ((c = *s++)) {
2631 bool ms_has_wild_w(const smb_ucs2_t *s)
2634 if (!s) return False;
2635 while ((c = *s++)) {
2637 case UCS2_CHAR('*'):
2638 case UCS2_CHAR('?'):
2639 case UCS2_CHAR('<'):
2640 case UCS2_CHAR('>'):
2641 case UCS2_CHAR('"'):
2648 /*******************************************************************
2649 A wrapper that handles case sensitivity and the special handling
2651 *******************************************************************/
2653 bool mask_match(const char *string, const char *pattern, bool is_case_sensitive)
2655 if (strcmp(string,"..") == 0)
2657 if (strcmp(pattern,".") == 0)
2660 return ms_fnmatch(pattern, string, Protocol <= PROTOCOL_LANMAN2, is_case_sensitive) == 0;
2663 /*******************************************************************
2664 A wrapper that handles case sensitivity and the special handling
2665 of the ".." name. Varient that is only called by old search code which requires
2666 pattern translation.
2667 *******************************************************************/
2669 bool mask_match_search(const char *string, const char *pattern, bool is_case_sensitive)
2671 if (strcmp(string,"..") == 0)
2673 if (strcmp(pattern,".") == 0)
2676 return ms_fnmatch(pattern, string, True, is_case_sensitive) == 0;
2679 /*******************************************************************
2680 A wrapper that handles a list of patters and calls mask_match()
2681 on each. Returns True if any of the patterns match.
2682 *******************************************************************/
2684 bool mask_match_list(const char *string, char **list, int listLen, bool is_case_sensitive)
2686 while (listLen-- > 0) {
2687 if (mask_match(string, *list++, is_case_sensitive))
2693 /*********************************************************
2694 Recursive routine that is called by unix_wild_match.
2695 *********************************************************/
2697 static bool unix_do_match(const char *regexp, const char *str)
2701 for( p = regexp; *p && *str; ) {
2712 * Look for a character matching
2713 * the one after the '*'.
2717 return true; /* Automatic match */
2720 while(*str && (*p != *str))
2724 * Patch from weidel@multichart.de. In the case of the regexp
2725 * '*XX*' we want to ensure there are at least 2 'X' characters
2726 * in the string after the '*' for a match to be made.
2733 * Eat all the characters that match, but count how many there were.
2736 while(*str && (*p == *str)) {
2742 * Now check that if the regexp had n identical characters that
2743 * matchcount had at least that many matches.
2746 while ( *(p+1) && (*(p+1) == *p)) {
2751 if ( matchcount <= 0 )
2755 str--; /* We've eaten the match char after the '*' */
2757 if(unix_do_match(p, str))
2779 if (!*p && str[0] == '.' && str[1] == 0)
2782 if (!*str && *p == '?') {
2788 if(!*str && (*p == '*' && p[1] == '\0'))
2794 /*******************************************************************
2795 Simple case insensitive interface to a UNIX wildcard matcher.
2796 Returns True if match, False if not.
2797 *******************************************************************/
2799 bool unix_wild_match(const char *pattern, const char *string)
2801 TALLOC_CTX *ctx = talloc_stackframe();
2807 p2 = talloc_strdup(ctx,pattern);
2808 s2 = talloc_strdup(ctx,string);
2816 /* Remove any *? and ** from the pattern as they are meaningless */
2817 for(p = p2; *p; p++) {
2818 while( *p == '*' && (p[1] == '?' ||p[1] == '*')) {
2819 memmove(&p[1], &p[2], strlen(&p[2])+1);
2823 if (strequal(p2,"*")) {
2828 ret = unix_do_match(p2, s2);
2833 /**********************************************************************
2834 Converts a name to a fully qualified domain name.
2835 Returns true if lookup succeeded, false if not (then fqdn is set to name)
2836 Note we deliberately use gethostbyname here, not getaddrinfo as we want
2837 to examine the h_aliases and I don't know how to do that with getaddrinfo.
2838 ***********************************************************************/
2840 bool name_to_fqdn(fstring fqdn, const char *name)
2843 struct hostent *hp = gethostbyname(name);
2845 if (!hp || !hp->h_name || !*hp->h_name) {
2846 DEBUG(10,("name_to_fqdn: lookup for %s failed.\n", name));
2847 fstrcpy(fqdn, name);
2851 /* Find out if the fqdn is returned as an alias
2852 * to cope with /etc/hosts files where the first
2853 * name is not the fqdn but the short name */
2854 if (hp->h_aliases && (! strchr_m(hp->h_name, '.'))) {
2856 for (i = 0; hp->h_aliases[i]; i++) {
2857 if (strchr_m(hp->h_aliases[i], '.')) {
2858 full = hp->h_aliases[i];
2863 if (full && (StrCaseCmp(full, "localhost.localdomain") == 0)) {
2864 DEBUG(1, ("WARNING: your /etc/hosts file may be broken!\n"));
2865 DEBUGADD(1, (" Specifing the machine hostname for address 127.0.0.1 may lead\n"));
2866 DEBUGADD(1, (" to Kerberos authentication problems as localhost.localdomain\n"));
2867 DEBUGADD(1, (" may end up being used instead of the real machine FQDN.\n"));
2874 DEBUG(10,("name_to_fqdn: lookup for %s -> %s.\n", name, full));
2875 fstrcpy(fqdn, full);
2879 /**********************************************************************
2880 Extension to talloc_get_type: Abort on type mismatch
2881 ***********************************************************************/
2883 void *talloc_check_name_abort(const void *ptr, const char *name)
2887 result = talloc_check_name(ptr, name);
2891 DEBUG(0, ("Talloc type mismatch, expected %s, got %s\n",
2892 name, talloc_get_name(ptr)));
2893 smb_panic("talloc type mismatch");
2894 /* Keep the compiler happy */
2898 uint32 map_share_mode_to_deny_mode(uint32 share_access, uint32 private_options)
2900 switch (share_access & ~FILE_SHARE_DELETE) {
2901 case FILE_SHARE_NONE:
2903 case FILE_SHARE_READ:
2905 case FILE_SHARE_WRITE:
2907 case FILE_SHARE_READ|FILE_SHARE_WRITE:
2910 if (private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS) {
2912 } else if (private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_FCB) {
2919 pid_t procid_to_pid(const struct server_id *proc)
2924 static uint32 my_vnn = NONCLUSTER_VNN;
2926 void set_my_vnn(uint32 vnn)
2928 DEBUG(10, ("vnn pid %d = %u\n", (int)sys_getpid(), (unsigned int)vnn));
2932 uint32 get_my_vnn(void)
2937 struct server_id pid_to_procid(pid_t pid)
2939 struct server_id result;
2941 #ifdef CLUSTER_SUPPORT
2942 result.vnn = my_vnn;
2947 struct server_id procid_self(void)
2949 return pid_to_procid(sys_getpid());
2952 struct server_id server_id_self(void)
2954 return procid_self();
2957 bool procid_equal(const struct server_id *p1, const struct server_id *p2)
2959 if (p1->pid != p2->pid)
2961 #ifdef CLUSTER_SUPPORT
2962 if (p1->vnn != p2->vnn)
2968 bool cluster_id_equal(const struct server_id *id1,
2969 const struct server_id *id2)
2971 return procid_equal(id1, id2);
2974 bool procid_is_me(const struct server_id *pid)
2976 if (pid->pid != sys_getpid())
2978 #ifdef CLUSTER_SUPPORT
2979 if (pid->vnn != my_vnn)
2985 struct server_id interpret_pid(const char *pid_string)
2987 #ifdef CLUSTER_SUPPORT
2988 unsigned int vnn, pid;
2989 struct server_id result;
2990 if (sscanf(pid_string, "%u:%u", &vnn, &pid) == 2) {
2994 else if (sscanf(pid_string, "%u", &pid) == 1) {
2995 result.vnn = NONCLUSTER_VNN;
2999 result.vnn = NONCLUSTER_VNN;
3004 return pid_to_procid(atoi(pid_string));
3008 char *procid_str(TALLOC_CTX *mem_ctx, const struct server_id *pid)
3010 #ifdef CLUSTER_SUPPORT
3011 if (pid->vnn == NONCLUSTER_VNN) {
3012 return talloc_asprintf(mem_ctx,
3017 return talloc_asprintf(mem_ctx,
3023 return talloc_asprintf(mem_ctx,
3029 char *procid_str_static(const struct server_id *pid)
3031 return procid_str(talloc_tos(), pid);
3034 bool procid_valid(const struct server_id *pid)
3036 return (pid->pid != -1);
3039 bool procid_is_local(const struct server_id *pid)
3041 #ifdef CLUSTER_SUPPORT
3042 return pid->vnn == my_vnn;
3048 int this_is_smp(void)
3050 #if defined(HAVE_SYSCONF)
3052 #if defined(SYSCONF_SC_NPROC_ONLN)
3053 return (sysconf(_SC_NPROC_ONLN) > 1) ? 1 : 0;
3054 #elif defined(SYSCONF_SC_NPROCESSORS_ONLN)
3055 return (sysconf(_SC_NPROCESSORS_ONLN) > 1) ? 1 : 0;
3065 /****************************************************************
3066 Check if an offset into a buffer is safe.
3067 If this returns True it's safe to indirect into the byte at
3069 ****************************************************************/
3071 bool is_offset_safe(const char *buf_base, size_t buf_len, char *ptr, size_t off)
3073 const char *end_base = buf_base + buf_len;
3074 char *end_ptr = ptr + off;
3076 if (!buf_base || !ptr) {
3080 if (end_base < buf_base || end_ptr < ptr) {
3081 return False; /* wrap. */
3084 if (end_ptr < end_base) {
3090 /****************************************************************
3091 Return a safe pointer into a buffer, or NULL.
3092 ****************************************************************/
3094 char *get_safe_ptr(const char *buf_base, size_t buf_len, char *ptr, size_t off)
3096 return is_offset_safe(buf_base, buf_len, ptr, off) ?
3100 /****************************************************************
3101 Return a safe pointer into a string within a buffer, or NULL.
3102 ****************************************************************/
3104 char *get_safe_str_ptr(const char *buf_base, size_t buf_len, char *ptr, size_t off)
3106 if (!is_offset_safe(buf_base, buf_len, ptr, off)) {
3109 /* Check if a valid string exists at this offset. */
3110 if (skip_string(buf_base,buf_len, ptr + off) == NULL) {
3116 /****************************************************************
3117 Return an SVAL at a pointer, or failval if beyond the end.
3118 ****************************************************************/
3120 int get_safe_SVAL(const char *buf_base, size_t buf_len, char *ptr, size_t off, int failval)
3123 * Note we use off+1 here, not off+2 as SVAL accesses ptr[0] and ptr[1],
3126 if (!is_offset_safe(buf_base, buf_len, ptr, off+1)) {
3129 return SVAL(ptr,off);
3132 /****************************************************************
3133 Return an IVAL at a pointer, or failval if beyond the end.
3134 ****************************************************************/
3136 int get_safe_IVAL(const char *buf_base, size_t buf_len, char *ptr, size_t off, int failval)
3139 * Note we use off+3 here, not off+4 as IVAL accesses
3140 * ptr[0] ptr[1] ptr[2] ptr[3] NOT ptr[4].
3142 if (!is_offset_safe(buf_base, buf_len, ptr, off+3)) {
3145 return IVAL(ptr,off);
3148 /****************************************************************
3149 Split DOM\user into DOM and user. Do not mix with winbind variants of that
3150 call (they take care of winbind separator and other winbind specific settings).
3151 ****************************************************************/
3153 void split_domain_user(TALLOC_CTX *mem_ctx,
3154 const char *full_name,
3158 const char *p = NULL;
3160 p = strchr_m(full_name, '\\');
3163 *domain = talloc_strndup(mem_ctx, full_name,
3164 PTR_DIFF(p, full_name));
3165 *user = talloc_strdup(mem_ctx, p+1);
3167 *domain = talloc_strdup(mem_ctx, "");
3168 *user = talloc_strdup(mem_ctx, full_name);
3174 Disable these now we have checked all code paths and ensured
3175 NULL returns on zero request. JRA.
3177 /****************************************************************
3178 talloc wrapper functions that guarentee a null pointer return
3180 ****************************************************************/
3182 #ifndef MAX_TALLOC_SIZE
3183 #define MAX_TALLOC_SIZE 0x10000000
3187 * talloc and zero memory.
3188 * - returns NULL if size is zero.
3191 void *_talloc_zero_zeronull(const void *ctx, size_t size, const char *name)
3199 p = talloc_named_const(ctx, size, name);
3202 memset(p, '\0', size);
3209 * memdup with a talloc.
3210 * - returns NULL if size is zero.
3213 void *_talloc_memdup_zeronull(const void *t, const void *p, size_t size, const char *name)
3221 newp = talloc_named_const(t, size, name);
3223 memcpy(newp, p, size);
3230 * alloc an array, checking for integer overflow in the array size.
3231 * - returns NULL if count or el_size are zero.
3234 void *_talloc_array_zeronull(const void *ctx, size_t el_size, unsigned count, const char *name)
3236 if (count >= MAX_TALLOC_SIZE/el_size) {
3240 if (el_size == 0 || count == 0) {
3244 return talloc_named_const(ctx, el_size * count, name);
3248 * alloc an zero array, checking for integer overflow in the array size
3249 * - returns NULL if count or el_size are zero.
3252 void *_talloc_zero_array_zeronull(const void *ctx, size_t el_size, unsigned count, const char *name)
3254 if (count >= MAX_TALLOC_SIZE/el_size) {
3258 if (el_size == 0 || count == 0) {
3262 return _talloc_zero(ctx, el_size * count, name);
3266 * Talloc wrapper that returns NULL if size == 0.
3268 void *talloc_zeronull(const void *context, size_t size, const char *name)
3273 return talloc_named_const(context, size, name);