Use shared util.c.
[samba.git] / lib / util / util.c
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
7    Copyright (C) Jim McDonough (jmcd@us.ibm.com)  2003.
8    Copyright (C) James J Myers 2003
9    
10    This program is free software; you can redistribute it and/or modify
11    it under the terms of the GNU General Public License as published by
12    the Free Software Foundation; either version 3 of the License, or
13    (at your option) any later version.
14    
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.
19    
20    You should have received a copy of the GNU General Public License
21    along with this program.  If not, see <http://www.gnu.org/licenses/>.
22 */
23
24 #include "includes.h"
25 #include "system/network.h"
26 #include "system/filesys.h"
27 #include "system/locale.h"
28 #undef malloc
29 #undef strcasecmp
30 #undef strdup
31 #undef realloc
32
33 /**
34  * @file
35  * @brief Misc utility functions
36  */
37
38 /**
39  Find a suitable temporary directory. The result should be copied immediately
40  as it may be overwritten by a subsequent call.
41 **/
42 _PUBLIC_ const char *tmpdir(void)
43 {
44         char *p;
45         if ((p = getenv("TMPDIR")))
46                 return p;
47         return "/tmp";
48 }
49
50
51 /**
52  Check if a file exists - call vfs_file_exist for samba files.
53 **/
54 _PUBLIC_ bool file_exist(const char *fname)
55 {
56         struct stat st;
57
58         if (stat(fname, &st) != 0) {
59                 return false;
60         }
61
62         return ((S_ISREG(st.st_mode)) || (S_ISFIFO(st.st_mode)));
63 }
64
65 /**
66  Check a files mod time.
67 **/
68
69 _PUBLIC_ time_t file_modtime(const char *fname)
70 {
71         struct stat st;
72   
73         if (stat(fname,&st) != 0) 
74                 return(0);
75
76         return(st.st_mtime);
77 }
78
79 /**
80  Check if a directory exists.
81 **/
82
83 _PUBLIC_ bool directory_exist(const char *dname)
84 {
85         struct stat st;
86         bool ret;
87
88         if (stat(dname,&st) != 0) {
89                 return false;
90         }
91
92         ret = S_ISDIR(st.st_mode);
93         if(!ret)
94                 errno = ENOTDIR;
95         return ret;
96 }
97
98 /**
99  * Try to create the specified directory if it didn't exist.
100  *
101  * @retval true if the directory already existed and has the right permissions 
102  * or was successfully created.
103  */
104 _PUBLIC_ bool directory_create_or_exist(const char *dname, uid_t uid, 
105                                mode_t dir_perms)
106 {
107         mode_t old_umask;
108         struct stat st;
109       
110         old_umask = umask(0);
111         if (lstat(dname, &st) == -1) {
112                 if (errno == ENOENT) {
113                         /* Create directory */
114                         if (mkdir(dname, dir_perms) == -1) {
115                                 DEBUG(0, ("error creating directory "
116                                           "%s: %s\n", dname, 
117                                           strerror(errno)));
118                                 umask(old_umask);
119                                 return false;
120                         }
121                 } else {
122                         DEBUG(0, ("lstat failed on directory %s: %s\n",
123                                   dname, strerror(errno)));
124                         umask(old_umask);
125                         return false;
126                 }
127         } else {
128                 /* Check ownership and permission on existing directory */
129                 if (!S_ISDIR(st.st_mode)) {
130                         DEBUG(0, ("directory %s isn't a directory\n",
131                                 dname));
132                         umask(old_umask);
133                         return false;
134                 }
135                 if ((st.st_uid != uid) || 
136                     ((st.st_mode & 0777) != dir_perms)) {
137                         DEBUG(0, ("invalid permissions on directory "
138                                   "%s\n", dname));
139                         umask(old_umask);
140                         return false;
141                 }
142         }
143         return true;
144 }       
145
146
147 /**
148  Set a fd into blocking/nonblocking mode. Uses POSIX O_NONBLOCK if available,
149  else
150   if SYSV use O_NDELAY
151   if BSD use FNDELAY
152 **/
153
154 _PUBLIC_ int set_blocking(int fd, bool set)
155 {
156         int val;
157 #ifdef O_NONBLOCK
158 #define FLAG_TO_SET O_NONBLOCK
159 #else
160 #ifdef SYSV
161 #define FLAG_TO_SET O_NDELAY
162 #else /* BSD */
163 #define FLAG_TO_SET FNDELAY
164 #endif
165 #endif
166
167         if((val = fcntl(fd, F_GETFL, 0)) == -1)
168                 return -1;
169         if(set) /* Turn blocking on - ie. clear nonblock flag */
170                 val &= ~FLAG_TO_SET;
171         else
172                 val |= FLAG_TO_SET;
173         return fcntl( fd, F_SETFL, val);
174 #undef FLAG_TO_SET
175 }
176
177
178 /**
179  Sleep for a specified number of milliseconds.
180 **/
181
182 _PUBLIC_ void msleep(unsigned int t)
183 {
184         struct timeval tval;  
185
186         tval.tv_sec = t/1000;
187         tval.tv_usec = 1000*(t%1000);
188         /* this should be the real select - do NOT replace
189            with sys_select() */
190         select(0,NULL,NULL,NULL,&tval);
191 }
192
193 /**
194  Get my own name, return in malloc'ed storage.
195 **/
196
197 _PUBLIC_ char *get_myname(void)
198 {
199         char *hostname;
200         char *p;
201
202         hostname = (char *)malloc(MAXHOSTNAMELEN+1);
203         *hostname = 0;
204
205         /* get my host name */
206         if (gethostname(hostname, MAXHOSTNAMELEN+1) == -1) {
207                 DEBUG(0,("gethostname failed\n"));
208                 return NULL;
209         } 
210
211         /* Ensure null termination. */
212         hostname[MAXHOSTNAMELEN] = '\0';
213
214         /* split off any parts after an initial . */
215         p = strchr(hostname, '.');
216
217         if (p != NULL)
218                 *p = 0;
219         
220         return hostname;
221 }
222
223 /**
224  Check if a process exists. Does this work on all unixes?
225 **/
226
227 _PUBLIC_ bool process_exists_by_pid(pid_t pid)
228 {
229         /* Doing kill with a non-positive pid causes messages to be
230          * sent to places we don't want. */
231         SMB_ASSERT(pid > 0);
232         return(kill(pid,0) == 0 || errno != ESRCH);
233 }
234
235 /**
236  Simple routine to do POSIX file locking. Cruft in NFS and 64->32 bit mapping
237  is dealt with in posix.c
238 **/
239
240 _PUBLIC_ bool fcntl_lock(int fd, int op, off_t offset, off_t count, int type)
241 {
242         struct flock lock;
243         int ret;
244
245         DEBUG(8,("fcntl_lock %d %d %.0f %.0f %d\n",fd,op,(double)offset,(double)count,type));
246
247         lock.l_type = type;
248         lock.l_whence = SEEK_SET;
249         lock.l_start = offset;
250         lock.l_len = count;
251         lock.l_pid = 0;
252
253         ret = fcntl(fd,op,&lock);
254
255         if (ret == -1 && errno != 0)
256                 DEBUG(3,("fcntl_lock: fcntl lock gave errno %d (%s)\n",errno,strerror(errno)));
257
258         /* a lock query */
259         if (op == F_GETLK) {
260                 if ((ret != -1) &&
261                                 (lock.l_type != F_UNLCK) && 
262                                 (lock.l_pid != 0) && 
263                                 (lock.l_pid != getpid())) {
264                         DEBUG(3,("fcntl_lock: fd %d is locked by pid %d\n",fd,(int)lock.l_pid));
265                         return true;
266                 }
267
268                 /* it must be not locked or locked by me */
269                 return false;
270         }
271
272         /* a lock set or unset */
273         if (ret == -1) {
274                 DEBUG(3,("fcntl_lock: lock failed at offset %.0f count %.0f op %d type %d (%s)\n",
275                         (double)offset,(double)count,op,type,strerror(errno)));
276                 return false;
277         }
278
279         /* everything went OK */
280         DEBUG(8,("fcntl_lock: Lock call successful\n"));
281
282         return true;
283 }
284
285
286 void print_asc(int level, const uint8_t *buf,int len)
287 {
288         int i;
289         for (i=0;i<len;i++)
290                 DEBUGADD(level,("%c", isprint(buf[i])?buf[i]:'.'));
291 }
292
293 /**
294  * Write dump of binary data to the log file.
295  *
296  * The data is only written if the log level is at least level.
297  */
298 static void _dump_data(int level, const uint8_t *buf, int len,
299                        bool omit_zero_bytes)
300 {
301         int i=0;
302         const uint8_t empty[16];
303         bool skipped = false;
304
305         if (len<=0) return;
306
307         if (!DEBUGLVL(level)) return;
308
309         memset(&empty, '\0', 16);
310
311         for (i=0;i<len;) {
312
313                 if (i%16 == 0) {
314                         if ((omit_zero_bytes == true) &&
315                             (i > 0) &&
316                             (len > i+16) &&
317                             (memcmp(&buf[i], &empty, 16) == 0))
318                         {
319                                 i +=16;
320                                 continue;
321                         }
322
323                         if (i<len)  {
324                                 DEBUGADD(level,("[%04X] ",i));
325                         }
326                 }
327
328                 DEBUGADD(level,("%02X ",(int)buf[i]));
329                 i++;
330                 if (i%8 == 0) DEBUGADD(level,("  "));
331                 if (i%16 == 0) {
332
333                         print_asc(level,&buf[i-16],8); DEBUGADD(level,(" "));
334                         print_asc(level,&buf[i-8],8); DEBUGADD(level,("\n"));
335
336                         if ((omit_zero_bytes == true) &&
337                             (len > i+16) &&
338                             (memcmp(&buf[i], &empty, 16) == 0)) {
339                                 if (!skipped) {
340                                         DEBUGADD(level,("skipping zero buffer bytes\n"));
341                                         skipped = true;
342                                 }
343                         }
344                 }
345         }
346
347         if (i%16) {
348                 int n;
349                 n = 16 - (i%16);
350                 DEBUGADD(level,(" "));
351                 if (n>8) DEBUGADD(level,(" "));
352                 while (n--) DEBUGADD(level,("   "));
353                 n = MIN(8,i%16);
354                 print_asc(level,&buf[i-(i%16)],n); DEBUGADD(level,( " " ));
355                 n = (i%16) - n;
356                 if (n>0) print_asc(level,&buf[i-n],n);
357                 DEBUGADD(level,("\n"));
358         }
359
360 }
361
362 /**
363  * Write dump of binary data to the log file.
364  *
365  * The data is only written if the log level is at least level.
366  */
367 _PUBLIC_ void dump_data(int level, const uint8_t *buf, int len)
368 {
369         _dump_data(level, buf, len, false);
370 }
371
372 /**
373  * Write dump of binary data to the log file.
374  *
375  * The data is only written if the log level is at least level.
376  * 16 zero bytes in a row are ommited
377  */
378 _PUBLIC_ void dump_data_skip_zeros(int level, const uint8_t *buf, int len)
379 {
380         _dump_data(level, buf, len, true);
381 }
382
383
384 /**
385  malloc that aborts with smb_panic on fail or zero size.
386 **/
387
388 _PUBLIC_ void *smb_xmalloc(size_t size)
389 {
390         void *p;
391         if (size == 0)
392                 smb_panic("smb_xmalloc: called with zero size.\n");
393         if ((p = malloc(size)) == NULL)
394                 smb_panic("smb_xmalloc: malloc fail.\n");
395         return p;
396 }
397
398 /**
399  Memdup with smb_panic on fail.
400 **/
401
402 _PUBLIC_ void *smb_xmemdup(const void *p, size_t size)
403 {
404         void *p2;
405         p2 = smb_xmalloc(size);
406         memcpy(p2, p, size);
407         return p2;
408 }
409
410 /**
411  strdup that aborts on malloc fail.
412 **/
413
414 char *smb_xstrdup(const char *s)
415 {
416 #if defined(PARANOID_MALLOC_CHECKER)
417 #ifdef strdup
418 #undef strdup
419 #endif
420 #endif
421
422 #ifndef HAVE_STRDUP
423 #define strdup rep_strdup
424 #endif
425
426         char *s1 = strdup(s);
427 #if defined(PARANOID_MALLOC_CHECKER)
428 #ifdef strdup
429 #undef strdup
430 #endif
431 #define strdup(s) __ERROR_DONT_USE_STRDUP_DIRECTLY
432 #endif
433         if (!s1) {
434                 smb_panic("smb_xstrdup: malloc failed");
435         }
436         return s1;
437
438 }
439
440 /**
441  strndup that aborts on malloc fail.
442 **/
443
444 char *smb_xstrndup(const char *s, size_t n)
445 {
446 #if defined(PARANOID_MALLOC_CHECKER)
447 #ifdef strndup
448 #undef strndup
449 #endif
450 #endif
451
452 #if (defined(BROKEN_STRNDUP) || !defined(HAVE_STRNDUP))
453 #undef HAVE_STRNDUP
454 #define strndup rep_strndup
455 #endif
456
457         char *s1 = strndup(s, n);
458 #if defined(PARANOID_MALLOC_CHECKER)
459 #ifdef strndup
460 #undef strndup
461 #endif
462 #define strndup(s,n) __ERROR_DONT_USE_STRNDUP_DIRECTLY
463 #endif
464         if (!s1) {
465                 smb_panic("smb_xstrndup: malloc failed");
466         }
467         return s1;
468 }
469
470
471
472 /**
473  Like strdup but for memory.
474 **/
475
476 _PUBLIC_ void *memdup(const void *p, size_t size)
477 {
478         void *p2;
479         if (size == 0)
480                 return NULL;
481         p2 = malloc(size);
482         if (!p2)
483                 return NULL;
484         memcpy(p2, p, size);
485         return p2;
486 }
487
488 /**
489  * Write a password to the log file.
490  *
491  * @note Only actually does something if DEBUG_PASSWORD was defined during 
492  * compile-time.
493  */
494 _PUBLIC_ void dump_data_pw(const char *msg, const uint8_t * data, size_t len)
495 {
496 #ifdef DEBUG_PASSWORD
497         DEBUG(11, ("%s", msg));
498         if (data != NULL && len > 0)
499         {
500                 dump_data(11, data, len);
501         }
502 #endif
503 }
504
505
506 /**
507  * see if a range of memory is all zero. A NULL pointer is considered
508  * to be all zero 
509  */
510 _PUBLIC_ bool all_zero(const uint8_t *ptr, size_t size)
511 {
512         int i;
513         if (!ptr) return true;
514         for (i=0;i<size;i++) {
515                 if (ptr[i]) return false;
516         }
517         return true;
518 }
519
520 /**
521   realloc an array, checking for integer overflow in the array size
522 */
523 _PUBLIC_ void *realloc_array(void *ptr, size_t el_size, unsigned count, bool free_on_fail)
524 {
525 #define MAX_MALLOC_SIZE 0x7fffffff
526         if (count == 0 ||
527             count >= MAX_MALLOC_SIZE/el_size) {
528                 if (free_on_fail)
529                         SAFE_FREE(ptr);
530                 return NULL;
531         }
532         if (!ptr) {
533                 return malloc(el_size * count);
534         }
535         return realloc(ptr, el_size * count);
536 }
537
538 /****************************************************************************
539  Type-safe malloc.
540 ****************************************************************************/
541
542 void *malloc_array(size_t el_size, unsigned int count)
543 {
544         return realloc_array(NULL, el_size, count, false);
545 }
546
547 _PUBLIC_ void *talloc_check_name_abort(const void *ptr, const char *name)
548 {
549         void *result;
550
551         result = talloc_check_name(ptr, name);
552         if (result != NULL)
553                 return result;
554
555         DEBUG(0, ("Talloc type mismatch, expected %s, got %s\n",
556                   name, talloc_get_name(ptr)));
557         smb_panic("talloc type mismatch");
558         /* Keep the compiler happy */
559         return NULL;
560 }
561