source3/lib/util.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Samba utility functions
   4    Copyright (C) Andrew Tridgell 1992-1998
   5    Copyright (C) Jeremy Allison 2001-2007
   6    Copyright (C) Simo Sorce 2001
   7    Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2003
   8    Copyright (C) James Peach 2006
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  22 */
  23
  24 #include "includes.h"
  25
  26 extern char *global_clobber_region_function;
  27 extern unsigned int global_clobber_region_line;
  28
  29 /* Max allowable allococation - 256mb - 0x10000000 */
  30 #define MAX_ALLOC_SIZE (1024*1024*256)
  31
  32 #if (defined(HAVE_NETGROUP) && defined (WITH_AUTOMOUNT))
  33 #ifdef WITH_NISPLUS_HOME
  34 #ifdef BROKEN_NISPLUS_INCLUDE_FILES
  35 /*
  36  * The following lines are needed due to buggy include files
  37  * in Solaris 2.6 which define GROUP in both /usr/include/sys/acl.h and
  38  * also in /usr/include/rpcsvc/nis.h. The definitions conflict. JRA.
  39  * Also GROUP_OBJ is defined as 0x4 in /usr/include/sys/acl.h and as
  40  * an enum in /usr/include/rpcsvc/nis.h.
  41  */
  42
  43 #if defined(GROUP)
  44 #undef GROUP
  45 #endif
  46
  47 #if defined(GROUP_OBJ)
  48 #undef GROUP_OBJ
  49 #endif
  50
  51 #endif /* BROKEN_NISPLUS_INCLUDE_FILES */
  52
  53 #include <rpcsvc/nis.h>
  54
  55 #endif /* WITH_NISPLUS_HOME */
  56 #endif /* HAVE_NETGROUP && WITH_AUTOMOUNT */
  57
  58 enum protocol_types Protocol = PROTOCOL_COREPLUS;
  59
  60 static enum remote_arch_types ra_type = RA_UNKNOWN;
  61
  62 /***********************************************************************
  63  Definitions for all names.
  64 ***********************************************************************/
  65
  66 static char *smb_myname;
  67 static char *smb_myworkgroup;
  68 static char *smb_scope;
  69 static int smb_num_netbios_names;
  70 static char **smb_my_netbios_names;
  71
  72 /***********************************************************************
  73  Allocate and set myname. Ensure upper case.
  74 ***********************************************************************/
  75
  76 bool set_global_myname(const char *myname)
  77 {
  78         SAFE_FREE(smb_myname);
  79         smb_myname = SMB_STRDUP(myname);
  80         if (!smb_myname)
  81                 return False;
  82         strupper_m(smb_myname);
  83         return True;
  84 }
  85
  86 const char *global_myname(void)
  87 {
  88         return smb_myname;
  89 }
  90
  91 /***********************************************************************
  92  Allocate and set myworkgroup. Ensure upper case.
  93 ***********************************************************************/
  94
  95 bool set_global_myworkgroup(const char *myworkgroup)
  96 {
  97         SAFE_FREE(smb_myworkgroup);
  98         smb_myworkgroup = SMB_STRDUP(myworkgroup);
  99         if (!smb_myworkgroup)
 100                 return False;
 101         strupper_m(smb_myworkgroup);
 102         return True;
 103 }
 104
 105 const char *lp_workgroup(void)
 106 {
 107         return smb_myworkgroup;
 108 }
 109
 110 /***********************************************************************
 111  Allocate and set scope. Ensure upper case.
 112 ***********************************************************************/
 113
 114 bool set_global_scope(const char *scope)
 115 {
 116         SAFE_FREE(smb_scope);
 117         smb_scope = SMB_STRDUP(scope);
 118         if (!smb_scope)
 119                 return False;
 120         strupper_m(smb_scope);
 121         return True;
 122 }
 123
 124 /*********************************************************************
 125  Ensure scope is never null string.
 126 *********************************************************************/
 127
 128 const char *global_scope(void)
 129 {
 130         if (!smb_scope)
 131                 set_global_scope("");
 132         return smb_scope;
 133 }
 134
 135 static void free_netbios_names_array(void)
 136 {
 137         int i;
 138
 139         for (i = 0; i < smb_num_netbios_names; i++)
 140                 SAFE_FREE(smb_my_netbios_names[i]);
 141
 142         SAFE_FREE(smb_my_netbios_names);
 143         smb_num_netbios_names = 0;
 144 }
 145
 146 static bool allocate_my_netbios_names_array(size_t number)
 147 {
 148         free_netbios_names_array();
 149
 150         smb_num_netbios_names = number + 1;
 151         smb_my_netbios_names = SMB_MALLOC_ARRAY( char *, smb_num_netbios_names );
 152
 153         if (!smb_my_netbios_names)
 154                 return False;
 155
 156         memset(smb_my_netbios_names, '\0', sizeof(char *) * smb_num_netbios_names);
 157         return True;
 158 }
 159
 160 static bool set_my_netbios_names(const char *name, int i)
 161 {
 162         SAFE_FREE(smb_my_netbios_names[i]);
 163
 164         smb_my_netbios_names[i] = SMB_STRDUP(name);
 165         if (!smb_my_netbios_names[i])
 166                 return False;
 167         strupper_m(smb_my_netbios_names[i]);
 168         return True;
 169 }
 170
 171 /***********************************************************************
 172  Free memory allocated to global objects
 173 ***********************************************************************/
 174
 175 void gfree_names(void)
 176 {
 177         SAFE_FREE( smb_myname );
 178         SAFE_FREE( smb_myworkgroup );
 179         SAFE_FREE( smb_scope );
 180         free_netbios_names_array();
 181         free_local_machine_name();
 182 }
 183
 184 void gfree_all( void )
 185 {
 186         gfree_names();
 187         gfree_loadparm();
 188         gfree_case_tables();
 189         gfree_charcnv();
 190         gfree_interfaces();
 191         gfree_debugsyms();
 192 }
 193
 194 const char *my_netbios_names(int i)
 195 {
 196         return smb_my_netbios_names[i];
 197 }
 198
 199 bool set_netbios_aliases(const char **str_array)
 200 {
 201         size_t namecount;
 202
 203         /* Work out the max number of netbios aliases that we have */
 204         for( namecount=0; str_array && (str_array[namecount] != NULL); namecount++ )
 205                 ;
 206
 207         if ( global_myname() && *global_myname())
 208                 namecount++;
 209
 210         /* Allocate space for the netbios aliases */
 211         if (!allocate_my_netbios_names_array(namecount))
 212                 return False;
 213
 214         /* Use the global_myname string first */
 215         namecount=0;
 216         if ( global_myname() && *global_myname()) {
 217                 set_my_netbios_names( global_myname(), namecount );
 218                 namecount++;
 219         }
 220
 221         if (str_array) {
 222                 size_t i;
 223                 for ( i = 0; str_array[i] != NULL; i++) {
 224                         size_t n;
 225                         bool duplicate = False;
 226
 227                         /* Look for duplicates */
 228                         for( n=0; n<namecount; n++ ) {
 229                                 if( strequal( str_array[i], my_netbios_names(n) ) ) {
 230                                         duplicate = True;
 231                                         break;
 232                                 }
 233                         }
 234                         if (!duplicate) {
 235                                 if (!set_my_netbios_names(str_array[i], namecount))
 236                                         return False;
 237                                 namecount++;
 238                         }
 239                 }
 240         }
 241         return True;
 242 }
 243
 244 /****************************************************************************
 245   Common name initialization code.
 246 ****************************************************************************/
 247
 248 bool init_names(void)
 249 {
 250         int n;
 251
 252         if (global_myname() == NULL || *global_myname() == '\0') {
 253                 if (!set_global_myname(myhostname())) {
 254                         DEBUG( 0, ( "init_structs: malloc fail.\n" ) );
 255                         return False;
 256                 }
 257         }
 258
 259         if (!set_netbios_aliases(lp_netbios_aliases())) {
 260                 DEBUG( 0, ( "init_structs: malloc fail.\n" ) );
 261                 return False;
 262         }
 263
 264         set_local_machine_name(global_myname(),false);
 265
 266         DEBUG( 5, ("Netbios name list:-\n") );
 267         for( n=0; my_netbios_names(n); n++ ) {
 268                 DEBUGADD( 5, ("my_netbios_names[%d]=\"%s\"\n",
 269                                         n, my_netbios_names(n) ) );
 270         }
 271
 272         return( True );
 273 }
 274
 275 /**************************************************************************n
 276   Code to cope with username/password auth options from the commandline.
 277   Used mainly in client tools.
 278 ****************************************************************************/
 279
 280 struct user_auth_info *user_auth_info_init(TALLOC_CTX *mem_ctx)
 281 {
 282         struct user_auth_info *result;
 283
 284         result = TALLOC_ZERO_P(mem_ctx, struct user_auth_info);
 285         if (result == NULL) {
 286                 return NULL;
 287         }
 288
 289         result->signing_state = Undefined;
 290         return result;
 291 }
 292
 293 const char *get_cmdline_auth_info_username(const struct user_auth_info *auth_info)
 294 {
 295         if (!auth_info->username) {
 296                 return "";
 297         }
 298         return auth_info->username;
 299 }
 300
 301 void set_cmdline_auth_info_username(struct user_auth_info *auth_info,
 302                                     const char *username)
 303 {
 304         TALLOC_FREE(auth_info->username);
 305         auth_info->username = talloc_strdup(auth_info, username);
 306         if (!auth_info->username) {
 307                 exit(ENOMEM);
 308         }
 309 }
 310
 311 const char *get_cmdline_auth_info_domain(const struct user_auth_info *auth_info)
 312 {
 313         if (!auth_info->domain) {
 314                 return "";
 315         }
 316         return auth_info->domain;
 317 }
 318
 319 void set_cmdline_auth_info_domain(struct user_auth_info *auth_info,
 320                                   const char *domain)
 321 {
 322         TALLOC_FREE(auth_info->domain);
 323         auth_info->domain = talloc_strdup(auth_info, domain);
 324         if (!auth_info->domain) {
 325                 exit(ENOMEM);
 326         }
 327 }
 328
 329 const char *get_cmdline_auth_info_password(const struct user_auth_info *auth_info)
 330 {
 331         if (!auth_info->password) {
 332                 return "";
 333         }
 334         return auth_info->password;
 335 }
 336
 337 void set_cmdline_auth_info_password(struct user_auth_info *auth_info,
 338                                     const char *password)
 339 {
 340         TALLOC_FREE(auth_info->password);
 341         if (password == NULL) {
 342                 password = "";
 343         }
 344         auth_info->password = talloc_strdup(auth_info, password);
 345         if (!auth_info->password) {
 346                 exit(ENOMEM);
 347         }
 348         auth_info->got_pass = true;
 349 }
 350
 351 bool set_cmdline_auth_info_signing_state(struct user_auth_info *auth_info,
 352                                          const char *arg)
 353 {
 354         auth_info->signing_state = -1;
 355         if (strequal(arg, "off") || strequal(arg, "no") ||
 356                         strequal(arg, "false")) {
 357                 auth_info->signing_state = false;
 358         } else if (strequal(arg, "on") || strequal(arg, "yes") ||
 359                         strequal(arg, "true") || strequal(arg, "auto")) {
 360                 auth_info->signing_state = true;
 361         } else if (strequal(arg, "force") || strequal(arg, "required") ||
 362                         strequal(arg, "forced")) {
 363                 auth_info->signing_state = Required;
 364         } else {
 365                 return false;
 366         }
 367         return true;
 368 }
 369
 370 int get_cmdline_auth_info_signing_state(const struct user_auth_info *auth_info)
 371 {
 372         return auth_info->signing_state;
 373 }
 374
 375 void set_cmdline_auth_info_use_kerberos(struct user_auth_info *auth_info,
 376                                         bool b)
 377 {
 378         auth_info->use_kerberos = b;
 379 }
 380
 381 bool get_cmdline_auth_info_use_kerberos(const struct user_auth_info *auth_info)
 382 {
 383         return auth_info->use_kerberos;
 384 }
 385
 386 void set_cmdline_auth_info_fallback_after_kerberos(struct user_auth_info *auth_info,
 387                                         bool b)
 388 {
 389         auth_info->fallback_after_kerberos = b;
 390 }
 391
 392 bool get_cmdline_auth_info_fallback_after_kerberos(const struct user_auth_info *auth_info)
 393 {
 394         return auth_info->fallback_after_kerberos;
 395 }
 396
 397 /* This should only be used by lib/popt_common.c JRA */
 398 void set_cmdline_auth_info_use_krb5_ticket(struct user_auth_info *auth_info)
 399 {
 400         auth_info->use_kerberos = true;
 401         auth_info->got_pass = true;
 402 }
 403
 404 /* This should only be used by lib/popt_common.c JRA */
 405 void set_cmdline_auth_info_smb_encrypt(struct user_auth_info *auth_info)
 406 {
 407         auth_info->smb_encrypt = true;
 408 }
 409
 410 void set_cmdline_auth_info_use_machine_account(struct user_auth_info *auth_info)
 411 {
 412         auth_info->use_machine_account = true;
 413 }
 414
 415 bool get_cmdline_auth_info_got_pass(const struct user_auth_info *auth_info)
 416 {
 417         return auth_info->got_pass;
 418 }
 419
 420 bool get_cmdline_auth_info_smb_encrypt(const struct user_auth_info *auth_info)
 421 {
 422         return auth_info->smb_encrypt;
 423 }
 424
 425 bool get_cmdline_auth_info_use_machine_account(const struct user_auth_info *auth_info)
 426 {
 427         return auth_info->use_machine_account;
 428 }
 429
 430 struct user_auth_info *get_cmdline_auth_info_copy(TALLOC_CTX *mem_ctx,
 431                                                   const struct user_auth_info *src)
 432 {
 433         struct user_auth_info *result;
 434
 435         result = user_auth_info_init(mem_ctx);
 436         if (result == NULL) {
 437                 return NULL;
 438         }
 439
 440         *result = *src;
 441
 442         result->username = talloc_strdup(
 443                 result, get_cmdline_auth_info_username(src));
 444         result->password = talloc_strdup(
 445                 result, get_cmdline_auth_info_password(src));
 446         if ((result->username == NULL) || (result->password == NULL)) {
 447                 TALLOC_FREE(result);
 448                 return NULL;
 449         }
 450
 451         return result;
 452 }
 453
 454 bool set_cmdline_auth_info_machine_account_creds(struct user_auth_info *auth_info)
 455 {
 456         char *pass = NULL;
 457         char *account = NULL;
 458
 459         if (!get_cmdline_auth_info_use_machine_account(auth_info)) {
 460                 return false;
 461         }
 462
 463         if (!secrets_init()) {
 464                 d_printf("ERROR: Unable to open secrets database\n");
 465                 return false;
 466         }
 467
 468         if (asprintf(&account, "%s$@%s", global_myname(), lp_realm()) < 0) {
 469                 return false;
 470         }
 471
 472         pass = secrets_fetch_machine_password(lp_workgroup(), NULL, NULL);
 473         if (!pass) {
 474                 d_printf("ERROR: Unable to fetch machine password for "
 475                         "%s in domain %s\n",
 476                         account, lp_workgroup());
 477                 SAFE_FREE(account);
 478                 return false;
 479         }
 480
 481         set_cmdline_auth_info_username(auth_info, account);
 482         set_cmdline_auth_info_password(auth_info, pass);
 483
 484         SAFE_FREE(account);
 485         SAFE_FREE(pass);
 486
 487         return true;
 488 }
 489
 490 /****************************************************************************
 491  Ensure we have a password if one not given.
 492 ****************************************************************************/
 493
 494 void set_cmdline_auth_info_getpass(struct user_auth_info *auth_info)
 495 {
 496         char *label = NULL;
 497         char *pass;
 498         TALLOC_CTX *frame;
 499
 500         if (get_cmdline_auth_info_got_pass(auth_info) ||
 501                         get_cmdline_auth_info_use_kerberos(auth_info)) {
 502                 /* Already got one... */
 503                 return;
 504         }
 505
 506         frame = talloc_stackframe();
 507         label = talloc_asprintf(frame, "Enter %s's password: ",
 508                         get_cmdline_auth_info_username(auth_info));
 509         pass = getpass(label);
 510         if (pass) {
 511                 set_cmdline_auth_info_password(auth_info, pass);
 512         }
 513         TALLOC_FREE(frame);
 514 }
 515
 516 /*******************************************************************
 517  Check if a file exists - call vfs_file_exist for samba files.
 518 ********************************************************************/
 519
 520 bool file_exist_stat(const char *fname,SMB_STRUCT_STAT *sbuf)
 521 {
 522         SMB_STRUCT_STAT st;
 523         if (!sbuf)
 524                 sbuf = &st;
 525
 526         if (sys_stat(fname,sbuf) != 0)
 527                 return(False);
 528
 529         return((S_ISREG(sbuf->st_ex_mode)) || (S_ISFIFO(sbuf->st_ex_mode)));
 530 }
 531
 532 /*******************************************************************
 533  Check if a unix domain socket exists - call vfs_file_exist for samba files.
 534 ********************************************************************/
 535
 536 bool socket_exist(const char *fname)
 537 {
 538         SMB_STRUCT_STAT st;
 539         if (sys_stat(fname,&st) != 0)
 540                 return(False);
 541
 542         return S_ISSOCK(st.st_ex_mode);
 543 }
 544
 545 /*******************************************************************
 546  Check if a directory exists.
 547 ********************************************************************/
 548
 549 bool directory_exist_stat(char *dname,SMB_STRUCT_STAT *st)
 550 {
 551         SMB_STRUCT_STAT st2;
 552         bool ret;
 553
 554         if (!st)
 555                 st = &st2;
 556
 557         if (sys_stat(dname,st) != 0)
 558                 return(False);
 559
 560         ret = S_ISDIR(st->st_ex_mode);
 561         if(!ret)
 562                 errno = ENOTDIR;
 563         return ret;
 564 }
 565
 566 /*******************************************************************
 567  Returns the size in bytes of the named given the stat struct.
 568 ********************************************************************/
 569
 570 uint64_t get_file_size_stat(const SMB_STRUCT_STAT *sbuf)
 571 {
 572         return sbuf->st_ex_size;
 573 }
 574
 575 /*******************************************************************
 576  Returns the size in bytes of the named file.
 577 ********************************************************************/
 578
 579 SMB_OFF_T get_file_size(char *file_name)
 580 {
 581         SMB_STRUCT_STAT buf;
 582         buf.st_ex_size = 0;
 583         if(sys_stat(file_name,&buf) != 0)
 584                 return (SMB_OFF_T)-1;
 585         return get_file_size_stat(&buf);
 586 }
 587
 588 /*******************************************************************
 589  Return a string representing an attribute for a file.
 590 ********************************************************************/
 591
 592 char *attrib_string(uint16 mode)
 593 {
 594         fstring attrstr;
 595
 596         attrstr[0] = 0;
 597
 598         if (mode & aVOLID) fstrcat(attrstr,"V");
 599         if (mode & aDIR) fstrcat(attrstr,"D");
 600         if (mode & aARCH) fstrcat(attrstr,"A");
 601         if (mode & aHIDDEN) fstrcat(attrstr,"H");
 602         if (mode & aSYSTEM) fstrcat(attrstr,"S");
 603         if (mode & aRONLY) fstrcat(attrstr,"R");
 604
 605         return talloc_strdup(talloc_tos(), attrstr);
 606 }
 607
 608 /*******************************************************************
 609  Show a smb message structure.
 610 ********************************************************************/
 611
 612 void show_msg(char *buf)
 613 {
 614         int i;
 615         int bcc=0;
 616
 617         if (!DEBUGLVL(5))
 618                 return;
 619
 620         DEBUG(5,("size=%d\nsmb_com=0x%x\nsmb_rcls=%d\nsmb_reh=%d\nsmb_err=%d\nsmb_flg=%d\nsmb_flg2=%d\n",
 621                         smb_len(buf),
 622                         (int)CVAL(buf,smb_com),
 623                         (int)CVAL(buf,smb_rcls),
 624                         (int)CVAL(buf,smb_reh),
 625                         (int)SVAL(buf,smb_err),
 626                         (int)CVAL(buf,smb_flg),
 627                         (int)SVAL(buf,smb_flg2)));
 628         DEBUGADD(5,("smb_tid=%d\nsmb_pid=%d\nsmb_uid=%d\nsmb_mid=%d\n",
 629                         (int)SVAL(buf,smb_tid),
 630                         (int)SVAL(buf,smb_pid),
 631                         (int)SVAL(buf,smb_uid),
 632                         (int)SVAL(buf,smb_mid)));
 633         DEBUGADD(5,("smt_wct=%d\n",(int)CVAL(buf,smb_wct)));
 634
 635         for (i=0;i<(int)CVAL(buf,smb_wct);i++)
 636                 DEBUGADD(5,("smb_vwv[%2d]=%5d (0x%X)\n",i,
 637                         SVAL(buf,smb_vwv+2*i),SVAL(buf,smb_vwv+2*i)));
 638
 639         bcc = (int)SVAL(buf,smb_vwv+2*(CVAL(buf,smb_wct)));
 640
 641         DEBUGADD(5,("smb_bcc=%d\n",bcc));
 642
 643         if (DEBUGLEVEL < 10)
 644                 return;
 645
 646         if (DEBUGLEVEL < 50)
 647                 bcc = MIN(bcc, 512);
 648
 649         dump_data(10, (uint8 *)smb_buf(buf), bcc);
 650 }
 651
 652 /*******************************************************************
 653  Set the length and marker of an encrypted smb packet.
 654 ********************************************************************/
 655
 656 void smb_set_enclen(char *buf,int len,uint16 enc_ctx_num)
 657 {
 658         _smb_setlen(buf,len);
 659
 660         SCVAL(buf,4,0xFF);
 661         SCVAL(buf,5,'E');
 662         SSVAL(buf,6,enc_ctx_num);
 663 }
 664
 665 /*******************************************************************
 666  Set the length and marker of an smb packet.
 667 ********************************************************************/
 668
 669 void smb_setlen(char *buf,int len)
 670 {
 671         _smb_setlen(buf,len);
 672
 673         SCVAL(buf,4,0xFF);
 674         SCVAL(buf,5,'S');
 675         SCVAL(buf,6,'M');
 676         SCVAL(buf,7,'B');
 677 }
 678
 679 /*******************************************************************
 680  Setup only the byte count for a smb message.
 681 ********************************************************************/
 682
 683 int set_message_bcc(char *buf,int num_bytes)
 684 {
 685         int num_words = CVAL(buf,smb_wct);
 686         SSVAL(buf,smb_vwv + num_words*SIZEOFWORD,num_bytes);
 687         _smb_setlen(buf,smb_size + num_words*2 + num_bytes - 4);
 688         return (smb_size + num_words*2 + num_bytes);
 689 }
 690
 691 /*******************************************************************
 692  Add a data blob to the end of a smb_buf, adjusting bcc and smb_len.
 693  Return the bytes added
 694 ********************************************************************/
 695
 696 ssize_t message_push_blob(uint8 **outbuf, DATA_BLOB blob)
 697 {
 698         size_t newlen = smb_len(*outbuf) + 4 + blob.length;
 699         uint8 *tmp;
 700
 701         if (!(tmp = TALLOC_REALLOC_ARRAY(NULL, *outbuf, uint8, newlen))) {
 702                 DEBUG(0, ("talloc failed\n"));
 703                 return -1;
 704         }
 705         *outbuf = tmp;
 706
 707         memcpy(tmp + smb_len(tmp) + 4, blob.data, blob.length);
 708         set_message_bcc((char *)tmp, smb_buflen(tmp) + blob.length);
 709         return blob.length;
 710 }
 711
 712 /*******************************************************************
 713  Reduce a file name, removing .. elements.
 714 ********************************************************************/
 715
 716 static char *dos_clean_name(TALLOC_CTX *ctx, const char *s)
 717 {
 718         char *p = NULL;
 719         char *str = NULL;
 720
 721         DEBUG(3,("dos_clean_name [%s]\n",s));
 722
 723         /* remove any double slashes */
 724         str = talloc_all_string_sub(ctx, s, "\\\\", "\\");
 725         if (!str) {
 726                 return NULL;
 727         }
 728
 729         /* Remove leading .\\ characters */
 730         if(strncmp(str, ".\\", 2) == 0) {
 731                 trim_string(str, ".\\", NULL);
 732                 if(*str == 0) {
 733                         str = talloc_strdup(ctx, ".\\");
 734                         if (!str) {
 735                                 return NULL;
 736                         }
 737                 }
 738         }
 739
 740         while ((p = strstr_m(str,"\\..\\")) != NULL) {
 741                 char *s1;
 742
 743                 *p = 0;
 744                 s1 = p+3;
 745
 746                 if ((p=strrchr_m(str,'\\')) != NULL) {
 747                         *p = 0;
 748                 } else {
 749                         *str = 0;
 750                 }
 751                 str = talloc_asprintf(ctx,
 752                                 "%s%s",
 753                                 str,
 754                                 s1);
 755                 if (!str) {
 756                         return NULL;
 757                 }
 758         }
 759
 760         trim_string(str,NULL,"\\..");
 761         return talloc_all_string_sub(ctx, str, "\\.\\", "\\");
 762 }
 763
 764 /*******************************************************************
 765  Reduce a file name, removing .. elements.
 766 ********************************************************************/
 767
 768 char *unix_clean_name(TALLOC_CTX *ctx, const char *s)
 769 {
 770         char *p = NULL;
 771         char *str = NULL;
 772
 773         DEBUG(3,("unix_clean_name [%s]\n",s));
 774
 775         /* remove any double slashes */
 776         str = talloc_all_string_sub(ctx, s, "//","/");
 777         if (!str) {
 778                 return NULL;
 779         }
 780
 781         /* Remove leading ./ characters */
 782         if(strncmp(str, "./", 2) == 0) {
 783                 trim_string(str, "./", NULL);
 784                 if(*str == 0) {
 785                         str = talloc_strdup(ctx, "./");
 786                         if (!str) {
 787                                 return NULL;
 788                         }
 789                 }
 790         }
 791
 792         while ((p = strstr_m(str,"/../")) != NULL) {
 793                 char *s1;
 794
 795                 *p = 0;
 796                 s1 = p+3;
 797
 798                 if ((p=strrchr_m(str,'/')) != NULL) {
 799                         *p = 0;
 800                 } else {
 801                         *str = 0;
 802                 }
 803                 str = talloc_asprintf(ctx,
 804                                 "%s%s",
 805                                 str,
 806                                 s1);
 807                 if (!str) {
 808                         return NULL;
 809                 }
 810         }
 811
 812         trim_string(str,NULL,"/..");
 813         return talloc_all_string_sub(ctx, str, "/./", "/");
 814 }
 815
 816 char *clean_name(TALLOC_CTX *ctx, const char *s)
 817 {
 818         char *str = dos_clean_name(ctx, s);
 819         if (!str) {
 820                 return NULL;
 821         }
 822         return unix_clean_name(ctx, str);
 823 }
 824
 825 /*******************************************************************
 826  Write data into an fd at a given offset. Ignore seek errors.
 827 ********************************************************************/
 828
 829 ssize_t write_data_at_offset(int fd, const char *buffer, size_t N, SMB_OFF_T pos)
 830 {
 831         size_t total=0;
 832         ssize_t ret;
 833
 834         if (pos == (SMB_OFF_T)-1) {
 835                 return write_data(fd, buffer, N);
 836         }
 837 #if defined(HAVE_PWRITE) || defined(HAVE_PRWITE64)
 838         while (total < N) {
 839                 ret = sys_pwrite(fd,buffer + total,N - total, pos);
 840                 if (ret == -1 && errno == ESPIPE) {
 841                         return write_data(fd, buffer + total,N - total);
 842                 }
 843                 if (ret == -1) {
 844                         DEBUG(0,("write_data_at_offset: write failure. Error = %s\n", strerror(errno) ));
 845                         return -1;
 846                 }
 847                 if (ret == 0) {
 848                         return total;
 849                 }
 850                 total += ret;
 851                 pos += ret;
 852         }
 853         return (ssize_t)total;
 854 #else
 855         /* Use lseek and write_data. */
 856         if (sys_lseek(fd, pos, SEEK_SET) == -1) {
 857                 if (errno != ESPIPE) {
 858                         return -1;
 859                 }
 860         }
 861         return write_data(fd, buffer, N);
 862 #endif
 863 }
 864
 865 /*******************************************************************
 866  Sleep for a specified number of milliseconds.
 867 ********************************************************************/
 868
 869 void smb_msleep(unsigned int t)
 870 {
 871 #if defined(HAVE_NANOSLEEP)
 872         struct timespec tval;
 873         int ret;
 874
 875         tval.tv_sec = t/1000;
 876         tval.tv_nsec = 1000000*(t%1000);
 877
 878         do {
 879                 errno = 0;
 880                 ret = nanosleep(&tval, &tval);
 881         } while (ret < 0 && errno == EINTR && (tval.tv_sec > 0 || tval.tv_nsec > 0));
 882 #else
 883         unsigned int tdiff=0;
 884         struct timeval tval,t1,t2;
 885         fd_set fds;
 886
 887         GetTimeOfDay(&t1);
 888         t2 = t1;
 889
 890         while (tdiff < t) {
 891                 tval.tv_sec = (t-tdiff)/1000;
 892                 tval.tv_usec = 1000*((t-tdiff)%1000);
 893
 894                 /* Never wait for more than 1 sec. */
 895                 if (tval.tv_sec > 1) {
 896                         tval.tv_sec = 1;
 897                         tval.tv_usec = 0;
 898                 }
 899
 900                 FD_ZERO(&fds);
 901                 errno = 0;
 902                 sys_select_intr(0,&fds,NULL,NULL,&tval);
 903
 904                 GetTimeOfDay(&t2);
 905                 if (t2.tv_sec < t1.tv_sec) {
 906                         /* Someone adjusted time... */
 907                         t1 = t2;
 908                 }
 909
 910                 tdiff = TvalDiff(&t1,&t2);
 911         }
 912 #endif
 913 }
 914
 915 NTSTATUS reinit_after_fork(struct messaging_context *msg_ctx,
 916                        struct event_context *ev_ctx,
 917                        bool parent_longlived)
 918 {
 919         NTSTATUS status = NT_STATUS_OK;
 920
 921         /* Reset the state of the random
 922          * number generation system, so
 923          * children do not get the same random
 924          * numbers as each other */
 925         set_need_random_reseed();
 926
 927         /* tdb needs special fork handling */
 928         if (tdb_reopen_all(parent_longlived ? 1 : 0) == -1) {
 929                 DEBUG(0,("tdb_reopen_all failed.\n"));
 930                 status = NT_STATUS_OPEN_FAILED;
 931                 goto done;
 932         }
 933
 934         if (ev_ctx) {
 935                 event_context_reinit(ev_ctx);
 936         }
 937
 938         if (msg_ctx) {
 939                 /*
 940                  * For clustering, we need to re-init our ctdbd connection after the
 941                  * fork
 942                  */
 943                 status = messaging_reinit(msg_ctx);
 944                 if (!NT_STATUS_IS_OK(status)) {
 945                         DEBUG(0,("messaging_reinit() failed: %s\n",
 946                                  nt_errstr(status)));
 947                 }
 948         }
 949  done:
 950         return status;
 951 }
 952
 953 /****************************************************************************
 954  Put up a yes/no prompt.
 955 ****************************************************************************/
 956
 957 bool yesno(const char *p)
 958 {
 959         char ans[20];
 960         printf("%s",p);
 961
 962         if (!fgets(ans,sizeof(ans)-1,stdin))
 963                 return(False);
 964
 965         if (*ans == 'y' || *ans == 'Y')
 966                 return(True);
 967
 968         return(False);
 969 }
 970
 971 #if defined(PARANOID_MALLOC_CHECKER)
 972
 973 /****************************************************************************
 974  Internal malloc wrapper. Externally visible.
 975 ****************************************************************************/
 976
 977 void *malloc_(size_t size)
 978 {
 979         if (size == 0) {
 980                 return NULL;
 981         }
 982 #undef malloc
 983         return malloc(size);
 984 #define malloc(s) __ERROR_DONT_USE_MALLOC_DIRECTLY
 985 }
 986
 987 /****************************************************************************
 988  Internal calloc wrapper. Not externally visible.
 989 ****************************************************************************/
 990
 991 static void *calloc_(size_t count, size_t size)
 992 {
 993         if (size == 0 || count == 0) {
 994                 return NULL;
 995         }
 996 #undef calloc
 997         return calloc(count, size);
 998 #define calloc(n,s) __ERROR_DONT_USE_CALLOC_DIRECTLY
 999 }
