2 Unix SMB/CIFS implementation.
3 Samba utility functions
4 Copyright (C) Andrew Tridgell 1992-1998
5 Copyright (C) Jeremy Allison 2001-2002
6 Copyright (C) Simo Sorce 2001
7 Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2003
8 Copyright (C) James Peach 2006
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27 extern fstring local_machine
;
28 extern char *global_clobber_region_function
;
29 extern unsigned int global_clobber_region_line
;
30 extern fstring remote_arch
;
32 /* Max allowable allococation - 256mb - 0x10000000 */
33 #define MAX_ALLOC_SIZE (1024*1024*256)
35 #if (defined(HAVE_NETGROUP) && defined (WITH_AUTOMOUNT))
36 #ifdef WITH_NISPLUS_HOME
37 #ifdef BROKEN_NISPLUS_INCLUDE_FILES
39 * The following lines are needed due to buggy include files
40 * in Solaris 2.6 which define GROUP in both /usr/include/sys/acl.h and
41 * also in /usr/include/rpcsvc/nis.h. The definitions conflict. JRA.
42 * Also GROUP_OBJ is defined as 0x4 in /usr/include/sys/acl.h and as
43 * an enum in /usr/include/rpcsvc/nis.h.
50 #if defined(GROUP_OBJ)
54 #endif /* BROKEN_NISPLUS_INCLUDE_FILES */
56 #include <rpcsvc/nis.h>
58 #endif /* WITH_NISPLUS_HOME */
59 #endif /* HAVE_NETGROUP && WITH_AUTOMOUNT */
61 enum protocol_types Protocol
= PROTOCOL_COREPLUS
;
63 /* a default finfo structure to ensure all fields are sensible */
64 file_info def_finfo
= {-1,0,0,0,0,0,0,"",""};
66 /* this is used by the chaining code */
71 static enum remote_arch_types ra_type
= RA_UNKNOWN
;
72 pstring user_socket_options
=DEFAULT_SOCKET_OPTIONS
;
74 /***********************************************************************
75 Definitions for all names.
76 ***********************************************************************/
78 static char *smb_myname
;
79 static char *smb_myworkgroup
;
80 static char *smb_scope
;
81 static int smb_num_netbios_names
;
82 static char **smb_my_netbios_names
;
84 /***********************************************************************
85 Allocate and set myname. Ensure upper case.
86 ***********************************************************************/
88 BOOL
set_global_myname(const char *myname
)
90 SAFE_FREE(smb_myname
);
91 smb_myname
= SMB_STRDUP(myname
);
94 strupper_m(smb_myname
);
98 const char *global_myname(void)
103 /***********************************************************************
104 Allocate and set myworkgroup. Ensure upper case.
105 ***********************************************************************/
107 BOOL
set_global_myworkgroup(const char *myworkgroup
)
109 SAFE_FREE(smb_myworkgroup
);
110 smb_myworkgroup
= SMB_STRDUP(myworkgroup
);
111 if (!smb_myworkgroup
)
113 strupper_m(smb_myworkgroup
);
117 const char *lp_workgroup(void)
119 return smb_myworkgroup
;
122 /***********************************************************************
123 Allocate and set scope. Ensure upper case.
124 ***********************************************************************/
126 BOOL
set_global_scope(const char *scope
)
128 SAFE_FREE(smb_scope
);
129 smb_scope
= SMB_STRDUP(scope
);
132 strupper_m(smb_scope
);
136 /*********************************************************************
137 Ensure scope is never null string.
138 *********************************************************************/
140 const char *global_scope(void)
143 set_global_scope("");
147 static void free_netbios_names_array(void)
151 for (i
= 0; i
< smb_num_netbios_names
; i
++)
152 SAFE_FREE(smb_my_netbios_names
[i
]);
154 SAFE_FREE(smb_my_netbios_names
);
155 smb_num_netbios_names
= 0;
158 static BOOL
allocate_my_netbios_names_array(size_t number
)
160 free_netbios_names_array();
162 smb_num_netbios_names
= number
+ 1;
163 smb_my_netbios_names
= SMB_MALLOC_ARRAY( char *, smb_num_netbios_names
);
165 if (!smb_my_netbios_names
)
168 memset(smb_my_netbios_names
, '\0', sizeof(char *) * smb_num_netbios_names
);
172 static BOOL
set_my_netbios_names(const char *name
, int i
)
174 SAFE_FREE(smb_my_netbios_names
[i
]);
176 smb_my_netbios_names
[i
] = SMB_STRDUP(name
);
177 if (!smb_my_netbios_names
[i
])
179 strupper_m(smb_my_netbios_names
[i
]);
183 /***********************************************************************
184 Free memory allocated to global objects
185 ***********************************************************************/
187 void gfree_names(void)
189 SAFE_FREE( smb_myname
);
190 SAFE_FREE( smb_myworkgroup
);
191 SAFE_FREE( smb_scope
);
192 free_netbios_names_array();
195 void gfree_all( void )
204 /* release the talloc null_context memory last */
208 const char *my_netbios_names(int i
)
210 return smb_my_netbios_names
[i
];
213 BOOL
set_netbios_aliases(const char **str_array
)
217 /* Work out the max number of netbios aliases that we have */
218 for( namecount
=0; str_array
&& (str_array
[namecount
] != NULL
); namecount
++ )
221 if ( global_myname() && *global_myname())
224 /* Allocate space for the netbios aliases */
225 if (!allocate_my_netbios_names_array(namecount
))
228 /* Use the global_myname string first */
230 if ( global_myname() && *global_myname()) {
231 set_my_netbios_names( global_myname(), namecount
);
237 for ( i
= 0; str_array
[i
] != NULL
; i
++) {
239 BOOL duplicate
= False
;
241 /* Look for duplicates */
242 for( n
=0; n
<namecount
; n
++ ) {
243 if( strequal( str_array
[i
], my_netbios_names(n
) ) ) {
249 if (!set_my_netbios_names(str_array
[i
], namecount
))
258 /****************************************************************************
259 Common name initialization code.
260 ****************************************************************************/
262 BOOL
init_names(void)
267 if (global_myname() == NULL
|| *global_myname() == '\0') {
268 if (!set_global_myname(myhostname())) {
269 DEBUG( 0, ( "init_structs: malloc fail.\n" ) );
274 if (!set_netbios_aliases(lp_netbios_aliases())) {
275 DEBUG( 0, ( "init_structs: malloc fail.\n" ) );
279 fstrcpy( local_machine
, global_myname() );
280 trim_char( local_machine
, ' ', ' ' );
281 p
= strchr( local_machine
, ' ' );
284 strlower_m( local_machine
);
286 DEBUG( 5, ("Netbios name list:-\n") );
287 for( n
=0; my_netbios_names(n
); n
++ )
288 DEBUGADD( 5, ( "my_netbios_names[%d]=\"%s\"\n", n
, my_netbios_names(n
) ) );
293 /**************************************************************************n
294 Find a suitable temporary directory. The result should be copied immediately
295 as it may be overwritten by a subsequent call.
296 ****************************************************************************/
298 const char *tmpdir(void)
301 if ((p
= getenv("TMPDIR")))
306 /****************************************************************************
307 Add a gid to an array of gids if it's not already there.
308 ****************************************************************************/
310 void add_gid_to_array_unique(TALLOC_CTX
*mem_ctx
, gid_t gid
,
311 gid_t
**gids
, size_t *num_gids
)
315 for (i
=0; i
<*num_gids
; i
++) {
316 if ((*gids
)[i
] == gid
)
320 if (mem_ctx
!= NULL
) {
321 *gids
= TALLOC_REALLOC_ARRAY(mem_ctx
, *gids
, gid_t
, *num_gids
+1);
323 *gids
= SMB_REALLOC_ARRAY(*gids
, gid_t
, *num_gids
+1);
330 (*gids
)[*num_gids
] = gid
;
334 /****************************************************************************
335 Like atoi but gets the value up to the separator character.
336 ****************************************************************************/
338 static const char *Atoic(const char *p
, int *n
, const char *c
)
340 if (!isdigit((int)*p
)) {
341 DEBUG(5, ("Atoic: malformed number\n"));
347 while ((*p
) && isdigit((int)*p
))
350 if (strchr_m(c
, *p
) == NULL
) {
351 DEBUG(5, ("Atoic: no separator characters (%s) not found\n", c
));
358 /*************************************************************************
359 Reads a list of numbers.
360 *************************************************************************/
362 const char *get_numlist(const char *p
, uint32
**num
, int *count
)
366 if (num
== NULL
|| count
== NULL
)
372 while ((p
= Atoic(p
, &val
, ":,")) != NULL
&& (*p
) != ':') {
373 *num
= SMB_REALLOC_ARRAY((*num
), uint32
, (*count
)+1);
377 (*num
)[(*count
)] = val
;
385 /*******************************************************************
386 Check if a file exists - call vfs_file_exist for samba files.
387 ********************************************************************/
389 BOOL
file_exist(const char *fname
,SMB_STRUCT_STAT
*sbuf
)
395 if (sys_stat(fname
,sbuf
) != 0)
398 return((S_ISREG(sbuf
->st_mode
)) || (S_ISFIFO(sbuf
->st_mode
)));
401 /*******************************************************************
402 Check a files mod time.
403 ********************************************************************/
405 time_t file_modtime(const char *fname
)
409 if (sys_stat(fname
,&st
) != 0)
415 /*******************************************************************
416 Check if a directory exists.
417 ********************************************************************/
419 BOOL
directory_exist(char *dname
,SMB_STRUCT_STAT
*st
)
427 if (sys_stat(dname
,st
) != 0)
430 ret
= S_ISDIR(st
->st_mode
);
436 /*******************************************************************
437 Returns the size in bytes of the named file.
438 ********************************************************************/
440 SMB_OFF_T
get_file_size(char *file_name
)
444 if(sys_stat(file_name
,&buf
) != 0)
445 return (SMB_OFF_T
)-1;
449 /*******************************************************************
450 Return a string representing an attribute for a file.
451 ********************************************************************/
453 char *attrib_string(uint16 mode
)
455 static fstring attrstr
;
459 if (mode
& aVOLID
) fstrcat(attrstr
,"V");
460 if (mode
& aDIR
) fstrcat(attrstr
,"D");
461 if (mode
& aARCH
) fstrcat(attrstr
,"A");
462 if (mode
& aHIDDEN
) fstrcat(attrstr
,"H");
463 if (mode
& aSYSTEM
) fstrcat(attrstr
,"S");
464 if (mode
& aRONLY
) fstrcat(attrstr
,"R");
469 /*******************************************************************
470 Show a smb message structure.
471 ********************************************************************/
473 void show_msg(char *buf
)
481 DEBUG(5,("size=%d\nsmb_com=0x%x\nsmb_rcls=%d\nsmb_reh=%d\nsmb_err=%d\nsmb_flg=%d\nsmb_flg2=%d\n",
483 (int)CVAL(buf
,smb_com
),
484 (int)CVAL(buf
,smb_rcls
),
485 (int)CVAL(buf
,smb_reh
),
486 (int)SVAL(buf
,smb_err
),
487 (int)CVAL(buf
,smb_flg
),
488 (int)SVAL(buf
,smb_flg2
)));
489 DEBUGADD(5,("smb_tid=%d\nsmb_pid=%d\nsmb_uid=%d\nsmb_mid=%d\n",
490 (int)SVAL(buf
,smb_tid
),
491 (int)SVAL(buf
,smb_pid
),
492 (int)SVAL(buf
,smb_uid
),
493 (int)SVAL(buf
,smb_mid
)));
494 DEBUGADD(5,("smt_wct=%d\n",(int)CVAL(buf
,smb_wct
)));
496 for (i
=0;i
<(int)CVAL(buf
,smb_wct
);i
++)
497 DEBUGADD(5,("smb_vwv[%2d]=%5d (0x%X)\n",i
,
498 SVAL(buf
,smb_vwv
+2*i
),SVAL(buf
,smb_vwv
+2*i
)));
500 bcc
= (int)SVAL(buf
,smb_vwv
+2*(CVAL(buf
,smb_wct
)));
502 DEBUGADD(5,("smb_bcc=%d\n",bcc
));
510 dump_data(10, smb_buf(buf
), bcc
);
513 /*******************************************************************
514 Set the length and marker of an smb packet.
515 ********************************************************************/
517 void smb_setlen(char *buf
,int len
)
519 _smb_setlen(buf
,len
);
527 /*******************************************************************
528 Setup the word count and byte count for a smb message.
529 ********************************************************************/
531 int set_message(char *buf
,int num_words
,int num_bytes
,BOOL zero
)
533 if (zero
&& (num_words
|| num_bytes
)) {
534 memset(buf
+ smb_size
,'\0',num_words
*2 + num_bytes
);
536 SCVAL(buf
,smb_wct
,num_words
);
537 SSVAL(buf
,smb_vwv
+ num_words
*SIZEOFWORD
,num_bytes
);
538 smb_setlen(buf
,smb_size
+ num_words
*2 + num_bytes
- 4);
539 return (smb_size
+ num_words
*2 + num_bytes
);
542 /*******************************************************************
543 Setup only the byte count for a smb message.
544 ********************************************************************/
546 int set_message_bcc(char *buf
,int num_bytes
)
548 int num_words
= CVAL(buf
,smb_wct
);
549 SSVAL(buf
,smb_vwv
+ num_words
*SIZEOFWORD
,num_bytes
);
550 smb_setlen(buf
,smb_size
+ num_words
*2 + num_bytes
- 4);
551 return (smb_size
+ num_words
*2 + num_bytes
);
554 /*******************************************************************
555 Setup only the byte count for a smb message, using the end of the
557 ********************************************************************/
559 int set_message_end(void *outbuf
,void *end_ptr
)
561 return set_message_bcc((char *)outbuf
,PTR_DIFF(end_ptr
,smb_buf((char *)outbuf
)));
564 /*******************************************************************
565 Reduce a file name, removing .. elements.
566 ********************************************************************/
568 void dos_clean_name(char *s
)
572 DEBUG(3,("dos_clean_name [%s]\n",s
));
574 /* remove any double slashes */
575 all_string_sub(s
, "\\\\", "\\", 0);
577 while ((p
= strstr_m(s
,"\\..\\")) != NULL
) {
583 if ((p
=strrchr_m(s
,'\\')) != NULL
)
590 trim_string(s
,NULL
,"\\..");
592 all_string_sub(s
, "\\.\\", "\\", 0);
595 /*******************************************************************
596 Reduce a file name, removing .. elements.
597 ********************************************************************/
599 void unix_clean_name(char *s
)
603 DEBUG(3,("unix_clean_name [%s]\n",s
));
605 /* remove any double slashes */
606 all_string_sub(s
, "//","/", 0);
608 /* Remove leading ./ characters */
609 if(strncmp(s
, "./", 2) == 0) {
610 trim_string(s
, "./", NULL
);
615 while ((p
= strstr_m(s
,"/../")) != NULL
) {
621 if ((p
=strrchr_m(s
,'/')) != NULL
)
628 trim_string(s
,NULL
,"/..");
631 /*******************************************************************
632 Close the low 3 fd's and open dev/null in their place.
633 ********************************************************************/
635 void close_low_fds(BOOL stderr_too
)
647 /* try and use up these file descriptors, so silly
648 library routines writing to stdout etc won't cause havoc */
650 if (i
== 2 && !stderr_too
)
653 fd
= sys_open("/dev/null",O_RDWR
,0);
655 fd
= sys_open("/dev/null",O_WRONLY
,0);
657 DEBUG(0,("Can't open /dev/null\n"));
661 DEBUG(0,("Didn't get file descriptor %d\n",i
));
668 /*******************************************************************
669 Write data into an fd at a given offset. Ignore seek errors.
670 ********************************************************************/
672 ssize_t
write_data_at_offset(int fd
, const char *buffer
, size_t N
, SMB_OFF_T pos
)
677 if (pos
== (SMB_OFF_T
)-1) {
678 return write_data(fd
, buffer
, N
);
680 #if defined(HAVE_PWRITE) || defined(HAVE_PRWITE64)
682 ret
= sys_pwrite(fd
,buffer
+ total
,N
- total
, pos
);
683 if (ret
== -1 && errno
== ESPIPE
) {
684 return write_data(fd
, buffer
+ total
,N
- total
);
687 DEBUG(0,("write_data_at_offset: write failure. Error = %s\n", strerror(errno
) ));
696 return (ssize_t
)total
;
698 /* Use lseek and write_data. */
699 if (sys_lseek(fd
, pos
, SEEK_SET
) == -1) {
700 if (errno
!= ESPIPE
) {
704 return write_data(fd
, buffer
, N
);
708 /****************************************************************************
709 Set a fd into blocking/nonblocking mode. Uses POSIX O_NONBLOCK if available,
713 ****************************************************************************/
715 int set_blocking(int fd
, BOOL set
)
719 #define FLAG_TO_SET O_NONBLOCK
722 #define FLAG_TO_SET O_NDELAY
724 #define FLAG_TO_SET FNDELAY
728 if((val
= sys_fcntl_long(fd
, F_GETFL
, 0)) == -1)
730 if(set
) /* Turn blocking on - ie. clear nonblock flag */
734 return sys_fcntl_long( fd
, F_SETFL
, val
);
738 /****************************************************************************
739 Transfer some data between two fd's.
740 ****************************************************************************/
742 #ifndef TRANSFER_BUF_SIZE
743 #define TRANSFER_BUF_SIZE 65536
746 ssize_t
transfer_file_internal(int infd
, int outfd
, size_t n
, ssize_t (*read_fn
)(int, void *, size_t),
747 ssize_t (*write_fn
)(int, const void *, size_t))
753 size_t num_to_read_thistime
;
754 size_t num_written
= 0;
756 if ((buf
= SMB_MALLOC(TRANSFER_BUF_SIZE
)) == NULL
)
760 num_to_read_thistime
= MIN((n
- total
), TRANSFER_BUF_SIZE
);
762 read_ret
= (*read_fn
)(infd
, buf
, num_to_read_thistime
);
763 if (read_ret
== -1) {
764 DEBUG(0,("transfer_file_internal: read failure. Error = %s\n", strerror(errno
) ));
773 while (num_written
< read_ret
) {
774 write_ret
= (*write_fn
)(outfd
,buf
+ num_written
, read_ret
- num_written
);
776 if (write_ret
== -1) {
777 DEBUG(0,("transfer_file_internal: write failure. Error = %s\n", strerror(errno
) ));
782 return (ssize_t
)total
;
784 num_written
+= (size_t)write_ret
;
787 total
+= (size_t)read_ret
;
791 return (ssize_t
)total
;
794 SMB_OFF_T
transfer_file(int infd
,int outfd
,SMB_OFF_T n
)
796 return (SMB_OFF_T
)transfer_file_internal(infd
, outfd
, (size_t)n
, sys_read
, sys_write
);
799 /*******************************************************************
800 Sleep for a specified number of milliseconds.
801 ********************************************************************/
803 void smb_msleep(unsigned int t
)
805 #if defined(HAVE_NANOSLEEP)
806 struct timespec tval
;
809 tval
.tv_sec
= t
/1000;
810 tval
.tv_nsec
= 1000000*(t
%1000);
814 ret
= nanosleep(&tval
, &tval
);
815 } while (ret
< 0 && errno
== EINTR
&& (tval
.tv_sec
> 0 || tval
.tv_nsec
> 0));
817 unsigned int tdiff
=0;
818 struct timeval tval
,t1
,t2
;
825 tval
.tv_sec
= (t
-tdiff
)/1000;
826 tval
.tv_usec
= 1000*((t
-tdiff
)%1000);
828 /* Never wait for more than 1 sec. */
829 if (tval
.tv_sec
> 1) {
836 sys_select_intr(0,&fds
,NULL
,NULL
,&tval
);
839 if (t2
.tv_sec
< t1
.tv_sec
) {
840 /* Someone adjusted time... */
844 tdiff
= TvalDiff(&t1
,&t2
);
849 /****************************************************************************
850 Become a daemon, discarding the controlling terminal.
851 ****************************************************************************/
853 void become_daemon(BOOL Fork
, BOOL no_process_group
)
861 /* detach from the terminal */
863 if (!no_process_group
) setsid();
864 #elif defined(TIOCNOTTY)
865 if (!no_process_group
) {
866 int i
= sys_open("/dev/tty", O_RDWR
, 0);
868 ioctl(i
, (int) TIOCNOTTY
, (char *)0);
872 #endif /* HAVE_SETSID */
874 /* Close fd's 0,1,2. Needed if started by rsh */
875 close_low_fds(False
); /* Don't close stderr, let the debug system
876 attach it to the logfile */
879 /****************************************************************************
880 Put up a yes/no prompt.
881 ****************************************************************************/
888 if (!fgets(ans
,sizeof(ans
)-1,stdin
))
891 if (*ans
== 'y' || *ans
== 'Y')
897 #if defined(PARANOID_MALLOC_CHECKER)
899 /****************************************************************************
900 Internal malloc wrapper. Externally visible.
901 ****************************************************************************/
903 void *malloc_(size_t size
)
907 #define malloc(s) __ERROR_DONT_USE_MALLOC_DIRECTLY
910 /****************************************************************************
911 Internal calloc wrapper. Not externally visible.
912 ****************************************************************************/
914 static void *calloc_(size_t count
, size_t size
)
917 return calloc(count
, size
);
918 #define calloc(n,s) __ERROR_DONT_USE_CALLOC_DIRECTLY
921 /****************************************************************************
922 Internal realloc wrapper. Not externally visible.
923 ****************************************************************************/
925 static void *realloc_(void *ptr
, size_t size
)
928 return realloc(ptr
, size
);
929 #define realloc(p,s) __ERROR_DONT_USE_RELLOC_DIRECTLY
932 #endif /* PARANOID_MALLOC_CHECKER */
934 /****************************************************************************
936 ****************************************************************************/
938 void *malloc_array(size_t el_size
, unsigned int count
)
940 if (count
>= MAX_ALLOC_SIZE
/el_size
) {
944 #if defined(PARANOID_MALLOC_CHECKER)
945 return malloc_(el_size
*count
);
947 return malloc(el_size
*count
);
951 /****************************************************************************
953 ****************************************************************************/
955 void *calloc_array(size_t size
, size_t nmemb
)
957 if (nmemb
>= MAX_ALLOC_SIZE
/size
) {
960 #if defined(PARANOID_MALLOC_CHECKER)
961 return calloc_(nmemb
, size
);
963 return calloc(nmemb
, size
);
967 /****************************************************************************
968 Expand a pointer to be a particular size.
969 Note that this version of Realloc has an extra parameter that decides
970 whether to free the passed in storage on allocation failure or if the
973 This is designed for use in the typical idiom of :
975 p = SMB_REALLOC(p, size)
980 and not to have to keep track of the old 'p' contents to free later, nor
981 to worry if the size parameter was zero. In the case where NULL is returned
982 we guarentee that p has been freed.
984 If free later semantics are desired, then pass 'free_old_on_error' as False which
985 guarentees that the old contents are not freed on error, even if size == 0. To use
988 tmp = SMB_REALLOC_KEEP_OLD_ON_ERROR(p, size);
996 Changes were instigated by Coverity error checking. JRA.
997 ****************************************************************************/
999 void *Realloc(void *p
, size_t size
, BOOL free_old_on_error
)
1004 if (free_old_on_error
) {
1007 DEBUG(2,("Realloc asked for 0 bytes\n"));
1011 #if defined(PARANOID_MALLOC_CHECKER)
1013 ret
= (void *)malloc_(size
);
1015 ret
= (void *)realloc_(p
,size
);
1019 ret
= (void *)malloc(size
);
1021 ret
= (void *)realloc(p
,size
);
1026 if (free_old_on_error
&& p
) {
1029 DEBUG(0,("Memory allocation error: failed to expand to %d bytes\n",(int)size
));
1035 /****************************************************************************
1037 ****************************************************************************/
1039 void *realloc_array(void *p
, size_t el_size
, unsigned int count
, BOOL free_old_on_error
)
1041 if (count
>= MAX_ALLOC_SIZE
/el_size
) {
1042 if (free_old_on_error
) {
1047 return Realloc(p
, el_size
*count
, free_old_on_error
);
1050 /****************************************************************************
1051 (Hopefully) efficient array append.
1052 ****************************************************************************/
1054 void add_to_large_array(TALLOC_CTX
*mem_ctx
, size_t element_size
,
1055 void *element
, void **array
, uint32
*num_elements
,
1056 ssize_t
*array_size
)
1058 if (*array_size
< 0) {
1062 if (*array
== NULL
) {
1063 if (*array_size
== 0) {
1067 if (*array_size
>= MAX_ALLOC_SIZE
/element_size
) {
1071 if (mem_ctx
!= NULL
) {
1072 *array
= TALLOC(mem_ctx
, element_size
* (*array_size
));
1074 *array
= SMB_MALLOC(element_size
* (*array_size
));
1077 if (*array
== NULL
) {
1082 if (*num_elements
== *array_size
) {
1085 if (*array_size
>= MAX_ALLOC_SIZE
/element_size
) {
1089 if (mem_ctx
!= NULL
) {
1090 *array
= TALLOC_REALLOC(mem_ctx
, *array
,
1091 element_size
* (*array_size
));
1093 *array
= SMB_REALLOC(*array
,
1094 element_size
* (*array_size
));
1097 if (*array
== NULL
) {
1102 memcpy((char *)(*array
) + element_size
*(*num_elements
),
1103 element
, element_size
);
1113 /****************************************************************************
1114 Free memory, checks for NULL.
1115 Use directly SAFE_FREE()
1116 Exists only because we need to pass a function pointer somewhere --SSS
1117 ****************************************************************************/
1119 void safe_free(void *p
)
1124 /****************************************************************************
1125 Get my own name and IP.
1126 ****************************************************************************/
1128 BOOL
get_myname(char *my_name
)
1134 /* get my host name */
1135 if (gethostname(hostname
, sizeof(hostname
)) == -1) {
1136 DEBUG(0,("gethostname failed\n"));
1140 /* Ensure null termination. */
1141 hostname
[sizeof(hostname
)-1] = '\0';
1144 /* split off any parts after an initial . */
1145 char *p
= strchr_m(hostname
,'.');
1150 fstrcpy(my_name
,hostname
);
1156 /****************************************************************************
1157 Get my own canonical name, including domain.
1158 ****************************************************************************/
1160 BOOL
get_mydnsfullname(fstring my_dnsname
)
1162 static fstring dnshostname
;
1165 if (!*dnshostname
) {
1166 /* get my host name */
1167 if (gethostname(dnshostname
, sizeof(dnshostname
)) == -1) {
1168 *dnshostname
= '\0';
1169 DEBUG(0,("gethostname failed\n"));
1173 /* Ensure null termination. */
1174 dnshostname
[sizeof(dnshostname
)-1] = '\0';
1176 /* Ensure we get the cannonical name. */
1177 if (!(hp
= sys_gethostbyname(dnshostname
))) {
1178 *dnshostname
= '\0';
1181 fstrcpy(dnshostname
, hp
->h_name
);
1183 fstrcpy(my_dnsname
, dnshostname
);
1187 /****************************************************************************
1188 Get my own domain name.
1189 ****************************************************************************/
1191 BOOL
get_mydnsdomname(fstring my_domname
)
1197 if (!get_mydnsfullname(domname
)) {
1200 p
= strchr_m(domname
, '.');
1203 fstrcpy(my_domname
, p
);
1209 /****************************************************************************
1210 Interpret a protocol description string, with a default.
1211 ****************************************************************************/
1213 int interpret_protocol(const char *str
,int def
)
1215 if (strequal(str
,"NT1"))
1216 return(PROTOCOL_NT1
);
1217 if (strequal(str
,"LANMAN2"))
1218 return(PROTOCOL_LANMAN2
);
1219 if (strequal(str
,"LANMAN1"))
1220 return(PROTOCOL_LANMAN1
);
1221 if (strequal(str
,"CORE"))
1222 return(PROTOCOL_CORE
);
1223 if (strequal(str
,"COREPLUS"))
1224 return(PROTOCOL_COREPLUS
);
1225 if (strequal(str
,"CORE+"))
1226 return(PROTOCOL_COREPLUS
);
1228 DEBUG(0,("Unrecognised protocol level %s\n",str
));
1233 /****************************************************************************
1234 Return true if a string could be a pure IP address.
1235 ****************************************************************************/
1237 BOOL
is_ipaddress(const char *str
)
1239 BOOL pure_address
= True
;
1242 for (i
=0; pure_address
&& str
[i
]; i
++)
1243 if (!(isdigit((int)str
[i
]) || str
[i
] == '.'))
1244 pure_address
= False
;
1246 /* Check that a pure number is not misinterpreted as an IP */
1247 pure_address
= pure_address
&& (strchr_m(str
, '.') != NULL
);
1249 return pure_address
;
1252 /****************************************************************************
1253 Interpret an internet address or name into an IP address in 4 byte form.
1254 ****************************************************************************/
1256 uint32
interpret_addr(const char *str
)
1261 if (strcmp(str
,"0.0.0.0") == 0)
1263 if (strcmp(str
,"255.255.255.255") == 0)
1266 /* if it's in the form of an IP address then get the lib to interpret it */
1267 if (is_ipaddress(str
)) {
1268 res
= inet_addr(str
);
1270 /* otherwise assume it's a network name of some sort and use
1271 sys_gethostbyname */
1272 if ((hp
= sys_gethostbyname(str
)) == 0) {
1273 DEBUG(3,("sys_gethostbyname: Unknown host. %s\n",str
));
1277 if(hp
->h_addr
== NULL
) {
1278 DEBUG(3,("sys_gethostbyname: host address is invalid for host %s\n",str
));
1281 putip((char *)&res
,(char *)hp
->h_addr
);
1284 if (res
== (uint32
)-1)
1290 /*******************************************************************
1291 A convenient addition to interpret_addr().
1292 ******************************************************************/
1294 struct in_addr
*interpret_addr2(const char *str
)
1296 static struct in_addr ret
;
1297 uint32 a
= interpret_addr(str
);
1302 /*******************************************************************
1303 Check if an IP is the 0.0.0.0.
1304 ******************************************************************/
1306 BOOL
is_zero_ip(struct in_addr ip
)
1309 putip((char *)&a
,(char *)&ip
);
1313 /*******************************************************************
1314 Set an IP to 0.0.0.0.
1315 ******************************************************************/
1317 void zero_ip(struct in_addr
*ip
)
1320 static struct in_addr ipzero
;
1323 ipzero
= *interpret_addr2("0.0.0.0");
1330 #if (defined(HAVE_NETGROUP) && defined(WITH_AUTOMOUNT))
1331 /******************************************************************
1332 Remove any mount options such as -rsize=2048,wsize=2048 etc.
1333 Based on a fix from <Thomas.Hepper@icem.de>.
1334 *******************************************************************/
1336 static void strip_mount_options( pstring
*str
)
1340 while(*p
&& !isspace(*p
))
1342 while(*p
&& isspace(*p
))
1347 pstrcpy(tmp_str
, p
);
1348 pstrcpy(*str
, tmp_str
);
1353 /*******************************************************************
1354 Patch from jkf@soton.ac.uk
1355 Split Luke's automount_server into YP lookup and string splitter
1356 so can easily implement automount_path().
1357 As we may end up doing both, cache the last YP result.
1358 *******************************************************************/
1360 #ifdef WITH_NISPLUS_HOME
1361 char *automount_lookup(const char *user_name
)
1363 static fstring last_key
= "";
1364 static pstring last_value
= "";
1366 char *nis_map
= (char *)lp_nis_home_map_name();
1368 char buffer
[NIS_MAXATTRVAL
+ 1];
1373 if (strcmp(user_name
, last_key
)) {
1374 slprintf(buffer
, sizeof(buffer
)-1, "[key=%s],%s", user_name
, nis_map
);
1375 DEBUG(5, ("NIS+ querystring: %s\n", buffer
));
1377 if (result
= nis_list(buffer
, FOLLOW_PATH
|EXPAND_NAME
|HARD_LOOKUP
, NULL
, NULL
)) {
1378 if (result
->status
!= NIS_SUCCESS
) {
1379 DEBUG(3, ("NIS+ query failed: %s\n", nis_sperrno(result
->status
)));
1380 fstrcpy(last_key
, ""); pstrcpy(last_value
, "");
1382 object
= result
->objects
.objects_val
;
1383 if (object
->zo_data
.zo_type
== ENTRY_OBJ
) {
1384 entry
= &object
->zo_data
.objdata_u
.en_data
;
1385 DEBUG(5, ("NIS+ entry type: %s\n", entry
->en_type
));
1386 DEBUG(3, ("NIS+ result: %s\n", entry
->en_cols
.en_cols_val
[1].ec_value
.ec_value_val
));
1388 pstrcpy(last_value
, entry
->en_cols
.en_cols_val
[1].ec_value
.ec_value_val
);
1389 pstring_sub(last_value
, "&", user_name
);
1390 fstrcpy(last_key
, user_name
);
1394 nis_freeresult(result
);
1397 strip_mount_options(&last_value
);
1399 DEBUG(4, ("NIS+ Lookup: %s resulted in %s\n", user_name
, last_value
));
1402 #else /* WITH_NISPLUS_HOME */
1404 char *automount_lookup(const char *user_name
)
1406 static fstring last_key
= "";
1407 static pstring last_value
= "";
1409 int nis_error
; /* returned by yp all functions */
1410 char *nis_result
; /* yp_match inits this */
1411 int nis_result_len
; /* and set this */
1412 char *nis_domain
; /* yp_get_default_domain inits this */
1413 char *nis_map
= (char *)lp_nis_home_map_name();
1415 if ((nis_error
= yp_get_default_domain(&nis_domain
)) != 0) {
1416 DEBUG(3, ("YP Error: %s\n", yperr_string(nis_error
)));
1420 DEBUG(5, ("NIS Domain: %s\n", nis_domain
));
1422 if (!strcmp(user_name
, last_key
)) {
1423 nis_result
= last_value
;
1424 nis_result_len
= strlen(last_value
);
1427 if ((nis_error
= yp_match(nis_domain
, nis_map
, user_name
, strlen(user_name
),
1428 &nis_result
, &nis_result_len
)) == 0) {
1429 fstrcpy(last_key
, user_name
);
1430 pstrcpy(last_value
, nis_result
);
1431 strip_mount_options(&last_value
);
1433 } else if(nis_error
== YPERR_KEY
) {
1435 /* If Key lookup fails user home server is not in nis_map
1436 use default information for server, and home directory */
1438 DEBUG(3, ("YP Key not found: while looking up \"%s\" in map \"%s\"\n",
1439 user_name
, nis_map
));
1440 DEBUG(3, ("using defaults for server and home directory\n"));
1442 DEBUG(3, ("YP Error: \"%s\" while looking up \"%s\" in map \"%s\"\n",
1443 yperr_string(nis_error
), user_name
, nis_map
));
1447 DEBUG(4, ("YP Lookup: %s resulted in %s\n", user_name
, last_value
));
1450 #endif /* WITH_NISPLUS_HOME */
1453 /*******************************************************************
1454 Are two IPs on the same subnet?
1455 ********************************************************************/
1457 BOOL
same_net(struct in_addr ip1
,struct in_addr ip2
,struct in_addr mask
)
1459 uint32 net1
,net2
,nmask
;
1461 nmask
= ntohl(mask
.s_addr
);
1462 net1
= ntohl(ip1
.s_addr
);
1463 net2
= ntohl(ip2
.s_addr
);
1465 return((net1
& nmask
) == (net2
& nmask
));
1469 /****************************************************************************
1470 Check if a process exists. Does this work on all unixes?
1471 ****************************************************************************/
1473 BOOL
process_exists(const struct process_id pid
)
1475 if (!procid_is_local(&pid
)) {
1476 /* This *SEVERELY* needs fixing. */
1480 /* Doing kill with a non-positive pid causes messages to be
1481 * sent to places we don't want. */
1482 SMB_ASSERT(pid
.pid
> 0);
1483 return(kill(pid
.pid
,0) == 0 || errno
!= ESRCH
);
1486 BOOL
process_exists_by_pid(pid_t pid
)
1488 return process_exists(pid_to_procid(pid
));
1491 /*******************************************************************
1492 Convert a uid into a user name.
1493 ********************************************************************/
1495 const char *uidtoname(uid_t uid
)
1497 static fstring name
;
1498 struct passwd
*pass
;
1500 pass
= getpwuid_alloc(NULL
, uid
);
1502 fstrcpy(name
, pass
->pw_name
);
1505 slprintf(name
, sizeof(name
) - 1, "%ld",(long int)uid
);
1511 /*******************************************************************
1512 Convert a gid into a group name.
1513 ********************************************************************/
1515 char *gidtoname(gid_t gid
)
1517 static fstring name
;
1520 grp
= getgrgid(gid
);
1522 return(grp
->gr_name
);
1523 slprintf(name
,sizeof(name
) - 1, "%d",(int)gid
);
1527 /*******************************************************************
1528 Convert a user name into a uid.
1529 ********************************************************************/
1531 uid_t
nametouid(const char *name
)
1533 struct passwd
*pass
;
1537 pass
= getpwnam_alloc(NULL
, name
);
1544 u
= (uid_t
)strtol(name
, &p
, 0);
1545 if ((p
!= name
) && (*p
== '\0'))
1551 /*******************************************************************
1552 Convert a name to a gid_t if possible. Return -1 if not a group.
1553 ********************************************************************/
1555 gid_t
nametogid(const char *name
)
1561 g
= (gid_t
)strtol(name
, &p
, 0);
1562 if ((p
!= name
) && (*p
== '\0'))
1565 grp
= sys_getgrnam(name
);
1567 return(grp
->gr_gid
);
1571 /*******************************************************************
1572 Something really nasty happened - panic !
1573 ********************************************************************/
1575 void smb_panic(const char *const why
)
1583 if (global_clobber_region_function
) {
1584 DEBUG(0,("smb_panic: clobber_region() last called from [%s(%u)]\n",
1585 global_clobber_region_function
,
1586 global_clobber_region_line
));
1591 DEBUG(0,("PANIC (pid %llu): %s\n",
1592 (unsigned long long)sys_getpid(), why
));
1595 /* only smbd needs to decrement the smbd counter in connections.tdb */
1596 decrement_smbd_process_count();
1598 cmd
= lp_panic_action();
1600 DEBUG(0, ("smb_panic(): calling panic action [%s]\n", cmd
));
1601 result
= system(cmd
);
1604 DEBUG(0, ("smb_panic(): fork failed in panic action: %s\n",
1607 DEBUG(0, ("smb_panic(): action returned status %d\n",
1608 WEXITSTATUS(result
)));
1614 /*******************************************************************
1615 Print a backtrace of the stack to the debug log. This function
1616 DELIBERATELY LEAKS MEMORY. The expectation is that you should
1617 exit shortly after calling it.
1618 ********************************************************************/
1620 #ifdef HAVE_LIBUNWIND_H
1621 #include <libunwind.h>
1624 #ifdef HAVE_EXECINFO_H
1625 #include <execinfo.h>
1628 #ifdef HAVE_LIBEXC_H
1632 void log_stack_trace(void)
1634 #ifdef HAVE_LIBUNWIND
1635 /* Try to use libunwind before any other technique since on ia64
1636 * libunwind correctly walks the stack in more circumstances than
1639 unw_cursor_t cursor
;
1644 unw_word_t ip
, sp
, off
;
1646 procname
[sizeof(procname
) - 1] = '\0';
1648 if (unw_getcontext(&uc
) != 0) {
1649 goto libunwind_failed
;
1652 if (unw_init_local(&cursor
, &uc
) != 0) {
1653 goto libunwind_failed
;
1656 DEBUG(0, ("BACKTRACE:\n"));
1660 unw_get_reg(&cursor
, UNW_REG_IP
, &ip
);
1661 unw_get_reg(&cursor
, UNW_REG_SP
, &sp
);
1663 switch (unw_get_proc_name(&cursor
,
1664 procname
, sizeof(procname
) - 1, &off
) ) {
1668 /* Name truncated. */
1669 DEBUGADD(0, (" #%u %s + %#llx [ip=%#llx] [sp=%#llx]\n",
1670 i
, procname
, (long long)off
,
1671 (long long)ip
, (long long) sp
));
1674 /* case -UNW_ENOINFO: */
1675 /* case -UNW_EUNSPEC: */
1676 /* No symbol name found. */
1677 DEBUGADD(0, (" #%u %s [ip=%#llx] [sp=%#llx]\n",
1678 i
, "<unknown symbol>",
1679 (long long)ip
, (long long) sp
));
1682 } while (unw_step(&cursor
) > 0);
1687 DEBUG(0, ("unable to produce a stack trace with libunwind\n"));
1689 #elif HAVE_BACKTRACE_SYMBOLS
1690 void *backtrace_stack
[BACKTRACE_STACK_SIZE
];
1691 size_t backtrace_size
;
1692 char **backtrace_strings
;
1694 /* get the backtrace (stack frames) */
1695 backtrace_size
= backtrace(backtrace_stack
,BACKTRACE_STACK_SIZE
);
1696 backtrace_strings
= backtrace_symbols(backtrace_stack
, backtrace_size
);
1698 DEBUG(0, ("BACKTRACE: %lu stack frames:\n",
1699 (unsigned long)backtrace_size
));
1701 if (backtrace_strings
) {
1704 for (i
= 0; i
< backtrace_size
; i
++)
1705 DEBUGADD(0, (" #%u %s\n", i
, backtrace_strings
[i
]));
1707 /* Leak the backtrace_strings, rather than risk what free() might do */
1712 /* The IRIX libexc library provides an API for unwinding the stack. See
1713 * libexc(3) for details. Apparantly trace_back_stack leaks memory, but
1714 * since we are about to abort anyway, it hardly matters.
1717 #define NAMESIZE 32 /* Arbitrary */
1719 __uint64_t addrs
[BACKTRACE_STACK_SIZE
];
1720 char * names
[BACKTRACE_STACK_SIZE
];
1721 char namebuf
[BACKTRACE_STACK_SIZE
* NAMESIZE
];
1728 ZERO_ARRAY(namebuf
);
1730 /* We need to be root so we can open our /proc entry to walk
1731 * our stack. It also helps when we want to dump core.
1735 for (i
= 0; i
< BACKTRACE_STACK_SIZE
; i
++) {
1736 names
[i
] = namebuf
+ (i
* NAMESIZE
);
1739 levels
= trace_back_stack(0, addrs
, names
,
1740 BACKTRACE_STACK_SIZE
, NAMESIZE
- 1);
1742 DEBUG(0, ("BACKTRACE: %d stack frames:\n", levels
));
1743 for (i
= 0; i
< levels
; i
++) {
1744 DEBUGADD(0, (" #%d 0x%llx %s\n", i
, addrs
[i
], names
[i
]));
1749 DEBUG(0, ("unable to produce a stack trace on this platform\n"));
1753 /*******************************************************************
1754 A readdir wrapper which just returns the file name.
1755 ********************************************************************/
1757 const char *readdirname(SMB_STRUCT_DIR
*p
)
1759 SMB_STRUCT_DIRENT
*ptr
;
1765 ptr
= (SMB_STRUCT_DIRENT
*)sys_readdir(p
);
1769 dname
= ptr
->d_name
;
1776 #ifdef HAVE_BROKEN_READDIR_NAME
1777 /* using /usr/ucb/cc is BAD */
1783 int len
= NAMLEN(ptr
);
1784 memcpy(buf
, dname
, len
);
1792 /*******************************************************************
1793 Utility function used to decide if the last component
1794 of a path matches a (possibly wildcarded) entry in a namelist.
1795 ********************************************************************/
1797 BOOL
is_in_path(const char *name
, name_compare_entry
*namelist
, BOOL case_sensitive
)
1799 pstring last_component
;
1802 /* if we have no list it's obviously not in the path */
1803 if((namelist
== NULL
) || ((namelist
!= NULL
) && (namelist
[0].name
== NULL
))) {
1807 DEBUG(8, ("is_in_path: %s\n", name
));
1809 /* Get the last component of the unix name. */
1810 p
= strrchr_m(name
, '/');
1811 pstrcpy(last_component
, p
? ++p
: name
);
1813 for(; namelist
->name
!= NULL
; namelist
++) {
1814 if(namelist
->is_wild
) {
1815 if (mask_match(last_component
, namelist
->name
, case_sensitive
)) {
1816 DEBUG(8,("is_in_path: mask match succeeded\n"));
1820 if((case_sensitive
&& (strcmp(last_component
, namelist
->name
) == 0))||
1821 (!case_sensitive
&& (StrCaseCmp(last_component
, namelist
->name
) == 0))) {
1822 DEBUG(8,("is_in_path: match succeeded\n"));
1827 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
, char *namelist
)
1848 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 do POSIX file locking. Cruft in NFS and 64->32 bit mapping
1942 is dealt with in posix.c
1943 Returns True if the lock was granted, False otherwise.
1944 ****************************************************************************/
1946 BOOL
fcntl_lock(int fd
, int op
, SMB_OFF_T offset
, SMB_OFF_T count
, int type
)
1948 SMB_STRUCT_FLOCK lock
;
1951 DEBUG(8,("fcntl_lock fd=%d op=%d offset=%.0f count=%.0f type=%d\n",
1952 fd
,op
,(double)offset
,(double)count
,type
));
1955 lock
.l_whence
= SEEK_SET
;
1956 lock
.l_start
= offset
;
1960 ret
= sys_fcntl_ptr(fd
,op
,&lock
);
1964 DEBUG(3,("fcntl_lock: lock failed at offset %.0f count %.0f op %d type %d (%s)\n",
1965 (double)offset
,(double)count
,op
,type
,strerror(errno
)));
1970 /* everything went OK */
1971 DEBUG(8,("fcntl_lock: Lock call successful\n"));
1976 /****************************************************************************
1977 Simple routine to query existing file locks. Cruft in NFS and 64->32 bit mapping
1978 is dealt with in posix.c
1979 Returns True if we have information regarding this lock region (and returns
1980 F_UNLCK in *ptype if the region is unlocked). False if the call failed.
1981 ****************************************************************************/
1983 BOOL
fcntl_getlock(int fd
, SMB_OFF_T
*poffset
, SMB_OFF_T
*pcount
, int *ptype
, pid_t
*ppid
)
1985 SMB_STRUCT_FLOCK lock
;
1988 DEBUG(8,("fcntl_getlock fd=%d offset=%.0f count=%.0f type=%d\n",
1989 fd
,(double)*poffset
,(double)*pcount
,*ptype
));
1991 lock
.l_type
= *ptype
;
1992 lock
.l_whence
= SEEK_SET
;
1993 lock
.l_start
= *poffset
;
1994 lock
.l_len
= *pcount
;
1997 ret
= sys_fcntl_ptr(fd
,SMB_F_GETLK
,&lock
);
2001 DEBUG(3,("fcntl_getlock: lock request failed at offset %.0f count %.0f type %d (%s)\n",
2002 (double)*poffset
,(double)*pcount
,*ptype
,strerror(errno
)));
2007 *ptype
= lock
.l_type
;
2008 *poffset
= lock
.l_start
;
2009 *pcount
= lock
.l_len
;
2012 DEBUG(3,("fcntl_getlock: fd %d is returned info %d pid %u\n",
2013 fd
, (int)lock
.l_type
, (unsigned int)lock
.l_pid
));
2018 #define DBGC_CLASS DBGC_ALL
2020 /*******************************************************************
2021 Is the name specified one of my netbios names.
2022 Returns true if it is equal, false otherwise.
2023 ********************************************************************/
2025 BOOL
is_myname(const char *s
)
2030 for (n
=0; my_netbios_names(n
); n
++) {
2031 if (strequal(my_netbios_names(n
), s
)) {
2036 DEBUG(8, ("is_myname(\"%s\") returns %d\n", s
, ret
));
2040 BOOL
is_myname_or_ipaddr(const char *s
)
2042 fstring name
, dnsname
;
2048 /* santize the string from '\\name' */
2052 servername
= strrchr_m( name
, '\\' );
2058 /* optimize for the common case */
2060 if (strequal(servername
, global_myname()))
2063 /* check for an alias */
2065 if (is_myname(servername
))
2068 /* check for loopback */
2070 if (strequal(servername
, "localhost"))
2073 /* maybe it's my dns name */
2075 if ( get_mydnsfullname( dnsname
) )
2076 if ( strequal( servername
, dnsname
) )
2079 /* handle possible CNAME records */
2081 if ( !is_ipaddress( servername
) ) {
2082 /* use DNS to resolve the name, but only the first address */
2085 if (((hp
= sys_gethostbyname(name
)) != NULL
) && (hp
->h_addr
!= NULL
)) {
2086 struct in_addr return_ip
;
2087 putip( (char*)&return_ip
, (char*)hp
->h_addr
);
2088 fstrcpy( name
, inet_ntoa( return_ip
) );
2093 /* maybe its an IP address? */
2094 if (is_ipaddress(servername
)) {
2095 struct iface_struct nics
[MAX_INTERFACES
];
2099 ip
= interpret_addr(servername
);
2100 if ((ip
==0) || (ip
==0xffffffff))
2103 n
= get_interfaces(nics
, MAX_INTERFACES
);
2104 for (i
=0; i
<n
; i
++) {
2105 if (ip
== nics
[i
].ip
.s_addr
)
2114 /*******************************************************************
2115 Is the name specified our workgroup/domain.
2116 Returns true if it is equal, false otherwise.
2117 ********************************************************************/
2119 BOOL
is_myworkgroup(const char *s
)
2123 if (strequal(s
, lp_workgroup())) {
2127 DEBUG(8, ("is_myworkgroup(\"%s\") returns %d\n", s
, ret
));
2131 /*******************************************************************
2132 we distinguish between 2K and XP by the "Native Lan Manager" string
2133 WinXP => "Windows 2002 5.1"
2134 Win2k => "Windows 2000 5.0"
2135 NT4 => "Windows NT 4.0"
2136 Win9x => "Windows 4.0"
2137 Windows 2003 doesn't set the native lan manager string but
2138 they do set the domain to "Windows 2003 5.2" (probably a bug).
2139 ********************************************************************/
2141 void ra_lanman_string( const char *native_lanman
)
2143 if ( strcmp( native_lanman
, "Windows 2002 5.1" ) == 0 )
2144 set_remote_arch( RA_WINXP
);
2145 else if ( strcmp( native_lanman
, "Windows Server 2003 5.2" ) == 0 )
2146 set_remote_arch( RA_WIN2K3
);
2149 /*******************************************************************
2150 Set the horrid remote_arch string based on an enum.
2151 ********************************************************************/
2153 void set_remote_arch(enum remote_arch_types type
)
2158 fstrcpy(remote_arch
, "WfWg");
2161 fstrcpy(remote_arch
, "OS2");
2164 fstrcpy(remote_arch
, "Win95");
2167 fstrcpy(remote_arch
, "WinNT");
2170 fstrcpy(remote_arch
, "Win2K");
2173 fstrcpy(remote_arch
, "WinXP");
2176 fstrcpy(remote_arch
, "Win2K3");
2179 fstrcpy(remote_arch
,"Samba");
2182 fstrcpy(remote_arch
,"CIFSFS");
2185 ra_type
= RA_UNKNOWN
;
2186 fstrcpy(remote_arch
, "UNKNOWN");
2190 DEBUG(10,("set_remote_arch: Client arch is \'%s\'\n", remote_arch
));
2193 /*******************************************************************
2194 Get the remote_arch type.
2195 ********************************************************************/
2197 enum remote_arch_types
get_remote_arch(void)
2202 void print_asc(int level
, const unsigned char *buf
,int len
)
2206 DEBUG(level
,("%c", isprint(buf
[i
])?buf
[i
]:'.'));
2209 void dump_data(int level
, const char *buf1
,int len
)
2211 const unsigned char *buf
= (const unsigned char *)buf1
;
2215 if (!DEBUGLVL(level
)) return;
2217 DEBUGADD(level
,("[%03X] ",i
));
2219 DEBUGADD(level
,("%02X ",(int)buf
[i
]));
2221 if (i
%8 == 0) DEBUGADD(level
,(" "));
2223 print_asc(level
,&buf
[i
-16],8); DEBUGADD(level
,(" "));
2224 print_asc(level
,&buf
[i
-8],8); DEBUGADD(level
,("\n"));
2225 if (i
<len
) DEBUGADD(level
,("[%03X] ",i
));
2231 DEBUGADD(level
,(" "));
2232 if (n
>8) DEBUGADD(level
,(" "));
2233 while (n
--) DEBUGADD(level
,(" "));
2235 print_asc(level
,&buf
[i
-(i
%16)],n
); DEBUGADD(level
,( " " ));
2237 if (n
>0) print_asc(level
,&buf
[i
-n
],n
);
2238 DEBUGADD(level
,("\n"));
2242 void dump_data_pw(const char *msg
, const uchar
* data
, size_t len
)
2244 #ifdef DEBUG_PASSWORD
2245 DEBUG(11, ("%s", msg
));
2246 if (data
!= NULL
&& len
> 0)
2248 dump_data(11, (const char *)data
, len
);
2253 char *tab_depth(int depth
)
2255 static pstring spaces
;
2256 memset(spaces
, ' ', depth
* 4);
2257 spaces
[depth
* 4] = 0;
2261 /*****************************************************************************
2262 Provide a checksum on a string
2264 Input: s - the null-terminated character string for which the checksum
2267 Output: The checksum value calculated for s.
2268 *****************************************************************************/
2270 int str_checksum(const char *s
)
2278 res
^= (c
<< (i
% 15)) ^ (c
>> (15-(i
%15)));
2285 /*****************************************************************
2286 Zero a memory area then free it. Used to catch bugs faster.
2287 *****************************************************************/
2289 void zero_free(void *p
, size_t size
)
2295 /*****************************************************************
2296 Set our open file limit to a requested max and return the limit.
2297 *****************************************************************/
2299 int set_maxfiles(int requested_max
)
2301 #if (defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE))
2303 int saved_current_limit
;
2305 if(getrlimit(RLIMIT_NOFILE
, &rlp
)) {
2306 DEBUG(0,("set_maxfiles: getrlimit (1) for RLIMIT_NOFILE failed with error %s\n",
2309 return requested_max
;
2313 * Set the fd limit to be real_max_open_files + MAX_OPEN_FUDGEFACTOR to
2314 * account for the extra fd we need
2315 * as well as the log files and standard
2316 * handles etc. Save the limit we want to set in case
2317 * we are running on an OS that doesn't support this limit (AIX)
2318 * which always returns RLIM_INFINITY for rlp.rlim_max.
2321 /* Try raising the hard (max) limit to the requested amount. */
2323 #if defined(RLIM_INFINITY)
2324 if (rlp
.rlim_max
!= RLIM_INFINITY
) {
2325 int orig_max
= rlp
.rlim_max
;
2327 if ( rlp
.rlim_max
< requested_max
)
2328 rlp
.rlim_max
= requested_max
;
2330 /* This failing is not an error - many systems (Linux) don't
2331 support our default request of 10,000 open files. JRA. */
2333 if(setrlimit(RLIMIT_NOFILE
, &rlp
)) {
2334 DEBUG(3,("set_maxfiles: setrlimit for RLIMIT_NOFILE for %d max files failed with error %s\n",
2335 (int)rlp
.rlim_max
, strerror(errno
) ));
2337 /* Set failed - restore original value from get. */
2338 rlp
.rlim_max
= orig_max
;
2343 /* Now try setting the soft (current) limit. */
2345 saved_current_limit
= rlp
.rlim_cur
= MIN(requested_max
,rlp
.rlim_max
);
2347 if(setrlimit(RLIMIT_NOFILE
, &rlp
)) {
2348 DEBUG(0,("set_maxfiles: setrlimit for RLIMIT_NOFILE for %d files failed with error %s\n",
2349 (int)rlp
.rlim_cur
, strerror(errno
) ));
2351 return saved_current_limit
;
2354 if(getrlimit(RLIMIT_NOFILE
, &rlp
)) {
2355 DEBUG(0,("set_maxfiles: getrlimit (2) for RLIMIT_NOFILE failed with error %s\n",
2358 return saved_current_limit
;
2361 #if defined(RLIM_INFINITY)
2362 if(rlp
.rlim_cur
== RLIM_INFINITY
)
2363 return saved_current_limit
;
2366 if((int)rlp
.rlim_cur
> saved_current_limit
)
2367 return saved_current_limit
;
2369 return rlp
.rlim_cur
;
2370 #else /* !defined(HAVE_GETRLIMIT) || !defined(RLIMIT_NOFILE) */
2372 * No way to know - just guess...
2374 return requested_max
;
2378 /*****************************************************************
2379 Possibly replace mkstemp if it is broken.
2380 *****************************************************************/
2382 int smb_mkstemp(char *name_template
)
2384 #if HAVE_SECURE_MKSTEMP
2385 return mkstemp(name_template
);
2387 /* have a reasonable go at emulating it. Hope that
2388 the system mktemp() isn't completly hopeless */
2389 char *p
= mktemp(name_template
);
2392 return open(p
, O_CREAT
|O_EXCL
|O_RDWR
, 0600);
2396 /*****************************************************************
2397 malloc that aborts with smb_panic on fail or zero size.
2398 *****************************************************************/
2400 void *smb_xmalloc_array(size_t size
, unsigned int count
)
2404 smb_panic("smb_xmalloc_array: called with zero size.\n");
2405 if (count
>= MAX_ALLOC_SIZE
/size
) {
2406 smb_panic("smb_xmalloc: alloc size too large.\n");
2408 if ((p
= SMB_MALLOC(size
*count
)) == NULL
) {
2409 DEBUG(0, ("smb_xmalloc_array failed to allocate %lu * %lu bytes\n",
2410 (unsigned long)size
, (unsigned long)count
));
2411 smb_panic("smb_xmalloc_array: malloc fail.\n");
2417 Memdup with smb_panic on fail.
2420 void *smb_xmemdup(const void *p
, size_t size
)
2423 p2
= SMB_XMALLOC_ARRAY(unsigned char,size
);
2424 memcpy(p2
, p
, size
);
2429 strdup that aborts on malloc fail.
2432 char *smb_xstrdup(const char *s
)
2434 #if defined(PARANOID_MALLOC_CHECKER)
2439 char *s1
= strdup(s
);
2440 #if defined(PARANOID_MALLOC_CHECKER)
2441 #define strdup(s) __ERROR_DONT_USE_STRDUP_DIRECTLY
2444 smb_panic("smb_xstrdup: malloc fail\n");
2450 strndup that aborts on malloc fail.
2453 char *smb_xstrndup(const char *s
, size_t n
)
2455 #if defined(PARANOID_MALLOC_CHECKER)
2460 char *s1
= strndup(s
, n
);
2461 #if defined(PARANOID_MALLOC_CHECKER)
2462 #define strndup(s,n) __ERROR_DONT_USE_STRNDUP_DIRECTLY
2465 smb_panic("smb_xstrndup: malloc fail\n");
2470 vasprintf that aborts on malloc fail
2473 int smb_xvasprintf(char **ptr
, const char *format
, va_list ap
)
2480 n
= vasprintf(ptr
, format
, ap2
);
2481 if (n
== -1 || ! *ptr
)
2482 smb_panic("smb_xvasprintf: out of memory");
2486 /*****************************************************************
2487 Like strdup but for memory.
2488 *****************************************************************/
2490 void *memdup(const void *p
, size_t size
)
2495 p2
= SMB_MALLOC(size
);
2498 memcpy(p2
, p
, size
);
2502 /*****************************************************************
2503 Get local hostname and cache result.
2504 *****************************************************************/
2506 char *myhostname(void)
2514 /*****************************************************************
2515 A useful function for returning a path in the Samba lock directory.
2516 *****************************************************************/
2518 char *lock_path(const char *name
)
2520 static pstring fname
;
2522 pstrcpy(fname
,lp_lockdir());
2523 trim_char(fname
,'\0','/');
2525 if (!directory_exist(fname
,NULL
))
2529 pstrcat(fname
,name
);
2534 /*****************************************************************
2535 A useful function for returning a path in the Samba pid directory.
2536 *****************************************************************/
2538 char *pid_path(const char *name
)
2540 static pstring fname
;
2542 pstrcpy(fname
,lp_piddir());
2543 trim_char(fname
,'\0','/');
2545 if (!directory_exist(fname
,NULL
))
2549 pstrcat(fname
,name
);
2555 * @brief Returns an absolute path to a file in the Samba lib directory.
2557 * @param name File to find, relative to LIBDIR.
2559 * @retval Pointer to a static #pstring containing the full path.
2562 char *lib_path(const char *name
)
2564 static pstring fname
;
2565 fstr_sprintf(fname
, "%s/%s", dyn_LIBDIR
, name
);
2570 * @brief Returns the platform specific shared library extension.
2572 * @retval Pointer to a static #fstring containing the extension.
2575 const char *shlib_ext(void)
2577 return dyn_SHLIBEXT
;
2580 /*******************************************************************
2581 Given a filename - get its directory name
2582 NB: Returned in static storage. Caveats:
2583 o Not safe in thread environment.
2584 o Caller must not free.
2585 o If caller wishes to preserve, they should copy.
2586 ********************************************************************/
2588 char *parent_dirname(const char *path
)
2590 static pstring dirpath
;
2596 pstrcpy(dirpath
, path
);
2597 p
= strrchr_m(dirpath
, '/'); /* Find final '/', if any */
2599 pstrcpy(dirpath
, "."); /* No final "/", so dir is "." */
2602 ++p
; /* For root "/", leave "/" in place */
2609 /*******************************************************************
2610 Determine if a pattern contains any Microsoft wildcard characters.
2611 *******************************************************************/
2613 BOOL
ms_has_wild(const char *s
)
2617 if (lp_posix_pathnames()) {
2618 /* With posix pathnames no characters are wild. */
2622 while ((c
= *s
++)) {
2635 BOOL
ms_has_wild_w(const smb_ucs2_t
*s
)
2638 if (!s
) return False
;
2639 while ((c
= *s
++)) {
2641 case UCS2_CHAR('*'):
2642 case UCS2_CHAR('?'):
2643 case UCS2_CHAR('<'):
2644 case UCS2_CHAR('>'):
2645 case UCS2_CHAR('"'):
2652 /*******************************************************************
2653 A wrapper that handles case sensitivity and the special handling
2655 *******************************************************************/
2657 BOOL
mask_match(const char *string
, char *pattern
, BOOL is_case_sensitive
)
2659 if (strcmp(string
,"..") == 0)
2661 if (strcmp(pattern
,".") == 0)
2664 return ms_fnmatch(pattern
, string
, Protocol
<= PROTOCOL_LANMAN2
, is_case_sensitive
) == 0;
2667 /*******************************************************************
2668 A wrapper that handles case sensitivity and the special handling
2669 of the ".." name. Varient that is only called by old search code which requires
2670 pattern translation.
2671 *******************************************************************/
2673 BOOL
mask_match_search(const char *string
, char *pattern
, BOOL is_case_sensitive
)
2675 if (strcmp(string
,"..") == 0)
2677 if (strcmp(pattern
,".") == 0)
2680 return ms_fnmatch(pattern
, string
, True
, is_case_sensitive
) == 0;
2683 /*******************************************************************
2684 A wrapper that handles a list of patters and calls mask_match()
2685 on each. Returns True if any of the patterns match.
2686 *******************************************************************/
2688 BOOL
mask_match_list(const char *string
, char **list
, int listLen
, BOOL is_case_sensitive
)
2690 while (listLen
-- > 0) {
2691 if (mask_match(string
, *list
++, is_case_sensitive
))
2697 /*********************************************************
2698 Recursive routine that is called by unix_wild_match.
2699 *********************************************************/
2701 static BOOL
unix_do_match(const char *regexp
, const char *str
)
2705 for( p
= regexp
; *p
&& *str
; ) {
2716 * Look for a character matching
2717 * the one after the '*'.
2721 return True
; /* Automatic match */
2724 while(*str
&& (*p
!= *str
))
2728 * Patch from weidel@multichart.de. In the case of the regexp
2729 * '*XX*' we want to ensure there are at least 2 'X' characters
2730 * in the string after the '*' for a match to be made.
2737 * Eat all the characters that match, but count how many there were.
2740 while(*str
&& (*p
== *str
)) {
2746 * Now check that if the regexp had n identical characters that
2747 * matchcount had at least that many matches.
2750 while ( *(p
+1) && (*(p
+1) == *p
)) {
2755 if ( matchcount
<= 0 )
2759 str
--; /* We've eaten the match char after the '*' */
2761 if(unix_do_match(p
, str
))
2783 if (!*p
&& str
[0] == '.' && str
[1] == 0)
2786 if (!*str
&& *p
== '?') {
2792 if(!*str
&& (*p
== '*' && p
[1] == '\0'))
2798 /*******************************************************************
2799 Simple case insensitive interface to a UNIX wildcard matcher.
2800 Returns True if match, False if not.
2801 *******************************************************************/
2803 BOOL
unix_wild_match(const char *pattern
, const char *string
)
2808 pstrcpy(p2
, pattern
);
2809 pstrcpy(s2
, string
);
2813 /* Remove any *? and ** from the pattern as they are meaningless */
2814 for(p
= p2
; *p
; p
++)
2815 while( *p
== '*' && (p
[1] == '?' ||p
[1] == '*'))
2816 pstrcpy( &p
[1], &p
[2]);
2818 if (strequal(p2
,"*"))
2821 return unix_do_match(p2
, s2
);
2824 /**********************************************************************
2825 Converts a name to a fully qalified domain name.
2826 ***********************************************************************/
2828 void name_to_fqdn(fstring fqdn
, const char *name
)
2830 struct hostent
*hp
= sys_gethostbyname(name
);
2831 if ( hp
&& hp
->h_name
&& *hp
->h_name
) {
2832 DEBUG(10,("name_to_fqdn: lookup for %s -> %s.\n", name
, hp
->h_name
));
2833 fstrcpy(fqdn
,hp
->h_name
);
2835 DEBUG(10,("name_to_fqdn: lookup for %s failed.\n", name
));
2836 fstrcpy(fqdn
, name
);
2840 /**********************************************************************
2841 Extension to talloc_get_type: Abort on type mismatch
2842 ***********************************************************************/
2844 void *talloc_check_name_abort(const void *ptr
, const char *name
)
2848 result
= talloc_check_name(ptr
, name
);
2852 DEBUG(0, ("Talloc type mismatch, expected %s, got %s\n",
2853 name
, talloc_get_name(ptr
)));
2854 smb_panic("aborting");
2855 /* Keep the compiler happy */
2862 /*******************************************************************
2863 This routine is a trick to immediately catch errors when debugging
2864 with insure. A xterm with a gdb is popped up when insure catches
2865 a error. It is Linux specific.
2866 ********************************************************************/
2868 int _Insure_trap_error(int a1
, int a2
, int a3
, int a4
, int a5
, int a6
)
2873 /* you can get /usr/bin/backtrace from
2874 http://samba.org/ftp/unpacked/junkcode/backtrace */
2875 pstring cmd
= "/usr/bin/backtrace %d";
2877 slprintf(pidstr
, sizeof(pidstr
)-1, "%d", sys_getpid());
2878 pstring_sub(cmd
, "%d", pidstr
);
2882 h
= dlopen("/usr/local/parasoft/insure++lite/lib.linux2/libinsure.so", RTLD_LAZY
);
2883 fn
= dlsym(h
, "_Insure_trap_error");
2885 if (!h
|| h
== _Insure_trap_error
) {
2886 h
= dlopen("/usr/local/parasoft/lib.linux2/libinsure.so", RTLD_LAZY
);
2887 fn
= dlsym(h
, "_Insure_trap_error");
2891 ret
= fn(a1
, a2
, a3
, a4
, a5
, a6
);
2899 uint32
map_share_mode_to_deny_mode(uint32 share_access
, uint32 private_options
)
2901 switch (share_access
& ~FILE_SHARE_DELETE
) {
2902 case FILE_SHARE_NONE
:
2904 case FILE_SHARE_READ
:
2906 case FILE_SHARE_WRITE
:
2908 case FILE_SHARE_READ
|FILE_SHARE_WRITE
:
2911 if (private_options
& NTCREATEX_OPTIONS_PRIVATE_DENY_DOS
) {
2913 } else if (private_options
& NTCREATEX_OPTIONS_PRIVATE_DENY_FCB
) {
2920 pid_t
procid_to_pid(const struct process_id
*proc
)
2925 struct process_id
pid_to_procid(pid_t pid
)
2927 struct process_id result
;
2932 struct process_id
procid_self(void)
2934 return pid_to_procid(sys_getpid());
2937 BOOL
procid_equal(const struct process_id
*p1
, const struct process_id
*p2
)
2939 return (p1
->pid
== p2
->pid
);
2942 BOOL
procid_is_me(const struct process_id
*pid
)
2944 return (pid
->pid
== sys_getpid());
2947 struct process_id
interpret_pid(const char *pid_string
)
2949 return pid_to_procid(atoi(pid_string
));
2952 char *procid_str_static(const struct process_id
*pid
)
2955 fstr_sprintf(str
, "%d", pid
->pid
);
2959 char *procid_str(TALLOC_CTX
*mem_ctx
, const struct process_id
*pid
)
2961 return talloc_strdup(mem_ctx
, procid_str_static(pid
));
2964 BOOL
procid_valid(const struct process_id
*pid
)
2966 return (pid
->pid
!= -1);
2969 BOOL
procid_is_local(const struct process_id
*pid
)
2974 int this_is_smp(void)
2976 #if defined(HAVE_SYSCONF)
2978 #if defined(SYSCONF_SC_NPROC_ONLN)
2979 return (sysconf(_SC_NPROC_ONLN
) > 1) ? 1 : 0;
2980 #elif defined(SYSCONF_SC_NPROCESSORS_ONLN)
2981 return (sysconf(_SC_NPROCESSORS_ONLN
) > 1) ? 1 : 0;