source3/lib/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-2007
   6    Copyright (C) Simo Sorce 2001
   7    Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2003
   8    Copyright (C) James Peach 2006
   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
  26 extern char *global_clobber_region_function;
  27 extern unsigned int global_clobber_region_line;
  28
  29 /* Max allowable allococation - 256mb - 0x10000000 */
  30 #define MAX_ALLOC_SIZE (1024*1024*256)
  31
  32 #if (defined(HAVE_NETGROUP) && defined (WITH_AUTOMOUNT))
  33 #ifdef WITH_NISPLUS_HOME
  34 #ifdef BROKEN_NISPLUS_INCLUDE_FILES
  35 /*
  36  * The following lines are needed due to buggy include files
  37  * in Solaris 2.6 which define GROUP in both /usr/include/sys/acl.h and
  38  * also in /usr/include/rpcsvc/nis.h. The definitions conflict. JRA.
  39  * Also GROUP_OBJ is defined as 0x4 in /usr/include/sys/acl.h and as
  40  * an enum in /usr/include/rpcsvc/nis.h.
  41  */
  42
  43 #if defined(GROUP)
  44 #undef GROUP
  45 #endif
  46
  47 #if defined(GROUP_OBJ)
  48 #undef GROUP_OBJ
  49 #endif
  50
  51 #endif /* BROKEN_NISPLUS_INCLUDE_FILES */
  52
  53 #include <rpcsvc/nis.h>
  54
  55 #endif /* WITH_NISPLUS_HOME */
  56 #endif /* HAVE_NETGROUP && WITH_AUTOMOUNT */
  57
  58 enum protocol_types Protocol = PROTOCOL_COREPLUS;
  59
  60 /* this is used by the chaining code */
  61 int chain_size = 0;
  62
  63 static enum remote_arch_types ra_type = RA_UNKNOWN;
  64
  65 /***********************************************************************
  66  Definitions for all names.
  67 ***********************************************************************/
  68
  69 static char *smb_myname;
  70 static char *smb_myworkgroup;
  71 static char *smb_scope;
  72 static int smb_num_netbios_names;
  73 static char **smb_my_netbios_names;
  74
  75 /***********************************************************************
  76  Allocate and set myname. Ensure upper case.
  77 ***********************************************************************/
  78
  79 bool set_global_myname(const char *myname)
  80 {
  81         SAFE_FREE(smb_myname);
  82         smb_myname = SMB_STRDUP(myname);
  83         if (!smb_myname)
  84                 return False;
  85         strupper_m(smb_myname);
  86         return True;
  87 }
  88
  89 const char *global_myname(void)
  90 {
  91         return smb_myname;
  92 }
  93
  94 /***********************************************************************
  95  Allocate and set myworkgroup. Ensure upper case.
  96 ***********************************************************************/
  97
  98 bool set_global_myworkgroup(const char *myworkgroup)
  99 {
 100         SAFE_FREE(smb_myworkgroup);
 101         smb_myworkgroup = SMB_STRDUP(myworkgroup);
 102         if (!smb_myworkgroup)
 103                 return False;
 104         strupper_m(smb_myworkgroup);
 105         return True;
 106 }
 107
 108 const char *lp_workgroup(void)
 109 {
 110         return smb_myworkgroup;
 111 }
 112
 113 /***********************************************************************
 114  Allocate and set scope. Ensure upper case.
 115 ***********************************************************************/
 116
 117 bool set_global_scope(const char *scope)
 118 {
 119         SAFE_FREE(smb_scope);
 120         smb_scope = SMB_STRDUP(scope);
 121         if (!smb_scope)
 122                 return False;
 123         strupper_m(smb_scope);
 124         return True;
 125 }
 126
 127 /*********************************************************************
 128  Ensure scope is never null string.
 129 *********************************************************************/
 130
 131 const char *global_scope(void)
 132 {
 133         if (!smb_scope)
 134                 set_global_scope("");
 135         return smb_scope;
 136 }
 137
 138 static void free_netbios_names_array(void)
 139 {
 140         int i;
 141
 142         for (i = 0; i < smb_num_netbios_names; i++)
 143                 SAFE_FREE(smb_my_netbios_names[i]);
 144
 145         SAFE_FREE(smb_my_netbios_names);
 146         smb_num_netbios_names = 0;
 147 }
 148
 149 static bool allocate_my_netbios_names_array(size_t number)
 150 {
 151         free_netbios_names_array();
 152
 153         smb_num_netbios_names = number + 1;
 154         smb_my_netbios_names = SMB_MALLOC_ARRAY( char *, smb_num_netbios_names );
 155
 156         if (!smb_my_netbios_names)
 157                 return False;
 158
 159         memset(smb_my_netbios_names, '\0', sizeof(char *) * smb_num_netbios_names);
 160         return True;
 161 }
 162
 163 static bool set_my_netbios_names(const char *name, int i)
 164 {
 165         SAFE_FREE(smb_my_netbios_names[i]);
 166
 167         smb_my_netbios_names[i] = SMB_STRDUP(name);
 168         if (!smb_my_netbios_names[i])
 169                 return False;
 170         strupper_m(smb_my_netbios_names[i]);
 171         return True;
 172 }
 173
 174 /***********************************************************************
 175  Free memory allocated to global objects
 176 ***********************************************************************/
 177
 178 void gfree_names(void)
 179 {
 180         SAFE_FREE( smb_myname );
 181         SAFE_FREE( smb_myworkgroup );
 182         SAFE_FREE( smb_scope );
 183         free_netbios_names_array();
 184         free_local_machine_name();
 185 }
 186
 187 void gfree_all( void )
 188 {
 189         gfree_names();
 190         gfree_loadparm();
 191         gfree_case_tables();
 192         gfree_charcnv();
 193         gfree_interfaces();
 194         gfree_debugsyms();
 195 }
 196
 197 const char *my_netbios_names(int i)
 198 {
 199         return smb_my_netbios_names[i];
 200 }
 201
 202 bool set_netbios_aliases(const char **str_array)
 203 {
 204         size_t namecount;
 205
 206         /* Work out the max number of netbios aliases that we have */
 207         for( namecount=0; str_array && (str_array[namecount] != NULL); namecount++ )
 208                 ;
 209
 210         if ( global_myname() && *global_myname())
 211                 namecount++;
 212
 213         /* Allocate space for the netbios aliases */
 214         if (!allocate_my_netbios_names_array(namecount))
 215                 return False;
 216
 217         /* Use the global_myname string first */
 218         namecount=0;
 219         if ( global_myname() && *global_myname()) {
 220                 set_my_netbios_names( global_myname(), namecount );
 221                 namecount++;
 222         }
 223
 224         if (str_array) {
 225                 size_t i;
 226                 for ( i = 0; str_array[i] != NULL; i++) {
 227                         size_t n;
 228                         bool duplicate = False;
 229
 230                         /* Look for duplicates */
 231                         for( n=0; n<namecount; n++ ) {
 232                                 if( strequal( str_array[i], my_netbios_names(n) ) ) {
 233                                         duplicate = True;
 234                                         break;
 235                                 }
 236                         }
 237                         if (!duplicate) {
 238                                 if (!set_my_netbios_names(str_array[i], namecount))
 239                                         return False;
 240                                 namecount++;
 241                         }
 242                 }
 243         }
 244         return True;
 245 }
 246
 247 /****************************************************************************
 248   Common name initialization code.
 249 ****************************************************************************/
 250
 251 bool init_names(void)
 252 {
 253         int n;
 254
 255         if (global_myname() == NULL || *global_myname() == '\0') {
 256                 if (!set_global_myname(myhostname())) {
 257                         DEBUG( 0, ( "init_structs: malloc fail.\n" ) );
 258                         return False;
 259                 }
 260         }
 261
 262         if (!set_netbios_aliases(lp_netbios_aliases())) {
 263                 DEBUG( 0, ( "init_structs: malloc fail.\n" ) );
 264                 return False;
 265         }
 266
 267         set_local_machine_name(global_myname(),false);
 268
 269         DEBUG( 5, ("Netbios name list:-\n") );
 270         for( n=0; my_netbios_names(n); n++ ) {
 271                 DEBUGADD( 5, ("my_netbios_names[%d]=\"%s\"\n",
 272                                         n, my_netbios_names(n) ) );
 273         }
 274
 275         return( True );
 276 }
 277
 278 /**************************************************************************n
 279   Code to cope with username/password auth options from the commandline.
 280   Used mainly in client tools.
 281 ****************************************************************************/
 282
 283 struct user_auth_info *user_auth_info_init(TALLOC_CTX *mem_ctx)
 284 {
 285         struct user_auth_info *result;
 286
 287         result = TALLOC_ZERO_P(mem_ctx, struct user_auth_info);
 288         if (result == NULL) {
 289                 return NULL;
 290         }
 291
 292         result->signing_state = Undefined;
 293         return result;
 294 }
 295
 296 const char *get_cmdline_auth_info_username(struct user_auth_info *auth_info)
 297 {
 298         if (!auth_info->username) {
 299                 return "";
 300         }
 301         return auth_info->username;
 302 }
 303
 304 void set_cmdline_auth_info_username(struct user_auth_info *auth_info,
 305                                     const char *username)
 306 {
 307         TALLOC_FREE(auth_info->username);
 308         auth_info->username = talloc_strdup(auth_info, username);
 309         if (!auth_info->username) {
 310                 exit(ENOMEM);
 311         }
 312 }
 313
 314 const char *get_cmdline_auth_info_password(struct user_auth_info *auth_info)
 315 {
 316         if (!auth_info->password) {
 317                 return "";
 318         }
 319         return auth_info->password;
 320 }
 321
 322 void set_cmdline_auth_info_password(struct user_auth_info *auth_info,
 323                                     const char *password)
 324 {
 325         TALLOC_FREE(auth_info->password);
 326         auth_info->password = talloc_strdup(auth_info, password);
 327         if (!auth_info->password) {
 328                 exit(ENOMEM);
 329         }
 330         auth_info->got_pass = true;
 331 }
 332
 333 bool set_cmdline_auth_info_signing_state(struct user_auth_info *auth_info,
 334                                          const char *arg)
 335 {
 336         auth_info->signing_state = -1;
 337         if (strequal(arg, "off") || strequal(arg, "no") ||
 338                         strequal(arg, "false")) {
 339                 auth_info->signing_state = false;
 340         } else if (strequal(arg, "on") || strequal(arg, "yes") ||
 341                         strequal(arg, "true") || strequal(arg, "auto")) {
 342                 auth_info->signing_state = true;
 343         } else if (strequal(arg, "force") || strequal(arg, "required") ||
 344                         strequal(arg, "forced")) {
 345                 auth_info->signing_state = Required;
 346         } else {
 347                 return false;
 348         }
 349         return true;
 350 }
 351
 352 int get_cmdline_auth_info_signing_state(struct user_auth_info *auth_info)
 353 {
 354         return auth_info->signing_state;
 355 }
 356
 357 void set_cmdline_auth_info_use_kerberos(struct user_auth_info *auth_info,
 358                                         bool b)
 359 {
 360         auth_info->use_kerberos = b;
 361 }
 362
 363 bool get_cmdline_auth_info_use_kerberos(struct user_auth_info *auth_info)
 364 {
 365         return auth_info->use_kerberos;
 366 }
 367
 368 /* This should only be used by lib/popt_common.c JRA */
 369 void set_cmdline_auth_info_use_krb5_ticket(struct user_auth_info *auth_info)
 370 {
 371         auth_info->use_kerberos = true;
 372         auth_info->got_pass = true;
 373 }
 374
 375 /* This should only be used by lib/popt_common.c JRA */
 376 void set_cmdline_auth_info_smb_encrypt(struct user_auth_info *auth_info)
 377 {
 378         auth_info->smb_encrypt = true;
 379 }
 380
 381 void set_cmdline_auth_info_use_machine_account(struct user_auth_info *auth_info)
 382 {
 383         auth_info->use_machine_account = true;
 384 }
 385
 386 bool get_cmdline_auth_info_got_pass(struct user_auth_info *auth_info)
 387 {
 388         return auth_info->got_pass;
 389 }
 390
 391 bool get_cmdline_auth_info_smb_encrypt(struct user_auth_info *auth_info)
 392 {
 393         return auth_info->smb_encrypt;
 394 }
 395
 396 bool get_cmdline_auth_info_use_machine_account(struct user_auth_info *auth_info)
 397 {
 398         return auth_info->use_machine_account;
 399 }
 400
 401 struct user_auth_info *get_cmdline_auth_info_copy(TALLOC_CTX *mem_ctx,
 402                                                   struct user_auth_info *src)
 403 {
 404         struct user_auth_info *result;
 405
 406         result = user_auth_info_init(mem_ctx);
 407         if (result == NULL) {
 408                 return NULL;
 409         }
 410
 411         *result = *src;
 412
 413         result->username = talloc_strdup(
 414                 result, get_cmdline_auth_info_username(src));
 415         result->password = talloc_strdup(
 416                 result, get_cmdline_auth_info_password(src));
 417         if ((result->username == NULL) || (result->password == NULL)) {
 418                 TALLOC_FREE(result);
 419                 return NULL;
 420         }
 421
 422         return result;
 423 }
 424
 425 bool set_cmdline_auth_info_machine_account_creds(struct user_auth_info *auth_info)
 426 {
 427         char *pass = NULL;
 428         char *account = NULL;
 429
 430         if (!get_cmdline_auth_info_use_machine_account(auth_info)) {
 431                 return false;
 432         }
 433
 434         if (!secrets_init()) {
 435                 d_printf("ERROR: Unable to open secrets database\n");
 436                 return false;
 437         }
 438
 439         if (asprintf(&account, "%s$@%s", global_myname(), lp_realm()) < 0) {
 440                 return false;
 441         }
 442
 443         pass = secrets_fetch_machine_password(lp_workgroup(), NULL, NULL);
 444         if (!pass) {
 445                 d_printf("ERROR: Unable to fetch machine password for "
 446                         "%s in domain %s\n",
 447                         account, lp_workgroup());
 448                 SAFE_FREE(account);
 449                 return false;
 450         }
 451
 452         set_cmdline_auth_info_username(auth_info, account);
 453         set_cmdline_auth_info_password(auth_info, pass);
 454
 455         SAFE_FREE(account);
 456         SAFE_FREE(pass);
 457
 458         return true;
 459 }
 460
 461 /****************************************************************************
 462  Add a gid to an array of gids if it's not already there.
 463 ****************************************************************************/
 464
 465 bool add_gid_to_array_unique(TALLOC_CTX *mem_ctx, gid_t gid,
 466                              gid_t **gids, size_t *num_gids)
 467 {
 468         int i;
 469
 470         if ((*num_gids != 0) && (*gids == NULL)) {
 471                 /*
 472                  * A former call to this routine has failed to allocate memory
 473                  */
 474                 return False;
 475         }
 476
 477         for (i=0; i<*num_gids; i++) {
 478                 if ((*gids)[i] == gid) {
 479                         return True;
 480                 }
 481         }
 482
 483         *gids = TALLOC_REALLOC_ARRAY(mem_ctx, *gids, gid_t, *num_gids+1);
 484         if (*gids == NULL) {
 485                 *num_gids = 0;
 486                 return False;
 487         }
 488
 489         (*gids)[*num_gids] = gid;
 490         *num_gids += 1;
 491         return True;
 492 }
 493
 494 /*******************************************************************
 495  Check if a file exists - call vfs_file_exist for samba files.
 496 ********************************************************************/
 497
 498 bool file_exist_stat(const char *fname,SMB_STRUCT_STAT *sbuf)
 499 {
 500         SMB_STRUCT_STAT st;
 501         if (!sbuf)
 502                 sbuf = &st;
 503
 504         if (sys_stat(fname,sbuf) != 0)
 505                 return(False);
 506
 507         return((S_ISREG(sbuf->st_mode)) || (S_ISFIFO(sbuf->st_mode)));
 508 }
 509
 510 /*******************************************************************
 511  Check if a unix domain socket exists - call vfs_file_exist for samba files.
 512 ********************************************************************/
 513
 514 bool socket_exist(const char *fname)
 515 {
 516         SMB_STRUCT_STAT st;
 517         if (sys_stat(fname,&st) != 0)
 518                 return(False);
 519
 520         return S_ISSOCK(st.st_mode);
 521 }
 522
 523 /*******************************************************************
 524  Check if a directory exists.
 525 ********************************************************************/
 526
 527 bool directory_exist_stat(char *dname,SMB_STRUCT_STAT *st)
 528 {
 529         SMB_STRUCT_STAT st2;
 530         bool ret;
 531
 532         if (!st)
 533                 st = &st2;
 534
 535         if (sys_stat(dname,st) != 0)
 536                 return(False);
 537
 538         ret = S_ISDIR(st->st_mode);
 539         if(!ret)
 540                 errno = ENOTDIR;
 541         return ret;
 542 }
 543
 544 /*******************************************************************
 545  Returns the size in bytes of the named file.
 546 ********************************************************************/
 547
 548 SMB_OFF_T get_file_size(char *file_name)
 549 {
 550         SMB_STRUCT_STAT buf;
 551         buf.st_size = 0;
 552         if(sys_stat(file_name,&buf) != 0)
 553                 return (SMB_OFF_T)-1;
 554         return(buf.st_size);
 555 }
 556
 557 /*******************************************************************
 558  Return a string representing an attribute for a file.
 559 ********************************************************************/
 560
 561 char *attrib_string(uint16 mode)
 562 {
 563         fstring attrstr;
 564
 565         attrstr[0] = 0;
 566
 567         if (mode & aVOLID) fstrcat(attrstr,"V");
 568         if (mode & aDIR) fstrcat(attrstr,"D");
 569         if (mode & aARCH) fstrcat(attrstr,"A");
 570         if (mode & aHIDDEN) fstrcat(attrstr,"H");
 571         if (mode & aSYSTEM) fstrcat(attrstr,"S");
 572         if (mode & aRONLY) fstrcat(attrstr,"R");
 573
 574         return talloc_strdup(talloc_tos(), attrstr);
 575 }
 576
 577 /*******************************************************************
 578  Show a smb message structure.
 579 ********************************************************************/
 580
 581 void show_msg(char *buf)
 582 {
 583         int i;
 584         int bcc=0;
 585
 586         if (!DEBUGLVL(5))
 587                 return;
 588
 589         DEBUG(5,("size=%d\nsmb_com=0x%x\nsmb_rcls=%d\nsmb_reh=%d\nsmb_err=%d\nsmb_flg=%d\nsmb_flg2=%d\n",
 590                         smb_len(buf),
 591                         (int)CVAL(buf,smb_com),
 592                         (int)CVAL(buf,smb_rcls),
 593                         (int)CVAL(buf,smb_reh),
 594                         (int)SVAL(buf,smb_err),
 595                         (int)CVAL(buf,smb_flg),
 596                         (int)SVAL(buf,smb_flg2)));
 597         DEBUGADD(5,("smb_tid=%d\nsmb_pid=%d\nsmb_uid=%d\nsmb_mid=%d\n",
 598                         (int)SVAL(buf,smb_tid),
 599                         (int)SVAL(buf,smb_pid),
 600                         (int)SVAL(buf,smb_uid),
 601                         (int)SVAL(buf,smb_mid)));
 602         DEBUGADD(5,("smt_wct=%d\n",(int)CVAL(buf,smb_wct)));
 603
 604         for (i=0;i<(int)CVAL(buf,smb_wct);i++)
 605                 DEBUGADD(5,("smb_vwv[%2d]=%5d (0x%X)\n",i,
 606                         SVAL(buf,smb_vwv+2*i),SVAL(buf,smb_vwv+2*i)));
 607
 608         bcc = (int)SVAL(buf,smb_vwv+2*(CVAL(buf,smb_wct)));
 609
 610         DEBUGADD(5,("smb_bcc=%d\n",bcc));
 611
 612         if (DEBUGLEVEL < 10)
 613                 return;
 614
 615         if (DEBUGLEVEL < 50)
 616                 bcc = MIN(bcc, 512);
 617
 618         dump_data(10, (uint8 *)smb_buf(buf), bcc);
 619 }
 620
 621 /*******************************************************************
 622  Set the length and marker of an encrypted smb packet.
 623 ********************************************************************/
 624
 625 void smb_set_enclen(char *buf,int len,uint16 enc_ctx_num)
 626 {
 627         _smb_setlen(buf,len);
 628
 629         SCVAL(buf,4,0xFF);
 630         SCVAL(buf,5,'E');
 631         SSVAL(buf,6,enc_ctx_num);
 632 }
 633
 634 /*******************************************************************
 635  Set the length and marker of an smb packet.
 636 ********************************************************************/
 637
 638 void smb_setlen(char *buf,int len)
 639 {
 640         _smb_setlen(buf,len);
 641
 642         SCVAL(buf,4,0xFF);
 643         SCVAL(buf,5,'S');
 644         SCVAL(buf,6,'M');
 645         SCVAL(buf,7,'B');
 646 }
 647
 648 /*******************************************************************
 649  Setup only the byte count for a smb message.
 650 ********************************************************************/
 651
 652 int set_message_bcc(char *buf,int num_bytes)
 653 {
 654         int num_words = CVAL(buf,smb_wct);
 655         SSVAL(buf,smb_vwv + num_words*SIZEOFWORD,num_bytes);
 656         _smb_setlen(buf,smb_size + num_words*2 + num_bytes - 4);
 657         return (smb_size + num_words*2 + num_bytes);
 658 }
 659
 660 /*******************************************************************
 661  Add a data blob to the end of a smb_buf, adjusting bcc and smb_len.
 662  Return the bytes added
 663 ********************************************************************/
 664
 665 ssize_t message_push_blob(uint8 **outbuf, DATA_BLOB blob)
 666 {
 667         size_t newlen = smb_len(*outbuf) + 4 + blob.length;
 668         uint8 *tmp;
 669
 670         if (!(tmp = TALLOC_REALLOC_ARRAY(NULL, *outbuf, uint8, newlen))) {
 671                 DEBUG(0, ("talloc failed\n"));
 672                 return -1;
 673         }
 674         *outbuf = tmp;
 675
 676         memcpy(tmp + smb_len(tmp) + 4, blob.data, blob.length);
 677         set_message_bcc((char *)tmp, smb_buflen(tmp) + blob.length);
 678         return blob.length;
 679 }
 680
 681 /*******************************************************************
 682  Reduce a file name, removing .. elements.
 683 ********************************************************************/
 684
 685 static char *dos_clean_name(TALLOC_CTX *ctx, const char *s)
 686 {
 687         char *p = NULL;
 688         char *str = NULL;
 689
 690         DEBUG(3,("dos_clean_name [%s]\n",s));
 691
 692         /* remove any double slashes */
 693         str = talloc_all_string_sub(ctx, s, "\\\\", "\\");
 694         if (!str) {
 695                 return NULL;
 696         }
 697
 698         /* Remove leading .\\ characters */
 699         if(strncmp(str, ".\\", 2) == 0) {
 700                 trim_string(str, ".\\", NULL);
 701                 if(*str == 0) {
 702                         str = talloc_strdup(ctx, ".\\");
 703                         if (!str) {
 704                                 return NULL;
 705                         }
 706                 }
 707         }
 708
 709         while ((p = strstr_m(str,"\\..\\")) != NULL) {
 710                 char *s1;
 711
 712                 *p = 0;
 713                 s1 = p+3;
 714
 715                 if ((p=strrchr_m(str,'\\')) != NULL) {
 716                         *p = 0;
 717                 } else {
 718                         *str = 0;
 719                 }
 720                 str = talloc_asprintf(ctx,
 721                                 "%s%s",
 722                                 str,
 723                                 s1);
 724                 if (!str) {
 725                         return NULL;
 726                 }
 727         }
 728
 729         trim_string(str,NULL,"\\..");
 730         return talloc_all_string_sub(ctx, str, "\\.\\", "\\");
 731 }
 732
 733 /*******************************************************************
 734  Reduce a file name, removing .. elements.
 735 ********************************************************************/
 736
 737 char *unix_clean_name(TALLOC_CTX *ctx, const char *s)
 738 {
 739         char *p = NULL;
 740         char *str = NULL;
 741
 742         DEBUG(3,("unix_clean_name [%s]\n",s));
 743
 744         /* remove any double slashes */
 745         str = talloc_all_string_sub(ctx, s, "//","/");
 746         if (!str) {
 747                 return NULL;
 748         }
 749
 750         /* Remove leading ./ characters */
 751         if(strncmp(str, "./", 2) == 0) {
 752                 trim_string(str, "./", NULL);
 753                 if(*str == 0) {
 754                         str = talloc_strdup(ctx, "./");
 755                         if (!str) {
 756                                 return NULL;
 757                         }
 758                 }
 759         }
 760
 761         while ((p = strstr_m(str,"/../")) != NULL) {
 762                 char *s1;
 763
 764                 *p = 0;
 765                 s1 = p+3;
 766
 767                 if ((p=strrchr_m(str,'/')) != NULL) {
 768                         *p = 0;
 769                 } else {
 770                         *str = 0;
 771                 }
 772                 str = talloc_asprintf(ctx,
 773                                 "%s%s",
 774                                 str,
 775                                 s1);
 776                 if (!str) {
 777                         return NULL;
 778                 }
 779         }
 780
 781         trim_string(str,NULL,"/..");
 782         return talloc_all_string_sub(ctx, str, "/./", "/");
 783 }
 784
 785 char *clean_name(TALLOC_CTX *ctx, const char *s)
 786 {
 787         char *str = dos_clean_name(ctx, s);
 788         if (!str) {
 789                 return NULL;
 790         }
 791         return unix_clean_name(ctx, str);
 792 }
 793
 794 /*******************************************************************
 795  Close the low 3 fd's and open dev/null in their place.
 796 ********************************************************************/
 797
 798 void close_low_fds(bool stderr_too)
 799 {
 800 #ifndef VALGRIND
 801         int fd;
 802         int i;
 803
 804         close(0);
 805         close(1);
 806
 807         if (stderr_too)
 808                 close(2);
 809
 810         /* try and use up these file descriptors, so silly
 811                 library routines writing to stdout etc won't cause havoc */
 812         for (i=0;i<3;i++) {
 813                 if (i == 2 && !stderr_too)
 814                         continue;
 815
 816                 fd = sys_open("/dev/null",O_RDWR,0);
 817                 if (fd < 0)
 818                         fd = sys_open("/dev/null",O_WRONLY,0);
 819                 if (fd < 0) {
 820                         DEBUG(0,("Can't open /dev/null\n"));
 821                         return;
 822                 }
 823                 if (fd != i) {
 824                         DEBUG(0,("Didn't get file descriptor %d\n",i));
 825                         return;
 826                 }
 827         }
 828 #endif
 829 }
 830
 831 /*******************************************************************
 832  Write data into an fd at a given offset. Ignore seek errors.
 833 ********************************************************************/
 834
 835 ssize_t write_data_at_offset(int fd, const char *buffer, size_t N, SMB_OFF_T pos)
 836 {
 837         size_t total=0;
 838         ssize_t ret;
 839
 840         if (pos == (SMB_OFF_T)-1) {
 841                 return write_data(fd, buffer, N);
 842         }
 843 #if defined(HAVE_PWRITE) || defined(HAVE_PRWITE64)
 844         while (total < N) {
 845                 ret = sys_pwrite(fd,buffer + total,N - total, pos);
 846                 if (ret == -1 && errno == ESPIPE) {
 847                         return write_data(fd, buffer + total,N - total);
 848                 }
 849                 if (ret == -1) {
 850                         DEBUG(0,("write_data_at_offset: write failure. Error = %s\n", strerror(errno) ));
 851                         return -1;
 852                 }
 853                 if (ret == 0) {
 854                         return total;
 855                 }
 856                 total += ret;
 857                 pos += ret;
 858         }
 859         return (ssize_t)total;
 860 #else
 861         /* Use lseek and write_data. */
 862         if (sys_lseek(fd, pos, SEEK_SET) == -1) {
 863                 if (errno != ESPIPE) {
 864                         return -1;
 865                 }
 866         }
 867         return write_data(fd, buffer, N);
 868 #endif
 869 }
 870
 871 /*******************************************************************
 872  Sleep for a specified number of milliseconds.
 873 ********************************************************************/
 874
 875 void smb_msleep(unsigned int t)
 876 {
 877 #if defined(HAVE_NANOSLEEP)
 878         struct timespec tval;
 879         int ret;
 880
 881         tval.tv_sec = t/1000;
 882         tval.tv_nsec = 1000000*(t%1000);
 883
 884         do {
 885                 errno = 0;
 886                 ret = nanosleep(&tval, &tval);
 887         } while (ret < 0 && errno == EINTR && (tval.tv_sec > 0 || tval.tv_nsec > 0));
 888 #else
 889         unsigned int tdiff=0;
 890         struct timeval tval,t1,t2;
 891         fd_set fds;
 892
 893         GetTimeOfDay(&t1);
 894         t2 = t1;
 895
 896         while (tdiff < t) {
 897                 tval.tv_sec = (t-tdiff)/1000;
 898                 tval.tv_usec = 1000*((t-tdiff)%1000);
 899
 900                 /* Never wait for more than 1 sec. */
 901                 if (tval.tv_sec > 1) {
 902                         tval.tv_sec = 1;
 903                         tval.tv_usec = 0;
 904                 }
 905
 906                 FD_ZERO(&fds);
 907                 errno = 0;
 908                 sys_select_intr(0,&fds,NULL,NULL,&tval);
 909
 910                 GetTimeOfDay(&t2);
 911                 if (t2.tv_sec < t1.tv_sec) {
 912                         /* Someone adjusted time... */
 913                         t1 = t2;
 914                 }
 915
 916                 tdiff = TvalDiff(&t1,&t2);
 917         }
 918 #endif
 919 }
 920
 921 /****************************************************************************
 922  Become a daemon, discarding the controlling terminal.
 923 ****************************************************************************/
 924
 925 void become_daemon(bool Fork, bool no_process_group)
 926 {
 927         if (Fork) {
 928                 if (sys_fork()) {
 929                         _exit(0);
 930                 }
 931         }
 932
 933   /* detach from the terminal */
 934 #ifdef HAVE_SETSID
 935         if (!no_process_group) setsid();
 936 #elif defined(TIOCNOTTY)
 937         if (!no_process_group) {
 938                 int i = sys_open("/dev/tty", O_RDWR, 0);
 939                 if (i != -1) {
 940                         ioctl(i, (int) TIOCNOTTY, (char *)0);
 941                         close(i);
 942                 }
 943         }
 944 #endif /* HAVE_SETSID */
 945
 946         /* Close fd's 0,1,2. Needed if started by rsh */
 947         close_low_fds(False);  /* Don't close stderr, let the debug system
 948                                   attach it to the logfile */
 949 }
 950
 951 bool reinit_after_fork(struct messaging_context *msg_ctx,
 952                        struct event_context *ev_ctx,
 953                        bool parent_longlived)
 954 {
 955         NTSTATUS status;
 956
 957         /* Reset the state of the random
 958          * number generation system, so
 959          * children do not get the same random
 960          * numbers as each other */
 961         set_need_random_reseed();
 962
 963         /* tdb needs special fork handling */
 964         if (tdb_reopen_all(parent_longlived ? 1 : 0) == -1) {
 965                 DEBUG(0,("tdb_reopen_all failed.\n"));
 966                 return false;
 967         }
 968
 969         if (ev_ctx) {
 970                 event_context_reinit(ev_ctx);
 971         }
 972
 973         if (msg_ctx) {
 974                 /*
 975                  * For clustering, we need to re-init our ctdbd connection after the
 976                  * fork
 977                  */
 978                 status = messaging_reinit(msg_ctx);
 979                 if (!NT_STATUS_IS_OK(status)) {
 980                         DEBUG(0,("messaging_reinit() failed: %s\n",
 981                                  nt_errstr(status)));
 982                         return false;
 983                 }
 984         }
 985
 986         return true;
 987 }
 988
 989 /****************************************************************************
 990  Put up a yes/no prompt.
 991 ****************************************************************************/
 992
 993 bool yesno(const char *p)
 994 {
 995         char ans[20];
 996         printf("%s",p);
 997
 998         if (!fgets(ans,sizeof(ans)-1,stdin))
 999                 return(False);
1000
1001         if (*ans == 'y' || *ans == 'Y')
1002                 return(True);
1003
1004         return(False);
1005 }
1006
1007 #if defined(PARANOID_MALLOC_CHECKER)
1008
1009 /****************************************************************************
1010  Internal malloc wrapper. Externally visible.
1011 ****************************************************************************/
1012
1013 void *malloc_(size_t size)
1014 {
1015         if (size == 0) {
1016                 return NULL;
1017         }
1018 #undef malloc
1019         return malloc(size);
1020 #define malloc(s) __ERROR_DONT_USE_MALLOC_DIRECTLY
1021 }
1022
1023 /****************************************************************************
1024  Internal calloc wrapper. Not externally visible.
1025 ****************************************************************************/
1026
1027 static void *calloc_(size_t count, size_t size)
1028 {
1029         if (size == 0 || count == 0) {
1030                 return NULL;
1031         }
1032 #undef calloc
1033         return calloc(count, size);
1034 #define calloc(n,s) __ERROR_DONT_USE_CALLOC_DIRECTLY
1035 }
1036
1037 /****************************************************************************
1038  Internal realloc wrapper. Not externally visible.
1039 ****************************************************************************/
1040
1041 static void *realloc_(void *ptr, size_t size)
1042 {
1043 #undef realloc
1044         return realloc(ptr, size);
1045 #define realloc(p,s) __ERROR_DONT_USE_RELLOC_DIRECTLY
1046 }
1047
1048 #endif /* PARANOID_MALLOC_CHECKER */
1049
1050 /****************************************************************************
1051  Type-safe memalign
1052 ****************************************************************************/
1053
1054 void *memalign_array(size_t el_size, size_t align, unsigned int count)
1055 {
1056         if (count >= MAX_ALLOC_SIZE/el_size) {
1057                 return NULL;
1058         }
1059
1060         return sys_memalign(align, el_size*count);
1061 }
1062
1063 /****************************************************************************
1064  Type-safe calloc.
1065 ****************************************************************************/
1066
1067 void *calloc_array(size_t size, size_t nmemb)
1068 {
1069         if (nmemb >= MAX_ALLOC_SIZE/size) {
1070                 return NULL;
1071         }
1072         if (size == 0 || nmemb == 0) {
1073                 return NULL;
1074         }
1075 #if defined(PARANOID_MALLOC_CHECKER)
1076         return calloc_(nmemb, size);
1077 #else
1078         return calloc(nmemb, size);
1079 #endif
1080 }
1081
1082 /****************************************************************************
1083  Expand a pointer to be a particular size.
1084  Note that this version of Realloc has an extra parameter that decides
1085  whether to free the passed in storage on allocation failure or if the
1086  new size is zero.
1087
1088  This is designed for use in the typical idiom of :
1089
1090  p = SMB_REALLOC(p, size)
1091  if (!p) {
1092     return error;
1093  }
1094
1095  and not to have to keep track of the old 'p' contents to free later, nor
1096  to worry if the size parameter was zero. In the case where NULL is returned
1097  we guarentee that p has been freed.
1098
1099  If free later semantics are desired, then pass 'free_old_on_error' as False which
1100  guarentees that the old contents are not freed on error, even if size == 0. To use
1101  this idiom use :
1102
1103  tmp = SMB_REALLOC_KEEP_OLD_ON_ERROR(p, size);
1104  if (!tmp) {
1105     SAFE_FREE(p);
1106     return error;
1107  } else {
1108     p = tmp;
1109  }
1110
1111  Changes were instigated by Coverity error checking. JRA.
1112 ****************************************************************************/
1113
1114 void *Realloc(void *p, size_t size, bool free_old_on_error)
1115 {
1116         void *ret=NULL;
1117
1118         if (size == 0) {
1119                 if (free_old_on_error) {
1120                         SAFE_FREE(p);
1121                 }
1122                 DEBUG(2,("Realloc asked for 0 bytes\n"));
1123                 return NULL;
1124         }
1125
1126 #if defined(PARANOID_MALLOC_CHECKER)
1127         if (!p) {
1128                 ret = (void *)malloc_(size);
1129         } else {
1130                 ret = (void *)realloc_(p,size);
1131         }
1132 #else
1133         if (!p) {
1134                 ret = (void *)malloc(size);
1135         } else {
1136                 ret = (void *)realloc(p,size);
1137         }
1138 #endif
1139
1140         if (!ret) {
1141                 if (free_old_on_error && p) {
1142                         SAFE_FREE(p);
1143                 }
1144                 DEBUG(0,("Memory allocation error: failed to expand to %d bytes\n",(int)size));
1145         }
1146
1147         return(ret);
1148 }
1149
1150 /****************************************************************************
1151  (Hopefully) efficient array append.
1152 ****************************************************************************/
1153
1154 void add_to_large_array(TALLOC_CTX *mem_ctx, size_t element_size,
1155                         void *element, void *_array, uint32 *num_elements,
1156                         ssize_t *array_size)
1157 {
1158         void **array = (void **)_array;
1159
1160         if (*array_size < 0) {
1161                 return;
1162         }
1163
1164         if (*array == NULL) {
1165                 if (*array_size == 0) {
1166                         *array_size = 128;
1167                 }
1168
1169                 if (*array_size >= MAX_ALLOC_SIZE/element_size) {
1170                         goto error;
1171                 }
1172
1173                 *array = TALLOC(mem_ctx, element_size * (*array_size));
1174                 if (*array == NULL) {
1175                         goto error;
1176                 }
1177         }
1178
1179         if (*num_elements == *array_size) {
1180                 *array_size *= 2;
1181
1182                 if (*array_size >= MAX_ALLOC_SIZE/element_size) {
1183                         goto error;
1184                 }
1185
1186                 *array = TALLOC_REALLOC(mem_ctx, *array,
1187                                         element_size * (*array_size));
1188
1189                 if (*array == NULL) {
1190                         goto error;
1191                 }
1192         }
1193
1194         memcpy((char *)(*array) + element_size*(*num_elements),
1195                element, element_size);
1196         *num_elements += 1;
1197
1198         return;
1199
1200  error:
1201         *num_elements = 0;
1202         *array_size = -1;
1203 }
1204
1205 /****************************************************************************
1206  Get my own name and IP.
1207 ****************************************************************************/
1208
1209 char *talloc_get_myname(TALLOC_CTX *ctx)
1210 {
1211         char *p;
1212         char hostname[HOST_NAME_MAX];
1213
1214         *hostname = 0;
1215
1216         /* get my host name */
1217         if (gethostname(hostname, sizeof(hostname)) == -1) {
1218                 DEBUG(0,("gethostname failed\n"));
1219                 return False;
1220         }
1221
1222         /* Ensure null termination. */
1223         hostname[sizeof(hostname)-1] = '\0';
1224
1225         /* split off any parts after an initial . */
1226         p = strchr_m(hostname,'.');
1227         if (p) {
1228                 *p = 0;
1229         }
1230
1231         return talloc_strdup(ctx, hostname);
1232 }
1233
1234 /****************************************************************************
1235  Get my own domain name, or "" if we have none.
1236 ****************************************************************************/
1237
1238 char *get_mydnsdomname(TALLOC_CTX *ctx)
1239 {
1240         const char *domname;
1241         char *p;
1242
1243         domname = get_mydnsfullname();
1244         if (!domname) {
1245                 return NULL;
1246         }
1247
1248         p = strchr_m(domname, '.');
1249         if (p) {
1250                 p++;
1251                 return talloc_strdup(ctx, p);
1252         } else {
1253                 return talloc_strdup(ctx, "");
1254         }
1255 }
1256
1257 /****************************************************************************
1258  Interpret a protocol description string, with a default.
1259 ****************************************************************************/
1260
1261 int interpret_protocol(const char *str,int def)
1262 {
1263         if (strequal(str,"NT1"))
1264                 return(PROTOCOL_NT1);
1265         if (strequal(str,"LANMAN2"))
1266                 return(PROTOCOL_LANMAN2);
1267         if (strequal(str,"LANMAN1"))
1268                 return(PROTOCOL_LANMAN1);
1269         if (strequal(str,"CORE"))
1270                 return(PROTOCOL_CORE);
1271         if (strequal(str,"COREPLUS"))
1272                 return(PROTOCOL_COREPLUS);
1273         if (strequal(str,"CORE+"))
1274                 return(PROTOCOL_COREPLUS);
1275
1276         DEBUG(0,("Unrecognised protocol level %s\n",str));
1277
1278         return(def);
1279 }
1280
1281
1282 #if (defined(HAVE_NETGROUP) && defined(WITH_AUTOMOUNT))
1283 /******************************************************************
1284  Remove any mount options such as -rsize=2048,wsize=2048 etc.
1285  Based on a fix from <Thomas.Hepper@icem.de>.
1286  Returns a malloc'ed string.
1287 *******************************************************************/
1288
1289 static char *strip_mount_options(TALLOC_CTX *ctx, const char *str)
1290 {
1291         if (*str == '-') {
1292                 const char *p = str;
1293                 while(*p && !isspace(*p))
1294                         p++;
1295                 while(*p && isspace(*p))
1296                         p++;
1297                 if(*p) {
1298                         return talloc_strdup(ctx, p);
1299                 }
1300         }
1301         return NULL;
1302 }
1303
1304 /*******************************************************************
1305  Patch from jkf@soton.ac.uk
1306  Split Luke's automount_server into YP lookup and string splitter
1307  so can easily implement automount_path().
1308  Returns a malloc'ed string.
1309 *******************************************************************/
1310
1311 #ifdef WITH_NISPLUS_HOME
1312 char *automount_lookup(TALLOC_CTX *ctx, const char *user_name)
1313 {
1314         char *value = NULL;
1315
1316         char *nis_map = (char *)lp_nis_home_map_name();
1317
1318         char buffer[NIS_MAXATTRVAL + 1];
1319         nis_result *result;
1320         nis_object *object;
1321         entry_obj  *entry;
1322
1323         snprintf(buffer, sizeof(buffer), "[key=%s],%s", user_name, nis_map);
1324         DEBUG(5, ("NIS+ querystring: %s\n", buffer));
1325
1326         if (result = nis_list(buffer, FOLLOW_PATH|EXPAND_NAME|HARD_LOOKUP, NULL, NULL)) {
1327                 if (result->status != NIS_SUCCESS) {
1328                         DEBUG(3, ("NIS+ query failed: %s\n", nis_sperrno(result->status)));
1329                 } else {
1330                         object = result->objects.objects_val;
1331                         if (object->zo_data.zo_type == ENTRY_OBJ) {
1332                                 entry = &object->zo_data.objdata_u.en_data;
1333                                 DEBUG(5, ("NIS+ entry type: %s\n", entry->en_type));
1334                                 DEBUG(3, ("NIS+ result: %s\n", entry->en_cols.en_cols_val[1].ec_value.ec_value_val));
1335
1336                                 value = talloc_strdup(ctx,
1337                                                 entry->en_cols.en_cols_val[1].ec_value.ec_value_val);
1338                                 if (!value) {
1339                                         nis_freeresult(result);
1340                                         return NULL;
1341                                 }
1342                                 value = talloc_string_sub(ctx,
1343                                                 value,
1344                                                 "&",
1345                                                 user_name);
1346                         }
1347                 }
1348         }
1349         nis_freeresult(result);
1350
1351         if (value) {
1352                 value = strip_mount_options(ctx, value);
1353                 DEBUG(4, ("NIS+ Lookup: %s resulted in %s\n",
1354                                         user_name, value));
1355         }
1356         return value;
1357 }
1358 #else /* WITH_NISPLUS_HOME */
1359
1360 char *automount_lookup(TALLOC_CTX *ctx, const char *user_name)
1361 {
1362         char *value = NULL;
1363
1364         int nis_error;        /* returned by yp all functions */
1365         char *nis_result;     /* yp_match inits this */
1366         int nis_result_len;  /* and set this */
1367         char *nis_domain;     /* yp_get_default_domain inits this */
1368         char *nis_map = (char *)lp_nis_home_map_name();
1369
1370         if ((nis_error = yp_get_default_domain(&nis_domain)) != 0) {
1371                 DEBUG(3, ("YP Error: %s\n", yperr_string(nis_error)));
1372                 return NULL;
1373         }
1374
1375         DEBUG(5, ("NIS Domain: %s\n", nis_domain));
1376
1377         if ((nis_error = yp_match(nis_domain, nis_map, user_name,
1378                                         strlen(user_name), &nis_result,
1379                                         &nis_result_len)) == 0) {
1380                 value = talloc_strdup(ctx, nis_result);
1381                 if (!value) {
1382                         return NULL;
1383                 }
1384                 value = strip_mount_options(ctx, value);
1385         } else if(nis_error == YPERR_KEY) {
1386                 DEBUG(3, ("YP Key not found:  while looking up \"%s\" in map \"%s\"\n",
1387                                 user_name, nis_map));
1388                 DEBUG(3, ("using defaults for server and home directory\n"));
1389         } else {
1390                 DEBUG(3, ("YP Error: \"%s\" while looking up \"%s\" in map \"%s\"\n",
1391                                 yperr_string(nis_error), user_name, nis_map));
1392         }
1393
1394         if (value) {
1395                 DEBUG(4, ("YP Lookup: %s resulted in %s\n", user_name, value));
1396         }
1397         return value;
1398 }
1399 #endif /* WITH_NISPLUS_HOME */
1400 #endif
1401
1402 /****************************************************************************
1403  Check if a process exists. Does this work on all unixes?
1404 ****************************************************************************/
1405
1406 bool process_exists(const struct server_id pid)
1407 {
1408         if (procid_is_me(&pid)) {
1409                 return True;
1410         }
1411
1412         if (procid_is_local(&pid)) {
1413                 return (kill(pid.pid,0) == 0 || errno != ESRCH);
1414         }
1415
1416 #ifdef CLUSTER_SUPPORT
1417         return ctdbd_process_exists(messaging_ctdbd_connection(), pid.vnn,
1418                                     pid.pid);
1419 #else
1420         return False;
1421 #endif
1422 }
1423
1424 /*******************************************************************
1425  Convert a uid into a user name.
1426 ********************************************************************/
1427
1428 const char *uidtoname(uid_t uid)
1429 {
1430         TALLOC_CTX *ctx = talloc_tos();
1431         char *name = NULL;
1432         struct passwd *pass = NULL;
1433
1434         pass = getpwuid_alloc(ctx,uid);
1435         if (pass) {
1436                 name = talloc_strdup(ctx,pass->pw_name);
1437                 TALLOC_FREE(pass);
1438         } else {
1439                 name = talloc_asprintf(ctx,
1440                                 "%ld",
1441                                 (long int)uid);
1442         }
1443         return name;
1444 }
1445
1446 /*******************************************************************
1447  Convert a gid into a group name.
1448 ********************************************************************/
1449
1450 char *gidtoname(gid_t gid)
1451 {
1452         struct group *grp;
1453
1454         grp = getgrgid(gid);
1455         if (grp) {
1456                 return talloc_strdup(talloc_tos(), grp->gr_name);
1457         }
1458         else {
1459                 return talloc_asprintf(talloc_tos(),
1460                                         "%d",
1461                                         (int)gid);
1462         }
1463 }
1464
1465 /*******************************************************************
1466  Convert a user name into a uid.
1467 ********************************************************************/
1468
1469 uid_t nametouid(const char *name)
1470 {
1471         struct passwd *pass;
1472         char *p;
1473         uid_t u;
1474
1475         pass = getpwnam_alloc(talloc_autofree_context(), name);
1476         if (pass) {
1477                 u = pass->pw_uid;
1478                 TALLOC_FREE(pass);
1479                 return u;
1480         }
1481
1482         u = (uid_t)strtol(name, &p, 0);
1483         if ((p != name) && (*p == '\0'))
1484                 return u;
1485
1486         return (uid_t)-1;
1487 }
1488
1489 /*******************************************************************
1490  Convert a name to a gid_t if possible. Return -1 if not a group.
1491 ********************************************************************/
1492
1493 gid_t nametogid(const char *name)
1494 {
1495         struct group *grp;
1496         char *p;
1497         gid_t g;
1498
1499         g = (gid_t)strtol(name, &p, 0);
1500         if ((p != name) && (*p == '\0'))
1501                 return g;
1502
1503         grp = sys_getgrnam(name);
1504         if (grp)
1505                 return(grp->gr_gid);
1506         return (gid_t)-1;
1507 }
1508
1509 /*******************************************************************
1510  Something really nasty happened - panic !
1511 ********************************************************************/
1512
1513 void smb_panic(const char *const why)
1514 {
1515         char *cmd;
1516         int result;
1517
1518 #ifdef DEVELOPER
1519         {
1520
1521                 if (global_clobber_region_function) {
1522                         DEBUG(0,("smb_panic: clobber_region() last called from [%s(%u)]\n",
1523                                          global_clobber_region_function,
1524                                          global_clobber_region_line));
1525                 }
1526         }
1527 #endif
1528
1529         DEBUG(0,("PANIC (pid %llu): %s\n",
1530                     (unsigned long long)sys_getpid(), why));
1531         log_stack_trace();
1532
1533         cmd = lp_panic_action();
1534         if (cmd && *cmd) {
1535                 DEBUG(0, ("smb_panic(): calling panic action [%s]\n", cmd));
1536                 result = system(cmd);
1537
1538                 if (result == -1)
1539                         DEBUG(0, ("smb_panic(): fork failed in panic action: %s\n",
1540                                           strerror(errno)));
1541                 else
1542                         DEBUG(0, ("smb_panic(): action returned status %d\n",
1543                                           WEXITSTATUS(result)));
1544         }
1545
1546         dump_core();
1547 }
1548
1549 /*******************************************************************
1550  Print a backtrace of the stack to the debug log. This function
1551  DELIBERATELY LEAKS MEMORY. The expectation is that you should
1552  exit shortly after calling it.
1553 ********************************************************************/
1554
1555 #ifdef HAVE_LIBUNWIND_H
1556 #include <libunwind.h>
1557 #endif
1558
1559 #ifdef HAVE_EXECINFO_H
1560 #include <execinfo.h>
1561 #endif
1562
1563 #ifdef HAVE_LIBEXC_H
1564 #include <libexc.h>
1565 #endif
1566
1567 void log_stack_trace(void)
1568 {
1569 #ifdef HAVE_LIBUNWIND
1570         /* Try to use libunwind before any other technique since on ia64
1571          * libunwind correctly walks the stack in more circumstances than
1572          * backtrace.
1573          */
1574         unw_cursor_t cursor;
1575         unw_context_t uc;
1576         unsigned i = 0;
1577
1578         char procname[256];
1579         unw_word_t ip, sp, off;
1580
1581         procname[sizeof(procname) - 1] = '\0';
1582
1583         if (unw_getcontext(&uc) != 0) {
1584                 goto libunwind_failed;
1585         }
1586
1587         if (unw_init_local(&cursor, &uc) != 0) {
1588                 goto libunwind_failed;
1589         }
1590
1591         DEBUG(0, ("BACKTRACE:\n"));
1592
1593         do {
1594             ip = sp = 0;
1595             unw_get_reg(&cursor, UNW_REG_IP, &ip);
1596             unw_get_reg(&cursor, UNW_REG_SP, &sp);
1597
1598             switch (unw_get_proc_name(&cursor,
1599                         procname, sizeof(procname) - 1, &off) ) {
1600             case 0:
1601                     /* Name found. */
1602             case -UNW_ENOMEM:
1603                     /* Name truncated. */
1604                     DEBUGADD(0, (" #%u %s + %#llx [ip=%#llx] [sp=%#llx]\n",
1605                             i, procname, (long long)off,
1606                             (long long)ip, (long long) sp));
1607                     break;
1608             default:
1609             /* case -UNW_ENOINFO: */
1610             /* case -UNW_EUNSPEC: */
1611                     /* No symbol name found. */
1612                     DEBUGADD(0, (" #%u %s [ip=%#llx] [sp=%#llx]\n",
1613                             i, "<unknown symbol>",
1614                             (long long)ip, (long long) sp));
1615             }
1616             ++i;
1617         } while (unw_step(&cursor) > 0);
1618
1619         return;
1620
1621 libunwind_failed:
1622         DEBUG(0, ("unable to produce a stack trace with libunwind\n"));
1623
1624 #elif HAVE_BACKTRACE_SYMBOLS
1625         void *backtrace_stack[BACKTRACE_STACK_SIZE];
1626         size_t backtrace_size;
1627         char **backtrace_strings;
1628
1629         /* get the backtrace (stack frames) */
1630         backtrace_size = backtrace(backtrace_stack,BACKTRACE_STACK_SIZE);
1631         backtrace_strings = backtrace_symbols(backtrace_stack, backtrace_size);
1632
1633         DEBUG(0, ("BACKTRACE: %lu stack frames:\n",
1634                   (unsigned long)backtrace_size));
1635
1636         if (backtrace_strings) {
1637                 int i;
1638
1639                 for (i = 0; i < backtrace_size; i++)
1640                         DEBUGADD(0, (" #%u %s\n", i, backtrace_strings[i]));
1641
1642                 /* Leak the backtrace_strings, rather than risk what free() might do */
1643         }
1644
1645 #elif HAVE_LIBEXC
1646
1647         /* The IRIX libexc library provides an API for unwinding the stack. See
1648          * libexc(3) for details. Apparantly trace_back_stack leaks memory, but
1649          * since we are about to abort anyway, it hardly matters.
1650          */
1651
1652 #define NAMESIZE 32 /* Arbitrary */
1653
1654         __uint64_t      addrs[BACKTRACE_STACK_SIZE];
1655         char *          names[BACKTRACE_STACK_SIZE];
1656         char            namebuf[BACKTRACE_STACK_SIZE * NAMESIZE];
1657
1658         int             i;
1659         int             levels;
1660
1661         ZERO_ARRAY(addrs);
1662         ZERO_ARRAY(names);
1663         ZERO_ARRAY(namebuf);
1664
1665         /* We need to be root so we can open our /proc entry to walk
1666          * our stack. It also helps when we want to dump core.
1667          */
1668         become_root();
1669
1670         for (i = 0; i < BACKTRACE_STACK_SIZE; i++) {
1671                 names[i] = namebuf + (i * NAMESIZE);
1672         }
1673
1674         levels = trace_back_stack(0, addrs, names,
1675                         BACKTRACE_STACK_SIZE, NAMESIZE - 1);
1676
1677         DEBUG(0, ("BACKTRACE: %d stack frames:\n", levels));
1678         for (i = 0; i < levels; i++) {
1679                 DEBUGADD(0, (" #%d 0x%llx %s\n", i, addrs[i], names[i]));
1680         }
1681 #undef NAMESIZE
1682
1683 #else
1684         DEBUG(0, ("unable to produce a stack trace on this platform\n"));
1685 #endif
1686 }
1687
1688 /*******************************************************************
1689   A readdir wrapper which just returns the file name.
1690  ********************************************************************/
1691
1692 const char *readdirname(SMB_STRUCT_DIR *p)
1693 {
1694         SMB_STRUCT_DIRENT *ptr;
1695         char *dname;
1696
1697         if (!p)
1698                 return(NULL);
1699
1700         ptr = (SMB_STRUCT_DIRENT *)sys_readdir(p);
1701         if (!ptr)
1702                 return(NULL);
1703
1704         dname = ptr->d_name;
1705
1706 #ifdef NEXT2
1707         if (telldir(p) < 0)
1708                 return(NULL);
1709 #endif
1710
1711 #ifdef HAVE_BROKEN_READDIR_NAME
1712         /* using /usr/ucb/cc is BAD */
1713         dname = dname - 2;
1714 #endif
1715
1716         return talloc_strdup(talloc_tos(), dname);
1717 }
1718
1719 /*******************************************************************
1720  Utility function used to decide if the last component
1721  of a path matches a (possibly wildcarded) entry in a namelist.
1722 ********************************************************************/
1723
1724 bool is_in_path(const char *name, name_compare_entry *namelist, bool case_sensitive)
1725 {
1726         const char *last_component;
1727
1728         /* if we have no list it's obviously not in the path */
1729         if((namelist == NULL ) || ((namelist != NULL) && (namelist[0].name == NULL))) {
1730                 return False;
1731         }
1732
1733         DEBUG(8, ("is_in_path: %s\n", name));
1734
1735         /* Get the last component of the unix name. */
1736         last_component = strrchr_m(name, '/');
1737         if (!last_component) {
1738                 last_component = name;
1739         } else {
1740                 last_component++; /* Go past '/' */
1741         }
1742
1743         for(; namelist->name != NULL; namelist++) {
1744                 if(namelist->is_wild) {
1745                         if (mask_match(last_component, namelist->name, case_sensitive)) {
1746                                 DEBUG(8,("is_in_path: mask match succeeded\n"));
1747                                 return True;
1748                         }
1749                 } else {
1750                         if((case_sensitive && (strcmp(last_component, namelist->name) == 0))||
1751                                                 (!case_sensitive && (StrCaseCmp(last_component, namelist->name) == 0))) {
1752                                 DEBUG(8,("is_in_path: match succeeded\n"));
1753                                 return True;
1754                         }
1755                 }
1756         }
1757         DEBUG(8,("is_in_path: match not found\n"));
1758         return False;
1759 }
1760
1761 /*******************************************************************
1762  Strip a '/' separated list into an array of
1763  name_compare_enties structures suitable for
1764  passing to is_in_path(). We do this for
1765  speed so we can pre-parse all the names in the list
1766  and don't do it for each call to is_in_path().
1767  namelist is modified here and is assumed to be
1768  a copy owned by the caller.
1769  We also check if the entry contains a wildcard to
1770  remove a potentially expensive call to mask_match
1771  if possible.
1772 ********************************************************************/
1773
1774 void set_namearray(name_compare_entry **ppname_array, const char *namelist)
1775 {
1776         char *name_end;
1777         const char *nameptr = namelist;
1778         int num_entries = 0;
1779         int i;
1780
1781         (*ppname_array) = NULL;
1782
1783         if((nameptr == NULL ) || ((nameptr != NULL) && (*nameptr == '\0')))
1784                 return;
1785
1786         /* We need to make two passes over the string. The
1787                 first to count the number of elements, the second
1788                 to split it.
1789         */
1790
1791         while(*nameptr) {
1792                 if ( *nameptr == '/' ) {
1793                         /* cope with multiple (useless) /s) */
1794                         nameptr++;
1795                         continue;
1796                 }
1797                 /* find the next / */
1798                 name_end = strchr_m(nameptr, '/');
1799
1800                 /* oops - the last check for a / didn't find one. */
1801                 if (name_end == NULL)
1802                         break;
1803
1804                 /* next segment please */
1805                 nameptr = name_end + 1;
1806                 num_entries++;
1807         }
1808
1809         if(num_entries == 0)
1810                 return;
1811
1812         if(( (*ppname_array) = SMB_MALLOC_ARRAY(name_compare_entry, num_entries + 1)) == NULL) {
1813                 DEBUG(0,("set_namearray: malloc fail\n"));
1814                 return;
1815         }
1816
1817         /* Now copy out the names */
1818         nameptr = namelist;
1819         i = 0;
1820         while(*nameptr) {
1821                 if ( *nameptr == '/' ) {
1822                         /* cope with multiple (useless) /s) */
1823                         nameptr++;
1824                         continue;
1825                 }
1826                 /* find the next / */
1827                 if ((name_end = strchr_m(nameptr, '/')) != NULL)
1828                         *name_end = 0;
1829
1830                 /* oops - the last check for a / didn't find one. */
1831                 if(name_end == NULL)
1832                         break;
1833
1834                 (*ppname_array)[i].is_wild = ms_has_wild(nameptr);
1835                 if(((*ppname_array)[i].name = SMB_STRDUP(nameptr)) == NULL) {
1836                         DEBUG(0,("set_namearray: malloc fail (1)\n"));
1837                         return;
1838                 }
1839
1840                 /* next segment please */
1841                 nameptr = name_end + 1;
1842                 i++;
1843         }
1844
1845         (*ppname_array)[i].name = NULL;
1846
1847         return;
1848 }
1849
1850 /****************************************************************************
1851  Routine to free a namearray.
1852 ****************************************************************************/
1853
1854 void free_namearray(name_compare_entry *name_array)
1855 {
1856         int i;
1857
1858         if(name_array == NULL)
1859                 return;
1860
1861         for(i=0; name_array[i].name!=NULL; i++)
1862                 SAFE_FREE(name_array[i].name);
1863         SAFE_FREE(name_array);
1864 }
1865
1866 #undef DBGC_CLASS
1867 #define DBGC_CLASS DBGC_LOCKING
1868
1869 /****************************************************************************
1870  Simple routine to query existing file locks. Cruft in NFS and 64->32 bit mapping
1871  is dealt with in posix.c
1872  Returns True if we have information regarding this lock region (and returns
1873  F_UNLCK in *ptype if the region is unlocked). False if the call failed.
1874 ****************************************************************************/
1875
1876 bool fcntl_getlock(int fd, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype, pid_t *ppid)
1877 {
1878         SMB_STRUCT_FLOCK lock;
1879         int ret;
1880
1881         DEBUG(8,("fcntl_getlock fd=%d offset=%.0f count=%.0f type=%d\n",
1882                     fd,(double)*poffset,(double)*pcount,*ptype));
1883
1884         lock.l_type = *ptype;
1885         lock.l_whence = SEEK_SET;
1886         lock.l_start = *poffset;
1887         lock.l_len = *pcount;
1888         lock.l_pid = 0;
1889
1890         ret = sys_fcntl_ptr(fd,SMB_F_GETLK,&lock);
1891
1892         if (ret == -1) {
1893                 int sav = errno;
1894                 DEBUG(3,("fcntl_getlock: lock request failed at offset %.0f count %.0f type %d (%s)\n",
1895                         (double)*poffset,(double)*pcount,*ptype,strerror(errno)));
1896                 errno = sav;
1897                 return False;
1898         }
1899
1900         *ptype = lock.l_type;
1901         *poffset = lock.l_start;
1902         *pcount = lock.l_len;
1903         *ppid = lock.l_pid;
1904
1905         DEBUG(3,("fcntl_getlock: fd %d is returned info %d pid %u\n",
1906                         fd, (int)lock.l_type, (unsigned int)lock.l_pid));
1907         return True;
1908 }
1909
1910 #undef DBGC_CLASS
1911 #define DBGC_CLASS DBGC_ALL
1912
1913 /*******************************************************************
1914  Is the name specified one of my netbios names.
1915  Returns true if it is equal, false otherwise.
1916 ********************************************************************/
1917
1918 bool is_myname(const char *s)
1919 {
1920         int n;
1921         bool ret = False;
1922
1923         for (n=0; my_netbios_names(n); n++) {
1924                 if (strequal(my_netbios_names(n), s)) {
1925                         ret=True;
1926                         break;
1927                 }
1928         }
1929         DEBUG(8, ("is_myname(\"%s\") returns %d\n", s, ret));
1930         return(ret);
1931 }
1932
1933 /*******************************************************************
1934  Is the name specified our workgroup/domain.
1935  Returns true if it is equal, false otherwise.
1936 ********************************************************************/
1937
1938 bool is_myworkgroup(const char *s)
1939 {
1940         bool ret = False;
1941
1942         if (strequal(s, lp_workgroup())) {
1943                 ret=True;
1944         }
1945
1946         DEBUG(8, ("is_myworkgroup(\"%s\") returns %d\n", s, ret));
1947         return(ret);
1948 }
1949
1950 /*******************************************************************
1951  we distinguish between 2K and XP by the "Native Lan Manager" string
1952    WinXP => "Windows 2002 5.1"
1953    WinXP 64bit => "Windows XP 5.2"
1954    Win2k => "Windows 2000 5.0"
1955    NT4   => "Windows NT 4.0"
1956    Win9x => "Windows 4.0"
1957  Windows 2003 doesn't set the native lan manager string but
1958  they do set the domain to "Windows 2003 5.2" (probably a bug).
1959 ********************************************************************/
1960
1961 void ra_lanman_string( const char *native_lanman )
1962 {
1963         if ( strcmp( native_lanman, "Windows 2002 5.1" ) == 0 )
1964                 set_remote_arch( RA_WINXP );
1965         else if ( strcmp( native_lanman, "Windows XP 5.2" ) == 0 )
1966                 set_remote_arch( RA_WINXP64 );
1967         else if ( strcmp( native_lanman, "Windows Server 2003 5.2" ) == 0 )
1968                 set_remote_arch( RA_WIN2K3 );
1969 }
1970
1971 static const char *remote_arch_str;
1972
1973 const char *get_remote_arch_str(void)
1974 {
1975         if (!remote_arch_str) {
1976                 return "UNKNOWN";
1977         }
1978         return remote_arch_str;
1979 }
1980
1981 /*******************************************************************
1982  Set the horrid remote_arch string based on an enum.
1983 ********************************************************************/
1984
1985 void set_remote_arch(enum remote_arch_types type)
1986 {
1987         ra_type = type;
1988         switch( type ) {
1989         case RA_WFWG:
1990                 remote_arch_str = "WfWg";
1991                 break;
1992         case RA_OS2:
1993                 remote_arch_str = "OS2";
1994                 break;
1995         case RA_WIN95:
1996                 remote_arch_str = "Win95";
1997                 break;
1998         case RA_WINNT:
1999                 remote_arch_str = "WinNT";
2000                 break;
2001         case RA_WIN2K:
2002                 remote_arch_str = "Win2K";
2003                 break;
2004         case RA_WINXP:
2005                 remote_arch_str = "WinXP";
2006                 break;
2007         case RA_WINXP64:
2008                 remote_arch_str = "WinXP64";
2009                 break;
2010         case RA_WIN2K3:
2011                 remote_arch_str = "Win2K3";
2012                 break;
2013         case RA_VISTA:
2014                 remote_arch_str = "Vista";
2015                 break;
2016         case RA_SAMBA:
2017                 remote_arch_str = "Samba";
2018                 break;
2019         case RA_CIFSFS:
2020                 remote_arch_str = "CIFSFS";
2021                 break;
2022         default:
2023                 ra_type = RA_UNKNOWN;
2024                 remote_arch_str = "UNKNOWN";
2025                 break;
2026         }
2027
2028         DEBUG(10,("set_remote_arch: Client arch is \'%s\'\n",
2029                                 remote_arch_str));
2030 }
2031
2032 /*******************************************************************
2033  Get the remote_arch type.
2034 ********************************************************************/
2035
2036 enum remote_arch_types get_remote_arch(void)
2037 {
2038         return ra_type;
2039 }
2040
2041 const char *tab_depth(int level, int depth)
2042 {
2043         if( CHECK_DEBUGLVL(level) ) {
2044                 dbgtext("%*s", depth*4, "");
2045         }
2046         return "";
2047 }
2048
2049 /*****************************************************************************
2050  Provide a checksum on a string
2051
2052  Input:  s - the null-terminated character string for which the checksum
2053              will be calculated.
2054
2055   Output: The checksum value calculated for s.
2056 *****************************************************************************/
2057
2058 int str_checksum(const char *s)
2059 {
2060         int res = 0;
2061         int c;
2062         int i=0;
2063
2064         while(*s) {
2065                 c = *s;
2066                 res ^= (c << (i % 15)) ^ (c >> (15-(i%15)));
2067                 s++;
2068                 i++;
2069         }
2070         return(res);
2071 }
2072
2073 /*****************************************************************
2074  Zero a memory area then free it. Used to catch bugs faster.
2075 *****************************************************************/
2076
2077 void zero_free(void *p, size_t size)
2078 {
2079         memset(p, 0, size);
2080         SAFE_FREE(p);
2081 }
2082
2083 /*****************************************************************
2084  Set our open file limit to a requested max and return the limit.
2085 *****************************************************************/
2086
2087 int set_maxfiles(int requested_max)
2088 {
2089 #if (defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE))
2090         struct rlimit rlp;
2091         int saved_current_limit;
2092
2093         if(getrlimit(RLIMIT_NOFILE, &rlp)) {
2094                 DEBUG(0,("set_maxfiles: getrlimit (1) for RLIMIT_NOFILE failed with error %s\n",
2095                         strerror(errno) ));
2096                 /* just guess... */
2097                 return requested_max;
2098         }
2099
2100         /*
2101          * Set the fd limit to be real_max_open_files + MAX_OPEN_FUDGEFACTOR to
2102          * account for the extra fd we need
2103          * as well as the log files and standard
2104          * handles etc. Save the limit we want to set in case
2105          * we are running on an OS that doesn't support this limit (AIX)
2106          * which always returns RLIM_INFINITY for rlp.rlim_max.
2107          */
2108
2109         /* Try raising the hard (max) limit to the requested amount. */
2110
2111 #if defined(RLIM_INFINITY)
2112         if (rlp.rlim_max != RLIM_INFINITY) {
2113                 int orig_max = rlp.rlim_max;
2114
2115                 if ( rlp.rlim_max < requested_max )
2116                         rlp.rlim_max = requested_max;
2117
2118                 /* This failing is not an error - many systems (Linux) don't
2119                         support our default request of 10,000 open files. JRA. */
2120
2121                 if(setrlimit(RLIMIT_NOFILE, &rlp)) {
2122                         DEBUG(3,("set_maxfiles: setrlimit for RLIMIT_NOFILE for %d max files failed with error %s\n",
2123                                 (int)rlp.rlim_max, strerror(errno) ));
2124
2125                         /* Set failed - restore original value from get. */
2126                         rlp.rlim_max = orig_max;
2127                 }
2128         }
2129 #endif
2130
2131         /* Now try setting the soft (current) limit. */
2132
2133         saved_current_limit = rlp.rlim_cur = MIN(requested_max,rlp.rlim_max);
2134
2135         if(setrlimit(RLIMIT_NOFILE, &rlp)) {
2136                 DEBUG(0,("set_maxfiles: setrlimit for RLIMIT_NOFILE for %d files failed with error %s\n",
2137                         (int)rlp.rlim_cur, strerror(errno) ));
2138                 /* just guess... */
2139                 return saved_current_limit;
2140         }
2141
2142         if(getrlimit(RLIMIT_NOFILE, &rlp)) {
2143                 DEBUG(0,("set_maxfiles: getrlimit (2) for RLIMIT_NOFILE failed with error %s\n",
2144                         strerror(errno) ));
2145                 /* just guess... */
2146                 return saved_current_limit;
2147     }
2148
2149 #if defined(RLIM_INFINITY)
2150         if(rlp.rlim_cur == RLIM_INFINITY)
2151                 return saved_current_limit;
2152 #endif
2153
2154         if((int)rlp.rlim_cur > saved_current_limit)
2155                 return saved_current_limit;
2156
2157         return rlp.rlim_cur;
2158 #else /* !defined(HAVE_GETRLIMIT) || !defined(RLIMIT_NOFILE) */
2159         /*
2160          * No way to know - just guess...
2161          */
2162         return requested_max;
2163 #endif
2164 }
2165
2166 /*****************************************************************
2167  Possibly replace mkstemp if it is broken.
2168 *****************************************************************/
2169
2170 int smb_mkstemp(char *name_template)
2171 {
2172 #if HAVE_SECURE_MKSTEMP
2173         return mkstemp(name_template);
2174 #else
2175         /* have a reasonable go at emulating it. Hope that
2176            the system mktemp() isn't completly hopeless */
2177         char *p = mktemp(name_template);
2178         if (!p)
2179                 return -1;
2180         return open(p, O_CREAT|O_EXCL|O_RDWR, 0600);
2181 #endif
2182 }
2183
2184 /*****************************************************************
2185  malloc that aborts with smb_panic on fail or zero size.
2186  *****************************************************************/
2187
2188 void *smb_xmalloc_array(size_t size, unsigned int count)
2189 {
2190         void *p;
2191         if (size == 0) {
2192                 smb_panic("smb_xmalloc_array: called with zero size");
2193         }
2194         if (count >= MAX_ALLOC_SIZE/size) {
2195                 smb_panic("smb_xmalloc_array: alloc size too large");
2196         }
2197         if ((p = SMB_MALLOC(size*count)) == NULL) {
2198                 DEBUG(0, ("smb_xmalloc_array failed to allocate %lu * %lu bytes\n",
2199                         (unsigned long)size, (unsigned long)count));
2200                 smb_panic("smb_xmalloc_array: malloc failed");
2201         }
2202         return p;
2203 }
2204
2205 /*
2206   vasprintf that aborts on malloc fail
2207 */
2208
2209  int smb_xvasprintf(char **ptr, const char *format, va_list ap)
2210 {
2211         int n;
2212         va_list ap2;
2213
2214         va_copy(ap2, ap);
2215
2216         n = vasprintf(ptr, format, ap2);
2217         if (n == -1 || ! *ptr) {
2218                 smb_panic("smb_xvasprintf: out of memory");
2219         }
2220         va_end(ap2);
2221         return n;
2222 }
2223
2224 /*****************************************************************
2225  Get local hostname and cache result.
2226 *****************************************************************/
2227
2228 char *myhostname(void)
2229 {
2230         static char *ret;
2231         if (ret == NULL) {
2232                 /* This is cached forever so
2233                  * use talloc_autofree_context() ctx. */
2234                 ret = talloc_get_myname(talloc_autofree_context());
2235         }
2236         return ret;
2237 }
2238
2239 /**
2240  * @brief Returns an absolute path to a file concatenating the provided
2241  * @a rootpath and @a basename
2242  *
2243  * @param name Filename, relative to @a rootpath
2244  *
2245  * @retval Pointer to a string containing the full path.
2246  **/
2247
2248 static char *xx_path(const char *name, const char *rootpath)
2249 {
2250         char *fname = NULL;
2251
2252         fname = talloc_strdup(talloc_tos(), rootpath);
2253         if (!fname) {
2254                 return NULL;
2255         }
2256         trim_string(fname,"","/");
2257
2258         if (!directory_exist(fname)) {
2259                 if (!mkdir(fname,0755))
2260                         DEBUG(1, ("Unable to create directory %s for file %s. "
2261                               "Error was %s\n", fname, name, strerror(errno)));
2262         }
2263
2264         return talloc_asprintf(talloc_tos(),
2265                                 "%s/%s",
2266                                 fname,
2267                                 name);
2268 }
2269
2270 /**
2271  * @brief Returns an absolute path to a file in the Samba lock directory.
2272  *
2273  * @param name File to find, relative to LOCKDIR.
2274  *
2275  * @retval Pointer to a talloc'ed string containing the full path.
2276  **/
2277
2278 char *lock_path(const char *name)
2279 {
2280         return xx_path(name, lp_lockdir());
2281 }
2282
2283 /**
2284  * @brief Returns an absolute path to a file in the Samba pid directory.
2285  *
2286  * @param name File to find, relative to PIDDIR.
2287  *
2288  * @retval Pointer to a talloc'ed string containing the full path.
2289  **/
2290
2291 char *pid_path(const char *name)
2292 {
2293         return xx_path(name, lp_piddir());
2294 }
2295
2296 /**
2297  * @brief Returns an absolute path to a file in the Samba lib directory.
2298  *
2299  * @param name File to find, relative to LIBDIR.
2300  *
2301  * @retval Pointer to a string containing the full path.
2302  **/
2303
2304 char *lib_path(const char *name)
2305 {
2306         return talloc_asprintf(talloc_tos(), "%s/%s", get_dyn_LIBDIR(), name);
2307 }
2308
2309 /**
2310  * @brief Returns an absolute path to a file in the Samba modules directory.
2311  *
2312  * @param name File to find, relative to MODULESDIR.
2313  *
2314  * @retval Pointer to a string containing the full path.
2315  **/
2316
2317 char *modules_path(const char *name)
2318 {
2319         return talloc_asprintf(talloc_tos(), "%s/%s", get_dyn_MODULESDIR(), name);
2320 }
2321
2322 /**
2323  * @brief Returns an absolute path to a file in the Samba data directory.
2324  *
2325  * @param name File to find, relative to CODEPAGEDIR.
2326  *
2327  * @retval Pointer to a talloc'ed string containing the full path.
2328  **/
2329
2330 char *data_path(const char *name)
2331 {
2332         return talloc_asprintf(talloc_tos(), "%s/%s", get_dyn_CODEPAGEDIR(), name);
2333 }
2334
2335 /**
2336  * @brief Returns an absolute path to a file in the Samba state directory.
2337  *
2338  * @param name File to find, relative to STATEDIR.
2339  *
2340  * @retval Pointer to a talloc'ed string containing the full path.
2341  **/
2342
2343 char *state_path(const char *name)
2344 {
2345         return xx_path(name, lp_statedir());
2346 }
2347
2348 /**
2349  * @brief Returns an absolute path to a file in the Samba cache directory.
2350  *
2351  * @param name File to find, relative to CACHEDIR.
2352  *
2353  * @retval Pointer to a talloc'ed string containing the full path.
2354  **/
2355
2356 char *cache_path(const char *name)
2357 {
2358         return xx_path(name, lp_cachedir());
2359 }
2360
2361 /**
2362  * @brief Returns the platform specific shared library extension.
2363  *
2364  * @retval Pointer to a const char * containing the extension.
2365  **/
2366
2367 const char *shlib_ext(void)
2368 {
2369         return get_dyn_SHLIBEXT();
2370 }
2371
2372 /*******************************************************************
2373  Given a filename - get its directory name
2374 ********************************************************************/
2375
2376 bool parent_dirname(TALLOC_CTX *mem_ctx, const char *dir, char **parent,
2377                     const char **name)
2378 {
2379         char *p;
2380         ptrdiff_t len;
2381
2382         p = strrchr_m(dir, '/'); /* Find final '/', if any */
2383
2384         if (p == NULL) {
2385                 if (!(*parent = talloc_strdup(mem_ctx, "."))) {
2386                         return False;
2387                 }
2388                 if (name) {
2389                         *name = "";
2390                 }
2391                 return True;
2392         }
2393
2394         len = p-dir;
2395
2396         if (!(*parent = (char *)TALLOC_MEMDUP(mem_ctx, dir, len+1))) {
2397                 return False;
2398         }
2399         (*parent)[len] = '\0';
2400
2401         if (name) {
2402                 *name = p+1;
2403         }
2404         return True;
2405 }
2406
2407 /*******************************************************************
2408  Determine if a pattern contains any Microsoft wildcard characters.
2409 *******************************************************************/
2410
2411 bool ms_has_wild(const char *s)
2412 {
2413         char c;
2414
2415         if (lp_posix_pathnames()) {
2416                 /* With posix pathnames no characters are wild. */
2417                 return False;
2418         }
2419
2420         while ((c = *s++)) {
2421                 switch (c) {
2422                 case '*':
2423                 case '?':
2424                 case '<':
2425                 case '>':
2426                 case '"':
2427                         return True;
2428                 }
2429         }
2430         return False;
2431 }
2432
2433 bool ms_has_wild_w(const smb_ucs2_t *s)
2434 {
2435         smb_ucs2_t c;
2436         if (!s) return False;
2437         while ((c = *s++)) {
2438                 switch (c) {
2439                 case UCS2_CHAR('*'):
2440                 case UCS2_CHAR('?'):
2441                 case UCS2_CHAR('<'):
2442                 case UCS2_CHAR('>'):
2443                 case UCS2_CHAR('"'):
2444                         return True;
2445                 }
2446         }
2447         return False;
2448 }
2449
2450 /*******************************************************************
2451  A wrapper that handles case sensitivity and the special handling
2452  of the ".." name.
2453 *******************************************************************/
2454
2455 bool mask_match(const char *string, const char *pattern, bool is_case_sensitive)
2456 {
2457         if (strcmp(string,"..") == 0)
2458                 string = ".";
2459         if (strcmp(pattern,".") == 0)
2460                 return False;
2461
2462         return ms_fnmatch(pattern, string, Protocol <= PROTOCOL_LANMAN2, is_case_sensitive) == 0;
2463 }
2464
2465 /*******************************************************************
2466  A wrapper that handles case sensitivity and the special handling
2467  of the ".." name. Varient that is only called by old search code which requires
2468  pattern translation.
2469 *******************************************************************/
2470
2471 bool mask_match_search(const char *string, const char *pattern, bool is_case_sensitive)
2472 {
2473         if (strcmp(string,"..") == 0)
2474                 string = ".";
2475         if (strcmp(pattern,".") == 0)
2476                 return False;
2477
2478         return ms_fnmatch(pattern, string, True, is_case_sensitive) == 0;
2479 }
2480
2481 /*******************************************************************
2482  A wrapper that handles a list of patters and calls mask_match()
2483  on each.  Returns True if any of the patterns match.
2484 *******************************************************************/
2485
2486 bool mask_match_list(const char *string, char **list, int listLen, bool is_case_sensitive)
2487 {
2488        while (listLen-- > 0) {
2489                if (mask_match(string, *list++, is_case_sensitive))
2490                        return True;
2491        }
2492        return False;
2493 }
2494
2495 /*********************************************************
2496  Recursive routine that is called by unix_wild_match.
2497 *********************************************************/
2498
2499 static bool unix_do_match(const char *regexp, const char *str)
2500 {
2501         const char *p;
2502
2503         for( p = regexp; *p && *str; ) {
2504
2505                 switch(*p) {
2506                         case '?':
2507                                 str++;
2508                                 p++;
2509                                 break;
2510
2511                         case '*':
2512
2513                                 /*
2514                                  * Look for a character matching
2515                                  * the one after the '*'.
2516                                  */
2517                                 p++;
2518                                 if(!*p)
2519                                         return true; /* Automatic match */
2520                                 while(*str) {
2521
2522                                         while(*str && (*p != *str))
2523                                                 str++;
2524
2525                                         /*
2526                                          * Patch from weidel@multichart.de. In the case of the regexp
2527                                          * '*XX*' we want to ensure there are at least 2 'X' characters
2528                                          * in the string after the '*' for a match to be made.
2529                                          */
2530
2531                                         {
2532                                                 int matchcount=0;
2533
2534                                                 /*
2535                                                  * Eat all the characters that match, but count how many there were.
2536                                                  */
2537
2538                                                 while(*str && (*p == *str)) {
2539                                                         str++;
2540                                                         matchcount++;
2541                                                 }
2542
2543                                                 /*
2544                                                  * Now check that if the regexp had n identical characters that
2545                                                  * matchcount had at least that many matches.
2546                                                  */
2547
2548                                                 while ( *(p+1) && (*(p+1) == *p)) {
2549                                                         p++;
2550                                                         matchcount--;
2551                                                 }
2552
2553                                                 if ( matchcount <= 0 )
2554                                                         return false;
2555                                         }
2556
2557                                         str--; /* We've eaten the match char after the '*' */
2558
2559                                         if(unix_do_match(p, str))
2560                                                 return true;
2561
2562                                         if(!*str)
2563                                                 return false;
2564                                         else
2565                                                 str++;
2566                                 }
2567                                 return false;
2568
2569                         default:
2570                                 if(*str != *p)
2571                                         return false;
2572                                 str++;
2573                                 p++;
2574                                 break;
2575                 }
2576         }
2577
2578         if(!*p && !*str)
2579                 return true;
2580
2581         if (!*p && str[0] == '.' && str[1] == 0)
2582                 return true;
2583
2584         if (!*str && *p == '?') {
2585                 while (*p == '?')
2586                         p++;
2587                 return(!*p);
2588         }
2589
2590         if(!*str && (*p == '*' && p[1] == '\0'))
2591                 return true;
2592
2593         return false;
2594 }
2595
2596 /*******************************************************************
2597  Simple case insensitive interface to a UNIX wildcard matcher.
2598  Returns True if match, False if not.
2599 *******************************************************************/
2600
2601 bool unix_wild_match(const char *pattern, const char *string)
2602 {
2603         TALLOC_CTX *ctx = talloc_stackframe();
2604         char *p2;
2605         char *s2;
2606         char *p;
2607         bool ret = false;
2608
2609         p2 = talloc_strdup(ctx,pattern);
2610         s2 = talloc_strdup(ctx,string);
2611         if (!p2 || !s2) {
2612                 TALLOC_FREE(ctx);
2613                 return false;
2614         }
2615         strlower_m(p2);
2616         strlower_m(s2);
2617
2618         /* Remove any *? and ** from the pattern as they are meaningless */
2619         for(p = p2; *p; p++) {
2620                 while( *p == '*' && (p[1] == '?' ||p[1] == '*')) {
2621                         memmove(&p[1], &p[2], strlen(&p[2])+1);
2622                 }
2623         }
2624
2625         if (strequal(p2,"*")) {
2626                 TALLOC_FREE(ctx);
2627                 return true;
2628         }
2629
2630         ret = unix_do_match(p2, s2);
2631         TALLOC_FREE(ctx);
2632         return ret;
2633 }
2634
2635 /**********************************************************************
2636  Converts a name to a fully qualified domain name.
2637  Returns true if lookup succeeded, false if not (then fqdn is set to name)
2638  Note we deliberately use gethostbyname here, not getaddrinfo as we want
2639  to examine the h_aliases and I don't know how to do that with getaddrinfo.
2640 ***********************************************************************/
2641
2642 bool name_to_fqdn(fstring fqdn, const char *name)
2643 {
2644         char *full = NULL;
2645         struct hostent *hp = gethostbyname(name);
2646
2647         if (!hp || !hp->h_name || !*hp->h_name) {
2648                 DEBUG(10,("name_to_fqdn: lookup for %s failed.\n", name));
2649                 fstrcpy(fqdn, name);
2650                 return false;
2651         }
2652
2653         /* Find out if the fqdn is returned as an alias
2654          * to cope with /etc/hosts files where the first
2655          * name is not the fqdn but the short name */
2656         if (hp->h_aliases && (! strchr_m(hp->h_name, '.'))) {
2657                 int i;
2658                 for (i = 0; hp->h_aliases[i]; i++) {
2659                         if (strchr_m(hp->h_aliases[i], '.')) {
2660                                 full = hp->h_aliases[i];
2661                                 break;
2662                         }
2663                 }
2664         }
2665         if (full && (StrCaseCmp(full, "localhost.localdomain") == 0)) {
2666                 DEBUG(1, ("WARNING: your /etc/hosts file may be broken!\n"));
2667                 DEBUGADD(1, ("    Specifing the machine hostname for address 127.0.0.1 may lead\n"));
2668                 DEBUGADD(1, ("    to Kerberos authentication problems as localhost.localdomain\n"));
2669                 DEBUGADD(1, ("    may end up being used instead of the real machine FQDN.\n"));
2670                 full = hp->h_name;
2671         }
2672         if (!full) {
2673                 full = hp->h_name;
2674         }
2675
2676         DEBUG(10,("name_to_fqdn: lookup for %s -> %s.\n", name, full));
2677         fstrcpy(fqdn, full);
2678         return true;
2679 }
2680
2681 /**********************************************************************
2682  Append a DATA_BLOB to a talloc'ed object
2683 ***********************************************************************/
2684
2685 void *talloc_append_blob(TALLOC_CTX *mem_ctx, void *buf, DATA_BLOB blob)
2686 {
2687         size_t old_size = 0;
2688         char *result;
2689
2690         if (blob.length == 0) {
2691                 return buf;
2692         }
2693
2694         if (buf != NULL) {
2695                 old_size = talloc_get_size(buf);
2696         }
2697
2698         result = (char *)TALLOC_REALLOC(mem_ctx, buf, old_size + blob.length);
2699         if (result == NULL) {
2700                 return NULL;
2701         }
2702
2703         memcpy(result + old_size, blob.data, blob.length);
2704         return result;
2705 }
2706
2707 uint32 map_share_mode_to_deny_mode(uint32 share_access, uint32 private_options)
2708 {
2709         switch (share_access & ~FILE_SHARE_DELETE) {
2710                 case FILE_SHARE_NONE:
2711                         return DENY_ALL;
2712                 case FILE_SHARE_READ:
2713                         return DENY_WRITE;
2714                 case FILE_SHARE_WRITE:
2715                         return DENY_READ;
2716                 case FILE_SHARE_READ|FILE_SHARE_WRITE:
2717                         return DENY_NONE;
2718         }
2719         if (private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS) {
2720                 return DENY_DOS;
2721         } else if (private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_FCB) {
2722                 return DENY_FCB;
2723         }
2724
2725         return (uint32)-1;
2726 }
2727
2728 pid_t procid_to_pid(const struct server_id *proc)
2729 {
2730         return proc->pid;
2731 }
2732
2733 static uint32 my_vnn = NONCLUSTER_VNN;
2734
2735 void set_my_vnn(uint32 vnn)
2736 {
2737         DEBUG(10, ("vnn pid %d = %u\n", (int)sys_getpid(), (unsigned int)vnn));
2738         my_vnn = vnn;
2739 }
2740
2741 uint32 get_my_vnn(void)
2742 {
2743         return my_vnn;
2744 }
2745
2746 struct server_id pid_to_procid(pid_t pid)
2747 {
2748         struct server_id result;
2749         result.pid = pid;
2750 #ifdef CLUSTER_SUPPORT
2751         result.vnn = my_vnn;
2752 #endif
2753         return result;
2754 }
2755
2756 struct server_id procid_self(void)
2757 {
2758         return pid_to_procid(sys_getpid());
2759 }
2760
2761 struct server_id server_id_self(void)
2762 {
2763         return procid_self();
2764 }
2765
2766 bool procid_equal(const struct server_id *p1, const struct server_id *p2)
2767 {
2768         if (p1->pid != p2->pid)
2769                 return False;
2770 #ifdef CLUSTER_SUPPORT
2771         if (p1->vnn != p2->vnn)
2772                 return False;
2773 #endif
2774         return True;
2775 }
2776
2777 bool cluster_id_equal(const struct server_id *id1,
2778                       const struct server_id *id2)
2779 {
2780         return procid_equal(id1, id2);
2781 }
2782
2783 bool procid_is_me(const struct server_id *pid)
2784 {
2785         if (pid->pid != sys_getpid())
2786                 return False;
2787 #ifdef CLUSTER_SUPPORT
2788         if (pid->vnn != my_vnn)
2789                 return False;
2790 #endif
2791         return True;
2792 }
2793
2794 struct server_id interpret_pid(const char *pid_string)
2795 {
2796 #ifdef CLUSTER_SUPPORT
2797         unsigned int vnn, pid;
2798         struct server_id result;
2799         if (sscanf(pid_string, "%u:%u", &vnn, &pid) == 2) {
2800                 result.vnn = vnn;
2801                 result.pid = pid;
2802         }
2803         else if (sscanf(pid_string, "%u", &pid) == 1) {
2804                 result.vnn = get_my_vnn();
2805                 result.pid = pid;
2806         }
2807         else {
2808                 result.vnn = NONCLUSTER_VNN;
2809                 result.pid = -1;
2810         }
2811         return result;
2812 #else
2813         return pid_to_procid(atoi(pid_string));
2814 #endif
2815 }
2816
2817 char *procid_str(TALLOC_CTX *mem_ctx, const struct server_id *pid)
2818 {
2819 #ifdef CLUSTER_SUPPORT
2820         if (pid->vnn == NONCLUSTER_VNN) {
2821                 return talloc_asprintf(mem_ctx,
2822                                 "%d",
2823                                 (int)pid->pid);
2824         }
2825         else {
2826                 return talloc_asprintf(mem_ctx,
2827                                         "%u:%d",
2828                                         (unsigned)pid->vnn,
2829                                         (int)pid->pid);
2830         }
2831 #else
2832         return talloc_asprintf(mem_ctx,
2833                         "%d",
2834                         (int)pid->pid);
2835 #endif
2836 }
2837
2838 char *procid_str_static(const struct server_id *pid)
2839 {
2840         return procid_str(talloc_tos(), pid);
2841 }
2842
2843 bool procid_valid(const struct server_id *pid)
2844 {
2845         return (pid->pid != -1);
2846 }
2847
2848 bool procid_is_local(const struct server_id *pid)
2849 {
2850 #ifdef CLUSTER_SUPPORT
2851         return pid->vnn == my_vnn;
2852 #else
2853         return True;
2854 #endif
2855 }
2856
2857 int this_is_smp(void)
2858 {
2859 #if defined(HAVE_SYSCONF)
2860
2861 #if defined(SYSCONF_SC_NPROC_ONLN)
2862         return (sysconf(_SC_NPROC_ONLN) > 1) ? 1 : 0;
2863 #elif defined(SYSCONF_SC_NPROCESSORS_ONLN)
2864         return (sysconf(_SC_NPROCESSORS_ONLN) > 1) ? 1 : 0;
2865 #else
2866         return 0;
2867 #endif
2868
2869 #else
2870         return 0;
2871 #endif
2872 }
2873
2874 /****************************************************************
2875  Check if offset/length fit into bufsize. Should probably be
2876  merged with is_offset_safe, but this would require a rewrite
2877  of lanman.c. Later :-)
2878 ****************************************************************/
2879
2880 bool trans_oob(uint32_t bufsize, uint32_t offset, uint32_t length)
2881 {
2882         if ((offset + length < offset) || (offset + length < length)) {
2883                 /* wrap */
2884                 return true;
2885         }
2886         if ((offset > bufsize) || (offset + length > bufsize)) {
2887                 /* overflow */
2888                 return true;
2889         }
2890         return false;
2891 }
2892
2893 /****************************************************************
2894  Check if an offset into a buffer is safe.
2895  If this returns True it's safe to indirect into the byte at
2896  pointer ptr+off.
2897 ****************************************************************/
2898
2899 bool is_offset_safe(const char *buf_base, size_t buf_len, char *ptr, size_t off)
2900 {
2901         const char *end_base = buf_base + buf_len;
2902         char *end_ptr = ptr + off;
2903
2904         if (!buf_base || !ptr) {
2905                 return False;
2906         }
2907
2908         if (end_base < buf_base || end_ptr < ptr) {
2909                 return False; /* wrap. */
2910         }
2911
2912         if (end_ptr < end_base) {
2913                 return True;
2914         }
2915         return False;
2916 }
2917
2918 /****************************************************************
2919  Return a safe pointer into a buffer, or NULL.
2920 ****************************************************************/
2921
2922 char *get_safe_ptr(const char *buf_base, size_t buf_len, char *ptr, size_t off)
2923 {
2924         return is_offset_safe(buf_base, buf_len, ptr, off) ?
2925                         ptr + off : NULL;
2926 }
2927
2928 /****************************************************************
2929  Return a safe pointer into a string within a buffer, or NULL.
2930 ****************************************************************/
2931
2932 char *get_safe_str_ptr(const char *buf_base, size_t buf_len, char *ptr, size_t off)
2933 {
2934         if (!is_offset_safe(buf_base, buf_len, ptr, off)) {
2935                 return NULL;
2936         }
2937         /* Check if a valid string exists at this offset. */
2938         if (skip_string(buf_base,buf_len, ptr + off) == NULL) {
2939                 return NULL;
2940         }
2941         return ptr + off;
2942 }
2943
2944 /****************************************************************
2945  Return an SVAL at a pointer, or failval if beyond the end.
2946 ****************************************************************/
2947
2948 int get_safe_SVAL(const char *buf_base, size_t buf_len, char *ptr, size_t off, int failval)
2949 {
2950         /*
2951          * Note we use off+1 here, not off+2 as SVAL accesses ptr[0] and ptr[1],
2952          * NOT ptr[2].
2953          */
2954         if (!is_offset_safe(buf_base, buf_len, ptr, off+1)) {
2955                 return failval;
2956         }
2957         return SVAL(ptr,off);
2958 }
2959
2960 /****************************************************************
2961  Return an IVAL at a pointer, or failval if beyond the end.
2962 ****************************************************************/
2963
2964 int get_safe_IVAL(const char *buf_base, size_t buf_len, char *ptr, size_t off, int failval)
2965 {
2966         /*
2967          * Note we use off+3 here, not off+4 as IVAL accesses
2968          * ptr[0] ptr[1] ptr[2] ptr[3] NOT ptr[4].
2969          */
2970         if (!is_offset_safe(buf_base, buf_len, ptr, off+3)) {
2971                 return failval;
2972         }
2973         return IVAL(ptr,off);
2974 }
2975
2976 /****************************************************************
2977  Split DOM\user into DOM and user. Do not mix with winbind variants of that
2978  call (they take care of winbind separator and other winbind specific settings).
2979 ****************************************************************/
2980
2981 void split_domain_user(TALLOC_CTX *mem_ctx,
2982                        const char *full_name,
2983                        char **domain,
2984                        char **user)
2985 {
2986         const char *p = NULL;
2987
2988         p = strchr_m(full_name, '\\');
2989
2990         if (p != NULL) {
2991                 *domain = talloc_strndup(mem_ctx, full_name,
2992                                          PTR_DIFF(p, full_name));
2993                 *user = talloc_strdup(mem_ctx, p+1);
2994         } else {
2995                 *domain = talloc_strdup(mem_ctx, "");
2996                 *user = talloc_strdup(mem_ctx, full_name);
2997         }
2998 }
2999
3000 #if 0
3001
3002 Disable these now we have checked all code paths and ensured
3003 NULL returns on zero request. JRA.
3004
3005 /****************************************************************
3006  talloc wrapper functions that guarentee a null pointer return
3007  if size == 0.
3008 ****************************************************************/
3009
3010 #ifndef MAX_TALLOC_SIZE
3011 #define MAX_TALLOC_SIZE 0x10000000
3012 #endif
3013
3014 /*
3015  *    talloc and zero memory.
3016  *    - returns NULL if size is zero.
3017  */
3018
3019 void *_talloc_zero_zeronull(const void *ctx, size_t size, const char *name)
3020 {
3021         void *p;
3022
3023         if (size == 0) {
3024                 return NULL;
3025         }
3026
3027         p = talloc_named_const(ctx, size, name);
3028
3029         if (p) {
3030                 memset(p, '\0', size);
3031         }
3032
3033         return p;
3034 }
3035
3036 /*
3037  *   memdup with a talloc.
3038  *   - returns NULL if size is zero.
3039  */
3040
3041 void *_talloc_memdup_zeronull(const void *t, const void *p, size_t size, const char *name)
3042 {
3043         void *newp;
3044
3045         if (size == 0) {
3046                 return NULL;
3047         }
3048
3049         newp = talloc_named_const(t, size, name);
3050         if (newp) {
3051                 memcpy(newp, p, size);
3052         }
3053
3054         return newp;
3055 }
3056
3057 /*
3058  *   alloc an array, checking for integer overflow in the array size.
3059  *   - returns NULL if count or el_size are zero.
3060  */
3061
3062 void *_talloc_array_zeronull(const void *ctx, size_t el_size, unsigned count, const char *name)
3063 {
3064         if (count >= MAX_TALLOC_SIZE/el_size) {
3065                 return NULL;
3066         }
3067
3068         if (el_size == 0 || count == 0) {
3069                 return NULL;
3070         }
3071
3072         return talloc_named_const(ctx, el_size * count, name);
3073 }
3074
3075 /*
3076  *   alloc an zero array, checking for integer overflow in the array size
3077  *   - returns NULL if count or el_size are zero.
3078  */
3079
3080 void *_talloc_zero_array_zeronull(const void *ctx, size_t el_size, unsigned count, const char *name)
3081 {
3082         if (count >= MAX_TALLOC_SIZE/el_size) {
3083                 return NULL;
3084         }
3085
3086         if (el_size == 0 || count == 0) {
3087                 return NULL;
3088         }
3089
3090         return _talloc_zero(ctx, el_size * count, name);
3091 }
3092
3093 /*
3094  *   Talloc wrapper that returns NULL if size == 0.
3095  */
3096 void *talloc_zeronull(const void *context, size_t size, const char *name)
3097 {
3098         if (size == 0) {
3099                 return NULL;
3100         }
3101         return talloc_named_const(context, size, name);
3102 }
3103 #endif
3104
3105 /* Split a path name into filename and stream name components. Canonicalise
3106  * such that an implicit $DATA token is always explicit.
3107  *
3108  * The "specification" of this function can be found in the
3109  * run_local_stream_name() function in torture.c, I've tried those
3110  * combinations against a W2k3 server.
3111  */
3112
3113 NTSTATUS split_ntfs_stream_name(TALLOC_CTX *mem_ctx, const char *fname,
3114                                 char **pbase, char **pstream)
3115 {
3116         char *base = NULL;
3117         char *stream = NULL;
3118         char *sname; /* stream name */
3119         const char *stype; /* stream type */
3120
3121         DEBUG(10, ("split_ntfs_stream_name called for [%s]\n", fname));
3122
3123         sname = strchr_m(fname, ':');
3124
3125         if (lp_posix_pathnames() || (sname == NULL)) {
3126                 if (pbase != NULL) {
3127                         base = talloc_strdup(mem_ctx, fname);
3128                         NT_STATUS_HAVE_NO_MEMORY(base);
3129                 }
3130                 goto done;
3131         }
3132
3133         if (pbase != NULL) {
3134                 base = talloc_strndup(mem_ctx, fname, PTR_DIFF(sname, fname));
3135                 NT_STATUS_HAVE_NO_MEMORY(base);
3136         }
3137
3138         sname += 1;
3139
3140         stype = strchr_m(sname, ':');
3141
3142         if (stype == NULL) {
3143                 sname = talloc_strdup(mem_ctx, sname);
3144                 stype = "$DATA";
3145         }
3146         else {
3147                 if (StrCaseCmp(stype, ":$DATA") != 0) {
3148                         /*
3149                          * If there is an explicit stream type, so far we only
3150                          * allow $DATA. Is there anything else allowed? -- vl
3151                          */
3152                         DEBUG(10, ("[%s] is an invalid stream type\n", stype));
3153                         TALLOC_FREE(base);
3154                         return NT_STATUS_OBJECT_NAME_INVALID;
3155                 }
3156                 sname = talloc_strndup(mem_ctx, sname, PTR_DIFF(stype, sname));
3157                 stype += 1;
3158         }
3159
3160         if (sname == NULL) {
3161                 TALLOC_FREE(base);
3162                 return NT_STATUS_NO_MEMORY;
3163         }
3164
3165         if (sname[0] == '\0') {
3166                 /*
3167                  * no stream name, so no stream
3168                  */
3169                 goto done;
3170         }
3171
3172         if (pstream != NULL) {
3173                 stream = talloc_asprintf(mem_ctx, "%s:%s", sname, stype);
3174                 if (stream == NULL) {
3175                         TALLOC_FREE(sname);
3176                         TALLOC_FREE(base);
3177                         return NT_STATUS_NO_MEMORY;
3178                 }
3179                 /*
3180                  * upper-case the type field
3181                  */
3182                 strupper_m(strchr_m(stream, ':')+1);
3183         }
3184
3185  done:
3186         if (pbase != NULL) {
3187                 *pbase = base;
3188         }
3189         if (pstream != NULL) {
3190                 *pstream = stream;
3191         }
3192         return NT_STATUS_OK;
3193 }
3194
3195 bool is_valid_policy_hnd(const POLICY_HND *hnd)
3196 {
3197         POLICY_HND tmp;
3198         ZERO_STRUCT(tmp);
3199         return (memcmp(&tmp, hnd, sizeof(tmp)) != 0);
3200 }
3201
3202 bool policy_hnd_equal(const struct policy_handle *hnd1,
3203                       const struct policy_handle *hnd2)
3204 {
3205         if (!hnd1 || !hnd2) {
3206                 return false;
3207         }
3208
3209         return (memcmp(hnd1, hnd2, sizeof(*hnd1)) == 0);
3210 }
3211
3212 /****************************************************************
3213  strip off leading '\\' from a hostname
3214 ****************************************************************/
3215
3216 const char *strip_hostname(const char *s)
3217 {
3218         if (!s) {
3219                 return NULL;
3220         }
3221
3222         if (strlen_m(s) < 3) {
3223                 return s;
3224         }
3225
3226         if (s[0] == '\\') s++;
3227         if (s[0] == '\\') s++;
3228
3229         return s;
3230 }