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