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