2 Unix SMB/CIFS implementation.
3 Samba utility functions
4 Copyright (C) Andrew Tridgell 1992-1998
5 Copyright (C) Jeremy Allison 2001-2002
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 fstring local_machine;
27 extern char *global_clobber_region_function;
28 extern unsigned int global_clobber_region_line;
29 extern fstring remote_arch;
31 /* Max allowable allococation - 256mb - 0x10000000 */
32 #define MAX_ALLOC_SIZE (1024*1024*256)
34 #if (defined(HAVE_NETGROUP) && defined (WITH_AUTOMOUNT))
35 #ifdef WITH_NISPLUS_HOME
36 #ifdef BROKEN_NISPLUS_INCLUDE_FILES
38 * The following lines are needed due to buggy include files
39 * in Solaris 2.6 which define GROUP in both /usr/include/sys/acl.h and
40 * also in /usr/include/rpcsvc/nis.h. The definitions conflict. JRA.
41 * Also GROUP_OBJ is defined as 0x4 in /usr/include/sys/acl.h and as
42 * an enum in /usr/include/rpcsvc/nis.h.
49 #if defined(GROUP_OBJ)
53 #endif /* BROKEN_NISPLUS_INCLUDE_FILES */
55 #include <rpcsvc/nis.h>
57 #endif /* WITH_NISPLUS_HOME */
58 #endif /* HAVE_NETGROUP && WITH_AUTOMOUNT */
60 enum protocol_types Protocol = PROTOCOL_COREPLUS;
62 /* a default finfo structure to ensure all fields are sensible */
65 /* this is used by the chaining code */
70 static enum remote_arch_types ra_type = RA_UNKNOWN;
71 pstring user_socket_options=DEFAULT_SOCKET_OPTIONS;
73 /***********************************************************************
74 Definitions for all names.
75 ***********************************************************************/
77 static char *smb_myname;
78 static char *smb_myworkgroup;
79 static char *smb_scope;
80 static int smb_num_netbios_names;
81 static char **smb_my_netbios_names;
83 /***********************************************************************
84 Allocate and set myname. Ensure upper case.
85 ***********************************************************************/
87 bool set_global_myname(const char *myname)
89 SAFE_FREE(smb_myname);
90 smb_myname = SMB_STRDUP(myname);
93 strupper_m(smb_myname);
97 const char *global_myname(void)
102 /***********************************************************************
103 Allocate and set myworkgroup. Ensure upper case.
104 ***********************************************************************/
106 bool set_global_myworkgroup(const char *myworkgroup)
108 SAFE_FREE(smb_myworkgroup);
109 smb_myworkgroup = SMB_STRDUP(myworkgroup);
110 if (!smb_myworkgroup)
112 strupper_m(smb_myworkgroup);
116 const char *lp_workgroup(void)
118 return smb_myworkgroup;
121 /***********************************************************************
122 Allocate and set scope. Ensure upper case.
123 ***********************************************************************/
125 bool set_global_scope(const char *scope)
127 SAFE_FREE(smb_scope);
128 smb_scope = SMB_STRDUP(scope);
131 strupper_m(smb_scope);
135 /*********************************************************************
136 Ensure scope is never null string.
137 *********************************************************************/
139 const char *global_scope(void)
142 set_global_scope("");
146 static void free_netbios_names_array(void)
150 for (i = 0; i < smb_num_netbios_names; i++)
151 SAFE_FREE(smb_my_netbios_names[i]);
153 SAFE_FREE(smb_my_netbios_names);
154 smb_num_netbios_names = 0;
157 static bool allocate_my_netbios_names_array(size_t number)
159 free_netbios_names_array();
161 smb_num_netbios_names = number + 1;
162 smb_my_netbios_names = SMB_MALLOC_ARRAY( char *, smb_num_netbios_names );
164 if (!smb_my_netbios_names)
167 memset(smb_my_netbios_names, '\0', sizeof(char *) * smb_num_netbios_names);
171 static bool set_my_netbios_names(const char *name, int i)
173 SAFE_FREE(smb_my_netbios_names[i]);
175 smb_my_netbios_names[i] = SMB_STRDUP(name);
176 if (!smb_my_netbios_names[i])
178 strupper_m(smb_my_netbios_names[i]);
182 /***********************************************************************
183 Free memory allocated to global objects
184 ***********************************************************************/
186 void gfree_names(void)
188 SAFE_FREE( smb_myname );
189 SAFE_FREE( smb_myworkgroup );
190 SAFE_FREE( smb_scope );
191 free_netbios_names_array();
194 void gfree_all( void )
203 /* release the talloc null_context memory last */
204 talloc_disable_null_tracking();
207 const char *my_netbios_names(int i)
209 return smb_my_netbios_names[i];
212 bool set_netbios_aliases(const char **str_array)
216 /* Work out the max number of netbios aliases that we have */
217 for( namecount=0; str_array && (str_array[namecount] != NULL); namecount++ )
220 if ( global_myname() && *global_myname())
223 /* Allocate space for the netbios aliases */
224 if (!allocate_my_netbios_names_array(namecount))
227 /* Use the global_myname string first */
229 if ( global_myname() && *global_myname()) {
230 set_my_netbios_names( global_myname(), namecount );
236 for ( i = 0; str_array[i] != NULL; i++) {
238 bool duplicate = False;
240 /* Look for duplicates */
241 for( n=0; n<namecount; n++ ) {
242 if( strequal( str_array[i], my_netbios_names(n) ) ) {
248 if (!set_my_netbios_names(str_array[i], namecount))
257 /****************************************************************************
258 Common name initialization code.
259 ****************************************************************************/
261 bool init_names(void)
266 if (global_myname() == NULL || *global_myname() == '\0') {
267 if (!set_global_myname(myhostname())) {
268 DEBUG( 0, ( "init_structs: malloc fail.\n" ) );
273 if (!set_netbios_aliases(lp_netbios_aliases())) {
274 DEBUG( 0, ( "init_structs: malloc fail.\n" ) );
278 fstrcpy( local_machine, global_myname() );
279 trim_char( local_machine, ' ', ' ' );
280 p = strchr( local_machine, ' ' );
283 strlower_m( local_machine );
285 DEBUG( 5, ("Netbios name list:-\n") );
286 for( n=0; my_netbios_names(n); n++ )
287 DEBUGADD( 5, ( "my_netbios_names[%d]=\"%s\"\n", n, my_netbios_names(n) ) );
292 /**************************************************************************n
293 Find a suitable temporary directory. The result should be copied immediately
294 as it may be overwritten by a subsequent call.
295 ****************************************************************************/
297 const char *tmpdir(void)
300 if ((p = getenv("TMPDIR")))
305 /****************************************************************************
306 Add a gid to an array of gids if it's not already there.
307 ****************************************************************************/
309 bool add_gid_to_array_unique(TALLOC_CTX *mem_ctx, gid_t gid,
310 gid_t **gids, size_t *num_gids)
314 if ((*num_gids != 0) && (*gids == NULL)) {
316 * A former call to this routine has failed to allocate memory
321 for (i=0; i<*num_gids; i++) {
322 if ((*gids)[i] == gid) {
327 *gids = TALLOC_REALLOC_ARRAY(mem_ctx, *gids, gid_t, *num_gids+1);
333 (*gids)[*num_gids] = gid;
338 /****************************************************************************
339 Like atoi but gets the value up to the separator character.
340 ****************************************************************************/
342 static const char *Atoic(const char *p, int *n, const char *c)
344 if (!isdigit((int)*p)) {
345 DEBUG(5, ("Atoic: malformed number\n"));
351 while ((*p) && isdigit((int)*p))
354 if (strchr_m(c, *p) == NULL) {
355 DEBUG(5, ("Atoic: no separator characters (%s) not found\n", c));
362 /*************************************************************************
363 Reads a list of numbers.
364 *************************************************************************/
366 const char *get_numlist(const char *p, uint32 **num, int *count)
370 if (num == NULL || count == NULL)
376 while ((p = Atoic(p, &val, ":,")) != NULL && (*p) != ':') {
377 *num = SMB_REALLOC_ARRAY((*num), uint32, (*count)+1);
381 (*num)[(*count)] = val;
389 /*******************************************************************
390 Check if a file exists - call vfs_file_exist for samba files.
391 ********************************************************************/
393 bool file_exist(const char *fname,SMB_STRUCT_STAT *sbuf)
399 if (sys_stat(fname,sbuf) != 0)
402 return((S_ISREG(sbuf->st_mode)) || (S_ISFIFO(sbuf->st_mode)));
405 /*******************************************************************
406 Check a files mod time.
407 ********************************************************************/
409 time_t file_modtime(const char *fname)
413 if (sys_stat(fname,&st) != 0)
419 /*******************************************************************
420 Check if a directory exists.
421 ********************************************************************/
423 bool directory_exist(char *dname,SMB_STRUCT_STAT *st)
431 if (sys_stat(dname,st) != 0)
434 ret = S_ISDIR(st->st_mode);
440 /*******************************************************************
441 Returns the size in bytes of the named file.
442 ********************************************************************/
444 SMB_OFF_T get_file_size(char *file_name)
448 if(sys_stat(file_name,&buf) != 0)
449 return (SMB_OFF_T)-1;
453 /*******************************************************************
454 Return a string representing an attribute for a file.
455 ********************************************************************/
457 char *attrib_string(uint16 mode)
463 if (mode & aVOLID) fstrcat(attrstr,"V");
464 if (mode & aDIR) fstrcat(attrstr,"D");
465 if (mode & aARCH) fstrcat(attrstr,"A");
466 if (mode & aHIDDEN) fstrcat(attrstr,"H");
467 if (mode & aSYSTEM) fstrcat(attrstr,"S");
468 if (mode & aRONLY) fstrcat(attrstr,"R");
470 return talloc_strdup(talloc_tos(), attrstr);
473 /*******************************************************************
474 Show a smb message structure.
475 ********************************************************************/
477 void show_msg(char *buf)
485 DEBUG(5,("size=%d\nsmb_com=0x%x\nsmb_rcls=%d\nsmb_reh=%d\nsmb_err=%d\nsmb_flg=%d\nsmb_flg2=%d\n",
487 (int)CVAL(buf,smb_com),
488 (int)CVAL(buf,smb_rcls),
489 (int)CVAL(buf,smb_reh),
490 (int)SVAL(buf,smb_err),
491 (int)CVAL(buf,smb_flg),
492 (int)SVAL(buf,smb_flg2)));
493 DEBUGADD(5,("smb_tid=%d\nsmb_pid=%d\nsmb_uid=%d\nsmb_mid=%d\n",
494 (int)SVAL(buf,smb_tid),
495 (int)SVAL(buf,smb_pid),
496 (int)SVAL(buf,smb_uid),
497 (int)SVAL(buf,smb_mid)));
498 DEBUGADD(5,("smt_wct=%d\n",(int)CVAL(buf,smb_wct)));
500 for (i=0;i<(int)CVAL(buf,smb_wct);i++)
501 DEBUGADD(5,("smb_vwv[%2d]=%5d (0x%X)\n",i,
502 SVAL(buf,smb_vwv+2*i),SVAL(buf,smb_vwv+2*i)));
504 bcc = (int)SVAL(buf,smb_vwv+2*(CVAL(buf,smb_wct)));
506 DEBUGADD(5,("smb_bcc=%d\n",bcc));
514 dump_data(10, (uint8 *)smb_buf(buf), bcc);
517 /*******************************************************************
518 Set the length and marker of an smb packet.
519 ********************************************************************/
521 void smb_setlen(char *buf,int len)
523 _smb_setlen(buf,len);
531 /*******************************************************************
532 Setup the word count and byte count for a smb message.
533 ********************************************************************/
535 int set_message(char *buf,int num_words,int num_bytes,bool zero)
537 if (zero && (num_words || num_bytes)) {
538 memset(buf + smb_size,'\0',num_words*2 + num_bytes);
540 SCVAL(buf,smb_wct,num_words);
541 SSVAL(buf,smb_vwv + num_words*SIZEOFWORD,num_bytes);
542 smb_setlen(buf,smb_size + num_words*2 + num_bytes - 4);
543 return (smb_size + num_words*2 + num_bytes);
546 /*******************************************************************
547 Setup only the byte count for a smb message.
548 ********************************************************************/
550 int set_message_bcc(char *buf,int num_bytes)
552 int num_words = CVAL(buf,smb_wct);
553 SSVAL(buf,smb_vwv + num_words*SIZEOFWORD,num_bytes);
554 smb_setlen(buf,smb_size + num_words*2 + num_bytes - 4);
555 return (smb_size + num_words*2 + num_bytes);
558 /*******************************************************************
559 Setup only the byte count for a smb message, using the end of the
561 ********************************************************************/
563 int set_message_end(void *outbuf,void *end_ptr)
565 return set_message_bcc((char *)outbuf,PTR_DIFF(end_ptr,smb_buf((char *)outbuf)));
568 /*******************************************************************
569 Add a data blob to the end of a smb_buf, adjusting bcc and smb_len.
570 Return the bytes added
571 ********************************************************************/
573 ssize_t message_push_blob(uint8 **outbuf, DATA_BLOB blob)
575 size_t newlen = smb_len(*outbuf) + 4 + blob.length;
578 if (!(tmp = TALLOC_REALLOC_ARRAY(NULL, *outbuf, uint8, newlen))) {
579 DEBUG(0, ("talloc failed\n"));
584 memcpy(tmp + smb_len(tmp) + 4, blob.data, blob.length);
585 set_message_bcc((char *)tmp, smb_buflen(tmp) + blob.length);
589 /*******************************************************************
590 Reduce a file name, removing .. elements.
591 ********************************************************************/
593 void dos_clean_name(char *s)
597 DEBUG(3,("dos_clean_name [%s]\n",s));
599 /* remove any double slashes */
600 all_string_sub(s, "\\\\", "\\", 0);
602 /* Remove leading .\\ characters */
603 if(strncmp(s, ".\\", 2) == 0) {
604 trim_string(s, ".\\", NULL);
609 while ((p = strstr_m(s,"\\..\\")) != NULL) {
615 if ((p=strrchr_m(s,'\\')) != NULL)
622 trim_string(s,NULL,"\\..");
623 all_string_sub(s, "\\.\\", "\\", 0);
626 /*******************************************************************
627 Reduce a file name, removing .. elements.
628 ********************************************************************/
630 void unix_clean_name(char *s)
634 DEBUG(3,("unix_clean_name [%s]\n",s));
636 /* remove any double slashes */
637 all_string_sub(s, "//","/", 0);
639 /* Remove leading ./ characters */
640 if(strncmp(s, "./", 2) == 0) {
641 trim_string(s, "./", NULL);
646 while ((p = strstr_m(s,"/../")) != NULL) {
652 if ((p=strrchr_m(s,'/')) != NULL)
659 trim_string(s,NULL,"/..");
660 all_string_sub(s, "/./", "/", 0);
663 void clean_name(char *s)
669 /*******************************************************************
670 Close the low 3 fd's and open dev/null in their place.
671 ********************************************************************/
673 void close_low_fds(bool stderr_too)
685 /* try and use up these file descriptors, so silly
686 library routines writing to stdout etc won't cause havoc */
688 if (i == 2 && !stderr_too)
691 fd = sys_open("/dev/null",O_RDWR,0);
693 fd = sys_open("/dev/null",O_WRONLY,0);
695 DEBUG(0,("Can't open /dev/null\n"));
699 DEBUG(0,("Didn't get file descriptor %d\n",i));
706 /*******************************************************************
707 Write data into an fd at a given offset. Ignore seek errors.
708 ********************************************************************/
710 ssize_t write_data_at_offset(int fd, const char *buffer, size_t N, SMB_OFF_T pos)
715 if (pos == (SMB_OFF_T)-1) {
716 return write_data(fd, buffer, N);
718 #if defined(HAVE_PWRITE) || defined(HAVE_PRWITE64)
720 ret = sys_pwrite(fd,buffer + total,N - total, pos);
721 if (ret == -1 && errno == ESPIPE) {
722 return write_data(fd, buffer + total,N - total);
725 DEBUG(0,("write_data_at_offset: write failure. Error = %s\n", strerror(errno) ));
734 return (ssize_t)total;
736 /* Use lseek and write_data. */
737 if (sys_lseek(fd, pos, SEEK_SET) == -1) {
738 if (errno != ESPIPE) {
742 return write_data(fd, buffer, N);
746 /****************************************************************************
747 Set a fd into blocking/nonblocking mode. Uses POSIX O_NONBLOCK if available,
751 ****************************************************************************/
753 int set_blocking(int fd, bool set)
757 #define FLAG_TO_SET O_NONBLOCK
760 #define FLAG_TO_SET O_NDELAY
762 #define FLAG_TO_SET FNDELAY
766 if((val = sys_fcntl_long(fd, F_GETFL, 0)) == -1)
768 if(set) /* Turn blocking on - ie. clear nonblock flag */
772 return sys_fcntl_long( fd, F_SETFL, val);
776 /****************************************************************************
777 Transfer some data between two fd's.
778 ****************************************************************************/
780 #ifndef TRANSFER_BUF_SIZE
781 #define TRANSFER_BUF_SIZE 65536
784 ssize_t transfer_file_internal(int infd, int outfd, size_t n, ssize_t (*read_fn)(int, void *, size_t),
785 ssize_t (*write_fn)(int, const void *, size_t))
791 size_t num_to_read_thistime;
792 size_t num_written = 0;
794 if ((buf = SMB_MALLOC_ARRAY(char, TRANSFER_BUF_SIZE)) == NULL)
798 num_to_read_thistime = MIN((n - total), TRANSFER_BUF_SIZE);
800 read_ret = (*read_fn)(infd, buf, num_to_read_thistime);
801 if (read_ret == -1) {
802 DEBUG(0,("transfer_file_internal: read failure. Error = %s\n", strerror(errno) ));
811 while (num_written < read_ret) {
812 write_ret = (*write_fn)(outfd,buf + num_written, read_ret - num_written);
814 if (write_ret == -1) {
815 DEBUG(0,("transfer_file_internal: write failure. Error = %s\n", strerror(errno) ));
820 return (ssize_t)total;
822 num_written += (size_t)write_ret;
825 total += (size_t)read_ret;
829 return (ssize_t)total;
832 SMB_OFF_T transfer_file(int infd,int outfd,SMB_OFF_T n)
834 return (SMB_OFF_T)transfer_file_internal(infd, outfd, (size_t)n, sys_read, sys_write);
837 /*******************************************************************
838 Sleep for a specified number of milliseconds.
839 ********************************************************************/
841 void smb_msleep(unsigned int t)
843 #if defined(HAVE_NANOSLEEP)
844 struct timespec tval;
847 tval.tv_sec = t/1000;
848 tval.tv_nsec = 1000000*(t%1000);
852 ret = nanosleep(&tval, &tval);
853 } while (ret < 0 && errno == EINTR && (tval.tv_sec > 0 || tval.tv_nsec > 0));
855 unsigned int tdiff=0;
856 struct timeval tval,t1,t2;
863 tval.tv_sec = (t-tdiff)/1000;
864 tval.tv_usec = 1000*((t-tdiff)%1000);
866 /* Never wait for more than 1 sec. */
867 if (tval.tv_sec > 1) {
874 sys_select_intr(0,&fds,NULL,NULL,&tval);
877 if (t2.tv_sec < t1.tv_sec) {
878 /* Someone adjusted time... */
882 tdiff = TvalDiff(&t1,&t2);
887 /****************************************************************************
888 Become a daemon, discarding the controlling terminal.
889 ****************************************************************************/
891 void become_daemon(bool Fork, bool no_process_group)
899 /* detach from the terminal */
901 if (!no_process_group) setsid();
902 #elif defined(TIOCNOTTY)
903 if (!no_process_group) {
904 int i = sys_open("/dev/tty", O_RDWR, 0);
906 ioctl(i, (int) TIOCNOTTY, (char *)0);
910 #endif /* HAVE_SETSID */
912 /* Close fd's 0,1,2. Needed if started by rsh */
913 close_low_fds(False); /* Don't close stderr, let the debug system
914 attach it to the logfile */
917 /****************************************************************************
918 Put up a yes/no prompt.
919 ****************************************************************************/
926 if (!fgets(ans,sizeof(ans)-1,stdin))
929 if (*ans == 'y' || *ans == 'Y')
935 #if defined(PARANOID_MALLOC_CHECKER)
937 /****************************************************************************
938 Internal malloc wrapper. Externally visible.
939 ****************************************************************************/
941 void *malloc_(size_t size)
948 #define malloc(s) __ERROR_DONT_USE_MALLOC_DIRECTLY
951 /****************************************************************************
952 Internal calloc wrapper. Not externally visible.
953 ****************************************************************************/
955 static void *calloc_(size_t count, size_t size)
957 if (size == 0 || count == 0) {
961 return calloc(count, size);
962 #define calloc(n,s) __ERROR_DONT_USE_CALLOC_DIRECTLY
965 /****************************************************************************
966 Internal realloc wrapper. Not externally visible.
967 ****************************************************************************/
969 static void *realloc_(void *ptr, size_t size)
972 return realloc(ptr, size);
973 #define realloc(p,s) __ERROR_DONT_USE_RELLOC_DIRECTLY
976 #endif /* PARANOID_MALLOC_CHECKER */
978 /****************************************************************************
980 ****************************************************************************/
982 void *malloc_array(size_t el_size, unsigned int count)
984 if (count >= MAX_ALLOC_SIZE/el_size) {
988 if (el_size == 0 || count == 0) {
991 #if defined(PARANOID_MALLOC_CHECKER)
992 return malloc_(el_size*count);
994 return malloc(el_size*count);
998 /****************************************************************************
1000 ****************************************************************************/
1002 void *memalign_array(size_t el_size, size_t align, unsigned int count)
1004 if (count >= MAX_ALLOC_SIZE/el_size) {
1008 return sys_memalign(align, el_size*count);
1011 /****************************************************************************
1013 ****************************************************************************/
1015 void *calloc_array(size_t size, size_t nmemb)
1017 if (nmemb >= MAX_ALLOC_SIZE/size) {
1020 if (size == 0 || nmemb == 0) {
1023 #if defined(PARANOID_MALLOC_CHECKER)
1024 return calloc_(nmemb, size);
1026 return calloc(nmemb, size);
1030 /****************************************************************************
1031 Expand a pointer to be a particular size.
1032 Note that this version of Realloc has an extra parameter that decides
1033 whether to free the passed in storage on allocation failure or if the
1036 This is designed for use in the typical idiom of :
1038 p = SMB_REALLOC(p, size)
1043 and not to have to keep track of the old 'p' contents to free later, nor
1044 to worry if the size parameter was zero. In the case where NULL is returned
1045 we guarentee that p has been freed.
1047 If free later semantics are desired, then pass 'free_old_on_error' as False which
1048 guarentees that the old contents are not freed on error, even if size == 0. To use
1051 tmp = SMB_REALLOC_KEEP_OLD_ON_ERROR(p, size);
1059 Changes were instigated by Coverity error checking. JRA.
1060 ****************************************************************************/
1062 void *Realloc(void *p, size_t size, bool free_old_on_error)
1067 if (free_old_on_error) {
1070 DEBUG(2,("Realloc asked for 0 bytes\n"));
1074 #if defined(PARANOID_MALLOC_CHECKER)
1076 ret = (void *)malloc_(size);
1078 ret = (void *)realloc_(p,size);
1082 ret = (void *)malloc(size);
1084 ret = (void *)realloc(p,size);
1089 if (free_old_on_error && p) {
1092 DEBUG(0,("Memory allocation error: failed to expand to %d bytes\n",(int)size));
1098 /****************************************************************************
1100 ****************************************************************************/
1102 void *realloc_array(void *p, size_t el_size, unsigned int count, bool free_old_on_error)
1104 if (count >= MAX_ALLOC_SIZE/el_size) {
1105 if (free_old_on_error) {
1110 return Realloc(p, el_size*count, free_old_on_error);
1113 /****************************************************************************
1114 (Hopefully) efficient array append.
1115 ****************************************************************************/
1117 void add_to_large_array(TALLOC_CTX *mem_ctx, size_t element_size,
1118 void *element, void *_array, uint32 *num_elements,
1119 ssize_t *array_size)
1121 void **array = (void **)_array;
1123 if (*array_size < 0) {
1127 if (*array == NULL) {
1128 if (*array_size == 0) {
1132 if (*array_size >= MAX_ALLOC_SIZE/element_size) {
1136 *array = TALLOC(mem_ctx, element_size * (*array_size));
1137 if (*array == NULL) {
1142 if (*num_elements == *array_size) {
1145 if (*array_size >= MAX_ALLOC_SIZE/element_size) {
1149 *array = TALLOC_REALLOC(mem_ctx, *array,
1150 element_size * (*array_size));
1152 if (*array == NULL) {
1157 memcpy((char *)(*array) + element_size*(*num_elements),
1158 element, element_size);
1168 /****************************************************************************
1169 Free memory, checks for NULL.
1170 Use directly SAFE_FREE()
1171 Exists only because we need to pass a function pointer somewhere --SSS
1172 ****************************************************************************/
1174 void safe_free(void *p)
1179 /****************************************************************************
1180 Get my own name and IP.
1181 ****************************************************************************/
1183 char *get_myname(TALLOC_CTX *ctx)
1186 char hostname[HOST_NAME_MAX];
1190 /* get my host name */
1191 if (gethostname(hostname, sizeof(hostname)) == -1) {
1192 DEBUG(0,("gethostname failed\n"));
1196 /* Ensure null termination. */
1197 hostname[sizeof(hostname)-1] = '\0';
1199 /* split off any parts after an initial . */
1200 p = strchr_m(hostname,'.');
1205 return talloc_strdup(ctx, hostname);
1208 /****************************************************************************
1209 Get my own domain name, or "" if we have none.
1210 ****************************************************************************/
1212 char *get_mydnsdomname(TALLOC_CTX *ctx)
1214 const char *domname;
1217 domname = get_mydnsfullname();
1222 p = strchr_m(domname, '.');
1225 return talloc_strdup(ctx, p);
1227 return talloc_strdup(ctx, "");
1231 /****************************************************************************
1232 Interpret a protocol description string, with a default.
1233 ****************************************************************************/
1235 int interpret_protocol(const char *str,int def)
1237 if (strequal(str,"NT1"))
1238 return(PROTOCOL_NT1);
1239 if (strequal(str,"LANMAN2"))
1240 return(PROTOCOL_LANMAN2);
1241 if (strequal(str,"LANMAN1"))
1242 return(PROTOCOL_LANMAN1);
1243 if (strequal(str,"CORE"))
1244 return(PROTOCOL_CORE);
1245 if (strequal(str,"COREPLUS"))
1246 return(PROTOCOL_COREPLUS);
1247 if (strequal(str,"CORE+"))
1248 return(PROTOCOL_COREPLUS);
1250 DEBUG(0,("Unrecognised protocol level %s\n",str));
1256 #if (defined(HAVE_NETGROUP) && defined(WITH_AUTOMOUNT))
1257 /******************************************************************
1258 Remove any mount options such as -rsize=2048,wsize=2048 etc.
1259 Based on a fix from <Thomas.Hepper@icem.de>.
1260 *******************************************************************/
1262 static void strip_mount_options( pstring *str)
1266 while(*p && !isspace(*p))
1268 while(*p && isspace(*p))
1273 pstrcpy(tmp_str, p);
1274 pstrcpy(*str, tmp_str);
1279 /*******************************************************************
1280 Patch from jkf@soton.ac.uk
1281 Split Luke's automount_server into YP lookup and string splitter
1282 so can easily implement automount_path().
1283 As we may end up doing both, cache the last YP result.
1284 *******************************************************************/
1286 #ifdef WITH_NISPLUS_HOME
1287 char *automount_lookup(const char *user_name)
1289 static fstring last_key = "";
1290 static pstring last_value = "";
1292 char *nis_map = (char *)lp_nis_home_map_name();
1294 char buffer[NIS_MAXATTRVAL + 1];
1299 if (strcmp(user_name, last_key)) {
1300 slprintf(buffer, sizeof(buffer)-1, "[key=%s],%s", user_name, nis_map);
1301 DEBUG(5, ("NIS+ querystring: %s\n", buffer));
1303 if (result = nis_list(buffer, FOLLOW_PATH|EXPAND_NAME|HARD_LOOKUP, NULL, NULL)) {
1304 if (result->status != NIS_SUCCESS) {
1305 DEBUG(3, ("NIS+ query failed: %s\n", nis_sperrno(result->status)));
1306 fstrcpy(last_key, ""); pstrcpy(last_value, "");
1308 object = result->objects.objects_val;
1309 if (object->zo_data.zo_type == ENTRY_OBJ) {
1310 entry = &object->zo_data.objdata_u.en_data;
1311 DEBUG(5, ("NIS+ entry type: %s\n", entry->en_type));
1312 DEBUG(3, ("NIS+ result: %s\n", entry->en_cols.en_cols_val[1].ec_value.ec_value_val));
1314 pstrcpy(last_value, entry->en_cols.en_cols_val[1].ec_value.ec_value_val);
1315 pstring_sub(last_value, "&", user_name);
1316 fstrcpy(last_key, user_name);
1320 nis_freeresult(result);
1323 strip_mount_options(&last_value);
1325 DEBUG(4, ("NIS+ Lookup: %s resulted in %s\n", user_name, last_value));
1328 #else /* WITH_NISPLUS_HOME */
1330 char *automount_lookup(const char *user_name)
1332 static fstring last_key = "";
1333 static pstring last_value = "";
1335 int nis_error; /* returned by yp all functions */
1336 char *nis_result; /* yp_match inits this */
1337 int nis_result_len; /* and set this */
1338 char *nis_domain; /* yp_get_default_domain inits this */
1339 char *nis_map = (char *)lp_nis_home_map_name();
1341 if ((nis_error = yp_get_default_domain(&nis_domain)) != 0) {
1342 DEBUG(3, ("YP Error: %s\n", yperr_string(nis_error)));
1346 DEBUG(5, ("NIS Domain: %s\n", nis_domain));
1348 if (!strcmp(user_name, last_key)) {
1349 nis_result = last_value;
1350 nis_result_len = strlen(last_value);
1353 if ((nis_error = yp_match(nis_domain, nis_map, user_name, strlen(user_name),
1354 &nis_result, &nis_result_len)) == 0) {
1355 fstrcpy(last_key, user_name);
1356 pstrcpy(last_value, nis_result);
1357 strip_mount_options(&last_value);
1359 } else if(nis_error == YPERR_KEY) {
1361 /* If Key lookup fails user home server is not in nis_map
1362 use default information for server, and home directory */
1364 DEBUG(3, ("YP Key not found: while looking up \"%s\" in map \"%s\"\n",
1365 user_name, nis_map));
1366 DEBUG(3, ("using defaults for server and home directory\n"));
1368 DEBUG(3, ("YP Error: \"%s\" while looking up \"%s\" in map \"%s\"\n",
1369 yperr_string(nis_error), user_name, nis_map));
1373 DEBUG(4, ("YP Lookup: %s resulted in %s\n", user_name, last_value));
1376 #endif /* WITH_NISPLUS_HOME */
1379 /****************************************************************************
1380 Check if a process exists. Does this work on all unixes?
1381 ****************************************************************************/
1383 bool process_exists(const struct server_id pid)
1385 if (procid_is_me(&pid)) {
1389 if (procid_is_local(&pid)) {
1390 return (kill(pid.pid,0) == 0 || errno != ESRCH);
1393 #ifdef CLUSTER_SUPPORT
1394 return ctdbd_process_exists(messaging_ctdbd_connection(), pid.vnn,
1401 bool process_exists_by_pid(pid_t pid)
1403 /* Doing kill with a non-positive pid causes messages to be
1404 * sent to places we don't want. */
1405 SMB_ASSERT(pid > 0);
1406 return(kill(pid,0) == 0 || errno != ESRCH);
1409 /*******************************************************************
1410 Convert a uid into a user name.
1411 ********************************************************************/
1413 const char *uidtoname(uid_t uid)
1415 TALLOC_CTX *ctx = talloc_tos();
1417 struct passwd *pass = NULL;
1419 pass = getpwuid_alloc(ctx,uid);
1421 name = talloc_strdup(ctx,pass->pw_name);
1424 name = talloc_asprintf(ctx,
1431 /*******************************************************************
1432 Convert a gid into a group name.
1433 ********************************************************************/
1435 char *gidtoname(gid_t gid)
1440 grp = getgrgid(gid);
1442 fstrcpy(name, grp->gr_name);
1445 slprintf(name,sizeof(name) - 1, "%d",(int)gid);
1447 return talloc_strdup(talloc_tos(), name);
1450 /*******************************************************************
1451 Convert a user name into a uid.
1452 ********************************************************************/
1454 uid_t nametouid(const char *name)
1456 struct passwd *pass;
1460 pass = getpwnam_alloc(NULL, name);
1467 u = (uid_t)strtol(name, &p, 0);
1468 if ((p != name) && (*p == '\0'))
1474 /*******************************************************************
1475 Convert a name to a gid_t if possible. Return -1 if not a group.
1476 ********************************************************************/
1478 gid_t nametogid(const char *name)
1484 g = (gid_t)strtol(name, &p, 0);
1485 if ((p != name) && (*p == '\0'))
1488 grp = sys_getgrnam(name);
1490 return(grp->gr_gid);
1494 /*******************************************************************
1495 Something really nasty happened - panic !
1496 ********************************************************************/
1498 void smb_panic(const char *const why)
1506 if (global_clobber_region_function) {
1507 DEBUG(0,("smb_panic: clobber_region() last called from [%s(%u)]\n",
1508 global_clobber_region_function,
1509 global_clobber_region_line));
1514 DEBUG(0,("PANIC (pid %llu): %s\n",
1515 (unsigned long long)sys_getpid(), why));
1518 cmd = lp_panic_action();
1520 DEBUG(0, ("smb_panic(): calling panic action [%s]\n", cmd));
1521 result = system(cmd);
1524 DEBUG(0, ("smb_panic(): fork failed in panic action: %s\n",
1527 DEBUG(0, ("smb_panic(): action returned status %d\n",
1528 WEXITSTATUS(result)));
1534 /*******************************************************************
1535 Print a backtrace of the stack to the debug log. This function
1536 DELIBERATELY LEAKS MEMORY. The expectation is that you should
1537 exit shortly after calling it.
1538 ********************************************************************/
1540 #ifdef HAVE_LIBUNWIND_H
1541 #include <libunwind.h>
1544 #ifdef HAVE_EXECINFO_H
1545 #include <execinfo.h>
1548 #ifdef HAVE_LIBEXC_H
1552 void log_stack_trace(void)
1554 #ifdef HAVE_LIBUNWIND
1555 /* Try to use libunwind before any other technique since on ia64
1556 * libunwind correctly walks the stack in more circumstances than
1559 unw_cursor_t cursor;
1564 unw_word_t ip, sp, off;
1566 procname[sizeof(procname) - 1] = '\0';
1568 if (unw_getcontext(&uc) != 0) {
1569 goto libunwind_failed;
1572 if (unw_init_local(&cursor, &uc) != 0) {
1573 goto libunwind_failed;
1576 DEBUG(0, ("BACKTRACE:\n"));
1580 unw_get_reg(&cursor, UNW_REG_IP, &ip);
1581 unw_get_reg(&cursor, UNW_REG_SP, &sp);
1583 switch (unw_get_proc_name(&cursor,
1584 procname, sizeof(procname) - 1, &off) ) {
1588 /* Name truncated. */
1589 DEBUGADD(0, (" #%u %s + %#llx [ip=%#llx] [sp=%#llx]\n",
1590 i, procname, (long long)off,
1591 (long long)ip, (long long) sp));
1594 /* case -UNW_ENOINFO: */
1595 /* case -UNW_EUNSPEC: */
1596 /* No symbol name found. */
1597 DEBUGADD(0, (" #%u %s [ip=%#llx] [sp=%#llx]\n",
1598 i, "<unknown symbol>",
1599 (long long)ip, (long long) sp));
1602 } while (unw_step(&cursor) > 0);
1607 DEBUG(0, ("unable to produce a stack trace with libunwind\n"));
1609 #elif HAVE_BACKTRACE_SYMBOLS
1610 void *backtrace_stack[BACKTRACE_STACK_SIZE];
1611 size_t backtrace_size;
1612 char **backtrace_strings;
1614 /* get the backtrace (stack frames) */
1615 backtrace_size = backtrace(backtrace_stack,BACKTRACE_STACK_SIZE);
1616 backtrace_strings = backtrace_symbols(backtrace_stack, backtrace_size);
1618 DEBUG(0, ("BACKTRACE: %lu stack frames:\n",
1619 (unsigned long)backtrace_size));
1621 if (backtrace_strings) {
1624 for (i = 0; i < backtrace_size; i++)
1625 DEBUGADD(0, (" #%u %s\n", i, backtrace_strings[i]));
1627 /* Leak the backtrace_strings, rather than risk what free() might do */
1632 /* The IRIX libexc library provides an API for unwinding the stack. See
1633 * libexc(3) for details. Apparantly trace_back_stack leaks memory, but
1634 * since we are about to abort anyway, it hardly matters.
1637 #define NAMESIZE 32 /* Arbitrary */
1639 __uint64_t addrs[BACKTRACE_STACK_SIZE];
1640 char * names[BACKTRACE_STACK_SIZE];
1641 char namebuf[BACKTRACE_STACK_SIZE * NAMESIZE];
1648 ZERO_ARRAY(namebuf);
1650 /* We need to be root so we can open our /proc entry to walk
1651 * our stack. It also helps when we want to dump core.
1655 for (i = 0; i < BACKTRACE_STACK_SIZE; i++) {
1656 names[i] = namebuf + (i * NAMESIZE);
1659 levels = trace_back_stack(0, addrs, names,
1660 BACKTRACE_STACK_SIZE, NAMESIZE - 1);
1662 DEBUG(0, ("BACKTRACE: %d stack frames:\n", levels));
1663 for (i = 0; i < levels; i++) {
1664 DEBUGADD(0, (" #%d 0x%llx %s\n", i, addrs[i], names[i]));
1669 DEBUG(0, ("unable to produce a stack trace on this platform\n"));
1673 /*******************************************************************
1674 A readdir wrapper which just returns the file name.
1675 ********************************************************************/
1677 const char *readdirname(SMB_STRUCT_DIR *p)
1679 SMB_STRUCT_DIRENT *ptr;
1685 ptr = (SMB_STRUCT_DIRENT *)sys_readdir(p);
1689 dname = ptr->d_name;
1696 #ifdef HAVE_BROKEN_READDIR_NAME
1697 /* using /usr/ucb/cc is BAD */
1701 return talloc_strdup(talloc_tos(), dname);
1704 /*******************************************************************
1705 Utility function used to decide if the last component
1706 of a path matches a (possibly wildcarded) entry in a namelist.
1707 ********************************************************************/
1709 bool is_in_path(const char *name, name_compare_entry *namelist, bool case_sensitive)
1711 const char *last_component;
1713 /* if we have no list it's obviously not in the path */
1714 if((namelist == NULL ) || ((namelist != NULL) && (namelist[0].name == NULL))) {
1718 DEBUG(8, ("is_in_path: %s\n", name));
1720 /* Get the last component of the unix name. */
1721 last_component = strrchr_m(name, '/');
1722 if (!last_component) {
1723 last_component = name;
1725 last_component++; /* Go past '/' */
1728 for(; namelist->name != NULL; namelist++) {
1729 if(namelist->is_wild) {
1730 if (mask_match(last_component, namelist->name, case_sensitive)) {
1731 DEBUG(8,("is_in_path: mask match succeeded\n"));
1735 if((case_sensitive && (strcmp(last_component, namelist->name) == 0))||
1736 (!case_sensitive && (StrCaseCmp(last_component, namelist->name) == 0))) {
1737 DEBUG(8,("is_in_path: match succeeded\n"));
1742 DEBUG(8,("is_in_path: match not found\n"));
1746 /*******************************************************************
1747 Strip a '/' separated list into an array of
1748 name_compare_enties structures suitable for
1749 passing to is_in_path(). We do this for
1750 speed so we can pre-parse all the names in the list
1751 and don't do it for each call to is_in_path().
1752 namelist is modified here and is assumed to be
1753 a copy owned by the caller.
1754 We also check if the entry contains a wildcard to
1755 remove a potentially expensive call to mask_match
1757 ********************************************************************/
1759 void set_namearray(name_compare_entry **ppname_array, char *namelist)
1762 char *nameptr = namelist;
1763 int num_entries = 0;
1766 (*ppname_array) = NULL;
1768 if((nameptr == NULL ) || ((nameptr != NULL) && (*nameptr == '\0')))
1771 /* We need to make two passes over the string. The
1772 first to count the number of elements, the second
1777 if ( *nameptr == '/' ) {
1778 /* cope with multiple (useless) /s) */
1782 /* find the next / */
1783 name_end = strchr_m(nameptr, '/');
1785 /* oops - the last check for a / didn't find one. */
1786 if (name_end == NULL)
1789 /* next segment please */
1790 nameptr = name_end + 1;
1794 if(num_entries == 0)
1797 if(( (*ppname_array) = SMB_MALLOC_ARRAY(name_compare_entry, num_entries + 1)) == NULL) {
1798 DEBUG(0,("set_namearray: malloc fail\n"));
1802 /* Now copy out the names */
1806 if ( *nameptr == '/' ) {
1807 /* cope with multiple (useless) /s) */
1811 /* find the next / */
1812 if ((name_end = strchr_m(nameptr, '/')) != NULL)
1815 /* oops - the last check for a / didn't find one. */
1816 if(name_end == NULL)
1819 (*ppname_array)[i].is_wild = ms_has_wild(nameptr);
1820 if(((*ppname_array)[i].name = SMB_STRDUP(nameptr)) == NULL) {
1821 DEBUG(0,("set_namearray: malloc fail (1)\n"));
1825 /* next segment please */
1826 nameptr = name_end + 1;
1830 (*ppname_array)[i].name = NULL;
1835 /****************************************************************************
1836 Routine to free a namearray.
1837 ****************************************************************************/
1839 void free_namearray(name_compare_entry *name_array)
1843 if(name_array == NULL)
1846 for(i=0; name_array[i].name!=NULL; i++)
1847 SAFE_FREE(name_array[i].name);
1848 SAFE_FREE(name_array);
1852 #define DBGC_CLASS DBGC_LOCKING
1854 /****************************************************************************
1855 Simple routine to do POSIX file locking. Cruft in NFS and 64->32 bit mapping
1856 is dealt with in posix.c
1857 Returns True if the lock was granted, False otherwise.
1858 ****************************************************************************/
1860 bool fcntl_lock(int fd, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
1862 SMB_STRUCT_FLOCK lock;
1865 DEBUG(8,("fcntl_lock fd=%d op=%d offset=%.0f count=%.0f type=%d\n",
1866 fd,op,(double)offset,(double)count,type));
1869 lock.l_whence = SEEK_SET;
1870 lock.l_start = offset;
1874 ret = sys_fcntl_ptr(fd,op,&lock);
1878 DEBUG(3,("fcntl_lock: lock failed at offset %.0f count %.0f op %d type %d (%s)\n",
1879 (double)offset,(double)count,op,type,strerror(errno)));
1884 /* everything went OK */
1885 DEBUG(8,("fcntl_lock: Lock call successful\n"));
1890 /****************************************************************************
1891 Simple routine to query existing file locks. Cruft in NFS and 64->32 bit mapping
1892 is dealt with in posix.c
1893 Returns True if we have information regarding this lock region (and returns
1894 F_UNLCK in *ptype if the region is unlocked). False if the call failed.
1895 ****************************************************************************/
1897 bool fcntl_getlock(int fd, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype, pid_t *ppid)
1899 SMB_STRUCT_FLOCK lock;
1902 DEBUG(8,("fcntl_getlock fd=%d offset=%.0f count=%.0f type=%d\n",
1903 fd,(double)*poffset,(double)*pcount,*ptype));
1905 lock.l_type = *ptype;
1906 lock.l_whence = SEEK_SET;
1907 lock.l_start = *poffset;
1908 lock.l_len = *pcount;
1911 ret = sys_fcntl_ptr(fd,SMB_F_GETLK,&lock);
1915 DEBUG(3,("fcntl_getlock: lock request failed at offset %.0f count %.0f type %d (%s)\n",
1916 (double)*poffset,(double)*pcount,*ptype,strerror(errno)));
1921 *ptype = lock.l_type;
1922 *poffset = lock.l_start;
1923 *pcount = lock.l_len;
1926 DEBUG(3,("fcntl_getlock: fd %d is returned info %d pid %u\n",
1927 fd, (int)lock.l_type, (unsigned int)lock.l_pid));
1932 #define DBGC_CLASS DBGC_ALL
1934 /*******************************************************************
1935 Is the name specified one of my netbios names.
1936 Returns true if it is equal, false otherwise.
1937 ********************************************************************/
1939 bool is_myname(const char *s)
1944 for (n=0; my_netbios_names(n); n++) {
1945 if (strequal(my_netbios_names(n), s)) {
1950 DEBUG(8, ("is_myname(\"%s\") returns %d\n", s, ret));
1954 /*******************************************************************
1955 Is the name specified our workgroup/domain.
1956 Returns true if it is equal, false otherwise.
1957 ********************************************************************/
1959 bool is_myworkgroup(const char *s)
1963 if (strequal(s, lp_workgroup())) {
1967 DEBUG(8, ("is_myworkgroup(\"%s\") returns %d\n", s, ret));
1971 /*******************************************************************
1972 we distinguish between 2K and XP by the "Native Lan Manager" string
1973 WinXP => "Windows 2002 5.1"
1974 WinXP 64bit => "Windows XP 5.2"
1975 Win2k => "Windows 2000 5.0"
1976 NT4 => "Windows NT 4.0"
1977 Win9x => "Windows 4.0"
1978 Windows 2003 doesn't set the native lan manager string but
1979 they do set the domain to "Windows 2003 5.2" (probably a bug).
1980 ********************************************************************/
1982 void ra_lanman_string( const char *native_lanman )
1984 if ( strcmp( native_lanman, "Windows 2002 5.1" ) == 0 )
1985 set_remote_arch( RA_WINXP );
1986 else if ( strcmp( native_lanman, "Windows XP 5.2" ) == 0 )
1987 set_remote_arch( RA_WINXP );
1988 else if ( strcmp( native_lanman, "Windows Server 2003 5.2" ) == 0 )
1989 set_remote_arch( RA_WIN2K3 );
1992 /*******************************************************************
1993 Set the horrid remote_arch string based on an enum.
1994 ********************************************************************/
1996 void set_remote_arch(enum remote_arch_types type)
2001 fstrcpy(remote_arch, "WfWg");
2004 fstrcpy(remote_arch, "OS2");
2007 fstrcpy(remote_arch, "Win95");
2010 fstrcpy(remote_arch, "WinNT");
2013 fstrcpy(remote_arch, "Win2K");
2016 fstrcpy(remote_arch, "WinXP");
2019 fstrcpy(remote_arch, "Win2K3");
2022 fstrcpy(remote_arch, "Vista");
2025 fstrcpy(remote_arch,"Samba");
2028 fstrcpy(remote_arch,"CIFSFS");
2031 ra_type = RA_UNKNOWN;
2032 fstrcpy(remote_arch, "UNKNOWN");
2036 DEBUG(10,("set_remote_arch: Client arch is \'%s\'\n", remote_arch));
2039 /*******************************************************************
2040 Get the remote_arch type.
2041 ********************************************************************/
2043 enum remote_arch_types get_remote_arch(void)
2048 void print_asc(int level, const unsigned char *buf,int len)
2052 DEBUG(level,("%c", isprint(buf[i])?buf[i]:'.'));
2055 void dump_data(int level, const unsigned char *buf1,int len)
2057 const unsigned char *buf = (const unsigned char *)buf1;
2061 if (!DEBUGLVL(level)) return;
2063 DEBUGADD(level,("[%03X] ",i));
2065 DEBUGADD(level,("%02X ",(int)buf[i]));
2067 if (i%8 == 0) DEBUGADD(level,(" "));
2069 print_asc(level,&buf[i-16],8); DEBUGADD(level,(" "));
2070 print_asc(level,&buf[i-8],8); DEBUGADD(level,("\n"));
2071 if (i<len) DEBUGADD(level,("[%03X] ",i));
2077 DEBUGADD(level,(" "));
2078 if (n>8) DEBUGADD(level,(" "));
2079 while (n--) DEBUGADD(level,(" "));
2081 print_asc(level,&buf[i-(i%16)],n); DEBUGADD(level,( " " ));
2083 if (n>0) print_asc(level,&buf[i-n],n);
2084 DEBUGADD(level,("\n"));
2088 void dump_data_pw(const char *msg, const uchar * data, size_t len)
2090 #ifdef DEBUG_PASSWORD
2091 DEBUG(11, ("%s", msg));
2092 if (data != NULL && len > 0)
2094 dump_data(11, data, len);
2099 char *tab_depth(int depth)
2101 static pstring spaces;
2102 memset(spaces, ' ', depth * 4);
2103 spaces[depth * 4] = 0;
2107 /*****************************************************************************
2108 Provide a checksum on a string
2110 Input: s - the null-terminated character string for which the checksum
2113 Output: The checksum value calculated for s.
2114 *****************************************************************************/
2116 int str_checksum(const char *s)
2124 res ^= (c << (i % 15)) ^ (c >> (15-(i%15)));
2131 /*****************************************************************
2132 Zero a memory area then free it. Used to catch bugs faster.
2133 *****************************************************************/
2135 void zero_free(void *p, size_t size)
2141 /*****************************************************************
2142 Set our open file limit to a requested max and return the limit.
2143 *****************************************************************/
2145 int set_maxfiles(int requested_max)
2147 #if (defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE))
2149 int saved_current_limit;
2151 if(getrlimit(RLIMIT_NOFILE, &rlp)) {
2152 DEBUG(0,("set_maxfiles: getrlimit (1) for RLIMIT_NOFILE failed with error %s\n",
2155 return requested_max;
2159 * Set the fd limit to be real_max_open_files + MAX_OPEN_FUDGEFACTOR to
2160 * account for the extra fd we need
2161 * as well as the log files and standard
2162 * handles etc. Save the limit we want to set in case
2163 * we are running on an OS that doesn't support this limit (AIX)
2164 * which always returns RLIM_INFINITY for rlp.rlim_max.
2167 /* Try raising the hard (max) limit to the requested amount. */
2169 #if defined(RLIM_INFINITY)
2170 if (rlp.rlim_max != RLIM_INFINITY) {
2171 int orig_max = rlp.rlim_max;
2173 if ( rlp.rlim_max < requested_max )
2174 rlp.rlim_max = requested_max;
2176 /* This failing is not an error - many systems (Linux) don't
2177 support our default request of 10,000 open files. JRA. */
2179 if(setrlimit(RLIMIT_NOFILE, &rlp)) {
2180 DEBUG(3,("set_maxfiles: setrlimit for RLIMIT_NOFILE for %d max files failed with error %s\n",
2181 (int)rlp.rlim_max, strerror(errno) ));
2183 /* Set failed - restore original value from get. */
2184 rlp.rlim_max = orig_max;
2189 /* Now try setting the soft (current) limit. */
2191 saved_current_limit = rlp.rlim_cur = MIN(requested_max,rlp.rlim_max);
2193 if(setrlimit(RLIMIT_NOFILE, &rlp)) {
2194 DEBUG(0,("set_maxfiles: setrlimit for RLIMIT_NOFILE for %d files failed with error %s\n",
2195 (int)rlp.rlim_cur, strerror(errno) ));
2197 return saved_current_limit;
2200 if(getrlimit(RLIMIT_NOFILE, &rlp)) {
2201 DEBUG(0,("set_maxfiles: getrlimit (2) for RLIMIT_NOFILE failed with error %s\n",
2204 return saved_current_limit;
2207 #if defined(RLIM_INFINITY)
2208 if(rlp.rlim_cur == RLIM_INFINITY)
2209 return saved_current_limit;
2212 if((int)rlp.rlim_cur > saved_current_limit)
2213 return saved_current_limit;
2215 return rlp.rlim_cur;
2216 #else /* !defined(HAVE_GETRLIMIT) || !defined(RLIMIT_NOFILE) */
2218 * No way to know - just guess...
2220 return requested_max;
2224 /*****************************************************************
2225 Possibly replace mkstemp if it is broken.
2226 *****************************************************************/
2228 int smb_mkstemp(char *name_template)
2230 #if HAVE_SECURE_MKSTEMP
2231 return mkstemp(name_template);
2233 /* have a reasonable go at emulating it. Hope that
2234 the system mktemp() isn't completly hopeless */
2235 char *p = mktemp(name_template);
2238 return open(p, O_CREAT|O_EXCL|O_RDWR, 0600);
2242 /*****************************************************************
2243 malloc that aborts with smb_panic on fail or zero size.
2244 *****************************************************************/
2246 void *smb_xmalloc_array(size_t size, unsigned int count)
2250 smb_panic("smb_xmalloc_array: called with zero size");
2252 if (count >= MAX_ALLOC_SIZE/size) {
2253 smb_panic("smb_xmalloc_array: alloc size too large");
2255 if ((p = SMB_MALLOC(size*count)) == NULL) {
2256 DEBUG(0, ("smb_xmalloc_array failed to allocate %lu * %lu bytes\n",
2257 (unsigned long)size, (unsigned long)count));
2258 smb_panic("smb_xmalloc_array: malloc failed");
2264 Memdup with smb_panic on fail.
2267 void *smb_xmemdup(const void *p, size_t size)
2270 p2 = SMB_XMALLOC_ARRAY(unsigned char,size);
2271 memcpy(p2, p, size);
2276 strdup that aborts on malloc fail.
2279 char *smb_xstrdup(const char *s)
2281 #if defined(PARANOID_MALLOC_CHECKER)
2288 #define strdup rep_strdup
2291 char *s1 = strdup(s);
2292 #if defined(PARANOID_MALLOC_CHECKER)
2296 #define strdup(s) __ERROR_DONT_USE_STRDUP_DIRECTLY
2299 smb_panic("smb_xstrdup: malloc failed");
2306 strndup that aborts on malloc fail.
2309 char *smb_xstrndup(const char *s, size_t n)
2311 #if defined(PARANOID_MALLOC_CHECKER)
2317 #if (defined(BROKEN_STRNDUP) || !defined(HAVE_STRNDUP))
2319 #define strndup rep_strndup
2322 char *s1 = strndup(s, n);
2323 #if defined(PARANOID_MALLOC_CHECKER)
2327 #define strndup(s,n) __ERROR_DONT_USE_STRNDUP_DIRECTLY
2330 smb_panic("smb_xstrndup: malloc failed");
2336 vasprintf that aborts on malloc fail
2339 int smb_xvasprintf(char **ptr, const char *format, va_list ap)
2346 n = vasprintf(ptr, format, ap2);
2347 if (n == -1 || ! *ptr) {
2348 smb_panic("smb_xvasprintf: out of memory");
2353 /*****************************************************************
2354 Like strdup but for memory.
2355 *****************************************************************/
2357 void *memdup(const void *p, size_t size)
2362 p2 = SMB_MALLOC(size);
2365 memcpy(p2, p, size);
2369 /*****************************************************************
2370 Get local hostname and cache result.
2371 *****************************************************************/
2373 char *myhostname(void)
2377 /* This is cached forever so
2378 * use NULL talloc ctx. */
2379 ret = get_myname(NULL);
2384 /*****************************************************************
2385 A useful function for returning a path in the Samba pid directory.
2386 *****************************************************************/
2388 static char *xx_path(const char *name, const char *rootpath)
2392 fname = talloc_strdup(talloc_tos(), rootpath);
2396 trim_string(fname,"","/");
2398 if (!directory_exist(fname,NULL)) {
2402 return talloc_asprintf(talloc_tos(),
2408 /*****************************************************************
2409 A useful function for returning a path in the Samba lock directory.
2410 *****************************************************************/
2412 char *lock_path(const char *name)
2414 return xx_path(name, lp_lockdir());
2417 /*****************************************************************
2418 A useful function for returning a path in the Samba pid directory.
2419 *****************************************************************/
2421 char *pid_path(const char *name)
2423 return xx_path(name, lp_piddir());
2427 * @brief Returns an absolute path to a file in the Samba lib directory.
2429 * @param name File to find, relative to LIBDIR.
2431 * @retval Pointer to a static #pstring containing the full path.
2434 char *lib_path(const char *name)
2436 return talloc_asprintf(talloc_tos(), "%s/%s", dyn_LIBDIR, name);
2440 * @brief Returns an absolute path to a file in the Samba data directory.
2442 * @param name File to find, relative to CODEPAGEDIR.
2444 * @retval Pointer to a talloc'ed string containing the full path.
2447 char *data_path(const char *name)
2449 return talloc_asprintf(talloc_tos(), "%s/%s", dyn_CODEPAGEDIR, name);
2452 /*****************************************************************
2453 a useful function for returning a path in the Samba state directory
2454 *****************************************************************/
2456 char *state_path(const char *name)
2458 return xx_path(name, dyn_STATEDIR());
2462 * @brief Returns the platform specific shared library extension.
2464 * @retval Pointer to a static #fstring containing the extension.
2467 const char *shlib_ext(void)
2469 return dyn_SHLIBEXT;
2472 /*******************************************************************
2473 Given a filename - get its directory name
2474 NB: Returned in static storage. Caveats:
2475 o If caller wishes to preserve, they should copy.
2476 ********************************************************************/
2478 char *parent_dirname(const char *path)
2482 if (!parent_dirname_talloc(talloc_tos(), path, &parent, NULL)) {
2489 bool parent_dirname_talloc(TALLOC_CTX *mem_ctx, const char *dir,
2490 char **parent, const char **name)
2495 p = strrchr_m(dir, '/'); /* Find final '/', if any */
2498 if (!(*parent = talloc_strdup(mem_ctx, "."))) {
2509 if (!(*parent = TALLOC_ARRAY(mem_ctx, char, len+1))) {
2512 memcpy(*parent, dir, len);
2513 (*parent)[len] = '\0';
2521 /*******************************************************************
2522 Determine if a pattern contains any Microsoft wildcard characters.
2523 *******************************************************************/
2525 bool ms_has_wild(const char *s)
2529 if (lp_posix_pathnames()) {
2530 /* With posix pathnames no characters are wild. */
2534 while ((c = *s++)) {
2547 bool ms_has_wild_w(const smb_ucs2_t *s)
2550 if (!s) return False;
2551 while ((c = *s++)) {
2553 case UCS2_CHAR('*'):
2554 case UCS2_CHAR('?'):
2555 case UCS2_CHAR('<'):
2556 case UCS2_CHAR('>'):
2557 case UCS2_CHAR('"'):
2564 /*******************************************************************
2565 A wrapper that handles case sensitivity and the special handling
2567 *******************************************************************/
2569 bool mask_match(const char *string, const char *pattern, bool is_case_sensitive)
2571 if (strcmp(string,"..") == 0)
2573 if (strcmp(pattern,".") == 0)
2576 return ms_fnmatch(pattern, string, Protocol <= PROTOCOL_LANMAN2, is_case_sensitive) == 0;
2579 /*******************************************************************
2580 A wrapper that handles case sensitivity and the special handling
2581 of the ".." name. Varient that is only called by old search code which requires
2582 pattern translation.
2583 *******************************************************************/
2585 bool mask_match_search(const char *string, const char *pattern, bool is_case_sensitive)
2587 if (strcmp(string,"..") == 0)
2589 if (strcmp(pattern,".") == 0)
2592 return ms_fnmatch(pattern, string, True, is_case_sensitive) == 0;
2595 /*******************************************************************
2596 A wrapper that handles a list of patters and calls mask_match()
2597 on each. Returns True if any of the patterns match.
2598 *******************************************************************/
2600 bool mask_match_list(const char *string, char **list, int listLen, bool is_case_sensitive)
2602 while (listLen-- > 0) {
2603 if (mask_match(string, *list++, is_case_sensitive))
2609 /*********************************************************
2610 Recursive routine that is called by unix_wild_match.
2611 *********************************************************/
2613 static bool unix_do_match(const char *regexp, const char *str)
2617 for( p = regexp; *p && *str; ) {
2628 * Look for a character matching
2629 * the one after the '*'.
2633 return true; /* Automatic match */
2636 while(*str && (*p != *str))
2640 * Patch from weidel@multichart.de. In the case of the regexp
2641 * '*XX*' we want to ensure there are at least 2 'X' characters
2642 * in the string after the '*' for a match to be made.
2649 * Eat all the characters that match, but count how many there were.
2652 while(*str && (*p == *str)) {
2658 * Now check that if the regexp had n identical characters that
2659 * matchcount had at least that many matches.
2662 while ( *(p+1) && (*(p+1) == *p)) {
2667 if ( matchcount <= 0 )
2671 str--; /* We've eaten the match char after the '*' */
2673 if(unix_do_match(p, str))
2695 if (!*p && str[0] == '.' && str[1] == 0)
2698 if (!*str && *p == '?') {
2704 if(!*str && (*p == '*' && p[1] == '\0'))
2710 /*******************************************************************
2711 Simple case insensitive interface to a UNIX wildcard matcher.
2712 Returns True if match, False if not.
2713 *******************************************************************/
2715 bool unix_wild_match(const char *pattern, const char *string)
2717 TALLOC_CTX *ctx = talloc_stackframe();
2723 p2 = talloc_strdup(ctx,pattern);
2724 s2 = talloc_strdup(ctx,string);
2732 /* Remove any *? and ** from the pattern as they are meaningless */
2733 for(p = p2; *p; p++) {
2734 while( *p == '*' && (p[1] == '?' ||p[1] == '*')) {
2735 memmove(&p[1], &p[2], strlen(&p[2])+1);
2739 if (strequal(p2,"*")) {
2744 ret = unix_do_match(p2, s2);
2749 /**********************************************************************
2750 Converts a name to a fully qualified domain name.
2751 Returns true if lookup succeeded, false if not (then fqdn is set to name)
2752 Note we deliberately use gethostbyname here, not getaddrinfo as we want
2753 to examine the h_aliases and I don't know how to do that with getaddrinfo.
2754 ***********************************************************************/
2756 bool name_to_fqdn(fstring fqdn, const char *name)
2759 struct hostent *hp = gethostbyname(name);
2761 if (!hp || !hp->h_name || !*hp->h_name) {
2762 DEBUG(10,("name_to_fqdn: lookup for %s failed.\n", name));
2763 fstrcpy(fqdn, name);
2767 /* Find out if the fqdn is returned as an alias
2768 * to cope with /etc/hosts files where the first
2769 * name is not the fqdn but the short name */
2770 if (hp->h_aliases && (! strchr_m(hp->h_name, '.'))) {
2772 for (i = 0; hp->h_aliases[i]; i++) {
2773 if (strchr_m(hp->h_aliases[i], '.')) {
2774 full = hp->h_aliases[i];
2779 if (full && (StrCaseCmp(full, "localhost.localdomain") == 0)) {
2780 DEBUG(1, ("WARNING: your /etc/hosts file may be broken!\n"));
2781 DEBUGADD(1, (" Specifing the machine hostname for address 127.0.0.1 may lead\n"));
2782 DEBUGADD(1, (" to Kerberos authentication problems as localhost.localdomain\n"));
2783 DEBUGADD(1, (" may end up being used instead of the real machine FQDN.\n"));
2790 DEBUG(10,("name_to_fqdn: lookup for %s -> %s.\n", name, full));
2791 fstrcpy(fqdn, full);
2795 /**********************************************************************
2796 Extension to talloc_get_type: Abort on type mismatch
2797 ***********************************************************************/
2799 void *talloc_check_name_abort(const void *ptr, const char *name)
2803 result = talloc_check_name(ptr, name);
2807 DEBUG(0, ("Talloc type mismatch, expected %s, got %s\n",
2808 name, talloc_get_name(ptr)));
2809 smb_panic("talloc type mismatch");
2810 /* Keep the compiler happy */
2817 /*******************************************************************
2818 This routine is a trick to immediately catch errors when debugging
2819 with insure. A xterm with a gdb is popped up when insure catches
2820 a error. It is Linux specific.
2821 ********************************************************************/
2823 int _Insure_trap_error(int a1, int a2, int a3, int a4, int a5, int a6)
2828 /* you can get /usr/bin/backtrace from
2829 http://samba.org/ftp/unpacked/junkcode/backtrace */
2830 pstring cmd = "/usr/bin/backtrace %d";
2832 slprintf(pidstr, sizeof(pidstr)-1, "%d", sys_getpid());
2833 pstring_sub(cmd, "%d", pidstr);
2837 h = dlopen("/usr/local/parasoft/insure++lite/lib.linux2/libinsure.so", RTLD_LAZY);
2838 fn = dlsym(h, "_Insure_trap_error");
2840 if (!h || h == _Insure_trap_error) {
2841 h = dlopen("/usr/local/parasoft/lib.linux2/libinsure.so", RTLD_LAZY);
2842 fn = dlsym(h, "_Insure_trap_error");
2846 ret = fn(a1, a2, a3, a4, a5, a6);
2854 uint32 map_share_mode_to_deny_mode(uint32 share_access, uint32 private_options)
2856 switch (share_access & ~FILE_SHARE_DELETE) {
2857 case FILE_SHARE_NONE:
2859 case FILE_SHARE_READ:
2861 case FILE_SHARE_WRITE:
2863 case FILE_SHARE_READ|FILE_SHARE_WRITE:
2866 if (private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS) {
2868 } else if (private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_FCB) {
2875 pid_t procid_to_pid(const struct server_id *proc)
2880 static uint32 my_vnn = NONCLUSTER_VNN;
2882 void set_my_vnn(uint32 vnn)
2884 DEBUG(10, ("vnn pid %d = %u\n", (int)sys_getpid(), (unsigned int)vnn));
2888 uint32 get_my_vnn(void)
2893 struct server_id pid_to_procid(pid_t pid)
2895 struct server_id result;
2897 #ifdef CLUSTER_SUPPORT
2898 result.vnn = my_vnn;
2903 struct server_id procid_self(void)
2905 return pid_to_procid(sys_getpid());
2908 struct server_id server_id_self(void)
2910 return procid_self();
2913 bool procid_equal(const struct server_id *p1, const struct server_id *p2)
2915 if (p1->pid != p2->pid)
2917 #ifdef CLUSTER_SUPPORT
2918 if (p1->vnn != p2->vnn)
2924 bool cluster_id_equal(const struct server_id *id1,
2925 const struct server_id *id2)
2927 return procid_equal(id1, id2);
2930 bool procid_is_me(const struct server_id *pid)
2932 if (pid->pid != sys_getpid())
2934 #ifdef CLUSTER_SUPPORT
2935 if (pid->vnn != my_vnn)
2941 struct server_id interpret_pid(const char *pid_string)
2943 #ifdef CLUSTER_SUPPORT
2944 unsigned int vnn, pid;
2945 struct server_id result;
2946 if (sscanf(pid_string, "%u:%u", &vnn, &pid) == 2) {
2950 else if (sscanf(pid_string, "%u", &pid) == 1) {
2951 result.vnn = NONCLUSTER_VNN;
2955 result.vnn = NONCLUSTER_VNN;
2960 return pid_to_procid(atoi(pid_string));
2964 char *procid_str(TALLOC_CTX *mem_ctx, const struct server_id *pid)
2967 #ifdef CLUSTER_SUPPORT
2968 if (pid->vnn == NONCLUSTER_VNN) {
2969 fstr_sprintf(str, "%d", (int)pid->pid);
2972 fstr_sprintf(str, "%u:%d", (unsigned)pid->vnn, (int)pid->pid);
2975 fstr_sprintf(str, "%d", (int)pid->pid);
2977 return talloc_strdup(mem_ctx, str);
2980 char *procid_str_static(const struct server_id *pid)
2982 return procid_str(talloc_tos(), pid);
2985 bool procid_valid(const struct server_id *pid)
2987 return (pid->pid != -1);
2990 bool procid_is_local(const struct server_id *pid)
2992 #ifdef CLUSTER_SUPPORT
2993 return pid->vnn == my_vnn;
2999 int this_is_smp(void)
3001 #if defined(HAVE_SYSCONF)
3003 #if defined(SYSCONF_SC_NPROC_ONLN)
3004 return (sysconf(_SC_NPROC_ONLN) > 1) ? 1 : 0;
3005 #elif defined(SYSCONF_SC_NPROCESSORS_ONLN)
3006 return (sysconf(_SC_NPROCESSORS_ONLN) > 1) ? 1 : 0;
3016 /****************************************************************
3017 Check if an offset into a buffer is safe.
3018 If this returns True it's safe to indirect into the byte at
3020 ****************************************************************/
3022 bool is_offset_safe(const char *buf_base, size_t buf_len, char *ptr, size_t off)
3024 const char *end_base = buf_base + buf_len;
3025 char *end_ptr = ptr + off;
3027 if (!buf_base || !ptr) {
3031 if (end_base < buf_base || end_ptr < ptr) {
3032 return False; /* wrap. */
3035 if (end_ptr < end_base) {
3041 /****************************************************************
3042 Return a safe pointer into a buffer, or NULL.
3043 ****************************************************************/
3045 char *get_safe_ptr(const char *buf_base, size_t buf_len, char *ptr, size_t off)
3047 return is_offset_safe(buf_base, buf_len, ptr, off) ?
3051 /****************************************************************
3052 Return a safe pointer into a string within a buffer, or NULL.
3053 ****************************************************************/
3055 char *get_safe_str_ptr(const char *buf_base, size_t buf_len, char *ptr, size_t off)
3057 if (!is_offset_safe(buf_base, buf_len, ptr, off)) {
3060 /* Check if a valid string exists at this offset. */
3061 if (skip_string(buf_base,buf_len, ptr + off) == NULL) {
3067 /****************************************************************
3068 Return an SVAL at a pointer, or failval if beyond the end.
3069 ****************************************************************/
3071 int get_safe_SVAL(const char *buf_base, size_t buf_len, char *ptr, size_t off, int failval)
3074 * Note we use off+1 here, not off+2 as SVAL accesses ptr[0] and ptr[1],
3077 if (!is_offset_safe(buf_base, buf_len, ptr, off+1)) {
3080 return SVAL(ptr,off);
3083 /****************************************************************
3084 Return an IVAL at a pointer, or failval if beyond the end.
3085 ****************************************************************/
3087 int get_safe_IVAL(const char *buf_base, size_t buf_len, char *ptr, size_t off, int failval)
3090 * Note we use off+3 here, not off+4 as IVAL accesses
3091 * ptr[0] ptr[1] ptr[2] ptr[3] NOT ptr[4].
3093 if (!is_offset_safe(buf_base, buf_len, ptr, off+3)) {
3096 return IVAL(ptr,off);
3101 Disable these now we have checked all code paths and ensured
3102 NULL returns on zero request. JRA.
3104 /****************************************************************
3105 talloc wrapper functions that guarentee a null pointer return
3107 ****************************************************************/
3109 #ifndef MAX_TALLOC_SIZE
3110 #define MAX_TALLOC_SIZE 0x10000000
3114 * talloc and zero memory.
3115 * - returns NULL if size is zero.
3118 void *_talloc_zero_zeronull(const void *ctx, size_t size, const char *name)
3126 p = talloc_named_const(ctx, size, name);
3129 memset(p, '\0', size);
3136 * memdup with a talloc.
3137 * - returns NULL if size is zero.
3140 void *_talloc_memdup_zeronull(const void *t, const void *p, size_t size, const char *name)
3148 newp = talloc_named_const(t, size, name);
3150 memcpy(newp, p, size);
3157 * alloc an array, checking for integer overflow in the array size.
3158 * - returns NULL if count or el_size are zero.
3161 void *_talloc_array_zeronull(const void *ctx, size_t el_size, unsigned count, const char *name)
3163 if (count >= MAX_TALLOC_SIZE/el_size) {
3167 if (el_size == 0 || count == 0) {
3171 return talloc_named_const(ctx, el_size * count, name);
3175 * alloc an zero array, checking for integer overflow in the array size
3176 * - returns NULL if count or el_size are zero.
3179 void *_talloc_zero_array_zeronull(const void *ctx, size_t el_size, unsigned count, const char *name)
3181 if (count >= MAX_TALLOC_SIZE/el_size) {
3185 if (el_size == 0 || count == 0) {
3189 return _talloc_zero(ctx, el_size * count, name);
3193 * Talloc wrapper that returns NULL if size == 0.
3195 void *talloc_zeronull(const void *context, size_t size, const char *name)
3200 return talloc_named_const(context, size, name);