1000
1001 /****************************************************************************
1002  Internal realloc wrapper. Not externally visible.
1003 ****************************************************************************/
1004
1005 static void *realloc_(void *ptr, size_t size)
1006 {
1007 #undef realloc
1008         return realloc(ptr, size);
1009 #define realloc(p,s) __ERROR_DONT_USE_RELLOC_DIRECTLY
1010 }
1011
1012 #endif /* PARANOID_MALLOC_CHECKER */
1013
1014 /****************************************************************************
1015  Type-safe memalign
1016 ****************************************************************************/
1017
1018 void *memalign_array(size_t el_size, size_t align, unsigned int count)
1019 {
1020         if (count >= MAX_ALLOC_SIZE/el_size) {
1021                 return NULL;
1022         }
1023
1024         return sys_memalign(align, el_size*count);
1025 }
1026
1027 /****************************************************************************
1028  Type-safe calloc.
1029 ****************************************************************************/
1030
1031 void *calloc_array(size_t size, size_t nmemb)
1032 {
1033         if (nmemb >= MAX_ALLOC_SIZE/size) {
1034                 return NULL;
1035         }
1036         if (size == 0 || nmemb == 0) {
1037                 return NULL;
1038         }
1039 #if defined(PARANOID_MALLOC_CHECKER)
1040         return calloc_(nmemb, size);
1041 #else
1042         return calloc(nmemb, size);
1043 #endif
1044 }
1045
1046 /****************************************************************************
1047  Expand a pointer to be a particular size.
1048  Note that this version of Realloc has an extra parameter that decides
1049  whether to free the passed in storage on allocation failure or if the
1050  new size is zero.
1051
1052  This is designed for use in the typical idiom of :
1053
1054  p = SMB_REALLOC(p, size)
1055  if (!p) {
1056     return error;
1057  }
1058
1059  and not to have to keep track of the old 'p' contents to free later, nor
1060  to worry if the size parameter was zero. In the case where NULL is returned
1061  we guarentee that p has been freed.
1062
1063  If free later semantics are desired, then pass 'free_old_on_error' as False which
1064  guarentees that the old contents are not freed on error, even if size == 0. To use
1065  this idiom use :
1066
1067  tmp = SMB_REALLOC_KEEP_OLD_ON_ERROR(p, size);
1068  if (!tmp) {
1069     SAFE_FREE(p);
1070     return error;
1071  } else {
1072     p = tmp;
1073  }
1074
1075  Changes were instigated by Coverity error checking. JRA.
1076 ****************************************************************************/
1077
1078 void *Realloc(void *p, size_t size, bool free_old_on_error)
1079 {
1080         void *ret=NULL;
1081
1082         if (size == 0) {
1083                 if (free_old_on_error) {
1084                         SAFE_FREE(p);
1085                 }
1086                 DEBUG(2,("Realloc asked for 0 bytes\n"));
1087                 return NULL;
1088         }
1089
1090 #if defined(PARANOID_MALLOC_CHECKER)
1091         if (!p) {
1092                 ret = (void *)malloc_(size);
1093         } else {
1094                 ret = (void *)realloc_(p,size);
1095         }
1096 #else
1097         if (!p) {
1098                 ret = (void *)malloc(size);
1099         } else {
1100                 ret = (void *)realloc(p,size);
1101         }
1102 #endif
1103
1104         if (!ret) {
1105                 if (free_old_on_error && p) {
1106                         SAFE_FREE(p);
1107                 }
1108                 DEBUG(0,("Memory allocation error: failed to expand to %d bytes\n",(int)size));
1109         }
1110
1111         return(ret);
1112 }
1113
1114 /****************************************************************************
1115  (Hopefully) efficient array append.
1116 ****************************************************************************/
1117
1118 void add_to_large_array(TALLOC_CTX *mem_ctx, size_t element_size,
1119                         void *element, void *_array, uint32 *num_elements,
1120                         ssize_t *array_size)
1121 {
1122         void **array = (void **)_array;
1123
1124         if (*array_size < 0) {
1125                 return;
1126         }
1127
1128         if (*array == NULL) {
1129                 if (*array_size == 0) {
1130                         *array_size = 128;
1131                 }
1132
1133                 if (*array_size >= MAX_ALLOC_SIZE/element_size) {
1134                         goto error;
1135                 }
1136
1137                 *array = TALLOC(mem_ctx, element_size * (*array_size));
1138                 if (*array == NULL) {
1139                         goto error;
1140                 }
1141         }
1142
1143         if (*num_elements == *array_size) {
1144                 *array_size *= 2;
1145
1146                 if (*array_size >= MAX_ALLOC_SIZE/element_size) {
1147                         goto error;
1148                 }
1149
1150                 *array = TALLOC_REALLOC(mem_ctx, *array,
1151                                         element_size * (*array_size));
1152
1153                 if (*array == NULL) {
1154                         goto error;
1155                 }
1156         }
1157
1158         memcpy((char *)(*array) + element_size*(*num_elements),
1159                element, element_size);
1160         *num_elements += 1;
1161
1162         return;
1163
1164  error:
1165         *num_elements = 0;
1166         *array_size = -1;
1167 }
1168
1169 /****************************************************************************
1170  Get my own domain name, or "" if we have none.
1171 ****************************************************************************/
1172
1173 char *get_mydnsdomname(TALLOC_CTX *ctx)
1174 {
1175         const char *domname;
1176         char *p;
1177
1178         domname = get_mydnsfullname();
1179         if (!domname) {
1180                 return NULL;
1181         }
1182
1183         p = strchr_m(domname, '.');
1184         if (p) {
1185                 p++;
1186                 return talloc_strdup(ctx, p);
1187         } else {
1188                 return talloc_strdup(ctx, "");
1189         }
1190 }
1191
1192 /****************************************************************************
1193  Interpret a protocol description string, with a default.
1194 ****************************************************************************/
1195
1196 int interpret_protocol(const char *str,int def)
1197 {
1198         if (strequal(str,"NT1"))
1199                 return(PROTOCOL_NT1);
1200         if (strequal(str,"LANMAN2"))
1201                 return(PROTOCOL_LANMAN2);
1202         if (strequal(str,"LANMAN1"))
1203                 return(PROTOCOL_LANMAN1);
1204         if (strequal(str,"CORE"))
1205                 return(PROTOCOL_CORE);
1206         if (strequal(str,"COREPLUS"))
1207                 return(PROTOCOL_COREPLUS);
1208         if (strequal(str,"CORE+"))
1209                 return(PROTOCOL_COREPLUS);
1210
1211         DEBUG(0,("Unrecognised protocol level %s\n",str));
1212
1213         return(def);
1214 }
1215
1216
1217 #if (defined(HAVE_NETGROUP) && defined(WITH_AUTOMOUNT))
1218 /******************************************************************
1219  Remove any mount options such as -rsize=2048,wsize=2048 etc.
1220  Based on a fix from <Thomas.Hepper@icem.de>.
1221  Returns a malloc'ed string.
1222 *******************************************************************/
1223
1224 static char *strip_mount_options(TALLOC_CTX *ctx, const char *str)
1225 {
1226         if (*str == '-') {
1227                 const char *p = str;
1228                 while(*p && !isspace(*p))
1229                         p++;
1230                 while(*p && isspace(*p))
1231                         p++;
1232                 if(*p) {
1233                         return talloc_strdup(ctx, p);
1234                 }
1235         }
1236         return NULL;
1237 }
1238
1239 /*******************************************************************
1240  Patch from jkf@soton.ac.uk
1241  Split Luke's automount_server into YP lookup and string splitter
1242  so can easily implement automount_path().
1243  Returns a malloc'ed string.
1244 *******************************************************************/
1245
1246 #ifdef WITH_NISPLUS_HOME
1247 char *automount_lookup(TALLOC_CTX *ctx, const char *user_name)
1248 {
1249         char *value = NULL;
1250
1251         char *nis_map = (char *)lp_nis_home_map_name();
1252
1253         char buffer[NIS_MAXATTRVAL + 1];
1254         nis_result *result;
1255         nis_object *object;
1256         entry_obj  *entry;
1257
1258         snprintf(buffer, sizeof(buffer), "[key=%s],%s", user_name, nis_map);
1259         DEBUG(5, ("NIS+ querystring: %s\n", buffer));
1260
1261         if (result = nis_list(buffer, FOLLOW_PATH|EXPAND_NAME|HARD_LOOKUP, NULL, NULL)) {
1262                 if (result->status != NIS_SUCCESS) {
1263                         DEBUG(3, ("NIS+ query failed: %s\n", nis_sperrno(result->status)));
1264                 } else {
1265                         object = result->objects.objects_val;
1266                         if (object->zo_data.zo_type == ENTRY_OBJ) {
1267                                 entry = &object->zo_data.objdata_u.en_data;
1268                                 DEBUG(5, ("NIS+ entry type: %s\n", entry->en_type));
1269                                 DEBUG(3, ("NIS+ result: %s\n", entry->en_cols.en_cols_val[1].ec_value.ec_value_val));
1270
1271                                 value = talloc_strdup(ctx,
1272                                                 entry->en_cols.en_cols_val[1].ec_value.ec_value_val);
1273                                 if (!value) {
1274                                         nis_freeresult(result);
1275                                         return NULL;
1276                                 }
1277                                 value = talloc_string_sub(ctx,
1278                                                 value,
1279                                                 "&",
1280                                                 user_name);
1281                         }
1282                 }
1283         }
1284         nis_freeresult(result);
1285
1286         if (value) {
1287                 value = strip_mount_options(ctx, value);
1288                 DEBUG(4, ("NIS+ Lookup: %s resulted in %s\n",
1289                                         user_name, value));
1290         }
1291         return value;
1292 }
1293 #else /* WITH_NISPLUS_HOME */
1294
1295 char *automount_lookup(TALLOC_CTX *ctx, const char *user_name)
1296 {
1297         char *value = NULL;
1298
1299         int nis_error;        /* returned by yp all functions */
1300         char *nis_result;     /* yp_match inits this */
1301         int nis_result_len;  /* and set this */
1302         char *nis_domain;     /* yp_get_default_domain inits this */
1303         char *nis_map = (char *)lp_nis_home_map_name();
1304
1305         if ((nis_error = yp_get_default_domain(&nis_domain)) != 0) {
1306                 DEBUG(3, ("YP Error: %s\n", yperr_string(nis_error)));
1307                 return NULL;
1308         }
1309
1310         DEBUG(5, ("NIS Domain: %s\n", nis_domain));
1311
1312         if ((nis_error = yp_match(nis_domain, nis_map, user_name,
1313                                         strlen(user_name), &nis_result,
1314                                         &nis_result_len)) == 0) {
1315                 value = talloc_strdup(ctx, nis_result);
1316                 if (!value) {
1317                         return NULL;
1318                 }
1319                 value = strip_mount_options(ctx, value);
1320         } else if(nis_error == YPERR_KEY) {
1321                 DEBUG(3, ("YP Key not found:  while looking up \"%s\" in map \"%s\"\n",
1322                                 user_name, nis_map));
1323                 DEBUG(3, ("using defaults for server and home directory\n"));
1324         } else {
1325                 DEBUG(3, ("YP Error: \"%s\" while looking up \"%s\" in map \"%s\"\n",
1326                                 yperr_string(nis_error), user_name, nis_map));
1327         }
1328
1329         if (value) {
1330                 DEBUG(4, ("YP Lookup: %s resulted in %s\n", user_name, value));
1331         }
1332         return value;
1333 }
1334 #endif /* WITH_NISPLUS_HOME */
1335 #endif
1336
1337 /****************************************************************************
1338  Check if a process exists. Does this work on all unixes?
1339 ****************************************************************************/
1340
1341 bool process_exists(const struct server_id pid)
1342 {
1343         if (procid_is_me(&pid)) {
1344                 return True;
1345         }
1346
1347         if (procid_is_local(&pid)) {
1348                 return (kill(pid.pid,0) == 0 || errno != ESRCH);
1349         }
1350
1351 #ifdef CLUSTER_SUPPORT
1352         return ctdbd_process_exists(messaging_ctdbd_connection(), pid.vnn,
1353                                     pid.pid);
1354 #else
1355         return False;
1356 #endif
1357 }
1358
1359 /*******************************************************************
1360  Convert a uid into a user name.
1361 ********************************************************************/
1362
1363 const char *uidtoname(uid_t uid)
1364 {
1365         TALLOC_CTX *ctx = talloc_tos();
1366         char *name = NULL;
1367         struct passwd *pass = NULL;
1368
1369         pass = getpwuid_alloc(ctx,uid);
1370         if (pass) {
1371                 name = talloc_strdup(ctx,pass->pw_name);
1372                 TALLOC_FREE(pass);
1373         } else {
1374                 name = talloc_asprintf(ctx,
1375                                 "%ld",
1376                                 (long int)uid);
1377         }
1378         return name;
1379 }
1380
1381 /*******************************************************************
1382  Convert a gid into a group name.
1383 ********************************************************************/
1384
1385 char *gidtoname(gid_t gid)
1386 {
1387         struct group *grp;
1388
1389         grp = getgrgid(gid);
1390         if (grp) {
1391                 return talloc_strdup(talloc_tos(), grp->gr_name);
1392         }
1393         else {
1394                 return talloc_asprintf(talloc_tos(),
1395                                         "%d",
1396                                         (int)gid);
1397         }
1398 }
1399
1400 /*******************************************************************
1401  Convert a user name into a uid.
1402 ********************************************************************/
1403
1404 uid_t nametouid(const char *name)
1405 {
1406         struct passwd *pass;
1407         char *p;
1408         uid_t u;
1409
1410         pass = getpwnam_alloc(talloc_autofree_context(), name);
1411         if (pass) {
1412                 u = pass->pw_uid;
1413                 TALLOC_FREE(pass);
1414                 return u;
1415         }
1416
1417         u = (uid_t)strtol(name, &p, 0);
1418         if ((p != name) && (*p == '\0'))
1419                 return u;
1420
1421         return (uid_t)-1;
1422 }
1423
1424 /*******************************************************************
1425  Convert a name to a gid_t if possible. Return -1 if not a group.
1426 ********************************************************************/
1427
1428 gid_t nametogid(const char *name)
1429 {
1430         struct group *grp;
1431         char *p;
1432         gid_t g;
1433
1434         g = (gid_t)strtol(name, &p, 0);
1435         if ((p != name) && (*p == '\0'))
1436                 return g;
1437
1438         grp = sys_getgrnam(name);
1439         if (grp)
1440                 return(grp->gr_gid);
1441         return (gid_t)-1;
1442 }
1443
1444 /*******************************************************************
1445  Something really nasty happened - panic !
1446 ********************************************************************/
1447
1448 void smb_panic(const char *const why)
1449 {
1450         char *cmd;
1451         int result;
1452
1453 #ifdef DEVELOPER
1454         {
1455
1456                 if (global_clobber_region_function) {
1457                         DEBUG(0,("smb_panic: clobber_region() last called from [%s(%u)]\n",
1458                                          global_clobber_region_function,
1459                                          global_clobber_region_line));
1460                 }
1461         }
1462 #endif
1463
1464         DEBUG(0,("PANIC (pid %llu): %s\n",
1465                     (unsigned long long)sys_getpid(), why));
1466         log_stack_trace();
1467
1468         cmd = lp_panic_action();
1469         if (cmd && *cmd) {
1470                 DEBUG(0, ("smb_panic(): calling panic action [%s]\n", cmd));
1471                 result = system(cmd);
1472
1473                 if (result == -1)
1474                         DEBUG(0, ("smb_panic(): fork failed in panic action: %s\n",
1475                                           strerror(errno)));
1476                 else
1477                         DEBUG(0, ("smb_panic(): action returned status %d\n",
1478                                           WEXITSTATUS(result)));
1479         }
1480
1481         dump_core();
1482 }
1483
1484 /*******************************************************************
1485  Print a backtrace of the stack to the debug log. This function
1486  DELIBERATELY LEAKS MEMORY. The expectation is that you should
1487  exit shortly after calling it.
1488 ********************************************************************/
1489
1490 #ifdef HAVE_LIBUNWIND_H
1491 #include <libunwind.h>
1492 #endif
1493
1494 #ifdef HAVE_EXECINFO_H
1495 #include <execinfo.h>
1496 #endif
1497
1498 #ifdef HAVE_LIBEXC_H
1499 #include <libexc.h>
1500 #endif
1501
1502 void log_stack_trace(void)
1503 {
1504 #ifdef HAVE_LIBUNWIND
1505         /* Try to use libunwind before any other technique since on ia64
1506          * libunwind correctly walks the stack in more circumstances than
1507          * backtrace.
1508          */
1509         unw_cursor_t cursor;
1510         unw_context_t uc;
1511         unsigned i = 0;
1512
1513         char procname[256];
1514         unw_word_t ip, sp, off;
1515
1516         procname[sizeof(procname) - 1] = '\0';
1517
1518         if (unw_getcontext(&uc) != 0) {
1519                 goto libunwind_failed;
1520         }
1521
1522         if (unw_init_local(&cursor, &uc) != 0) {
1523                 goto libunwind_failed;
1524         }
1525
1526         DEBUG(0, ("BACKTRACE:\n"));
1527
1528         do {
1529             ip = sp = 0;
1530             unw_get_reg(&cursor, UNW_REG_IP, &ip);
1531             unw_get_reg(&cursor, UNW_REG_SP, &sp);
1532
1533             switch (unw_get_proc_name(&cursor,
1534                         procname, sizeof(procname) - 1, &off) ) {
1535             case 0:
1536                     /* Name found. */
1537             case -UNW_ENOMEM:
1538                     /* Name truncated. */
1539                     DEBUGADD(0, (" #%u %s + %#llx [ip=%#llx] [sp=%#llx]\n",
1540                             i, procname, (long long)off,
1541                             (long long)ip, (long long) sp));
1542                     break;
1543             default:
1544             /* case -UNW_ENOINFO: */
1545             /* case -UNW_EUNSPEC: */
1546                     /* No symbol name found. */
1547                     DEBUGADD(0, (" #%u %s [ip=%#llx] [sp=%#llx]\n",
1548                             i, "<unknown symbol>",
1549                             (long long)ip, (long long) sp));
1550             }
1551             ++i;
1552         } while (unw_step(&cursor) > 0);
1553
1554         return;
1555
1556 libunwind_failed:
1557         DEBUG(0, ("unable to produce a stack trace with libunwind\n"));
1558
1559 #elif HAVE_BACKTRACE_SYMBOLS
1560         void *backtrace_stack[BACKTRACE_STACK_SIZE];
1561         size_t backtrace_size;
1562         char **backtrace_strings;
1563
1564         /* get the backtrace (stack frames) */
1565         backtrace_size = backtrace(backtrace_stack,BACKTRACE_STACK_SIZE);
1566         backtrace_strings = backtrace_symbols(backtrace_stack, backtrace_size);
1567
1568         DEBUG(0, ("BACKTRACE: %lu stack frames:\n",
1569                   (unsigned long)backtrace_size));
1570
1571         if (backtrace_strings) {
1572                 int i;
1573
1574                 for (i = 0; i < backtrace_size; i++)
1575                         DEBUGADD(0, (" #%u %s\n", i, backtrace_strings[i]));
1576
1577                 /* Leak the backtrace_strings, rather than risk what free() might do */
1578         }
1579
1580 #elif HAVE_LIBEXC
1581
1582         /* The IRIX libexc library provides an API for unwinding the stack. See
1583          * libexc(3) for details. Apparantly trace_back_stack leaks memory, but
1584          * since we are about to abort anyway, it hardly matters.
1585          */
1586
1587 #define NAMESIZE 32 /* Arbitrary */
1588
1589         __uint64_t      addrs[BACKTRACE_STACK_SIZE];
1590         char *          names[BACKTRACE_STACK_SIZE];
1591         char            namebuf[BACKTRACE_STACK_SIZE * NAMESIZE];
1592
1593         int             i;
1594         int             levels;
1595
1596         ZERO_ARRAY(addrs);
1597         ZERO_ARRAY(names);
1598         ZERO_ARRAY(namebuf);
1599
1600         /* We need to be root so we can open our /proc entry to walk
1601          * our stack. It also helps when we want to dump core.
1602          */
1603         become_root();
1604
1605         for (i = 0; i < BACKTRACE_STACK_SIZE; i++) {
1606                 names[i] = namebuf + (i * NAMESIZE);
1607         }
1608
1609         levels = trace_back_stack(0, addrs, names,
1610                         BACKTRACE_STACK_SIZE, NAMESIZE - 1);
1611
1612         DEBUG(0, ("BACKTRACE: %d stack frames:\n", levels));
1613         for (i = 0; i < levels; i++) {
1614                 DEBUGADD(0, (" #%d 0x%llx %s\n", i, addrs[i], names[i]));
1615         }
1616 #undef NAMESIZE
1617
1618 #else
1619         DEBUG(0, ("unable to produce a stack trace on this platform\n"));
1620 #endif
1621 }
1622
1623 /*******************************************************************
1624   A readdir wrapper which just returns the file name.
1625  ********************************************************************/
1626
1627 const char *readdirname(SMB_STRUCT_DIR *p)
1628 {
1629         SMB_STRUCT_DIRENT *ptr;
1630         char *dname;
1631
1632         if (!p)
1633                 return(NULL);
1634
1635         ptr = (SMB_STRUCT_DIRENT *)sys_readdir(p);
1636         if (!ptr)
1637                 return(NULL);
1638
1639         dname = ptr->d_name;
1640
1641 #ifdef NEXT2
1642         if (telldir(p) < 0)
1643                 return(NULL);
1644 #endif
1645
1646 #ifdef HAVE_BROKEN_READDIR_NAME
1647         /* using /usr/ucb/cc is BAD */
1648         dname = dname - 2;
1649 #endif
1650
1651         return talloc_strdup(talloc_tos(), dname);
1652 }
1653
1654 /*******************************************************************
1655  Utility function used to decide if the last component
1656  of a path matches a (possibly wildcarded) entry in a namelist.
1657 ********************************************************************/
1658
1659 bool is_in_path(const char *name, name_compare_entry *namelist, bool case_sensitive)
1660 {
1661         const char *last_component;
1662
1663         /* if we have no list it's obviously not in the path */
1664         if((namelist == NULL ) || ((namelist != NULL) && (namelist[0].name == NULL))) {
1665                 return False;
1666         }
1667
1668         DEBUG(8, ("is_in_path: %s\n", name));
1669
1670         /* Get the last component of the unix name. */
1671         last_component = strrchr_m(name, '/');
1672         if (!last_component) {
1673                 last_component = name;
1674         } else {
1675                 last_component++; /* Go past '/' */
1676         }
1677
1678         for(; namelist->name != NULL; namelist++) {
1679                 if(namelist->is_wild) {
1680                         if (mask_match(last_component, namelist->name, 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, bool is_case_sensitive)
2378 {
2379         if (strcmp(string,"..") == 0)
2380                 string = ".";
2381         if (strcmp(pattern,".") == 0)
2382                 return False;
2383
2384         return ms_fnmatch(pattern, string, Protocol <= PROTOCOL_LANMAN2, is_case_sensitive) == 0;
2385 }
2386
2387 /*******************************************************************
2388  A wrapper that handles case sensitivity and the special handling
2389  of the ".." name. Varient that is only called by old search code which requires
2390  pattern translation.
2391 *******************************************************************/
2392
2393 bool mask_match_search(const char *string, const char *pattern, bool is_case_sensitive)
2394 {
2395         if (strcmp(string,"..") == 0)
2396                 string = ".";
2397         if (strcmp(pattern,".") == 0)
2398                 return False;
2399
2400         return ms_fnmatch(pattern, string, True, is_case_sensitive) == 0;
2401 }
2402
2403 /*******************************************************************
2404  A wrapper that handles a list of patters and calls mask_match()
2405  on each.  Returns True if any of the patterns match.
2406 *******************************************************************/
2407
2408 bool mask_match_list(const char *string, char **list, int listLen, bool is_case_sensitive)
2409 {
2410        while (listLen-- > 0) {
2411                if (mask_match(string, *list++, is_case_sensitive))
2412                        return True;
2413        }
2414        return False;
2415 }
2416
2417 /*********************************************************
2418  Recursive routine that is called by unix_wild_match.
2419 *********************************************************/
2420
2421 static bool unix_do_match(const char *regexp, const char *str)
2422 {
2423         const char *p;
2424
2425         for( p = regexp; *p && *str; ) {
2426
2427                 switch(*p) {
2428                         case '?':
2429                                 str++;
2430                                 p++;
2431                                 break;
2432
2433                         case '*':
2434
2435                                 /*
2436                                  * Look for a character matching
2437                                  * the one after the '*'.
2438                                  */
2439                                 p++;
2440                                 if(!*p)
2441                                         return true; /* Automatic match */
2442                                 while(*str) {
2443
2444                                         while(*str && (*p != *str))
2445                                                 str++;
2446
2447                                         /*
2448                                          * Patch from weidel@multichart.de. In the case of the regexp
2449                                          * '*XX*' we want to ensure there are at least 2 'X' characters
2450                                          * in the string after the '*' for a match to be made.
2451                                          */
2452
2453                                         {
2454                                                 int matchcount=0;
2455
2456                                                 /*
2457                                                  * Eat all the characters that match, but count how many there were.
2458                                                  */
2459
2460                                                 while(*str && (*p == *str)) {
2461                                                         str++;
2462                                                         matchcount++;
2463                                                 }
2464
2465                                                 /*
2466                                                  * Now check that if the regexp had n identical characters that
2467                                                  * matchcount had at least that many matches.
2468                                                  */
2469
2470                                                 while ( *(p+1) && (*(p+1) == *p)) {
2471                                                         p++;
2472                                                         matchcount--;
2473                                                 }
2474
2475                                                 if ( matchcount <= 0 )
2476                                                         return false;
2477                                         }
2478
2479                                         str--; /* We've eaten the match char after the '*' */
2480
2481                                         if(unix_do_match(p, str))
2482                                                 return true;
2483
2484                                         if(!*str)
2485                                                 return false;
2486                                         else
2487                                                 str++;
2488                                 }
2489                                 return false;
2490
2491                         default:
2492                                 if(*str != *p)
2493                                         return false;
2494                                 str++;
2495                                 p++;
2496                                 break;
2497                 }
2498         }
2499
2500         if(!*p && !*str)
2501                 return true;
2502
2503         if (!*p && str[0] == '.' && str[1] == 0)
2504                 return true;
2505
2506         if (!*str && *p == '?') {
2507                 while (*p == '?')
2508                         p++;
2509                 return(!*p);
2510         }
2511
2512         if(!*str && (*p == '*' && p[1] == '\0'))
2513                 return true;
2514
2515         return false;
2516 }
2517
2518 /*******************************************************************
2519  Simple case insensitive interface to a UNIX wildcard matcher.
2520  Returns True if match, False if not.
2521 *******************************************************************/
2522
2523 bool unix_wild_match(const char *pattern, const char *string)
2524 {
2525         TALLOC_CTX *ctx = talloc_stackframe();
2526         char *p2;
2527         char *s2;
2528         char *p;
2529         bool ret = false;
2530
2531         p2 = talloc_strdup(ctx,pattern);
2532         s2 = talloc_strdup(ctx,string);
2533         if (!p2 || !s2) {
2534                 TALLOC_FREE(ctx);
2535                 return false;
2536         }
2537         strlower_m(p2);
2538         strlower_m(s2);
2539
2540         /* Remove any *? and ** from the pattern as they are meaningless */
2541         for(p = p2; *p; p++) {
2542                 while( *p == '*' && (p[1] == '?' ||p[1] == '*')) {
2543                         memmove(&p[1], &p[2], strlen(&p[2])+1);
2544                 }
2545         }
2546
2547         if (strequal(p2,"*")) {
2548                 TALLOC_FREE(ctx);
2549                 return true;
2550         }
2551
2552         ret = unix_do_match(p2, s2);
2553         TALLOC_FREE(ctx);
2554         return ret;
2555 }
2556
2557 /**********************************************************************
2558  Converts a name to a fully qualified domain name.
2559  Returns true if lookup succeeded, false if not (then fqdn is set to name)
2560  Note we deliberately use gethostbyname here, not getaddrinfo as we want
2561  to examine the h_aliases and I don't know how to do that with getaddrinfo.
2562 ***********************************************************************/
2563
2564 bool name_to_fqdn(fstring fqdn, const char *name)
2565 {
2566         char *full = NULL;
2567         struct hostent *hp = gethostbyname(name);
2568
2569         if (!hp || !hp->h_name || !*hp->h_name) {
2570                 DEBUG(10,("name_to_fqdn: lookup for %s failed.\n", name));
2571                 fstrcpy(fqdn, name);
2572                 return false;
2573         }
2574
2575         /* Find out if the fqdn is returned as an alias
2576          * to cope with /etc/hosts files where the first
2577          * name is not the fqdn but the short name */
2578         if (hp->h_aliases && (! strchr_m(hp->h_name, '.'))) {
2579                 int i;
2580                 for (i = 0; hp->h_aliases[i]; i++) {
2581                         if (strchr_m(hp->h_aliases[i], '.')) {
2582                                 full = hp->h_aliases[i];
2583                                 break;
2584                         }
2585                 }
2586         }
2587         if (full && (StrCaseCmp(full, "localhost.localdomain") == 0)) {
2588                 DEBUG(1, ("WARNING: your /etc/hosts file may be broken!\n"));
2589                 DEBUGADD(1, ("    Specifing the machine hostname for address 127.0.0.1 may lead\n"));
2590                 DEBUGADD(1, ("    to Kerberos authentication problems as localhost.localdomain\n"));
2591                 DEBUGADD(1, ("    may end up being used instead of the real machine FQDN.\n"));
2592                 full = hp->h_name;
2593         }
2594         if (!full) {
2595                 full = hp->h_name;
2596         }
2597
2598         DEBUG(10,("name_to_fqdn: lookup for %s -> %s.\n", name, full));
2599         fstrcpy(fqdn, full);
2600         return true;
2601 }
2602
2603 /**********************************************************************
2604  Append a DATA_BLOB to a talloc'ed object
2605 ***********************************************************************/
2606
2607 void *talloc_append_blob(TALLOC_CTX *mem_ctx, void *buf, DATA_BLOB blob)
2608 {
2609         size_t old_size = 0;
2610         char *result;
2611
2612         if (blob.length == 0) {
2613                 return buf;
2614         }
2615
2616         if (buf != NULL) {
2617                 old_size = talloc_get_size(buf);
2618         }
2619
2620         result = (char *)TALLOC_REALLOC(mem_ctx, buf, old_size + blob.length);
2621         if (result == NULL) {
2622                 return NULL;
2623         }
2624
2625         memcpy(result + old_size, blob.data, blob.length);
2626         return result;
2627 }
2628
2629 uint32 map_share_mode_to_deny_mode(uint32 share_access, uint32 private_options)
2630 {
2631         switch (share_access & ~FILE_SHARE_DELETE) {
2632                 case FILE_SHARE_NONE:
2633                         return DENY_ALL;
2634                 case FILE_SHARE_READ:
2635                         return DENY_WRITE;
2636                 case FILE_SHARE_WRITE:
2637                         return DENY_READ;
2638                 case FILE_SHARE_READ|FILE_SHARE_WRITE:
2639                         return DENY_NONE;
2640         }
2641         if (private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS) {
2642                 return DENY_DOS;
2643         } else if (private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_FCB) {
2644                 return DENY_FCB;
2645         }
2646
2647         return (uint32)-1;
2648 }
2649
2650 pid_t procid_to_pid(const struct server_id *proc)
2651 {
2652         return proc->pid;
2653 }
2654
2655 static uint32 my_vnn = NONCLUSTER_VNN;
2656
2657 void set_my_vnn(uint32 vnn)
2658 {
2659         DEBUG(10, ("vnn pid %d = %u\n", (int)sys_getpid(), (unsigned int)vnn));
2660         my_vnn = vnn;
2661 }
2662
2663 uint32 get_my_vnn(void)
2664 {
2665         return my_vnn;
2666 }
2667
2668 struct server_id pid_to_procid(pid_t pid)
2669 {
2670         struct server_id result;
2671         result.pid = pid;
2672 #ifdef CLUSTER_SUPPORT
2673         result.vnn = my_vnn;
2674 #endif
2675         return result;
2676 }
2677
2678 struct server_id procid_self(void)
2679 {
2680         return pid_to_procid(sys_getpid());
2681 }
2682
2683 struct server_id server_id_self(void)
2684 {
2685         return procid_self();
2686 }
2687
2688 bool procid_equal(const struct server_id *p1, const struct server_id *p2)
2689 {
2690         if (p1->pid != p2->pid)
2691                 return False;
2692 #ifdef CLUSTER_SUPPORT
2693         if (p1->vnn != p2->vnn)
2694                 return False;
2695 #endif
2696         return True;
2697 }
2698
2699 bool cluster_id_equal(const struct server_id *id1,
2700                       const struct server_id *id2)
2701 {
2702         return procid_equal(id1, id2);
2703 }
2704
2705 bool procid_is_me(const struct server_id *pid)
2706 {
2707         if (pid->pid != sys_getpid())
2708                 return False;
2709 #ifdef CLUSTER_SUPPORT
2710         if (pid->vnn != my_vnn)
2711                 return False;
2712 #endif
2713         return True;
2714 }
2715
2716 struct server_id interpret_pid(const char *pid_string)
2717 {
2718         struct server_id result;
2719         int pid;
2720 #ifdef CLUSTER_SUPPORT
2721         unsigned int vnn;
2722         if (sscanf(pid_string, "%u:%d", &vnn, &pid) == 2) {
2723                 result.vnn = vnn;
2724                 result.pid = pid;
2725         }
2726         else if (sscanf(pid_string, "%d", &pid) == 1) {
2727                 result.vnn = get_my_vnn();
2728                 result.pid = pid;
2729         }
2730         else {
2731                 result.vnn = NONCLUSTER_VNN;
2732                 result.pid = -1;
2733         }
2734 #else
2735         if (sscanf(pid_string, "%d", &pid) != 1) {
2736                 result.pid = -1;
2737         } else {
2738                 result.pid = pid;
2739         }
2740 #endif
2741         /* Assigning to result.pid may have overflowed
2742            Map negative pid to -1: i.e. error */
2743         if (result.pid < 0) {
2744                 result.pid = -1;
2745         }
2746         return result;
2747 }
2748
2749 char *procid_str(TALLOC_CTX *mem_ctx, const struct server_id *pid)
2750 {
2751 #ifdef CLUSTER_SUPPORT
2752         if (pid->vnn == NONCLUSTER_VNN) {
2753                 return talloc_asprintf(mem_ctx,
2754                                 "%d",
2755                                 (int)pid->pid);
2756         }
2757         else {
2758                 return talloc_asprintf(mem_ctx,
2759                                         "%u:%d",
2760                                         (unsigned)pid->vnn,
2761                                         (int)pid->pid);
2762         }
2763 #else
2764         return talloc_asprintf(mem_ctx,
2765                         "%d",
2766                         (int)pid->pid);
2767 #endif
2768 }
2769
2770 char *procid_str_static(const struct server_id *pid)
2771 {
2772         return procid_str(talloc_tos(), pid);
2773 }
2774
2775 bool procid_valid(const struct server_id *pid)
2776 {
2777         return (pid->pid != -1);
2778 }
2779
2780 bool procid_is_local(const struct server_id *pid)
2781 {
2782 #ifdef CLUSTER_SUPPORT
2783         return pid->vnn == my_vnn;
2784 #else
2785         return True;
2786 #endif
2787 }
2788
2789 int this_is_smp(void)
2790 {
2791 #if defined(HAVE_SYSCONF)
2792
2793 #if defined(SYSCONF_SC_NPROC_ONLN)
2794         return (sysconf(_SC_NPROC_ONLN) > 1) ? 1 : 0;
2795 #elif defined(SYSCONF_SC_NPROCESSORS_ONLN)
2796         return (sysconf(_SC_NPROCESSORS_ONLN) > 1) ? 1 : 0;
2797 #else
2798         return 0;
2799 #endif
2800
2801 #else
2802         return 0;
2803 #endif
2804 }
2805
2806 /****************************************************************
2807  Check if offset/length fit into bufsize. Should probably be
2808  merged with is_offset_safe, but this would require a rewrite
2809  of lanman.c. Later :-)
2810 ****************************************************************/
2811
2812 bool trans_oob(uint32_t bufsize, uint32_t offset, uint32_t length)
2813 {
2814         if ((offset + length < offset) || (offset + length < length)) {
2815                 /* wrap */
2816                 return true;
2817         }
2818         if ((offset > bufsize) || (offset + length > bufsize)) {
2819                 /* overflow */
2820                 return true;
2821         }
2822         return false;
2823 }
2824
2825 /****************************************************************
2826  Check if an offset into a buffer is safe.
2827  If this returns True it's safe to indirect into the byte at
2828  pointer ptr+off.
2829 ****************************************************************/
2830
2831 bool is_offset_safe(const char *buf_base, size_t buf_len, char *ptr, size_t off)
2832 {
2833         const char *end_base = buf_base + buf_len;
2834         char *end_ptr = ptr + off;
2835
2836         if (!buf_base || !ptr) {
2837                 return False;
2838         }
2839
2840         if (end_base < buf_base || end_ptr < ptr) {
2841                 return False; /* wrap. */
2842         }
2843
2844         if (end_ptr < end_base) {
2845                 return True;
2846         }
2847         return False;
2848 }
2849
2850 /****************************************************************
2851  Return a safe pointer into a buffer, or NULL.
2852 ****************************************************************/
2853
2854 char *get_safe_ptr(const char *buf_base, size_t buf_len, char *ptr, size_t off)
2855 {
2856         return is_offset_safe(buf_base, buf_len, ptr, off) ?
2857                         ptr + off : NULL;
2858 }
2859
2860 /****************************************************************
2861  Return a safe pointer into a string within a buffer, or NULL.
2862 ****************************************************************/
2863
2864 char *get_safe_str_ptr(const char *buf_base, size_t buf_len, char *ptr, size_t off)
2865 {
2866         if (!is_offset_safe(buf_base, buf_len, ptr, off)) {
2867                 return NULL;
2868         }
2869         /* Check if a valid string exists at this offset. */
2870         if (skip_string(buf_base,buf_len, ptr + off) == NULL) {
2871                 return NULL;
2872         }
2873         return ptr + off;
2874 }
2875
2876 /****************************************************************
2877  Return an SVAL at a pointer, or failval if beyond the end.
2878 ****************************************************************/
2879
2880 int get_safe_SVAL(const char *buf_base, size_t buf_len, char *ptr, size_t off, int failval)
2881 {
2882         /*
2883          * Note we use off+1 here, not off+2 as SVAL accesses ptr[0] and ptr[1],
2884          * NOT ptr[2].
2885          */
2886         if (!is_offset_safe(buf_base, buf_len, ptr, off+1)) {
2887                 return failval;
2888         }
2889         return SVAL(ptr,off);
2890 }
2891
2892 /****************************************************************
2893  Return an IVAL at a pointer, or failval if beyond the end.
2894 ****************************************************************/
2895
2896 int get_safe_IVAL(const char *buf_base, size_t buf_len, char *ptr, size_t off, int failval)
2897 {
2898         /*
2899          * Note we use off+3 here, not off+4 as IVAL accesses
2900          * ptr[0] ptr[1] ptr[2] ptr[3] NOT ptr[4].
2901          */
2902         if (!is_offset_safe(buf_base, buf_len, ptr, off+3)) {
2903                 return failval;
2904         }
2905         return IVAL(ptr,off);
2906 }
2907
2908 /****************************************************************
2909  Split DOM\user into DOM and user. Do not mix with winbind variants of that
2910  call (they take care of winbind separator and other winbind specific settings).
2911 ****************************************************************/
2912
2913 void split_domain_user(TALLOC_CTX *mem_ctx,
2914                        const char *full_name,
2915                        char **domain,
2916                        char **user)
2917 {
2918         const char *p = NULL;
2919
2920         p = strchr_m(full_name, '\\');
2921
2922         if (p != NULL) {
2923                 *domain = talloc_strndup(mem_ctx, full_name,
2924                                          PTR_DIFF(p, full_name));
2925                 *user = talloc_strdup(mem_ctx, p+1);
2926         } else {
2927                 *domain = talloc_strdup(mem_ctx, "");
2928                 *user = talloc_strdup(mem_ctx, full_name);
2929         }
2930 }
2931
2932 #if 0
2933
2934 Disable these now we have checked all code paths and ensured
2935 NULL returns on zero request. JRA.
2936
2937 /****************************************************************
2938  talloc wrapper functions that guarentee a null pointer return
2939  if size == 0.
2940 ****************************************************************/
2941
2942 #ifndef MAX_TALLOC_SIZE
2943 #define MAX_TALLOC_SIZE 0x10000000
2944 #endif
2945
2946 /*
2947  *    talloc and zero memory.
2948  *    - returns NULL if size is zero.
2949  */
2950
2951 void *_talloc_zero_zeronull(const void *ctx, size_t size, const char *name)
2952 {
2953         void *p;
2954
2955         if (size == 0) {
2956                 return NULL;
2957         }
2958
2959         p = talloc_named_const(ctx, size, name);
2960
2961         if (p) {
2962                 memset(p, '\0', size);
2963         }
2964
2965         return p;
2966 }
2967
2968 /*
2969  *   memdup with a talloc.
2970  *   - returns NULL if size is zero.
2971  */
2972
2973 void *_talloc_memdup_zeronull(const void *t, const void *p, size_t size, const char *name)
2974 {
2975         void *newp;
2976
2977         if (size == 0) {
2978                 return NULL;
2979         }
2980
2981         newp = talloc_named_const(t, size, name);
2982         if (newp) {
2983                 memcpy(newp, p, size);
2984         }
2985
2986         return newp;
2987 }
2988
2989 /*
2990  *   alloc an array, checking for integer overflow in the array size.
2991  *   - returns NULL if count or el_size are zero.
2992  */
2993
2994 void *_talloc_array_zeronull(const void *ctx, size_t el_size, unsigned count, const char *name)
2995 {
2996         if (count >= MAX_TALLOC_SIZE/el_size) {
2997                 return NULL;
2998         }
2999
3000         if (el_size == 0 || count == 0) {
3001                 return NULL;
3002         }
3003
3004         return talloc_named_const(ctx, el_size * count, name);
3005 }
3006
3007 /*
3008  *   alloc an zero array, checking for integer overflow in the array size
3009  *   - returns NULL if count or el_size are zero.
3010  */
3011
3012 void *_talloc_zero_array_zeronull(const void *ctx, size_t el_size, unsigned count, const char *name)
3013 {
3014         if (count >= MAX_TALLOC_SIZE/el_size) {
3015                 return NULL;
3016         }
3017
3018         if (el_size == 0 || count == 0) {
3019                 return NULL;
3020         }
3021
3022         return _talloc_zero(ctx, el_size * count, name);
3023 }
3024
3025 /*
3026  *   Talloc wrapper that returns NULL if size == 0.
3027  */
3028 void *talloc_zeronull(const void *context, size_t size, const char *name)
3029 {
3030         if (size == 0) {
3031                 return NULL;
3032         }
3033         return talloc_named_const(context, size, name);
3034 }
3035 #endif
3036
3037 bool is_valid_policy_hnd(const struct policy_handle *hnd)
3038 {
3039         struct policy_handle tmp;
3040         ZERO_STRUCT(tmp);
3041         return (memcmp(&tmp, hnd, sizeof(tmp)) != 0);
3042 }
3043
3044 bool policy_hnd_equal(const struct policy_handle *hnd1,
3045                       const struct policy_handle *hnd2)
3046 {
3047         if (!hnd1 || !hnd2) {
3048                 return false;
3049         }
3050
3051         return (memcmp(hnd1, hnd2, sizeof(*hnd1)) == 0);
3052 }
3053
3054 /****************************************************************
3055  strip off leading '\\' from a hostname
3056 ****************************************************************/
3057
3058 const char *strip_hostname(const char *s)
3059 {
3060         if (!s) {
3061                 return NULL;
3062         }
3063
3064         if (strlen_m(s) < 3) {
3065                 return s;
3066         }
3067
3068         if (s[0] == '\\') s++;
3069         if (s[0] == '\\') s++;
3070
3071         return s;
3072 }