s4:librpc/rpc: let dcerpc_ship_next_request() use DCERPC_AUTH_PAD_ALIGNMENT define
[Samba.git] / lib / util / util.c
blob35c18963b98bb2c9fff7fb6799f6afa475d88d0e
1 /*
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-2011
7 Copyright (C) Jim McDonough (jmcd@us.ibm.com) 2003.
8 Copyright (C) James J Myers 2003
9 Copyright (C) Volker Lendecke 2010
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>.
25 #include "includes.h"
26 #include "system/network.h"
27 #include "system/filesys.h"
28 #include "system/locale.h"
29 #include "system/shmem.h"
30 #include "system/passwd.h"
32 #undef malloc
33 #undef strcasecmp
34 #undef strncasecmp
35 #undef strdup
36 #undef realloc
37 #undef calloc
39 /**
40 * @file
41 * @brief Misc utility functions
44 /**
45 Find a suitable temporary directory. The result should be copied immediately
46 as it may be overwritten by a subsequent call.
47 **/
48 _PUBLIC_ const char *tmpdir(void)
50 char *p;
51 if ((p = getenv("TMPDIR")))
52 return p;
53 return "/tmp";
57 /**
58 Create a tmp file, open it and immediately unlink it.
59 If dir is NULL uses tmpdir()
60 Returns the file descriptor or -1 on error.
61 **/
62 int create_unlink_tmp(const char *dir)
64 char *fname;
65 int fd;
66 mode_t mask;
68 if (!dir) {
69 dir = tmpdir();
72 fname = talloc_asprintf(talloc_tos(), "%s/listenerlock_XXXXXX", dir);
73 if (fname == NULL) {
74 errno = ENOMEM;
75 return -1;
77 mask = umask(S_IRWXO | S_IRWXG);
78 fd = mkstemp(fname);
79 umask(mask);
80 if (fd == -1) {
81 TALLOC_FREE(fname);
82 return -1;
84 if (unlink(fname) == -1) {
85 int sys_errno = errno;
86 close(fd);
87 TALLOC_FREE(fname);
88 errno = sys_errno;
89 return -1;
91 TALLOC_FREE(fname);
92 return fd;
96 /**
97 Check if a file exists - call vfs_file_exist for samba files.
98 **/
99 _PUBLIC_ bool file_exist(const char *fname)
101 struct stat st;
103 if (stat(fname, &st) != 0) {
104 return false;
107 return ((S_ISREG(st.st_mode)) || (S_ISFIFO(st.st_mode)));
111 Check a files mod time.
114 _PUBLIC_ time_t file_modtime(const char *fname)
116 struct stat st;
118 if (stat(fname,&st) != 0)
119 return(0);
121 return(st.st_mtime);
125 Check file permissions.
128 _PUBLIC_ bool file_check_permissions(const char *fname,
129 uid_t uid,
130 mode_t file_perms,
131 struct stat *pst)
133 int ret;
134 struct stat st;
136 if (pst == NULL) {
137 pst = &st;
140 ZERO_STRUCTP(pst);
142 ret = stat(fname, pst);
143 if (ret != 0) {
144 DEBUG(0, ("stat failed on file '%s': %s\n",
145 fname, strerror(errno)));
146 return false;
149 if (pst->st_uid != uid && !uwrap_enabled()) {
150 DEBUG(0, ("invalid ownership of file '%s': "
151 "owned by uid %u, should be %u\n",
152 fname, (unsigned int)pst->st_uid,
153 (unsigned int)uid));
154 return false;
157 if ((pst->st_mode & 0777) != file_perms) {
158 DEBUG(0, ("invalid permissions on file "
159 "'%s': has 0%o should be 0%o\n", fname,
160 (unsigned int)(pst->st_mode & 0777),
161 (unsigned int)file_perms));
162 return false;
165 return true;
169 Check if a directory exists.
172 _PUBLIC_ bool directory_exist(const char *dname)
174 struct stat st;
175 bool ret;
177 if (stat(dname,&st) != 0) {
178 return false;
181 ret = S_ISDIR(st.st_mode);
182 if(!ret)
183 errno = ENOTDIR;
184 return ret;
188 * Try to create the specified directory if it didn't exist.
190 * @retval true if the directory already existed and has the right permissions
191 * or was successfully created.
193 _PUBLIC_ bool directory_create_or_exist(const char *dname,
194 uid_t uid,
195 mode_t dir_perms)
197 int ret;
198 struct stat st;
200 ret = lstat(dname, &st);
201 if (ret == -1) {
202 mode_t old_umask;
204 if (errno != ENOENT) {
205 DEBUG(0, ("lstat failed on directory %s: %s\n",
206 dname, strerror(errno)));
207 return false;
210 /* Create directory */
211 old_umask = umask(0);
212 ret = mkdir(dname, dir_perms);
213 if (ret == -1 && errno != EEXIST) {
214 DEBUG(0, ("mkdir failed on directory "
215 "%s: %s\n", dname,
216 strerror(errno)));
217 umask(old_umask);
218 return false;
220 umask(old_umask);
222 ret = lstat(dname, &st);
223 if (ret == -1) {
224 DEBUG(0, ("lstat failed on created directory %s: %s\n",
225 dname, strerror(errno)));
226 return false;
230 return true;
234 * @brief Try to create a specified directory if it doesn't exist.
236 * The function creates a directory with the given uid and permissions if it
237 * doesn't exixt. If it exists it makes sure the uid and permissions are
238 * correct and it will fail if they are different.
240 * @param[in] dname The directory to create.
242 * @param[in] uid The uid the directory needs to belong too.
244 * @param[in] dir_perms The expected permissions of the directory.
246 * @return True on success, false on error.
248 _PUBLIC_ bool directory_create_or_exist_strict(const char *dname,
249 uid_t uid,
250 mode_t dir_perms)
252 struct stat st;
253 bool ok;
254 int rc;
256 ok = directory_create_or_exist(dname, uid, dir_perms);
257 if (!ok) {
258 return false;
261 rc = lstat(dname, &st);
262 if (rc == -1) {
263 DEBUG(0, ("lstat failed on created directory %s: %s\n",
264 dname, strerror(errno)));
265 return false;
268 /* Check ownership and permission on existing directory */
269 if (!S_ISDIR(st.st_mode)) {
270 DEBUG(0, ("directory %s isn't a directory\n",
271 dname));
272 return false;
274 if (st.st_uid != uid && !uwrap_enabled()) {
275 DEBUG(0, ("invalid ownership on directory "
276 "%s\n", dname));
277 return false;
279 if ((st.st_mode & 0777) != dir_perms) {
280 DEBUG(0, ("invalid permissions on directory "
281 "'%s': has 0%o should be 0%o\n", dname,
282 (unsigned int)(st.st_mode & 0777), (unsigned int)dir_perms));
283 return false;
286 return true;
291 Sleep for a specified number of milliseconds.
294 _PUBLIC_ void smb_msleep(unsigned int t)
296 #if defined(HAVE_NANOSLEEP)
297 struct timespec ts;
298 int ret;
300 ts.tv_sec = t/1000;
301 ts.tv_nsec = 1000000*(t%1000);
303 do {
304 errno = 0;
305 ret = nanosleep(&ts, &ts);
306 } while (ret < 0 && errno == EINTR && (ts.tv_sec > 0 || ts.tv_nsec > 0));
307 #else
308 unsigned int tdiff=0;
309 struct timeval tval,t1,t2;
310 fd_set fds;
312 GetTimeOfDay(&t1);
313 t2 = t1;
315 while (tdiff < t) {
316 tval.tv_sec = (t-tdiff)/1000;
317 tval.tv_usec = 1000*((t-tdiff)%1000);
319 /* Never wait for more than 1 sec. */
320 if (tval.tv_sec > 1) {
321 tval.tv_sec = 1;
322 tval.tv_usec = 0;
325 FD_ZERO(&fds);
326 errno = 0;
327 select(0,&fds,NULL,NULL,&tval);
329 GetTimeOfDay(&t2);
330 if (t2.tv_sec < t1.tv_sec) {
331 /* Someone adjusted time... */
332 t1 = t2;
335 tdiff = usec_time_diff(&t2,&t1)/1000;
337 #endif
341 Get my own name, return in talloc'ed storage.
344 _PUBLIC_ char *get_myname(TALLOC_CTX *ctx)
346 char *p;
347 char hostname[HOST_NAME_MAX];
349 /* get my host name */
350 if (gethostname(hostname, sizeof(hostname)) == -1) {
351 DEBUG(0,("gethostname failed\n"));
352 return NULL;
355 /* Ensure null termination. */
356 hostname[sizeof(hostname)-1] = '\0';
358 /* split off any parts after an initial . */
359 p = strchr_m(hostname, '.');
360 if (p) {
361 *p = 0;
364 return talloc_strdup(ctx, hostname);
368 Check if a process exists. Does this work on all unixes?
371 _PUBLIC_ bool process_exists_by_pid(pid_t pid)
373 /* Doing kill with a non-positive pid causes messages to be
374 * sent to places we don't want. */
375 if (pid <= 0) {
376 return false;
378 return(kill(pid,0) == 0 || errno != ESRCH);
382 Simple routine to do POSIX file locking. Cruft in NFS and 64->32 bit mapping
383 is dealt with in posix.c
386 _PUBLIC_ bool fcntl_lock(int fd, int op, off_t offset, off_t count, int type)
388 struct flock lock;
389 int ret;
391 DEBUG(8,("fcntl_lock %d %d %.0f %.0f %d\n",fd,op,(double)offset,(double)count,type));
393 lock.l_type = type;
394 lock.l_whence = SEEK_SET;
395 lock.l_start = offset;
396 lock.l_len = count;
397 lock.l_pid = 0;
399 ret = fcntl(fd,op,&lock);
401 if (ret == -1 && errno != 0)
402 DEBUG(3,("fcntl_lock: fcntl lock gave errno %d (%s)\n",errno,strerror(errno)));
404 /* a lock query */
405 if (op == F_GETLK) {
406 if ((ret != -1) &&
407 (lock.l_type != F_UNLCK) &&
408 (lock.l_pid != 0) &&
409 (lock.l_pid != getpid())) {
410 DEBUG(3,("fcntl_lock: fd %d is locked by pid %d\n",fd,(int)lock.l_pid));
411 return true;
414 /* it must be not locked or locked by me */
415 return false;
418 /* a lock set or unset */
419 if (ret == -1) {
420 DEBUG(3,("fcntl_lock: lock failed at offset %.0f count %.0f op %d type %d (%s)\n",
421 (double)offset,(double)count,op,type,strerror(errno)));
422 return false;
425 /* everything went OK */
426 DEBUG(8,("fcntl_lock: Lock call successful\n"));
428 return true;
431 struct debug_channel_level {
432 int channel;
433 int level;
436 static void debugadd_channel_cb(const char *buf, void *private_data)
438 struct debug_channel_level *dcl =
439 (struct debug_channel_level *)private_data;
441 DEBUGADDC(dcl->channel, dcl->level,("%s", buf));
444 static void debugadd_cb(const char *buf, void *private_data)
446 int *plevel = (int *)private_data;
447 DEBUGADD(*plevel, ("%s", buf));
450 void print_asc_cb(const uint8_t *buf, int len,
451 void (*cb)(const char *buf, void *private_data),
452 void *private_data)
454 int i;
455 char s[2];
456 s[1] = 0;
458 for (i=0; i<len; i++) {
459 s[0] = isprint(buf[i]) ? buf[i] : '.';
460 cb(s, private_data);
464 void print_asc(int level, const uint8_t *buf,int len)
466 print_asc_cb(buf, len, debugadd_cb, &level);
470 * Write dump of binary data to a callback
472 void dump_data_cb(const uint8_t *buf, int len,
473 bool omit_zero_bytes,
474 void (*cb)(const char *buf, void *private_data),
475 void *private_data)
477 int i=0;
478 static const uint8_t empty[16] = { 0, };
479 bool skipped = false;
480 char tmp[16];
482 if (len<=0) return;
484 for (i=0;i<len;) {
486 if (i%16 == 0) {
487 if ((omit_zero_bytes == true) &&
488 (i > 0) &&
489 (len > i+16) &&
490 (memcmp(&buf[i], &empty, 16) == 0))
492 i +=16;
493 continue;
496 if (i<len) {
497 snprintf(tmp, sizeof(tmp), "[%04X] ", i);
498 cb(tmp, private_data);
502 snprintf(tmp, sizeof(tmp), "%02X ", (int)buf[i]);
503 cb(tmp, private_data);
504 i++;
505 if (i%8 == 0) {
506 cb(" ", private_data);
508 if (i%16 == 0) {
510 print_asc_cb(&buf[i-16], 8, cb, private_data);
511 cb(" ", private_data);
512 print_asc_cb(&buf[i-8], 8, cb, private_data);
513 cb("\n", private_data);
515 if ((omit_zero_bytes == true) &&
516 (len > i+16) &&
517 (memcmp(&buf[i], &empty, 16) == 0)) {
518 if (!skipped) {
519 cb("skipping zero buffer bytes\n",
520 private_data);
521 skipped = true;
527 if (i%16) {
528 int n;
529 n = 16 - (i%16);
530 cb(" ", private_data);
531 if (n>8) {
532 cb(" ", private_data);
534 while (n--) {
535 cb(" ", private_data);
537 n = MIN(8,i%16);
538 print_asc_cb(&buf[i-(i%16)], n, cb, private_data);
539 cb(" ", private_data);
540 n = (i%16) - n;
541 if (n>0) {
542 print_asc_cb(&buf[i-n], n, cb, private_data);
544 cb("\n", private_data);
550 * Write dump of binary data to the log file.
552 * The data is only written if the log level is at least level.
554 _PUBLIC_ void dump_data(int level, const uint8_t *buf, int len)
556 if (!DEBUGLVL(level)) {
557 return;
559 dump_data_cb(buf, len, false, debugadd_cb, &level);
563 * Write dump of binary data to the log file.
565 * The data is only written if the log level is at least level for
566 * debug class dbgc_class.
568 _PUBLIC_ void dump_data_dbgc(int dbgc_class, int level, const uint8_t *buf, int len)
570 struct debug_channel_level dcl = { dbgc_class, level };
572 if (!DEBUGLVLC(dbgc_class, level)) {
573 return;
575 dump_data_cb(buf, len, false, debugadd_channel_cb, &dcl);
579 * Write dump of binary data to the log file.
581 * The data is only written if the log level is at least level.
582 * 16 zero bytes in a row are omitted
584 _PUBLIC_ void dump_data_skip_zeros(int level, const uint8_t *buf, int len)
586 if (!DEBUGLVL(level)) {
587 return;
589 dump_data_cb(buf, len, true, debugadd_cb, &level);
592 static void fprintf_cb(const char *buf, void *private_data)
594 FILE *f = (FILE *)private_data;
595 fprintf(f, "%s", buf);
598 void dump_data_file(const uint8_t *buf, int len, bool omit_zero_bytes,
599 FILE *f)
601 dump_data_cb(buf, len, omit_zero_bytes, fprintf_cb, f);
605 malloc that aborts with smb_panic on fail or zero size.
608 _PUBLIC_ void *smb_xmalloc(size_t size)
610 void *p;
611 if (size == 0)
612 smb_panic("smb_xmalloc: called with zero size.\n");
613 if ((p = malloc(size)) == NULL)
614 smb_panic("smb_xmalloc: malloc fail.\n");
615 return p;
619 Memdup with smb_panic on fail.
622 _PUBLIC_ void *smb_xmemdup(const void *p, size_t size)
624 void *p2;
625 p2 = smb_xmalloc(size);
626 memcpy(p2, p, size);
627 return p2;
631 strdup that aborts on malloc fail.
634 char *smb_xstrdup(const char *s)
636 #if defined(PARANOID_MALLOC_CHECKER)
637 #ifdef strdup
638 #undef strdup
639 #endif
640 #endif
642 #ifndef HAVE_STRDUP
643 #define strdup rep_strdup
644 #endif
646 char *s1 = strdup(s);
647 #if defined(PARANOID_MALLOC_CHECKER)
648 #ifdef strdup
649 #undef strdup
650 #endif
651 #define strdup(s) __ERROR_DONT_USE_STRDUP_DIRECTLY
652 #endif
653 if (!s1) {
654 smb_panic("smb_xstrdup: malloc failed");
656 return s1;
661 strndup that aborts on malloc fail.
664 char *smb_xstrndup(const char *s, size_t n)
666 #if defined(PARANOID_MALLOC_CHECKER)
667 #ifdef strndup
668 #undef strndup
669 #endif
670 #endif
672 #if (defined(BROKEN_STRNDUP) || !defined(HAVE_STRNDUP))
673 #undef HAVE_STRNDUP
674 #define strndup rep_strndup
675 #endif
677 char *s1 = strndup(s, n);
678 #if defined(PARANOID_MALLOC_CHECKER)
679 #ifdef strndup
680 #undef strndup
681 #endif
682 #define strndup(s,n) __ERROR_DONT_USE_STRNDUP_DIRECTLY
683 #endif
684 if (!s1) {
685 smb_panic("smb_xstrndup: malloc failed");
687 return s1;
693 Like strdup but for memory.
696 _PUBLIC_ void *smb_memdup(const void *p, size_t size)
698 void *p2;
699 if (size == 0)
700 return NULL;
701 p2 = malloc(size);
702 if (!p2)
703 return NULL;
704 memcpy(p2, p, size);
705 return p2;
709 * Write a password to the log file.
711 * @note Only actually does something if DEBUG_PASSWORD was defined during
712 * compile-time.
714 _PUBLIC_ void dump_data_pw(const char *msg, const uint8_t * data, size_t len)
716 #ifdef DEBUG_PASSWORD
717 DEBUG(11, ("%s", msg));
718 if (data != NULL && len > 0)
720 dump_data(11, data, len);
722 #endif
727 * see if a range of memory is all zero. A NULL pointer is considered
728 * to be all zero
730 _PUBLIC_ bool all_zero(const uint8_t *ptr, size_t size)
732 int i;
733 if (!ptr) return true;
734 for (i=0;i<size;i++) {
735 if (ptr[i]) return false;
737 return true;
741 realloc an array, checking for integer overflow in the array size
743 _PUBLIC_ void *realloc_array(void *ptr, size_t el_size, unsigned count, bool free_on_fail)
745 #define MAX_MALLOC_SIZE 0x7fffffff
746 if (count == 0 ||
747 count >= MAX_MALLOC_SIZE/el_size) {
748 if (free_on_fail)
749 SAFE_FREE(ptr);
750 return NULL;
752 if (!ptr) {
753 return malloc(el_size * count);
755 return realloc(ptr, el_size * count);
758 /****************************************************************************
759 Type-safe malloc.
760 ****************************************************************************/
762 void *malloc_array(size_t el_size, unsigned int count)
764 return realloc_array(NULL, el_size, count, false);
767 /****************************************************************************
768 Type-safe memalign
769 ****************************************************************************/
771 void *memalign_array(size_t el_size, size_t align, unsigned int count)
773 if (count*el_size >= MAX_MALLOC_SIZE) {
774 return NULL;
777 return memalign(align, el_size*count);
780 /****************************************************************************
781 Type-safe calloc.
782 ****************************************************************************/
784 void *calloc_array(size_t size, size_t nmemb)
786 if (nmemb >= MAX_MALLOC_SIZE/size) {
787 return NULL;
789 if (size == 0 || nmemb == 0) {
790 return NULL;
792 return calloc(nmemb, size);
796 Trim the specified elements off the front and back of a string.
798 _PUBLIC_ bool trim_string(char *s, const char *front, const char *back)
800 bool ret = false;
801 size_t front_len;
802 size_t back_len;
803 size_t len;
805 /* Ignore null or empty strings. */
806 if (!s || (s[0] == '\0'))
807 return false;
809 front_len = front? strlen(front) : 0;
810 back_len = back? strlen(back) : 0;
812 len = strlen(s);
814 if (front_len) {
815 while (len && strncmp(s, front, front_len)==0) {
816 /* Must use memmove here as src & dest can
817 * easily overlap. Found by valgrind. JRA. */
818 memmove(s, s+front_len, (len-front_len)+1);
819 len -= front_len;
820 ret=true;
824 if (back_len) {
825 while ((len >= back_len) && strncmp(s+len-back_len,back,back_len)==0) {
826 s[len-back_len]='\0';
827 len -= back_len;
828 ret=true;
831 return ret;
835 Find the number of 'c' chars in a string
837 _PUBLIC_ _PURE_ size_t count_chars(const char *s, char c)
839 size_t count = 0;
841 while (*s) {
842 if (*s == c) count++;
843 s ++;
846 return count;
850 * Routine to get hex characters and turn them into a byte array.
851 * the array can be variable length.
852 * - "0xnn" or "0Xnn" is specially catered for.
853 * - The first non-hex-digit character (apart from possibly leading "0x"
854 * finishes the conversion and skips the rest of the input.
855 * - A single hex-digit character at the end of the string is skipped.
857 * valid examples: "0A5D15"; "0x123456"
859 _PUBLIC_ size_t strhex_to_str(char *p, size_t p_len, const char *strhex, size_t strhex_len)
861 size_t i = 0;
862 size_t num_chars = 0;
863 uint8_t lonybble, hinybble;
864 const char *hexchars = "0123456789ABCDEF";
865 char *p1 = NULL, *p2 = NULL;
867 /* skip leading 0x prefix */
868 if (strncasecmp(strhex, "0x", 2) == 0) {
869 i += 2; /* skip two chars */
872 for (; i+1 < strhex_len && strhex[i] != 0 && strhex[i+1] != 0; i++) {
873 p1 = strchr(hexchars, toupper((unsigned char)strhex[i]));
874 if (p1 == NULL) {
875 break;
878 i++; /* next hex digit */
880 p2 = strchr(hexchars, toupper((unsigned char)strhex[i]));
881 if (p2 == NULL) {
882 break;
885 /* get the two nybbles */
886 hinybble = PTR_DIFF(p1, hexchars);
887 lonybble = PTR_DIFF(p2, hexchars);
889 if (num_chars >= p_len) {
890 break;
893 p[num_chars] = (hinybble << 4) | lonybble;
894 num_chars++;
896 p1 = NULL;
897 p2 = NULL;
899 return num_chars;
902 /**
903 * Parse a hex string and return a data blob.
905 _PUBLIC_ _PURE_ DATA_BLOB strhex_to_data_blob(TALLOC_CTX *mem_ctx, const char *strhex)
907 DATA_BLOB ret_blob = data_blob_talloc(mem_ctx, NULL, strlen(strhex)/2+1);
909 ret_blob.length = strhex_to_str((char *)ret_blob.data, ret_blob.length,
910 strhex,
911 strlen(strhex));
913 return ret_blob;
917 * Print a buf in hex. Assumes dst is at least (srclen*2)+1 large.
919 _PUBLIC_ void hex_encode_buf(char *dst, const uint8_t *src, size_t srclen)
921 size_t i;
922 for (i=0; i<srclen; i++) {
923 snprintf(dst + i*2, 3, "%02X", src[i]);
926 * Ensure 0-termination for 0-length buffers
928 dst[srclen*2] = '\0';
932 * Routine to print a buffer as HEX digits, into an allocated string.
934 _PUBLIC_ void hex_encode(const unsigned char *buff_in, size_t len, char **out_hex_buffer)
936 char *hex_buffer;
938 *out_hex_buffer = malloc_array_p(char, (len*2)+1);
939 hex_buffer = *out_hex_buffer;
940 hex_encode_buf(hex_buffer, buff_in, len);
944 * talloc version of hex_encode()
946 _PUBLIC_ char *hex_encode_talloc(TALLOC_CTX *mem_ctx, const unsigned char *buff_in, size_t len)
948 char *hex_buffer;
950 hex_buffer = talloc_array(mem_ctx, char, (len*2)+1);
951 if (!hex_buffer) {
952 return NULL;
954 hex_encode_buf(hex_buffer, buff_in, len);
955 talloc_set_name_const(hex_buffer, hex_buffer);
956 return hex_buffer;
960 varient of strcmp() that handles NULL ptrs
962 _PUBLIC_ int strcmp_safe(const char *s1, const char *s2)
964 if (s1 == s2) {
965 return 0;
967 if (s1 == NULL || s2 == NULL) {
968 return s1?-1:1;
970 return strcmp(s1, s2);
975 return the number of bytes occupied by a buffer in ASCII format
976 the result includes the null termination
977 limited by 'n' bytes
979 _PUBLIC_ size_t ascii_len_n(const char *src, size_t n)
981 size_t len;
983 len = strnlen(src, n);
984 if (len+1 <= n) {
985 len += 1;
988 return len;
992 Set a boolean variable from the text value stored in the passed string.
993 Returns true in success, false if the passed string does not correctly
994 represent a boolean.
997 _PUBLIC_ bool set_boolean(const char *boolean_string, bool *boolean)
999 if (strwicmp(boolean_string, "yes") == 0 ||
1000 strwicmp(boolean_string, "true") == 0 ||
1001 strwicmp(boolean_string, "on") == 0 ||
1002 strwicmp(boolean_string, "1") == 0) {
1003 *boolean = true;
1004 return true;
1005 } else if (strwicmp(boolean_string, "no") == 0 ||
1006 strwicmp(boolean_string, "false") == 0 ||
1007 strwicmp(boolean_string, "off") == 0 ||
1008 strwicmp(boolean_string, "0") == 0) {
1009 *boolean = false;
1010 return true;
1012 return false;
1016 return the number of bytes occupied by a buffer in CH_UTF16 format
1017 the result includes the null termination
1019 _PUBLIC_ size_t utf16_len(const void *buf)
1021 size_t len;
1023 for (len = 0; SVAL(buf,len); len += 2) ;
1025 return len + 2;
1029 return the number of bytes occupied by a buffer in CH_UTF16 format
1030 the result includes the null termination
1031 limited by 'n' bytes
1033 _PUBLIC_ size_t utf16_len_n(const void *src, size_t n)
1035 size_t len;
1037 for (len = 0; (len+2 < n) && SVAL(src, len); len += 2) ;
1039 if (len+2 <= n) {
1040 len += 2;
1043 return len;
1047 * @file
1048 * @brief String utilities.
1051 static bool next_token_internal_talloc(TALLOC_CTX *ctx,
1052 const char **ptr,
1053 char **pp_buff,
1054 const char *sep,
1055 bool ltrim)
1057 const char *s;
1058 const char *saved_s;
1059 char *pbuf;
1060 bool quoted;
1061 size_t len=1;
1063 *pp_buff = NULL;
1064 if (!ptr) {
1065 return(false);
1068 s = *ptr;
1070 /* default to simple separators */
1071 if (!sep) {
1072 sep = " \t\n\r";
1075 /* find the first non sep char, if left-trimming is requested */
1076 if (ltrim) {
1077 while (*s && strchr_m(sep,*s)) {
1078 s++;
1082 /* nothing left? */
1083 if (!*s) {
1084 return false;
1087 /* When restarting we need to go from here. */
1088 saved_s = s;
1090 /* Work out the length needed. */
1091 for (quoted = false; *s &&
1092 (quoted || !strchr_m(sep,*s)); s++) {
1093 if (*s == '\"') {
1094 quoted = !quoted;
1095 } else {
1096 len++;
1100 /* We started with len = 1 so we have space for the nul. */
1101 *pp_buff = talloc_array(ctx, char, len);
1102 if (!*pp_buff) {
1103 return false;
1106 /* copy over the token */
1107 pbuf = *pp_buff;
1108 s = saved_s;
1109 for (quoted = false; *s &&
1110 (quoted || !strchr_m(sep,*s)); s++) {
1111 if ( *s == '\"' ) {
1112 quoted = !quoted;
1113 } else {
1114 *pbuf++ = *s;
1118 *ptr = (*s) ? s+1 : s;
1119 *pbuf = 0;
1121 return true;
1124 bool next_token_talloc(TALLOC_CTX *ctx,
1125 const char **ptr,
1126 char **pp_buff,
1127 const char *sep)
1129 return next_token_internal_talloc(ctx, ptr, pp_buff, sep, true);
1133 * Get the next token from a string, return false if none found. Handles
1134 * double-quotes. This version does not trim leading separator characters
1135 * before looking for a token.
1138 bool next_token_no_ltrim_talloc(TALLOC_CTX *ctx,
1139 const char **ptr,
1140 char **pp_buff,
1141 const char *sep)
1143 return next_token_internal_talloc(ctx, ptr, pp_buff, sep, false);
1147 * Get the next token from a string, return False if none found.
1148 * Handles double-quotes.
1150 * Based on a routine by GJC@VILLAGE.COM.
1151 * Extensively modified by Andrew.Tridgell@anu.edu.au
1153 _PUBLIC_ bool next_token(const char **ptr,char *buff, const char *sep, size_t bufsize)
1155 const char *s;
1156 bool quoted;
1157 size_t len=1;
1159 if (!ptr)
1160 return false;
1162 s = *ptr;
1164 /* default to simple separators */
1165 if (!sep)
1166 sep = " \t\n\r";
1168 /* find the first non sep char */
1169 while (*s && strchr_m(sep,*s))
1170 s++;
1172 /* nothing left? */
1173 if (!*s)
1174 return false;
1176 /* copy over the token */
1177 for (quoted = false; len < bufsize && *s && (quoted || !strchr_m(sep,*s)); s++) {
1178 if (*s == '\"') {
1179 quoted = !quoted;
1180 } else {
1181 len++;
1182 *buff++ = *s;
1186 *ptr = (*s) ? s+1 : s;
1187 *buff = 0;
1189 return true;
1192 struct anonymous_shared_header {
1193 union {
1194 size_t length;
1195 uint8_t pad[16];
1196 } u;
1199 /* Map a shared memory buffer of at least nelem counters. */
1200 void *anonymous_shared_allocate(size_t orig_bufsz)
1202 void *ptr;
1203 void *buf;
1204 size_t pagesz = getpagesize();
1205 size_t pagecnt;
1206 size_t bufsz = orig_bufsz;
1207 struct anonymous_shared_header *hdr;
1209 bufsz += sizeof(*hdr);
1211 /* round up to full pages */
1212 pagecnt = bufsz / pagesz;
1213 if (bufsz % pagesz) {
1214 pagecnt += 1;
1216 bufsz = pagesz * pagecnt;
1218 if (orig_bufsz >= bufsz) {
1219 /* integer wrap */
1220 errno = ENOMEM;
1221 return NULL;
1224 #ifdef MAP_ANON
1225 /* BSD */
1226 buf = mmap(NULL, bufsz, PROT_READ|PROT_WRITE, MAP_ANON|MAP_SHARED,
1227 -1 /* fd */, 0 /* offset */);
1228 #else
1230 int saved_errno;
1231 int fd;
1233 fd = open("/dev/zero", O_RDWR);
1234 if (fd == -1) {
1235 return NULL;
1238 buf = mmap(NULL, bufsz, PROT_READ|PROT_WRITE, MAP_FILE|MAP_SHARED,
1239 fd, 0 /* offset */);
1240 saved_errno = errno;
1241 close(fd);
1242 errno = saved_errno;
1244 #endif
1246 if (buf == MAP_FAILED) {
1247 return NULL;
1250 hdr = (struct anonymous_shared_header *)buf;
1251 hdr->u.length = bufsz;
1253 ptr = (void *)(&hdr[1]);
1255 return ptr;
1258 void *anonymous_shared_resize(void *ptr, size_t new_size, bool maymove)
1260 #ifdef HAVE_MREMAP
1261 void *buf;
1262 size_t pagesz = getpagesize();
1263 size_t pagecnt;
1264 size_t bufsz;
1265 struct anonymous_shared_header *hdr;
1266 int flags = 0;
1268 if (ptr == NULL) {
1269 errno = EINVAL;
1270 return NULL;
1273 hdr = (struct anonymous_shared_header *)ptr;
1274 hdr--;
1275 if (hdr->u.length > (new_size + sizeof(*hdr))) {
1276 errno = EINVAL;
1277 return NULL;
1280 bufsz = new_size + sizeof(*hdr);
1282 /* round up to full pages */
1283 pagecnt = bufsz / pagesz;
1284 if (bufsz % pagesz) {
1285 pagecnt += 1;
1287 bufsz = pagesz * pagecnt;
1289 if (new_size >= bufsz) {
1290 /* integer wrap */
1291 errno = ENOSPC;
1292 return NULL;
1295 if (bufsz <= hdr->u.length) {
1296 return ptr;
1299 if (maymove) {
1300 flags = MREMAP_MAYMOVE;
1303 buf = mremap(hdr, hdr->u.length, bufsz, flags);
1305 if (buf == MAP_FAILED) {
1306 errno = ENOSPC;
1307 return NULL;
1310 hdr = (struct anonymous_shared_header *)buf;
1311 hdr->u.length = bufsz;
1313 ptr = (void *)(&hdr[1]);
1315 return ptr;
1316 #else
1317 errno = ENOSPC;
1318 return NULL;
1319 #endif
1322 void anonymous_shared_free(void *ptr)
1324 struct anonymous_shared_header *hdr;
1326 if (ptr == NULL) {
1327 return;
1330 hdr = (struct anonymous_shared_header *)ptr;
1332 hdr--;
1334 munmap(hdr, hdr->u.length);
1337 #ifdef DEVELOPER
1338 /* used when you want a debugger started at a particular point in the
1339 code. Mostly useful in code that runs as a child process, where
1340 normal gdb attach is harder to organise.
1342 void samba_start_debugger(void)
1344 char *cmd = NULL;
1345 if (asprintf(&cmd, "xterm -e \"gdb --pid %u\"&", getpid()) == -1) {
1346 return;
1348 if (system(cmd) == -1) {
1349 free(cmd);
1350 return;
1352 free(cmd);
1353 sleep(2);
1355 #endif