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, case_sensitive)) {
1691                                 DEBUG(8,("is_in_path: mask match succeeded\n"));
1692                                 return True;
1693                         }
1694                 } else {
1695                         if((case_sensitive && (strcmp(last_component, namelist->name) == 0))||
1696                                                 (!case_sensitive && (StrCaseCmp(last_component, namelist->name) == 0))) {
1697                                 DEBUG(8,("is_in_path: match succeeded\n"));
1698                                 return True;
1699                         }
1700                 }
1701         }
1702         DEBUG(8,("is_in_path: match not found\n"));
1703         return False;
1704 }
1705
1706 /*******************************************************************
1707  Strip a '/' separated list into an array of
1708  name_compare_enties structures suitable for
1709  passing to is_in_path(). We do this for
1710  speed so we can pre-parse all the names in the list
1711  and don't do it for each call to is_in_path().
1712  namelist is modified here and is assumed to be
1713  a copy owned by the caller.
1714  We also check if the entry contains a wildcard to
1715  remove a potentially expensive call to mask_match
1716  if possible.
1717 ********************************************************************/
1718
1719 void set_namearray(name_compare_entry **ppname_array, const char *namelist)
1720 {
1721         char *name_end;
1722         char *nameptr = (char *)namelist;
1723         int num_entries = 0;
1724         int i;
1725
1726         (*ppname_array) = NULL;
1727
1728         if((nameptr == NULL ) || ((nameptr != NULL) && (*nameptr == '\0')))
1729                 return;
1730
1731         /* We need to make two passes over the string. The
1732                 first to count the number of elements, the second
1733                 to split it.
1734         */
1735
1736         while(*nameptr) {
1737                 if ( *nameptr == '/' ) {
1738                         /* cope with multiple (useless) /s) */
1739                         nameptr++;
1740                         continue;
1741                 }
1742                 /* anything left? */
1743                 if ( *nameptr == '\0' )
1744                         break;
1745
1746                 /* find the next '/' or consume remaining */
1747                 name_end = strchr_m(nameptr, '/');
1748                 if (name_end == NULL)
1749                         name_end = (char *)nameptr + strlen(nameptr);
1750
1751                 /* next segment please */
1752                 nameptr = name_end + 1;
1753                 num_entries++;
1754         }
1755
1756         if(num_entries == 0)
1757                 return;
1758
1759         if(( (*ppname_array) = SMB_MALLOC_ARRAY(name_compare_entry, num_entries + 1)) == NULL) {
1760                 DEBUG(0,("set_namearray: malloc fail\n"));
1761                 return;
1762         }
1763
1764         /* Now copy out the names */
1765         nameptr = (char *)namelist;
1766         i = 0;
1767         while(*nameptr) {
1768                 if ( *nameptr == '/' ) {
1769                         /* cope with multiple (useless) /s) */
1770                         nameptr++;
1771                         continue;
1772                 }
1773                 /* anything left? */
1774                 if ( *nameptr == '\0' )
1775                         break;
1776
1777                 /* find the next '/' or consume remaining */
1778                 name_end = strchr_m(nameptr, '/');
1779                 if (name_end)
1780                         *name_end = '\0';
1781                 else
1782                         name_end = nameptr + strlen(nameptr);
1783
1784                 (*ppname_array)[i].is_wild = ms_has_wild(nameptr);
1785                 if(((*ppname_array)[i].name = SMB_STRDUP(nameptr)) == NULL) {
1786                         DEBUG(0,("set_namearray: malloc fail (1)\n"));
1787                         return;
1788                 }
1789
1790                 /* next segment please */
1791                 nameptr = name_end + 1;
1792                 i++;
1793         }
1794
1795         (*ppname_array)[i].name = NULL;
1796
1797         return;
1798 }
1799
1800 /****************************************************************************
1801  Routine to free a namearray.
1802 ****************************************************************************/
1803
1804 void free_namearray(name_compare_entry *name_array)
1805 {
1806         int i;
1807
1808         if(name_array == NULL)
1809                 return;
1810
1811         for(i=0; name_array[i].name!=NULL; i++)
1812                 SAFE_FREE(name_array[i].name);
1813         SAFE_FREE(name_array);
1814 }
1815
1816 #undef DBGC_CLASS
1817 #define DBGC_CLASS DBGC_LOCKING
1818
1819 /****************************************************************************
1820  Simple routine to query existing file locks. Cruft in NFS and 64->32 bit mapping
1821  is dealt with in posix.c
1822  Returns True if we have information regarding this lock region (and returns
1823  F_UNLCK in *ptype if the region is unlocked). False if the call failed.
1824 ****************************************************************************/
1825
1826 bool fcntl_getlock(int fd, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype, pid_t *ppid)
1827 {
1828         SMB_STRUCT_FLOCK lock;
1829         int ret;
1830
1831         DEBUG(8,("fcntl_getlock fd=%d offset=%.0f count=%.0f type=%d\n",
1832                     fd,(double)*poffset,(double)*pcount,*ptype));
1833
1834         lock.l_type = *ptype;
1835         lock.l_whence = SEEK_SET;
1836         lock.l_start = *poffset;
1837         lock.l_len = *pcount;
1838         lock.l_pid = 0;
1839
1840         ret = sys_fcntl_ptr(fd,SMB_F_GETLK,&lock);
1841
1842         if (ret == -1) {
1843                 int sav = errno;
1844                 DEBUG(3,("fcntl_getlock: lock request failed at offset %.0f count %.0f type %d (%s)\n",
1845                         (double)*poffset,(double)*pcount,*ptype,strerror(errno)));
1846                 errno = sav;
1847                 return False;
1848         }
1849
1850         *ptype = lock.l_type;
1851         *poffset = lock.l_start;
1852         *pcount = lock.l_len;
1853         *ppid = lock.l_pid;
1854
1855         DEBUG(3,("fcntl_getlock: fd %d is returned info %d pid %u\n",
1856                         fd, (int)lock.l_type, (unsigned int)lock.l_pid));
1857         return True;
1858 }
1859
1860 #undef DBGC_CLASS
1861 #define DBGC_CLASS DBGC_ALL
1862
1863 /*******************************************************************
1864  Is the name specified one of my netbios names.
1865  Returns true if it is equal, false otherwise.
1866 ********************************************************************/
1867
1868 bool is_myname(const char *s)
1869 {
1870         int n;
1871         bool ret = False;
1872
1873         for (n=0; my_netbios_names(n); n++) {
1874                 if (strequal(my_netbios_names(n), s)) {
1875                         ret=True;
1876                         break;
1877                 }
1878         }
1879         DEBUG(8, ("is_myname(\"%s\") returns %d\n", s, ret));
1880         return(ret);
1881 }
1882
1883 /*******************************************************************
1884  Is the name specified our workgroup/domain.
1885  Returns true if it is equal, false otherwise.
1886 ********************************************************************/
1887
1888 bool is_myworkgroup(const char *s)
1889 {
1890         bool ret = False;
1891
1892         if (strequal(s, lp_workgroup())) {
1893                 ret=True;
1894         }
1895
1896         DEBUG(8, ("is_myworkgroup(\"%s\") returns %d\n", s, ret));
1897         return(ret);
1898 }
1899
1900 /*******************************************************************
1901  we distinguish between 2K and XP by the "Native Lan Manager" string
1902    WinXP => "Windows 2002 5.1"
1903    WinXP 64bit => "Windows XP 5.2"
1904    Win2k => "Windows 2000 5.0"
1905    NT4   => "Windows NT 4.0"
1906    Win9x => "Windows 4.0"
1907  Windows 2003 doesn't set the native lan manager string but
1908  they do set the domain to "Windows 2003 5.2" (probably a bug).
1909 ********************************************************************/
1910
1911 void ra_lanman_string( const char *native_lanman )
1912 {
1913         if ( strcmp( native_lanman, "Windows 2002 5.1" ) == 0 )
1914                 set_remote_arch( RA_WINXP );
1915         else if ( strcmp( native_lanman, "Windows XP 5.2" ) == 0 )
1916                 set_remote_arch( RA_WINXP64 );
1917         else if ( strcmp( native_lanman, "Windows Server 2003 5.2" ) == 0 )
1918                 set_remote_arch( RA_WIN2K3 );
1919 }
1920
1921 static const char *remote_arch_str;
1922
1923 const char *get_remote_arch_str(void)
1924 {
1925         if (!remote_arch_str) {
1926                 return "UNKNOWN";
1927         }
1928         return remote_arch_str;
1929 }
1930
1931 /*******************************************************************
1932  Set the horrid remote_arch string based on an enum.
1933 ********************************************************************/
1934
1935 void set_remote_arch(enum remote_arch_types type)
1936 {
1937         ra_type = type;
1938         switch( type ) {
1939         case RA_WFWG:
1940                 remote_arch_str = "WfWg";
1941                 break;
1942         case RA_OS2:
1943                 remote_arch_str = "OS2";
1944                 break;
1945         case RA_WIN95:
1946                 remote_arch_str = "Win95";
1947                 break;
1948         case RA_WINNT:
1949                 remote_arch_str = "WinNT";
1950                 break;
1951         case RA_WIN2K:
1952                 remote_arch_str = "Win2K";
1953                 break;
1954         case RA_WINXP:
1955                 remote_arch_str = "WinXP";
1956                 break;
1957         case RA_WINXP64:
1958                 remote_arch_str = "WinXP64";
1959                 break;
1960         case RA_WIN2K3:
1961                 remote_arch_str = "Win2K3";
1962                 break;
1963         case RA_VISTA:
1964                 remote_arch_str = "Vista";
1965                 break;
1966         case RA_SAMBA:
1967                 remote_arch_str = "Samba";
1968                 break;
1969         case RA_CIFSFS:
1970                 remote_arch_str = "CIFSFS";
1971                 break;
1972         default:
1973                 ra_type = RA_UNKNOWN;
1974                 remote_arch_str = "UNKNOWN";
1975                 break;
1976         }
1977
1978         DEBUG(10,("set_remote_arch: Client arch is \'%s\'\n",
1979                                 remote_arch_str));
1980 }
1981
1982 /*******************************************************************
1983  Get the remote_arch type.
1984 ********************************************************************/
1985
1986 enum remote_arch_types get_remote_arch(void)
1987 {
1988         return ra_type;
1989 }
1990
1991 const char *tab_depth(int level, int depth)
1992 {
1993         if( CHECK_DEBUGLVL(level) ) {
1994                 dbgtext("%*s", depth*4, "");
1995         }
1996         return "";
1997 }
1998
1999 /*****************************************************************************
2000  Provide a checksum on a string
2001
2002  Input:  s - the null-terminated character string for which the checksum
2003              will be calculated.
2004
2005   Output: The checksum value calculated for s.
2006 *****************************************************************************/
2007
2008 int str_checksum(const char *s)
2009 {
2010         int res = 0;
2011         int c;
2012         int i=0;
2013
2014         while(*s) {
2015                 c = *s;
2016                 res ^= (c << (i % 15)) ^ (c >> (15-(i%15)));
2017                 s++;
2018                 i++;
2019         }
2020         return(res);
2021 }
2022
2023 /*****************************************************************
2024  Zero a memory area then free it. Used to catch bugs faster.
2025 *****************************************************************/
2026
2027 void zero_free(void *p, size_t size)
2028 {
2029         memset(p, 0, size);
2030         SAFE_FREE(p);
2031 }
2032
2033 /*****************************************************************
2034  Set our open file limit to a requested max and return the limit.
2035 *****************************************************************/
2036
2037 int set_maxfiles(int requested_max)
2038 {
2039 #if (defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE))
2040         struct rlimit rlp;
2041         int saved_current_limit;
2042
2043         if(getrlimit(RLIMIT_NOFILE, &rlp)) {
2044                 DEBUG(0,("set_maxfiles: getrlimit (1) for RLIMIT_NOFILE failed with error %s\n",
2045                         strerror(errno) ));
2046                 /* just guess... */
2047                 return requested_max;
2048         }
2049
2050         /*
2051          * Set the fd limit to be real_max_open_files + MAX_OPEN_FUDGEFACTOR to
2052          * account for the extra fd we need
2053          * as well as the log files and standard
2054          * handles etc. Save the limit we want to set in case
2055          * we are running on an OS that doesn't support this limit (AIX)
2056          * which always returns RLIM_INFINITY for rlp.rlim_max.
2057          */
2058
2059         /* Try raising the hard (max) limit to the requested amount. */
2060
2061 #if defined(RLIM_INFINITY)
2062         if (rlp.rlim_max != RLIM_INFINITY) {
2063                 int orig_max = rlp.rlim_max;
2064
2065                 if ( rlp.rlim_max < requested_max )
2066                         rlp.rlim_max = requested_max;
2067
2068                 /* This failing is not an error - many systems (Linux) don't
2069                         support our default request of 10,000 open files. JRA. */
2070
2071                 if(setrlimit(RLIMIT_NOFILE, &rlp)) {
2072                         DEBUG(3,("set_maxfiles: setrlimit for RLIMIT_NOFILE for %d max files failed with error %s\n",
2073                                 (int)rlp.rlim_max, strerror(errno) ));
2074
2075                         /* Set failed - restore original value from get. */
2076                         rlp.rlim_max = orig_max;
2077                 }
2078         }
2079 #endif
2080
2081         /* Now try setting the soft (current) limit. */
2082
2083         saved_current_limit = rlp.rlim_cur = MIN(requested_max,rlp.rlim_max);
2084
2085         if(setrlimit(RLIMIT_NOFILE, &rlp)) {
2086                 DEBUG(0,("set_maxfiles: setrlimit for RLIMIT_NOFILE for %d files failed with error %s\n",
2087                         (int)rlp.rlim_cur, strerror(errno) ));
2088                 /* just guess... */
2089                 return saved_current_limit;
2090         }
2091
2092         if(getrlimit(RLIMIT_NOFILE, &rlp)) {
2093                 DEBUG(0,("set_maxfiles: getrlimit (2) for RLIMIT_NOFILE failed with error %s\n",
2094                         strerror(errno) ));
2095                 /* just guess... */
2096                 return saved_current_limit;
2097     }
2098
2099 #if defined(RLIM_INFINITY)
2100         if(rlp.rlim_cur == RLIM_INFINITY)
2101                 return saved_current_limit;
2102 #endif
2103
2104         if((int)rlp.rlim_cur > saved_current_limit)
2105                 return saved_current_limit;
2106
2107         return rlp.rlim_cur;
2108 #else /* !defined(HAVE_GETRLIMIT) || !defined(RLIMIT_NOFILE) */
2109         /*
2110          * No way to know - just guess...
2111          */
2112         return requested_max;
2113 #endif
2114 }
2115
2116 /*****************************************************************
2117  malloc that aborts with smb_panic on fail or zero size.
2118  *****************************************************************/
2119
2120 void *smb_xmalloc_array(size_t size, unsigned int count)
2121 {
2122         void *p;
2123         if (size == 0) {
2124                 smb_panic("smb_xmalloc_array: called with zero size");
2125         }
2126         if (count >= MAX_ALLOC_SIZE/size) {
2127                 smb_panic("smb_xmalloc_array: alloc size too large");
2128         }
2129         if ((p = SMB_MALLOC(size*count)) == NULL) {
2130                 DEBUG(0, ("smb_xmalloc_array failed to allocate %lu * %lu bytes\n",
2131                         (unsigned long)size, (unsigned long)count));
2132                 smb_panic("smb_xmalloc_array: malloc failed");
2133         }
2134         return p;
2135 }
2136
2137 /*
2138   vasprintf that aborts on malloc fail
2139 */
2140
2141  int smb_xvasprintf(char **ptr, const char *format, va_list ap)
2142 {
2143         int n;
2144         va_list ap2;
2145
2146         va_copy(ap2, ap);
2147
2148         n = vasprintf(ptr, format, ap2);
2149         va_end(ap2);
2150         if (n == -1 || ! *ptr) {
2151                 smb_panic("smb_xvasprintf: out of memory");
2152         }
2153         return n;
2154 }
2155
2156 /*****************************************************************
2157  Get local hostname and cache result.
2158 *****************************************************************/
2159
2160 char *myhostname(void)
2161 {
2162         static char *ret;
2163         if (ret == NULL) {
2164                 /* This is cached forever so
2165                  * use talloc_autofree_context() ctx. */
2166                 ret = get_myname(talloc_autofree_context());
2167         }
2168         return ret;
2169 }
2170
2171 /**
2172  * @brief Returns an absolute path to a file concatenating the provided
2173  * @a rootpath and @a basename
2174  *
2175  * @param name Filename, relative to @a rootpath
2176  *
2177  * @retval Pointer to a string containing the full path.
2178  **/
2179
2180 static char *xx_path(const char *name, const char *rootpath)
2181 {
2182         char *fname = NULL;
2183
2184         fname = talloc_strdup(talloc_tos(), rootpath);
2185         if (!fname) {
2186                 return NULL;
2187         }
2188         trim_string(fname,"","/");
2189
2190         if (!directory_exist(fname)) {
2191                 if (!mkdir(fname,0755))
2192                         DEBUG(1, ("Unable to create directory %s for file %s. "
2193                               "Error was %s\n", fname, name, strerror(errno)));
2194         }
2195
2196         return talloc_asprintf(talloc_tos(),
2197                                 "%s/%s",
2198                                 fname,
2199                                 name);
2200 }
2201
2202 /**
2203  * @brief Returns an absolute path to a file in the Samba lock directory.
2204  *
2205  * @param name File to find, relative to LOCKDIR.
2206  *
2207  * @retval Pointer to a talloc'ed string containing the full path.
2208  **/
2209
2210 char *lock_path(const char *name)
2211 {
2212         return xx_path(name, lp_lockdir());
2213 }
2214
2215 /**
2216  * @brief Returns an absolute path to a file in the Samba pid directory.
2217  *
2218  * @param name File to find, relative to PIDDIR.
2219  *
2220  * @retval Pointer to a talloc'ed string containing the full path.
2221  **/
2222
2223 char *pid_path(const char *name)
2224 {
2225         return xx_path(name, lp_piddir());
2226 }
2227
2228 /**
2229  * @brief Returns an absolute path to a file in the Samba lib directory.
2230  *
2231  * @param name File to find, relative to LIBDIR.
2232  *
2233  * @retval Pointer to a string containing the full path.
2234  **/
2235
2236 char *lib_path(const char *name)
2237 {
2238         return talloc_asprintf(talloc_tos(), "%s/%s", get_dyn_LIBDIR(), name);
2239 }
2240
2241 /**
2242  * @brief Returns an absolute path to a file in the Samba modules directory.
2243  *
2244  * @param name File to find, relative to MODULESDIR.
2245  *
2246  * @retval Pointer to a string containing the full path.
2247  **/
2248
2249 char *modules_path(const char *name)
2250 {
2251         return talloc_asprintf(talloc_tos(), "%s/%s", get_dyn_MODULESDIR(), name);
2252 }
2253
2254 /**
2255  * @brief Returns an absolute path to a file in the Samba data directory.
2256  *
2257  * @param name File to find, relative to CODEPAGEDIR.
2258  *
2259  * @retval Pointer to a talloc'ed string containing the full path.
2260  **/
2261
2262 char *data_path(const char *name)
2263 {
2264         return talloc_asprintf(talloc_tos(), "%s/%s", get_dyn_CODEPAGEDIR(), name);
2265 }
2266
2267 /**
2268  * @brief Returns an absolute path to a file in the Samba state directory.
2269  *
2270  * @param name File to find, relative to STATEDIR.
2271  *
2272  * @retval Pointer to a talloc'ed string containing the full path.
2273  **/
2274
2275 char *state_path(const char *name)
2276 {
2277         return xx_path(name, lp_statedir());
2278 }
2279
2280 /**
2281  * @brief Returns an absolute path to a file in the Samba cache directory.
2282  *
2283  * @param name File to find, relative to CACHEDIR.
2284  *
2285  * @retval Pointer to a talloc'ed string containing the full path.
2286  **/
2287
2288 char *cache_path(const char *name)
2289 {
2290         return xx_path(name, lp_cachedir());
2291 }
2292
2293 /**
2294  * @brief Returns the platform specific shared library extension.
2295  *
2296  * @retval Pointer to a const char * containing the extension.
2297  **/
2298
2299 const char *shlib_ext(void)
2300 {
2301         return get_dyn_SHLIBEXT();
2302 }
2303
2304 /*******************************************************************
2305  Given a filename - get its directory name
2306 ********************************************************************/
2307
2308 bool parent_dirname(TALLOC_CTX *mem_ctx, const char *dir, char **parent,
2309                     const char **name)
2310 {
2311         char *p;
2312         ptrdiff_t len;
2313
2314         p = strrchr_m(dir, '/'); /* Find final '/', if any */
2315
2316         if (p == NULL) {
2317                 if (!(*parent = talloc_strdup(mem_ctx, "."))) {
2318                         return False;
2319                 }
2320                 if (name) {
2321                         *name = dir;
2322                 }
2323                 return True;
2324         }
2325
2326         len = p-dir;
2327
2328         if (!(*parent = (char *)TALLOC_MEMDUP(mem_ctx, dir, len+1))) {
2329                 return False;
2330         }
2331         (*parent)[len] = '\0';
2332
2333         if (name) {
2334                 *name = p+1;
2335         }
2336         return True;
2337 }
2338
2339 /*******************************************************************
2340  Determine if a pattern contains any Microsoft wildcard characters.
2341 *******************************************************************/
2342
2343 bool ms_has_wild(const char *s)
2344 {
2345         char c;
2346
2347         if (lp_posix_pathnames()) {
2348                 /* With posix pathnames no characters are wild. */
2349                 return False;
2350         }
2351
2352         while ((c = *s++)) {
2353                 switch (c) {
2354                 case '*':
2355                 case '?':
2356                 case '<':
2357                 case '>':
2358                 case '"':
2359                         return True;
2360                 }
2361         }
2362         return False;
2363 }
2364
2365 bool ms_has_wild_w(const smb_ucs2_t *s)
2366 {
2367         smb_ucs2_t c;
2368         if (!s) return False;
2369         while ((c = *s++)) {
2370                 switch (c) {
2371                 case UCS2_CHAR('*'):
2372                 case UCS2_CHAR('?'):
2373                 case UCS2_CHAR('<'):
2374                 case UCS2_CHAR('>'):
2375                 case UCS2_CHAR('"'):
2376                         return True;
2377                 }
2378         }
2379         return False;
2380 }
2381
2382 /*******************************************************************
2383  A wrapper that handles case sensitivity and the special handling
2384  of the ".." name.
2385 *******************************************************************/
2386
2387 bool mask_match(const char *string, const char *pattern, bool is_case_sensitive)
2388 {
2389         if (strcmp(string,"..") == 0)
2390                 string = ".";
2391         if (strcmp(pattern,".") == 0)
2392                 return False;
2393
2394         return ms_fnmatch(pattern, string, Protocol <= PROTOCOL_LANMAN2, is_case_sensitive) == 0;
2395 }
2396
2397 /*******************************************************************
2398  A wrapper that handles case sensitivity and the special handling
2399  of the ".." name. Varient that is only called by old search code which requires
2400  pattern translation.
2401 *******************************************************************/
2402
2403 bool mask_match_search(const char *string, const char *pattern, bool is_case_sensitive)
2404 {
2405         if (strcmp(string,"..") == 0)
2406                 string = ".";
2407         if (strcmp(pattern,".") == 0)
2408                 return False;
2409
2410         return ms_fnmatch(pattern, string, True, is_case_sensitive) == 0;
2411 }
2412
2413 /*******************************************************************
2414  A wrapper that handles a list of patters and calls mask_match()
2415  on each.  Returns True if any of the patterns match.
2416 *******************************************************************/
2417
2418 bool mask_match_list(const char *string, char **list, int listLen, bool is_case_sensitive)
2419 {
2420        while (listLen-- > 0) {
2421                if (mask_match(string, *list++, is_case_sensitive))
2422                        return True;
2423        }
2424        return False;
2425 }
2426
2427 /*********************************************************
2428  Recursive routine that is called by unix_wild_match.
2429 *********************************************************/
2430
2431 static bool unix_do_match(const char *regexp, const char *str)
2432 {
2433         const char *p;
2434
2435         for( p = regexp; *p && *str; ) {
2436
2437                 switch(*p) {
2438                         case '?':
2439                                 str++;
2440                                 p++;
2441                                 break;
2442
2443                         case '*':
2444
2445                                 /*
2446                                  * Look for a character matching
2447                                  * the one after the '*'.
2448                                  */
2449                                 p++;
2450                                 if(!*p)
2451                                         return true; /* Automatic match */
2452                                 while(*str) {
2453
2454                                         while(*str && (*p != *str))
2455                                                 str++;
2456
2457                                         /*
2458                                          * Patch from weidel@multichart.de. In the case of the regexp
2459                                          * '*XX*' we want to ensure there are at least 2 'X' characters
2460                                          * in the string after the '*' for a match to be made.
2461                                          */
2462
2463                                         {
2464                                                 int matchcount=0;
2465
2466                                                 /*
2467                                                  * Eat all the characters that match, but count how many there were.
2468                                                  */
2469
2470                                                 while(*str && (*p == *str)) {
2471                                                         str++;
2472                                                         matchcount++;
2473                                                 }
2474
2475                                                 /*
2476                                                  * Now check that if the regexp had n identical characters that
2477                                                  * matchcount had at least that many matches.
2478                                                  */
2479
2480                                                 while ( *(p+1) && (*(p+1) == *p)) {
2481                                                         p++;
2482                                                         matchcount--;
2483                                                 }
2484
2485                                                 if ( matchcount <= 0 )
2486                                                         return false;
2487                                         }
2488
2489                                         str--; /* We've eaten the match char after the '*' */
2490
2491                                         if(unix_do_match(p, str))
2492                                                 return true;
2493
2494                                         if(!*str)
2495                                                 return false;
2496                                         else
2497                                                 str++;
2498                                 }
2499                                 return false;
2500
2501                         default:
2502                                 if(*str != *p)
2503                                         return false;
2504                                 str++;
2505                                 p++;
2506                                 break;
2507                 }
2508         }
2509
2510         if(!*p && !*str)
2511                 return true;
2512
2513         if (!*p && str[0] == '.' && str[1] == 0)
2514                 return true;
2515
2516         if (!*str && *p == '?') {
2517                 while (*p == '?')
2518                         p++;
2519                 return(!*p);
2520         }
2521
2522         if(!*str && (*p == '*' && p[1] == '\0'))
2523                 return true;
2524
2525         return false;
2526 }
2527
2528 /*******************************************************************
2529  Simple case insensitive interface to a UNIX wildcard matcher.
2530  Returns True if match, False if not.
2531 *******************************************************************/
2532
2533 bool unix_wild_match(const char *pattern, const char *string)
2534 {
2535         TALLOC_CTX *ctx = talloc_stackframe();
2536         char *p2;
2537         char *s2;
2538         char *p;
2539         bool ret = false;
2540
2541         p2 = talloc_strdup(ctx,pattern);
2542         s2 = talloc_strdup(ctx,string);
2543         if (!p2 || !s2) {
2544                 TALLOC_FREE(ctx);
2545                 return false;
2546         }
2547         strlower_m(p2);
2548         strlower_m(s2);
2549
2550         /* Remove any *? and ** from the pattern as they are meaningless */
2551         for(p = p2; *p; p++) {
2552                 while( *p == '*' && (p[1] == '?' ||p[1] == '*')) {
2553                         memmove(&p[1], &p[2], strlen(&p[2])+1);
2554                 }
2555         }
2556
2557         if (strequal(p2,"*")) {
2558                 TALLOC_FREE(ctx);
2559                 return true;
2560         }
2561
2562         ret = unix_do_match(p2, s2);
2563         TALLOC_FREE(ctx);
2564         return ret;
2565 }
2566
2567 /**********************************************************************
2568  Converts a name to a fully qualified domain name.
2569  Returns true if lookup succeeded, false if not (then fqdn is set to name)
2570  Note we deliberately use gethostbyname here, not getaddrinfo as we want
2571  to examine the h_aliases and I don't know how to do that with getaddrinfo.
2572 ***********************************************************************/
2573
2574 bool name_to_fqdn(fstring fqdn, const char *name)
2575 {
2576         char *full = NULL;
2577         struct hostent *hp = gethostbyname(name);
2578
2579         if (!hp || !hp->h_name || !*hp->h_name) {
2580                 DEBUG(10,("name_to_fqdn: lookup for %s failed.\n", name));
2581                 fstrcpy(fqdn, name);
2582                 return false;
2583         }
2584
2585         /* Find out if the fqdn is returned as an alias
2586          * to cope with /etc/hosts files where the first
2587          * name is not the fqdn but the short name */
2588         if (hp->h_aliases && (! strchr_m(hp->h_name, '.'))) {
2589                 int i;
2590                 for (i = 0; hp->h_aliases[i]; i++) {
2591                         if (strchr_m(hp->h_aliases[i], '.')) {
2592                                 full = hp->h_aliases[i];
2593                                 break;
2594                         }
2595                 }
2596         }
2597         if (full && (StrCaseCmp(full, "localhost.localdomain") == 0)) {
2598                 DEBUG(1, ("WARNING: your /etc/hosts file may be broken!\n"));
2599                 DEBUGADD(1, ("    Specifing the machine hostname for address 127.0.0.1 may lead\n"));
2600                 DEBUGADD(1, ("    to Kerberos authentication problems as localhost.localdomain\n"));
2601                 DEBUGADD(1, ("    may end up being used instead of the real machine FQDN.\n"));
2602                 full = hp->h_name;
2603         }
2604         if (!full) {
2605                 full = hp->h_name;
2606         }
2607
2608         DEBUG(10,("name_to_fqdn: lookup for %s -> %s.\n", name, full));
2609         fstrcpy(fqdn, full);
2610         return true;
2611 }
2612
2613 /**********************************************************************
2614  Append a DATA_BLOB to a talloc'ed object
2615 ***********************************************************************/
2616
2617 void *talloc_append_blob(TALLOC_CTX *mem_ctx, void *buf, DATA_BLOB blob)
2618 {
2619         size_t old_size = 0;
2620         char *result;
2621
2622         if (blob.length == 0) {
2623                 return buf;
2624         }
2625
2626         if (buf != NULL) {
2627                 old_size = talloc_get_size(buf);
2628         }
2629
2630         result = (char *)TALLOC_REALLOC(mem_ctx, buf, old_size + blob.length);
2631         if (result == NULL) {
2632                 return NULL;
2633         }
2634
2635         memcpy(result + old_size, blob.data, blob.length);
2636         return result;
2637 }
2638
2639 uint32 map_share_mode_to_deny_mode(uint32 share_access, uint32 private_options)
2640 {
2641         switch (share_access & ~FILE_SHARE_DELETE) {
2642                 case FILE_SHARE_NONE:
2643                         return DENY_ALL;
2644                 case FILE_SHARE_READ:
2645                         return DENY_WRITE;
2646                 case FILE_SHARE_WRITE:
2647                         return DENY_READ;
2648                 case FILE_SHARE_READ|FILE_SHARE_WRITE:
2649                         return DENY_NONE;
2650         }
2651         if (private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS) {
2652                 return DENY_DOS;
2653         } else if (private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_FCB) {
2654                 return DENY_FCB;
2655         }
2656
2657         return (uint32)-1;
2658 }
2659
2660 pid_t procid_to_pid(const struct server_id *proc)
2661 {
2662         return proc->pid;
2663 }
2664
2665 static uint32 my_vnn = NONCLUSTER_VNN;
2666
2667 void set_my_vnn(uint32 vnn)
2668 {
2669         DEBUG(10, ("vnn pid %d = %u\n", (int)sys_getpid(), (unsigned int)vnn));
2670         my_vnn = vnn;
2671 }
2672
2673 uint32 get_my_vnn(void)
2674 {
2675         return my_vnn;
2676 }
2677
2678 struct server_id pid_to_procid(pid_t pid)
2679 {
2680         struct server_id result;
2681         result.pid = pid;
2682 #ifdef CLUSTER_SUPPORT
2683         result.vnn = my_vnn;
2684 #endif
2685         return result;
2686 }
2687
2688 struct server_id procid_self(void)
2689 {
2690         return pid_to_procid(sys_getpid());
2691 }
2692
2693 struct server_id server_id_self(void)
2694 {
2695         return procid_self();
2696 }
2697
2698 bool procid_equal(const struct server_id *p1, const struct server_id *p2)
2699 {
2700         if (p1->pid != p2->pid)
2701                 return False;
2702 #ifdef CLUSTER_SUPPORT
2703         if (p1->vnn != p2->vnn)
2704                 return False;
2705 #endif
2706         return True;
2707 }
2708
2709 bool cluster_id_equal(const struct server_id *id1,
2710                       const struct server_id *id2)
2711 {
2712         return procid_equal(id1, id2);
2713 }
2714
2715 bool procid_is_me(const struct server_id *pid)
2716 {
2717         if (pid->pid != sys_getpid())
2718                 return False;
2719 #ifdef CLUSTER_SUPPORT
2720         if (pid->vnn != my_vnn)
2721                 return False;
2722 #endif
2723         return True;
2724 }
2725
2726 struct server_id interpret_pid(const char *pid_string)
2727 {
2728         struct server_id result;
2729         int pid;
2730 #ifdef CLUSTER_SUPPORT
2731         unsigned int vnn;
2732         if (sscanf(pid_string, "%u:%d", &vnn, &pid) == 2) {
2733                 result.vnn = vnn;
2734                 result.pid = pid;
2735         }
2736         else if (sscanf(pid_string, "%d", &pid) == 1) {
2737                 result.vnn = get_my_vnn();
2738                 result.pid = pid;
2739         }
2740         else {
2741                 result.vnn = NONCLUSTER_VNN;
2742                 result.pid = -1;
2743         }
2744 #else
2745         if (sscanf(pid_string, "%d", &pid) != 1) {
2746                 result.pid = -1;
2747         } else {
2748                 result.pid = pid;
2749         }
2750 #endif
2751         /* Assigning to result.pid may have overflowed
2752            Map negative pid to -1: i.e. error */
2753         if (result.pid < 0) {
2754                 result.pid = -1;
2755         }
2756         return result;
2757 }
2758
2759 char *procid_str(TALLOC_CTX *mem_ctx, const struct server_id *pid)
2760 {
2761 #ifdef CLUSTER_SUPPORT
2762         if (pid->vnn == NONCLUSTER_VNN) {
2763                 return talloc_asprintf(mem_ctx,
2764                                 "%d",
2765                                 (int)pid->pid);
2766         }
2767         else {
2768                 return talloc_asprintf(mem_ctx,
2769                                         "%u:%d",
2770                                         (unsigned)pid->vnn,
2771                                         (int)pid->pid);
2772         }
2773 #else
2774         return talloc_asprintf(mem_ctx,
2775                         "%d",
2776                         (int)pid->pid);
2777 #endif
2778 }
2779
2780 char *procid_str_static(const struct server_id *pid)
2781 {
2782         return procid_str(talloc_tos(), pid);
2783 }
2784
2785 bool procid_valid(const struct server_id *pid)
2786 {
2787         return (pid->pid != -1);
2788 }
2789
2790 bool procid_is_local(const struct server_id *pid)
2791 {
2792 #ifdef CLUSTER_SUPPORT
2793         return pid->vnn == my_vnn;
2794 #else
2795         return True;
2796 #endif
2797 }
2798
2799 int this_is_smp(void)
2800 {
2801 #if defined(HAVE_SYSCONF)
2802
2803 #if defined(SYSCONF_SC_NPROC_ONLN)
2804         return (sysconf(_SC_NPROC_ONLN) > 1) ? 1 : 0;
2805 #elif defined(SYSCONF_SC_NPROCESSORS_ONLN)
2806         return (sysconf(_SC_NPROCESSORS_ONLN) > 1) ? 1 : 0;
2807 #else
2808         return 0;
2809 #endif
2810
2811 #else
2812         return 0;
2813 #endif
2814 }
2815
2816 /****************************************************************
2817  Check if offset/length fit into bufsize. Should probably be
2818  merged with is_offset_safe, but this would require a rewrite
2819  of lanman.c. Later :-)
2820 ****************************************************************/
2821
2822 bool trans_oob(uint32_t bufsize, uint32_t offset, uint32_t length)
2823 {
2824         if ((offset + length < offset) || (offset + length < length)) {
2825                 /* wrap */
2826                 return true;
2827         }
2828         if ((offset > bufsize) || (offset + length > bufsize)) {
2829                 /* overflow */
2830                 return true;
2831         }
2832         return false;
2833 }
2834
2835 /****************************************************************
2836  Check if an offset into a buffer is safe.
2837  If this returns True it's safe to indirect into the byte at
2838  pointer ptr+off.
2839 ****************************************************************/
2840
2841 bool is_offset_safe(const char *buf_base, size_t buf_len, char *ptr, size_t off)
2842 {
2843         const char *end_base = buf_base + buf_len;
2844         char *end_ptr = ptr + off;
2845
2846         if (!buf_base || !ptr) {
2847                 return False;
2848         }
2849
2850         if (end_base < buf_base || end_ptr < ptr) {
2851                 return False; /* wrap. */
2852         }
2853
2854         if (end_ptr < end_base) {
2855                 return True;
2856         }
2857         return False;
2858 }
2859
2860 /****************************************************************
2861  Return a safe pointer into a buffer, or NULL.
2862 ****************************************************************/
2863
2864 char *get_safe_ptr(const char *buf_base, size_t buf_len, char *ptr, size_t off)
2865 {
2866         return is_offset_safe(buf_base, buf_len, ptr, off) ?
2867                         ptr + off : NULL;
2868 }
2869
2870 /****************************************************************
2871  Return a safe pointer into a string within a buffer, or NULL.
2872 ****************************************************************/
2873
2874 char *get_safe_str_ptr(const char *buf_base, size_t buf_len, char *ptr, size_t off)
2875 {
2876         if (!is_offset_safe(buf_base, buf_len, ptr, off)) {
2877                 return NULL;
2878         }
2879         /* Check if a valid string exists at this offset. */
2880         if (skip_string(buf_base,buf_len, ptr + off) == NULL) {
2881                 return NULL;
2882         }
2883         return ptr + off;
2884 }
2885
2886 /****************************************************************
2887  Return an SVAL at a pointer, or failval if beyond the end.
2888 ****************************************************************/
2889
2890 int get_safe_SVAL(const char *buf_base, size_t buf_len, char *ptr, size_t off, int failval)
2891 {
2892         /*
2893          * Note we use off+1 here, not off+2 as SVAL accesses ptr[0] and ptr[1],
2894          * NOT ptr[2].
2895          */
2896         if (!is_offset_safe(buf_base, buf_len, ptr, off+1)) {
2897                 return failval;
2898         }
2899         return SVAL(ptr,off);
2900 }
2901
2902 /****************************************************************
2903  Return an IVAL at a pointer, or failval if beyond the end.
2904 ****************************************************************/
2905
2906 int get_safe_IVAL(const char *buf_base, size_t buf_len, char *ptr, size_t off, int failval)
2907 {
2908         /*
2909          * Note we use off+3 here, not off+4 as IVAL accesses
2910          * ptr[0] ptr[1] ptr[2] ptr[3] NOT ptr[4].
2911          */
2912         if (!is_offset_safe(buf_base, buf_len, ptr, off+3)) {
2913                 return failval;
2914         }
2915         return IVAL(ptr,off);
2916 }
2917
2918 /****************************************************************
2919  Split DOM\user into DOM and user. Do not mix with winbind variants of that
2920  call (they take care of winbind separator and other winbind specific settings).
2921 ****************************************************************/
2922
2923 void split_domain_user(TALLOC_CTX *mem_ctx,
2924                        const char *full_name,
2925                        char **domain,
2926                        char **user)
2927 {
2928         const char *p = NULL;
2929
2930         p = strchr_m(full_name, '\\');
2931
2932         if (p != NULL) {
2933                 *domain = talloc_strndup(mem_ctx, full_name,
2934                                          PTR_DIFF(p, full_name));
2935                 *user = talloc_strdup(mem_ctx, p+1);
2936         } else {
2937                 *domain = talloc_strdup(mem_ctx, "");
2938                 *user = talloc_strdup(mem_ctx, full_name);
2939         }
2940 }
2941
2942 #if 0
2943
2944 Disable these now we have checked all code paths and ensured
2945 NULL returns on zero request. JRA.
2946
2947 /****************************************************************
2948  talloc wrapper functions that guarentee a null pointer return
2949  if size == 0.
2950 ****************************************************************/
2951
2952 #ifndef MAX_TALLOC_SIZE
2953 #define MAX_TALLOC_SIZE 0x10000000
2954 #endif
2955
2956 /*
2957  *    talloc and zero memory.
2958  *    - returns NULL if size is zero.
2959  */
2960
2961 void *_talloc_zero_zeronull(const void *ctx, size_t size, const char *name)
2962 {
2963         void *p;
2964
2965         if (size == 0) {
2966                 return NULL;
2967         }
2968
2969         p = talloc_named_const(ctx, size, name);
2970
2971         if (p) {
2972                 memset(p, '\0', size);
2973         }
2974
2975         return p;
2976 }
2977
2978 /*
2979  *   memdup with a talloc.
2980  *   - returns NULL if size is zero.
2981  */
2982
2983 void *_talloc_memdup_zeronull(const void *t, const void *p, size_t size, const char *name)
2984 {
2985         void *newp;
2986
2987         if (size == 0) {
2988                 return NULL;
2989         }
2990
2991         newp = talloc_named_const(t, size, name);
2992         if (newp) {
2993                 memcpy(newp, p, size);
2994         }
2995
2996         return newp;
2997 }
2998
2999 /*
3000  *   alloc an array, checking for integer overflow in the array size.
3001  *   - returns NULL if count or el_size are zero.
3002  */
3003
3004 void *_talloc_array_zeronull(const void *ctx, size_t el_size, unsigned count, const char *name)
3005 {
3006         if (count >= MAX_TALLOC_SIZE/el_size) {
3007                 return NULL;
3008         }
3009
3010         if (el_size == 0 || count == 0) {
3011                 return NULL;
3012         }
3013
3014         return talloc_named_const(ctx, el_size * count, name);
3015 }
3016
3017 /*
3018  *   alloc an zero array, checking for integer overflow in the array size
3019  *   - returns NULL if count or el_size are zero.
3020  */
3021
3022 void *_talloc_zero_array_zeronull(const void *ctx, size_t el_size, unsigned count, const char *name)
3023 {
3024         if (count >= MAX_TALLOC_SIZE/el_size) {
3025                 return NULL;
3026         }
3027
3028         if (el_size == 0 || count == 0) {
3029                 return NULL;
3030         }
3031
3032         return _talloc_zero(ctx, el_size * count, name);
3033 }
3034
3035 /*
3036  *   Talloc wrapper that returns NULL if size == 0.
3037  */
3038 void *talloc_zeronull(const void *context, size_t size, const char *name)
3039 {
3040         if (size == 0) {
3041                 return NULL;
3042         }
3043         return talloc_named_const(context, size, name);
3044 }
3045 #endif
3046
3047 bool is_valid_policy_hnd(const struct policy_handle *hnd)
3048 {
3049         struct policy_handle tmp;
3050         ZERO_STRUCT(tmp);
3051         return (memcmp(&tmp, hnd, sizeof(tmp)) != 0);
3052 }
3053
3054 bool policy_hnd_equal(const struct policy_handle *hnd1,
3055                       const struct policy_handle *hnd2)
3056 {
3057         if (!hnd1 || !hnd2) {
3058                 return false;
3059         }
3060
3061         return (memcmp(hnd1, hnd2, sizeof(*hnd1)) == 0);
3062 }
3063
3064 /****************************************************************
3065  strip off leading '\\' from a hostname
3066 ****************************************************************/
3067
3068 const char *strip_hostname(const char *s)
3069 {
3070         if (!s) {
3071                 return NULL;
3072         }
3073
3074         if (strlen_m(s) < 3) {
3075                 return s;
3076         }
3077
3078         if (s[0] == '\\') s++;
3079         if (s[0] == '\\') s++;
3080
3081         return s;
3082 }