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 2 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, write to the Free Software
22 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27 extern fstring local_machine;
28 extern char *global_clobber_region_function;
29 extern unsigned int global_clobber_region_line;
30 extern fstring remote_arch;
32 /* Max allowable allococation - 256mb - 0x10000000 */
33 #define MAX_ALLOC_SIZE (1024*1024*256)
35 #if (defined(HAVE_NETGROUP) && defined (WITH_AUTOMOUNT))
36 #ifdef WITH_NISPLUS_HOME
37 #ifdef BROKEN_NISPLUS_INCLUDE_FILES
39 * The following lines are needed due to buggy include files
40 * in Solaris 2.6 which define GROUP in both /usr/include/sys/acl.h and
41 * also in /usr/include/rpcsvc/nis.h. The definitions conflict. JRA.
42 * Also GROUP_OBJ is defined as 0x4 in /usr/include/sys/acl.h and as
43 * an enum in /usr/include/rpcsvc/nis.h.
50 #if defined(GROUP_OBJ)
54 #endif /* BROKEN_NISPLUS_INCLUDE_FILES */
56 #include <rpcsvc/nis.h>
58 #endif /* WITH_NISPLUS_HOME */
59 #endif /* HAVE_NETGROUP && WITH_AUTOMOUNT */
61 enum protocol_types Protocol = PROTOCOL_COREPLUS;
63 /* a default finfo structure to ensure all fields are sensible */
66 /* this is used by the chaining code */
71 static enum remote_arch_types ra_type = RA_UNKNOWN;
72 pstring user_socket_options=DEFAULT_SOCKET_OPTIONS;
74 /***********************************************************************
75 Definitions for all names.
76 ***********************************************************************/
78 static char *smb_myname;
79 static char *smb_myworkgroup;
80 static char *smb_scope;
81 static int smb_num_netbios_names;
82 static char **smb_my_netbios_names;
84 /***********************************************************************
85 Allocate and set myname. Ensure upper case.
86 ***********************************************************************/
88 BOOL set_global_myname(const char *myname)
90 SAFE_FREE(smb_myname);
91 smb_myname = SMB_STRDUP(myname);
94 strupper_m(smb_myname);
98 const char *global_myname(void)
103 /***********************************************************************
104 Allocate and set myworkgroup. Ensure upper case.
105 ***********************************************************************/
107 BOOL set_global_myworkgroup(const char *myworkgroup)
109 SAFE_FREE(smb_myworkgroup);
110 smb_myworkgroup = SMB_STRDUP(myworkgroup);
111 if (!smb_myworkgroup)
113 strupper_m(smb_myworkgroup);
117 const char *lp_workgroup(void)
119 return smb_myworkgroup;
122 /***********************************************************************
123 Allocate and set scope. Ensure upper case.
124 ***********************************************************************/
126 BOOL set_global_scope(const char *scope)
128 SAFE_FREE(smb_scope);
129 smb_scope = SMB_STRDUP(scope);
132 strupper_m(smb_scope);
136 /*********************************************************************
137 Ensure scope is never null string.
138 *********************************************************************/
140 const char *global_scope(void)
143 set_global_scope("");
147 static void free_netbios_names_array(void)
151 for (i = 0; i < smb_num_netbios_names; i++)
152 SAFE_FREE(smb_my_netbios_names[i]);
154 SAFE_FREE(smb_my_netbios_names);
155 smb_num_netbios_names = 0;
158 static BOOL allocate_my_netbios_names_array(size_t number)
160 free_netbios_names_array();
162 smb_num_netbios_names = number + 1;
163 smb_my_netbios_names = SMB_MALLOC_ARRAY( char *, smb_num_netbios_names );
165 if (!smb_my_netbios_names)
168 memset(smb_my_netbios_names, '\0', sizeof(char *) * smb_num_netbios_names);
172 static BOOL set_my_netbios_names(const char *name, int i)
174 SAFE_FREE(smb_my_netbios_names[i]);
176 smb_my_netbios_names[i] = SMB_STRDUP(name);
177 if (!smb_my_netbios_names[i])
179 strupper_m(smb_my_netbios_names[i]);
183 /***********************************************************************
184 Free memory allocated to global objects
185 ***********************************************************************/
187 void gfree_names(void)
189 SAFE_FREE( smb_myname );
190 SAFE_FREE( smb_myworkgroup );
191 SAFE_FREE( smb_scope );
192 free_netbios_names_array();
195 void gfree_all( void )
204 /* release the talloc null_context memory last */
205 talloc_disable_null_tracking();
208 const char *my_netbios_names(int i)
210 return smb_my_netbios_names[i];
213 BOOL set_netbios_aliases(const char **str_array)
217 /* Work out the max number of netbios aliases that we have */
218 for( namecount=0; str_array && (str_array[namecount] != NULL); namecount++ )
221 if ( global_myname() && *global_myname())
224 /* Allocate space for the netbios aliases */
225 if (!allocate_my_netbios_names_array(namecount))
228 /* Use the global_myname string first */
230 if ( global_myname() && *global_myname()) {
231 set_my_netbios_names( global_myname(), namecount );
237 for ( i = 0; str_array[i] != NULL; i++) {
239 BOOL duplicate = False;
241 /* Look for duplicates */
242 for( n=0; n<namecount; n++ ) {
243 if( strequal( str_array[i], my_netbios_names(n) ) ) {
249 if (!set_my_netbios_names(str_array[i], namecount))
258 /****************************************************************************
259 Common name initialization code.
260 ****************************************************************************/
262 BOOL init_names(void)
267 if (global_myname() == NULL || *global_myname() == '\0') {
268 if (!set_global_myname(myhostname())) {
269 DEBUG( 0, ( "init_structs: malloc fail.\n" ) );
274 if (!set_netbios_aliases(lp_netbios_aliases())) {
275 DEBUG( 0, ( "init_structs: malloc fail.\n" ) );
279 fstrcpy( local_machine, global_myname() );
280 trim_char( local_machine, ' ', ' ' );
281 p = strchr( local_machine, ' ' );
284 strlower_m( local_machine );
286 DEBUG( 5, ("Netbios name list:-\n") );
287 for( n=0; my_netbios_names(n); n++ )
288 DEBUGADD( 5, ( "my_netbios_names[%d]=\"%s\"\n", n, my_netbios_names(n) ) );
293 /**************************************************************************n
294 Find a suitable temporary directory. The result should be copied immediately
295 as it may be overwritten by a subsequent call.
296 ****************************************************************************/
298 const char *tmpdir(void)
301 if ((p = getenv("TMPDIR")))
306 /****************************************************************************
307 Add a gid to an array of gids if it's not already there.
308 ****************************************************************************/
310 BOOL add_gid_to_array_unique(TALLOC_CTX *mem_ctx, gid_t gid,
311 gid_t **gids, size_t *num_gids)
315 if ((*num_gids != 0) && (*gids == NULL)) {
317 * A former call to this routine has failed to allocate memory
322 for (i=0; i<*num_gids; i++) {
323 if ((*gids)[i] == gid) {
328 *gids = TALLOC_REALLOC_ARRAY(mem_ctx, *gids, gid_t, *num_gids+1);
334 (*gids)[*num_gids] = gid;
339 /****************************************************************************
340 Like atoi but gets the value up to the separator character.
341 ****************************************************************************/
343 static const char *Atoic(const char *p, int *n, const char *c)
345 if (!isdigit((int)*p)) {
346 DEBUG(5, ("Atoic: malformed number\n"));
352 while ((*p) && isdigit((int)*p))
355 if (strchr_m(c, *p) == NULL) {
356 DEBUG(5, ("Atoic: no separator characters (%s) not found\n", c));
363 /*************************************************************************
364 Reads a list of numbers.
365 *************************************************************************/
367 const char *get_numlist(const char *p, uint32 **num, int *count)
371 if (num == NULL || count == NULL)
377 while ((p = Atoic(p, &val, ":,")) != NULL && (*p) != ':') {
378 *num = SMB_REALLOC_ARRAY((*num), uint32, (*count)+1);
382 (*num)[(*count)] = val;
390 /*******************************************************************
391 Check if a file exists - call vfs_file_exist for samba files.
392 ********************************************************************/
394 BOOL file_exist(const char *fname,SMB_STRUCT_STAT *sbuf)
400 if (sys_stat(fname,sbuf) != 0)
403 return((S_ISREG(sbuf->st_mode)) || (S_ISFIFO(sbuf->st_mode)));
406 /*******************************************************************
407 Check a files mod time.
408 ********************************************************************/
410 time_t file_modtime(const char *fname)
414 if (sys_stat(fname,&st) != 0)
420 /*******************************************************************
421 Check if a directory exists.
422 ********************************************************************/
424 BOOL directory_exist(char *dname,SMB_STRUCT_STAT *st)
432 if (sys_stat(dname,st) != 0)
435 ret = S_ISDIR(st->st_mode);
441 /*******************************************************************
442 Returns the size in bytes of the named file.
443 ********************************************************************/
445 SMB_OFF_T get_file_size(char *file_name)
449 if(sys_stat(file_name,&buf) != 0)
450 return (SMB_OFF_T)-1;
454 /*******************************************************************
455 Return a string representing an attribute for a file.
456 ********************************************************************/
458 char *attrib_string(uint16 mode)
460 static fstring attrstr;
464 if (mode & aVOLID) fstrcat(attrstr,"V");
465 if (mode & aDIR) fstrcat(attrstr,"D");
466 if (mode & aARCH) fstrcat(attrstr,"A");
467 if (mode & aHIDDEN) fstrcat(attrstr,"H");
468 if (mode & aSYSTEM) fstrcat(attrstr,"S");
469 if (mode & aRONLY) fstrcat(attrstr,"R");
474 /*******************************************************************
475 Show a smb message structure.
476 ********************************************************************/
478 void show_msg(char *buf)
486 DEBUG(5,("size=%d\nsmb_com=0x%x\nsmb_rcls=%d\nsmb_reh=%d\nsmb_err=%d\nsmb_flg=%d\nsmb_flg2=%d\n",
488 (int)CVAL(buf,smb_com),
489 (int)CVAL(buf,smb_rcls),
490 (int)CVAL(buf,smb_reh),
491 (int)SVAL(buf,smb_err),
492 (int)CVAL(buf,smb_flg),
493 (int)SVAL(buf,smb_flg2)));
494 DEBUGADD(5,("smb_tid=%d\nsmb_pid=%d\nsmb_uid=%d\nsmb_mid=%d\n",
495 (int)SVAL(buf,smb_tid),
496 (int)SVAL(buf,smb_pid),
497 (int)SVAL(buf,smb_uid),
498 (int)SVAL(buf,smb_mid)));
499 DEBUGADD(5,("smt_wct=%d\n",(int)CVAL(buf,smb_wct)));
501 for (i=0;i<(int)CVAL(buf,smb_wct);i++)
502 DEBUGADD(5,("smb_vwv[%2d]=%5d (0x%X)\n",i,
503 SVAL(buf,smb_vwv+2*i),SVAL(buf,smb_vwv+2*i)));
505 bcc = (int)SVAL(buf,smb_vwv+2*(CVAL(buf,smb_wct)));
507 DEBUGADD(5,("smb_bcc=%d\n",bcc));
515 dump_data(10, (uint8 *)smb_buf(buf), bcc);
518 /*******************************************************************
519 Set the length and marker of an encrypted smb packet.
520 ********************************************************************/
522 void smb_set_enclen(char *buf,int len,uint16 enc_ctx_num)
524 _smb_setlen(buf,len);
528 SSVAL(buf,6,enc_ctx_num);
531 /*******************************************************************
532 Set the length and marker of an smb packet.
533 ********************************************************************/
535 void smb_setlen(const char *frombuf, char *buf, int len)
537 _smb_setlen(buf,len);
540 if (buf != frombuf) {
541 memcpy(buf+4, frombuf+4, 4);
551 /*******************************************************************
552 Setup the word count and byte count for a smb message.
553 ********************************************************************/
555 int set_message(const char *frombuf, char *buf,int num_words,int num_bytes,BOOL zero)
557 if (zero && (num_words || num_bytes)) {
558 memset(buf + smb_size,'\0',num_words*2 + num_bytes);
560 SCVAL(buf,smb_wct,num_words);
561 SSVAL(buf,smb_vwv + num_words*SIZEOFWORD,num_bytes);
562 smb_setlen(frombuf, buf,smb_size + num_words*2 + num_bytes - 4);
563 return (smb_size + num_words*2 + num_bytes);
566 /*******************************************************************
567 Setup only the byte count for a smb message.
568 ********************************************************************/
570 int set_message_bcc(const char *frombuf, char *buf,int num_bytes)
572 int num_words = CVAL(buf,smb_wct);
573 SSVAL(buf,smb_vwv + num_words*SIZEOFWORD,num_bytes);
574 smb_setlen(frombuf, buf,smb_size + num_words*2 + num_bytes - 4);
575 return (smb_size + num_words*2 + num_bytes);
578 /*******************************************************************
579 Setup only the byte count for a smb message, using the end of the
581 ********************************************************************/
583 int set_message_end(const char *frombuf, void *outbuf,void *end_ptr)
585 return set_message_bcc(frombuf,
587 PTR_DIFF(end_ptr,smb_buf((char *)outbuf)));
590 /*******************************************************************
591 Reduce a file name, removing .. elements.
592 ********************************************************************/
594 void dos_clean_name(char *s)
598 DEBUG(3,("dos_clean_name [%s]\n",s));
600 /* remove any double slashes */
601 all_string_sub(s, "\\\\", "\\", 0);
603 /* Remove leading .\\ characters */
604 if(strncmp(s, ".\\", 2) == 0) {
605 trim_string(s, ".\\", NULL);
610 while ((p = strstr_m(s,"\\..\\")) != NULL) {
616 if ((p=strrchr_m(s,'\\')) != NULL)
623 trim_string(s,NULL,"\\..");
624 all_string_sub(s, "\\.\\", "\\", 0);
627 /*******************************************************************
628 Reduce a file name, removing .. elements.
629 ********************************************************************/
631 void unix_clean_name(char *s)
635 DEBUG(3,("unix_clean_name [%s]\n",s));
637 /* remove any double slashes */
638 all_string_sub(s, "//","/", 0);
640 /* Remove leading ./ characters */
641 if(strncmp(s, "./", 2) == 0) {
642 trim_string(s, "./", NULL);
647 while ((p = strstr_m(s,"/../")) != NULL) {
653 if ((p=strrchr_m(s,'/')) != NULL)
660 trim_string(s,NULL,"/..");
661 all_string_sub(s, "/./", "/", 0);
664 void clean_name(char *s)
670 /*******************************************************************
671 Close the low 3 fd's and open dev/null in their place.
672 ********************************************************************/
674 void close_low_fds(BOOL stderr_too)
686 /* try and use up these file descriptors, so silly
687 library routines writing to stdout etc won't cause havoc */
689 if (i == 2 && !stderr_too)
692 fd = sys_open("/dev/null",O_RDWR,0);
694 fd = sys_open("/dev/null",O_WRONLY,0);
696 DEBUG(0,("Can't open /dev/null\n"));
700 DEBUG(0,("Didn't get file descriptor %d\n",i));
707 /*******************************************************************
708 Write data into an fd at a given offset. Ignore seek errors.
709 ********************************************************************/
711 ssize_t write_data_at_offset(int fd, const char *buffer, size_t N, SMB_OFF_T pos)
716 if (pos == (SMB_OFF_T)-1) {
717 return write_data(fd, buffer, N);
719 #if defined(HAVE_PWRITE) || defined(HAVE_PRWITE64)
721 ret = sys_pwrite(fd,buffer + total,N - total, pos);
722 if (ret == -1 && errno == ESPIPE) {
723 return write_data(fd, buffer + total,N - total);
726 DEBUG(0,("write_data_at_offset: write failure. Error = %s\n", strerror(errno) ));
735 return (ssize_t)total;
737 /* Use lseek and write_data. */
738 if (sys_lseek(fd, pos, SEEK_SET) == -1) {
739 if (errno != ESPIPE) {
743 return write_data(fd, buffer, N);
747 /****************************************************************************
748 Set a fd into blocking/nonblocking mode. Uses POSIX O_NONBLOCK if available,
752 ****************************************************************************/
754 int set_blocking(int fd, BOOL set)
758 #define FLAG_TO_SET O_NONBLOCK
761 #define FLAG_TO_SET O_NDELAY
763 #define FLAG_TO_SET FNDELAY
767 if((val = sys_fcntl_long(fd, F_GETFL, 0)) == -1)
769 if(set) /* Turn blocking on - ie. clear nonblock flag */
773 return sys_fcntl_long( fd, F_SETFL, val);
777 /****************************************************************************
778 Transfer some data between two fd's.
779 ****************************************************************************/
781 #ifndef TRANSFER_BUF_SIZE
782 #define TRANSFER_BUF_SIZE 65536
785 ssize_t transfer_file_internal(int infd, int outfd, size_t n, ssize_t (*read_fn)(int, void *, size_t),
786 ssize_t (*write_fn)(int, const void *, size_t))
792 size_t num_to_read_thistime;
793 size_t num_written = 0;
795 if ((buf = SMB_MALLOC_ARRAY(char, TRANSFER_BUF_SIZE)) == NULL)
799 num_to_read_thistime = MIN((n - total), TRANSFER_BUF_SIZE);
801 read_ret = (*read_fn)(infd, buf, num_to_read_thistime);
802 if (read_ret == -1) {
803 DEBUG(0,("transfer_file_internal: read failure. Error = %s\n", strerror(errno) ));
812 while (num_written < read_ret) {
813 write_ret = (*write_fn)(outfd,buf + num_written, read_ret - num_written);
815 if (write_ret == -1) {
816 DEBUG(0,("transfer_file_internal: write failure. Error = %s\n", strerror(errno) ));
821 return (ssize_t)total;
823 num_written += (size_t)write_ret;
826 total += (size_t)read_ret;
830 return (ssize_t)total;
833 SMB_OFF_T transfer_file(int infd,int outfd,SMB_OFF_T n)
835 return (SMB_OFF_T)transfer_file_internal(infd, outfd, (size_t)n, sys_read, sys_write);
838 /*******************************************************************
839 Sleep for a specified number of milliseconds.
840 ********************************************************************/
842 void smb_msleep(unsigned int t)
844 #if defined(HAVE_NANOSLEEP)
845 struct timespec tval;
848 tval.tv_sec = t/1000;
849 tval.tv_nsec = 1000000*(t%1000);
853 ret = nanosleep(&tval, &tval);
854 } while (ret < 0 && errno == EINTR && (tval.tv_sec > 0 || tval.tv_nsec > 0));
856 unsigned int tdiff=0;
857 struct timeval tval,t1,t2;
864 tval.tv_sec = (t-tdiff)/1000;
865 tval.tv_usec = 1000*((t-tdiff)%1000);
867 /* Never wait for more than 1 sec. */
868 if (tval.tv_sec > 1) {
875 sys_select_intr(0,&fds,NULL,NULL,&tval);
878 if (t2.tv_sec < t1.tv_sec) {
879 /* Someone adjusted time... */
883 tdiff = TvalDiff(&t1,&t2);
888 /****************************************************************************
889 Become a daemon, discarding the controlling terminal.
890 ****************************************************************************/
892 void become_daemon(BOOL Fork, BOOL no_process_group)
900 /* detach from the terminal */
902 if (!no_process_group) setsid();
903 #elif defined(TIOCNOTTY)
904 if (!no_process_group) {
905 int i = sys_open("/dev/tty", O_RDWR, 0);
907 ioctl(i, (int) TIOCNOTTY, (char *)0);
911 #endif /* HAVE_SETSID */
913 /* Close fd's 0,1,2. Needed if started by rsh */
914 close_low_fds(False); /* Don't close stderr, let the debug system
915 attach it to the logfile */
918 /****************************************************************************
919 Put up a yes/no prompt.
920 ****************************************************************************/
927 if (!fgets(ans,sizeof(ans)-1,stdin))
930 if (*ans == 'y' || *ans == 'Y')
936 #if defined(PARANOID_MALLOC_CHECKER)
938 /****************************************************************************
939 Internal malloc wrapper. Externally visible.
940 ****************************************************************************/
942 void *malloc_(size_t size)
949 #define malloc(s) __ERROR_DONT_USE_MALLOC_DIRECTLY
952 /****************************************************************************
953 Internal calloc wrapper. Not externally visible.
954 ****************************************************************************/
956 static void *calloc_(size_t count, size_t size)
958 if (size == 0 || count == 0) {
962 return calloc(count, size);
963 #define calloc(n,s) __ERROR_DONT_USE_CALLOC_DIRECTLY
966 /****************************************************************************
967 Internal realloc wrapper. Not externally visible.
968 ****************************************************************************/
970 static void *realloc_(void *ptr, size_t size)
973 return realloc(ptr, size);
974 #define realloc(p,s) __ERROR_DONT_USE_RELLOC_DIRECTLY
977 #endif /* PARANOID_MALLOC_CHECKER */
979 /****************************************************************************
981 ****************************************************************************/
983 void *malloc_array(size_t el_size, unsigned int count)
985 if (count >= MAX_ALLOC_SIZE/el_size) {
989 if (el_size == 0 || count == 0) {
992 #if defined(PARANOID_MALLOC_CHECKER)
993 return malloc_(el_size*count);
995 return malloc(el_size*count);
999 /****************************************************************************
1001 ****************************************************************************/
1003 void *memalign_array(size_t el_size, size_t align, unsigned int count)
1005 if (count >= MAX_ALLOC_SIZE/el_size) {
1009 return sys_memalign(align, el_size*count);
1012 /****************************************************************************
1014 ****************************************************************************/
1016 void *calloc_array(size_t size, size_t nmemb)
1018 if (nmemb >= MAX_ALLOC_SIZE/size) {
1021 if (size == 0 || nmemb == 0) {
1024 #if defined(PARANOID_MALLOC_CHECKER)
1025 return calloc_(nmemb, size);
1027 return calloc(nmemb, size);
1031 /****************************************************************************
1032 Expand a pointer to be a particular size.
1033 Note that this version of Realloc has an extra parameter that decides
1034 whether to free the passed in storage on allocation failure or if the
1037 This is designed for use in the typical idiom of :
1039 p = SMB_REALLOC(p, size)
1044 and not to have to keep track of the old 'p' contents to free later, nor
1045 to worry if the size parameter was zero. In the case where NULL is returned
1046 we guarentee that p has been freed.
1048 If free later semantics are desired, then pass 'free_old_on_error' as False which
1049 guarentees that the old contents are not freed on error, even if size == 0. To use
1052 tmp = SMB_REALLOC_KEEP_OLD_ON_ERROR(p, size);
1060 Changes were instigated by Coverity error checking. JRA.
1061 ****************************************************************************/
1063 void *Realloc(void *p, size_t size, BOOL free_old_on_error)
1068 if (free_old_on_error) {
1071 DEBUG(2,("Realloc asked for 0 bytes\n"));
1075 #if defined(PARANOID_MALLOC_CHECKER)
1077 ret = (void *)malloc_(size);
1079 ret = (void *)realloc_(p,size);
1083 ret = (void *)malloc(size);
1085 ret = (void *)realloc(p,size);
1090 if (free_old_on_error && p) {
1093 DEBUG(0,("Memory allocation error: failed to expand to %d bytes\n",(int)size));
1099 /****************************************************************************
1101 ****************************************************************************/
1103 void *realloc_array(void *p, size_t el_size, unsigned int count, BOOL free_old_on_error)
1105 if (count >= MAX_ALLOC_SIZE/el_size) {
1106 if (free_old_on_error) {
1111 return Realloc(p, el_size*count, free_old_on_error);
1114 /****************************************************************************
1115 (Hopefully) efficient array append.
1116 ****************************************************************************/
1118 void add_to_large_array(TALLOC_CTX *mem_ctx, size_t element_size,
1119 void *element, void *_array, uint32 *num_elements,
1120 ssize_t *array_size)
1122 void **array = (void **)_array;
1124 if (*array_size < 0) {
1128 if (*array == NULL) {
1129 if (*array_size == 0) {
1133 if (*array_size >= MAX_ALLOC_SIZE/element_size) {
1137 *array = TALLOC(mem_ctx, element_size * (*array_size));
1138 if (*array == NULL) {
1143 if (*num_elements == *array_size) {
1146 if (*array_size >= MAX_ALLOC_SIZE/element_size) {
1150 *array = TALLOC_REALLOC(mem_ctx, *array,
1151 element_size * (*array_size));
1153 if (*array == NULL) {
1158 memcpy((char *)(*array) + element_size*(*num_elements),
1159 element, element_size);
1169 /****************************************************************************
1170 Free memory, checks for NULL.
1171 Use directly SAFE_FREE()
1172 Exists only because we need to pass a function pointer somewhere --SSS
1173 ****************************************************************************/
1175 void safe_free(void *p)
1180 /****************************************************************************
1181 Get my own name and IP.
1182 ****************************************************************************/
1184 BOOL get_myname(char *my_name)
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';
1200 /* split off any parts after an initial . */
1201 char *p = strchr_m(hostname,'.');
1206 fstrcpy(my_name,hostname);
1212 /****************************************************************************
1213 Get my own canonical name, including domain.
1214 ****************************************************************************/
1216 BOOL get_mydnsfullname(fstring my_dnsname)
1218 static fstring dnshostname;
1221 if (!*dnshostname) {
1222 /* get my host name */
1223 if (gethostname(dnshostname, sizeof(dnshostname)) == -1) {
1224 *dnshostname = '\0';
1225 DEBUG(0,("gethostname failed\n"));
1229 /* Ensure null termination. */
1230 dnshostname[sizeof(dnshostname)-1] = '\0';
1232 /* Ensure we get the cannonical name. */
1233 if (!(hp = sys_gethostbyname(dnshostname))) {
1234 *dnshostname = '\0';
1237 fstrcpy(dnshostname, hp->h_name);
1239 fstrcpy(my_dnsname, dnshostname);
1243 /****************************************************************************
1244 Get my own domain name.
1245 ****************************************************************************/
1247 BOOL get_mydnsdomname(fstring my_domname)
1253 if (!get_mydnsfullname(domname)) {
1256 p = strchr_m(domname, '.');
1259 fstrcpy(my_domname, p);
1265 /****************************************************************************
1266 Interpret a protocol description string, with a default.
1267 ****************************************************************************/
1269 int interpret_protocol(const char *str,int def)
1271 if (strequal(str,"NT1"))
1272 return(PROTOCOL_NT1);
1273 if (strequal(str,"LANMAN2"))
1274 return(PROTOCOL_LANMAN2);
1275 if (strequal(str,"LANMAN1"))
1276 return(PROTOCOL_LANMAN1);
1277 if (strequal(str,"CORE"))
1278 return(PROTOCOL_CORE);
1279 if (strequal(str,"COREPLUS"))
1280 return(PROTOCOL_COREPLUS);
1281 if (strequal(str,"CORE+"))
1282 return(PROTOCOL_COREPLUS);
1284 DEBUG(0,("Unrecognised protocol level %s\n",str));
1289 /****************************************************************************
1290 Return true if a string could be a pure IP address.
1291 ****************************************************************************/
1293 BOOL is_ipaddress(const char *str)
1295 BOOL pure_address = True;
1298 for (i=0; pure_address && str[i]; i++)
1299 if (!(isdigit((int)str[i]) || str[i] == '.'))
1300 pure_address = False;
1302 /* Check that a pure number is not misinterpreted as an IP */
1303 pure_address = pure_address && (strchr_m(str, '.') != NULL);
1305 return pure_address;
1308 /****************************************************************************
1309 Interpret an internet address or name into an IP address in 4 byte form.
1310 ****************************************************************************/
1312 uint32 interpret_addr(const char *str)
1317 if (strcmp(str,"0.0.0.0") == 0)
1319 if (strcmp(str,"255.255.255.255") == 0)
1322 /* if it's in the form of an IP address then get the lib to interpret it */
1323 if (is_ipaddress(str)) {
1324 res = inet_addr(str);
1326 /* otherwise assume it's a network name of some sort and use
1327 sys_gethostbyname */
1328 if ((hp = sys_gethostbyname(str)) == 0) {
1329 DEBUG(3,("sys_gethostbyname: Unknown host. %s\n",str));
1333 if(hp->h_addr == NULL) {
1334 DEBUG(3,("sys_gethostbyname: host address is invalid for host %s\n",str));
1337 putip((char *)&res,(char *)hp->h_addr);
1340 if (res == (uint32)-1)
1346 /*******************************************************************
1347 A convenient addition to interpret_addr().
1348 ******************************************************************/
1350 struct in_addr *interpret_addr2(const char *str)
1352 static struct in_addr ret;
1353 uint32 a = interpret_addr(str);
1358 /*******************************************************************
1359 Check if an IP is the 0.0.0.0.
1360 ******************************************************************/
1362 BOOL is_zero_ip(struct in_addr ip)
1365 putip((char *)&a,(char *)&ip);
1369 /*******************************************************************
1370 Set an IP to 0.0.0.0.
1371 ******************************************************************/
1373 void zero_ip(struct in_addr *ip)
1376 static struct in_addr ipzero;
1379 ipzero = *interpret_addr2("0.0.0.0");
1386 #if (defined(HAVE_NETGROUP) && defined(WITH_AUTOMOUNT))
1387 /******************************************************************
1388 Remove any mount options such as -rsize=2048,wsize=2048 etc.
1389 Based on a fix from <Thomas.Hepper@icem.de>.
1390 *******************************************************************/
1392 static void strip_mount_options( pstring *str)
1396 while(*p && !isspace(*p))
1398 while(*p && isspace(*p))
1403 pstrcpy(tmp_str, p);
1404 pstrcpy(*str, tmp_str);
1409 /*******************************************************************
1410 Patch from jkf@soton.ac.uk
1411 Split Luke's automount_server into YP lookup and string splitter
1412 so can easily implement automount_path().
1413 As we may end up doing both, cache the last YP result.
1414 *******************************************************************/
1416 #ifdef WITH_NISPLUS_HOME
1417 char *automount_lookup(const char *user_name)
1419 static fstring last_key = "";
1420 static pstring last_value = "";
1422 char *nis_map = (char *)lp_nis_home_map_name();
1424 char buffer[NIS_MAXATTRVAL + 1];
1429 if (strcmp(user_name, last_key)) {
1430 slprintf(buffer, sizeof(buffer)-1, "[key=%s],%s", user_name, nis_map);
1431 DEBUG(5, ("NIS+ querystring: %s\n", buffer));
1433 if (result = nis_list(buffer, FOLLOW_PATH|EXPAND_NAME|HARD_LOOKUP, NULL, NULL)) {
1434 if (result->status != NIS_SUCCESS) {
1435 DEBUG(3, ("NIS+ query failed: %s\n", nis_sperrno(result->status)));
1436 fstrcpy(last_key, ""); pstrcpy(last_value, "");
1438 object = result->objects.objects_val;
1439 if (object->zo_data.zo_type == ENTRY_OBJ) {
1440 entry = &object->zo_data.objdata_u.en_data;
1441 DEBUG(5, ("NIS+ entry type: %s\n", entry->en_type));
1442 DEBUG(3, ("NIS+ result: %s\n", entry->en_cols.en_cols_val[1].ec_value.ec_value_val));
1444 pstrcpy(last_value, entry->en_cols.en_cols_val[1].ec_value.ec_value_val);
1445 pstring_sub(last_value, "&", user_name);
1446 fstrcpy(last_key, user_name);
1450 nis_freeresult(result);
1453 strip_mount_options(&last_value);
1455 DEBUG(4, ("NIS+ Lookup: %s resulted in %s\n", user_name, last_value));
1458 #else /* WITH_NISPLUS_HOME */
1460 char *automount_lookup(const char *user_name)
1462 static fstring last_key = "";
1463 static pstring last_value = "";
1465 int nis_error; /* returned by yp all functions */
1466 char *nis_result; /* yp_match inits this */
1467 int nis_result_len; /* and set this */
1468 char *nis_domain; /* yp_get_default_domain inits this */
1469 char *nis_map = (char *)lp_nis_home_map_name();
1471 if ((nis_error = yp_get_default_domain(&nis_domain)) != 0) {
1472 DEBUG(3, ("YP Error: %s\n", yperr_string(nis_error)));
1476 DEBUG(5, ("NIS Domain: %s\n", nis_domain));
1478 if (!strcmp(user_name, last_key)) {
1479 nis_result = last_value;
1480 nis_result_len = strlen(last_value);
1483 if ((nis_error = yp_match(nis_domain, nis_map, user_name, strlen(user_name),
1484 &nis_result, &nis_result_len)) == 0) {
1485 fstrcpy(last_key, user_name);
1486 pstrcpy(last_value, nis_result);
1487 strip_mount_options(&last_value);
1489 } else if(nis_error == YPERR_KEY) {
1491 /* If Key lookup fails user home server is not in nis_map
1492 use default information for server, and home directory */
1494 DEBUG(3, ("YP Key not found: while looking up \"%s\" in map \"%s\"\n",
1495 user_name, nis_map));
1496 DEBUG(3, ("using defaults for server and home directory\n"));
1498 DEBUG(3, ("YP Error: \"%s\" while looking up \"%s\" in map \"%s\"\n",
1499 yperr_string(nis_error), user_name, nis_map));
1503 DEBUG(4, ("YP Lookup: %s resulted in %s\n", user_name, last_value));
1506 #endif /* WITH_NISPLUS_HOME */
1509 /*******************************************************************
1510 Are two IPs on the same subnet?
1511 ********************************************************************/
1513 BOOL same_net(struct in_addr ip1,struct in_addr ip2,struct in_addr mask)
1515 uint32 net1,net2,nmask;
1517 nmask = ntohl(mask.s_addr);
1518 net1 = ntohl(ip1.s_addr);
1519 net2 = ntohl(ip2.s_addr);
1521 return((net1 & nmask) == (net2 & nmask));
1525 /****************************************************************************
1526 Check if a process exists. Does this work on all unixes?
1527 ****************************************************************************/
1529 BOOL process_exists(const struct server_id pid)
1531 if (procid_is_me(&pid)) {
1535 if (!procid_is_local(&pid)) {
1536 /* This *SEVERELY* needs fixing. */
1540 /* Doing kill with a non-positive pid causes messages to be
1541 * sent to places we don't want. */
1542 SMB_ASSERT(pid.pid > 0);
1543 return(kill(pid.pid,0) == 0 || errno != ESRCH);
1546 BOOL process_exists_by_pid(pid_t pid)
1548 return process_exists(pid_to_procid(pid));
1551 /*******************************************************************
1552 Convert a uid into a user name.
1553 ********************************************************************/
1555 const char *uidtoname(uid_t uid)
1557 static fstring name;
1558 struct passwd *pass;
1560 pass = getpwuid_alloc(NULL, uid);
1562 fstrcpy(name, pass->pw_name);
1565 slprintf(name, sizeof(name) - 1, "%ld",(long int)uid);
1571 /*******************************************************************
1572 Convert a gid into a group name.
1573 ********************************************************************/
1575 char *gidtoname(gid_t gid)
1577 static fstring name;
1580 grp = getgrgid(gid);
1582 return(grp->gr_name);
1583 slprintf(name,sizeof(name) - 1, "%d",(int)gid);
1587 /*******************************************************************
1588 Convert a user name into a uid.
1589 ********************************************************************/
1591 uid_t nametouid(const char *name)
1593 struct passwd *pass;
1597 pass = getpwnam_alloc(NULL, name);
1604 u = (uid_t)strtol(name, &p, 0);
1605 if ((p != name) && (*p == '\0'))
1611 /*******************************************************************
1612 Convert a name to a gid_t if possible. Return -1 if not a group.
1613 ********************************************************************/
1615 gid_t nametogid(const char *name)
1621 g = (gid_t)strtol(name, &p, 0);
1622 if ((p != name) && (*p == '\0'))
1625 grp = sys_getgrnam(name);
1627 return(grp->gr_gid);
1631 /*******************************************************************
1632 Something really nasty happened - panic !
1633 ********************************************************************/
1635 void smb_panic(const char *const why)
1643 if (global_clobber_region_function) {
1644 DEBUG(0,("smb_panic: clobber_region() last called from [%s(%u)]\n",
1645 global_clobber_region_function,
1646 global_clobber_region_line));
1651 DEBUG(0,("PANIC (pid %llu): %s\n",
1652 (unsigned long long)sys_getpid(), why));
1655 cmd = lp_panic_action();
1657 DEBUG(0, ("smb_panic(): calling panic action [%s]\n", cmd));
1658 result = system(cmd);
1661 DEBUG(0, ("smb_panic(): fork failed in panic action: %s\n",
1664 DEBUG(0, ("smb_panic(): action returned status %d\n",
1665 WEXITSTATUS(result)));
1671 /*******************************************************************
1672 Print a backtrace of the stack to the debug log. This function
1673 DELIBERATELY LEAKS MEMORY. The expectation is that you should
1674 exit shortly after calling it.
1675 ********************************************************************/
1677 #ifdef HAVE_LIBUNWIND_H
1678 #include <libunwind.h>
1681 #ifdef HAVE_EXECINFO_H
1682 #include <execinfo.h>
1685 #ifdef HAVE_LIBEXC_H
1689 void log_stack_trace(void)
1691 #ifdef HAVE_LIBUNWIND
1692 /* Try to use libunwind before any other technique since on ia64
1693 * libunwind correctly walks the stack in more circumstances than
1696 unw_cursor_t cursor;
1701 unw_word_t ip, sp, off;
1703 procname[sizeof(procname) - 1] = '\0';
1705 if (unw_getcontext(&uc) != 0) {
1706 goto libunwind_failed;
1709 if (unw_init_local(&cursor, &uc) != 0) {
1710 goto libunwind_failed;
1713 DEBUG(0, ("BACKTRACE:\n"));
1717 unw_get_reg(&cursor, UNW_REG_IP, &ip);
1718 unw_get_reg(&cursor, UNW_REG_SP, &sp);
1720 switch (unw_get_proc_name(&cursor,
1721 procname, sizeof(procname) - 1, &off) ) {
1725 /* Name truncated. */
1726 DEBUGADD(0, (" #%u %s + %#llx [ip=%#llx] [sp=%#llx]\n",
1727 i, procname, (long long)off,
1728 (long long)ip, (long long) sp));
1731 /* case -UNW_ENOINFO: */
1732 /* case -UNW_EUNSPEC: */
1733 /* No symbol name found. */
1734 DEBUGADD(0, (" #%u %s [ip=%#llx] [sp=%#llx]\n",
1735 i, "<unknown symbol>",
1736 (long long)ip, (long long) sp));
1739 } while (unw_step(&cursor) > 0);
1744 DEBUG(0, ("unable to produce a stack trace with libunwind\n"));
1746 #elif HAVE_BACKTRACE_SYMBOLS
1747 void *backtrace_stack[BACKTRACE_STACK_SIZE];
1748 size_t backtrace_size;
1749 char **backtrace_strings;
1751 /* get the backtrace (stack frames) */
1752 backtrace_size = backtrace(backtrace_stack,BACKTRACE_STACK_SIZE);
1753 backtrace_strings = backtrace_symbols(backtrace_stack, backtrace_size);
1755 DEBUG(0, ("BACKTRACE: %lu stack frames:\n",
1756 (unsigned long)backtrace_size));
1758 if (backtrace_strings) {
1761 for (i = 0; i < backtrace_size; i++)
1762 DEBUGADD(0, (" #%u %s\n", i, backtrace_strings[i]));
1764 /* Leak the backtrace_strings, rather than risk what free() might do */
1769 /* The IRIX libexc library provides an API for unwinding the stack. See
1770 * libexc(3) for details. Apparantly trace_back_stack leaks memory, but
1771 * since we are about to abort anyway, it hardly matters.
1774 #define NAMESIZE 32 /* Arbitrary */
1776 __uint64_t addrs[BACKTRACE_STACK_SIZE];
1777 char * names[BACKTRACE_STACK_SIZE];
1778 char namebuf[BACKTRACE_STACK_SIZE * NAMESIZE];
1785 ZERO_ARRAY(namebuf);
1787 /* We need to be root so we can open our /proc entry to walk
1788 * our stack. It also helps when we want to dump core.
1792 for (i = 0; i < BACKTRACE_STACK_SIZE; i++) {
1793 names[i] = namebuf + (i * NAMESIZE);
1796 levels = trace_back_stack(0, addrs, names,
1797 BACKTRACE_STACK_SIZE, NAMESIZE - 1);
1799 DEBUG(0, ("BACKTRACE: %d stack frames:\n", levels));
1800 for (i = 0; i < levels; i++) {
1801 DEBUGADD(0, (" #%d 0x%llx %s\n", i, addrs[i], names[i]));
1806 DEBUG(0, ("unable to produce a stack trace on this platform\n"));
1810 /*******************************************************************
1811 A readdir wrapper which just returns the file name.
1812 ********************************************************************/
1814 const char *readdirname(SMB_STRUCT_DIR *p)
1816 SMB_STRUCT_DIRENT *ptr;
1822 ptr = (SMB_STRUCT_DIRENT *)sys_readdir(p);
1826 dname = ptr->d_name;
1833 #ifdef HAVE_BROKEN_READDIR_NAME
1834 /* using /usr/ucb/cc is BAD */
1840 int len = NAMLEN(ptr);
1841 memcpy(buf, dname, len);
1849 /*******************************************************************
1850 Utility function used to decide if the last component
1851 of a path matches a (possibly wildcarded) entry in a namelist.
1852 ********************************************************************/
1854 BOOL is_in_path(const char *name, name_compare_entry *namelist, BOOL case_sensitive)
1856 pstring last_component;
1859 /* if we have no list it's obviously not in the path */
1860 if((namelist == NULL ) || ((namelist != NULL) && (namelist[0].name == NULL))) {
1864 DEBUG(8, ("is_in_path: %s\n", name));
1866 /* Get the last component of the unix name. */
1867 p = strrchr_m(name, '/');
1868 pstrcpy(last_component, p ? ++p : name);
1870 for(; namelist->name != NULL; namelist++) {
1871 if(namelist->is_wild) {
1872 if (mask_match(last_component, namelist->name, case_sensitive)) {
1873 DEBUG(8,("is_in_path: mask match succeeded\n"));
1877 if((case_sensitive && (strcmp(last_component, namelist->name) == 0))||
1878 (!case_sensitive && (StrCaseCmp(last_component, namelist->name) == 0))) {
1879 DEBUG(8,("is_in_path: match succeeded\n"));
1884 DEBUG(8,("is_in_path: match not found\n"));
1889 /*******************************************************************
1890 Strip a '/' separated list into an array of
1891 name_compare_enties structures suitable for
1892 passing to is_in_path(). We do this for
1893 speed so we can pre-parse all the names in the list
1894 and don't do it for each call to is_in_path().
1895 namelist is modified here and is assumed to be
1896 a copy owned by the caller.
1897 We also check if the entry contains a wildcard to
1898 remove a potentially expensive call to mask_match
1900 ********************************************************************/
1902 void set_namearray(name_compare_entry **ppname_array, char *namelist)
1905 char *nameptr = namelist;
1906 int num_entries = 0;
1909 (*ppname_array) = NULL;
1911 if((nameptr == NULL ) || ((nameptr != NULL) && (*nameptr == '\0')))
1914 /* We need to make two passes over the string. The
1915 first to count the number of elements, the second
1920 if ( *nameptr == '/' ) {
1921 /* cope with multiple (useless) /s) */
1925 /* find the next / */
1926 name_end = strchr_m(nameptr, '/');
1928 /* oops - the last check for a / didn't find one. */
1929 if (name_end == NULL)
1932 /* next segment please */
1933 nameptr = name_end + 1;
1937 if(num_entries == 0)
1940 if(( (*ppname_array) = SMB_MALLOC_ARRAY(name_compare_entry, num_entries + 1)) == NULL) {
1941 DEBUG(0,("set_namearray: malloc fail\n"));
1945 /* Now copy out the names */
1949 if ( *nameptr == '/' ) {
1950 /* cope with multiple (useless) /s) */
1954 /* find the next / */
1955 if ((name_end = strchr_m(nameptr, '/')) != NULL)
1958 /* oops - the last check for a / didn't find one. */
1959 if(name_end == NULL)
1962 (*ppname_array)[i].is_wild = ms_has_wild(nameptr);
1963 if(((*ppname_array)[i].name = SMB_STRDUP(nameptr)) == NULL) {
1964 DEBUG(0,("set_namearray: malloc fail (1)\n"));
1968 /* next segment please */
1969 nameptr = name_end + 1;
1973 (*ppname_array)[i].name = NULL;
1978 /****************************************************************************
1979 Routine to free a namearray.
1980 ****************************************************************************/
1982 void free_namearray(name_compare_entry *name_array)
1986 if(name_array == NULL)
1989 for(i=0; name_array[i].name!=NULL; i++)
1990 SAFE_FREE(name_array[i].name);
1991 SAFE_FREE(name_array);
1995 #define DBGC_CLASS DBGC_LOCKING
1997 /****************************************************************************
1998 Simple routine to do POSIX file locking. Cruft in NFS and 64->32 bit mapping
1999 is dealt with in posix.c
2000 Returns True if the lock was granted, False otherwise.
2001 ****************************************************************************/
2003 BOOL fcntl_lock(int fd, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
2005 SMB_STRUCT_FLOCK lock;
2008 DEBUG(8,("fcntl_lock fd=%d op=%d offset=%.0f count=%.0f type=%d\n",
2009 fd,op,(double)offset,(double)count,type));
2012 lock.l_whence = SEEK_SET;
2013 lock.l_start = offset;
2017 ret = sys_fcntl_ptr(fd,op,&lock);
2021 DEBUG(3,("fcntl_lock: lock failed at offset %.0f count %.0f op %d type %d (%s)\n",
2022 (double)offset,(double)count,op,type,strerror(errno)));
2027 /* everything went OK */
2028 DEBUG(8,("fcntl_lock: Lock call successful\n"));
2033 /****************************************************************************
2034 Simple routine to query existing file locks. Cruft in NFS and 64->32 bit mapping
2035 is dealt with in posix.c
2036 Returns True if we have information regarding this lock region (and returns
2037 F_UNLCK in *ptype if the region is unlocked). False if the call failed.
2038 ****************************************************************************/
2040 BOOL fcntl_getlock(int fd, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype, pid_t *ppid)
2042 SMB_STRUCT_FLOCK lock;
2045 DEBUG(8,("fcntl_getlock fd=%d offset=%.0f count=%.0f type=%d\n",
2046 fd,(double)*poffset,(double)*pcount,*ptype));
2048 lock.l_type = *ptype;
2049 lock.l_whence = SEEK_SET;
2050 lock.l_start = *poffset;
2051 lock.l_len = *pcount;
2054 ret = sys_fcntl_ptr(fd,SMB_F_GETLK,&lock);
2058 DEBUG(3,("fcntl_getlock: lock request failed at offset %.0f count %.0f type %d (%s)\n",
2059 (double)*poffset,(double)*pcount,*ptype,strerror(errno)));
2064 *ptype = lock.l_type;
2065 *poffset = lock.l_start;
2066 *pcount = lock.l_len;
2069 DEBUG(3,("fcntl_getlock: fd %d is returned info %d pid %u\n",
2070 fd, (int)lock.l_type, (unsigned int)lock.l_pid));
2075 #define DBGC_CLASS DBGC_ALL
2077 /*******************************************************************
2078 Is the name specified one of my netbios names.
2079 Returns true if it is equal, false otherwise.
2080 ********************************************************************/
2082 BOOL is_myname(const char *s)
2087 for (n=0; my_netbios_names(n); n++) {
2088 if (strequal(my_netbios_names(n), s)) {
2093 DEBUG(8, ("is_myname(\"%s\") returns %d\n", s, ret));
2097 BOOL is_myname_or_ipaddr(const char *s)
2099 fstring name, dnsname;
2105 /* santize the string from '\\name' */
2109 servername = strrchr_m( name, '\\' );
2115 /* optimize for the common case */
2117 if (strequal(servername, global_myname()))
2120 /* check for an alias */
2122 if (is_myname(servername))
2125 /* check for loopback */
2127 if (strequal(servername, "127.0.0.1"))
2130 if (strequal(servername, "localhost"))
2133 /* maybe it's my dns name */
2135 if ( get_mydnsfullname( dnsname ) )
2136 if ( strequal( servername, dnsname ) )
2139 /* handle possible CNAME records */
2141 if ( !is_ipaddress( servername ) ) {
2142 /* use DNS to resolve the name, but only the first address */
2145 if (((hp = sys_gethostbyname(name)) != NULL) && (hp->h_addr != NULL)) {
2146 struct in_addr return_ip;
2147 putip( (char*)&return_ip, (char*)hp->h_addr );
2148 fstrcpy( name, inet_ntoa( return_ip ) );
2153 /* maybe its an IP address? */
2154 if (is_ipaddress(servername)) {
2155 struct iface_struct nics[MAX_INTERFACES];
2159 ip = interpret_addr(servername);
2160 if ((ip==0) || (ip==0xffffffff))
2163 n = get_interfaces(nics, MAX_INTERFACES);
2164 for (i=0; i<n; i++) {
2165 if (ip == nics[i].ip.s_addr)
2174 /*******************************************************************
2175 Is the name specified our workgroup/domain.
2176 Returns true if it is equal, false otherwise.
2177 ********************************************************************/
2179 BOOL is_myworkgroup(const char *s)
2183 if (strequal(s, lp_workgroup())) {
2187 DEBUG(8, ("is_myworkgroup(\"%s\") returns %d\n", s, ret));
2191 /*******************************************************************
2192 we distinguish between 2K and XP by the "Native Lan Manager" string
2193 WinXP => "Windows 2002 5.1"
2194 WinXP 64bit => "Windows XP 5.2"
2195 Win2k => "Windows 2000 5.0"
2196 NT4 => "Windows NT 4.0"
2197 Win9x => "Windows 4.0"
2198 Windows 2003 doesn't set the native lan manager string but
2199 they do set the domain to "Windows 2003 5.2" (probably a bug).
2200 ********************************************************************/
2202 void ra_lanman_string( const char *native_lanman )
2204 if ( strcmp( native_lanman, "Windows 2002 5.1" ) == 0 )
2205 set_remote_arch( RA_WINXP );
2206 else if ( strcmp( native_lanman, "Windows XP 5.2" ) == 0 )
2207 set_remote_arch( RA_WINXP );
2208 else if ( strcmp( native_lanman, "Windows Server 2003 5.2" ) == 0 )
2209 set_remote_arch( RA_WIN2K3 );
2212 /*******************************************************************
2213 Set the horrid remote_arch string based on an enum.
2214 ********************************************************************/
2216 void set_remote_arch(enum remote_arch_types type)
2221 fstrcpy(remote_arch, "WfWg");
2224 fstrcpy(remote_arch, "OS2");
2227 fstrcpy(remote_arch, "Win95");
2230 fstrcpy(remote_arch, "WinNT");
2233 fstrcpy(remote_arch, "Win2K");
2236 fstrcpy(remote_arch, "WinXP");
2239 fstrcpy(remote_arch, "Win2K3");
2242 fstrcpy(remote_arch, "Vista");
2245 fstrcpy(remote_arch,"Samba");
2248 fstrcpy(remote_arch,"CIFSFS");
2251 ra_type = RA_UNKNOWN;
2252 fstrcpy(remote_arch, "UNKNOWN");
2256 DEBUG(10,("set_remote_arch: Client arch is \'%s\'\n", remote_arch));
2259 /*******************************************************************
2260 Get the remote_arch type.
2261 ********************************************************************/
2263 enum remote_arch_types get_remote_arch(void)
2268 void print_asc(int level, const unsigned char *buf,int len)
2272 DEBUG(level,("%c", isprint(buf[i])?buf[i]:'.'));
2275 void dump_data(int level, const unsigned char *buf,int len)
2280 if (!DEBUGLVL(level)) return;
2282 DEBUGADD(level,("[%03X] ",i));
2284 DEBUGADD(level,("%02X ",(int)buf[i]));
2286 if (i%8 == 0) DEBUGADD(level,(" "));
2288 print_asc(level,&buf[i-16],8); DEBUGADD(level,(" "));
2289 print_asc(level,&buf[i-8],8); DEBUGADD(level,("\n"));
2290 if (i<len) DEBUGADD(level,("[%03X] ",i));
2296 DEBUGADD(level,(" "));
2297 if (n>8) DEBUGADD(level,(" "));
2298 while (n--) DEBUGADD(level,(" "));
2300 print_asc(level,&buf[i-(i%16)],n); DEBUGADD(level,( " " ));
2302 if (n>0) print_asc(level,&buf[i-n],n);
2303 DEBUGADD(level,("\n"));
2307 void dump_data_pw(const char *msg, const uchar * data, size_t len)
2309 #ifdef DEBUG_PASSWORD
2310 DEBUG(11, ("%s", msg));
2311 if (data != NULL && len > 0)
2313 dump_data(11, data, len);
2318 char *tab_depth(int depth)
2320 static pstring spaces;
2321 memset(spaces, ' ', depth * 4);
2322 spaces[depth * 4] = 0;
2326 /*****************************************************************************
2327 Provide a checksum on a string
2329 Input: s - the null-terminated character string for which the checksum
2332 Output: The checksum value calculated for s.
2333 *****************************************************************************/
2335 int str_checksum(const char *s)
2343 res ^= (c << (i % 15)) ^ (c >> (15-(i%15)));
2350 /*****************************************************************
2351 Zero a memory area then free it. Used to catch bugs faster.
2352 *****************************************************************/
2354 void zero_free(void *p, size_t size)
2360 /*****************************************************************
2361 Set our open file limit to a requested max and return the limit.
2362 *****************************************************************/
2364 int set_maxfiles(int requested_max)
2366 #if (defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE))
2368 int saved_current_limit;
2370 if(getrlimit(RLIMIT_NOFILE, &rlp)) {
2371 DEBUG(0,("set_maxfiles: getrlimit (1) for RLIMIT_NOFILE failed with error %s\n",
2374 return requested_max;
2378 * Set the fd limit to be real_max_open_files + MAX_OPEN_FUDGEFACTOR to
2379 * account for the extra fd we need
2380 * as well as the log files and standard
2381 * handles etc. Save the limit we want to set in case
2382 * we are running on an OS that doesn't support this limit (AIX)
2383 * which always returns RLIM_INFINITY for rlp.rlim_max.
2386 /* Try raising the hard (max) limit to the requested amount. */
2388 #if defined(RLIM_INFINITY)
2389 if (rlp.rlim_max != RLIM_INFINITY) {
2390 int orig_max = rlp.rlim_max;
2392 if ( rlp.rlim_max < requested_max )
2393 rlp.rlim_max = requested_max;
2395 /* This failing is not an error - many systems (Linux) don't
2396 support our default request of 10,000 open files. JRA. */
2398 if(setrlimit(RLIMIT_NOFILE, &rlp)) {
2399 DEBUG(3,("set_maxfiles: setrlimit for RLIMIT_NOFILE for %d max files failed with error %s\n",
2400 (int)rlp.rlim_max, strerror(errno) ));
2402 /* Set failed - restore original value from get. */
2403 rlp.rlim_max = orig_max;
2408 /* Now try setting the soft (current) limit. */
2410 saved_current_limit = rlp.rlim_cur = MIN(requested_max,rlp.rlim_max);
2412 if(setrlimit(RLIMIT_NOFILE, &rlp)) {
2413 DEBUG(0,("set_maxfiles: setrlimit for RLIMIT_NOFILE for %d files failed with error %s\n",
2414 (int)rlp.rlim_cur, strerror(errno) ));
2416 return saved_current_limit;
2419 if(getrlimit(RLIMIT_NOFILE, &rlp)) {
2420 DEBUG(0,("set_maxfiles: getrlimit (2) for RLIMIT_NOFILE failed with error %s\n",
2423 return saved_current_limit;
2426 #if defined(RLIM_INFINITY)
2427 if(rlp.rlim_cur == RLIM_INFINITY)
2428 return saved_current_limit;
2431 if((int)rlp.rlim_cur > saved_current_limit)
2432 return saved_current_limit;
2434 return rlp.rlim_cur;
2435 #else /* !defined(HAVE_GETRLIMIT) || !defined(RLIMIT_NOFILE) */
2437 * No way to know - just guess...
2439 return requested_max;
2443 /*****************************************************************
2444 Possibly replace mkstemp if it is broken.
2445 *****************************************************************/
2447 int smb_mkstemp(char *name_template)
2449 #if HAVE_SECURE_MKSTEMP
2450 return mkstemp(name_template);
2452 /* have a reasonable go at emulating it. Hope that
2453 the system mktemp() isn't completly hopeless */
2454 char *p = mktemp(name_template);
2457 return open(p, O_CREAT|O_EXCL|O_RDWR, 0600);
2461 /*****************************************************************
2462 malloc that aborts with smb_panic on fail or zero size.
2463 *****************************************************************/
2465 void *smb_xmalloc_array(size_t size, unsigned int count)
2469 smb_panic("smb_xmalloc_array: called with zero size.\n");
2470 if (count >= MAX_ALLOC_SIZE/size) {
2471 smb_panic("smb_xmalloc: alloc size too large.\n");
2473 if ((p = SMB_MALLOC(size*count)) == NULL) {
2474 DEBUG(0, ("smb_xmalloc_array failed to allocate %lu * %lu bytes\n",
2475 (unsigned long)size, (unsigned long)count));
2476 smb_panic("smb_xmalloc_array: malloc fail.\n");
2482 Memdup with smb_panic on fail.
2485 void *smb_xmemdup(const void *p, size_t size)
2488 p2 = SMB_XMALLOC_ARRAY(unsigned char,size);
2489 memcpy(p2, p, size);
2494 strdup that aborts on malloc fail.
2497 char *smb_xstrdup(const char *s)
2499 #if defined(PARANOID_MALLOC_CHECKER)
2506 #define strdup rep_strdup
2509 char *s1 = strdup(s);
2510 #if defined(PARANOID_MALLOC_CHECKER)
2514 #define strdup(s) __ERROR_DONT_USE_STRDUP_DIRECTLY
2517 smb_panic("smb_xstrdup: malloc fail\n");
2523 strndup that aborts on malloc fail.
2526 char *smb_xstrndup(const char *s, size_t n)
2528 #if defined(PARANOID_MALLOC_CHECKER)
2534 #if (defined(BROKEN_STRNDUP) || !defined(HAVE_STRNDUP))
2536 #define strndup rep_strndup
2539 char *s1 = strndup(s, n);
2540 #if defined(PARANOID_MALLOC_CHECKER)
2544 #define strndup(s,n) __ERROR_DONT_USE_STRNDUP_DIRECTLY
2547 smb_panic("smb_xstrndup: malloc fail\n");
2552 vasprintf that aborts on malloc fail
2555 int smb_xvasprintf(char **ptr, const char *format, va_list ap)
2562 n = vasprintf(ptr, format, ap2);
2563 if (n == -1 || ! *ptr)
2564 smb_panic("smb_xvasprintf: out of memory");
2568 /*****************************************************************
2569 Like strdup but for memory.
2570 *****************************************************************/
2572 void *memdup(const void *p, size_t size)
2577 p2 = SMB_MALLOC(size);
2580 memcpy(p2, p, size);
2584 /*****************************************************************
2585 Get local hostname and cache result.
2586 *****************************************************************/
2588 char *myhostname(void)
2596 /*****************************************************************
2597 A useful function for returning a path in the Samba lock directory.
2598 *****************************************************************/
2600 char *lock_path(const char *name)
2602 static pstring fname;
2604 pstrcpy(fname,lp_lockdir());
2605 trim_char(fname,'\0','/');
2607 if (!directory_exist(fname,NULL))
2611 pstrcat(fname,name);
2616 /*****************************************************************
2617 A useful function for returning a path in the Samba pid directory.
2618 *****************************************************************/
2620 char *pid_path(const char *name)
2622 static pstring fname;
2624 pstrcpy(fname,lp_piddir());
2625 trim_char(fname,'\0','/');
2627 if (!directory_exist(fname,NULL))
2631 pstrcat(fname,name);
2637 * @brief Returns an absolute path to a file in the Samba lib directory.
2639 * @param name File to find, relative to LIBDIR.
2641 * @retval Pointer to a static #pstring containing the full path.
2644 char *lib_path(const char *name)
2646 static pstring fname;
2647 fstr_sprintf(fname, "%s/%s", dyn_LIBDIR, name);
2652 * @brief Returns the platform specific shared library extension.
2654 * @retval Pointer to a static #fstring containing the extension.
2657 const char *shlib_ext(void)
2659 return dyn_SHLIBEXT;
2662 /*******************************************************************
2663 Given a filename - get its directory name
2664 NB: Returned in static storage. Caveats:
2665 o Not safe in thread environment.
2666 o Caller must not free.
2667 o If caller wishes to preserve, they should copy.
2668 ********************************************************************/
2670 char *parent_dirname(const char *path)
2672 static pstring dirpath;
2678 pstrcpy(dirpath, path);
2679 p = strrchr_m(dirpath, '/'); /* Find final '/', if any */
2681 pstrcpy(dirpath, "."); /* No final "/", so dir is "." */
2684 ++p; /* For root "/", leave "/" in place */
2690 BOOL parent_dirname_talloc(TALLOC_CTX *mem_ctx, const char *dir,
2691 char **parent, const char **name)
2696 p = strrchr_m(dir, '/'); /* Find final '/', if any */
2699 if (!(*parent = talloc_strdup(mem_ctx, "."))) {
2710 if (!(*parent = TALLOC_ARRAY(mem_ctx, char, len+1))) {
2713 memcpy(*parent, dir, len);
2714 (*parent)[len] = '\0';
2722 /*******************************************************************
2723 Determine if a pattern contains any Microsoft wildcard characters.
2724 *******************************************************************/
2726 BOOL ms_has_wild(const char *s)
2730 if (lp_posix_pathnames()) {
2731 /* With posix pathnames no characters are wild. */
2735 while ((c = *s++)) {
2748 BOOL ms_has_wild_w(const smb_ucs2_t *s)
2751 if (!s) return False;
2752 while ((c = *s++)) {
2754 case UCS2_CHAR('*'):
2755 case UCS2_CHAR('?'):
2756 case UCS2_CHAR('<'):
2757 case UCS2_CHAR('>'):
2758 case UCS2_CHAR('"'):
2765 /*******************************************************************
2766 A wrapper that handles case sensitivity and the special handling
2768 *******************************************************************/
2770 BOOL mask_match(const char *string, char *pattern, BOOL is_case_sensitive)
2772 if (strcmp(string,"..") == 0)
2774 if (strcmp(pattern,".") == 0)
2777 return ms_fnmatch(pattern, string, Protocol <= PROTOCOL_LANMAN2, is_case_sensitive) == 0;
2780 /*******************************************************************
2781 A wrapper that handles case sensitivity and the special handling
2782 of the ".." name. Varient that is only called by old search code which requires
2783 pattern translation.
2784 *******************************************************************/
2786 BOOL mask_match_search(const char *string, char *pattern, BOOL is_case_sensitive)
2788 if (strcmp(string,"..") == 0)
2790 if (strcmp(pattern,".") == 0)
2793 return ms_fnmatch(pattern, string, True, is_case_sensitive) == 0;
2796 /*******************************************************************
2797 A wrapper that handles a list of patters and calls mask_match()
2798 on each. Returns True if any of the patterns match.
2799 *******************************************************************/
2801 BOOL mask_match_list(const char *string, char **list, int listLen, BOOL is_case_sensitive)
2803 while (listLen-- > 0) {
2804 if (mask_match(string, *list++, is_case_sensitive))
2810 /*********************************************************
2811 Recursive routine that is called by unix_wild_match.
2812 *********************************************************/
2814 static BOOL unix_do_match(const char *regexp, const char *str)
2818 for( p = regexp; *p && *str; ) {
2829 * Look for a character matching
2830 * the one after the '*'.
2834 return True; /* Automatic match */
2837 while(*str && (*p != *str))
2841 * Patch from weidel@multichart.de. In the case of the regexp
2842 * '*XX*' we want to ensure there are at least 2 'X' characters
2843 * in the string after the '*' for a match to be made.
2850 * Eat all the characters that match, but count how many there were.
2853 while(*str && (*p == *str)) {
2859 * Now check that if the regexp had n identical characters that
2860 * matchcount had at least that many matches.
2863 while ( *(p+1) && (*(p+1) == *p)) {
2868 if ( matchcount <= 0 )
2872 str--; /* We've eaten the match char after the '*' */
2874 if(unix_do_match(p, str))
2896 if (!*p && str[0] == '.' && str[1] == 0)
2899 if (!*str && *p == '?') {
2905 if(!*str && (*p == '*' && p[1] == '\0'))
2911 /*******************************************************************
2912 Simple case insensitive interface to a UNIX wildcard matcher.
2913 Returns True if match, False if not.
2914 *******************************************************************/
2916 BOOL unix_wild_match(const char *pattern, const char *string)
2921 pstrcpy(p2, pattern);
2922 pstrcpy(s2, string);
2926 /* Remove any *? and ** from the pattern as they are meaningless */
2927 for(p = p2; *p; p++)
2928 while( *p == '*' && (p[1] == '?' ||p[1] == '*'))
2929 pstrcpy( &p[1], &p[2]);
2931 if (strequal(p2,"*"))
2934 return unix_do_match(p2, s2);
2937 /**********************************************************************
2938 Converts a name to a fully qualified domain name.
2939 Returns True if lookup succeeded, False if not (then fqdn is set to name)
2940 ***********************************************************************/
2942 BOOL name_to_fqdn(fstring fqdn, const char *name)
2944 struct hostent *hp = sys_gethostbyname(name);
2946 if ( hp && hp->h_name && *hp->h_name ) {
2949 /* find out if the fqdn is returned as an alias
2950 * to cope with /etc/hosts files where the first
2951 * name is not the fqdn but the short name */
2952 if (hp->h_aliases && (! strchr_m(hp->h_name, '.'))) {
2954 for (i = 0; hp->h_aliases[i]; i++) {
2955 if (strchr_m(hp->h_aliases[i], '.')) {
2956 full = hp->h_aliases[i];
2961 if (full && (StrCaseCmp(full, "localhost.localdomain") == 0)) {
2962 DEBUG(1, ("WARNING: your /etc/hosts file may be broken!\n"));
2963 DEBUGADD(1, (" Specifing the machine hostname for address 127.0.0.1 may lead\n"));
2964 DEBUGADD(1, (" to Kerberos authentication problems as localhost.localdomain\n"));
2965 DEBUGADD(1, (" may end up being used instead of the real machine FQDN.\n"));
2973 DEBUG(10,("name_to_fqdn: lookup for %s -> %s.\n", name, full));
2974 fstrcpy(fqdn, full);
2977 DEBUG(10,("name_to_fqdn: lookup for %s failed.\n", name));
2978 fstrcpy(fqdn, name);
2983 /**********************************************************************
2984 Extension to talloc_get_type: Abort on type mismatch
2985 ***********************************************************************/
2987 void *talloc_check_name_abort(const void *ptr, const char *name)
2991 result = talloc_check_name(ptr, name);
2995 DEBUG(0, ("Talloc type mismatch, expected %s, got %s\n",
2996 name, talloc_get_name(ptr)));
2997 smb_panic("aborting");
2998 /* Keep the compiler happy */
3005 /*******************************************************************
3006 This routine is a trick to immediately catch errors when debugging
3007 with insure. A xterm with a gdb is popped up when insure catches
3008 a error. It is Linux specific.
3009 ********************************************************************/
3011 int _Insure_trap_error(int a1, int a2, int a3, int a4, int a5, int a6)
3016 /* you can get /usr/bin/backtrace from
3017 http://samba.org/ftp/unpacked/junkcode/backtrace */
3018 pstring cmd = "/usr/bin/backtrace %d";
3020 slprintf(pidstr, sizeof(pidstr)-1, "%d", sys_getpid());
3021 pstring_sub(cmd, "%d", pidstr);
3025 h = dlopen("/usr/local/parasoft/insure++lite/lib.linux2/libinsure.so", RTLD_LAZY);
3026 fn = dlsym(h, "_Insure_trap_error");
3028 if (!h || h == _Insure_trap_error) {
3029 h = dlopen("/usr/local/parasoft/lib.linux2/libinsure.so", RTLD_LAZY);
3030 fn = dlsym(h, "_Insure_trap_error");
3034 ret = fn(a1, a2, a3, a4, a5, a6);
3042 uint32 map_share_mode_to_deny_mode(uint32 share_access, uint32 private_options)
3044 switch (share_access & ~FILE_SHARE_DELETE) {
3045 case FILE_SHARE_NONE:
3047 case FILE_SHARE_READ:
3049 case FILE_SHARE_WRITE:
3051 case FILE_SHARE_READ|FILE_SHARE_WRITE:
3054 if (private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS) {
3056 } else if (private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_FCB) {
3063 pid_t procid_to_pid(const struct server_id *proc)
3068 struct server_id pid_to_procid(pid_t pid)
3070 struct server_id result;
3075 struct server_id procid_self(void)
3077 return pid_to_procid(sys_getpid());
3080 struct server_id server_id_self(void)
3082 return procid_self();
3085 BOOL procid_equal(const struct server_id *p1, const struct server_id *p2)
3087 return (p1->pid == p2->pid);
3090 BOOL cluster_id_equal(const struct server_id *id1,
3091 const struct server_id *id2)
3093 return procid_equal(id1, id2);
3096 BOOL procid_is_me(const struct server_id *pid)
3098 return (pid->pid == sys_getpid());
3101 struct server_id interpret_pid(const char *pid_string)
3103 return pid_to_procid(atoi(pid_string));
3106 char *procid_str_static(const struct server_id *pid)
3109 fstr_sprintf(str, "%d", pid->pid);
3113 char *procid_str(TALLOC_CTX *mem_ctx, const struct server_id *pid)
3115 return talloc_strdup(mem_ctx, procid_str_static(pid));
3118 BOOL procid_valid(const struct server_id *pid)
3120 return (pid->pid != -1);
3123 BOOL procid_is_local(const struct server_id *pid)
3128 int this_is_smp(void)
3130 #if defined(HAVE_SYSCONF)
3132 #if defined(SYSCONF_SC_NPROC_ONLN)
3133 return (sysconf(_SC_NPROC_ONLN) > 1) ? 1 : 0;
3134 #elif defined(SYSCONF_SC_NPROCESSORS_ONLN)
3135 return (sysconf(_SC_NPROCESSORS_ONLN) > 1) ? 1 : 0;
3145 /****************************************************************
3146 Check if an offset into a buffer is safe.
3147 If this returns True it's safe to indirect into the byte at
3149 ****************************************************************/
3151 BOOL is_offset_safe(const char *buf_base, size_t buf_len, char *ptr, size_t off)
3153 const char *end_base = buf_base + buf_len;
3154 char *end_ptr = ptr + off;
3156 if (!buf_base || !ptr) {
3160 if (end_base < buf_base || end_ptr < ptr) {
3161 return False; /* wrap. */
3164 if (end_ptr < end_base) {
3170 /****************************************************************
3171 Return a safe pointer into a buffer, or NULL.
3172 ****************************************************************/
3174 char *get_safe_ptr(const char *buf_base, size_t buf_len, char *ptr, size_t off)
3176 return is_offset_safe(buf_base, buf_len, ptr, off) ?
3180 /****************************************************************
3181 Return a safe pointer into a string within a buffer, or NULL.
3182 ****************************************************************/
3184 char *get_safe_str_ptr(const char *buf_base, size_t buf_len, char *ptr, size_t off)
3186 if (!is_offset_safe(buf_base, buf_len, ptr, off)) {
3189 /* Check if a valid string exists at this offset. */
3190 if (skip_string(buf_base,buf_len, ptr + off) == NULL) {
3196 /****************************************************************
3197 Return an SVAL at a pointer, or failval if beyond the end.
3198 ****************************************************************/
3200 int get_safe_SVAL(const char *buf_base, size_t buf_len, char *ptr, size_t off, int failval)
3203 * Note we use off+1 here, not off+2 as SVAL accesses ptr[0] and ptr[1],
3206 if (!is_offset_safe(buf_base, buf_len, ptr, off+1)) {
3209 return SVAL(ptr,off);
3212 /****************************************************************
3213 Return an IVAL at a pointer, or failval if beyond the end.
3214 ****************************************************************/
3216 int get_safe_IVAL(const char *buf_base, size_t buf_len, char *ptr, size_t off, int failval)
3219 * Note we use off+3 here, not off+4 as IVAL accesses
3220 * ptr[0] ptr[1] ptr[2] ptr[3] NOT ptr[4].
3222 if (!is_offset_safe(buf_base, buf_len, ptr, off+3)) {
3225 return IVAL(ptr,off);
3228 /****************************************************************
3229 talloc wrapper functions that guarentee a null pointer return
3231 ****************************************************************/
3233 #ifndef MAX_TALLOC_SIZE
3234 #define MAX_TALLOC_SIZE 0x10000000
3238 * talloc and zero memory.
3239 * - returns NULL if size is zero.
3242 void *_talloc_zero_zeronull(const void *ctx, size_t size, const char *name)
3250 p = talloc_named_const(ctx, size, name);
3253 memset(p, '\0', size);
3260 * memdup with a talloc.
3261 * - returns NULL if size is zero.
3264 void *_talloc_memdup_zeronull(const void *t, const void *p, size_t size, const char *name)
3272 newp = talloc_named_const(t, size, name);
3274 memcpy(newp, p, size);
3281 * alloc an array, checking for integer overflow in the array size.
3282 * - returns NULL if count or el_size are zero.
3285 void *_talloc_array_zeronull(const void *ctx, size_t el_size, unsigned count, const char *name)
3287 if (count >= MAX_TALLOC_SIZE/el_size) {
3291 if (el_size == 0 || count == 0) {
3295 return talloc_named_const(ctx, el_size * count, name);
3299 * alloc an zero array, checking for integer overflow in the array size
3300 * - returns NULL if count or el_size are zero.
3303 void *_talloc_zero_array_zeronull(const void *ctx, size_t el_size, unsigned count, const char *name)
3305 if (count >= MAX_TALLOC_SIZE/el_size) {
3309 if (el_size == 0 || count == 0) {
3313 return _talloc_zero(ctx, el_size * count, name);
3317 * Talloc wrapper that returns NULL if size == 0.
3319 void *talloc_zeronull(const void *context, size_t size, const char *name)
3324 return talloc_named_const(context, size, name);