2 Unix SMB/CIFS implementation.
3 Samba utility functions
4 Copyright (C) Andrew Tridgell 1992-1998
5 Copyright (C) Jeremy Allison 2001-2002
6 Copyright (C) Simo Sorce 2001
7 Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2003
8 Copyright (C) James Peach 2006
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27 extern fstring local_machine
;
28 extern char *global_clobber_region_function
;
29 extern unsigned int global_clobber_region_line
;
30 extern fstring remote_arch
;
32 /* Max allowable allococation - 256mb - 0x10000000 */
33 #define MAX_ALLOC_SIZE (1024*1024*256)
35 #if (defined(HAVE_NETGROUP) && defined (WITH_AUTOMOUNT))
36 #ifdef WITH_NISPLUS_HOME
37 #ifdef BROKEN_NISPLUS_INCLUDE_FILES
39 * The following lines are needed due to buggy include files
40 * in Solaris 2.6 which define GROUP in both /usr/include/sys/acl.h and
41 * also in /usr/include/rpcsvc/nis.h. The definitions conflict. JRA.
42 * Also GROUP_OBJ is defined as 0x4 in /usr/include/sys/acl.h and as
43 * an enum in /usr/include/rpcsvc/nis.h.
50 #if defined(GROUP_OBJ)
54 #endif /* BROKEN_NISPLUS_INCLUDE_FILES */
56 #include <rpcsvc/nis.h>
58 #endif /* WITH_NISPLUS_HOME */
59 #endif /* HAVE_NETGROUP && WITH_AUTOMOUNT */
61 enum protocol_types Protocol
= PROTOCOL_COREPLUS
;
63 /* a default finfo structure to ensure all fields are sensible */
66 /* this is used by the chaining code */
71 static enum remote_arch_types ra_type
= RA_UNKNOWN
;
72 pstring user_socket_options
=DEFAULT_SOCKET_OPTIONS
;
74 /***********************************************************************
75 Definitions for all names.
76 ***********************************************************************/
78 static char *smb_myname
;
79 static char *smb_myworkgroup
;
80 static char *smb_scope
;
81 static int smb_num_netbios_names
;
82 static char **smb_my_netbios_names
;
84 /***********************************************************************
85 Allocate and set myname. Ensure upper case.
86 ***********************************************************************/
88 BOOL
set_global_myname(const char *myname
)
90 SAFE_FREE(smb_myname
);
91 smb_myname
= SMB_STRDUP(myname
);
94 strupper_m(smb_myname
);
98 const char *global_myname(void)
103 /***********************************************************************
104 Allocate and set myworkgroup. Ensure upper case.
105 ***********************************************************************/
107 BOOL
set_global_myworkgroup(const char *myworkgroup
)
109 SAFE_FREE(smb_myworkgroup
);
110 smb_myworkgroup
= SMB_STRDUP(myworkgroup
);
111 if (!smb_myworkgroup
)
113 strupper_m(smb_myworkgroup
);
117 const char *lp_workgroup(void)
119 return smb_myworkgroup
;
122 /***********************************************************************
123 Allocate and set scope. Ensure upper case.
124 ***********************************************************************/
126 BOOL
set_global_scope(const char *scope
)
128 SAFE_FREE(smb_scope
);
129 smb_scope
= SMB_STRDUP(scope
);
132 strupper_m(smb_scope
);
136 /*********************************************************************
137 Ensure scope is never null string.
138 *********************************************************************/
140 const char *global_scope(void)
143 set_global_scope("");
147 static void free_netbios_names_array(void)
151 for (i
= 0; i
< smb_num_netbios_names
; i
++)
152 SAFE_FREE(smb_my_netbios_names
[i
]);
154 SAFE_FREE(smb_my_netbios_names
);
155 smb_num_netbios_names
= 0;
158 static BOOL
allocate_my_netbios_names_array(size_t number
)
160 free_netbios_names_array();
162 smb_num_netbios_names
= number
+ 1;
163 smb_my_netbios_names
= SMB_MALLOC_ARRAY( char *, smb_num_netbios_names
);
165 if (!smb_my_netbios_names
)
168 memset(smb_my_netbios_names
, '\0', sizeof(char *) * smb_num_netbios_names
);
172 static BOOL
set_my_netbios_names(const char *name
, int i
)
174 SAFE_FREE(smb_my_netbios_names
[i
]);
176 smb_my_netbios_names
[i
] = SMB_STRDUP(name
);
177 if (!smb_my_netbios_names
[i
])
179 strupper_m(smb_my_netbios_names
[i
]);
183 /***********************************************************************
184 Free memory allocated to global objects
185 ***********************************************************************/
187 void gfree_names(void)
189 SAFE_FREE( smb_myname
);
190 SAFE_FREE( smb_myworkgroup
);
191 SAFE_FREE( smb_scope
);
192 free_netbios_names_array();
195 void gfree_all( void )
205 /* release the talloc null_context memory last */
206 talloc_disable_null_tracking();
209 const char *my_netbios_names(int i
)
211 return smb_my_netbios_names
[i
];
214 BOOL
set_netbios_aliases(const char **str_array
)
218 /* Work out the max number of netbios aliases that we have */
219 for( namecount
=0; str_array
&& (str_array
[namecount
] != NULL
); namecount
++ )
222 if ( global_myname() && *global_myname())
225 /* Allocate space for the netbios aliases */
226 if (!allocate_my_netbios_names_array(namecount
))
229 /* Use the global_myname string first */
231 if ( global_myname() && *global_myname()) {
232 set_my_netbios_names( global_myname(), namecount
);
238 for ( i
= 0; str_array
[i
] != NULL
; i
++) {
240 BOOL duplicate
= False
;
242 /* Look for duplicates */
243 for( n
=0; n
<namecount
; n
++ ) {
244 if( strequal( str_array
[i
], my_netbios_names(n
) ) ) {
250 if (!set_my_netbios_names(str_array
[i
], namecount
))
259 /****************************************************************************
260 Common name initialization code.
261 ****************************************************************************/
263 BOOL
init_names(void)
268 if (global_myname() == NULL
|| *global_myname() == '\0') {
269 if (!set_global_myname(myhostname())) {
270 DEBUG( 0, ( "init_structs: malloc fail.\n" ) );
275 if (!set_netbios_aliases(lp_netbios_aliases())) {
276 DEBUG( 0, ( "init_structs: malloc fail.\n" ) );
280 fstrcpy( local_machine
, global_myname() );
281 trim_char( local_machine
, ' ', ' ' );
282 p
= strchr( local_machine
, ' ' );
285 strlower_m( local_machine
);
287 DEBUG( 5, ("Netbios name list:-\n") );
288 for( n
=0; my_netbios_names(n
); n
++ )
289 DEBUGADD( 5, ( "my_netbios_names[%d]=\"%s\"\n", n
, my_netbios_names(n
) ) );
294 /**************************************************************************n
295 Find a suitable temporary directory. The result should be copied immediately
296 as it may be overwritten by a subsequent call.
297 ****************************************************************************/
299 const char *tmpdir(void)
302 if ((p
= getenv("TMPDIR")))
307 /****************************************************************************
308 Add a gid to an array of gids if it's not already there.
309 ****************************************************************************/
311 BOOL
add_gid_to_array_unique(TALLOC_CTX
*mem_ctx
, gid_t gid
,
312 gid_t
**gids
, size_t *num_gids
)
316 if ((*num_gids
!= 0) && (*gids
== NULL
)) {
318 * A former call to this routine has failed to allocate memory
323 for (i
=0; i
<*num_gids
; i
++) {
324 if ((*gids
)[i
] == gid
) {
329 *gids
= TALLOC_REALLOC_ARRAY(mem_ctx
, *gids
, gid_t
, *num_gids
+1);
335 (*gids
)[*num_gids
] = gid
;
340 /****************************************************************************
341 Like atoi but gets the value up to the separator character.
342 ****************************************************************************/
344 static const char *Atoic(const char *p
, int *n
, const char *c
)
346 if (!isdigit((int)*p
)) {
347 DEBUG(5, ("Atoic: malformed number\n"));
353 while ((*p
) && isdigit((int)*p
))
356 if (strchr_m(c
, *p
) == NULL
) {
357 DEBUG(5, ("Atoic: no separator characters (%s) not found\n", c
));
364 /*************************************************************************
365 Reads a list of numbers.
366 *************************************************************************/
368 const char *get_numlist(const char *p
, uint32
**num
, int *count
)
372 if (num
== NULL
|| count
== NULL
)
378 while ((p
= Atoic(p
, &val
, ":,")) != NULL
&& (*p
) != ':') {
379 *num
= SMB_REALLOC_ARRAY((*num
), uint32
, (*count
)+1);
383 (*num
)[(*count
)] = val
;
391 /*******************************************************************
392 Check if a file exists - call vfs_file_exist for samba files.
393 ********************************************************************/
395 BOOL
file_exist(const char *fname
,SMB_STRUCT_STAT
*sbuf
)
401 if (sys_stat(fname
,sbuf
) != 0)
404 return((S_ISREG(sbuf
->st_mode
)) || (S_ISFIFO(sbuf
->st_mode
)));
407 /*******************************************************************
408 Check a files mod time.
409 ********************************************************************/
411 time_t file_modtime(const char *fname
)
415 if (sys_stat(fname
,&st
) != 0)
421 /*******************************************************************
422 Check if a directory exists.
423 ********************************************************************/
425 BOOL
directory_exist(char *dname
,SMB_STRUCT_STAT
*st
)
433 if (sys_stat(dname
,st
) != 0)
436 ret
= S_ISDIR(st
->st_mode
);
442 /*******************************************************************
443 Returns the size in bytes of the named file.
444 ********************************************************************/
446 SMB_OFF_T
get_file_size(char *file_name
)
450 if(sys_stat(file_name
,&buf
) != 0)
451 return (SMB_OFF_T
)-1;
455 /*******************************************************************
456 Return a string representing an attribute for a file.
457 ********************************************************************/
459 char *attrib_string(uint16 mode
)
461 static fstring attrstr
;
465 if (mode
& aVOLID
) fstrcat(attrstr
,"V");
466 if (mode
& aDIR
) fstrcat(attrstr
,"D");
467 if (mode
& aARCH
) fstrcat(attrstr
,"A");
468 if (mode
& aHIDDEN
) fstrcat(attrstr
,"H");
469 if (mode
& aSYSTEM
) fstrcat(attrstr
,"S");
470 if (mode
& aRONLY
) fstrcat(attrstr
,"R");
475 /*******************************************************************
476 Show a smb message structure.
477 ********************************************************************/
479 void show_msg(char *buf
)
487 DEBUG(5,("size=%d\nsmb_com=0x%x\nsmb_rcls=%d\nsmb_reh=%d\nsmb_err=%d\nsmb_flg=%d\nsmb_flg2=%d\n",
489 (int)CVAL(buf
,smb_com
),
490 (int)CVAL(buf
,smb_rcls
),
491 (int)CVAL(buf
,smb_reh
),
492 (int)SVAL(buf
,smb_err
),
493 (int)CVAL(buf
,smb_flg
),
494 (int)SVAL(buf
,smb_flg2
)));
495 DEBUGADD(5,("smb_tid=%d\nsmb_pid=%d\nsmb_uid=%d\nsmb_mid=%d\n",
496 (int)SVAL(buf
,smb_tid
),
497 (int)SVAL(buf
,smb_pid
),
498 (int)SVAL(buf
,smb_uid
),
499 (int)SVAL(buf
,smb_mid
)));
500 DEBUGADD(5,("smt_wct=%d\n",(int)CVAL(buf
,smb_wct
)));
502 for (i
=0;i
<(int)CVAL(buf
,smb_wct
);i
++)
503 DEBUGADD(5,("smb_vwv[%2d]=%5d (0x%X)\n",i
,
504 SVAL(buf
,smb_vwv
+2*i
),SVAL(buf
,smb_vwv
+2*i
)));
506 bcc
= (int)SVAL(buf
,smb_vwv
+2*(CVAL(buf
,smb_wct
)));
508 DEBUGADD(5,("smb_bcc=%d\n",bcc
));
516 dump_data(10, smb_buf(buf
), bcc
);
519 /*******************************************************************
520 Set the length and marker of an smb packet.
521 ********************************************************************/
523 void smb_setlen(char *buf
,int len
)
525 _smb_setlen(buf
,len
);
533 /*******************************************************************
534 Setup the word count and byte count for a smb message.
535 ********************************************************************/
537 int set_message(char *buf
,int num_words
,int num_bytes
,BOOL zero
)
539 if (zero
&& (num_words
|| num_bytes
)) {
540 memset(buf
+ smb_size
,'\0',num_words
*2 + num_bytes
);
542 SCVAL(buf
,smb_wct
,num_words
);
543 SSVAL(buf
,smb_vwv
+ num_words
*SIZEOFWORD
,num_bytes
);
544 smb_setlen(buf
,smb_size
+ num_words
*2 + num_bytes
- 4);
545 return (smb_size
+ num_words
*2 + num_bytes
);
548 /*******************************************************************
549 Setup only the byte count for a smb message.
550 ********************************************************************/
552 int set_message_bcc(char *buf
,int num_bytes
)
554 int num_words
= CVAL(buf
,smb_wct
);
555 SSVAL(buf
,smb_vwv
+ num_words
*SIZEOFWORD
,num_bytes
);
556 smb_setlen(buf
,smb_size
+ num_words
*2 + num_bytes
- 4);
557 return (smb_size
+ num_words
*2 + num_bytes
);
560 /*******************************************************************
561 Setup only the byte count for a smb message, using the end of the
563 ********************************************************************/
565 int set_message_end(void *outbuf
,void *end_ptr
)
567 return set_message_bcc((char *)outbuf
,PTR_DIFF(end_ptr
,smb_buf((char *)outbuf
)));
570 /*******************************************************************
571 Reduce a file name, removing .. elements.
572 ********************************************************************/
574 void dos_clean_name(char *s
)
578 DEBUG(3,("dos_clean_name [%s]\n",s
));
580 /* remove any double slashes */
581 all_string_sub(s
, "\\\\", "\\", 0);
583 /* Remove leading .\\ characters */
584 if(strncmp(s
, ".\\", 2) == 0) {
585 trim_string(s
, ".\\", NULL
);
590 while ((p
= strstr_m(s
,"\\..\\")) != NULL
) {
596 if ((p
=strrchr_m(s
,'\\')) != NULL
)
603 trim_string(s
,NULL
,"\\..");
604 all_string_sub(s
, "\\.\\", "\\", 0);
607 /*******************************************************************
608 Reduce a file name, removing .. elements.
609 ********************************************************************/
611 void unix_clean_name(char *s
)
615 DEBUG(3,("unix_clean_name [%s]\n",s
));
617 /* remove any double slashes */
618 all_string_sub(s
, "//","/", 0);
620 /* Remove leading ./ characters */
621 if(strncmp(s
, "./", 2) == 0) {
622 trim_string(s
, "./", NULL
);
627 while ((p
= strstr_m(s
,"/../")) != NULL
) {
633 if ((p
=strrchr_m(s
,'/')) != NULL
)
640 trim_string(s
,NULL
,"/..");
641 all_string_sub(s
, "/./", "/", 0);
644 void clean_name(char *s
)
650 /*******************************************************************
651 Close the low 3 fd's and open dev/null in their place.
652 ********************************************************************/
654 void close_low_fds(BOOL stderr_too
)
666 /* try and use up these file descriptors, so silly
667 library routines writing to stdout etc won't cause havoc */
669 if (i
== 2 && !stderr_too
)
672 fd
= sys_open("/dev/null",O_RDWR
,0);
674 fd
= sys_open("/dev/null",O_WRONLY
,0);
676 DEBUG(0,("Can't open /dev/null\n"));
680 DEBUG(0,("Didn't get file descriptor %d\n",i
));
687 /*******************************************************************
688 Write data into an fd at a given offset. Ignore seek errors.
689 ********************************************************************/
691 ssize_t
write_data_at_offset(int fd
, const char *buffer
, size_t N
, SMB_OFF_T pos
)
696 if (pos
== (SMB_OFF_T
)-1) {
697 return write_data(fd
, buffer
, N
);
699 #if defined(HAVE_PWRITE) || defined(HAVE_PRWITE64)
701 ret
= sys_pwrite(fd
,buffer
+ total
,N
- total
, pos
);
702 if (ret
== -1 && errno
== ESPIPE
) {
703 return write_data(fd
, buffer
+ total
,N
- total
);
706 DEBUG(0,("write_data_at_offset: write failure. Error = %s\n", strerror(errno
) ));
715 return (ssize_t
)total
;
717 /* Use lseek and write_data. */
718 if (sys_lseek(fd
, pos
, SEEK_SET
) == -1) {
719 if (errno
!= ESPIPE
) {
723 return write_data(fd
, buffer
, N
);
727 /****************************************************************************
728 Set a fd into blocking/nonblocking mode. Uses POSIX O_NONBLOCK if available,
732 ****************************************************************************/
734 int set_blocking(int fd
, BOOL set
)
738 #define FLAG_TO_SET O_NONBLOCK
741 #define FLAG_TO_SET O_NDELAY
743 #define FLAG_TO_SET FNDELAY
747 if((val
= sys_fcntl_long(fd
, F_GETFL
, 0)) == -1)
749 if(set
) /* Turn blocking on - ie. clear nonblock flag */
753 return sys_fcntl_long( fd
, F_SETFL
, val
);
757 /****************************************************************************
758 Transfer some data between two fd's.
759 ****************************************************************************/
761 #ifndef TRANSFER_BUF_SIZE
762 #define TRANSFER_BUF_SIZE 65536
765 ssize_t
transfer_file_internal(int infd
, int outfd
, size_t n
, ssize_t (*read_fn
)(int, void *, size_t),
766 ssize_t (*write_fn
)(int, const void *, size_t))
772 size_t num_to_read_thistime
;
773 size_t num_written
= 0;
775 if ((buf
= SMB_MALLOC_ARRAY(char, TRANSFER_BUF_SIZE
)) == NULL
)
779 num_to_read_thistime
= MIN((n
- total
), TRANSFER_BUF_SIZE
);
781 read_ret
= (*read_fn
)(infd
, buf
, num_to_read_thistime
);
782 if (read_ret
== -1) {
783 DEBUG(0,("transfer_file_internal: read failure. Error = %s\n", strerror(errno
) ));
792 while (num_written
< read_ret
) {
793 write_ret
= (*write_fn
)(outfd
,buf
+ num_written
, read_ret
- num_written
);
795 if (write_ret
== -1) {
796 DEBUG(0,("transfer_file_internal: write failure. Error = %s\n", strerror(errno
) ));
801 return (ssize_t
)total
;
803 num_written
+= (size_t)write_ret
;
806 total
+= (size_t)read_ret
;
810 return (ssize_t
)total
;
813 SMB_OFF_T
transfer_file(int infd
,int outfd
,SMB_OFF_T n
)
815 return (SMB_OFF_T
)transfer_file_internal(infd
, outfd
, (size_t)n
, sys_read
, sys_write
);
818 /*******************************************************************
819 Sleep for a specified number of milliseconds.
820 ********************************************************************/
822 void smb_msleep(unsigned int t
)
824 #if defined(HAVE_NANOSLEEP)
825 struct timespec tval
;
828 tval
.tv_sec
= t
/1000;
829 tval
.tv_nsec
= 1000000*(t
%1000);
833 ret
= nanosleep(&tval
, &tval
);
834 } while (ret
< 0 && errno
== EINTR
&& (tval
.tv_sec
> 0 || tval
.tv_nsec
> 0));
836 unsigned int tdiff
=0;
837 struct timeval tval
,t1
,t2
;
844 tval
.tv_sec
= (t
-tdiff
)/1000;
845 tval
.tv_usec
= 1000*((t
-tdiff
)%1000);
847 /* Never wait for more than 1 sec. */
848 if (tval
.tv_sec
> 1) {
855 sys_select_intr(0,&fds
,NULL
,NULL
,&tval
);
858 if (t2
.tv_sec
< t1
.tv_sec
) {
859 /* Someone adjusted time... */
863 tdiff
= TvalDiff(&t1
,&t2
);
868 /****************************************************************************
869 Become a daemon, discarding the controlling terminal.
870 ****************************************************************************/
872 void become_daemon(BOOL Fork
, BOOL no_process_group
)
880 /* detach from the terminal */
882 if (!no_process_group
) setsid();
883 #elif defined(TIOCNOTTY)
884 if (!no_process_group
) {
885 int i
= sys_open("/dev/tty", O_RDWR
, 0);
887 ioctl(i
, (int) TIOCNOTTY
, (char *)0);
891 #endif /* HAVE_SETSID */
893 /* Close fd's 0,1,2. Needed if started by rsh */
894 close_low_fds(False
); /* Don't close stderr, let the debug system
895 attach it to the logfile */
898 /****************************************************************************
899 Put up a yes/no prompt.
900 ****************************************************************************/
907 if (!fgets(ans
,sizeof(ans
)-1,stdin
))
910 if (*ans
== 'y' || *ans
== 'Y')
916 #if defined(PARANOID_MALLOC_CHECKER)
918 /****************************************************************************
919 Internal malloc wrapper. Externally visible.
920 ****************************************************************************/
922 void *malloc_(size_t size
)
929 #define malloc(s) __ERROR_DONT_USE_MALLOC_DIRECTLY
932 /****************************************************************************
933 Internal calloc wrapper. Not externally visible.
934 ****************************************************************************/
936 static void *calloc_(size_t count
, size_t size
)
938 if (size
== 0 || count
== 0) {
942 return calloc(count
, size
);
943 #define calloc(n,s) __ERROR_DONT_USE_CALLOC_DIRECTLY
946 /****************************************************************************
947 Internal realloc wrapper. Not externally visible.
948 ****************************************************************************/
950 static void *realloc_(void *ptr
, size_t size
)
953 return realloc(ptr
, size
);
954 #define realloc(p,s) __ERROR_DONT_USE_RELLOC_DIRECTLY
957 #endif /* PARANOID_MALLOC_CHECKER */
959 /****************************************************************************
961 ****************************************************************************/
963 void *malloc_array(size_t el_size
, unsigned int count
)
965 if (count
>= MAX_ALLOC_SIZE
/el_size
) {
969 if (el_size
== 0 || count
== 0) {
972 #if defined(PARANOID_MALLOC_CHECKER)
973 return malloc_(el_size
*count
);
975 return malloc(el_size
*count
);
979 /****************************************************************************
981 ****************************************************************************/
983 void *memalign_array(size_t el_size
, size_t align
, unsigned int count
)
985 if (count
>= MAX_ALLOC_SIZE
/el_size
) {
989 return sys_memalign(align
, el_size
*count
);
992 /****************************************************************************
994 ****************************************************************************/
996 void *calloc_array(size_t size
, size_t nmemb
)
998 if (nmemb
>= MAX_ALLOC_SIZE
/size
) {
1001 if (size
== 0 || nmemb
== 0) {
1004 #if defined(PARANOID_MALLOC_CHECKER)
1005 return calloc_(nmemb
, size
);
1007 return calloc(nmemb
, size
);
1011 /****************************************************************************
1012 Expand a pointer to be a particular size.
1013 Note that this version of Realloc has an extra parameter that decides
1014 whether to free the passed in storage on allocation failure or if the
1017 This is designed for use in the typical idiom of :
1019 p = SMB_REALLOC(p, size)
1024 and not to have to keep track of the old 'p' contents to free later, nor
1025 to worry if the size parameter was zero. In the case where NULL is returned
1026 we guarentee that p has been freed.
1028 If free later semantics are desired, then pass 'free_old_on_error' as False which
1029 guarentees that the old contents are not freed on error, even if size == 0. To use
1032 tmp = SMB_REALLOC_KEEP_OLD_ON_ERROR(p, size);
1040 Changes were instigated by Coverity error checking. JRA.
1041 ****************************************************************************/
1043 void *Realloc(void *p
, size_t size
, BOOL free_old_on_error
)
1048 if (free_old_on_error
) {
1051 DEBUG(2,("Realloc asked for 0 bytes\n"));
1055 #if defined(PARANOID_MALLOC_CHECKER)
1057 ret
= (void *)malloc_(size
);
1059 ret
= (void *)realloc_(p
,size
);
1063 ret
= (void *)malloc(size
);
1065 ret
= (void *)realloc(p
,size
);
1070 if (free_old_on_error
&& p
) {
1073 DEBUG(0,("Memory allocation error: failed to expand to %d bytes\n",(int)size
));
1079 /****************************************************************************
1081 ****************************************************************************/
1083 void *realloc_array(void *p
, size_t el_size
, unsigned int count
, BOOL free_old_on_error
)
1085 if (count
>= MAX_ALLOC_SIZE
/el_size
) {
1086 if (free_old_on_error
) {
1091 return Realloc(p
, el_size
*count
, free_old_on_error
);
1094 /****************************************************************************
1095 (Hopefully) efficient array append.
1096 ****************************************************************************/
1098 void add_to_large_array(TALLOC_CTX
*mem_ctx
, size_t element_size
,
1099 void *element
, void *_array
, uint32
*num_elements
,
1100 ssize_t
*array_size
)
1102 void **array
= (void **)_array
;
1104 if (*array_size
< 0) {
1108 if (*array
== NULL
) {
1109 if (*array_size
== 0) {
1113 if (*array_size
>= MAX_ALLOC_SIZE
/element_size
) {
1117 *array
= TALLOC(mem_ctx
, element_size
* (*array_size
));
1118 if (*array
== NULL
) {
1123 if (*num_elements
== *array_size
) {
1126 if (*array_size
>= MAX_ALLOC_SIZE
/element_size
) {
1130 *array
= TALLOC_REALLOC(mem_ctx
, *array
,
1131 element_size
* (*array_size
));
1133 if (*array
== NULL
) {
1138 memcpy((char *)(*array
) + element_size
*(*num_elements
),
1139 element
, element_size
);
1149 /****************************************************************************
1150 Free memory, checks for NULL.
1151 Use directly SAFE_FREE()
1152 Exists only because we need to pass a function pointer somewhere --SSS
1153 ****************************************************************************/
1155 void safe_free(void *p
)
1160 /****************************************************************************
1161 Get my own name and IP.
1162 ****************************************************************************/
1164 BOOL
get_myname(char *my_name
)
1170 /* get my host name */
1171 if (gethostname(hostname
, sizeof(hostname
)) == -1) {
1172 DEBUG(0,("gethostname failed\n"));
1176 /* Ensure null termination. */
1177 hostname
[sizeof(hostname
)-1] = '\0';
1180 /* split off any parts after an initial . */
1181 char *p
= strchr_m(hostname
,'.');
1186 fstrcpy(my_name
,hostname
);
1192 /****************************************************************************
1193 Get my own canonical name, including domain.
1194 ****************************************************************************/
1196 BOOL
get_mydnsfullname(fstring my_dnsname
)
1198 static fstring dnshostname
;
1201 if (!*dnshostname
) {
1202 /* get my host name */
1203 if (gethostname(dnshostname
, sizeof(dnshostname
)) == -1) {
1204 *dnshostname
= '\0';
1205 DEBUG(0,("gethostname failed\n"));
1209 /* Ensure null termination. */
1210 dnshostname
[sizeof(dnshostname
)-1] = '\0';
1212 /* Ensure we get the cannonical name. */
1213 if (!(hp
= sys_gethostbyname(dnshostname
))) {
1214 *dnshostname
= '\0';
1217 fstrcpy(dnshostname
, hp
->h_name
);
1219 fstrcpy(my_dnsname
, dnshostname
);
1223 /****************************************************************************
1224 Get my own domain name.
1225 ****************************************************************************/
1227 BOOL
get_mydnsdomname(fstring my_domname
)
1233 if (!get_mydnsfullname(domname
)) {
1236 p
= strchr_m(domname
, '.');
1239 fstrcpy(my_domname
, p
);
1246 /****************************************************************************
1247 Interpret a protocol description string, with a default.
1248 ****************************************************************************/
1250 int interpret_protocol(const char *str
,int def
)
1252 if (strequal(str
,"NT1"))
1253 return(PROTOCOL_NT1
);
1254 if (strequal(str
,"LANMAN2"))
1255 return(PROTOCOL_LANMAN2
);
1256 if (strequal(str
,"LANMAN1"))
1257 return(PROTOCOL_LANMAN1
);
1258 if (strequal(str
,"CORE"))
1259 return(PROTOCOL_CORE
);
1260 if (strequal(str
,"COREPLUS"))
1261 return(PROTOCOL_COREPLUS
);
1262 if (strequal(str
,"CORE+"))
1263 return(PROTOCOL_COREPLUS
);
1265 DEBUG(0,("Unrecognised protocol level %s\n",str
));
1270 /****************************************************************************
1271 Return true if a string could be a pure IP address.
1272 ****************************************************************************/
1274 BOOL
is_ipaddress(const char *str
)
1276 BOOL pure_address
= True
;
1279 for (i
=0; pure_address
&& str
[i
]; i
++)
1280 if (!(isdigit((int)str
[i
]) || str
[i
] == '.'))
1281 pure_address
= False
;
1283 /* Check that a pure number is not misinterpreted as an IP */
1284 pure_address
= pure_address
&& (strchr_m(str
, '.') != NULL
);
1286 return pure_address
;
1289 /****************************************************************************
1290 Interpret an internet address or name into an IP address in 4 byte form.
1291 ****************************************************************************/
1293 uint32
interpret_addr(const char *str
)
1298 if (strcmp(str
,"0.0.0.0") == 0)
1300 if (strcmp(str
,"255.255.255.255") == 0)
1303 /* if it's in the form of an IP address then get the lib to interpret it */
1304 if (is_ipaddress(str
)) {
1305 res
= inet_addr(str
);
1307 /* otherwise assume it's a network name of some sort and use
1308 sys_gethostbyname */
1309 if ((hp
= sys_gethostbyname(str
)) == 0) {
1310 DEBUG(3,("sys_gethostbyname: Unknown host. %s\n",str
));
1314 if(hp
->h_addr
== NULL
) {
1315 DEBUG(3,("sys_gethostbyname: host address is invalid for host %s\n",str
));
1318 putip((char *)&res
,(char *)hp
->h_addr
);
1321 if (res
== (uint32
)-1)
1327 /*******************************************************************
1328 A convenient addition to interpret_addr().
1329 ******************************************************************/
1331 struct in_addr
*interpret_addr2(const char *str
)
1333 static struct in_addr ret
;
1334 uint32 a
= interpret_addr(str
);
1339 /*******************************************************************
1340 Check if an IP is the 0.0.0.0.
1341 ******************************************************************/
1343 BOOL
is_zero_ip(struct in_addr ip
)
1346 putip((char *)&a
,(char *)&ip
);
1350 /*******************************************************************
1351 Set an IP to 0.0.0.0.
1352 ******************************************************************/
1354 void zero_ip(struct in_addr
*ip
)
1357 static struct in_addr ipzero
;
1360 ipzero
= *interpret_addr2("0.0.0.0");
1367 #if (defined(HAVE_NETGROUP) && defined(WITH_AUTOMOUNT))
1368 /******************************************************************
1369 Remove any mount options such as -rsize=2048,wsize=2048 etc.
1370 Based on a fix from <Thomas.Hepper@icem.de>.
1371 *******************************************************************/
1373 static void strip_mount_options( pstring
*str
)
1377 while(*p
&& !isspace(*p
))
1379 while(*p
&& isspace(*p
))
1384 pstrcpy(tmp_str
, p
);
1385 pstrcpy(*str
, tmp_str
);
1390 /*******************************************************************
1391 Patch from jkf@soton.ac.uk
1392 Split Luke's automount_server into YP lookup and string splitter
1393 so can easily implement automount_path().
1394 As we may end up doing both, cache the last YP result.
1395 *******************************************************************/
1397 #ifdef WITH_NISPLUS_HOME
1398 char *automount_lookup(const char *user_name
)
1400 static fstring last_key
= "";
1401 static pstring last_value
= "";
1403 char *nis_map
= (char *)lp_nis_home_map_name();
1405 char buffer
[NIS_MAXATTRVAL
+ 1];
1410 if (strcmp(user_name
, last_key
)) {
1411 slprintf(buffer
, sizeof(buffer
)-1, "[key=%s],%s", user_name
, nis_map
);
1412 DEBUG(5, ("NIS+ querystring: %s\n", buffer
));
1414 if (result
= nis_list(buffer
, FOLLOW_PATH
|EXPAND_NAME
|HARD_LOOKUP
, NULL
, NULL
)) {
1415 if (result
->status
!= NIS_SUCCESS
) {
1416 DEBUG(3, ("NIS+ query failed: %s\n", nis_sperrno(result
->status
)));
1417 fstrcpy(last_key
, ""); pstrcpy(last_value
, "");
1419 object
= result
->objects
.objects_val
;
1420 if (object
->zo_data
.zo_type
== ENTRY_OBJ
) {
1421 entry
= &object
->zo_data
.objdata_u
.en_data
;
1422 DEBUG(5, ("NIS+ entry type: %s\n", entry
->en_type
));
1423 DEBUG(3, ("NIS+ result: %s\n", entry
->en_cols
.en_cols_val
[1].ec_value
.ec_value_val
));
1425 pstrcpy(last_value
, entry
->en_cols
.en_cols_val
[1].ec_value
.ec_value_val
);
1426 pstring_sub(last_value
, "&", user_name
);
1427 fstrcpy(last_key
, user_name
);
1431 nis_freeresult(result
);
1434 strip_mount_options(&last_value
);
1436 DEBUG(4, ("NIS+ Lookup: %s resulted in %s\n", user_name
, last_value
));
1439 #else /* WITH_NISPLUS_HOME */
1441 char *automount_lookup(const char *user_name
)
1443 static fstring last_key
= "";
1444 static pstring last_value
= "";
1446 int nis_error
; /* returned by yp all functions */
1447 char *nis_result
; /* yp_match inits this */
1448 int nis_result_len
; /* and set this */
1449 char *nis_domain
; /* yp_get_default_domain inits this */
1450 char *nis_map
= (char *)lp_nis_home_map_name();
1452 if ((nis_error
= yp_get_default_domain(&nis_domain
)) != 0) {
1453 DEBUG(3, ("YP Error: %s\n", yperr_string(nis_error
)));
1457 DEBUG(5, ("NIS Domain: %s\n", nis_domain
));
1459 if (!strcmp(user_name
, last_key
)) {
1460 nis_result
= last_value
;
1461 nis_result_len
= strlen(last_value
);
1464 if ((nis_error
= yp_match(nis_domain
, nis_map
, user_name
, strlen(user_name
),
1465 &nis_result
, &nis_result_len
)) == 0) {
1466 fstrcpy(last_key
, user_name
);
1467 pstrcpy(last_value
, nis_result
);
1468 strip_mount_options(&last_value
);
1470 } else if(nis_error
== YPERR_KEY
) {
1472 /* If Key lookup fails user home server is not in nis_map
1473 use default information for server, and home directory */
1475 DEBUG(3, ("YP Key not found: while looking up \"%s\" in map \"%s\"\n",
1476 user_name
, nis_map
));
1477 DEBUG(3, ("using defaults for server and home directory\n"));
1479 DEBUG(3, ("YP Error: \"%s\" while looking up \"%s\" in map \"%s\"\n",
1480 yperr_string(nis_error
), user_name
, nis_map
));
1484 DEBUG(4, ("YP Lookup: %s resulted in %s\n", user_name
, last_value
));
1487 #endif /* WITH_NISPLUS_HOME */
1490 /*******************************************************************
1491 Are two IPs on the same subnet?
1492 ********************************************************************/
1494 BOOL
same_net(struct in_addr ip1
,struct in_addr ip2
,struct in_addr mask
)
1496 uint32 net1
,net2
,nmask
;
1498 nmask
= ntohl(mask
.s_addr
);
1499 net1
= ntohl(ip1
.s_addr
);
1500 net2
= ntohl(ip2
.s_addr
);
1502 return((net1
& nmask
) == (net2
& nmask
));
1506 /****************************************************************************
1507 Check if a process exists. Does this work on all unixes?
1508 ****************************************************************************/
1510 BOOL
process_exists(const struct process_id pid
)
1512 if (procid_is_me(&pid
)) {
1516 if (!procid_is_local(&pid
)) {
1517 /* This *SEVERELY* needs fixing. */
1521 /* Doing kill with a non-positive pid causes messages to be
1522 * sent to places we don't want. */
1523 SMB_ASSERT(pid
.pid
> 0);
1524 return(kill(pid
.pid
,0) == 0 || errno
!= ESRCH
);
1527 BOOL
process_exists_by_pid(pid_t pid
)
1529 return process_exists(pid_to_procid(pid
));
1532 /*******************************************************************
1533 Convert a uid into a user name.
1534 ********************************************************************/
1536 const char *uidtoname(uid_t uid
)
1538 static fstring name
;
1539 struct passwd
*pass
;
1541 pass
= getpwuid_alloc(NULL
, uid
);
1543 fstrcpy(name
, pass
->pw_name
);
1546 slprintf(name
, sizeof(name
) - 1, "%ld",(long int)uid
);
1552 /*******************************************************************
1553 Convert a gid into a group name.
1554 ********************************************************************/
1556 char *gidtoname(gid_t gid
)
1558 static fstring name
;
1561 grp
= getgrgid(gid
);
1563 return(grp
->gr_name
);
1564 slprintf(name
,sizeof(name
) - 1, "%d",(int)gid
);
1568 /*******************************************************************
1569 Convert a user name into a uid.
1570 ********************************************************************/
1572 uid_t
nametouid(const char *name
)
1574 struct passwd
*pass
;
1578 pass
= getpwnam_alloc(NULL
, name
);
1585 u
= (uid_t
)strtol(name
, &p
, 0);
1586 if ((p
!= name
) && (*p
== '\0'))
1592 /*******************************************************************
1593 Convert a name to a gid_t if possible. Return -1 if not a group.
1594 ********************************************************************/
1596 gid_t
nametogid(const char *name
)
1602 g
= (gid_t
)strtol(name
, &p
, 0);
1603 if ((p
!= name
) && (*p
== '\0'))
1606 grp
= sys_getgrnam(name
);
1608 return(grp
->gr_gid
);
1612 /*******************************************************************
1613 Something really nasty happened - panic !
1614 ********************************************************************/
1616 void smb_panic(const char *const why
)
1624 if (global_clobber_region_function
) {
1625 DEBUG(0,("smb_panic: clobber_region() last called from [%s(%u)]\n",
1626 global_clobber_region_function
,
1627 global_clobber_region_line
));
1632 DEBUG(0,("PANIC (pid %llu): %s\n",
1633 (unsigned long long)sys_getpid(), why
));
1636 cmd
= lp_panic_action();
1638 DEBUG(0, ("smb_panic(): calling panic action [%s]\n", cmd
));
1639 result
= system(cmd
);
1642 DEBUG(0, ("smb_panic(): fork failed in panic action: %s\n",
1645 DEBUG(0, ("smb_panic(): action returned status %d\n",
1646 WEXITSTATUS(result
)));
1652 /*******************************************************************
1653 Print a backtrace of the stack to the debug log. This function
1654 DELIBERATELY LEAKS MEMORY. The expectation is that you should
1655 exit shortly after calling it.
1656 ********************************************************************/
1658 #ifdef HAVE_LIBUNWIND_H
1659 #include <libunwind.h>
1662 #ifdef HAVE_EXECINFO_H
1663 #include <execinfo.h>
1666 #ifdef HAVE_LIBEXC_H
1670 void log_stack_trace(void)
1672 #ifdef HAVE_LIBUNWIND
1673 /* Try to use libunwind before any other technique since on ia64
1674 * libunwind correctly walks the stack in more circumstances than
1677 unw_cursor_t cursor
;
1682 unw_word_t ip
, sp
, off
;
1684 procname
[sizeof(procname
) - 1] = '\0';
1686 if (unw_getcontext(&uc
) != 0) {
1687 goto libunwind_failed
;
1690 if (unw_init_local(&cursor
, &uc
) != 0) {
1691 goto libunwind_failed
;
1694 DEBUG(0, ("BACKTRACE:\n"));
1698 unw_get_reg(&cursor
, UNW_REG_IP
, &ip
);
1699 unw_get_reg(&cursor
, UNW_REG_SP
, &sp
);
1701 switch (unw_get_proc_name(&cursor
,
1702 procname
, sizeof(procname
) - 1, &off
) ) {
1706 /* Name truncated. */
1707 DEBUGADD(0, (" #%u %s + %#llx [ip=%#llx] [sp=%#llx]\n",
1708 i
, procname
, (long long)off
,
1709 (long long)ip
, (long long) sp
));
1712 /* case -UNW_ENOINFO: */
1713 /* case -UNW_EUNSPEC: */
1714 /* No symbol name found. */
1715 DEBUGADD(0, (" #%u %s [ip=%#llx] [sp=%#llx]\n",
1716 i
, "<unknown symbol>",
1717 (long long)ip
, (long long) sp
));
1720 } while (unw_step(&cursor
) > 0);
1725 DEBUG(0, ("unable to produce a stack trace with libunwind\n"));
1727 #elif HAVE_BACKTRACE_SYMBOLS
1728 void *backtrace_stack
[BACKTRACE_STACK_SIZE
];
1729 size_t backtrace_size
;
1730 char **backtrace_strings
;
1732 /* get the backtrace (stack frames) */
1733 backtrace_size
= backtrace(backtrace_stack
,BACKTRACE_STACK_SIZE
);
1734 backtrace_strings
= backtrace_symbols(backtrace_stack
, backtrace_size
);
1736 DEBUG(0, ("BACKTRACE: %lu stack frames:\n",
1737 (unsigned long)backtrace_size
));
1739 if (backtrace_strings
) {
1742 for (i
= 0; i
< backtrace_size
; i
++)
1743 DEBUGADD(0, (" #%u %s\n", i
, backtrace_strings
[i
]));
1745 /* Leak the backtrace_strings, rather than risk what free() might do */
1750 /* The IRIX libexc library provides an API for unwinding the stack. See
1751 * libexc(3) for details. Apparantly trace_back_stack leaks memory, but
1752 * since we are about to abort anyway, it hardly matters.
1755 #define NAMESIZE 32 /* Arbitrary */
1757 __uint64_t addrs
[BACKTRACE_STACK_SIZE
];
1758 char * names
[BACKTRACE_STACK_SIZE
];
1759 char namebuf
[BACKTRACE_STACK_SIZE
* NAMESIZE
];
1766 ZERO_ARRAY(namebuf
);
1768 /* We need to be root so we can open our /proc entry to walk
1769 * our stack. It also helps when we want to dump core.
1773 for (i
= 0; i
< BACKTRACE_STACK_SIZE
; i
++) {
1774 names
[i
] = namebuf
+ (i
* NAMESIZE
);
1777 levels
= trace_back_stack(0, addrs
, names
,
1778 BACKTRACE_STACK_SIZE
, NAMESIZE
- 1);
1780 DEBUG(0, ("BACKTRACE: %d stack frames:\n", levels
));
1781 for (i
= 0; i
< levels
; i
++) {
1782 DEBUGADD(0, (" #%d 0x%llx %s\n", i
, addrs
[i
], names
[i
]));
1787 DEBUG(0, ("unable to produce a stack trace on this platform\n"));
1791 /*******************************************************************
1792 A readdir wrapper which just returns the file name.
1793 ********************************************************************/
1795 const char *readdirname(SMB_STRUCT_DIR
*p
)
1797 SMB_STRUCT_DIRENT
*ptr
;
1803 ptr
= (SMB_STRUCT_DIRENT
*)sys_readdir(p
);
1807 dname
= ptr
->d_name
;
1814 #ifdef HAVE_BROKEN_READDIR_NAME
1815 /* using /usr/ucb/cc is BAD */
1821 int len
= NAMLEN(ptr
);
1822 memcpy(buf
, dname
, len
);
1830 /*******************************************************************
1831 Utility function used to decide if the last component
1832 of a path matches a (possibly wildcarded) entry in a namelist.
1833 ********************************************************************/
1835 BOOL
is_in_path(const char *name
, name_compare_entry
*namelist
, BOOL case_sensitive
)
1837 const char *last_component
;
1839 /* if we have no list it's obviously not in the path */
1840 if((namelist
== NULL
) || ((namelist
!= NULL
) && (namelist
[0].name
== NULL
))) {
1844 DEBUG(8, ("is_in_path: %s\n", name
));
1846 /* Get the last component of the unix name. */
1847 last_component
= strrchr_m(name
, '/');
1848 if (!last_component
) {
1849 last_component
= name
;
1851 last_component
++; /* Go past '/' */
1854 for(; namelist
->name
!= NULL
; namelist
++) {
1855 if(namelist
->is_wild
) {
1856 if (mask_match(last_component
, namelist
->name
, case_sensitive
)) {
1857 DEBUG(8,("is_in_path: mask match succeeded\n"));
1861 if((case_sensitive
&& (strcmp(last_component
, namelist
->name
) == 0))||
1862 (!case_sensitive
&& (StrCaseCmp(last_component
, namelist
->name
) == 0))) {
1863 DEBUG(8,("is_in_path: match succeeded\n"));
1868 DEBUG(8,("is_in_path: match not found\n"));
1872 /*******************************************************************
1873 Strip a '/' separated list into an array of
1874 name_compare_enties structures suitable for
1875 passing to is_in_path(). We do this for
1876 speed so we can pre-parse all the names in the list
1877 and don't do it for each call to is_in_path().
1878 namelist is modified here and is assumed to be
1879 a copy owned by the caller.
1880 We also check if the entry contains a wildcard to
1881 remove a potentially expensive call to mask_match
1883 ********************************************************************/
1885 void set_namearray(name_compare_entry
**ppname_array
, char *namelist
)
1888 char *nameptr
= namelist
;
1889 int num_entries
= 0;
1892 (*ppname_array
) = NULL
;
1894 if((nameptr
== NULL
) || ((nameptr
!= NULL
) && (*nameptr
== '\0')))
1897 /* We need to make two passes over the string. The
1898 first to count the number of elements, the second
1903 if ( *nameptr
== '/' ) {
1904 /* cope with multiple (useless) /s) */
1908 /* find the next / */
1909 name_end
= strchr_m(nameptr
, '/');
1911 /* oops - the last check for a / didn't find one. */
1912 if (name_end
== NULL
)
1915 /* next segment please */
1916 nameptr
= name_end
+ 1;
1920 if(num_entries
== 0)
1923 if(( (*ppname_array
) = SMB_MALLOC_ARRAY(name_compare_entry
, num_entries
+ 1)) == NULL
) {
1924 DEBUG(0,("set_namearray: malloc fail\n"));
1928 /* Now copy out the names */
1932 if ( *nameptr
== '/' ) {
1933 /* cope with multiple (useless) /s) */
1937 /* find the next / */
1938 if ((name_end
= strchr_m(nameptr
, '/')) != NULL
)
1941 /* oops - the last check for a / didn't find one. */
1942 if(name_end
== NULL
)
1945 (*ppname_array
)[i
].is_wild
= ms_has_wild(nameptr
);
1946 if(((*ppname_array
)[i
].name
= SMB_STRDUP(nameptr
)) == NULL
) {
1947 DEBUG(0,("set_namearray: malloc fail (1)\n"));
1951 /* next segment please */
1952 nameptr
= name_end
+ 1;
1956 (*ppname_array
)[i
].name
= NULL
;
1961 /****************************************************************************
1962 Routine to free a namearray.
1963 ****************************************************************************/
1965 void free_namearray(name_compare_entry
*name_array
)
1969 if(name_array
== NULL
)
1972 for(i
=0; name_array
[i
].name
!=NULL
; i
++)
1973 SAFE_FREE(name_array
[i
].name
);
1974 SAFE_FREE(name_array
);
1978 #define DBGC_CLASS DBGC_LOCKING
1980 /****************************************************************************
1981 Simple routine to do POSIX file locking. Cruft in NFS and 64->32 bit mapping
1982 is dealt with in posix.c
1983 Returns True if the lock was granted, False otherwise.
1984 ****************************************************************************/
1986 BOOL
fcntl_lock(int fd
, int op
, SMB_OFF_T offset
, SMB_OFF_T count
, int type
)
1988 SMB_STRUCT_FLOCK lock
;
1991 DEBUG(8,("fcntl_lock fd=%d op=%d offset=%.0f count=%.0f type=%d\n",
1992 fd
,op
,(double)offset
,(double)count
,type
));
1995 lock
.l_whence
= SEEK_SET
;
1996 lock
.l_start
= offset
;
2000 ret
= sys_fcntl_ptr(fd
,op
,&lock
);
2004 DEBUG(3,("fcntl_lock: lock failed at offset %.0f count %.0f op %d type %d (%s)\n",
2005 (double)offset
,(double)count
,op
,type
,strerror(errno
)));
2010 /* everything went OK */
2011 DEBUG(8,("fcntl_lock: Lock call successful\n"));
2016 /****************************************************************************
2017 Simple routine to query existing file locks. Cruft in NFS and 64->32 bit mapping
2018 is dealt with in posix.c
2019 Returns True if we have information regarding this lock region (and returns
2020 F_UNLCK in *ptype if the region is unlocked). False if the call failed.
2021 ****************************************************************************/
2023 BOOL
fcntl_getlock(int fd
, SMB_OFF_T
*poffset
, SMB_OFF_T
*pcount
, int *ptype
, pid_t
*ppid
)
2025 SMB_STRUCT_FLOCK lock
;
2028 DEBUG(8,("fcntl_getlock fd=%d offset=%.0f count=%.0f type=%d\n",
2029 fd
,(double)*poffset
,(double)*pcount
,*ptype
));
2031 lock
.l_type
= *ptype
;
2032 lock
.l_whence
= SEEK_SET
;
2033 lock
.l_start
= *poffset
;
2034 lock
.l_len
= *pcount
;
2037 ret
= sys_fcntl_ptr(fd
,SMB_F_GETLK
,&lock
);
2041 DEBUG(3,("fcntl_getlock: lock request failed at offset %.0f count %.0f type %d (%s)\n",
2042 (double)*poffset
,(double)*pcount
,*ptype
,strerror(errno
)));
2047 *ptype
= lock
.l_type
;
2048 *poffset
= lock
.l_start
;
2049 *pcount
= lock
.l_len
;
2052 DEBUG(3,("fcntl_getlock: fd %d is returned info %d pid %u\n",
2053 fd
, (int)lock
.l_type
, (unsigned int)lock
.l_pid
));
2058 #define DBGC_CLASS DBGC_ALL
2060 /*******************************************************************
2061 Is the name specified one of my netbios names.
2062 Returns true if it is equal, false otherwise.
2063 ********************************************************************/
2065 BOOL
is_myname(const char *s
)
2070 for (n
=0; my_netbios_names(n
); n
++) {
2071 if (strequal(my_netbios_names(n
), s
)) {
2076 DEBUG(8, ("is_myname(\"%s\") returns %d\n", s
, ret
));
2080 BOOL
is_myname_or_ipaddr(const char *s
)
2082 fstring name
, dnsname
;
2088 /* santize the string from '\\name' */
2092 servername
= strrchr_m( name
, '\\' );
2098 /* optimize for the common case */
2100 if (strequal(servername
, global_myname()))
2103 /* check for an alias */
2105 if (is_myname(servername
))
2108 /* check for loopback */
2110 if (strequal(servername
, "127.0.0.1"))
2113 if (strequal(servername
, "localhost"))
2116 /* maybe it's my dns name */
2118 if ( get_mydnsfullname( dnsname
) )
2119 if ( strequal( servername
, dnsname
) )
2122 /* handle possible CNAME records */
2124 if ( !is_ipaddress( servername
) ) {
2125 /* use DNS to resolve the name, but only the first address */
2128 if (((hp
= sys_gethostbyname(name
)) != NULL
) && (hp
->h_addr
!= NULL
)) {
2129 struct in_addr return_ip
;
2130 putip( (char*)&return_ip
, (char*)hp
->h_addr
);
2131 fstrcpy( name
, inet_ntoa( return_ip
) );
2136 /* maybe its an IP address? */
2137 if (is_ipaddress(servername
)) {
2138 struct iface_struct nics
[MAX_INTERFACES
];
2142 ip
= interpret_addr(servername
);
2143 if ((ip
==0) || (ip
==0xffffffff))
2146 n
= get_interfaces(nics
, MAX_INTERFACES
);
2147 for (i
=0; i
<n
; i
++) {
2148 if (ip
== nics
[i
].ip
.s_addr
)
2157 /*******************************************************************
2158 Is the name specified our workgroup/domain.
2159 Returns true if it is equal, false otherwise.
2160 ********************************************************************/
2162 BOOL
is_myworkgroup(const char *s
)
2166 if (strequal(s
, lp_workgroup())) {
2170 DEBUG(8, ("is_myworkgroup(\"%s\") returns %d\n", s
, ret
));
2174 /*******************************************************************
2175 we distinguish between 2K and XP by the "Native Lan Manager" string
2176 WinXP => "Windows 2002 5.1"
2177 WinXP 64bit => "Windows XP 5.2"
2178 Win2k => "Windows 2000 5.0"
2179 NT4 => "Windows NT 4.0"
2180 Win9x => "Windows 4.0"
2181 Windows 2003 doesn't set the native lan manager string but
2182 they do set the domain to "Windows 2003 5.2" (probably a bug).
2183 ********************************************************************/
2185 void ra_lanman_string( const char *native_lanman
)
2187 if ( strcmp( native_lanman
, "Windows 2002 5.1" ) == 0 )
2188 set_remote_arch( RA_WINXP
);
2189 else if ( strcmp( native_lanman
, "Windows XP 5.2" ) == 0 )
2190 set_remote_arch( RA_WINXP
);
2191 else if ( strcmp( native_lanman
, "Windows Server 2003 5.2" ) == 0 )
2192 set_remote_arch( RA_WIN2K3
);
2195 /*******************************************************************
2196 Set the horrid remote_arch string based on an enum.
2197 ********************************************************************/
2199 void set_remote_arch(enum remote_arch_types type
)
2204 fstrcpy(remote_arch
, "WfWg");
2207 fstrcpy(remote_arch
, "OS2");
2210 fstrcpy(remote_arch
, "Win95");
2213 fstrcpy(remote_arch
, "WinNT");
2216 fstrcpy(remote_arch
, "Win2K");
2219 fstrcpy(remote_arch
, "WinXP");
2222 fstrcpy(remote_arch
, "Win2K3");
2225 fstrcpy(remote_arch
, "Vista");
2228 fstrcpy(remote_arch
,"Samba");
2231 fstrcpy(remote_arch
,"CIFSFS");
2234 ra_type
= RA_UNKNOWN
;
2235 fstrcpy(remote_arch
, "UNKNOWN");
2239 DEBUG(10,("set_remote_arch: Client arch is \'%s\'\n", remote_arch
));
2242 /*******************************************************************
2243 Get the remote_arch type.
2244 ********************************************************************/
2246 enum remote_arch_types
get_remote_arch(void)
2251 void print_asc(int level
, const unsigned char *buf
,int len
)
2255 DEBUG(level
,("%c", isprint(buf
[i
])?buf
[i
]:'.'));
2258 void dump_data(int level
, const char *buf1
,int len
)
2260 const unsigned char *buf
= (const unsigned char *)buf1
;
2264 if (!DEBUGLVL(level
)) return;
2266 DEBUGADD(level
,("[%03X] ",i
));
2268 DEBUGADD(level
,("%02X ",(int)buf
[i
]));
2270 if (i
%8 == 0) DEBUGADD(level
,(" "));
2272 print_asc(level
,&buf
[i
-16],8); DEBUGADD(level
,(" "));
2273 print_asc(level
,&buf
[i
-8],8); DEBUGADD(level
,("\n"));
2274 if (i
<len
) DEBUGADD(level
,("[%03X] ",i
));
2280 DEBUGADD(level
,(" "));
2281 if (n
>8) DEBUGADD(level
,(" "));
2282 while (n
--) DEBUGADD(level
,(" "));
2284 print_asc(level
,&buf
[i
-(i
%16)],n
); DEBUGADD(level
,( " " ));
2286 if (n
>0) print_asc(level
,&buf
[i
-n
],n
);
2287 DEBUGADD(level
,("\n"));
2291 void dump_data_pw(const char *msg
, const uchar
* data
, size_t len
)
2293 #ifdef DEBUG_PASSWORD
2294 DEBUG(11, ("%s", msg
));
2295 if (data
!= NULL
&& len
> 0)
2297 dump_data(11, (const char *)data
, len
);
2302 char *tab_depth(int depth
)
2304 static pstring spaces
;
2305 memset(spaces
, ' ', depth
* 4);
2306 spaces
[depth
* 4] = 0;
2310 /*****************************************************************************
2311 Provide a checksum on a string
2313 Input: s - the null-terminated character string for which the checksum
2316 Output: The checksum value calculated for s.
2317 *****************************************************************************/
2319 int str_checksum(const char *s
)
2327 res
^= (c
<< (i
% 15)) ^ (c
>> (15-(i
%15)));
2334 /*****************************************************************
2335 Zero a memory area then free it. Used to catch bugs faster.
2336 *****************************************************************/
2338 void zero_free(void *p
, size_t size
)
2344 /*****************************************************************
2345 Set our open file limit to a requested max and return the limit.
2346 *****************************************************************/
2348 int set_maxfiles(int requested_max
)
2350 #if (defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE))
2352 int saved_current_limit
;
2354 if(getrlimit(RLIMIT_NOFILE
, &rlp
)) {
2355 DEBUG(0,("set_maxfiles: getrlimit (1) for RLIMIT_NOFILE failed with error %s\n",
2358 return requested_max
;
2362 * Set the fd limit to be real_max_open_files + MAX_OPEN_FUDGEFACTOR to
2363 * account for the extra fd we need
2364 * as well as the log files and standard
2365 * handles etc. Save the limit we want to set in case
2366 * we are running on an OS that doesn't support this limit (AIX)
2367 * which always returns RLIM_INFINITY for rlp.rlim_max.
2370 /* Try raising the hard (max) limit to the requested amount. */
2372 #if defined(RLIM_INFINITY)
2373 if (rlp
.rlim_max
!= RLIM_INFINITY
) {
2374 int orig_max
= rlp
.rlim_max
;
2376 if ( rlp
.rlim_max
< requested_max
)
2377 rlp
.rlim_max
= requested_max
;
2379 /* This failing is not an error - many systems (Linux) don't
2380 support our default request of 10,000 open files. JRA. */
2382 if(setrlimit(RLIMIT_NOFILE
, &rlp
)) {
2383 DEBUG(3,("set_maxfiles: setrlimit for RLIMIT_NOFILE for %d max files failed with error %s\n",
2384 (int)rlp
.rlim_max
, strerror(errno
) ));
2386 /* Set failed - restore original value from get. */
2387 rlp
.rlim_max
= orig_max
;
2392 /* Now try setting the soft (current) limit. */
2394 saved_current_limit
= rlp
.rlim_cur
= MIN(requested_max
,rlp
.rlim_max
);
2396 if(setrlimit(RLIMIT_NOFILE
, &rlp
)) {
2397 DEBUG(0,("set_maxfiles: setrlimit for RLIMIT_NOFILE for %d files failed with error %s\n",
2398 (int)rlp
.rlim_cur
, strerror(errno
) ));
2400 return saved_current_limit
;
2403 if(getrlimit(RLIMIT_NOFILE
, &rlp
)) {
2404 DEBUG(0,("set_maxfiles: getrlimit (2) for RLIMIT_NOFILE failed with error %s\n",
2407 return saved_current_limit
;
2410 #if defined(RLIM_INFINITY)
2411 if(rlp
.rlim_cur
== RLIM_INFINITY
)
2412 return saved_current_limit
;
2415 if((int)rlp
.rlim_cur
> saved_current_limit
)
2416 return saved_current_limit
;
2418 return rlp
.rlim_cur
;
2419 #else /* !defined(HAVE_GETRLIMIT) || !defined(RLIMIT_NOFILE) */
2421 * No way to know - just guess...
2423 return requested_max
;
2427 /*****************************************************************
2428 Possibly replace mkstemp if it is broken.
2429 *****************************************************************/
2431 int smb_mkstemp(char *name_template
)
2433 #if HAVE_SECURE_MKSTEMP
2434 return mkstemp(name_template
);
2436 /* have a reasonable go at emulating it. Hope that
2437 the system mktemp() isn't completly hopeless */
2438 char *p
= mktemp(name_template
);
2441 return open(p
, O_CREAT
|O_EXCL
|O_RDWR
, 0600);
2445 /*****************************************************************
2446 malloc that aborts with smb_panic on fail or zero size.
2447 *****************************************************************/
2449 void *smb_xmalloc_array(size_t size
, unsigned int count
)
2453 smb_panic("smb_xmalloc_array: called with zero size.\n");
2454 if (count
>= MAX_ALLOC_SIZE
/size
) {
2455 smb_panic("smb_xmalloc: alloc size too large.\n");
2457 if ((p
= SMB_MALLOC(size
*count
)) == NULL
) {
2458 DEBUG(0, ("smb_xmalloc_array failed to allocate %lu * %lu bytes\n",
2459 (unsigned long)size
, (unsigned long)count
));
2460 smb_panic("smb_xmalloc_array: malloc fail.\n");
2466 Memdup with smb_panic on fail.
2469 void *smb_xmemdup(const void *p
, size_t size
)
2472 p2
= SMB_XMALLOC_ARRAY(unsigned char,size
);
2473 memcpy(p2
, p
, size
);
2478 strdup that aborts on malloc fail.
2481 char *smb_xstrdup(const char *s
)
2483 #if defined(PARANOID_MALLOC_CHECKER)
2490 #define strdup rep_strdup
2493 char *s1
= strdup(s
);
2494 #if defined(PARANOID_MALLOC_CHECKER)
2498 #define strdup(s) __ERROR_DONT_USE_STRDUP_DIRECTLY
2501 smb_panic("smb_xstrdup: malloc fail\n");
2507 strndup that aborts on malloc fail.
2510 char *smb_xstrndup(const char *s
, size_t n
)
2512 #if defined(PARANOID_MALLOC_CHECKER)
2518 #if (defined(BROKEN_STRNDUP) || !defined(HAVE_STRNDUP))
2520 #define strndup rep_strndup
2523 char *s1
= strndup(s
, n
);
2524 #if defined(PARANOID_MALLOC_CHECKER)
2528 #define strndup(s,n) __ERROR_DONT_USE_STRNDUP_DIRECTLY
2531 smb_panic("smb_xstrndup: malloc fail\n");
2536 vasprintf that aborts on malloc fail
2539 int smb_xvasprintf(char **ptr
, const char *format
, va_list ap
)
2546 n
= vasprintf(ptr
, format
, ap2
);
2547 if (n
== -1 || ! *ptr
)
2548 smb_panic("smb_xvasprintf: out of memory");
2552 /*****************************************************************
2553 Like strdup but for memory.
2554 *****************************************************************/
2556 void *memdup(const void *p
, size_t size
)
2561 p2
= SMB_MALLOC(size
);
2564 memcpy(p2
, p
, size
);
2568 /*****************************************************************
2569 Get local hostname and cache result.
2570 *****************************************************************/
2572 char *myhostname(void)
2580 /*****************************************************************
2581 A useful function for returning a path in the Samba lock directory.
2582 *****************************************************************/
2584 char *lock_path(const char *name
)
2586 static pstring fname
;
2588 pstrcpy(fname
,lp_lockdir());
2589 trim_char(fname
,'\0','/');
2591 if (!directory_exist(fname
,NULL
))
2595 pstrcat(fname
,name
);
2600 /*****************************************************************
2601 A useful function for returning a path in the Samba pid directory.
2602 *****************************************************************/
2604 char *pid_path(const char *name
)
2606 static pstring fname
;
2608 pstrcpy(fname
,lp_piddir());
2609 trim_char(fname
,'\0','/');
2611 if (!directory_exist(fname
,NULL
))
2615 pstrcat(fname
,name
);
2621 * @brief Returns an absolute path to a file in the Samba lib directory.
2623 * @param name File to find, relative to LIBDIR.
2625 * @retval Pointer to a static #pstring containing the full path.
2628 char *lib_path(const char *name
)
2630 static pstring fname
;
2631 fstr_sprintf(fname
, "%s/%s", dyn_LIBDIR
, name
);
2636 * @brief Returns the platform specific shared library extension.
2638 * @retval Pointer to a static #fstring containing the extension.
2641 const char *shlib_ext(void)
2643 return dyn_SHLIBEXT
;
2646 /*******************************************************************
2647 Given a filename - get its directory name
2648 NB: Returned in static storage. Caveats:
2649 o Not safe in thread environment.
2650 o Caller must not free.
2651 o If caller wishes to preserve, they should copy.
2652 ********************************************************************/
2654 char *parent_dirname(const char *path
)
2656 static pstring dirpath
;
2662 pstrcpy(dirpath
, path
);
2663 p
= strrchr_m(dirpath
, '/'); /* Find final '/', if any */
2665 pstrcpy(dirpath
, "."); /* No final "/", so dir is "." */
2668 ++p
; /* For root "/", leave "/" in place */
2674 BOOL
parent_dirname_talloc(TALLOC_CTX
*mem_ctx
, const char *dir
,
2675 char **parent
, const char **name
)
2680 p
= strrchr_m(dir
, '/'); /* Find final '/', if any */
2683 if (!(*parent
= talloc_strdup(mem_ctx
, "."))) {
2694 if (!(*parent
= TALLOC_ARRAY(mem_ctx
, char, len
+1))) {
2697 memcpy(*parent
, dir
, len
);
2698 (*parent
)[len
] = '\0';
2706 /*******************************************************************
2707 Determine if a pattern contains any Microsoft wildcard characters.
2708 *******************************************************************/
2710 BOOL
ms_has_wild(const char *s
)
2714 if (lp_posix_pathnames()) {
2715 /* With posix pathnames no characters are wild. */
2719 while ((c
= *s
++)) {
2732 BOOL
ms_has_wild_w(const smb_ucs2_t
*s
)
2735 if (!s
) return False
;
2736 while ((c
= *s
++)) {
2738 case UCS2_CHAR('*'):
2739 case UCS2_CHAR('?'):
2740 case UCS2_CHAR('<'):
2741 case UCS2_CHAR('>'):
2742 case UCS2_CHAR('"'):
2749 /*******************************************************************
2750 A wrapper that handles case sensitivity and the special handling
2752 *******************************************************************/
2754 BOOL
mask_match(const char *string
, const char *pattern
, BOOL is_case_sensitive
)
2756 if (strcmp(string
,"..") == 0)
2758 if (strcmp(pattern
,".") == 0)
2761 return ms_fnmatch(pattern
, string
, Protocol
<= PROTOCOL_LANMAN2
, is_case_sensitive
) == 0;
2764 /*******************************************************************
2765 A wrapper that handles case sensitivity and the special handling
2766 of the ".." name. Varient that is only called by old search code which requires
2767 pattern translation.
2768 *******************************************************************/
2770 BOOL
mask_match_search(const char *string
, const char *pattern
, BOOL is_case_sensitive
)
2772 if (strcmp(string
,"..") == 0)
2774 if (strcmp(pattern
,".") == 0)
2777 return ms_fnmatch(pattern
, string
, True
, is_case_sensitive
) == 0;
2780 /*******************************************************************
2781 A wrapper that handles a list of patters and calls mask_match()
2782 on each. Returns True if any of the patterns match.
2783 *******************************************************************/
2785 BOOL
mask_match_list(const char *string
, char **list
, int listLen
, BOOL is_case_sensitive
)
2787 while (listLen
-- > 0) {
2788 if (mask_match(string
, *list
++, is_case_sensitive
))
2794 /*********************************************************
2795 Recursive routine that is called by unix_wild_match.
2796 *********************************************************/
2798 static BOOL
unix_do_match(const char *regexp
, const char *str
)
2802 for( p
= regexp
; *p
&& *str
; ) {
2813 * Look for a character matching
2814 * the one after the '*'.
2818 return True
; /* Automatic match */
2821 while(*str
&& (*p
!= *str
))
2825 * Patch from weidel@multichart.de. In the case of the regexp
2826 * '*XX*' we want to ensure there are at least 2 'X' characters
2827 * in the string after the '*' for a match to be made.
2834 * Eat all the characters that match, but count how many there were.
2837 while(*str
&& (*p
== *str
)) {
2843 * Now check that if the regexp had n identical characters that
2844 * matchcount had at least that many matches.
2847 while ( *(p
+1) && (*(p
+1) == *p
)) {
2852 if ( matchcount
<= 0 )
2856 str
--; /* We've eaten the match char after the '*' */
2858 if(unix_do_match(p
, str
))
2880 if (!*p
&& str
[0] == '.' && str
[1] == 0)
2883 if (!*str
&& *p
== '?') {
2889 if(!*str
&& (*p
== '*' && p
[1] == '\0'))
2895 /*******************************************************************
2896 Simple case insensitive interface to a UNIX wildcard matcher.
2897 Returns True if match, False if not.
2898 *******************************************************************/
2900 BOOL
unix_wild_match(const char *pattern
, const char *string
)
2905 pstrcpy(p2
, pattern
);
2906 pstrcpy(s2
, string
);
2910 /* Remove any *? and ** from the pattern as they are meaningless */
2911 for(p
= p2
; *p
; p
++)
2912 while( *p
== '*' && (p
[1] == '?' ||p
[1] == '*'))
2913 pstrcpy( &p
[1], &p
[2]);
2915 if (strequal(p2
,"*"))
2918 return unix_do_match(p2
, s2
);
2921 /**********************************************************************
2922 Converts a name to a fully qualified domain name.
2923 Returns True if lookup succeeded, False if not (then fqdn is set to name)
2924 ***********************************************************************/
2926 BOOL
name_to_fqdn(fstring fqdn
, const char *name
)
2928 struct hostent
*hp
= sys_gethostbyname(name
);
2930 if ( hp
&& hp
->h_name
&& *hp
->h_name
) {
2933 /* find out if the fqdn is returned as an alias
2934 * to cope with /etc/hosts files where the first
2935 * name is not the fqdn but the short name */
2936 if (hp
->h_aliases
&& (! strchr_m(hp
->h_name
, '.'))) {
2938 for (i
= 0; hp
->h_aliases
[i
]; i
++) {
2939 if (strchr_m(hp
->h_aliases
[i
], '.')) {
2940 full
= hp
->h_aliases
[i
];
2945 if (full
&& (StrCaseCmp(full
, "localhost.localdomain") == 0)) {
2946 DEBUG(1, ("WARNING: your /etc/hosts file may be broken!\n"));
2947 DEBUGADD(1, (" Specifing the machine hostname for address 127.0.0.1 may lead\n"));
2948 DEBUGADD(1, (" to Kerberos authentication problems as localhost.localdomain\n"));
2949 DEBUGADD(1, (" may end up being used instead of the real machine FQDN.\n"));
2957 DEBUG(10,("name_to_fqdn: lookup for %s -> %s.\n", name
, full
));
2958 fstrcpy(fqdn
, full
);
2961 DEBUG(10,("name_to_fqdn: lookup for %s failed.\n", name
));
2962 fstrcpy(fqdn
, name
);
2967 /**********************************************************************
2968 Extension to talloc_get_type: Abort on type mismatch
2969 ***********************************************************************/
2971 void *talloc_check_name_abort(const void *ptr
, const char *name
)
2975 result
= talloc_check_name(ptr
, name
);
2979 DEBUG(0, ("Talloc type mismatch, expected %s, got %s\n",
2980 name
, talloc_get_name(ptr
)));
2981 smb_panic("aborting");
2982 /* Keep the compiler happy */
2989 /*******************************************************************
2990 This routine is a trick to immediately catch errors when debugging
2991 with insure. A xterm with a gdb is popped up when insure catches
2992 a error. It is Linux specific.
2993 ********************************************************************/
2995 int _Insure_trap_error(int a1
, int a2
, int a3
, int a4
, int a5
, int a6
)
3000 /* you can get /usr/bin/backtrace from
3001 http://samba.org/ftp/unpacked/junkcode/backtrace */
3002 pstring cmd
= "/usr/bin/backtrace %d";
3004 slprintf(pidstr
, sizeof(pidstr
)-1, "%d", sys_getpid());
3005 pstring_sub(cmd
, "%d", pidstr
);
3009 h
= dlopen("/usr/local/parasoft/insure++lite/lib.linux2/libinsure.so", RTLD_LAZY
);
3010 fn
= dlsym(h
, "_Insure_trap_error");
3012 if (!h
|| h
== _Insure_trap_error
) {
3013 h
= dlopen("/usr/local/parasoft/lib.linux2/libinsure.so", RTLD_LAZY
);
3014 fn
= dlsym(h
, "_Insure_trap_error");
3018 ret
= fn(a1
, a2
, a3
, a4
, a5
, a6
);
3026 uint32
map_share_mode_to_deny_mode(uint32 share_access
, uint32 private_options
)
3028 switch (share_access
& ~FILE_SHARE_DELETE
) {
3029 case FILE_SHARE_NONE
:
3031 case FILE_SHARE_READ
:
3033 case FILE_SHARE_WRITE
:
3035 case FILE_SHARE_READ
|FILE_SHARE_WRITE
:
3038 if (private_options
& NTCREATEX_OPTIONS_PRIVATE_DENY_DOS
) {
3040 } else if (private_options
& NTCREATEX_OPTIONS_PRIVATE_DENY_FCB
) {
3047 pid_t
procid_to_pid(const struct process_id
*proc
)
3052 struct process_id
pid_to_procid(pid_t pid
)
3054 struct process_id result
;
3059 struct process_id
procid_self(void)
3061 return pid_to_procid(sys_getpid());
3064 struct server_id
server_id_self(void)
3066 struct server_id id
;
3067 id
.id
= procid_self();
3071 BOOL
procid_equal(const struct process_id
*p1
, const struct process_id
*p2
)
3073 return (p1
->pid
== p2
->pid
);
3076 BOOL
cluster_id_equal(const struct server_id
*id1
,
3077 const struct server_id
*id2
)
3079 return procid_equal(&id1
->id
, &id2
->id
);
3082 BOOL
procid_is_me(const struct process_id
*pid
)
3084 return (pid
->pid
== sys_getpid());
3087 struct process_id
interpret_pid(const char *pid_string
)
3089 return pid_to_procid(atoi(pid_string
));
3092 char *procid_str_static(const struct process_id
*pid
)
3095 fstr_sprintf(str
, "%d", pid
->pid
);
3099 char *procid_str(TALLOC_CTX
*mem_ctx
, const struct process_id
*pid
)
3101 return talloc_strdup(mem_ctx
, procid_str_static(pid
));
3104 BOOL
procid_valid(const struct process_id
*pid
)
3106 return (pid
->pid
!= -1);
3109 BOOL
procid_is_local(const struct process_id
*pid
)
3114 int this_is_smp(void)
3116 #if defined(HAVE_SYSCONF)
3118 #if defined(SYSCONF_SC_NPROC_ONLN)
3119 return (sysconf(_SC_NPROC_ONLN
) > 1) ? 1 : 0;
3120 #elif defined(SYSCONF_SC_NPROCESSORS_ONLN)
3121 return (sysconf(_SC_NPROCESSORS_ONLN
) > 1) ? 1 : 0;
3131 /****************************************************************
3132 Check if an offset into a buffer is safe.
3133 If this returns True it's safe to indirect into the byte at
3135 ****************************************************************/
3137 BOOL
is_offset_safe(const char *buf_base
, size_t buf_len
, char *ptr
, size_t off
)
3139 const char *end_base
= buf_base
+ buf_len
;
3140 char *end_ptr
= ptr
+ off
;
3142 if (!buf_base
|| !ptr
) {
3146 if (end_base
< buf_base
|| end_ptr
< ptr
) {
3147 return False
; /* wrap. */
3150 if (end_ptr
< end_base
) {
3156 /****************************************************************
3157 Return a safe pointer into a buffer, or NULL.
3158 ****************************************************************/
3160 char *get_safe_ptr(const char *buf_base
, size_t buf_len
, char *ptr
, size_t off
)
3162 return is_offset_safe(buf_base
, buf_len
, ptr
, off
) ?
3166 /****************************************************************
3167 Return a safe pointer into a string within a buffer, or NULL.
3168 ****************************************************************/
3170 char *get_safe_str_ptr(const char *buf_base
, size_t buf_len
, char *ptr
, size_t off
)
3172 if (!is_offset_safe(buf_base
, buf_len
, ptr
, off
)) {
3175 /* Check if a valid string exists at this offset. */
3176 if (skip_string(buf_base
,buf_len
, ptr
+ off
) == NULL
) {
3182 /****************************************************************
3183 Return an SVAL at a pointer, or failval if beyond the end.
3184 ****************************************************************/
3186 int get_safe_SVAL(const char *buf_base
, size_t buf_len
, char *ptr
, size_t off
, int failval
)
3189 * Note we use off+1 here, not off+2 as SVAL accesses ptr[0] and ptr[1],
3192 if (!is_offset_safe(buf_base
, buf_len
, ptr
, off
+1)) {
3195 return SVAL(ptr
,off
);
3198 /****************************************************************
3199 Return an IVAL at a pointer, or failval if beyond the end.
3200 ****************************************************************/
3202 int get_safe_IVAL(const char *buf_base
, size_t buf_len
, char *ptr
, size_t off
, int failval
)
3205 * Note we use off+3 here, not off+4 as IVAL accesses
3206 * ptr[0] ptr[1] ptr[2] ptr[3] NOT ptr[4].
3208 if (!is_offset_safe(buf_base
, buf_len
, ptr
, off
+3)) {
3211 return IVAL(ptr
,off
);
3214 /****************************************************************
3215 talloc wrapper functions that guarentee a null pointer return
3217 ****************************************************************/
3219 #ifndef MAX_TALLOC_SIZE
3220 #define MAX_TALLOC_SIZE 0x10000000
3224 * talloc and zero memory.
3225 * - returns NULL if size is zero.
3228 void *_talloc_zero_zeronull(const void *ctx
, size_t size
, const char *name
)
3236 p
= talloc_named_const(ctx
, size
, name
);
3239 memset(p
, '\0', size
);
3246 * memdup with a talloc.
3247 * - returns NULL if size is zero.
3250 void *_talloc_memdup_zeronull(const void *t
, const void *p
, size_t size
, const char *name
)
3258 newp
= talloc_named_const(t
, size
, name
);
3260 memcpy(newp
, p
, size
);
3267 * alloc an array, checking for integer overflow in the array size.
3268 * - returns NULL if count or el_size are zero.
3271 void *_talloc_array_zeronull(const void *ctx
, size_t el_size
, unsigned count
, const char *name
)
3273 if (count
>= MAX_TALLOC_SIZE
/el_size
) {
3277 if (el_size
== 0 || count
== 0) {
3281 return talloc_named_const(ctx
, el_size
* count
, name
);
3285 * alloc an zero array, checking for integer overflow in the array size
3286 * - returns NULL if count or el_size are zero.
3289 void *_talloc_zero_array_zeronull(const void *ctx
, size_t el_size
, unsigned count
, const char *name
)
3291 if (count
>= MAX_TALLOC_SIZE
/el_size
) {
3295 if (el_size
== 0 || count
== 0) {
3299 return _talloc_zero(ctx
, el_size
* count
, name
);
3303 * Talloc wrapper that returns NULL if size == 0.
3305 void *talloc_zeronull(const void *context
, size_t size
, const char *name
)
3310 return talloc_named_const(context
, size
, name
);