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-2011
   7    Copyright (C) Jim McDonough (jmcd@us.ibm.com)  2003.
   8    Copyright (C) James J Myers 2003
   9    Copyright (C) Volker Lendecke 2010
  10    Copyright (C) Swen Schillig 2019
  11
  12    This program is free software; you can redistribute it and/or modify
  13    it under the terms of the GNU General Public License as published by
  14    the Free Software Foundation; either version 3 of the License, or
  15    (at your option) any later version.
  16
  17    This program is distributed in the hope that it will be useful,
  18    but WITHOUT ANY WARRANTY; without even the implied warranty of
  19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20    GNU General Public License for more details.
  21
  22    You should have received a copy of the GNU General Public License
  23    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  24 */
  25
  26 #include "replace.h"
  27 #include <talloc.h>
  28 #include "system/network.h"
  29 #include "system/filesys.h"
  30 #include "system/locale.h"
  31 #include "system/shmem.h"
  32 #include "system/passwd.h"
  33 #include "system/time.h"
  34 #include "system/wait.h"
  35 #include "debug.h"
  36 #include "samba_util.h"
  37 #include "lib/util/select.h"
  38 #include <libgen.h>
  39 #include <gnutls/gnutls.h>
  40
  41 #ifdef HAVE_SYS_PRCTL_H
  42 #include <sys/prctl.h>
  43 #endif
  44
  45 #undef malloc
  46 #undef strcasecmp
  47 #undef strncasecmp
  48 #undef strdup
  49 #undef realloc
  50 #undef calloc
  51
  52 /**
  53  * @file
  54  * @brief Misc utility functions
  55  */
  56
  57 /**
  58  Find a suitable temporary directory. The result should be copied immediately
  59  as it may be overwritten by a subsequent call.
  60 **/
  61 _PUBLIC_ const char *tmpdir(void)
  62 {
  63         char *p;
  64         if ((p = getenv("TMPDIR")))
  65                 return p;
  66         return "/tmp";
  67 }
  68
  69
  70 /**
  71  Create a tmp file, open it and immediately unlink it.
  72  If dir is NULL uses tmpdir()
  73  Returns the file descriptor or -1 on error.
  74 **/
  75 int create_unlink_tmp(const char *dir)
  76 {
  77         size_t len = strlen(dir ? dir : (dir = tmpdir()));
  78         char fname[len+25];
  79         int fd;
  80         mode_t mask;
  81
  82         len = snprintf(fname, sizeof(fname), "%s/listenerlock_XXXXXX", dir);
  83         if (len >= sizeof(fname)) {
  84                 errno = ENOMEM;
  85                 return -1;
  86         }
  87         mask = umask(S_IRWXO | S_IRWXG);
  88         fd = mkstemp(fname);
  89         umask(mask);
  90         if (fd == -1) {
  91                 return -1;
  92         }
  93         if (unlink(fname) == -1) {
  94                 int sys_errno = errno;
  95                 close(fd);
  96                 errno = sys_errno;
  97                 return -1;
  98         }
  99         return fd;
 100 }
 101
 102
 103 /**
 104  Check if a file exists - call vfs_file_exist for samba files.
 105 **/
 106 _PUBLIC_ bool file_exist(const char *fname)
 107 {
 108         struct stat st;
 109
 110         if (stat(fname, &st) != 0) {
 111                 return false;
 112         }
 113
 114         return ((S_ISREG(st.st_mode)) || (S_ISFIFO(st.st_mode)));
 115 }
 116
 117 /**
 118  Check a files mod time.
 119 **/
 120
 121 _PUBLIC_ time_t file_modtime(const char *fname)
 122 {
 123         struct stat st;
 124
 125         if (stat(fname,&st) != 0)
 126                 return(0);
 127
 128         return(st.st_mtime);
 129 }
 130
 131 /**
 132  Check file permissions.
 133 **/
 134
 135 _PUBLIC_ bool file_check_permissions(const char *fname,
 136                                      uid_t uid,
 137                                      mode_t file_perms,
 138                                      struct stat *pst)
 139 {
 140         int ret;
 141         struct stat st;
 142
 143         if (pst == NULL) {
 144                 pst = &st;
 145         }
 146
 147         ZERO_STRUCTP(pst);
 148
 149         ret = stat(fname, pst);
 150         if (ret != 0) {
 151                 DEBUG(0, ("stat failed on file '%s': %s\n",
 152                          fname, strerror(errno)));
 153                 return false;
 154         }
 155
 156         if (pst->st_uid != uid && !uid_wrapper_enabled()) {
 157                 DEBUG(0, ("invalid ownership of file '%s': "
 158                          "owned by uid %u, should be %u\n",
 159                          fname, (unsigned int)pst->st_uid,
 160                          (unsigned int)uid));
 161                 return false;
 162         }
 163
 164         if ((pst->st_mode & 0777) != file_perms) {
 165                 DEBUG(0, ("invalid permissions on file "
 166                          "'%s': has 0%o should be 0%o\n", fname,
 167                          (unsigned int)(pst->st_mode & 0777),
 168                          (unsigned int)file_perms));
 169                 return false;
 170         }
 171
 172         return true;
 173 }
 174
 175 /**
 176  Check if a directory exists.
 177 **/
 178
 179 _PUBLIC_ bool directory_exist(const char *dname)
 180 {
 181         struct stat st;
 182         bool ret;
 183
 184         if (stat(dname,&st) != 0) {
 185                 return false;
 186         }
 187
 188         ret = S_ISDIR(st.st_mode);
 189         if(!ret)
 190                 errno = ENOTDIR;
 191         return ret;
 192 }
 193
 194 /**
 195  * Try to create the specified directory if it didn't exist.
 196  * A symlink to a directory is also accepted as a valid existing directory.
 197  *
 198  * @retval true if the directory already existed
 199  * or was successfully created.
 200  */
 201 _PUBLIC_ bool directory_create_or_exist(const char *dname,
 202                                         mode_t dir_perms)
 203 {
 204         int ret;
 205         mode_t old_umask;
 206
 207         /* Create directory */
 208         old_umask = umask(0);
 209         ret = mkdir(dname, dir_perms);
 210         if (ret == -1 && errno != EEXIST) {
 211                 int dbg_level = geteuid() == 0 ? DBGLVL_ERR : DBGLVL_NOTICE;
 212
 213                 DBG_PREFIX(dbg_level,
 214                            ("mkdir failed on directory %s: %s\n",
 215                             dname,
 216                             strerror(errno)));
 217                 umask(old_umask);
 218                 return false;
 219         }
 220         umask(old_umask);
 221
 222         if (ret != 0 && errno == EEXIST) {
 223                 struct stat sbuf;
 224
 225                 ret = lstat(dname, &sbuf);
 226                 if (ret != 0) {
 227                         return false;
 228                 }
 229
 230                 if (S_ISDIR(sbuf.st_mode)) {
 231                         return true;
 232                 }
 233
 234                 if (S_ISLNK(sbuf.st_mode)) {
 235                         ret = stat(dname, &sbuf);
 236                         if (ret != 0) {
 237                                 return false;
 238                         }
 239
 240                         if (S_ISDIR(sbuf.st_mode)) {
 241                                 return true;
 242                         }
 243                 }
 244
 245                 return false;
 246         }
 247
 248         return true;
 249 }
 250
 251 _PUBLIC_ bool directory_create_or_exists_recursive(
 252                 const char *dname,
 253                 mode_t dir_perms)
 254 {
 255         bool ok;
 256
 257         ok = directory_create_or_exist(dname, dir_perms);
 258         if (!ok) {
 259                 if (!directory_exist(dname)) {
 260                         char tmp[PATH_MAX] = {0};
 261                         char *parent = NULL;
 262                         size_t n;
 263
 264                         /* Use the null context */
 265                         n = strlcpy(tmp, dname, sizeof(tmp));
 266                         if (n < strlen(dname)) {
 267                                 DBG_ERR("Path too long!\n");
 268                                 return false;
 269                         }
 270
 271                         parent = dirname(tmp);
 272                         if (parent == NULL) {
 273                                 DBG_ERR("Failed to create dirname!\n");
 274                                 return false;
 275                         }
 276
 277                         ok = directory_create_or_exists_recursive(parent,
 278                                                                   dir_perms);
 279                         if (!ok) {
 280                                 return false;
 281                         }
 282
 283                         ok = directory_create_or_exist(dname, dir_perms);
 284                 }
 285         }
 286
 287         return ok;
 288 }
 289
 290 /**
 291  * @brief Try to create a specified directory if it doesn't exist.
 292  *
 293  * The function creates a directory with the given uid and permissions if it
 294  * doesn't exist. If it exists it makes sure the uid and permissions are
 295  * correct and it will fail if they are different.
 296  *
 297  * @param[in]  dname  The directory to create.
 298  *
 299  * @param[in]  uid    The uid the directory needs to belong too.
 300  *
 301  * @param[in]  dir_perms  The expected permissions of the directory.
 302  *
 303  * @return True on success, false on error.
 304  */
 305 _PUBLIC_ bool directory_create_or_exist_strict(const char *dname,
 306                                                uid_t uid,
 307                                                mode_t dir_perms)
 308 {
 309         struct stat st;
 310         bool ok;
 311         int rc;
 312
 313         ok = directory_create_or_exist(dname, dir_perms);
 314         if (!ok) {
 315                 return false;
 316         }
 317
 318         rc = lstat(dname, &st);
 319         if (rc == -1) {
 320                 DEBUG(0, ("lstat failed on created directory %s: %s\n",
 321                           dname, strerror(errno)));
 322                 return false;
 323         }
 324
 325         /* Check ownership and permission on existing directory */
 326         if (!S_ISDIR(st.st_mode)) {
 327                 DEBUG(0, ("directory %s isn't a directory\n",
 328                         dname));
 329                 return false;
 330         }
 331         if (st.st_uid != uid && !uid_wrapper_enabled()) {
 332                 DBG_NOTICE("invalid ownership on directory "
 333                           "%s\n", dname);
 334                 return false;
 335         }
 336         if ((st.st_mode & 0777) != dir_perms) {
 337                 DEBUG(0, ("invalid permissions on directory "
 338                           "'%s': has 0%o should be 0%o\n", dname,
 339                           (unsigned int)(st.st_mode & 0777), (unsigned int)dir_perms));
 340                 return false;
 341         }
 342
 343         return true;
 344 }
 345
 346
 347 /**
 348  Sleep for a specified number of milliseconds.
 349 **/
 350
 351 _PUBLIC_ void smb_msleep(unsigned int t)
 352 {
 353         sys_poll_intr(NULL, 0, t);
 354 }
 355
 356 /**
 357  Get my own name, return in talloc'ed storage.
 358 **/
 359
 360 _PUBLIC_ char *get_myname(TALLOC_CTX *ctx)
 361 {
 362         char *p;
 363         char hostname[HOST_NAME_MAX];
 364
 365         /* get my host name */
 366         if (gethostname(hostname, sizeof(hostname)) == -1) {
 367                 DEBUG(0,("gethostname failed\n"));
 368                 return NULL;
 369         }
 370
 371         /* Ensure null termination. */
 372         hostname[sizeof(hostname)-1] = '\0';
 373
 374         /* split off any parts after an initial . */
 375         p = strchr_m(hostname, '.');
 376         if (p) {
 377                 *p = 0;
 378         }
 379
 380         return talloc_strdup(ctx, hostname);
 381 }
 382
 383 /**
 384  Check if a process exists. Does this work on all unixes?
 385 **/
 386
 387 _PUBLIC_ bool process_exists_by_pid(pid_t pid)
 388 {
 389         /* Doing kill with a non-positive pid causes messages to be
 390          * sent to places we don't want. */
 391         if (pid <= 0) {
 392                 return false;
 393         }
 394         return(kill(pid,0) == 0 || errno != ESRCH);
 395 }
 396
 397 /**
 398  Simple routine to do POSIX file locking. Cruft in NFS and 64->32 bit mapping
 399  is dealt with in posix.c
 400 **/
 401
 402 _PUBLIC_ bool fcntl_lock(int fd, int op, off_t offset, off_t count, int type)
 403 {
 404         struct flock lock;
 405         int ret;
 406
 407         DEBUG(8,("fcntl_lock %d %d %.0f %.0f %d\n",fd,op,(double)offset,(double)count,type));
 408
 409         lock.l_type = type;
 410         lock.l_whence = SEEK_SET;
 411         lock.l_start = offset;
 412         lock.l_len = count;
 413         lock.l_pid = 0;
 414
 415         ret = fcntl(fd,op,&lock);
 416
 417         if (ret == -1 && errno != 0)
 418                 DEBUG(3,("fcntl_lock: fcntl lock gave errno %d (%s)\n",errno,strerror(errno)));
 419
 420         /* a lock query */
 421         if (op == F_GETLK) {
 422                 if ((ret != -1) &&
 423                                 (lock.l_type != F_UNLCK) &&
 424                                 (lock.l_pid != 0) &&
 425                                 (lock.l_pid != getpid())) {
 426                         DEBUG(3,("fcntl_lock: fd %d is locked by pid %d\n",fd,(int)lock.l_pid));
 427                         return true;
 428                 }
 429
 430                 /* it must be not locked or locked by me */
 431                 return false;
 432         }
 433
 434         /* a lock set or unset */
 435         if (ret == -1) {
 436                 DEBUG(3,("fcntl_lock: lock failed at offset %.0f count %.0f op %d type %d (%s)\n",
 437                         (double)offset,(double)count,op,type,strerror(errno)));
 438                 return false;
 439         }
 440
 441         /* everything went OK */
 442         DEBUG(8,("fcntl_lock: Lock call successful\n"));
 443
 444         return true;
 445 }
 446
 447 struct debug_channel_level {
 448         int channel;
 449         int level;
 450 };
 451
 452 static void debugadd_channel_cb(const char *buf, void *private_data)
 453 {
 454         struct debug_channel_level *dcl =
 455                 (struct debug_channel_level *)private_data;
 456
 457         DEBUGADDC(dcl->channel, dcl->level,("%s", buf));
 458 }
 459
 460 static void debugadd_cb(const char *buf, void *private_data)
 461 {
 462         int *plevel = (int *)private_data;
 463         DEBUGADD(*plevel, ("%s", buf));
 464 }
 465
 466 void print_asc_cb(const uint8_t *buf, int len,
 467                   void (*cb)(const char *buf, void *private_data),
 468                   void *private_data)
 469 {
 470         int i;
 471         char s[2];
 472         s[1] = 0;
 473
 474         for (i=0; i<len; i++) {
 475                 s[0] = isprint(buf[i]) ? buf[i] : '.';
 476                 cb(s, private_data);
 477         }
 478 }
 479
 480 void print_asc(int level, const uint8_t *buf,int len)
 481 {
 482         print_asc_cb(buf, len, debugadd_cb, &level);
 483 }
 484
 485 static void dump_data_block16(const char *prefix, size_t idx,
 486                               const uint8_t *buf, size_t len,
 487                               void (*cb)(const char *buf, void *private_data),
 488                               void *private_data)
 489 {
 490         char tmp[16];
 491         size_t i;
 492
 493         SMB_ASSERT(len >= 0 && len <= 16);
 494
 495         snprintf(tmp, sizeof(tmp), "%s[%04zX]", prefix, idx);
 496         cb(tmp, private_data);
 497
 498         for (i=0; i<16; i++) {
 499                 if (i == 8) {
 500                         cb("  ", private_data);
 501                 }
 502                 if (i < len) {
 503                         snprintf(tmp, sizeof(tmp), " %02X", (int)buf[i]);
 504                 } else {
 505                         snprintf(tmp, sizeof(tmp), "   ");
 506                 }
 507                 cb(tmp, private_data);
 508         }
 509
 510         cb("   ", private_data);
 511
 512         if (len == 0) {
 513                 cb("EMPTY   BLOCK\n", private_data);
 514                 return;
 515         }
 516
 517         for (i=0; i<len; i++) {
 518                 if (i == 8) {
 519                         cb(" ", private_data);
 520                 }
 521                 print_asc_cb(&buf[i], 1, cb, private_data);
 522         }
 523
 524         cb("\n", private_data);
 525 }
 526
 527 /**
 528  * Write dump of binary data to a callback
 529  */
 530 void dump_data_cb(const uint8_t *buf, int len,
 531                   bool omit_zero_bytes,
 532                   void (*cb)(const char *buf, void *private_data),
 533                   void *private_data)
 534 {
 535         int i=0;
 536         bool skipped = false;
 537
 538         if (len<=0) return;
 539
 540         for (i=0;i<len;i+=16) {
 541                 size_t remaining_len = len - i;
 542                 size_t this_len = MIN(remaining_len, 16);
 543                 const uint8_t *this_buf = &buf[i];
 544
 545                 if ((omit_zero_bytes == true) &&
 546                     (i > 0) && (remaining_len > 16) &&
 547                     (this_len == 16) && all_zero(this_buf, 16))
 548                 {
 549                         if (!skipped) {
 550                                 cb("skipping zero buffer bytes\n",
 551                                    private_data);
 552                                 skipped = true;
 553                         }
 554                         continue;
 555                 }
 556
 557                 skipped = false;
 558                 dump_data_block16("", i, this_buf, this_len,
 559                                   cb, private_data);
 560         }
 561 }
 562
 563 /**
 564  * Write dump of binary data to the log file.
 565  *
 566  * The data is only written if the log level is at least level.
 567  */
 568 _PUBLIC_ void dump_data(int level, const uint8_t *buf, int len)
 569 {
 570         if (!DEBUGLVL(level)) {
 571                 return;
 572         }
 573         dump_data_cb(buf, len, false, debugadd_cb, &level);
 574 }
 575
 576 /**
 577  * Write dump of binary data to the log file.
 578  *
 579  * The data is only written if the log level is at least level for
 580  * debug class dbgc_class.
 581  */
 582 _PUBLIC_ void dump_data_dbgc(int dbgc_class, int level, const uint8_t *buf, int len)
 583 {
 584         struct debug_channel_level dcl = { dbgc_class, level };
 585
 586         if (!DEBUGLVLC(dbgc_class, level)) {
 587                 return;
 588         }
 589         dump_data_cb(buf, len, false, debugadd_channel_cb, &dcl);
 590 }
 591
 592 /**
 593  * Write dump of binary data to the log file.
 594  *
 595  * The data is only written if the log level is at least level.
 596  * 16 zero bytes in a row are omitted
 597  */
 598 _PUBLIC_ void dump_data_skip_zeros(int level, const uint8_t *buf, int len)
 599 {
 600         if (!DEBUGLVL(level)) {
 601                 return;
 602         }
 603         dump_data_cb(buf, len, true, debugadd_cb, &level);
 604 }
 605
 606 static void fprintf_cb(const char *buf, void *private_data)
 607 {
 608         FILE *f = (FILE *)private_data;
 609         fprintf(f, "%s", buf);
 610 }
 611
 612 void dump_data_file(const uint8_t *buf, int len, bool omit_zero_bytes,
 613                     FILE *f)
 614 {
 615         dump_data_cb(buf, len, omit_zero_bytes, fprintf_cb, f);
 616 }
 617
 618 /**
 619  * Write dump of compared binary data to a callback
 620  */
 621 void dump_data_diff_cb(const uint8_t *buf1, size_t len1,
 622                        const uint8_t *buf2, size_t len2,
 623                        bool omit_zero_bytes,
 624                        void (*cb)(const char *buf, void *private_data),
 625                        void *private_data)
 626 {
 627         size_t len = MAX(len1, len2);
 628         size_t i;
 629         bool skipped = false;
 630
 631         for (i=0; i<len; i+=16) {
 632                 size_t remaining_len = len - i;
 633                 size_t remaining_len1 = 0;
 634                 size_t this_len1 = 0;
 635                 const uint8_t *this_buf1 = NULL;
 636                 size_t remaining_len2 = 0;
 637                 size_t this_len2 = 0;
 638                 const uint8_t *this_buf2 = NULL;
 639
 640                 if (i < len1) {
 641                         remaining_len1 = len1 - i;
 642                         this_len1 = MIN(remaining_len1, 16);
 643                         this_buf1 = &buf1[i];
 644                 }
 645                 if (i < len2) {
 646                         remaining_len2 = len2 - i;
 647                         this_len2 = MIN(remaining_len2, 16);
 648                         this_buf2 = &buf2[i];
 649                 }
 650
 651                 if ((omit_zero_bytes == true) &&
 652                     (i > 0) && (remaining_len > 16) &&
 653                     (this_len1 == 16) && all_zero(this_buf1, 16) &&
 654                     (this_len2 == 16) && all_zero(this_buf2, 16))
 655                 {
 656                         if (!skipped) {
 657                                 cb("skipping zero buffer bytes\n",
 658                                    private_data);
 659                                 skipped = true;
 660                         }
 661                         continue;
 662                 }
 663
 664                 skipped = false;
 665
 666                 if ((this_len1 == this_len2) &&
 667                     (memcmp(this_buf1, this_buf2, this_len1) == 0))
 668                 {
 669                         dump_data_block16(" ", i, this_buf1, this_len1,
 670                                           cb, private_data);
 671                         continue;
 672                 }
 673
 674                 dump_data_block16("-", i, this_buf1, this_len1,
 675                                   cb, private_data);
 676                 dump_data_block16("+", i, this_buf2, this_len2,
 677                                   cb, private_data);
 678         }
 679 }
 680
 681 _PUBLIC_ void dump_data_diff(int dbgc_class, int level,
 682                              bool omit_zero_bytes,
 683                              const uint8_t *buf1, size_t len1,
 684                              const uint8_t *buf2, size_t len2)
 685 {
 686         struct debug_channel_level dcl = { dbgc_class, level };
 687
 688         if (!DEBUGLVLC(dbgc_class, level)) {
 689                 return;
 690         }
 691         dump_data_diff_cb(buf1, len1, buf2, len2, true, debugadd_channel_cb, &dcl);
 692 }
 693
 694 _PUBLIC_ void dump_data_file_diff(FILE *f,
 695                                   bool omit_zero_bytes,
 696                                   const uint8_t *buf1, size_t len1,
 697                                   const uint8_t *buf2, size_t len2)
 698 {
 699         dump_data_diff_cb(buf1, len1, buf2, len2, omit_zero_bytes, fprintf_cb, f);
 700 }
 701
 702 /**
 703  malloc that aborts with smb_panic on fail or zero size.
 704 **/
 705
 706 _PUBLIC_ void *smb_xmalloc(size_t size)
 707 {
 708         void *p;
 709         if (size == 0)
 710                 smb_panic("smb_xmalloc: called with zero size.\n");
 711         if ((p = malloc(size)) == NULL)
 712                 smb_panic("smb_xmalloc: malloc fail.\n");
 713         return p;
 714 }
 715
 716 /**
 717  Memdup with smb_panic on fail.
 718 **/
 719
 720 _PUBLIC_ void *smb_xmemdup(const void *p, size_t size)
 721 {
 722         void *p2;
 723         p2 = smb_xmalloc(size);
 724         memcpy(p2, p, size);
 725         return p2;
 726 }
 727
 728 /**
 729  strdup that aborts on malloc fail.
 730 **/
 731
 732 char *smb_xstrdup(const char *s)
 733 {
 734 #if defined(PARANOID_MALLOC_CHECKER)
 735 #ifdef strdup
 736 #undef strdup
 737 #endif
 738 #endif
 739
 740 #ifndef HAVE_STRDUP
 741 #define strdup rep_strdup
 742 #endif
 743
 744         char *s1 = strdup(s);
 745 #if defined(PARANOID_MALLOC_CHECKER)
 746 #ifdef strdup
 747 #undef strdup
 748 #endif
 749 #define strdup(s) __ERROR_DONT_USE_STRDUP_DIRECTLY
 750 #endif
 751         if (!s1) {
 752                 smb_panic("smb_xstrdup: malloc failed");
 753         }
 754         return s1;
 755
 756 }
 757
 758 /**
 759  strndup that aborts on malloc fail.
 760 **/
 761
 762 char *smb_xstrndup(const char *s, size_t n)
 763 {
 764 #if defined(PARANOID_MALLOC_CHECKER)
 765 #ifdef strndup
 766 #undef strndup
 767 #endif
 768 #endif
 769
 770 #if (defined(BROKEN_STRNDUP) || !defined(HAVE_STRNDUP))
 771 #undef HAVE_STRNDUP
 772 #define strndup rep_strndup
 773 #endif
 774
 775         char *s1 = strndup(s, n);
 776 #if defined(PARANOID_MALLOC_CHECKER)
 777 #ifdef strndup
 778 #undef strndup
 779 #endif
 780 #define strndup(s,n) __ERROR_DONT_USE_STRNDUP_DIRECTLY
 781 #endif
 782         if (!s1) {
 783                 smb_panic("smb_xstrndup: malloc failed");
 784         }
 785         return s1;
 786 }
 787
 788
 789
 790 /**
 791  Like strdup but for memory.
 792 **/
 793
 794 _PUBLIC_ void *smb_memdup(const void *p, size_t size)
 795 {
 796         void *p2;
 797         if (size == 0)
 798                 return NULL;
 799         p2 = malloc(size);
 800         if (!p2)
 801                 return NULL;
 802         memcpy(p2, p, size);
 803         return p2;
 804 }
 805
 806 /**
 807  * Write a password to the log file.
 808  *
 809  * @note Only actually does something if DEBUG_PASSWORD was defined during
 810  * compile-time.
 811  */
 812 _PUBLIC_ void dump_data_pw(const char *msg, const uint8_t * data, size_t len)
 813 {
 814 #ifdef DEBUG_PASSWORD
 815         DEBUG(11, ("%s", msg));
 816         if (data != NULL && len > 0)
 817         {
 818                 dump_data(11, data, len);
 819         }
 820 #endif
 821 }
 822
 823
 824 /**
 825  * see if a range of memory is all zero. A NULL pointer is considered
 826  * to be all zero
 827  */
 828 _PUBLIC_ bool all_zero(const uint8_t *ptr, size_t size)
 829 {
 830         size_t i;
 831         if (!ptr) return true;
 832         for (i=0;i<size;i++) {
 833                 if (ptr[i]) return false;
 834         }
 835         return true;
 836 }
 837
 838 /**
 839   realloc an array, checking for integer overflow in the array size
 840 */
 841 _PUBLIC_ void *realloc_array(void *ptr, size_t el_size, unsigned count, bool free_on_fail)
 842 {
 843 #define MAX_MALLOC_SIZE 0x7fffffff
 844         if (count == 0 ||
 845             count >= MAX_MALLOC_SIZE/el_size) {
 846                 if (free_on_fail)
 847                         SAFE_FREE(ptr);
 848                 return NULL;
 849         }
 850         if (!ptr) {
 851                 return malloc(el_size * count);
 852         }
 853         return realloc(ptr, el_size * count);
 854 }
 855
 856 /****************************************************************************
 857  Type-safe malloc.
 858 ****************************************************************************/
 859
 860 void *malloc_array(size_t el_size, unsigned int count)
 861 {
 862         return realloc_array(NULL, el_size, count, false);
 863 }
 864
 865 /****************************************************************************
 866  Type-safe memalign
 867 ****************************************************************************/
 868
 869 void *memalign_array(size_t el_size, size_t align, unsigned int count)
 870 {
 871         if (el_size == 0 || count >= MAX_MALLOC_SIZE/el_size) {
 872                 return NULL;
 873         }
 874
 875         return memalign(align, el_size*count);
 876 }
 877
 878 /****************************************************************************
 879  Type-safe calloc.
 880 ****************************************************************************/
 881
 882 void *calloc_array(size_t size, size_t nmemb)
 883 {
 884         if (nmemb >= MAX_MALLOC_SIZE/size) {
 885                 return NULL;
 886         }
 887         if (size == 0 || nmemb == 0) {
 888                 return NULL;
 889         }
 890         return calloc(nmemb, size);
 891 }
 892
 893 /**
 894  Trim the specified elements off the front and back of a string.
 895 **/
 896 _PUBLIC_ bool trim_string(char *s, const char *front, const char *back)
 897 {
 898         bool ret = false;
 899         size_t front_len;
 900         size_t back_len;
 901         size_t len;
 902
 903         /* Ignore null or empty strings. */
 904         if (!s || (s[0] == '\0')) {
 905                 return false;
 906         }
 907         len = strlen(s);
 908
 909         front_len       = front? strlen(front) : 0;
 910         back_len        = back? strlen(back) : 0;
 911
 912         if (front_len) {
 913                 size_t front_trim = 0;
 914
 915                 while (strncmp(s+front_trim, front, front_len)==0) {
 916                         front_trim += front_len;
 917                 }
 918                 if (front_trim > 0) {
 919                         /* Must use memmove here as src & dest can
 920                          * easily overlap. Found by valgrind. JRA. */
 921                         memmove(s, s+front_trim, (len-front_trim)+1);
 922                         len -= front_trim;
 923                         ret=true;
 924                 }
 925         }
 926
 927         if (back_len) {
 928                 while ((len >= back_len) && strncmp(s+len-back_len,back,back_len)==0) {
 929                         s[len-back_len]='\0';
 930                         len -= back_len;
 931                         ret=true;
 932                 }
 933         }
 934         return ret;
 935 }
 936
 937 /**
 938  Find the number of 'c' chars in a string
 939 **/
 940 _PUBLIC_ _PURE_ size_t count_chars(const char *s, char c)
 941 {
 942         size_t count = 0;
 943
 944         while (*s) {
 945                 if (*s == c) count++;
 946                 s ++;
 947         }
 948
 949         return count;
 950 }
 951
 952 /**
 953  * Routine to get hex characters and turn them into a byte array.
 954  * the array can be variable length.
 955  * -  "0xnn" or "0Xnn" is specially catered for.
 956  * - The first non-hex-digit character (apart from possibly leading "0x"
 957  *   finishes the conversion and skips the rest of the input.
 958  * - A single hex-digit character at the end of the string is skipped.
 959  *
 960  * valid examples: "0A5D15"; "0x123456"
 961  */
 962 _PUBLIC_ size_t strhex_to_str(char *p, size_t p_len, const char *strhex, size_t strhex_len)
 963 {
 964         size_t i = 0;
 965         size_t num_chars = 0;
 966
 967         /* skip leading 0x prefix */
 968         if (strncasecmp(strhex, "0x", 2) == 0) {
 969                 i += 2; /* skip two chars */
 970         }
 971
 972         while ((i < strhex_len) && (num_chars < p_len)) {
 973                 bool ok = hex_byte(&strhex[i], (uint8_t *)&p[num_chars]);
 974                 if (!ok) {
 975                         break;
 976                 }
 977                 i += 2;
 978                 num_chars += 1;
 979         }
 980
 981         return num_chars;
 982 }
 983
 984 /**
 985  * Parse a hex string and return a data blob.
 986  */
 987 _PUBLIC_ DATA_BLOB strhex_to_data_blob(TALLOC_CTX *mem_ctx, const char *strhex)
 988 {
 989         DATA_BLOB ret_blob = data_blob_talloc(mem_ctx, NULL, strlen(strhex)/2+1);
 990
 991         ret_blob.length = strhex_to_str((char *)ret_blob.data, ret_blob.length,
 992                                         strhex,
 993                                         strlen(strhex));
 994
 995         return ret_blob;
 996 }
 997
 998 /**
 999  * Parse a hex dump and return a data blob. Hex dump is structured as
1000  * is generated from dump_data_cb() elsewhere in this file
1001  *
1002  */
1003 _PUBLIC_ DATA_BLOB hexdump_to_data_blob(TALLOC_CTX *mem_ctx, const char *hexdump, size_t hexdump_len)
1004 {
1005         DATA_BLOB ret_blob = { 0 };
1006         size_t i = 0;
1007         size_t char_count = 0;
1008         /* hexdump line length is 77 chars long. We then use the ASCII representation of the bytes
1009          * at the end of the final line to calculate how many are in that line, minus the extra space
1010          * and newline. */
1011         size_t hexdump_byte_count = (16 * (hexdump_len / 77));
1012         if (hexdump_len % 77) {
1013                 hexdump_byte_count += ((hexdump_len % 77) - 59 - 2);
1014         }
1015
1016         ret_blob = data_blob_talloc(mem_ctx, NULL, hexdump_byte_count+1);
1017         for (; i+1 < hexdump_len && hexdump[i] != 0 && hexdump[i+1] != 0; i++) {
1018                 if ((i%77) == 0)
1019                         i += 7; /* Skip the offset at the start of the line */
1020                 if ((i%77) < 56) { /* position 56 is after both hex chunks */
1021                         if (hexdump[i] != ' ') {
1022                                 char_count += strhex_to_str((char *)&ret_blob.data[char_count],
1023                                                             hexdump_byte_count - char_count,
1024                                                             &hexdump[i], 2);
1025                                 i += 2;
1026                         } else {
1027                                 i++;
1028                         }
1029                 } else {
1030                         i++;
1031                 }
1032         }
1033         ret_blob.length = char_count;
1034
1035         return ret_blob;
1036 }
1037
1038 /**
1039  * Print a buf in hex. Assumes dst is at least (srclen*2)+1 large.
1040  */
1041 _PUBLIC_ void hex_encode_buf(char *dst, const uint8_t *src, size_t srclen)
1042 {
1043         size_t i;
1044         for (i=0; i<srclen; i++) {
1045                 snprintf(dst + i*2, 3, "%02X", src[i]);
1046         }
1047         /*
1048          * Ensure 0-termination for 0-length buffers
1049          */
1050         dst[srclen*2] = '\0';
1051 }
1052
1053 /**
1054  * talloc version of hex_encode_buf()
1055  */
1056 _PUBLIC_ char *hex_encode_talloc(TALLOC_CTX *mem_ctx, const unsigned char *buff_in, size_t len)
1057 {
1058         char *hex_buffer;
1059
1060         hex_buffer = talloc_array(mem_ctx, char, (len*2)+1);
1061         if (!hex_buffer) {
1062                 return NULL;
1063         }
1064         hex_encode_buf(hex_buffer, buff_in, len);
1065         talloc_set_name_const(hex_buffer, hex_buffer);
1066         return hex_buffer;
1067 }
1068
1069 /**
1070   varient of strcmp() that handles NULL ptrs
1071 **/
1072 _PUBLIC_ int strcmp_safe(const char *s1, const char *s2)
1073 {
1074         if (s1 == s2) {
1075                 return 0;
1076         }
1077         if (s1 == NULL || s2 == NULL) {
1078                 return s1?-1:1;
1079         }
1080         return strcmp(s1, s2);
1081 }
1082
1083
1084 /**
1085 return the number of bytes occupied by a buffer in ASCII format
1086 the result includes the null termination
1087 limited by 'n' bytes
1088 **/
1089 _PUBLIC_ size_t ascii_len_n(const char *src, size_t n)
1090 {
1091         size_t len;
1092
1093         len = strnlen(src, n);
1094         if (len+1 <= n) {
1095                 len += 1;
1096         }
1097
1098         return len;
1099 }
1100
1101 _PUBLIC_ bool mem_equal_const_time(const void *s1, const void *s2, size_t n)
1102 {
1103         /* Ensure we won't overflow the unsigned index used by gnutls. */
1104         SMB_ASSERT(n <= UINT_MAX);
1105
1106         return gnutls_memcmp(s1, s2, n) == 0;
1107 }
1108
1109 struct anonymous_shared_header {
1110         union {
1111                 size_t length;
1112                 uint8_t pad[16];
1113         } u;
1114 };
1115
1116 /* Map a shared memory buffer of at least nelem counters. */
1117 void *anonymous_shared_allocate(size_t orig_bufsz)
1118 {
1119         void *ptr;
1120         void *buf;
1121         size_t pagesz = getpagesize();
1122         size_t pagecnt;
1123         size_t bufsz = orig_bufsz;
1124         struct anonymous_shared_header *hdr;
1125
1126         bufsz += sizeof(*hdr);
1127
1128         /* round up to full pages */
1129         pagecnt = bufsz / pagesz;
1130         if (bufsz % pagesz) {
1131                 pagecnt += 1;
1132         }
1133         bufsz = pagesz * pagecnt;
1134
1135         if (orig_bufsz >= bufsz) {
1136                 /* integer wrap */
1137                 errno = ENOMEM;
1138                 return NULL;
1139         }
1140
1141 #ifdef MAP_ANON
1142         /* BSD */
1143         buf = mmap(NULL, bufsz, PROT_READ|PROT_WRITE, MAP_ANON|MAP_SHARED,
1144                         -1 /* fd */, 0 /* offset */);
1145 #else
1146 {
1147         int saved_errno;
1148         int fd;
1149
1150         fd = open("/dev/zero", O_RDWR);
1151         if (fd == -1) {
1152                 return NULL;
1153         }
1154
1155         buf = mmap(NULL, bufsz, PROT_READ|PROT_WRITE, MAP_FILE|MAP_SHARED,
1156                    fd, 0 /* offset */);
1157         saved_errno = errno;
1158         close(fd);
1159         errno = saved_errno;
1160 }
1161 #endif
1162
1163         if (buf == MAP_FAILED) {
1164                 return NULL;
1165         }
1166
1167         hdr = (struct anonymous_shared_header *)buf;
1168         hdr->u.length = bufsz;
1169
1170         ptr = (void *)(&hdr[1]);
1171
1172         return ptr;
1173 }
1174
1175 void *anonymous_shared_resize(void *ptr, size_t new_size, bool maymove)
1176 {
1177 #ifdef HAVE_MREMAP
1178         void *buf;
1179         size_t pagesz = getpagesize();
1180         size_t pagecnt;
1181         size_t bufsz;
1182         struct anonymous_shared_header *hdr;
1183         int flags = 0;
1184
1185         if (ptr == NULL) {
1186                 errno = EINVAL;
1187                 return NULL;
1188         }
1189
1190         hdr = (struct anonymous_shared_header *)ptr;
1191         hdr--;
1192         if (hdr->u.length > (new_size + sizeof(*hdr))) {
1193                 errno = EINVAL;
1194                 return NULL;
1195         }
1196
1197         bufsz = new_size + sizeof(*hdr);
1198
1199         /* round up to full pages */
1200         pagecnt = bufsz / pagesz;
1201         if (bufsz % pagesz) {
1202                 pagecnt += 1;
1203         }
1204         bufsz = pagesz * pagecnt;
1205
1206         if (new_size >= bufsz) {
1207                 /* integer wrap */
1208                 errno = ENOSPC;
1209                 return NULL;
1210         }
1211
1212         if (bufsz <= hdr->u.length) {
1213                 return ptr;
1214         }
1215
1216         if (maymove) {
1217                 flags = MREMAP_MAYMOVE;
1218         }
1219
1220         buf = mremap(hdr, hdr->u.length, bufsz, flags);
1221
1222         if (buf == MAP_FAILED) {
1223                 errno = ENOSPC;
1224                 return NULL;
1225         }
1226
1227         hdr = (struct anonymous_shared_header *)buf;
1228         hdr->u.length = bufsz;
1229
1230         ptr = (void *)(&hdr[1]);
1231
1232         return ptr;
1233 #else
1234         errno = ENOSPC;
1235         return NULL;
1236 #endif
1237 }
1238
1239 void anonymous_shared_free(void *ptr)
1240 {
1241         struct anonymous_shared_header *hdr;
1242
1243         if (ptr == NULL) {
1244                 return;
1245         }
1246
1247         hdr = (struct anonymous_shared_header *)ptr;
1248
1249         hdr--;
1250
1251         munmap(hdr, hdr->u.length);
1252 }
1253
1254 #ifdef DEVELOPER
1255 /* used when you want a debugger started at a particular point in the
1256    code. Mostly useful in code that runs as a child process, where
1257    normal gdb attach is harder to organise.
1258 */
1259 void samba_start_debugger(void)
1260 {
1261         int ready_pipe[2];
1262         char c;
1263         int ret;
1264         pid_t pid;
1265
1266         ret = pipe(ready_pipe);
1267         SMB_ASSERT(ret == 0);
1268
1269         pid = fork();
1270         SMB_ASSERT(pid >= 0);
1271
1272         if (pid) {
1273                 c = 0;
1274
1275                 ret = close(ready_pipe[0]);
1276                 SMB_ASSERT(ret == 0);
1277 #if defined(HAVE_PRCTL) && defined(PR_SET_PTRACER)
1278                 /*
1279                  * Make sure the child process can attach a debugger.
1280                  *
1281                  * We don't check the error code as the debugger
1282                  * will tell us if it can't attach.
1283                  */
1284                 (void)prctl(PR_SET_PTRACER, pid, 0, 0, 0);
1285 #endif
1286                 ret = write(ready_pipe[1], &c, 1);
1287                 SMB_ASSERT(ret == 1);
1288
1289                 ret = close(ready_pipe[1]);
1290                 SMB_ASSERT(ret == 0);
1291
1292                 /* Wait for gdb to attach. */
1293                 sleep(2);
1294         } else {
1295                 char *cmd = NULL;
1296
1297                 ret = close(ready_pipe[1]);
1298                 SMB_ASSERT(ret == 0);
1299
1300                 ret = read(ready_pipe[0], &c, 1);
1301                 SMB_ASSERT(ret == 1);
1302
1303                 ret = close(ready_pipe[0]);
1304                 SMB_ASSERT(ret == 0);
1305
1306                 ret = asprintf(&cmd, "gdb --pid %u", getppid());
1307                 SMB_ASSERT(ret != -1);
1308
1309                 execlp("xterm", "xterm", "-e", cmd, (char *) NULL);
1310                 smb_panic("execlp() failed");
1311         }
1312 }
1313 #endif