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 struct user_auth_info *user_auth_info_init(TALLOC_CTX *mem_ctx)
285 struct user_auth_info *result;
287 result = TALLOC_ZERO_P(mem_ctx, struct user_auth_info);
288 if (result == NULL) {
292 result->signing_state = Undefined;
296 const char *get_cmdline_auth_info_username(struct user_auth_info *auth_info)
298 if (!auth_info->username) {
301 return auth_info->username;
304 void set_cmdline_auth_info_username(struct user_auth_info *auth_info,
305 const char *username)
307 TALLOC_FREE(auth_info->username);
308 auth_info->username = talloc_strdup(auth_info, username);
309 if (!auth_info->username) {
314 const char *get_cmdline_auth_info_password(struct user_auth_info *auth_info)
316 if (!auth_info->password) {
319 return auth_info->password;
322 void set_cmdline_auth_info_password(struct user_auth_info *auth_info,
323 const char *password)
325 TALLOC_FREE(auth_info->password);
326 auth_info->password = talloc_strdup(auth_info, password);
327 if (!auth_info->password) {
330 auth_info->got_pass = true;
333 bool set_cmdline_auth_info_signing_state(struct user_auth_info *auth_info,
336 auth_info->signing_state = -1;
337 if (strequal(arg, "off") || strequal(arg, "no") ||
338 strequal(arg, "false")) {
339 auth_info->signing_state = false;
340 } else if (strequal(arg, "on") || strequal(arg, "yes") ||
341 strequal(arg, "true") || strequal(arg, "auto")) {
342 auth_info->signing_state = true;
343 } else if (strequal(arg, "force") || strequal(arg, "required") ||
344 strequal(arg, "forced")) {
345 auth_info->signing_state = Required;
352 int get_cmdline_auth_info_signing_state(struct user_auth_info *auth_info)
354 return auth_info->signing_state;
357 void set_cmdline_auth_info_use_kerberos(struct user_auth_info *auth_info,
360 auth_info->use_kerberos = b;
363 bool get_cmdline_auth_info_use_kerberos(struct user_auth_info *auth_info)
365 return auth_info->use_kerberos;
368 /* This should only be used by lib/popt_common.c JRA */
369 void set_cmdline_auth_info_use_krb5_ticket(struct user_auth_info *auth_info)
371 auth_info->use_kerberos = true;
372 auth_info->got_pass = true;
375 /* This should only be used by lib/popt_common.c JRA */
376 void set_cmdline_auth_info_smb_encrypt(struct user_auth_info *auth_info)
378 auth_info->smb_encrypt = true;
381 void set_cmdline_auth_info_use_machine_account(struct user_auth_info *auth_info)
383 auth_info->use_machine_account = true;
386 bool get_cmdline_auth_info_got_pass(struct user_auth_info *auth_info)
388 return auth_info->got_pass;
391 bool get_cmdline_auth_info_smb_encrypt(struct user_auth_info *auth_info)
393 return auth_info->smb_encrypt;
396 bool get_cmdline_auth_info_use_machine_account(struct user_auth_info *auth_info)
398 return auth_info->use_machine_account;
401 struct user_auth_info *get_cmdline_auth_info_copy(TALLOC_CTX *mem_ctx,
402 struct user_auth_info *src)
404 struct user_auth_info *result;
406 result = user_auth_info_init(mem_ctx);
407 if (result == NULL) {
413 result->username = talloc_strdup(
414 result, get_cmdline_auth_info_username(src));
415 result->password = talloc_strdup(
416 result, get_cmdline_auth_info_password(src));
417 if ((result->username == NULL) || (result->password == NULL)) {
425 bool set_cmdline_auth_info_machine_account_creds(struct user_auth_info *auth_info)
428 char *account = NULL;
430 if (!get_cmdline_auth_info_use_machine_account(auth_info)) {
434 if (!secrets_init()) {
435 d_printf("ERROR: Unable to open secrets database\n");
439 if (asprintf(&account, "%s$@%s", global_myname(), lp_realm()) < 0) {
443 pass = secrets_fetch_machine_password(lp_workgroup(), NULL, NULL);
445 d_printf("ERROR: Unable to fetch machine password for "
447 account, lp_workgroup());
452 set_cmdline_auth_info_username(auth_info, account);
453 set_cmdline_auth_info_password(auth_info, pass);
461 /****************************************************************************
462 Add a gid to an array of gids if it's not already there.
463 ****************************************************************************/
465 bool add_gid_to_array_unique(TALLOC_CTX *mem_ctx, gid_t gid,
466 gid_t **gids, size_t *num_gids)
470 if ((*num_gids != 0) && (*gids == NULL)) {
472 * A former call to this routine has failed to allocate memory
477 for (i=0; i<*num_gids; i++) {
478 if ((*gids)[i] == gid) {
483 *gids = TALLOC_REALLOC_ARRAY(mem_ctx, *gids, gid_t, *num_gids+1);
489 (*gids)[*num_gids] = gid;
494 /*******************************************************************
495 Check if a file exists - call vfs_file_exist for samba files.
496 ********************************************************************/
498 bool file_exist_stat(const char *fname,SMB_STRUCT_STAT *sbuf)
504 if (sys_stat(fname,sbuf) != 0)
507 return((S_ISREG(sbuf->st_mode)) || (S_ISFIFO(sbuf->st_mode)));
510 /*******************************************************************
511 Check if a unix domain socket exists - call vfs_file_exist for samba files.
512 ********************************************************************/
514 bool socket_exist(const char *fname)
517 if (sys_stat(fname,&st) != 0)
520 return S_ISSOCK(st.st_mode);
523 /*******************************************************************
524 Check if a directory exists.
525 ********************************************************************/
527 bool directory_exist_stat(char *dname,SMB_STRUCT_STAT *st)
535 if (sys_stat(dname,st) != 0)
538 ret = S_ISDIR(st->st_mode);
544 /*******************************************************************
545 Returns the size in bytes of the named file.
546 ********************************************************************/
548 SMB_OFF_T get_file_size(char *file_name)
552 if(sys_stat(file_name,&buf) != 0)
553 return (SMB_OFF_T)-1;
557 /*******************************************************************
558 Return a string representing an attribute for a file.
559 ********************************************************************/
561 char *attrib_string(uint16 mode)
567 if (mode & aVOLID) fstrcat(attrstr,"V");
568 if (mode & aDIR) fstrcat(attrstr,"D");
569 if (mode & aARCH) fstrcat(attrstr,"A");
570 if (mode & aHIDDEN) fstrcat(attrstr,"H");
571 if (mode & aSYSTEM) fstrcat(attrstr,"S");
572 if (mode & aRONLY) fstrcat(attrstr,"R");
574 return talloc_strdup(talloc_tos(), attrstr);
577 /*******************************************************************
578 Show a smb message structure.
579 ********************************************************************/
581 void show_msg(char *buf)
589 DEBUG(5,("size=%d\nsmb_com=0x%x\nsmb_rcls=%d\nsmb_reh=%d\nsmb_err=%d\nsmb_flg=%d\nsmb_flg2=%d\n",
591 (int)CVAL(buf,smb_com),
592 (int)CVAL(buf,smb_rcls),
593 (int)CVAL(buf,smb_reh),
594 (int)SVAL(buf,smb_err),
595 (int)CVAL(buf,smb_flg),
596 (int)SVAL(buf,smb_flg2)));
597 DEBUGADD(5,("smb_tid=%d\nsmb_pid=%d\nsmb_uid=%d\nsmb_mid=%d\n",
598 (int)SVAL(buf,smb_tid),
599 (int)SVAL(buf,smb_pid),
600 (int)SVAL(buf,smb_uid),
601 (int)SVAL(buf,smb_mid)));
602 DEBUGADD(5,("smt_wct=%d\n",(int)CVAL(buf,smb_wct)));
604 for (i=0;i<(int)CVAL(buf,smb_wct);i++)
605 DEBUGADD(5,("smb_vwv[%2d]=%5d (0x%X)\n",i,
606 SVAL(buf,smb_vwv+2*i),SVAL(buf,smb_vwv+2*i)));
608 bcc = (int)SVAL(buf,smb_vwv+2*(CVAL(buf,smb_wct)));
610 DEBUGADD(5,("smb_bcc=%d\n",bcc));
618 dump_data(10, (uint8 *)smb_buf(buf), bcc);
621 /*******************************************************************
622 Set the length and marker of an encrypted smb packet.
623 ********************************************************************/
625 void smb_set_enclen(char *buf,int len,uint16 enc_ctx_num)
627 _smb_setlen(buf,len);
631 SSVAL(buf,6,enc_ctx_num);
634 /*******************************************************************
635 Set the length and marker of an smb packet.
636 ********************************************************************/
638 void smb_setlen(char *buf,int len)
640 _smb_setlen(buf,len);
648 /*******************************************************************
649 Setup only the byte count for a smb message.
650 ********************************************************************/
652 int set_message_bcc(char *buf,int num_bytes)
654 int num_words = CVAL(buf,smb_wct);
655 SSVAL(buf,smb_vwv + num_words*SIZEOFWORD,num_bytes);
656 _smb_setlen(buf,smb_size + num_words*2 + num_bytes - 4);
657 return (smb_size + num_words*2 + num_bytes);
660 /*******************************************************************
661 Add a data blob to the end of a smb_buf, adjusting bcc and smb_len.
662 Return the bytes added
663 ********************************************************************/
665 ssize_t message_push_blob(uint8 **outbuf, DATA_BLOB blob)
667 size_t newlen = smb_len(*outbuf) + 4 + blob.length;
670 if (!(tmp = TALLOC_REALLOC_ARRAY(NULL, *outbuf, uint8, newlen))) {
671 DEBUG(0, ("talloc failed\n"));
676 memcpy(tmp + smb_len(tmp) + 4, blob.data, blob.length);
677 set_message_bcc((char *)tmp, smb_buflen(tmp) + blob.length);
681 /*******************************************************************
682 Reduce a file name, removing .. elements.
683 ********************************************************************/
685 static char *dos_clean_name(TALLOC_CTX *ctx, const char *s)
690 DEBUG(3,("dos_clean_name [%s]\n",s));
692 /* remove any double slashes */
693 str = talloc_all_string_sub(ctx, s, "\\\\", "\\");
698 /* Remove leading .\\ characters */
699 if(strncmp(str, ".\\", 2) == 0) {
700 trim_string(str, ".\\", NULL);
702 str = talloc_strdup(ctx, ".\\");
709 while ((p = strstr_m(str,"\\..\\")) != NULL) {
715 if ((p=strrchr_m(str,'\\')) != NULL) {
720 str = talloc_asprintf(ctx,
729 trim_string(str,NULL,"\\..");
730 return talloc_all_string_sub(ctx, str, "\\.\\", "\\");
733 /*******************************************************************
734 Reduce a file name, removing .. elements.
735 ********************************************************************/
737 char *unix_clean_name(TALLOC_CTX *ctx, const char *s)
742 DEBUG(3,("unix_clean_name [%s]\n",s));
744 /* remove any double slashes */
745 str = talloc_all_string_sub(ctx, s, "//","/");
750 /* Remove leading ./ characters */
751 if(strncmp(str, "./", 2) == 0) {
752 trim_string(str, "./", NULL);
754 str = talloc_strdup(ctx, "./");
761 while ((p = strstr_m(str,"/../")) != NULL) {
767 if ((p=strrchr_m(str,'/')) != NULL) {
772 str = talloc_asprintf(ctx,
781 trim_string(str,NULL,"/..");
782 return talloc_all_string_sub(ctx, str, "/./", "/");
785 char *clean_name(TALLOC_CTX *ctx, const char *s)
787 char *str = dos_clean_name(ctx, s);
791 return unix_clean_name(ctx, str);
794 /*******************************************************************
795 Close the low 3 fd's and open dev/null in their place.
796 ********************************************************************/
798 void close_low_fds(bool stderr_too)
810 /* try and use up these file descriptors, so silly
811 library routines writing to stdout etc won't cause havoc */
813 if (i == 2 && !stderr_too)
816 fd = sys_open("/dev/null",O_RDWR,0);
818 fd = sys_open("/dev/null",O_WRONLY,0);
820 DEBUG(0,("Can't open /dev/null\n"));
824 DEBUG(0,("Didn't get file descriptor %d\n",i));
831 /*******************************************************************
832 Write data into an fd at a given offset. Ignore seek errors.
833 ********************************************************************/
835 ssize_t write_data_at_offset(int fd, const char *buffer, size_t N, SMB_OFF_T pos)
840 if (pos == (SMB_OFF_T)-1) {
841 return write_data(fd, buffer, N);
843 #if defined(HAVE_PWRITE) || defined(HAVE_PRWITE64)
845 ret = sys_pwrite(fd,buffer + total,N - total, pos);
846 if (ret == -1 && errno == ESPIPE) {
847 return write_data(fd, buffer + total,N - total);
850 DEBUG(0,("write_data_at_offset: write failure. Error = %s\n", strerror(errno) ));
859 return (ssize_t)total;
861 /* Use lseek and write_data. */
862 if (sys_lseek(fd, pos, SEEK_SET) == -1) {
863 if (errno != ESPIPE) {
867 return write_data(fd, buffer, N);
871 /*******************************************************************
872 Sleep for a specified number of milliseconds.
873 ********************************************************************/
875 void smb_msleep(unsigned int t)
877 #if defined(HAVE_NANOSLEEP)
878 struct timespec tval;
881 tval.tv_sec = t/1000;
882 tval.tv_nsec = 1000000*(t%1000);
886 ret = nanosleep(&tval, &tval);
887 } while (ret < 0 && errno == EINTR && (tval.tv_sec > 0 || tval.tv_nsec > 0));
889 unsigned int tdiff=0;
890 struct timeval tval,t1,t2;
897 tval.tv_sec = (t-tdiff)/1000;
898 tval.tv_usec = 1000*((t-tdiff)%1000);
900 /* Never wait for more than 1 sec. */
901 if (tval.tv_sec > 1) {
908 sys_select_intr(0,&fds,NULL,NULL,&tval);
911 if (t2.tv_sec < t1.tv_sec) {
912 /* Someone adjusted time... */
916 tdiff = TvalDiff(&t1,&t2);
921 /****************************************************************************
922 Become a daemon, discarding the controlling terminal.
923 ****************************************************************************/
925 void become_daemon(bool Fork, bool no_process_group)
933 /* detach from the terminal */
935 if (!no_process_group) setsid();
936 #elif defined(TIOCNOTTY)
937 if (!no_process_group) {
938 int i = sys_open("/dev/tty", O_RDWR, 0);
940 ioctl(i, (int) TIOCNOTTY, (char *)0);
944 #endif /* HAVE_SETSID */
946 /* Close fd's 0,1,2. Needed if started by rsh */
947 close_low_fds(False); /* Don't close stderr, let the debug system
948 attach it to the logfile */
951 bool reinit_after_fork(struct messaging_context *msg_ctx,
952 bool parent_longlived)
956 /* Reset the state of the random
957 * number generation system, so
958 * children do not get the same random
959 * numbers as each other */
960 set_need_random_reseed();
962 /* tdb needs special fork handling */
963 if (tdb_reopen_all(parent_longlived ? 1 : 0) == -1) {
964 DEBUG(0,("tdb_reopen_all failed.\n"));
969 * For clustering, we need to re-init our ctdbd connection after the
972 status = messaging_reinit(msg_ctx);
973 if (!NT_STATUS_IS_OK(status)) {
974 DEBUG(0,("messaging_reinit() failed: %s\n",
982 /****************************************************************************
983 Put up a yes/no prompt.
984 ****************************************************************************/
986 bool yesno(const char *p)
991 if (!fgets(ans,sizeof(ans)-1,stdin))
994 if (*ans == 'y' || *ans == 'Y')
1000 #if defined(PARANOID_MALLOC_CHECKER)
1002 /****************************************************************************
1003 Internal malloc wrapper. Externally visible.
1004 ****************************************************************************/
1006 void *malloc_(size_t size)
1012 return malloc(size);
1013 #define malloc(s) __ERROR_DONT_USE_MALLOC_DIRECTLY
1016 /****************************************************************************
1017 Internal calloc wrapper. Not externally visible.
1018 ****************************************************************************/
1020 static void *calloc_(size_t count, size_t size)
1022 if (size == 0 || count == 0) {
1026 return calloc(count, size);
1027 #define calloc(n,s) __ERROR_DONT_USE_CALLOC_DIRECTLY
1030 /****************************************************************************
1031 Internal realloc wrapper. Not externally visible.
1032 ****************************************************************************/
1034 static void *realloc_(void *ptr, size_t size)
1037 return realloc(ptr, size);
1038 #define realloc(p,s) __ERROR_DONT_USE_RELLOC_DIRECTLY
1041 #endif /* PARANOID_MALLOC_CHECKER */
1043 /****************************************************************************
1045 ****************************************************************************/
1047 void *memalign_array(size_t el_size, size_t align, unsigned int count)
1049 if (count >= MAX_ALLOC_SIZE/el_size) {
1053 return sys_memalign(align, el_size*count);
1056 /****************************************************************************
1058 ****************************************************************************/
1060 void *calloc_array(size_t size, size_t nmemb)
1062 if (nmemb >= MAX_ALLOC_SIZE/size) {
1065 if (size == 0 || nmemb == 0) {
1068 #if defined(PARANOID_MALLOC_CHECKER)
1069 return calloc_(nmemb, size);
1071 return calloc(nmemb, size);
1075 /****************************************************************************
1076 Expand a pointer to be a particular size.
1077 Note that this version of Realloc has an extra parameter that decides
1078 whether to free the passed in storage on allocation failure or if the
1081 This is designed for use in the typical idiom of :
1083 p = SMB_REALLOC(p, size)
1088 and not to have to keep track of the old 'p' contents to free later, nor
1089 to worry if the size parameter was zero. In the case where NULL is returned
1090 we guarentee that p has been freed.
1092 If free later semantics are desired, then pass 'free_old_on_error' as False which
1093 guarentees that the old contents are not freed on error, even if size == 0. To use
1096 tmp = SMB_REALLOC_KEEP_OLD_ON_ERROR(p, size);
1104 Changes were instigated by Coverity error checking. JRA.
1105 ****************************************************************************/
1107 void *Realloc(void *p, size_t size, bool free_old_on_error)
1112 if (free_old_on_error) {
1115 DEBUG(2,("Realloc asked for 0 bytes\n"));
1119 #if defined(PARANOID_MALLOC_CHECKER)
1121 ret = (void *)malloc_(size);
1123 ret = (void *)realloc_(p,size);
1127 ret = (void *)malloc(size);
1129 ret = (void *)realloc(p,size);
1134 if (free_old_on_error && p) {
1137 DEBUG(0,("Memory allocation error: failed to expand to %d bytes\n",(int)size));
1143 /****************************************************************************
1144 (Hopefully) efficient array append.
1145 ****************************************************************************/
1147 void add_to_large_array(TALLOC_CTX *mem_ctx, size_t element_size,
1148 void *element, void *_array, uint32 *num_elements,
1149 ssize_t *array_size)
1151 void **array = (void **)_array;
1153 if (*array_size < 0) {
1157 if (*array == NULL) {
1158 if (*array_size == 0) {
1162 if (*array_size >= MAX_ALLOC_SIZE/element_size) {
1166 *array = TALLOC(mem_ctx, element_size * (*array_size));
1167 if (*array == NULL) {
1172 if (*num_elements == *array_size) {
1175 if (*array_size >= MAX_ALLOC_SIZE/element_size) {
1179 *array = TALLOC_REALLOC(mem_ctx, *array,
1180 element_size * (*array_size));
1182 if (*array == NULL) {
1187 memcpy((char *)(*array) + element_size*(*num_elements),
1188 element, element_size);
1198 /****************************************************************************
1199 Get my own name and IP.
1200 ****************************************************************************/
1202 char *talloc_get_myname(TALLOC_CTX *ctx)
1205 char hostname[HOST_NAME_MAX];
1209 /* get my host name */
1210 if (gethostname(hostname, sizeof(hostname)) == -1) {
1211 DEBUG(0,("gethostname failed\n"));
1215 /* Ensure null termination. */
1216 hostname[sizeof(hostname)-1] = '\0';
1218 /* split off any parts after an initial . */
1219 p = strchr_m(hostname,'.');
1224 return talloc_strdup(ctx, hostname);
1227 /****************************************************************************
1228 Get my own domain name, or "" if we have none.
1229 ****************************************************************************/
1231 char *get_mydnsdomname(TALLOC_CTX *ctx)
1233 const char *domname;
1236 domname = get_mydnsfullname();
1241 p = strchr_m(domname, '.');
1244 return talloc_strdup(ctx, p);
1246 return talloc_strdup(ctx, "");
1250 /****************************************************************************
1251 Interpret a protocol description string, with a default.
1252 ****************************************************************************/
1254 int interpret_protocol(const char *str,int def)
1256 if (strequal(str,"NT1"))
1257 return(PROTOCOL_NT1);
1258 if (strequal(str,"LANMAN2"))
1259 return(PROTOCOL_LANMAN2);
1260 if (strequal(str,"LANMAN1"))
1261 return(PROTOCOL_LANMAN1);
1262 if (strequal(str,"CORE"))
1263 return(PROTOCOL_CORE);
1264 if (strequal(str,"COREPLUS"))
1265 return(PROTOCOL_COREPLUS);
1266 if (strequal(str,"CORE+"))
1267 return(PROTOCOL_COREPLUS);
1269 DEBUG(0,("Unrecognised protocol level %s\n",str));
1275 #if (defined(HAVE_NETGROUP) && defined(WITH_AUTOMOUNT))
1276 /******************************************************************
1277 Remove any mount options such as -rsize=2048,wsize=2048 etc.
1278 Based on a fix from <Thomas.Hepper@icem.de>.
1279 Returns a malloc'ed string.
1280 *******************************************************************/
1282 static char *strip_mount_options(TALLOC_CTX *ctx, const char *str)
1285 const char *p = str;
1286 while(*p && !isspace(*p))
1288 while(*p && isspace(*p))
1291 return talloc_strdup(ctx, p);
1297 /*******************************************************************
1298 Patch from jkf@soton.ac.uk
1299 Split Luke's automount_server into YP lookup and string splitter
1300 so can easily implement automount_path().
1301 Returns a malloc'ed string.
1302 *******************************************************************/
1304 #ifdef WITH_NISPLUS_HOME
1305 char *automount_lookup(TALLOC_CTX *ctx, const char *user_name)
1309 char *nis_map = (char *)lp_nis_home_map_name();
1311 char buffer[NIS_MAXATTRVAL + 1];
1316 snprintf(buffer, sizeof(buffer), "[key=%s],%s", user_name, nis_map);
1317 DEBUG(5, ("NIS+ querystring: %s\n", buffer));
1319 if (result = nis_list(buffer, FOLLOW_PATH|EXPAND_NAME|HARD_LOOKUP, NULL, NULL)) {
1320 if (result->status != NIS_SUCCESS) {
1321 DEBUG(3, ("NIS+ query failed: %s\n", nis_sperrno(result->status)));
1323 object = result->objects.objects_val;
1324 if (object->zo_data.zo_type == ENTRY_OBJ) {
1325 entry = &object->zo_data.objdata_u.en_data;
1326 DEBUG(5, ("NIS+ entry type: %s\n", entry->en_type));
1327 DEBUG(3, ("NIS+ result: %s\n", entry->en_cols.en_cols_val[1].ec_value.ec_value_val));
1329 value = talloc_strdup(ctx,
1330 entry->en_cols.en_cols_val[1].ec_value.ec_value_val);
1332 nis_freeresult(result);
1335 value = talloc_string_sub(ctx,
1342 nis_freeresult(result);
1345 value = strip_mount_options(ctx, value);
1346 DEBUG(4, ("NIS+ Lookup: %s resulted in %s\n",
1351 #else /* WITH_NISPLUS_HOME */
1353 char *automount_lookup(TALLOC_CTX *ctx, const char *user_name)
1357 int nis_error; /* returned by yp all functions */
1358 char *nis_result; /* yp_match inits this */
1359 int nis_result_len; /* and set this */
1360 char *nis_domain; /* yp_get_default_domain inits this */
1361 char *nis_map = (char *)lp_nis_home_map_name();
1363 if ((nis_error = yp_get_default_domain(&nis_domain)) != 0) {
1364 DEBUG(3, ("YP Error: %s\n", yperr_string(nis_error)));
1368 DEBUG(5, ("NIS Domain: %s\n", nis_domain));
1370 if ((nis_error = yp_match(nis_domain, nis_map, user_name,
1371 strlen(user_name), &nis_result,
1372 &nis_result_len)) == 0) {
1373 value = talloc_strdup(ctx, nis_result);
1377 value = strip_mount_options(ctx, value);
1378 } else if(nis_error == YPERR_KEY) {
1379 DEBUG(3, ("YP Key not found: while looking up \"%s\" in map \"%s\"\n",
1380 user_name, nis_map));
1381 DEBUG(3, ("using defaults for server and home directory\n"));
1383 DEBUG(3, ("YP Error: \"%s\" while looking up \"%s\" in map \"%s\"\n",
1384 yperr_string(nis_error), user_name, nis_map));
1388 DEBUG(4, ("YP Lookup: %s resulted in %s\n", user_name, value));
1392 #endif /* WITH_NISPLUS_HOME */
1395 /****************************************************************************
1396 Check if a process exists. Does this work on all unixes?
1397 ****************************************************************************/
1399 bool process_exists(const struct server_id pid)
1401 if (procid_is_me(&pid)) {
1405 if (procid_is_local(&pid)) {
1406 return (kill(pid.pid,0) == 0 || errno != ESRCH);
1409 #ifdef CLUSTER_SUPPORT
1410 return ctdbd_process_exists(messaging_ctdbd_connection(), pid.vnn,
1417 /*******************************************************************
1418 Convert a uid into a user name.
1419 ********************************************************************/
1421 const char *uidtoname(uid_t uid)
1423 TALLOC_CTX *ctx = talloc_tos();
1425 struct passwd *pass = NULL;
1427 pass = getpwuid_alloc(ctx,uid);
1429 name = talloc_strdup(ctx,pass->pw_name);
1432 name = talloc_asprintf(ctx,
1439 /*******************************************************************
1440 Convert a gid into a group name.
1441 ********************************************************************/
1443 char *gidtoname(gid_t gid)
1447 grp = getgrgid(gid);
1449 return talloc_strdup(talloc_tos(), grp->gr_name);
1452 return talloc_asprintf(talloc_tos(),
1458 /*******************************************************************
1459 Convert a user name into a uid.
1460 ********************************************************************/
1462 uid_t nametouid(const char *name)
1464 struct passwd *pass;
1468 pass = getpwnam_alloc(talloc_autofree_context(), name);
1475 u = (uid_t)strtol(name, &p, 0);
1476 if ((p != name) && (*p == '\0'))
1482 /*******************************************************************
1483 Convert a name to a gid_t if possible. Return -1 if not a group.
1484 ********************************************************************/
1486 gid_t nametogid(const char *name)
1492 g = (gid_t)strtol(name, &p, 0);
1493 if ((p != name) && (*p == '\0'))
1496 grp = sys_getgrnam(name);
1498 return(grp->gr_gid);
1502 /*******************************************************************
1503 Something really nasty happened - panic !
1504 ********************************************************************/
1506 void smb_panic(const char *const why)
1514 if (global_clobber_region_function) {
1515 DEBUG(0,("smb_panic: clobber_region() last called from [%s(%u)]\n",
1516 global_clobber_region_function,
1517 global_clobber_region_line));
1522 DEBUG(0,("PANIC (pid %llu): %s\n",
1523 (unsigned long long)sys_getpid(), why));
1526 cmd = lp_panic_action();
1528 DEBUG(0, ("smb_panic(): calling panic action [%s]\n", cmd));
1529 result = system(cmd);
1532 DEBUG(0, ("smb_panic(): fork failed in panic action: %s\n",
1535 DEBUG(0, ("smb_panic(): action returned status %d\n",
1536 WEXITSTATUS(result)));
1542 /*******************************************************************
1543 Print a backtrace of the stack to the debug log. This function
1544 DELIBERATELY LEAKS MEMORY. The expectation is that you should
1545 exit shortly after calling it.
1546 ********************************************************************/
1548 #ifdef HAVE_LIBUNWIND_H
1549 #include <libunwind.h>
1552 #ifdef HAVE_EXECINFO_H
1553 #include <execinfo.h>
1556 #ifdef HAVE_LIBEXC_H
1560 void log_stack_trace(void)
1562 #ifdef HAVE_LIBUNWIND
1563 /* Try to use libunwind before any other technique since on ia64
1564 * libunwind correctly walks the stack in more circumstances than
1567 unw_cursor_t cursor;
1572 unw_word_t ip, sp, off;
1574 procname[sizeof(procname) - 1] = '\0';
1576 if (unw_getcontext(&uc) != 0) {
1577 goto libunwind_failed;
1580 if (unw_init_local(&cursor, &uc) != 0) {
1581 goto libunwind_failed;
1584 DEBUG(0, ("BACKTRACE:\n"));
1588 unw_get_reg(&cursor, UNW_REG_IP, &ip);
1589 unw_get_reg(&cursor, UNW_REG_SP, &sp);
1591 switch (unw_get_proc_name(&cursor,
1592 procname, sizeof(procname) - 1, &off) ) {
1596 /* Name truncated. */
1597 DEBUGADD(0, (" #%u %s + %#llx [ip=%#llx] [sp=%#llx]\n",
1598 i, procname, (long long)off,
1599 (long long)ip, (long long) sp));
1602 /* case -UNW_ENOINFO: */
1603 /* case -UNW_EUNSPEC: */
1604 /* No symbol name found. */
1605 DEBUGADD(0, (" #%u %s [ip=%#llx] [sp=%#llx]\n",
1606 i, "<unknown symbol>",
1607 (long long)ip, (long long) sp));
1610 } while (unw_step(&cursor) > 0);
1615 DEBUG(0, ("unable to produce a stack trace with libunwind\n"));
1617 #elif HAVE_BACKTRACE_SYMBOLS
1618 void *backtrace_stack[BACKTRACE_STACK_SIZE];
1619 size_t backtrace_size;
1620 char **backtrace_strings;
1622 /* get the backtrace (stack frames) */
1623 backtrace_size = backtrace(backtrace_stack,BACKTRACE_STACK_SIZE);
1624 backtrace_strings = backtrace_symbols(backtrace_stack, backtrace_size);
1626 DEBUG(0, ("BACKTRACE: %lu stack frames:\n",
1627 (unsigned long)backtrace_size));
1629 if (backtrace_strings) {
1632 for (i = 0; i < backtrace_size; i++)
1633 DEBUGADD(0, (" #%u %s\n", i, backtrace_strings[i]));
1635 /* Leak the backtrace_strings, rather than risk what free() might do */
1640 /* The IRIX libexc library provides an API for unwinding the stack. See
1641 * libexc(3) for details. Apparantly trace_back_stack leaks memory, but
1642 * since we are about to abort anyway, it hardly matters.
1645 #define NAMESIZE 32 /* Arbitrary */
1647 __uint64_t addrs[BACKTRACE_STACK_SIZE];
1648 char * names[BACKTRACE_STACK_SIZE];
1649 char namebuf[BACKTRACE_STACK_SIZE * NAMESIZE];
1656 ZERO_ARRAY(namebuf);
1658 /* We need to be root so we can open our /proc entry to walk
1659 * our stack. It also helps when we want to dump core.
1663 for (i = 0; i < BACKTRACE_STACK_SIZE; i++) {
1664 names[i] = namebuf + (i * NAMESIZE);
1667 levels = trace_back_stack(0, addrs, names,
1668 BACKTRACE_STACK_SIZE, NAMESIZE - 1);
1670 DEBUG(0, ("BACKTRACE: %d stack frames:\n", levels));
1671 for (i = 0; i < levels; i++) {
1672 DEBUGADD(0, (" #%d 0x%llx %s\n", i, addrs[i], names[i]));
1677 DEBUG(0, ("unable to produce a stack trace on this platform\n"));
1681 /*******************************************************************
1682 A readdir wrapper which just returns the file name.
1683 ********************************************************************/
1685 const char *readdirname(SMB_STRUCT_DIR *p)
1687 SMB_STRUCT_DIRENT *ptr;
1693 ptr = (SMB_STRUCT_DIRENT *)sys_readdir(p);
1697 dname = ptr->d_name;
1704 #ifdef HAVE_BROKEN_READDIR_NAME
1705 /* using /usr/ucb/cc is BAD */
1709 return talloc_strdup(talloc_tos(), dname);
1712 /*******************************************************************
1713 Utility function used to decide if the last component
1714 of a path matches a (possibly wildcarded) entry in a namelist.
1715 ********************************************************************/
1717 bool is_in_path(const char *name, name_compare_entry *namelist, bool case_sensitive)
1719 const char *last_component;
1721 /* if we have no list it's obviously not in the path */
1722 if((namelist == NULL ) || ((namelist != NULL) && (namelist[0].name == NULL))) {
1726 DEBUG(8, ("is_in_path: %s\n", name));
1728 /* Get the last component of the unix name. */
1729 last_component = strrchr_m(name, '/');
1730 if (!last_component) {
1731 last_component = name;
1733 last_component++; /* Go past '/' */
1736 for(; namelist->name != NULL; namelist++) {
1737 if(namelist->is_wild) {
1738 if (mask_match(last_component, namelist->name, case_sensitive)) {
1739 DEBUG(8,("is_in_path: mask match succeeded\n"));
1743 if((case_sensitive && (strcmp(last_component, namelist->name) == 0))||
1744 (!case_sensitive && (StrCaseCmp(last_component, namelist->name) == 0))) {
1745 DEBUG(8,("is_in_path: match succeeded\n"));
1750 DEBUG(8,("is_in_path: match not found\n"));
1754 /*******************************************************************
1755 Strip a '/' separated list into an array of
1756 name_compare_enties structures suitable for
1757 passing to is_in_path(). We do this for
1758 speed so we can pre-parse all the names in the list
1759 and don't do it for each call to is_in_path().
1760 namelist is modified here and is assumed to be
1761 a copy owned by the caller.
1762 We also check if the entry contains a wildcard to
1763 remove a potentially expensive call to mask_match
1765 ********************************************************************/
1767 void set_namearray(name_compare_entry **ppname_array, const char *namelist)
1770 const char *nameptr = namelist;
1771 int num_entries = 0;
1774 (*ppname_array) = NULL;
1776 if((nameptr == NULL ) || ((nameptr != NULL) && (*nameptr == '\0')))
1779 /* We need to make two passes over the string. The
1780 first to count the number of elements, the second
1785 if ( *nameptr == '/' ) {
1786 /* cope with multiple (useless) /s) */
1790 /* find the next / */
1791 name_end = strchr_m(nameptr, '/');
1793 /* oops - the last check for a / didn't find one. */
1794 if (name_end == NULL)
1797 /* next segment please */
1798 nameptr = name_end + 1;
1802 if(num_entries == 0)
1805 if(( (*ppname_array) = SMB_MALLOC_ARRAY(name_compare_entry, num_entries + 1)) == NULL) {
1806 DEBUG(0,("set_namearray: malloc fail\n"));
1810 /* Now copy out the names */
1814 if ( *nameptr == '/' ) {
1815 /* cope with multiple (useless) /s) */
1819 /* find the next / */
1820 if ((name_end = strchr_m(nameptr, '/')) != NULL)
1823 /* oops - the last check for a / didn't find one. */
1824 if(name_end == NULL)
1827 (*ppname_array)[i].is_wild = ms_has_wild(nameptr);
1828 if(((*ppname_array)[i].name = SMB_STRDUP(nameptr)) == NULL) {
1829 DEBUG(0,("set_namearray: malloc fail (1)\n"));
1833 /* next segment please */
1834 nameptr = name_end + 1;
1838 (*ppname_array)[i].name = NULL;
1843 /****************************************************************************
1844 Routine to free a namearray.
1845 ****************************************************************************/
1847 void free_namearray(name_compare_entry *name_array)
1851 if(name_array == NULL)
1854 for(i=0; name_array[i].name!=NULL; i++)
1855 SAFE_FREE(name_array[i].name);
1856 SAFE_FREE(name_array);
1860 #define DBGC_CLASS DBGC_LOCKING
1862 /****************************************************************************
1863 Simple routine to query existing file locks. Cruft in NFS and 64->32 bit mapping
1864 is dealt with in posix.c
1865 Returns True if we have information regarding this lock region (and returns
1866 F_UNLCK in *ptype if the region is unlocked). False if the call failed.
1867 ****************************************************************************/
1869 bool fcntl_getlock(int fd, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype, pid_t *ppid)
1871 SMB_STRUCT_FLOCK lock;
1874 DEBUG(8,("fcntl_getlock fd=%d offset=%.0f count=%.0f type=%d\n",
1875 fd,(double)*poffset,(double)*pcount,*ptype));
1877 lock.l_type = *ptype;
1878 lock.l_whence = SEEK_SET;
1879 lock.l_start = *poffset;
1880 lock.l_len = *pcount;
1883 ret = sys_fcntl_ptr(fd,SMB_F_GETLK,&lock);
1887 DEBUG(3,("fcntl_getlock: lock request failed at offset %.0f count %.0f type %d (%s)\n",
1888 (double)*poffset,(double)*pcount,*ptype,strerror(errno)));
1893 *ptype = lock.l_type;
1894 *poffset = lock.l_start;
1895 *pcount = lock.l_len;
1898 DEBUG(3,("fcntl_getlock: fd %d is returned info %d pid %u\n",
1899 fd, (int)lock.l_type, (unsigned int)lock.l_pid));
1904 #define DBGC_CLASS DBGC_ALL
1906 /*******************************************************************
1907 Is the name specified one of my netbios names.
1908 Returns true if it is equal, false otherwise.
1909 ********************************************************************/
1911 bool is_myname(const char *s)
1916 for (n=0; my_netbios_names(n); n++) {
1917 if (strequal(my_netbios_names(n), s)) {
1922 DEBUG(8, ("is_myname(\"%s\") returns %d\n", s, ret));
1926 /*******************************************************************
1927 Is the name specified our workgroup/domain.
1928 Returns true if it is equal, false otherwise.
1929 ********************************************************************/
1931 bool is_myworkgroup(const char *s)
1935 if (strequal(s, lp_workgroup())) {
1939 DEBUG(8, ("is_myworkgroup(\"%s\") returns %d\n", s, ret));
1943 /*******************************************************************
1944 we distinguish between 2K and XP by the "Native Lan Manager" string
1945 WinXP => "Windows 2002 5.1"
1946 WinXP 64bit => "Windows XP 5.2"
1947 Win2k => "Windows 2000 5.0"
1948 NT4 => "Windows NT 4.0"
1949 Win9x => "Windows 4.0"
1950 Windows 2003 doesn't set the native lan manager string but
1951 they do set the domain to "Windows 2003 5.2" (probably a bug).
1952 ********************************************************************/
1954 void ra_lanman_string( const char *native_lanman )
1956 if ( strcmp( native_lanman, "Windows 2002 5.1" ) == 0 )
1957 set_remote_arch( RA_WINXP );
1958 else if ( strcmp( native_lanman, "Windows XP 5.2" ) == 0 )
1959 set_remote_arch( RA_WINXP64 );
1960 else if ( strcmp( native_lanman, "Windows Server 2003 5.2" ) == 0 )
1961 set_remote_arch( RA_WIN2K3 );
1964 static const char *remote_arch_str;
1966 const char *get_remote_arch_str(void)
1968 if (!remote_arch_str) {
1971 return remote_arch_str;
1974 /*******************************************************************
1975 Set the horrid remote_arch string based on an enum.
1976 ********************************************************************/
1978 void set_remote_arch(enum remote_arch_types type)
1983 remote_arch_str = "WfWg";
1986 remote_arch_str = "OS2";
1989 remote_arch_str = "Win95";
1992 remote_arch_str = "WinNT";
1995 remote_arch_str = "Win2K";
1998 remote_arch_str = "WinXP";
2001 remote_arch_str = "WinXP64";
2004 remote_arch_str = "Win2K3";
2007 remote_arch_str = "Vista";
2010 remote_arch_str = "Samba";
2013 remote_arch_str = "CIFSFS";
2016 ra_type = RA_UNKNOWN;
2017 remote_arch_str = "UNKNOWN";
2021 DEBUG(10,("set_remote_arch: Client arch is \'%s\'\n",
2025 /*******************************************************************
2026 Get the remote_arch type.
2027 ********************************************************************/
2029 enum remote_arch_types get_remote_arch(void)
2034 const char *tab_depth(int level, int depth)
2036 if( CHECK_DEBUGLVL(level) ) {
2037 dbgtext("%*s", depth*4, "");
2042 /*****************************************************************************
2043 Provide a checksum on a string
2045 Input: s - the null-terminated character string for which the checksum
2048 Output: The checksum value calculated for s.
2049 *****************************************************************************/
2051 int str_checksum(const char *s)
2059 res ^= (c << (i % 15)) ^ (c >> (15-(i%15)));
2066 /*****************************************************************
2067 Zero a memory area then free it. Used to catch bugs faster.
2068 *****************************************************************/
2070 void zero_free(void *p, size_t size)
2076 /*****************************************************************
2077 Set our open file limit to a requested max and return the limit.
2078 *****************************************************************/
2080 int set_maxfiles(int requested_max)
2082 #if (defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE))
2084 int saved_current_limit;
2086 if(getrlimit(RLIMIT_NOFILE, &rlp)) {
2087 DEBUG(0,("set_maxfiles: getrlimit (1) for RLIMIT_NOFILE failed with error %s\n",
2090 return requested_max;
2094 * Set the fd limit to be real_max_open_files + MAX_OPEN_FUDGEFACTOR to
2095 * account for the extra fd we need
2096 * as well as the log files and standard
2097 * handles etc. Save the limit we want to set in case
2098 * we are running on an OS that doesn't support this limit (AIX)
2099 * which always returns RLIM_INFINITY for rlp.rlim_max.
2102 /* Try raising the hard (max) limit to the requested amount. */
2104 #if defined(RLIM_INFINITY)
2105 if (rlp.rlim_max != RLIM_INFINITY) {
2106 int orig_max = rlp.rlim_max;
2108 if ( rlp.rlim_max < requested_max )
2109 rlp.rlim_max = requested_max;
2111 /* This failing is not an error - many systems (Linux) don't
2112 support our default request of 10,000 open files. JRA. */
2114 if(setrlimit(RLIMIT_NOFILE, &rlp)) {
2115 DEBUG(3,("set_maxfiles: setrlimit for RLIMIT_NOFILE for %d max files failed with error %s\n",
2116 (int)rlp.rlim_max, strerror(errno) ));
2118 /* Set failed - restore original value from get. */
2119 rlp.rlim_max = orig_max;
2124 /* Now try setting the soft (current) limit. */
2126 saved_current_limit = rlp.rlim_cur = MIN(requested_max,rlp.rlim_max);
2128 if(setrlimit(RLIMIT_NOFILE, &rlp)) {
2129 DEBUG(0,("set_maxfiles: setrlimit for RLIMIT_NOFILE for %d files failed with error %s\n",
2130 (int)rlp.rlim_cur, strerror(errno) ));
2132 return saved_current_limit;
2135 if(getrlimit(RLIMIT_NOFILE, &rlp)) {
2136 DEBUG(0,("set_maxfiles: getrlimit (2) for RLIMIT_NOFILE failed with error %s\n",
2139 return saved_current_limit;
2142 #if defined(RLIM_INFINITY)
2143 if(rlp.rlim_cur == RLIM_INFINITY)
2144 return saved_current_limit;
2147 if((int)rlp.rlim_cur > saved_current_limit)
2148 return saved_current_limit;
2150 return rlp.rlim_cur;
2151 #else /* !defined(HAVE_GETRLIMIT) || !defined(RLIMIT_NOFILE) */
2153 * No way to know - just guess...
2155 return requested_max;
2159 /*****************************************************************
2160 Possibly replace mkstemp if it is broken.
2161 *****************************************************************/
2163 int smb_mkstemp(char *name_template)
2165 #if HAVE_SECURE_MKSTEMP
2166 return mkstemp(name_template);
2168 /* have a reasonable go at emulating it. Hope that
2169 the system mktemp() isn't completly hopeless */
2170 char *p = mktemp(name_template);
2173 return open(p, O_CREAT|O_EXCL|O_RDWR, 0600);
2177 /*****************************************************************
2178 malloc that aborts with smb_panic on fail or zero size.
2179 *****************************************************************/
2181 void *smb_xmalloc_array(size_t size, unsigned int count)
2185 smb_panic("smb_xmalloc_array: called with zero size");
2187 if (count >= MAX_ALLOC_SIZE/size) {
2188 smb_panic("smb_xmalloc_array: alloc size too large");
2190 if ((p = SMB_MALLOC(size*count)) == NULL) {
2191 DEBUG(0, ("smb_xmalloc_array failed to allocate %lu * %lu bytes\n",
2192 (unsigned long)size, (unsigned long)count));
2193 smb_panic("smb_xmalloc_array: malloc failed");
2199 vasprintf that aborts on malloc fail
2202 int smb_xvasprintf(char **ptr, const char *format, va_list ap)
2209 n = vasprintf(ptr, format, ap2);
2210 if (n == -1 || ! *ptr) {
2211 smb_panic("smb_xvasprintf: out of memory");
2217 /*****************************************************************
2218 Get local hostname and cache result.
2219 *****************************************************************/
2221 char *myhostname(void)
2225 /* This is cached forever so
2226 * use talloc_autofree_context() ctx. */
2227 ret = talloc_get_myname(talloc_autofree_context());
2232 /*****************************************************************
2233 A useful function for returning a path in the Samba pid directory.
2234 *****************************************************************/
2236 static char *xx_path(const char *name, const char *rootpath)
2240 fname = talloc_strdup(talloc_tos(), rootpath);
2244 trim_string(fname,"","/");
2246 if (!directory_exist(fname)) {
2250 return talloc_asprintf(talloc_tos(),
2256 /*****************************************************************
2257 A useful function for returning a path in the Samba lock directory.
2258 *****************************************************************/
2260 char *lock_path(const char *name)
2262 return xx_path(name, lp_lockdir());
2265 /*****************************************************************
2266 A useful function for returning a path in the Samba pid directory.
2267 *****************************************************************/
2269 char *pid_path(const char *name)
2271 return xx_path(name, lp_piddir());
2275 * @brief Returns an absolute path to a file in the Samba lib directory.
2277 * @param name File to find, relative to LIBDIR.
2279 * @retval Pointer to a string containing the full path.
2282 char *lib_path(const char *name)
2284 return talloc_asprintf(talloc_tos(), "%s/%s", get_dyn_LIBDIR(), name);
2288 * @brief Returns an absolute path to a file in the Samba modules directory.
2290 * @param name File to find, relative to MODULESDIR.
2292 * @retval Pointer to a string containing the full path.
2295 char *modules_path(const char *name)
2297 return talloc_asprintf(talloc_tos(), "%s/%s", get_dyn_MODULESDIR(), name);
2301 * @brief Returns an absolute path to a file in the Samba data directory.
2303 * @param name File to find, relative to CODEPAGEDIR.
2305 * @retval Pointer to a talloc'ed string containing the full path.
2308 char *data_path(const char *name)
2310 return talloc_asprintf(talloc_tos(), "%s/%s", get_dyn_CODEPAGEDIR(), name);
2313 /*****************************************************************
2314 a useful function for returning a path in the Samba state directory
2315 *****************************************************************/
2317 char *state_path(const char *name)
2319 return xx_path(name, get_dyn_STATEDIR());
2323 * @brief Returns the platform specific shared library extension.
2325 * @retval Pointer to a const char * containing the extension.
2328 const char *shlib_ext(void)
2330 return get_dyn_SHLIBEXT();
2333 /*******************************************************************
2334 Given a filename - get its directory name
2335 ********************************************************************/
2337 bool parent_dirname(TALLOC_CTX *mem_ctx, const char *dir, char **parent,
2343 p = strrchr_m(dir, '/'); /* Find final '/', if any */
2346 if (!(*parent = talloc_strdup(mem_ctx, "."))) {
2357 if (!(*parent = (char *)TALLOC_MEMDUP(mem_ctx, dir, len+1))) {
2360 (*parent)[len] = '\0';
2368 /*******************************************************************
2369 Determine if a pattern contains any Microsoft wildcard characters.
2370 *******************************************************************/
2372 bool ms_has_wild(const char *s)
2376 if (lp_posix_pathnames()) {
2377 /* With posix pathnames no characters are wild. */
2381 while ((c = *s++)) {
2394 bool ms_has_wild_w(const smb_ucs2_t *s)
2397 if (!s) return False;
2398 while ((c = *s++)) {
2400 case UCS2_CHAR('*'):
2401 case UCS2_CHAR('?'):
2402 case UCS2_CHAR('<'):
2403 case UCS2_CHAR('>'):
2404 case UCS2_CHAR('"'):
2411 /*******************************************************************
2412 A wrapper that handles case sensitivity and the special handling
2414 *******************************************************************/
2416 bool mask_match(const char *string, const char *pattern, bool is_case_sensitive)
2418 if (strcmp(string,"..") == 0)
2420 if (strcmp(pattern,".") == 0)
2423 return ms_fnmatch(pattern, string, Protocol <= PROTOCOL_LANMAN2, is_case_sensitive) == 0;
2426 /*******************************************************************
2427 A wrapper that handles case sensitivity and the special handling
2428 of the ".." name. Varient that is only called by old search code which requires
2429 pattern translation.
2430 *******************************************************************/
2432 bool mask_match_search(const char *string, const char *pattern, bool is_case_sensitive)
2434 if (strcmp(string,"..") == 0)
2436 if (strcmp(pattern,".") == 0)
2439 return ms_fnmatch(pattern, string, True, is_case_sensitive) == 0;
2442 /*******************************************************************
2443 A wrapper that handles a list of patters and calls mask_match()
2444 on each. Returns True if any of the patterns match.
2445 *******************************************************************/
2447 bool mask_match_list(const char *string, char **list, int listLen, bool is_case_sensitive)
2449 while (listLen-- > 0) {
2450 if (mask_match(string, *list++, is_case_sensitive))
2456 /*********************************************************
2457 Recursive routine that is called by unix_wild_match.
2458 *********************************************************/
2460 static bool unix_do_match(const char *regexp, const char *str)
2464 for( p = regexp; *p && *str; ) {
2475 * Look for a character matching
2476 * the one after the '*'.
2480 return true; /* Automatic match */
2483 while(*str && (*p != *str))
2487 * Patch from weidel@multichart.de. In the case of the regexp
2488 * '*XX*' we want to ensure there are at least 2 'X' characters
2489 * in the string after the '*' for a match to be made.
2496 * Eat all the characters that match, but count how many there were.
2499 while(*str && (*p == *str)) {
2505 * Now check that if the regexp had n identical characters that
2506 * matchcount had at least that many matches.
2509 while ( *(p+1) && (*(p+1) == *p)) {
2514 if ( matchcount <= 0 )
2518 str--; /* We've eaten the match char after the '*' */
2520 if(unix_do_match(p, str))
2542 if (!*p && str[0] == '.' && str[1] == 0)
2545 if (!*str && *p == '?') {
2551 if(!*str && (*p == '*' && p[1] == '\0'))
2557 /*******************************************************************
2558 Simple case insensitive interface to a UNIX wildcard matcher.
2559 Returns True if match, False if not.
2560 *******************************************************************/
2562 bool unix_wild_match(const char *pattern, const char *string)
2564 TALLOC_CTX *ctx = talloc_stackframe();
2570 p2 = talloc_strdup(ctx,pattern);
2571 s2 = talloc_strdup(ctx,string);
2579 /* Remove any *? and ** from the pattern as they are meaningless */
2580 for(p = p2; *p; p++) {
2581 while( *p == '*' && (p[1] == '?' ||p[1] == '*')) {
2582 memmove(&p[1], &p[2], strlen(&p[2])+1);
2586 if (strequal(p2,"*")) {
2591 ret = unix_do_match(p2, s2);
2596 /**********************************************************************
2597 Converts a name to a fully qualified domain name.
2598 Returns true if lookup succeeded, false if not (then fqdn is set to name)
2599 Note we deliberately use gethostbyname here, not getaddrinfo as we want
2600 to examine the h_aliases and I don't know how to do that with getaddrinfo.
2601 ***********************************************************************/
2603 bool name_to_fqdn(fstring fqdn, const char *name)
2606 struct hostent *hp = gethostbyname(name);
2608 if (!hp || !hp->h_name || !*hp->h_name) {
2609 DEBUG(10,("name_to_fqdn: lookup for %s failed.\n", name));
2610 fstrcpy(fqdn, name);
2614 /* Find out if the fqdn is returned as an alias
2615 * to cope with /etc/hosts files where the first
2616 * name is not the fqdn but the short name */
2617 if (hp->h_aliases && (! strchr_m(hp->h_name, '.'))) {
2619 for (i = 0; hp->h_aliases[i]; i++) {
2620 if (strchr_m(hp->h_aliases[i], '.')) {
2621 full = hp->h_aliases[i];
2626 if (full && (StrCaseCmp(full, "localhost.localdomain") == 0)) {
2627 DEBUG(1, ("WARNING: your /etc/hosts file may be broken!\n"));
2628 DEBUGADD(1, (" Specifing the machine hostname for address 127.0.0.1 may lead\n"));
2629 DEBUGADD(1, (" to Kerberos authentication problems as localhost.localdomain\n"));
2630 DEBUGADD(1, (" may end up being used instead of the real machine FQDN.\n"));
2637 DEBUG(10,("name_to_fqdn: lookup for %s -> %s.\n", name, full));
2638 fstrcpy(fqdn, full);
2642 /**********************************************************************
2643 Append a DATA_BLOB to a talloc'ed object
2644 ***********************************************************************/
2646 void *talloc_append_blob(TALLOC_CTX *mem_ctx, void *buf, DATA_BLOB blob)
2648 size_t old_size = 0;
2651 if (blob.length == 0) {
2656 old_size = talloc_get_size(buf);
2659 result = (char *)TALLOC_REALLOC(mem_ctx, buf, old_size + blob.length);
2660 if (result == NULL) {
2664 memcpy(result + old_size, blob.data, blob.length);
2668 uint32 map_share_mode_to_deny_mode(uint32 share_access, uint32 private_options)
2670 switch (share_access & ~FILE_SHARE_DELETE) {
2671 case FILE_SHARE_NONE:
2673 case FILE_SHARE_READ:
2675 case FILE_SHARE_WRITE:
2677 case FILE_SHARE_READ|FILE_SHARE_WRITE:
2680 if (private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS) {
2682 } else if (private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_FCB) {
2689 pid_t procid_to_pid(const struct server_id *proc)
2694 static uint32 my_vnn = NONCLUSTER_VNN;
2696 void set_my_vnn(uint32 vnn)
2698 DEBUG(10, ("vnn pid %d = %u\n", (int)sys_getpid(), (unsigned int)vnn));
2702 uint32 get_my_vnn(void)
2707 struct server_id pid_to_procid(pid_t pid)
2709 struct server_id result;
2711 #ifdef CLUSTER_SUPPORT
2712 result.vnn = my_vnn;
2717 struct server_id procid_self(void)
2719 return pid_to_procid(sys_getpid());
2722 struct server_id server_id_self(void)
2724 return procid_self();
2727 bool procid_equal(const struct server_id *p1, const struct server_id *p2)
2729 if (p1->pid != p2->pid)
2731 #ifdef CLUSTER_SUPPORT
2732 if (p1->vnn != p2->vnn)
2738 bool cluster_id_equal(const struct server_id *id1,
2739 const struct server_id *id2)
2741 return procid_equal(id1, id2);
2744 bool procid_is_me(const struct server_id *pid)
2746 if (pid->pid != sys_getpid())
2748 #ifdef CLUSTER_SUPPORT
2749 if (pid->vnn != my_vnn)
2755 struct server_id interpret_pid(const char *pid_string)
2757 #ifdef CLUSTER_SUPPORT
2758 unsigned int vnn, pid;
2759 struct server_id result;
2760 if (sscanf(pid_string, "%u:%u", &vnn, &pid) == 2) {
2764 else if (sscanf(pid_string, "%u", &pid) == 1) {
2765 result.vnn = get_my_vnn();
2769 result.vnn = NONCLUSTER_VNN;
2774 return pid_to_procid(atoi(pid_string));
2778 char *procid_str(TALLOC_CTX *mem_ctx, const struct server_id *pid)
2780 #ifdef CLUSTER_SUPPORT
2781 if (pid->vnn == NONCLUSTER_VNN) {
2782 return talloc_asprintf(mem_ctx,
2787 return talloc_asprintf(mem_ctx,
2793 return talloc_asprintf(mem_ctx,
2799 char *procid_str_static(const struct server_id *pid)
2801 return procid_str(talloc_tos(), pid);
2804 bool procid_valid(const struct server_id *pid)
2806 return (pid->pid != -1);
2809 bool procid_is_local(const struct server_id *pid)
2811 #ifdef CLUSTER_SUPPORT
2812 return pid->vnn == my_vnn;
2818 int this_is_smp(void)
2820 #if defined(HAVE_SYSCONF)
2822 #if defined(SYSCONF_SC_NPROC_ONLN)
2823 return (sysconf(_SC_NPROC_ONLN) > 1) ? 1 : 0;
2824 #elif defined(SYSCONF_SC_NPROCESSORS_ONLN)
2825 return (sysconf(_SC_NPROCESSORS_ONLN) > 1) ? 1 : 0;
2835 /****************************************************************
2836 Check if offset/length fit into bufsize. Should probably be
2837 merged with is_offset_safe, but this would require a rewrite
2838 of lanman.c. Later :-)
2839 ****************************************************************/
2841 bool trans_oob(uint32_t bufsize, uint32_t offset, uint32_t length)
2843 if ((offset + length < offset) || (offset + length < length)) {
2847 if ((offset > bufsize) || (offset + length > bufsize)) {
2854 /****************************************************************
2855 Check if an offset into a buffer is safe.
2856 If this returns True it's safe to indirect into the byte at
2858 ****************************************************************/
2860 bool is_offset_safe(const char *buf_base, size_t buf_len, char *ptr, size_t off)
2862 const char *end_base = buf_base + buf_len;
2863 char *end_ptr = ptr + off;
2865 if (!buf_base || !ptr) {
2869 if (end_base < buf_base || end_ptr < ptr) {
2870 return False; /* wrap. */
2873 if (end_ptr < end_base) {
2879 /****************************************************************
2880 Return a safe pointer into a buffer, or NULL.
2881 ****************************************************************/
2883 char *get_safe_ptr(const char *buf_base, size_t buf_len, char *ptr, size_t off)
2885 return is_offset_safe(buf_base, buf_len, ptr, off) ?
2889 /****************************************************************
2890 Return a safe pointer into a string within a buffer, or NULL.
2891 ****************************************************************/
2893 char *get_safe_str_ptr(const char *buf_base, size_t buf_len, char *ptr, size_t off)
2895 if (!is_offset_safe(buf_base, buf_len, ptr, off)) {
2898 /* Check if a valid string exists at this offset. */
2899 if (skip_string(buf_base,buf_len, ptr + off) == NULL) {
2905 /****************************************************************
2906 Return an SVAL at a pointer, or failval if beyond the end.
2907 ****************************************************************/
2909 int get_safe_SVAL(const char *buf_base, size_t buf_len, char *ptr, size_t off, int failval)
2912 * Note we use off+1 here, not off+2 as SVAL accesses ptr[0] and ptr[1],
2915 if (!is_offset_safe(buf_base, buf_len, ptr, off+1)) {
2918 return SVAL(ptr,off);
2921 /****************************************************************
2922 Return an IVAL at a pointer, or failval if beyond the end.
2923 ****************************************************************/
2925 int get_safe_IVAL(const char *buf_base, size_t buf_len, char *ptr, size_t off, int failval)
2928 * Note we use off+3 here, not off+4 as IVAL accesses
2929 * ptr[0] ptr[1] ptr[2] ptr[3] NOT ptr[4].
2931 if (!is_offset_safe(buf_base, buf_len, ptr, off+3)) {
2934 return IVAL(ptr,off);
2937 /****************************************************************
2938 Split DOM\user into DOM and user. Do not mix with winbind variants of that
2939 call (they take care of winbind separator and other winbind specific settings).
2940 ****************************************************************/
2942 void split_domain_user(TALLOC_CTX *mem_ctx,
2943 const char *full_name,
2947 const char *p = NULL;
2949 p = strchr_m(full_name, '\\');
2952 *domain = talloc_strndup(mem_ctx, full_name,
2953 PTR_DIFF(p, full_name));
2954 *user = talloc_strdup(mem_ctx, p+1);
2956 *domain = talloc_strdup(mem_ctx, "");
2957 *user = talloc_strdup(mem_ctx, full_name);
2963 Disable these now we have checked all code paths and ensured
2964 NULL returns on zero request. JRA.
2966 /****************************************************************
2967 talloc wrapper functions that guarentee a null pointer return
2969 ****************************************************************/
2971 #ifndef MAX_TALLOC_SIZE
2972 #define MAX_TALLOC_SIZE 0x10000000
2976 * talloc and zero memory.
2977 * - returns NULL if size is zero.
2980 void *_talloc_zero_zeronull(const void *ctx, size_t size, const char *name)
2988 p = talloc_named_const(ctx, size, name);
2991 memset(p, '\0', size);
2998 * memdup with a talloc.
2999 * - returns NULL if size is zero.
3002 void *_talloc_memdup_zeronull(const void *t, const void *p, size_t size, const char *name)
3010 newp = talloc_named_const(t, size, name);
3012 memcpy(newp, p, size);
3019 * alloc an array, checking for integer overflow in the array size.
3020 * - returns NULL if count or el_size are zero.
3023 void *_talloc_array_zeronull(const void *ctx, size_t el_size, unsigned count, const char *name)
3025 if (count >= MAX_TALLOC_SIZE/el_size) {
3029 if (el_size == 0 || count == 0) {
3033 return talloc_named_const(ctx, el_size * count, name);
3037 * alloc an zero array, checking for integer overflow in the array size
3038 * - returns NULL if count or el_size are zero.
3041 void *_talloc_zero_array_zeronull(const void *ctx, size_t el_size, unsigned count, const char *name)
3043 if (count >= MAX_TALLOC_SIZE/el_size) {
3047 if (el_size == 0 || count == 0) {
3051 return _talloc_zero(ctx, el_size * count, name);
3055 * Talloc wrapper that returns NULL if size == 0.
3057 void *talloc_zeronull(const void *context, size_t size, const char *name)
3062 return talloc_named_const(context, size, name);
3066 /* Split a path name into filename and stream name components. Canonicalise
3067 * such that an implicit $DATA token is always explicit.
3069 * The "specification" of this function can be found in the
3070 * run_local_stream_name() function in torture.c, I've tried those
3071 * combinations against a W2k3 server.
3074 NTSTATUS split_ntfs_stream_name(TALLOC_CTX *mem_ctx, const char *fname,
3075 char **pbase, char **pstream)
3078 char *stream = NULL;
3079 char *sname; /* stream name */
3080 const char *stype; /* stream type */
3082 DEBUG(10, ("split_ntfs_stream_name called for [%s]\n", fname));
3084 sname = strchr_m(fname, ':');
3086 if (lp_posix_pathnames() || (sname == NULL)) {
3087 if (pbase != NULL) {
3088 base = talloc_strdup(mem_ctx, fname);
3089 NT_STATUS_HAVE_NO_MEMORY(base);
3094 if (pbase != NULL) {
3095 base = talloc_strndup(mem_ctx, fname, PTR_DIFF(sname, fname));
3096 NT_STATUS_HAVE_NO_MEMORY(base);
3101 stype = strchr_m(sname, ':');
3103 if (stype == NULL) {
3104 sname = talloc_strdup(mem_ctx, sname);
3108 if (StrCaseCmp(stype, ":$DATA") != 0) {
3110 * If there is an explicit stream type, so far we only
3111 * allow $DATA. Is there anything else allowed? -- vl
3113 DEBUG(10, ("[%s] is an invalid stream type\n", stype));
3115 return NT_STATUS_OBJECT_NAME_INVALID;
3117 sname = talloc_strndup(mem_ctx, sname, PTR_DIFF(stype, sname));
3121 if (sname == NULL) {
3123 return NT_STATUS_NO_MEMORY;
3126 if (sname[0] == '\0') {
3128 * no stream name, so no stream
3133 if (pstream != NULL) {
3134 stream = talloc_asprintf(mem_ctx, "%s:%s", sname, stype);
3135 if (stream == NULL) {
3138 return NT_STATUS_NO_MEMORY;
3141 * upper-case the type field
3143 strupper_m(strchr_m(stream, ':')+1);
3147 if (pbase != NULL) {
3150 if (pstream != NULL) {
3153 return NT_STATUS_OK;
3156 bool is_valid_policy_hnd(const POLICY_HND *hnd)
3160 return (memcmp(&tmp, hnd, sizeof(tmp)) != 0);
3163 bool policy_hnd_equal(const struct policy_handle *hnd1,
3164 const struct policy_handle *hnd2)
3166 if (!hnd1 || !hnd2) {
3170 return (memcmp(hnd1, hnd2, sizeof(*hnd1)) == 0);
3173 /****************************************************************
3174 strip off leading '\\' from a hostname
3175 ****************************************************************/
3177 const char *strip_hostname(const char *s)
3183 if (strlen_m(s) < 3) {
3187 if (s[0] == '\\') s++;
3188 if (s[0] == '\\') s++;