2 Unix SMB/CIFS implementation.
3 Samba utility functions
4 Copyright (C) Andrew Tridgell 1992-1998
5 Copyright (C) Jeremy Allison 2001-2007
6 Copyright (C) Simo Sorce 2001
7 Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2003
8 Copyright (C) James Peach 2006
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>.
26 extern char *global_clobber_region_function;
27 extern unsigned int global_clobber_region_line;
29 /* Max allowable allococation - 256mb - 0x10000000 */
30 #define MAX_ALLOC_SIZE (1024*1024*256)
32 #if (defined(HAVE_NETGROUP) && defined (WITH_AUTOMOUNT))
33 #ifdef WITH_NISPLUS_HOME
34 #ifdef BROKEN_NISPLUS_INCLUDE_FILES
36 * The following lines are needed due to buggy include files
37 * in Solaris 2.6 which define GROUP in both /usr/include/sys/acl.h and
38 * also in /usr/include/rpcsvc/nis.h. The definitions conflict. JRA.
39 * Also GROUP_OBJ is defined as 0x4 in /usr/include/sys/acl.h and as
40 * an enum in /usr/include/rpcsvc/nis.h.
47 #if defined(GROUP_OBJ)
51 #endif /* BROKEN_NISPLUS_INCLUDE_FILES */
53 #include <rpcsvc/nis.h>
55 #endif /* WITH_NISPLUS_HOME */
56 #endif /* HAVE_NETGROUP && WITH_AUTOMOUNT */
58 enum protocol_types Protocol = PROTOCOL_COREPLUS;
60 /* this is used by the chaining code */
63 static enum remote_arch_types ra_type = RA_UNKNOWN;
65 /***********************************************************************
66 Definitions for all names.
67 ***********************************************************************/
69 static char *smb_myname;
70 static char *smb_myworkgroup;
71 static char *smb_scope;
72 static int smb_num_netbios_names;
73 static char **smb_my_netbios_names;
75 /***********************************************************************
76 Allocate and set myname. Ensure upper case.
77 ***********************************************************************/
79 bool set_global_myname(const char *myname)
81 SAFE_FREE(smb_myname);
82 smb_myname = SMB_STRDUP(myname);
85 strupper_m(smb_myname);
89 const char *global_myname(void)
94 /***********************************************************************
95 Allocate and set myworkgroup. Ensure upper case.
96 ***********************************************************************/
98 bool set_global_myworkgroup(const char *myworkgroup)
100 SAFE_FREE(smb_myworkgroup);
101 smb_myworkgroup = SMB_STRDUP(myworkgroup);
102 if (!smb_myworkgroup)
104 strupper_m(smb_myworkgroup);
108 const char *lp_workgroup(void)
110 return smb_myworkgroup;
113 /***********************************************************************
114 Allocate and set scope. Ensure upper case.
115 ***********************************************************************/
117 bool set_global_scope(const char *scope)
119 SAFE_FREE(smb_scope);
120 smb_scope = SMB_STRDUP(scope);
123 strupper_m(smb_scope);
127 /*********************************************************************
128 Ensure scope is never null string.
129 *********************************************************************/
131 const char *global_scope(void)
134 set_global_scope("");
138 static void free_netbios_names_array(void)
142 for (i = 0; i < smb_num_netbios_names; i++)
143 SAFE_FREE(smb_my_netbios_names[i]);
145 SAFE_FREE(smb_my_netbios_names);
146 smb_num_netbios_names = 0;
149 static bool allocate_my_netbios_names_array(size_t number)
151 free_netbios_names_array();
153 smb_num_netbios_names = number + 1;
154 smb_my_netbios_names = SMB_MALLOC_ARRAY( char *, smb_num_netbios_names );
156 if (!smb_my_netbios_names)
159 memset(smb_my_netbios_names, '\0', sizeof(char *) * smb_num_netbios_names);
163 static bool set_my_netbios_names(const char *name, int i)
165 SAFE_FREE(smb_my_netbios_names[i]);
167 smb_my_netbios_names[i] = SMB_STRDUP(name);
168 if (!smb_my_netbios_names[i])
170 strupper_m(smb_my_netbios_names[i]);
174 /***********************************************************************
175 Free memory allocated to global objects
176 ***********************************************************************/
178 void gfree_names(void)
180 SAFE_FREE( smb_myname );
181 SAFE_FREE( smb_myworkgroup );
182 SAFE_FREE( smb_scope );
183 free_netbios_names_array();
184 free_local_machine_name();
187 void gfree_all( void )
197 const char *my_netbios_names(int i)
199 return smb_my_netbios_names[i];
202 bool set_netbios_aliases(const char **str_array)
206 /* Work out the max number of netbios aliases that we have */
207 for( namecount=0; str_array && (str_array[namecount] != NULL); namecount++ )
210 if ( global_myname() && *global_myname())
213 /* Allocate space for the netbios aliases */
214 if (!allocate_my_netbios_names_array(namecount))
217 /* Use the global_myname string first */
219 if ( global_myname() && *global_myname()) {
220 set_my_netbios_names( global_myname(), namecount );
226 for ( i = 0; str_array[i] != NULL; i++) {
228 bool duplicate = False;
230 /* Look for duplicates */
231 for( n=0; n<namecount; n++ ) {
232 if( strequal( str_array[i], my_netbios_names(n) ) ) {
238 if (!set_my_netbios_names(str_array[i], namecount))
247 /****************************************************************************
248 Common name initialization code.
249 ****************************************************************************/
251 bool init_names(void)
255 if (global_myname() == NULL || *global_myname() == '\0') {
256 if (!set_global_myname(myhostname())) {
257 DEBUG( 0, ( "init_structs: malloc fail.\n" ) );
262 if (!set_netbios_aliases(lp_netbios_aliases())) {
263 DEBUG( 0, ( "init_structs: malloc fail.\n" ) );
267 set_local_machine_name(global_myname(),false);
269 DEBUG( 5, ("Netbios name list:-\n") );
270 for( n=0; my_netbios_names(n); n++ ) {
271 DEBUGADD( 5, ("my_netbios_names[%d]=\"%s\"\n",
272 n, my_netbios_names(n) ) );
278 /**************************************************************************n
279 Code to cope with username/password auth options from the commandline.
280 Used mainly in client tools.
281 ****************************************************************************/
283 static struct user_auth_info cmdline_auth_info = {
286 false, /* got_pass */
287 false, /* use_kerberos */
288 Undefined, /* signing state */
289 false, /* smb_encrypt */
290 false /* use machine account */
293 const char *get_cmdline_auth_info_username(void)
295 if (!cmdline_auth_info.username) {
298 return cmdline_auth_info.username;
301 void set_cmdline_auth_info_username(const char *username)
303 SAFE_FREE(cmdline_auth_info.username);
304 cmdline_auth_info.username = SMB_STRDUP(username);
305 if (!cmdline_auth_info.username) {
310 const char *get_cmdline_auth_info_password(void)
312 if (!cmdline_auth_info.password) {
315 return cmdline_auth_info.password;
318 void set_cmdline_auth_info_password(const char *password)
320 SAFE_FREE(cmdline_auth_info.password);
321 cmdline_auth_info.password = SMB_STRDUP(password);
322 if (!cmdline_auth_info.password) {
325 cmdline_auth_info.got_pass = true;
328 bool set_cmdline_auth_info_signing_state(const char *arg)
330 cmdline_auth_info.signing_state = -1;
331 if (strequal(arg, "off") || strequal(arg, "no") ||
332 strequal(arg, "false")) {
333 cmdline_auth_info.signing_state = false;
334 } else if (strequal(arg, "on") || strequal(arg, "yes") ||
335 strequal(arg, "true") || strequal(arg, "auto")) {
336 cmdline_auth_info.signing_state = true;
337 } else if (strequal(arg, "force") || strequal(arg, "required") ||
338 strequal(arg, "forced")) {
339 cmdline_auth_info.signing_state = Required;
346 int get_cmdline_auth_info_signing_state(void)
348 return cmdline_auth_info.signing_state;
351 void set_cmdline_auth_info_use_kerberos(bool b)
353 cmdline_auth_info.use_kerberos = b;
356 bool get_cmdline_auth_info_use_kerberos(void)
358 return cmdline_auth_info.use_kerberos;
361 /* This should only be used by lib/popt_common.c JRA */
362 void set_cmdline_auth_info_use_krb5_ticket(void)
364 cmdline_auth_info.use_kerberos = true;
365 cmdline_auth_info.got_pass = true;
368 /* This should only be used by lib/popt_common.c JRA */
369 void set_cmdline_auth_info_smb_encrypt(void)
371 cmdline_auth_info.smb_encrypt = true;
374 void set_cmdline_auth_info_use_machine_account(void)
376 cmdline_auth_info.use_machine_account = true;
379 bool get_cmdline_auth_info_got_pass(void)
381 return cmdline_auth_info.got_pass;
384 bool get_cmdline_auth_info_smb_encrypt(void)
386 return cmdline_auth_info.smb_encrypt;
389 bool get_cmdline_auth_info_use_machine_account(void)
391 return cmdline_auth_info.use_machine_account;
394 bool get_cmdline_auth_info_copy(struct user_auth_info *info)
396 *info = cmdline_auth_info;
397 /* Now re-alloc the strings. */
398 info->username = SMB_STRDUP(get_cmdline_auth_info_username());
399 info->password = SMB_STRDUP(get_cmdline_auth_info_password());
400 if (!info->username || !info->password) {
406 bool set_cmdline_auth_info_machine_account_creds(void)
409 char *account = NULL;
411 if (!get_cmdline_auth_info_use_machine_account()) {
415 if (!secrets_init()) {
416 d_printf("ERROR: Unable to open secrets database\n");
420 if (asprintf(&account, "%s$@%s", global_myname(), lp_realm()) < 0) {
424 pass = secrets_fetch_machine_password(lp_workgroup(), NULL, NULL);
426 d_printf("ERROR: Unable to fetch machine password for "
428 account, lp_workgroup());
433 set_cmdline_auth_info_username(account);
434 set_cmdline_auth_info_password(pass);
442 /****************************************************************************
443 Add a gid to an array of gids if it's not already there.
444 ****************************************************************************/
446 bool add_gid_to_array_unique(TALLOC_CTX *mem_ctx, gid_t gid,
447 gid_t **gids, size_t *num_gids)
451 if ((*num_gids != 0) && (*gids == NULL)) {
453 * A former call to this routine has failed to allocate memory
458 for (i=0; i<*num_gids; i++) {
459 if ((*gids)[i] == gid) {
464 *gids = TALLOC_REALLOC_ARRAY(mem_ctx, *gids, gid_t, *num_gids+1);
470 (*gids)[*num_gids] = gid;
475 /****************************************************************************
476 Like atoi but gets the value up to the separator character.
477 ****************************************************************************/
479 static const char *Atoic(const char *p, int *n, const char *c)
481 if (!isdigit((int)*p)) {
482 DEBUG(5, ("Atoic: malformed number\n"));
488 while ((*p) && isdigit((int)*p))
491 if (strchr_m(c, *p) == NULL) {
492 DEBUG(5, ("Atoic: no separator characters (%s) not found\n", c));
499 /*************************************************************************
500 Reads a list of numbers.
501 *************************************************************************/
503 const char *get_numlist(const char *p, uint32 **num, int *count)
507 if (num == NULL || count == NULL)
513 while ((p = Atoic(p, &val, ":,")) != NULL && (*p) != ':') {
514 *num = SMB_REALLOC_ARRAY((*num), uint32, (*count)+1);
518 (*num)[(*count)] = val;
526 /*******************************************************************
527 Check if a file exists - call vfs_file_exist for samba files.
528 ********************************************************************/
530 bool file_exist_stat(const char *fname,SMB_STRUCT_STAT *sbuf)
536 if (sys_stat(fname,sbuf) != 0)
539 return((S_ISREG(sbuf->st_mode)) || (S_ISFIFO(sbuf->st_mode)));
542 /*******************************************************************
543 Check if a unix domain socket exists - call vfs_file_exist for samba files.
544 ********************************************************************/
546 bool socket_exist(const char *fname)
549 if (sys_stat(fname,&st) != 0)
552 return S_ISSOCK(st.st_mode);
555 /*******************************************************************
556 Check if a directory exists.
557 ********************************************************************/
559 bool directory_exist_stat(char *dname,SMB_STRUCT_STAT *st)
567 if (sys_stat(dname,st) != 0)
570 ret = S_ISDIR(st->st_mode);
576 /*******************************************************************
577 Returns the size in bytes of the named file.
578 ********************************************************************/
580 SMB_OFF_T get_file_size(char *file_name)
584 if(sys_stat(file_name,&buf) != 0)
585 return (SMB_OFF_T)-1;
589 /*******************************************************************
590 Return a string representing an attribute for a file.
591 ********************************************************************/
593 char *attrib_string(uint16 mode)
599 if (mode & aVOLID) fstrcat(attrstr,"V");
600 if (mode & aDIR) fstrcat(attrstr,"D");
601 if (mode & aARCH) fstrcat(attrstr,"A");
602 if (mode & aHIDDEN) fstrcat(attrstr,"H");
603 if (mode & aSYSTEM) fstrcat(attrstr,"S");
604 if (mode & aRONLY) fstrcat(attrstr,"R");
606 return talloc_strdup(talloc_tos(), attrstr);
609 /*******************************************************************
610 Show a smb message structure.
611 ********************************************************************/
613 void show_msg(char *buf)
621 DEBUG(5,("size=%d\nsmb_com=0x%x\nsmb_rcls=%d\nsmb_reh=%d\nsmb_err=%d\nsmb_flg=%d\nsmb_flg2=%d\n",
623 (int)CVAL(buf,smb_com),
624 (int)CVAL(buf,smb_rcls),
625 (int)CVAL(buf,smb_reh),
626 (int)SVAL(buf,smb_err),
627 (int)CVAL(buf,smb_flg),
628 (int)SVAL(buf,smb_flg2)));
629 DEBUGADD(5,("smb_tid=%d\nsmb_pid=%d\nsmb_uid=%d\nsmb_mid=%d\n",
630 (int)SVAL(buf,smb_tid),
631 (int)SVAL(buf,smb_pid),
632 (int)SVAL(buf,smb_uid),
633 (int)SVAL(buf,smb_mid)));
634 DEBUGADD(5,("smt_wct=%d\n",(int)CVAL(buf,smb_wct)));
636 for (i=0;i<(int)CVAL(buf,smb_wct);i++)
637 DEBUGADD(5,("smb_vwv[%2d]=%5d (0x%X)\n",i,
638 SVAL(buf,smb_vwv+2*i),SVAL(buf,smb_vwv+2*i)));
640 bcc = (int)SVAL(buf,smb_vwv+2*(CVAL(buf,smb_wct)));
642 DEBUGADD(5,("smb_bcc=%d\n",bcc));
650 dump_data(10, (uint8 *)smb_buf(buf), bcc);
653 /*******************************************************************
654 Set the length and marker of an encrypted smb packet.
655 ********************************************************************/
657 void smb_set_enclen(char *buf,int len,uint16 enc_ctx_num)
659 _smb_setlen(buf,len);
663 SSVAL(buf,6,enc_ctx_num);
666 /*******************************************************************
667 Set the length and marker of an smb packet.
668 ********************************************************************/
670 void smb_setlen(char *buf,int len)
672 _smb_setlen(buf,len);
680 /*******************************************************************
681 Setup only the byte count for a smb message.
682 ********************************************************************/
684 int set_message_bcc(char *buf,int num_bytes)
686 int num_words = CVAL(buf,smb_wct);
687 SSVAL(buf,smb_vwv + num_words*SIZEOFWORD,num_bytes);
688 _smb_setlen(buf,smb_size + num_words*2 + num_bytes - 4);
689 return (smb_size + num_words*2 + num_bytes);
692 /*******************************************************************
693 Add a data blob to the end of a smb_buf, adjusting bcc and smb_len.
694 Return the bytes added
695 ********************************************************************/
697 ssize_t message_push_blob(uint8 **outbuf, DATA_BLOB blob)
699 size_t newlen = smb_len(*outbuf) + 4 + blob.length;
702 if (!(tmp = TALLOC_REALLOC_ARRAY(NULL, *outbuf, uint8, newlen))) {
703 DEBUG(0, ("talloc failed\n"));
708 memcpy(tmp + smb_len(tmp) + 4, blob.data, blob.length);
709 set_message_bcc((char *)tmp, smb_buflen(tmp) + blob.length);
713 /*******************************************************************
714 Reduce a file name, removing .. elements.
715 ********************************************************************/
717 static char *dos_clean_name(TALLOC_CTX *ctx, const char *s)
722 DEBUG(3,("dos_clean_name [%s]\n",s));
724 /* remove any double slashes */
725 str = talloc_all_string_sub(ctx, s, "\\\\", "\\");
730 /* Remove leading .\\ characters */
731 if(strncmp(str, ".\\", 2) == 0) {
732 trim_string(str, ".\\", NULL);
734 str = talloc_strdup(ctx, ".\\");
741 while ((p = strstr_m(str,"\\..\\")) != NULL) {
747 if ((p=strrchr_m(str,'\\')) != NULL) {
752 str = talloc_asprintf(ctx,
761 trim_string(str,NULL,"\\..");
762 return talloc_all_string_sub(ctx, str, "\\.\\", "\\");
765 /*******************************************************************
766 Reduce a file name, removing .. elements.
767 ********************************************************************/
769 char *unix_clean_name(TALLOC_CTX *ctx, const char *s)
774 DEBUG(3,("unix_clean_name [%s]\n",s));
776 /* remove any double slashes */
777 str = talloc_all_string_sub(ctx, s, "//","/");
782 /* Remove leading ./ characters */
783 if(strncmp(str, "./", 2) == 0) {
784 trim_string(str, "./", NULL);
786 str = talloc_strdup(ctx, "./");
793 while ((p = strstr_m(str,"/../")) != NULL) {
799 if ((p=strrchr_m(str,'/')) != NULL) {
804 str = talloc_asprintf(ctx,
813 trim_string(str,NULL,"/..");
814 return talloc_all_string_sub(ctx, str, "/./", "/");
817 char *clean_name(TALLOC_CTX *ctx, const char *s)
819 char *str = dos_clean_name(ctx, s);
823 return unix_clean_name(ctx, str);
826 /*******************************************************************
827 Close the low 3 fd's and open dev/null in their place.
828 ********************************************************************/
830 void close_low_fds(bool stderr_too)
842 /* try and use up these file descriptors, so silly
843 library routines writing to stdout etc won't cause havoc */
845 if (i == 2 && !stderr_too)
848 fd = sys_open("/dev/null",O_RDWR,0);
850 fd = sys_open("/dev/null",O_WRONLY,0);
852 DEBUG(0,("Can't open /dev/null\n"));
856 DEBUG(0,("Didn't get file descriptor %d\n",i));
863 /*******************************************************************
864 Write data into an fd at a given offset. Ignore seek errors.
865 ********************************************************************/
867 ssize_t write_data_at_offset(int fd, const char *buffer, size_t N, SMB_OFF_T pos)
872 if (pos == (SMB_OFF_T)-1) {
873 return write_data(fd, buffer, N);
875 #if defined(HAVE_PWRITE) || defined(HAVE_PRWITE64)
877 ret = sys_pwrite(fd,buffer + total,N - total, pos);
878 if (ret == -1 && errno == ESPIPE) {
879 return write_data(fd, buffer + total,N - total);
882 DEBUG(0,("write_data_at_offset: write failure. Error = %s\n", strerror(errno) ));
891 return (ssize_t)total;
893 /* Use lseek and write_data. */
894 if (sys_lseek(fd, pos, SEEK_SET) == -1) {
895 if (errno != ESPIPE) {
899 return write_data(fd, buffer, N);
903 /*******************************************************************
904 Sleep for a specified number of milliseconds.
905 ********************************************************************/
907 void smb_msleep(unsigned int t)
909 #if defined(HAVE_NANOSLEEP)
910 struct timespec tval;
913 tval.tv_sec = t/1000;
914 tval.tv_nsec = 1000000*(t%1000);
918 ret = nanosleep(&tval, &tval);
919 } while (ret < 0 && errno == EINTR && (tval.tv_sec > 0 || tval.tv_nsec > 0));
921 unsigned int tdiff=0;
922 struct timeval tval,t1,t2;
929 tval.tv_sec = (t-tdiff)/1000;
930 tval.tv_usec = 1000*((t-tdiff)%1000);
932 /* Never wait for more than 1 sec. */
933 if (tval.tv_sec > 1) {
940 sys_select_intr(0,&fds,NULL,NULL,&tval);
943 if (t2.tv_sec < t1.tv_sec) {
944 /* Someone adjusted time... */
948 tdiff = TvalDiff(&t1,&t2);
953 /****************************************************************************
954 Become a daemon, discarding the controlling terminal.
955 ****************************************************************************/
957 void become_daemon(bool Fork, bool no_process_group)
965 /* detach from the terminal */
967 if (!no_process_group) setsid();
968 #elif defined(TIOCNOTTY)
969 if (!no_process_group) {
970 int i = sys_open("/dev/tty", O_RDWR, 0);
972 ioctl(i, (int) TIOCNOTTY, (char *)0);
976 #endif /* HAVE_SETSID */
978 /* Close fd's 0,1,2. Needed if started by rsh */
979 close_low_fds(False); /* Don't close stderr, let the debug system
980 attach it to the logfile */
983 bool reinit_after_fork(struct messaging_context *msg_ctx,
984 bool parent_longlived)
988 /* Reset the state of the random
989 * number generation system, so
990 * children do not get the same random
991 * numbers as each other */
992 set_need_random_reseed();
994 /* tdb needs special fork handling */
995 if (tdb_reopen_all(parent_longlived ? 1 : 0) == -1) {
996 DEBUG(0,("tdb_reopen_all failed.\n"));
1001 * For clustering, we need to re-init our ctdbd connection after the
1004 status = messaging_reinit(msg_ctx);
1005 if (!NT_STATUS_IS_OK(status)) {
1006 DEBUG(0,("messaging_reinit() failed: %s\n",
1007 nt_errstr(status)));
1014 /****************************************************************************
1015 Put up a yes/no prompt.
1016 ****************************************************************************/
1018 bool yesno(const char *p)
1023 if (!fgets(ans,sizeof(ans)-1,stdin))
1026 if (*ans == 'y' || *ans == 'Y')
1032 #if defined(PARANOID_MALLOC_CHECKER)
1034 /****************************************************************************
1035 Internal malloc wrapper. Externally visible.
1036 ****************************************************************************/
1038 void *malloc_(size_t size)
1044 return malloc(size);
1045 #define malloc(s) __ERROR_DONT_USE_MALLOC_DIRECTLY
1048 /****************************************************************************
1049 Internal calloc wrapper. Not externally visible.
1050 ****************************************************************************/
1052 static void *calloc_(size_t count, size_t size)
1054 if (size == 0 || count == 0) {
1058 return calloc(count, size);
1059 #define calloc(n,s) __ERROR_DONT_USE_CALLOC_DIRECTLY
1062 /****************************************************************************
1063 Internal realloc wrapper. Not externally visible.
1064 ****************************************************************************/
1066 static void *realloc_(void *ptr, size_t size)
1069 return realloc(ptr, size);
1070 #define realloc(p,s) __ERROR_DONT_USE_RELLOC_DIRECTLY
1073 #endif /* PARANOID_MALLOC_CHECKER */
1075 /****************************************************************************
1077 ****************************************************************************/
1079 void *malloc_array(size_t el_size, unsigned int count)
1081 if (count >= MAX_ALLOC_SIZE/el_size) {
1085 if (el_size == 0 || count == 0) {
1088 #if defined(PARANOID_MALLOC_CHECKER)
1089 return malloc_(el_size*count);
1091 return malloc(el_size*count);
1095 /****************************************************************************
1097 ****************************************************************************/
1099 void *memalign_array(size_t el_size, size_t align, unsigned int count)
1101 if (count >= MAX_ALLOC_SIZE/el_size) {
1105 return sys_memalign(align, el_size*count);
1108 /****************************************************************************
1110 ****************************************************************************/
1112 void *calloc_array(size_t size, size_t nmemb)
1114 if (nmemb >= MAX_ALLOC_SIZE/size) {
1117 if (size == 0 || nmemb == 0) {
1120 #if defined(PARANOID_MALLOC_CHECKER)
1121 return calloc_(nmemb, size);
1123 return calloc(nmemb, size);
1127 /****************************************************************************
1128 Expand a pointer to be a particular size.
1129 Note that this version of Realloc has an extra parameter that decides
1130 whether to free the passed in storage on allocation failure or if the
1133 This is designed for use in the typical idiom of :
1135 p = SMB_REALLOC(p, size)
1140 and not to have to keep track of the old 'p' contents to free later, nor
1141 to worry if the size parameter was zero. In the case where NULL is returned
1142 we guarentee that p has been freed.
1144 If free later semantics are desired, then pass 'free_old_on_error' as False which
1145 guarentees that the old contents are not freed on error, even if size == 0. To use
1148 tmp = SMB_REALLOC_KEEP_OLD_ON_ERROR(p, size);
1156 Changes were instigated by Coverity error checking. JRA.
1157 ****************************************************************************/
1159 void *Realloc(void *p, size_t size, bool free_old_on_error)
1164 if (free_old_on_error) {
1167 DEBUG(2,("Realloc asked for 0 bytes\n"));
1171 #if defined(PARANOID_MALLOC_CHECKER)
1173 ret = (void *)malloc_(size);
1175 ret = (void *)realloc_(p,size);
1179 ret = (void *)malloc(size);
1181 ret = (void *)realloc(p,size);
1186 if (free_old_on_error && p) {
1189 DEBUG(0,("Memory allocation error: failed to expand to %d bytes\n",(int)size));
1195 /****************************************************************************
1197 ****************************************************************************/
1199 void *realloc_array(void *p, size_t el_size, unsigned int count, bool free_old_on_error)
1201 if (count >= MAX_ALLOC_SIZE/el_size) {
1202 if (free_old_on_error) {
1207 return Realloc(p, el_size*count, free_old_on_error);
1210 /****************************************************************************
1211 (Hopefully) efficient array append.
1212 ****************************************************************************/
1214 void add_to_large_array(TALLOC_CTX *mem_ctx, size_t element_size,
1215 void *element, void *_array, uint32 *num_elements,
1216 ssize_t *array_size)
1218 void **array = (void **)_array;
1220 if (*array_size < 0) {
1224 if (*array == NULL) {
1225 if (*array_size == 0) {
1229 if (*array_size >= MAX_ALLOC_SIZE/element_size) {
1233 *array = TALLOC(mem_ctx, element_size * (*array_size));
1234 if (*array == NULL) {
1239 if (*num_elements == *array_size) {
1242 if (*array_size >= MAX_ALLOC_SIZE/element_size) {
1246 *array = TALLOC_REALLOC(mem_ctx, *array,
1247 element_size * (*array_size));
1249 if (*array == NULL) {
1254 memcpy((char *)(*array) + element_size*(*num_elements),
1255 element, element_size);
1265 /****************************************************************************
1266 Free memory, checks for NULL.
1267 Use directly SAFE_FREE()
1268 Exists only because we need to pass a function pointer somewhere --SSS
1269 ****************************************************************************/
1271 void safe_free(void *p)
1276 /****************************************************************************
1277 Get my own name and IP.
1278 ****************************************************************************/
1280 char *talloc_get_myname(TALLOC_CTX *ctx)
1283 char hostname[HOST_NAME_MAX];
1287 /* get my host name */
1288 if (gethostname(hostname, sizeof(hostname)) == -1) {
1289 DEBUG(0,("gethostname failed\n"));
1293 /* Ensure null termination. */
1294 hostname[sizeof(hostname)-1] = '\0';
1296 /* split off any parts after an initial . */
1297 p = strchr_m(hostname,'.');
1302 return talloc_strdup(ctx, hostname);
1305 /****************************************************************************
1306 Get my own domain name, or "" if we have none.
1307 ****************************************************************************/
1309 char *get_mydnsdomname(TALLOC_CTX *ctx)
1311 const char *domname;
1314 domname = get_mydnsfullname();
1319 p = strchr_m(domname, '.');
1322 return talloc_strdup(ctx, p);
1324 return talloc_strdup(ctx, "");
1328 /****************************************************************************
1329 Interpret a protocol description string, with a default.
1330 ****************************************************************************/
1332 int interpret_protocol(const char *str,int def)
1334 if (strequal(str,"NT1"))
1335 return(PROTOCOL_NT1);
1336 if (strequal(str,"LANMAN2"))
1337 return(PROTOCOL_LANMAN2);
1338 if (strequal(str,"LANMAN1"))
1339 return(PROTOCOL_LANMAN1);
1340 if (strequal(str,"CORE"))
1341 return(PROTOCOL_CORE);
1342 if (strequal(str,"COREPLUS"))
1343 return(PROTOCOL_COREPLUS);
1344 if (strequal(str,"CORE+"))
1345 return(PROTOCOL_COREPLUS);
1347 DEBUG(0,("Unrecognised protocol level %s\n",str));
1353 #if (defined(HAVE_NETGROUP) && defined(WITH_AUTOMOUNT))
1354 /******************************************************************
1355 Remove any mount options such as -rsize=2048,wsize=2048 etc.
1356 Based on a fix from <Thomas.Hepper@icem.de>.
1357 Returns a malloc'ed string.
1358 *******************************************************************/
1360 static char *strip_mount_options(TALLOC_CTX *ctx, const char *str)
1363 const char *p = str;
1364 while(*p && !isspace(*p))
1366 while(*p && isspace(*p))
1369 return talloc_strdup(ctx, p);
1375 /*******************************************************************
1376 Patch from jkf@soton.ac.uk
1377 Split Luke's automount_server into YP lookup and string splitter
1378 so can easily implement automount_path().
1379 Returns a malloc'ed string.
1380 *******************************************************************/
1382 #ifdef WITH_NISPLUS_HOME
1383 char *automount_lookup(TALLOC_CTX *ctx, const char *user_name)
1387 char *nis_map = (char *)lp_nis_home_map_name();
1389 char buffer[NIS_MAXATTRVAL + 1];
1394 snprintf(buffer, sizeof(buffer), "[key=%s],%s", user_name, nis_map);
1395 DEBUG(5, ("NIS+ querystring: %s\n", buffer));
1397 if (result = nis_list(buffer, FOLLOW_PATH|EXPAND_NAME|HARD_LOOKUP, NULL, NULL)) {
1398 if (result->status != NIS_SUCCESS) {
1399 DEBUG(3, ("NIS+ query failed: %s\n", nis_sperrno(result->status)));
1401 object = result->objects.objects_val;
1402 if (object->zo_data.zo_type == ENTRY_OBJ) {
1403 entry = &object->zo_data.objdata_u.en_data;
1404 DEBUG(5, ("NIS+ entry type: %s\n", entry->en_type));
1405 DEBUG(3, ("NIS+ result: %s\n", entry->en_cols.en_cols_val[1].ec_value.ec_value_val));
1407 value = talloc_strdup(ctx,
1408 entry->en_cols.en_cols_val[1].ec_value.ec_value_val);
1410 nis_freeresult(result);
1413 value = talloc_string_sub(ctx,
1420 nis_freeresult(result);
1423 value = strip_mount_options(ctx, value);
1424 DEBUG(4, ("NIS+ Lookup: %s resulted in %s\n",
1429 #else /* WITH_NISPLUS_HOME */
1431 char *automount_lookup(TALLOC_CTX *ctx, const char *user_name)
1435 int nis_error; /* returned by yp all functions */
1436 char *nis_result; /* yp_match inits this */
1437 int nis_result_len; /* and set this */
1438 char *nis_domain; /* yp_get_default_domain inits this */
1439 char *nis_map = (char *)lp_nis_home_map_name();
1441 if ((nis_error = yp_get_default_domain(&nis_domain)) != 0) {
1442 DEBUG(3, ("YP Error: %s\n", yperr_string(nis_error)));
1446 DEBUG(5, ("NIS Domain: %s\n", nis_domain));
1448 if ((nis_error = yp_match(nis_domain, nis_map, user_name,
1449 strlen(user_name), &nis_result,
1450 &nis_result_len)) == 0) {
1451 value = talloc_strdup(ctx, nis_result);
1455 value = strip_mount_options(ctx, value);
1456 } else if(nis_error == YPERR_KEY) {
1457 DEBUG(3, ("YP Key not found: while looking up \"%s\" in map \"%s\"\n",
1458 user_name, nis_map));
1459 DEBUG(3, ("using defaults for server and home directory\n"));
1461 DEBUG(3, ("YP Error: \"%s\" while looking up \"%s\" in map \"%s\"\n",
1462 yperr_string(nis_error), user_name, nis_map));
1466 DEBUG(4, ("YP Lookup: %s resulted in %s\n", user_name, value));
1470 #endif /* WITH_NISPLUS_HOME */
1473 /****************************************************************************
1474 Check if a process exists. Does this work on all unixes?
1475 ****************************************************************************/
1477 bool process_exists(const struct server_id pid)
1479 if (procid_is_me(&pid)) {
1483 if (procid_is_local(&pid)) {
1484 return (kill(pid.pid,0) == 0 || errno != ESRCH);
1487 #ifdef CLUSTER_SUPPORT
1488 return ctdbd_process_exists(messaging_ctdbd_connection(), pid.vnn,
1495 /*******************************************************************
1496 Convert a uid into a user name.
1497 ********************************************************************/
1499 const char *uidtoname(uid_t uid)
1501 TALLOC_CTX *ctx = talloc_tos();
1503 struct passwd *pass = NULL;
1505 pass = getpwuid_alloc(ctx,uid);
1507 name = talloc_strdup(ctx,pass->pw_name);
1510 name = talloc_asprintf(ctx,
1517 /*******************************************************************
1518 Convert a gid into a group name.
1519 ********************************************************************/
1521 char *gidtoname(gid_t gid)
1525 grp = getgrgid(gid);
1527 return talloc_strdup(talloc_tos(), grp->gr_name);
1530 return talloc_asprintf(talloc_tos(),
1536 /*******************************************************************
1537 Convert a user name into a uid.
1538 ********************************************************************/
1540 uid_t nametouid(const char *name)
1542 struct passwd *pass;
1546 pass = getpwnam_alloc(NULL, name);
1553 u = (uid_t)strtol(name, &p, 0);
1554 if ((p != name) && (*p == '\0'))
1560 /*******************************************************************
1561 Convert a name to a gid_t if possible. Return -1 if not a group.
1562 ********************************************************************/
1564 gid_t nametogid(const char *name)
1570 g = (gid_t)strtol(name, &p, 0);
1571 if ((p != name) && (*p == '\0'))
1574 grp = sys_getgrnam(name);
1576 return(grp->gr_gid);
1580 /*******************************************************************
1581 Something really nasty happened - panic !
1582 ********************************************************************/
1584 void smb_panic(const char *const why)
1592 if (global_clobber_region_function) {
1593 DEBUG(0,("smb_panic: clobber_region() last called from [%s(%u)]\n",
1594 global_clobber_region_function,
1595 global_clobber_region_line));
1600 DEBUG(0,("PANIC (pid %llu): %s\n",
1601 (unsigned long long)sys_getpid(), why));
1604 cmd = lp_panic_action();
1606 DEBUG(0, ("smb_panic(): calling panic action [%s]\n", cmd));
1607 result = system(cmd);
1610 DEBUG(0, ("smb_panic(): fork failed in panic action: %s\n",
1613 DEBUG(0, ("smb_panic(): action returned status %d\n",
1614 WEXITSTATUS(result)));
1620 /*******************************************************************
1621 Print a backtrace of the stack to the debug log. This function
1622 DELIBERATELY LEAKS MEMORY. The expectation is that you should
1623 exit shortly after calling it.
1624 ********************************************************************/
1626 #ifdef HAVE_LIBUNWIND_H
1627 #include <libunwind.h>
1630 #ifdef HAVE_EXECINFO_H
1631 #include <execinfo.h>
1634 #ifdef HAVE_LIBEXC_H
1638 void log_stack_trace(void)
1640 #ifdef HAVE_LIBUNWIND
1641 /* Try to use libunwind before any other technique since on ia64
1642 * libunwind correctly walks the stack in more circumstances than
1645 unw_cursor_t cursor;
1650 unw_word_t ip, sp, off;
1652 procname[sizeof(procname) - 1] = '\0';
1654 if (unw_getcontext(&uc) != 0) {
1655 goto libunwind_failed;
1658 if (unw_init_local(&cursor, &uc) != 0) {
1659 goto libunwind_failed;
1662 DEBUG(0, ("BACKTRACE:\n"));
1666 unw_get_reg(&cursor, UNW_REG_IP, &ip);
1667 unw_get_reg(&cursor, UNW_REG_SP, &sp);
1669 switch (unw_get_proc_name(&cursor,
1670 procname, sizeof(procname) - 1, &off) ) {
1674 /* Name truncated. */
1675 DEBUGADD(0, (" #%u %s + %#llx [ip=%#llx] [sp=%#llx]\n",
1676 i, procname, (long long)off,
1677 (long long)ip, (long long) sp));
1680 /* case -UNW_ENOINFO: */
1681 /* case -UNW_EUNSPEC: */
1682 /* No symbol name found. */
1683 DEBUGADD(0, (" #%u %s [ip=%#llx] [sp=%#llx]\n",
1684 i, "<unknown symbol>",
1685 (long long)ip, (long long) sp));
1688 } while (unw_step(&cursor) > 0);
1693 DEBUG(0, ("unable to produce a stack trace with libunwind\n"));
1695 #elif HAVE_BACKTRACE_SYMBOLS
1696 void *backtrace_stack[BACKTRACE_STACK_SIZE];
1697 size_t backtrace_size;
1698 char **backtrace_strings;
1700 /* get the backtrace (stack frames) */
1701 backtrace_size = backtrace(backtrace_stack,BACKTRACE_STACK_SIZE);
1702 backtrace_strings = backtrace_symbols(backtrace_stack, backtrace_size);
1704 DEBUG(0, ("BACKTRACE: %lu stack frames:\n",
1705 (unsigned long)backtrace_size));
1707 if (backtrace_strings) {
1710 for (i = 0; i < backtrace_size; i++)
1711 DEBUGADD(0, (" #%u %s\n", i, backtrace_strings[i]));
1713 /* Leak the backtrace_strings, rather than risk what free() might do */
1718 /* The IRIX libexc library provides an API for unwinding the stack. See
1719 * libexc(3) for details. Apparantly trace_back_stack leaks memory, but
1720 * since we are about to abort anyway, it hardly matters.
1723 #define NAMESIZE 32 /* Arbitrary */
1725 __uint64_t addrs[BACKTRACE_STACK_SIZE];
1726 char * names[BACKTRACE_STACK_SIZE];
1727 char namebuf[BACKTRACE_STACK_SIZE * NAMESIZE];
1734 ZERO_ARRAY(namebuf);
1736 /* We need to be root so we can open our /proc entry to walk
1737 * our stack. It also helps when we want to dump core.
1741 for (i = 0; i < BACKTRACE_STACK_SIZE; i++) {
1742 names[i] = namebuf + (i * NAMESIZE);
1745 levels = trace_back_stack(0, addrs, names,
1746 BACKTRACE_STACK_SIZE, NAMESIZE - 1);
1748 DEBUG(0, ("BACKTRACE: %d stack frames:\n", levels));
1749 for (i = 0; i < levels; i++) {
1750 DEBUGADD(0, (" #%d 0x%llx %s\n", i, addrs[i], names[i]));
1755 DEBUG(0, ("unable to produce a stack trace on this platform\n"));
1759 /*******************************************************************
1760 A readdir wrapper which just returns the file name.
1761 ********************************************************************/
1763 const char *readdirname(SMB_STRUCT_DIR *p)
1765 SMB_STRUCT_DIRENT *ptr;
1771 ptr = (SMB_STRUCT_DIRENT *)sys_readdir(p);
1775 dname = ptr->d_name;
1782 #ifdef HAVE_BROKEN_READDIR_NAME
1783 /* using /usr/ucb/cc is BAD */
1787 return talloc_strdup(talloc_tos(), dname);
1790 /*******************************************************************
1791 Utility function used to decide if the last component
1792 of a path matches a (possibly wildcarded) entry in a namelist.
1793 ********************************************************************/
1795 bool is_in_path(const char *name, name_compare_entry *namelist, bool case_sensitive)
1797 const char *last_component;
1799 /* if we have no list it's obviously not in the path */
1800 if((namelist == NULL ) || ((namelist != NULL) && (namelist[0].name == NULL))) {
1804 DEBUG(8, ("is_in_path: %s\n", name));
1806 /* Get the last component of the unix name. */
1807 last_component = strrchr_m(name, '/');
1808 if (!last_component) {
1809 last_component = name;
1811 last_component++; /* Go past '/' */
1814 for(; namelist->name != NULL; namelist++) {
1815 if(namelist->is_wild) {
1816 if (mask_match(last_component, namelist->name, case_sensitive)) {
1817 DEBUG(8,("is_in_path: mask match succeeded\n"));
1821 if((case_sensitive && (strcmp(last_component, namelist->name) == 0))||
1822 (!case_sensitive && (StrCaseCmp(last_component, namelist->name) == 0))) {
1823 DEBUG(8,("is_in_path: match succeeded\n"));
1828 DEBUG(8,("is_in_path: match not found\n"));
1832 /*******************************************************************
1833 Strip a '/' separated list into an array of
1834 name_compare_enties structures suitable for
1835 passing to is_in_path(). We do this for
1836 speed so we can pre-parse all the names in the list
1837 and don't do it for each call to is_in_path().
1838 namelist is modified here and is assumed to be
1839 a copy owned by the caller.
1840 We also check if the entry contains a wildcard to
1841 remove a potentially expensive call to mask_match
1843 ********************************************************************/
1845 void set_namearray(name_compare_entry **ppname_array, const char *namelist)
1848 const char *nameptr = namelist;
1849 int num_entries = 0;
1852 (*ppname_array) = NULL;
1854 if((nameptr == NULL ) || ((nameptr != NULL) && (*nameptr == '\0')))
1857 /* We need to make two passes over the string. The
1858 first to count the number of elements, the second
1863 if ( *nameptr == '/' ) {
1864 /* cope with multiple (useless) /s) */
1868 /* find the next / */
1869 name_end = strchr_m(nameptr, '/');
1871 /* oops - the last check for a / didn't find one. */
1872 if (name_end == NULL)
1875 /* next segment please */
1876 nameptr = name_end + 1;
1880 if(num_entries == 0)
1883 if(( (*ppname_array) = SMB_MALLOC_ARRAY(name_compare_entry, num_entries + 1)) == NULL) {
1884 DEBUG(0,("set_namearray: malloc fail\n"));
1888 /* Now copy out the names */
1892 if ( *nameptr == '/' ) {
1893 /* cope with multiple (useless) /s) */
1897 /* find the next / */
1898 if ((name_end = strchr_m(nameptr, '/')) != NULL)
1901 /* oops - the last check for a / didn't find one. */
1902 if(name_end == NULL)
1905 (*ppname_array)[i].is_wild = ms_has_wild(nameptr);
1906 if(((*ppname_array)[i].name = SMB_STRDUP(nameptr)) == NULL) {
1907 DEBUG(0,("set_namearray: malloc fail (1)\n"));
1911 /* next segment please */
1912 nameptr = name_end + 1;
1916 (*ppname_array)[i].name = NULL;
1921 /****************************************************************************
1922 Routine to free a namearray.
1923 ****************************************************************************/
1925 void free_namearray(name_compare_entry *name_array)
1929 if(name_array == NULL)
1932 for(i=0; name_array[i].name!=NULL; i++)
1933 SAFE_FREE(name_array[i].name);
1934 SAFE_FREE(name_array);
1938 #define DBGC_CLASS DBGC_LOCKING
1940 /****************************************************************************
1941 Simple routine to query existing file locks. Cruft in NFS and 64->32 bit mapping
1942 is dealt with in posix.c
1943 Returns True if we have information regarding this lock region (and returns
1944 F_UNLCK in *ptype if the region is unlocked). False if the call failed.
1945 ****************************************************************************/
1947 bool fcntl_getlock(int fd, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype, pid_t *ppid)
1949 SMB_STRUCT_FLOCK lock;
1952 DEBUG(8,("fcntl_getlock fd=%d offset=%.0f count=%.0f type=%d\n",
1953 fd,(double)*poffset,(double)*pcount,*ptype));
1955 lock.l_type = *ptype;
1956 lock.l_whence = SEEK_SET;
1957 lock.l_start = *poffset;
1958 lock.l_len = *pcount;
1961 ret = sys_fcntl_ptr(fd,SMB_F_GETLK,&lock);
1965 DEBUG(3,("fcntl_getlock: lock request failed at offset %.0f count %.0f type %d (%s)\n",
1966 (double)*poffset,(double)*pcount,*ptype,strerror(errno)));
1971 *ptype = lock.l_type;
1972 *poffset = lock.l_start;
1973 *pcount = lock.l_len;
1976 DEBUG(3,("fcntl_getlock: fd %d is returned info %d pid %u\n",
1977 fd, (int)lock.l_type, (unsigned int)lock.l_pid));
1982 #define DBGC_CLASS DBGC_ALL
1984 /*******************************************************************
1985 Is the name specified one of my netbios names.
1986 Returns true if it is equal, false otherwise.
1987 ********************************************************************/
1989 bool is_myname(const char *s)
1994 for (n=0; my_netbios_names(n); n++) {
1995 if (strequal(my_netbios_names(n), s)) {
2000 DEBUG(8, ("is_myname(\"%s\") returns %d\n", s, ret));
2004 /*******************************************************************
2005 Is the name specified our workgroup/domain.
2006 Returns true if it is equal, false otherwise.
2007 ********************************************************************/
2009 bool is_myworkgroup(const char *s)
2013 if (strequal(s, lp_workgroup())) {
2017 DEBUG(8, ("is_myworkgroup(\"%s\") returns %d\n", s, ret));
2021 /*******************************************************************
2022 we distinguish between 2K and XP by the "Native Lan Manager" string
2023 WinXP => "Windows 2002 5.1"
2024 WinXP 64bit => "Windows XP 5.2"
2025 Win2k => "Windows 2000 5.0"
2026 NT4 => "Windows NT 4.0"
2027 Win9x => "Windows 4.0"
2028 Windows 2003 doesn't set the native lan manager string but
2029 they do set the domain to "Windows 2003 5.2" (probably a bug).
2030 ********************************************************************/
2032 void ra_lanman_string( const char *native_lanman )
2034 if ( strcmp( native_lanman, "Windows 2002 5.1" ) == 0 )
2035 set_remote_arch( RA_WINXP );
2036 else if ( strcmp( native_lanman, "Windows XP 5.2" ) == 0 )
2037 set_remote_arch( RA_WINXP64 );
2038 else if ( strcmp( native_lanman, "Windows Server 2003 5.2" ) == 0 )
2039 set_remote_arch( RA_WIN2K3 );
2042 static const char *remote_arch_str;
2044 const char *get_remote_arch_str(void)
2046 if (!remote_arch_str) {
2049 return remote_arch_str;
2052 /*******************************************************************
2053 Set the horrid remote_arch string based on an enum.
2054 ********************************************************************/
2056 void set_remote_arch(enum remote_arch_types type)
2061 remote_arch_str = "WfWg";
2064 remote_arch_str = "OS2";
2067 remote_arch_str = "Win95";
2070 remote_arch_str = "WinNT";
2073 remote_arch_str = "Win2K";
2076 remote_arch_str = "WinXP";
2079 remote_arch_str = "WinXP64";
2082 remote_arch_str = "Win2K3";
2085 remote_arch_str = "Vista";
2088 remote_arch_str = "Samba";
2091 remote_arch_str = "CIFSFS";
2094 ra_type = RA_UNKNOWN;
2095 remote_arch_str = "UNKNOWN";
2099 DEBUG(10,("set_remote_arch: Client arch is \'%s\'\n",
2103 /*******************************************************************
2104 Get the remote_arch type.
2105 ********************************************************************/
2107 enum remote_arch_types get_remote_arch(void)
2112 const char *tab_depth(int level, int depth)
2114 if( CHECK_DEBUGLVL(level) ) {
2115 dbgtext("%*s", depth*4, "");
2120 /*****************************************************************************
2121 Provide a checksum on a string
2123 Input: s - the null-terminated character string for which the checksum
2126 Output: The checksum value calculated for s.
2127 *****************************************************************************/
2129 int str_checksum(const char *s)
2137 res ^= (c << (i % 15)) ^ (c >> (15-(i%15)));
2144 /*****************************************************************
2145 Zero a memory area then free it. Used to catch bugs faster.
2146 *****************************************************************/
2148 void zero_free(void *p, size_t size)
2154 /*****************************************************************
2155 Set our open file limit to a requested max and return the limit.
2156 *****************************************************************/
2158 int set_maxfiles(int requested_max)
2160 #if (defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE))
2162 int saved_current_limit;
2164 if(getrlimit(RLIMIT_NOFILE, &rlp)) {
2165 DEBUG(0,("set_maxfiles: getrlimit (1) for RLIMIT_NOFILE failed with error %s\n",
2168 return requested_max;
2172 * Set the fd limit to be real_max_open_files + MAX_OPEN_FUDGEFACTOR to
2173 * account for the extra fd we need
2174 * as well as the log files and standard
2175 * handles etc. Save the limit we want to set in case
2176 * we are running on an OS that doesn't support this limit (AIX)
2177 * which always returns RLIM_INFINITY for rlp.rlim_max.
2180 /* Try raising the hard (max) limit to the requested amount. */
2182 #if defined(RLIM_INFINITY)
2183 if (rlp.rlim_max != RLIM_INFINITY) {
2184 int orig_max = rlp.rlim_max;
2186 if ( rlp.rlim_max < requested_max )
2187 rlp.rlim_max = requested_max;
2189 /* This failing is not an error - many systems (Linux) don't
2190 support our default request of 10,000 open files. JRA. */
2192 if(setrlimit(RLIMIT_NOFILE, &rlp)) {
2193 DEBUG(3,("set_maxfiles: setrlimit for RLIMIT_NOFILE for %d max files failed with error %s\n",
2194 (int)rlp.rlim_max, strerror(errno) ));
2196 /* Set failed - restore original value from get. */
2197 rlp.rlim_max = orig_max;
2202 /* Now try setting the soft (current) limit. */
2204 saved_current_limit = rlp.rlim_cur = MIN(requested_max,rlp.rlim_max);
2206 if(setrlimit(RLIMIT_NOFILE, &rlp)) {
2207 DEBUG(0,("set_maxfiles: setrlimit for RLIMIT_NOFILE for %d files failed with error %s\n",
2208 (int)rlp.rlim_cur, strerror(errno) ));
2210 return saved_current_limit;
2213 if(getrlimit(RLIMIT_NOFILE, &rlp)) {
2214 DEBUG(0,("set_maxfiles: getrlimit (2) for RLIMIT_NOFILE failed with error %s\n",
2217 return saved_current_limit;
2220 #if defined(RLIM_INFINITY)
2221 if(rlp.rlim_cur == RLIM_INFINITY)
2222 return saved_current_limit;
2225 if((int)rlp.rlim_cur > saved_current_limit)
2226 return saved_current_limit;
2228 return rlp.rlim_cur;
2229 #else /* !defined(HAVE_GETRLIMIT) || !defined(RLIMIT_NOFILE) */
2231 * No way to know - just guess...
2233 return requested_max;
2237 /*****************************************************************
2238 Possibly replace mkstemp if it is broken.
2239 *****************************************************************/
2241 int smb_mkstemp(char *name_template)
2243 #if HAVE_SECURE_MKSTEMP
2244 return mkstemp(name_template);
2246 /* have a reasonable go at emulating it. Hope that
2247 the system mktemp() isn't completly hopeless */
2248 char *p = mktemp(name_template);
2251 return open(p, O_CREAT|O_EXCL|O_RDWR, 0600);
2255 /*****************************************************************
2256 malloc that aborts with smb_panic on fail or zero size.
2257 *****************************************************************/
2259 void *smb_xmalloc_array(size_t size, unsigned int count)
2263 smb_panic("smb_xmalloc_array: called with zero size");
2265 if (count >= MAX_ALLOC_SIZE/size) {
2266 smb_panic("smb_xmalloc_array: alloc size too large");
2268 if ((p = SMB_MALLOC(size*count)) == NULL) {
2269 DEBUG(0, ("smb_xmalloc_array failed to allocate %lu * %lu bytes\n",
2270 (unsigned long)size, (unsigned long)count));
2271 smb_panic("smb_xmalloc_array: malloc failed");
2277 vasprintf that aborts on malloc fail
2280 int smb_xvasprintf(char **ptr, const char *format, va_list ap)
2287 n = vasprintf(ptr, format, ap2);
2288 if (n == -1 || ! *ptr) {
2289 smb_panic("smb_xvasprintf: out of memory");
2295 /*****************************************************************
2296 Get local hostname and cache result.
2297 *****************************************************************/
2299 char *myhostname(void)
2303 /* This is cached forever so
2304 * use NULL talloc ctx. */
2305 ret = talloc_get_myname(NULL);
2310 /*****************************************************************
2311 A useful function for returning a path in the Samba pid directory.
2312 *****************************************************************/
2314 static char *xx_path(const char *name, const char *rootpath)
2318 fname = talloc_strdup(talloc_tos(), rootpath);
2322 trim_string(fname,"","/");
2324 if (!directory_exist(fname)) {
2328 return talloc_asprintf(talloc_tos(),
2334 /*****************************************************************
2335 A useful function for returning a path in the Samba lock directory.
2336 *****************************************************************/
2338 char *lock_path(const char *name)
2340 return xx_path(name, lp_lockdir());
2343 /*****************************************************************
2344 A useful function for returning a path in the Samba pid directory.
2345 *****************************************************************/
2347 char *pid_path(const char *name)
2349 return xx_path(name, lp_piddir());
2353 * @brief Returns an absolute path to a file in the Samba lib directory.
2355 * @param name File to find, relative to LIBDIR.
2357 * @retval Pointer to a string containing the full path.
2360 char *lib_path(const char *name)
2362 return talloc_asprintf(talloc_tos(), "%s/%s", get_dyn_LIBDIR(), name);
2366 * @brief Returns an absolute path to a file in the Samba modules directory.
2368 * @param name File to find, relative to MODULESDIR.
2370 * @retval Pointer to a string containing the full path.
2373 char *modules_path(const char *name)
2375 return talloc_asprintf(talloc_tos(), "%s/%s", get_dyn_MODULESDIR(), name);
2379 * @brief Returns an absolute path to a file in the Samba data directory.
2381 * @param name File to find, relative to CODEPAGEDIR.
2383 * @retval Pointer to a talloc'ed string containing the full path.
2386 char *data_path(const char *name)
2388 return talloc_asprintf(talloc_tos(), "%s/%s", get_dyn_CODEPAGEDIR(), name);
2391 /*****************************************************************
2392 a useful function for returning a path in the Samba state directory
2393 *****************************************************************/
2395 char *state_path(const char *name)
2397 return xx_path(name, get_dyn_STATEDIR());
2401 * @brief Returns the platform specific shared library extension.
2403 * @retval Pointer to a const char * containing the extension.
2406 const char *shlib_ext(void)
2408 return get_dyn_SHLIBEXT();
2411 /*******************************************************************
2412 Given a filename - get its directory name
2413 NB: Returned in static storage. Caveats:
2414 o If caller wishes to preserve, they should copy.
2415 ********************************************************************/
2417 char *parent_dirname(const char *path)
2421 if (!parent_dirname_talloc(talloc_tos(), path, &parent, NULL)) {
2428 bool parent_dirname_talloc(TALLOC_CTX *mem_ctx, const char *dir,
2429 char **parent, const char **name)
2434 p = strrchr_m(dir, '/'); /* Find final '/', if any */
2437 if (!(*parent = talloc_strdup(mem_ctx, "."))) {
2448 if (!(*parent = TALLOC_ARRAY(mem_ctx, char, len+1))) {
2451 memcpy(*parent, dir, len);
2452 (*parent)[len] = '\0';
2460 /*******************************************************************
2461 Determine if a pattern contains any Microsoft wildcard characters.
2462 *******************************************************************/
2464 bool ms_has_wild(const char *s)
2468 if (lp_posix_pathnames()) {
2469 /* With posix pathnames no characters are wild. */
2473 while ((c = *s++)) {
2486 bool ms_has_wild_w(const smb_ucs2_t *s)
2489 if (!s) return False;
2490 while ((c = *s++)) {
2492 case UCS2_CHAR('*'):
2493 case UCS2_CHAR('?'):
2494 case UCS2_CHAR('<'):
2495 case UCS2_CHAR('>'):
2496 case UCS2_CHAR('"'):
2503 /*******************************************************************
2504 A wrapper that handles case sensitivity and the special handling
2506 *******************************************************************/
2508 bool mask_match(const char *string, const char *pattern, bool is_case_sensitive)
2510 if (strcmp(string,"..") == 0)
2512 if (strcmp(pattern,".") == 0)
2515 return ms_fnmatch(pattern, string, Protocol <= PROTOCOL_LANMAN2, is_case_sensitive) == 0;
2518 /*******************************************************************
2519 A wrapper that handles case sensitivity and the special handling
2520 of the ".." name. Varient that is only called by old search code which requires
2521 pattern translation.
2522 *******************************************************************/
2524 bool mask_match_search(const char *string, const char *pattern, bool is_case_sensitive)
2526 if (strcmp(string,"..") == 0)
2528 if (strcmp(pattern,".") == 0)
2531 return ms_fnmatch(pattern, string, True, is_case_sensitive) == 0;
2534 /*******************************************************************
2535 A wrapper that handles a list of patters and calls mask_match()
2536 on each. Returns True if any of the patterns match.
2537 *******************************************************************/
2539 bool mask_match_list(const char *string, char **list, int listLen, bool is_case_sensitive)
2541 while (listLen-- > 0) {
2542 if (mask_match(string, *list++, is_case_sensitive))
2548 /*********************************************************
2549 Recursive routine that is called by unix_wild_match.
2550 *********************************************************/
2552 static bool unix_do_match(const char *regexp, const char *str)
2556 for( p = regexp; *p && *str; ) {
2567 * Look for a character matching
2568 * the one after the '*'.
2572 return true; /* Automatic match */
2575 while(*str && (*p != *str))
2579 * Patch from weidel@multichart.de. In the case of the regexp
2580 * '*XX*' we want to ensure there are at least 2 'X' characters
2581 * in the string after the '*' for a match to be made.
2588 * Eat all the characters that match, but count how many there were.
2591 while(*str && (*p == *str)) {
2597 * Now check that if the regexp had n identical characters that
2598 * matchcount had at least that many matches.
2601 while ( *(p+1) && (*(p+1) == *p)) {
2606 if ( matchcount <= 0 )
2610 str--; /* We've eaten the match char after the '*' */
2612 if(unix_do_match(p, str))
2634 if (!*p && str[0] == '.' && str[1] == 0)
2637 if (!*str && *p == '?') {
2643 if(!*str && (*p == '*' && p[1] == '\0'))
2649 /*******************************************************************
2650 Simple case insensitive interface to a UNIX wildcard matcher.
2651 Returns True if match, False if not.
2652 *******************************************************************/
2654 bool unix_wild_match(const char *pattern, const char *string)
2656 TALLOC_CTX *ctx = talloc_stackframe();
2662 p2 = talloc_strdup(ctx,pattern);
2663 s2 = talloc_strdup(ctx,string);
2671 /* Remove any *? and ** from the pattern as they are meaningless */
2672 for(p = p2; *p; p++) {
2673 while( *p == '*' && (p[1] == '?' ||p[1] == '*')) {
2674 memmove(&p[1], &p[2], strlen(&p[2])+1);
2678 if (strequal(p2,"*")) {
2683 ret = unix_do_match(p2, s2);
2688 /**********************************************************************
2689 Converts a name to a fully qualified domain name.
2690 Returns true if lookup succeeded, false if not (then fqdn is set to name)
2691 Note we deliberately use gethostbyname here, not getaddrinfo as we want
2692 to examine the h_aliases and I don't know how to do that with getaddrinfo.
2693 ***********************************************************************/
2695 bool name_to_fqdn(fstring fqdn, const char *name)
2698 struct hostent *hp = gethostbyname(name);
2700 if (!hp || !hp->h_name || !*hp->h_name) {
2701 DEBUG(10,("name_to_fqdn: lookup for %s failed.\n", name));
2702 fstrcpy(fqdn, name);
2706 /* Find out if the fqdn is returned as an alias
2707 * to cope with /etc/hosts files where the first
2708 * name is not the fqdn but the short name */
2709 if (hp->h_aliases && (! strchr_m(hp->h_name, '.'))) {
2711 for (i = 0; hp->h_aliases[i]; i++) {
2712 if (strchr_m(hp->h_aliases[i], '.')) {
2713 full = hp->h_aliases[i];
2718 if (full && (StrCaseCmp(full, "localhost.localdomain") == 0)) {
2719 DEBUG(1, ("WARNING: your /etc/hosts file may be broken!\n"));
2720 DEBUGADD(1, (" Specifing the machine hostname for address 127.0.0.1 may lead\n"));
2721 DEBUGADD(1, (" to Kerberos authentication problems as localhost.localdomain\n"));
2722 DEBUGADD(1, (" may end up being used instead of the real machine FQDN.\n"));
2729 DEBUG(10,("name_to_fqdn: lookup for %s -> %s.\n", name, full));
2730 fstrcpy(fqdn, full);
2734 /**********************************************************************
2735 Append a DATA_BLOB to a talloc'ed object
2736 ***********************************************************************/
2738 void *talloc_append_blob(TALLOC_CTX *mem_ctx, void *buf, DATA_BLOB blob)
2740 size_t old_size = 0;
2743 if (blob.length == 0) {
2748 old_size = talloc_get_size(buf);
2751 result = (char *)TALLOC_REALLOC(mem_ctx, buf, old_size + blob.length);
2752 if (result == NULL) {
2756 memcpy(result + old_size, blob.data, blob.length);
2760 uint32 map_share_mode_to_deny_mode(uint32 share_access, uint32 private_options)
2762 switch (share_access & ~FILE_SHARE_DELETE) {
2763 case FILE_SHARE_NONE:
2765 case FILE_SHARE_READ:
2767 case FILE_SHARE_WRITE:
2769 case FILE_SHARE_READ|FILE_SHARE_WRITE:
2772 if (private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS) {
2774 } else if (private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_FCB) {
2781 pid_t procid_to_pid(const struct server_id *proc)
2786 static uint32 my_vnn = NONCLUSTER_VNN;
2788 void set_my_vnn(uint32 vnn)
2790 DEBUG(10, ("vnn pid %d = %u\n", (int)sys_getpid(), (unsigned int)vnn));
2794 uint32 get_my_vnn(void)
2799 struct server_id pid_to_procid(pid_t pid)
2801 struct server_id result;
2803 #ifdef CLUSTER_SUPPORT
2804 result.vnn = my_vnn;
2809 struct server_id procid_self(void)
2811 return pid_to_procid(sys_getpid());
2814 struct server_id server_id_self(void)
2816 return procid_self();
2819 bool procid_equal(const struct server_id *p1, const struct server_id *p2)
2821 if (p1->pid != p2->pid)
2823 #ifdef CLUSTER_SUPPORT
2824 if (p1->vnn != p2->vnn)
2830 bool cluster_id_equal(const struct server_id *id1,
2831 const struct server_id *id2)
2833 return procid_equal(id1, id2);
2836 bool procid_is_me(const struct server_id *pid)
2838 if (pid->pid != sys_getpid())
2840 #ifdef CLUSTER_SUPPORT
2841 if (pid->vnn != my_vnn)
2847 struct server_id interpret_pid(const char *pid_string)
2849 #ifdef CLUSTER_SUPPORT
2850 unsigned int vnn, pid;
2851 struct server_id result;
2852 if (sscanf(pid_string, "%u:%u", &vnn, &pid) == 2) {
2856 else if (sscanf(pid_string, "%u", &pid) == 1) {
2857 result.vnn = get_my_vnn();
2861 result.vnn = NONCLUSTER_VNN;
2866 return pid_to_procid(atoi(pid_string));
2870 char *procid_str(TALLOC_CTX *mem_ctx, const struct server_id *pid)
2872 #ifdef CLUSTER_SUPPORT
2873 if (pid->vnn == NONCLUSTER_VNN) {
2874 return talloc_asprintf(mem_ctx,
2879 return talloc_asprintf(mem_ctx,
2885 return talloc_asprintf(mem_ctx,
2891 char *procid_str_static(const struct server_id *pid)
2893 return procid_str(talloc_tos(), pid);
2896 bool procid_valid(const struct server_id *pid)
2898 return (pid->pid != -1);
2901 bool procid_is_local(const struct server_id *pid)
2903 #ifdef CLUSTER_SUPPORT
2904 return pid->vnn == my_vnn;
2910 int this_is_smp(void)
2912 #if defined(HAVE_SYSCONF)
2914 #if defined(SYSCONF_SC_NPROC_ONLN)
2915 return (sysconf(_SC_NPROC_ONLN) > 1) ? 1 : 0;
2916 #elif defined(SYSCONF_SC_NPROCESSORS_ONLN)
2917 return (sysconf(_SC_NPROCESSORS_ONLN) > 1) ? 1 : 0;
2927 /****************************************************************
2928 Check if an offset into a buffer is safe.
2929 If this returns True it's safe to indirect into the byte at
2931 ****************************************************************/
2933 bool is_offset_safe(const char *buf_base, size_t buf_len, char *ptr, size_t off)
2935 const char *end_base = buf_base + buf_len;
2936 char *end_ptr = ptr + off;
2938 if (!buf_base || !ptr) {
2942 if (end_base < buf_base || end_ptr < ptr) {
2943 return False; /* wrap. */
2946 if (end_ptr < end_base) {
2952 /****************************************************************
2953 Return a safe pointer into a buffer, or NULL.
2954 ****************************************************************/
2956 char *get_safe_ptr(const char *buf_base, size_t buf_len, char *ptr, size_t off)
2958 return is_offset_safe(buf_base, buf_len, ptr, off) ?
2962 /****************************************************************
2963 Return a safe pointer into a string within a buffer, or NULL.
2964 ****************************************************************/
2966 char *get_safe_str_ptr(const char *buf_base, size_t buf_len, char *ptr, size_t off)
2968 if (!is_offset_safe(buf_base, buf_len, ptr, off)) {
2971 /* Check if a valid string exists at this offset. */
2972 if (skip_string(buf_base,buf_len, ptr + off) == NULL) {
2978 /****************************************************************
2979 Return an SVAL at a pointer, or failval if beyond the end.
2980 ****************************************************************/
2982 int get_safe_SVAL(const char *buf_base, size_t buf_len, char *ptr, size_t off, int failval)
2985 * Note we use off+1 here, not off+2 as SVAL accesses ptr[0] and ptr[1],
2988 if (!is_offset_safe(buf_base, buf_len, ptr, off+1)) {
2991 return SVAL(ptr,off);
2994 /****************************************************************
2995 Return an IVAL at a pointer, or failval if beyond the end.
2996 ****************************************************************/
2998 int get_safe_IVAL(const char *buf_base, size_t buf_len, char *ptr, size_t off, int failval)
3001 * Note we use off+3 here, not off+4 as IVAL accesses
3002 * ptr[0] ptr[1] ptr[2] ptr[3] NOT ptr[4].
3004 if (!is_offset_safe(buf_base, buf_len, ptr, off+3)) {
3007 return IVAL(ptr,off);
3010 /****************************************************************
3011 Split DOM\user into DOM and user. Do not mix with winbind variants of that
3012 call (they take care of winbind separator and other winbind specific settings).
3013 ****************************************************************/
3015 void split_domain_user(TALLOC_CTX *mem_ctx,
3016 const char *full_name,
3020 const char *p = NULL;
3022 p = strchr_m(full_name, '\\');
3025 *domain = talloc_strndup(mem_ctx, full_name,
3026 PTR_DIFF(p, full_name));
3027 *user = talloc_strdup(mem_ctx, p+1);
3029 *domain = talloc_strdup(mem_ctx, "");
3030 *user = talloc_strdup(mem_ctx, full_name);
3036 Disable these now we have checked all code paths and ensured
3037 NULL returns on zero request. JRA.
3039 /****************************************************************
3040 talloc wrapper functions that guarentee a null pointer return
3042 ****************************************************************/
3044 #ifndef MAX_TALLOC_SIZE
3045 #define MAX_TALLOC_SIZE 0x10000000
3049 * talloc and zero memory.
3050 * - returns NULL if size is zero.
3053 void *_talloc_zero_zeronull(const void *ctx, size_t size, const char *name)
3061 p = talloc_named_const(ctx, size, name);
3064 memset(p, '\0', size);
3071 * memdup with a talloc.
3072 * - returns NULL if size is zero.
3075 void *_talloc_memdup_zeronull(const void *t, const void *p, size_t size, const char *name)
3083 newp = talloc_named_const(t, size, name);
3085 memcpy(newp, p, size);
3092 * alloc an array, checking for integer overflow in the array size.
3093 * - returns NULL if count or el_size are zero.
3096 void *_talloc_array_zeronull(const void *ctx, size_t el_size, unsigned count, const char *name)
3098 if (count >= MAX_TALLOC_SIZE/el_size) {
3102 if (el_size == 0 || count == 0) {
3106 return talloc_named_const(ctx, el_size * count, name);
3110 * alloc an zero array, checking for integer overflow in the array size
3111 * - returns NULL if count or el_size are zero.
3114 void *_talloc_zero_array_zeronull(const void *ctx, size_t el_size, unsigned count, const char *name)
3116 if (count >= MAX_TALLOC_SIZE/el_size) {
3120 if (el_size == 0 || count == 0) {
3124 return _talloc_zero(ctx, el_size * count, name);
3128 * Talloc wrapper that returns NULL if size == 0.
3130 void *talloc_zeronull(const void *context, size_t size, const char *name)
3135 return talloc_named_const(context, size, name);
3139 /* Split a path name into filename and stream name components. Canonicalise
3140 * such that an implicit $DATA token is always explicit.
3142 * The "specification" of this function can be found in the
3143 * run_local_stream_name() function in torture.c, I've tried those
3144 * combinations against a W2k3 server.
3147 NTSTATUS split_ntfs_stream_name(TALLOC_CTX *mem_ctx, const char *fname,
3148 char **pbase, char **pstream)
3151 char *stream = NULL;
3152 char *sname; /* stream name */
3153 const char *stype; /* stream type */
3155 DEBUG(10, ("split_ntfs_stream_name called for [%s]\n", fname));
3157 sname = strchr_m(fname, ':');
3159 if (lp_posix_pathnames() || (sname == NULL)) {
3160 if (pbase != NULL) {
3161 base = talloc_strdup(mem_ctx, fname);
3162 NT_STATUS_HAVE_NO_MEMORY(base);
3167 if (pbase != NULL) {
3168 base = talloc_strndup(mem_ctx, fname, PTR_DIFF(sname, fname));
3169 NT_STATUS_HAVE_NO_MEMORY(base);
3174 stype = strchr_m(sname, ':');
3176 if (stype == NULL) {
3177 sname = talloc_strdup(mem_ctx, sname);
3181 if (StrCaseCmp(stype, ":$DATA") != 0) {
3183 * If there is an explicit stream type, so far we only
3184 * allow $DATA. Is there anything else allowed? -- vl
3186 DEBUG(10, ("[%s] is an invalid stream type\n", stype));
3188 return NT_STATUS_OBJECT_NAME_INVALID;
3190 sname = talloc_strndup(mem_ctx, sname, PTR_DIFF(stype, sname));
3194 if (sname == NULL) {
3196 return NT_STATUS_NO_MEMORY;
3199 if (sname[0] == '\0') {
3201 * no stream name, so no stream
3206 if (pstream != NULL) {
3207 stream = talloc_asprintf(mem_ctx, "%s:%s", sname, stype);
3208 if (stream == NULL) {
3211 return NT_STATUS_NO_MEMORY;
3214 * upper-case the type field
3216 strupper_m(strchr_m(stream, ':')+1);
3220 if (pbase != NULL) {
3223 if (pstream != NULL) {
3226 return NT_STATUS_OK;
3229 bool is_valid_policy_hnd(const POLICY_HND *hnd)
3233 return (memcmp(&tmp, hnd, sizeof(tmp)) != 0);
3236 bool policy_hnd_equal(const struct policy_handle *hnd1,
3237 const struct policy_handle *hnd2)
3239 if (!hnd1 || !hnd2) {
3243 return (memcmp(hnd1, hnd2, sizeof(*hnd1)) == 0);
3246 /****************************************************************
3247 strip off leading '\\' from a hostname
3248 ****************************************************************/
3250 const char *strip_hostname(const char *s)
3256 if (strlen_m(s) < 3) {
3260 if (s[0] == '\\') s++;
3261 if (s[0] == '\\') s++;