source3/lib/util.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Samba utility functions
   4    Copyright (C) Andrew Tridgell 1992-1998
   5    Copyright (C) Jeremy Allison 2001-2007
   6    Copyright (C) Simo Sorce 2001
   7    Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2003
   8    Copyright (C) James Peach 2006
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  22 */
  23
  24 #include "includes.h"
  25
  26 extern char *global_clobber_region_function;
  27 extern unsigned int global_clobber_region_line;
  28
  29 /* Max allowable allococation - 256mb - 0x10000000 */
  30 #define MAX_ALLOC_SIZE (1024*1024*256)
  31
  32 #if (defined(HAVE_NETGROUP) && defined (WITH_AUTOMOUNT))
  33 #ifdef WITH_NISPLUS_HOME
  34 #ifdef BROKEN_NISPLUS_INCLUDE_FILES
  35 /*
  36  * The following lines are needed due to buggy include files
  37  * in Solaris 2.6 which define GROUP in both /usr/include/sys/acl.h and
  38  * also in /usr/include/rpcsvc/nis.h. The definitions conflict. JRA.
  39  * Also GROUP_OBJ is defined as 0x4 in /usr/include/sys/acl.h and as
  40  * an enum in /usr/include/rpcsvc/nis.h.
  41  */
  42
  43 #if defined(GROUP)
  44 #undef GROUP
  45 #endif
  46
  47 #if defined(GROUP_OBJ)
  48 #undef GROUP_OBJ
  49 #endif
  50
  51 #endif /* BROKEN_NISPLUS_INCLUDE_FILES */
  52
  53 #include <rpcsvc/nis.h>
  54
  55 #endif /* WITH_NISPLUS_HOME */
  56 #endif /* HAVE_NETGROUP && WITH_AUTOMOUNT */
  57
  58 static enum protocol_types Protocol = PROTOCOL_COREPLUS;
  59
  60 enum protocol_types get_Protocol(void)
  61 {
  62         return Protocol;
  63 }
  64
  65 void set_Protocol(enum protocol_types  p)
  66 {
  67         Protocol = p;
  68 }
  69
  70 static enum remote_arch_types ra_type = RA_UNKNOWN;
  71
  72 /***********************************************************************
  73  Definitions for all names.
  74 ***********************************************************************/
  75
  76 static char *smb_myname;
  77 static char *smb_myworkgroup;
  78 static char *smb_scope;
  79 static int smb_num_netbios_names;
  80 static char **smb_my_netbios_names;
  81
  82 /***********************************************************************
  83  Allocate and set myname. Ensure upper case.
  84 ***********************************************************************/
  85
  86 bool set_global_myname(const char *myname)
  87 {
  88         SAFE_FREE(smb_myname);
  89         smb_myname = SMB_STRDUP(myname);
  90         if (!smb_myname)
  91                 return False;
  92         strupper_m(smb_myname);
  93         return True;
  94 }
  95
  96 const char *global_myname(void)
  97 {
  98         return smb_myname;
  99 }
 100
 101 /***********************************************************************
 102  Allocate and set myworkgroup. Ensure upper case.
 103 ***********************************************************************/
 104
 105 bool set_global_myworkgroup(const char *myworkgroup)
 106 {
 107         SAFE_FREE(smb_myworkgroup);
 108         smb_myworkgroup = SMB_STRDUP(myworkgroup);
 109         if (!smb_myworkgroup)
 110                 return False;
 111         strupper_m(smb_myworkgroup);
 112         return True;
 113 }
 114
 115 const char *lp_workgroup(void)
 116 {
 117         return smb_myworkgroup;
 118 }
 119
 120 /***********************************************************************
 121  Allocate and set scope. Ensure upper case.
 122 ***********************************************************************/
 123
 124 bool set_global_scope(const char *scope)
 125 {
 126         SAFE_FREE(smb_scope);
 127         smb_scope = SMB_STRDUP(scope);
 128         if (!smb_scope)
 129                 return False;
 130         strupper_m(smb_scope);
 131         return True;
 132 }
 133
 134 /*********************************************************************
 135  Ensure scope is never null string.
 136 *********************************************************************/
 137
 138 const char *global_scope(void)
 139 {
 140         if (!smb_scope)
 141                 set_global_scope("");
 142         return smb_scope;
 143 }
 144
 145 static void free_netbios_names_array(void)
 146 {
 147         int i;
 148
 149         for (i = 0; i < smb_num_netbios_names; i++)
 150                 SAFE_FREE(smb_my_netbios_names[i]);
 151
 152         SAFE_FREE(smb_my_netbios_names);
 153         smb_num_netbios_names = 0;
 154 }
 155
 156 static bool allocate_my_netbios_names_array(size_t number)
 157 {
 158         free_netbios_names_array();
 159
 160         smb_num_netbios_names = number + 1;
 161         smb_my_netbios_names = SMB_MALLOC_ARRAY( char *, smb_num_netbios_names );
 162
 163         if (!smb_my_netbios_names)
 164                 return False;
 165
 166         memset(smb_my_netbios_names, '\0', sizeof(char *) * smb_num_netbios_names);
 167         return True;
 168 }
 169
 170 static bool set_my_netbios_names(const char *name, int i)
 171 {
 172         SAFE_FREE(smb_my_netbios_names[i]);
 173
 174         smb_my_netbios_names[i] = SMB_STRDUP(name);
 175         if (!smb_my_netbios_names[i])
 176                 return False;
 177         strupper_m(smb_my_netbios_names[i]);
 178         return True;
 179 }
 180
 181 /***********************************************************************
 182  Free memory allocated to global objects
 183 ***********************************************************************/
 184
 185 void gfree_names(void)
 186 {
 187         SAFE_FREE( smb_myname );
 188         SAFE_FREE( smb_myworkgroup );
 189         SAFE_FREE( smb_scope );
 190         free_netbios_names_array();
 191         free_local_machine_name();
 192 }
 193
 194 void gfree_all( void )
 195 {
 196         gfree_names();
 197         gfree_loadparm();
 198         gfree_case_tables();
 199         gfree_charcnv();
 200         gfree_interfaces();
 201         gfree_debugsyms();
 202 }
 203
 204 const char *my_netbios_names(int i)
 205 {
 206         return smb_my_netbios_names[i];
 207 }
 208
 209 bool set_netbios_aliases(const char **str_array)
 210 {
 211         size_t namecount;
 212
 213         /* Work out the max number of netbios aliases that we have */
 214         for( namecount=0; str_array && (str_array[namecount] != NULL); namecount++ )
 215                 ;
 216
 217         if ( global_myname() && *global_myname())
 218                 namecount++;
 219
 220         /* Allocate space for the netbios aliases */
 221         if (!allocate_my_netbios_names_array(namecount))
 222                 return False;
 223
 224         /* Use the global_myname string first */
 225         namecount=0;
 226         if ( global_myname() && *global_myname()) {
 227                 set_my_netbios_names( global_myname(), namecount );
 228                 namecount++;
 229         }
 230
 231         if (str_array) {
 232                 size_t i;
 233                 for ( i = 0; str_array[i] != NULL; i++) {
 234                         size_t n;
 235                         bool duplicate = False;
 236
 237                         /* Look for duplicates */
 238                         for( n=0; n<namecount; n++ ) {
 239                                 if( strequal( str_array[i], my_netbios_names(n) ) ) {
 240                                         duplicate = True;
 241                                         break;
 242                                 }
 243                         }
 244                         if (!duplicate) {
 245                                 if (!set_my_netbios_names(str_array[i], namecount))
 246                                         return False;
 247                                 namecount++;
 248                         }
 249                 }
 250         }
 251         return True;
 252 }
 253
 254 /****************************************************************************
 255   Common name initialization code.
 256 ****************************************************************************/
 257
 258 bool init_names(void)
 259 {
 260         int n;
 261
 262         if (global_myname() == NULL || *global_myname() == '\0') {
 263                 if (!set_global_myname(myhostname())) {
 264                         DEBUG( 0, ( "init_structs: malloc fail.\n" ) );
 265                         return False;
 266                 }
 267         }
 268
 269         if (!set_netbios_aliases(lp_netbios_aliases())) {
 270                 DEBUG( 0, ( "init_structs: malloc fail.\n" ) );
 271                 return False;
 272         }
 273
 274         set_local_machine_name(global_myname(),false);
 275
 276         DEBUG( 5, ("Netbios name list:-\n") );
 277         for( n=0; my_netbios_names(n); n++ ) {
 278                 DEBUGADD( 5, ("my_netbios_names[%d]=\"%s\"\n",
 279                                         n, my_netbios_names(n) ) );
 280         }
 281
 282         return( True );
 283 }
 284
 285 /**************************************************************************n
 286   Code to cope with username/password auth options from the commandline.
 287   Used mainly in client tools.
 288 ****************************************************************************/
 289
 290 struct user_auth_info *user_auth_info_init(TALLOC_CTX *mem_ctx)
 291 {
 292         struct user_auth_info *result;
 293
 294         result = TALLOC_ZERO_P(mem_ctx, struct user_auth_info);
 295         if (result == NULL) {
 296                 return NULL;
 297         }
 298
 299         result->signing_state = Undefined;
 300         return result;
 301 }
 302
 303 const char *get_cmdline_auth_info_username(const struct user_auth_info *auth_info)
 304 {
 305         if (!auth_info->username) {
 306                 return "";
 307         }
 308         return auth_info->username;
 309 }
 310
 311 void set_cmdline_auth_info_username(struct user_auth_info *auth_info,
 312                                     const char *username)
 313 {
 314         TALLOC_FREE(auth_info->username);
 315         auth_info->username = talloc_strdup(auth_info, username);
 316         if (!auth_info->username) {
 317                 exit(ENOMEM);
 318         }
 319 }
 320
 321 const char *get_cmdline_auth_info_domain(const struct user_auth_info *auth_info)
 322 {
 323         if (!auth_info->domain) {
 324                 return "";
 325         }
 326         return auth_info->domain;
 327 }
 328
 329 void set_cmdline_auth_info_domain(struct user_auth_info *auth_info,
 330                                   const char *domain)
 331 {
 332         TALLOC_FREE(auth_info->domain);
 333         auth_info->domain = talloc_strdup(auth_info, domain);
 334         if (!auth_info->domain) {
 335                 exit(ENOMEM);
 336         }
 337 }
 338
 339 const char *get_cmdline_auth_info_password(const struct user_auth_info *auth_info)
 340 {
 341         if (!auth_info->password) {
 342                 return "";
 343         }
 344         return auth_info->password;
 345 }
 346
 347 void set_cmdline_auth_info_password(struct user_auth_info *auth_info,
 348                                     const char *password)
 349 {
 350         TALLOC_FREE(auth_info->password);
 351         if (password == NULL) {
 352                 password = "";
 353         }
 354         auth_info->password = talloc_strdup(auth_info, password);
 355         if (!auth_info->password) {
 356                 exit(ENOMEM);
 357         }
 358         auth_info->got_pass = true;
 359 }
 360
 361 bool set_cmdline_auth_info_signing_state(struct user_auth_info *auth_info,
 362                                          const char *arg)
 363 {
 364         auth_info->signing_state = -1;
 365         if (strequal(arg, "off") || strequal(arg, "no") ||
 366                         strequal(arg, "false")) {
 367                 auth_info->signing_state = false;
 368         } else if (strequal(arg, "on") || strequal(arg, "yes") ||
 369                         strequal(arg, "true") || strequal(arg, "auto")) {
 370                 auth_info->signing_state = true;
 371         } else if (strequal(arg, "force") || strequal(arg, "required") ||
 372                         strequal(arg, "forced")) {
 373                 auth_info->signing_state = Required;
 374         } else {
 375                 return false;
 376         }
 377         return true;
 378 }
 379
 380 int get_cmdline_auth_info_signing_state(const struct user_auth_info *auth_info)
 381 {
 382         return auth_info->signing_state;
 383 }
 384
 385 void set_cmdline_auth_info_use_ccache(struct user_auth_info *auth_info, bool b)
 386 {
 387         auth_info->use_ccache = b;
 388 }
 389
 390 bool get_cmdline_auth_info_use_ccache(const struct user_auth_info *auth_info)
 391 {
 392         return auth_info->use_ccache;
 393 }
 394
 395 void set_cmdline_auth_info_use_kerberos(struct user_auth_info *auth_info,
 396                                         bool b)
 397 {
 398         auth_info->use_kerberos = b;
 399 }
 400
 401 bool get_cmdline_auth_info_use_kerberos(const struct user_auth_info *auth_info)
 402 {
 403         return auth_info->use_kerberos;
 404 }
 405
 406 void set_cmdline_auth_info_fallback_after_kerberos(struct user_auth_info *auth_info,
 407                                         bool b)
 408 {
 409         auth_info->fallback_after_kerberos = b;
 410 }
 411
 412 bool get_cmdline_auth_info_fallback_after_kerberos(const struct user_auth_info *auth_info)
 413 {
 414         return auth_info->fallback_after_kerberos;
 415 }
 416
 417 /* This should only be used by lib/popt_common.c JRA */
 418 void set_cmdline_auth_info_use_krb5_ticket(struct user_auth_info *auth_info)
 419 {
 420         auth_info->use_kerberos = true;
 421         auth_info->got_pass = true;
 422 }
 423
 424 /* This should only be used by lib/popt_common.c JRA */
 425 void set_cmdline_auth_info_smb_encrypt(struct user_auth_info *auth_info)
 426 {
 427         auth_info->smb_encrypt = true;
 428 }
 429
 430 void set_cmdline_auth_info_use_machine_account(struct user_auth_info *auth_info)
 431 {
 432         auth_info->use_machine_account = true;
 433 }
 434
 435 bool get_cmdline_auth_info_got_pass(const struct user_auth_info *auth_info)
 436 {
 437         return auth_info->got_pass;
 438 }
 439
 440 bool get_cmdline_auth_info_smb_encrypt(const struct user_auth_info *auth_info)
 441 {
 442         return auth_info->smb_encrypt;
 443 }
 444
 445 bool get_cmdline_auth_info_use_machine_account(const struct user_auth_info *auth_info)
 446 {
 447         return auth_info->use_machine_account;
 448 }
 449
 450 struct user_auth_info *get_cmdline_auth_info_copy(TALLOC_CTX *mem_ctx,
 451                                                   const struct user_auth_info *src)
 452 {
 453         struct user_auth_info *result;
 454
 455         result = user_auth_info_init(mem_ctx);
 456         if (result == NULL) {
 457                 return NULL;
 458         }
 459
 460         *result = *src;
 461
 462         result->username = talloc_strdup(
 463                 result, get_cmdline_auth_info_username(src));
 464         result->password = talloc_strdup(
 465                 result, get_cmdline_auth_info_password(src));
 466         if ((result->username == NULL) || (result->password == NULL)) {
 467                 TALLOC_FREE(result);
 468                 return NULL;
 469         }
 470
 471         return result;
 472 }
 473
 474 bool set_cmdline_auth_info_machine_account_creds(struct user_auth_info *auth_info)
 475 {
 476         char *pass = NULL;
 477         char *account = NULL;
 478
 479         if (!get_cmdline_auth_info_use_machine_account(auth_info)) {
 480                 return false;
 481         }
 482
 483         if (!secrets_init()) {
 484                 d_printf("ERROR: Unable to open secrets database\n");
 485                 return false;
 486         }
 487
 488         if (asprintf(&account, "%s$@%s", global_myname(), lp_realm()) < 0) {
 489                 return false;
 490         }
 491
 492         pass = secrets_fetch_machine_password(lp_workgroup(), NULL, NULL);
 493         if (!pass) {
 494                 d_printf("ERROR: Unable to fetch machine password for "
 495                         "%s in domain %s\n",
 496                         account, lp_workgroup());
 497                 SAFE_FREE(account);
 498                 return false;
 499         }
 500
 501         set_cmdline_auth_info_username(auth_info, account);
 502         set_cmdline_auth_info_password(auth_info, pass);
 503
 504         SAFE_FREE(account);
 505         SAFE_FREE(pass);
 506
 507         return true;
 508 }
 509
 510 /****************************************************************************
 511  Ensure we have a password if one not given.
 512 ****************************************************************************/
 513
 514 void set_cmdline_auth_info_getpass(struct user_auth_info *auth_info)
 515 {
 516         char *label = NULL;
 517         char *pass;
 518         TALLOC_CTX *frame;
 519
 520         if (get_cmdline_auth_info_got_pass(auth_info) ||
 521                         get_cmdline_auth_info_use_kerberos(auth_info)) {
 522                 /* Already got one... */
 523                 return;
 524         }
 525
 526         frame = talloc_stackframe();
 527         label = talloc_asprintf(frame, "Enter %s's password: ",
 528                         get_cmdline_auth_info_username(auth_info));
 529         pass = getpass(label);
 530         if (pass) {
 531                 set_cmdline_auth_info_password(auth_info, pass);
 532         }
 533         TALLOC_FREE(frame);
 534 }
 535
 536 /*******************************************************************
 537  Check if a file exists - call vfs_file_exist for samba files.
 538 ********************************************************************/
 539
 540 bool file_exist_stat(const char *fname,SMB_STRUCT_STAT *sbuf,
 541                      bool fake_dir_create_times)
 542 {
 543         SMB_STRUCT_STAT st;
 544         if (!sbuf)
 545                 sbuf = &st;
 546
 547         if (sys_stat(fname, sbuf, fake_dir_create_times) != 0)
 548                 return(False);
 549
 550         return((S_ISREG(sbuf->st_ex_mode)) || (S_ISFIFO(sbuf->st_ex_mode)));
 551 }
 552
 553 /*******************************************************************
 554  Check if a unix domain socket exists - call vfs_file_exist for samba files.
 555 ********************************************************************/
 556
 557 bool socket_exist(const char *fname)
 558 {
 559         SMB_STRUCT_STAT st;
 560         if (sys_stat(fname, &st, false) != 0)
 561                 return(False);
 562
 563         return S_ISSOCK(st.st_ex_mode);
 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, false) != 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 = Get_Pwnam_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 }
3073
3074 bool tevent_req_poll_ntstatus(struct tevent_req *req,
3075                               struct tevent_context *ev,
3076                               NTSTATUS *status)
3077 {
3078         bool ret = tevent_req_poll(req, ev);
3079         if (!ret) {
3080                 *status = map_nt_error_from_unix(errno);
3081         }
3082         return ret;
3083 }