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