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 #include "popt_common.h"
  26 #include "secrets.h"
  27 #include "ctdbd_conn.h"
  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_names: malloc fail.\n" ) );
 224                         return False;
 225                 }
 226         }
 227
 228         if (!set_netbios_aliases(lp_netbios_aliases())) {
 229                 DEBUG( 0, ( "init_names: 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 NTSTATUS reinit_after_fork(struct messaging_context *msg_ctx,
 826                            struct event_context *ev_ctx,
 827                            struct server_id id,
 828                            bool parent_longlived)
 829 {
 830         NTSTATUS status = NT_STATUS_OK;
 831
 832         /* Reset the state of the random
 833          * number generation system, so
 834          * children do not get the same random
 835          * numbers as each other */
 836         set_need_random_reseed();
 837
 838         /* tdb needs special fork handling */
 839         if (tdb_reopen_all(parent_longlived ? 1 : 0) == -1) {
 840                 DEBUG(0,("tdb_reopen_all failed.\n"));
 841                 status = NT_STATUS_OPEN_FAILED;
 842                 goto done;
 843         }
 844
 845         if (ev_ctx && tevent_re_initialise(ev_ctx) != 0) {
 846                 smb_panic(__location__ ": Failed to re-initialise event context");
 847         }
 848
 849         if (msg_ctx) {
 850                 /*
 851                  * For clustering, we need to re-init our ctdbd connection after the
 852                  * fork
 853                  */
 854                 status = messaging_reinit(msg_ctx, id);
 855                 if (!NT_STATUS_IS_OK(status)) {
 856                         DEBUG(0,("messaging_reinit() failed: %s\n",
 857                                  nt_errstr(status)));
 858                 }
 859         }
 860  done:
 861         return status;
 862 }
 863
 864 #if defined(PARANOID_MALLOC_CHECKER)
 865
 866 /****************************************************************************
 867  Internal malloc wrapper. Externally visible.
 868 ****************************************************************************/
 869
 870 void *malloc_(size_t size)
 871 {
 872         if (size == 0) {
 873                 return NULL;
 874         }
 875 #undef malloc
 876         return malloc(size);
 877 #define malloc(s) __ERROR_DONT_USE_MALLOC_DIRECTLY
 878 }
 879
 880 /****************************************************************************
 881  Internal calloc wrapper. Not externally visible.
 882 ****************************************************************************/
 883
 884 static void *calloc_(size_t count, size_t size)
 885 {
 886         if (size == 0 || count == 0) {
 887                 return NULL;
 888         }
 889 #undef calloc
 890         return calloc(count, size);
 891 #define calloc(n,s) __ERROR_DONT_USE_CALLOC_DIRECTLY
 892 }
 893
 894 /****************************************************************************
 895  Internal realloc wrapper. Not externally visible.
 896 ****************************************************************************/
 897
 898 static void *realloc_(void *ptr, size_t size)
 899 {
 900 #undef realloc
 901         return realloc(ptr, size);
 902 #define realloc(p,s) __ERROR_DONT_USE_RELLOC_DIRECTLY
 903 }
 904
 905 #endif /* PARANOID_MALLOC_CHECKER */
 906
 907 /****************************************************************************
 908  Type-safe memalign
 909 ****************************************************************************/
 910
 911 void *memalign_array(size_t el_size, size_t align, unsigned int count)
 912 {
 913         if (count >= MAX_ALLOC_SIZE/el_size) {
 914                 return NULL;
 915         }
 916
 917         return sys_memalign(align, el_size*count);
 918 }
 919
 920 /****************************************************************************
 921  Type-safe calloc.
 922 ****************************************************************************/
 923
 924 void *calloc_array(size_t size, size_t nmemb)
 925 {
 926         if (nmemb >= MAX_ALLOC_SIZE/size) {
 927                 return NULL;
 928         }
 929         if (size == 0 || nmemb == 0) {
 930                 return NULL;
 931         }
 932 #if defined(PARANOID_MALLOC_CHECKER)
 933         return calloc_(nmemb, size);
 934 #else
 935         return calloc(nmemb, size);
 936 #endif
 937 }
 938
 939 /****************************************************************************
 940  Expand a pointer to be a particular size.
 941  Note that this version of Realloc has an extra parameter that decides
 942  whether to free the passed in storage on allocation failure or if the
 943  new size is zero.
 944
 945  This is designed for use in the typical idiom of :
 946
 947  p = SMB_REALLOC(p, size)
 948  if (!p) {
 949     return error;
 950  }
 951
 952  and not to have to keep track of the old 'p' contents to free later, nor
 953  to worry if the size parameter was zero. In the case where NULL is returned
 954  we guarentee that p has been freed.
 955
 956  If free later semantics are desired, then pass 'free_old_on_error' as False which
 957  guarentees that the old contents are not freed on error, even if size == 0. To use
 958  this idiom use :
 959
 960  tmp = SMB_REALLOC_KEEP_OLD_ON_ERROR(p, size);
 961  if (!tmp) {
 962     SAFE_FREE(p);
 963     return error;
 964  } else {
 965     p = tmp;
 966  }
 967
 968  Changes were instigated by Coverity error checking. JRA.
 969 ****************************************************************************/
 970
 971 void *Realloc(void *p, size_t size, bool free_old_on_error)
 972 {
 973         void *ret=NULL;
 974
 975         if (size == 0) {
 976                 if (free_old_on_error) {
 977                         SAFE_FREE(p);
 978                 }
 979                 DEBUG(2,("Realloc asked for 0 bytes\n"));
 980                 return NULL;
 981         }
 982
 983 #if defined(PARANOID_MALLOC_CHECKER)
 984         if (!p) {
 985                 ret = (void *)malloc_(size);
 986         } else {
 987                 ret = (void *)realloc_(p,size);
 988         }
 989 #else
 990         if (!p) {
 991                 ret = (void *)malloc(size);
 992         } else {
 993                 ret = (void *)realloc(p,size);
 994         }
 995 #endif
 996
 997         if (!ret) {
 998                 if (free_old_on_error && p) {
 999                         SAFE_FREE(p);
1000                 }
1001                 DEBUG(0,("Memory allocation error: failed to expand to %d bytes\n",(int)size));
1002         }
1003
1004         return(ret);
1005 }
1006
1007 /****************************************************************************
1008  (Hopefully) efficient array append.
1009 ****************************************************************************/
1010
1011 void add_to_large_array(TALLOC_CTX *mem_ctx, size_t element_size,
1012                         void *element, void *_array, uint32 *num_elements,
1013                         ssize_t *array_size)
1014 {
1015         void **array = (void **)_array;
1016
1017         if (*array_size < 0) {
1018                 return;
1019         }
1020
1021         if (*array == NULL) {
1022                 if (*array_size == 0) {
1023                         *array_size = 128;
1024                 }
1025
1026                 if (*array_size >= MAX_ALLOC_SIZE/element_size) {
1027                         goto error;
1028                 }
1029
1030                 *array = TALLOC(mem_ctx, element_size * (*array_size));
1031                 if (*array == NULL) {
1032                         goto error;
1033                 }
1034         }
1035
1036         if (*num_elements == *array_size) {
1037                 *array_size *= 2;
1038
1039                 if (*array_size >= MAX_ALLOC_SIZE/element_size) {
1040                         goto error;
1041                 }
1042
1043                 *array = TALLOC_REALLOC(mem_ctx, *array,
1044                                         element_size * (*array_size));
1045
1046                 if (*array == NULL) {
1047                         goto error;
1048                 }
1049         }
1050
1051         memcpy((char *)(*array) + element_size*(*num_elements),
1052                element, element_size);
1053         *num_elements += 1;
1054
1055         return;
1056
1057  error:
1058         *num_elements = 0;
1059         *array_size = -1;
1060 }
1061
1062 /****************************************************************************
1063  Get my own domain name, or "" if we have none.
1064 ****************************************************************************/
1065
1066 char *get_mydnsdomname(TALLOC_CTX *ctx)
1067 {
1068         const char *domname;
1069         char *p;
1070
1071         domname = get_mydnsfullname();
1072         if (!domname) {
1073                 return NULL;
1074         }
1075
1076         p = strchr_m(domname, '.');
1077         if (p) {
1078                 p++;
1079                 return talloc_strdup(ctx, p);
1080         } else {
1081                 return talloc_strdup(ctx, "");
1082         }
1083 }
1084
1085 /****************************************************************************
1086  Interpret a protocol description string, with a default.
1087 ****************************************************************************/
1088
1089 int interpret_protocol(const char *str,int def)
1090 {
1091         if (strequal(str,"NT1"))
1092                 return(PROTOCOL_NT1);
1093         if (strequal(str,"LANMAN2"))
1094                 return(PROTOCOL_LANMAN2);
1095         if (strequal(str,"LANMAN1"))
1096                 return(PROTOCOL_LANMAN1);
1097         if (strequal(str,"CORE"))
1098                 return(PROTOCOL_CORE);
1099         if (strequal(str,"COREPLUS"))
1100                 return(PROTOCOL_COREPLUS);
1101         if (strequal(str,"CORE+"))
1102                 return(PROTOCOL_COREPLUS);
1103
1104         DEBUG(0,("Unrecognised protocol level %s\n",str));
1105
1106         return(def);
1107 }
1108
1109
1110 #if (defined(HAVE_NETGROUP) && defined(WITH_AUTOMOUNT))
1111 /******************************************************************
1112  Remove any mount options such as -rsize=2048,wsize=2048 etc.
1113  Based on a fix from <Thomas.Hepper@icem.de>.
1114  Returns a malloc'ed string.
1115 *******************************************************************/
1116
1117 static char *strip_mount_options(TALLOC_CTX *ctx, const char *str)
1118 {
1119         if (*str == '-') {
1120                 const char *p = str;
1121                 while(*p && !isspace(*p))
1122                         p++;
1123                 while(*p && isspace(*p))
1124                         p++;
1125                 if(*p) {
1126                         return talloc_strdup(ctx, p);
1127                 }
1128         }
1129         return NULL;
1130 }
1131
1132 /*******************************************************************
1133  Patch from jkf@soton.ac.uk
1134  Split Luke's automount_server into YP lookup and string splitter
1135  so can easily implement automount_path().
1136  Returns a malloc'ed string.
1137 *******************************************************************/
1138
1139 #ifdef WITH_NISPLUS_HOME
1140 char *automount_lookup(TALLOC_CTX *ctx, const char *user_name)
1141 {
1142         char *value = NULL;
1143
1144         char *nis_map = (char *)lp_nis_home_map_name();
1145
1146         char buffer[NIS_MAXATTRVAL + 1];
1147         nis_result *result;
1148         nis_object *object;
1149         entry_obj  *entry;
1150
1151         snprintf(buffer, sizeof(buffer), "[key=%s],%s", user_name, nis_map);
1152         DEBUG(5, ("NIS+ querystring: %s\n", buffer));
1153
1154         if (result = nis_list(buffer, FOLLOW_PATH|EXPAND_NAME|HARD_LOOKUP, NULL, NULL)) {
1155                 if (result->status != NIS_SUCCESS) {
1156                         DEBUG(3, ("NIS+ query failed: %s\n", nis_sperrno(result->status)));
1157                 } else {
1158                         object = result->objects.objects_val;
1159                         if (object->zo_data.zo_type == ENTRY_OBJ) {
1160                                 entry = &object->zo_data.objdata_u.en_data;
1161                                 DEBUG(5, ("NIS+ entry type: %s\n", entry->en_type));
1162                                 DEBUG(3, ("NIS+ result: %s\n", entry->en_cols.en_cols_val[1].ec_value.ec_value_val));
1163
1164                                 value = talloc_strdup(ctx,
1165                                                 entry->en_cols.en_cols_val[1].ec_value.ec_value_val);
1166                                 if (!value) {
1167                                         nis_freeresult(result);
1168                                         return NULL;
1169                                 }
1170                                 value = talloc_string_sub(ctx,
1171                                                 value,
1172                                                 "&",
1173                                                 user_name);
1174                         }
1175                 }
1176         }
1177         nis_freeresult(result);
1178
1179         if (value) {
1180                 value = strip_mount_options(ctx, value);
1181                 DEBUG(4, ("NIS+ Lookup: %s resulted in %s\n",
1182                                         user_name, value));
1183         }
1184         return value;
1185 }
1186 #else /* WITH_NISPLUS_HOME */
1187
1188 char *automount_lookup(TALLOC_CTX *ctx, const char *user_name)
1189 {
1190         char *value = NULL;
1191
1192         int nis_error;        /* returned by yp all functions */
1193         char *nis_result;     /* yp_match inits this */
1194         int nis_result_len;  /* and set this */
1195         char *nis_domain;     /* yp_get_default_domain inits this */
1196         char *nis_map = (char *)lp_nis_home_map_name();
1197
1198         if ((nis_error = yp_get_default_domain(&nis_domain)) != 0) {
1199                 DEBUG(3, ("YP Error: %s\n", yperr_string(nis_error)));
1200                 return NULL;
1201         }
1202
1203         DEBUG(5, ("NIS Domain: %s\n", nis_domain));
1204
1205         if ((nis_error = yp_match(nis_domain, nis_map, user_name,
1206                                         strlen(user_name), &nis_result,
1207                                         &nis_result_len)) == 0) {
1208                 if (nis_result_len > 0 && nis_result[nis_result_len] == '\n') {
1209                         nis_result[nis_result_len] = '\0';
1210                 }
1211                 value = talloc_strdup(ctx, nis_result);
1212                 if (!value) {
1213                         return NULL;
1214                 }
1215                 value = strip_mount_options(ctx, value);
1216         } else if(nis_error == YPERR_KEY) {
1217                 DEBUG(3, ("YP Key not found:  while looking up \"%s\" in map \"%s\"\n",
1218                                 user_name, nis_map));
1219                 DEBUG(3, ("using defaults for server and home directory\n"));
1220         } else {
1221                 DEBUG(3, ("YP Error: \"%s\" while looking up \"%s\" in map \"%s\"\n",
1222                                 yperr_string(nis_error), user_name, nis_map));
1223         }
1224
1225         if (value) {
1226                 DEBUG(4, ("YP Lookup: %s resulted in %s\n", user_name, value));
1227         }
1228         return value;
1229 }
1230 #endif /* WITH_NISPLUS_HOME */
1231 #endif
1232
1233 /****************************************************************************
1234  Check if a process exists. Does this work on all unixes?
1235 ****************************************************************************/
1236
1237 bool process_exists(const struct server_id pid)
1238 {
1239         if (procid_is_me(&pid)) {
1240                 return True;
1241         }
1242
1243         if (procid_is_local(&pid)) {
1244                 return (kill(pid.pid,0) == 0 || errno != ESRCH);
1245         }
1246
1247 #ifdef CLUSTER_SUPPORT
1248         return ctdbd_process_exists(messaging_ctdbd_connection(),
1249                                     pid.vnn, pid.pid);
1250 #else
1251         return False;
1252 #endif
1253 }
1254
1255 /*******************************************************************
1256  Convert a uid into a user name.
1257 ********************************************************************/
1258
1259 const char *uidtoname(uid_t uid)
1260 {
1261         TALLOC_CTX *ctx = talloc_tos();
1262         char *name = NULL;
1263         struct passwd *pass = NULL;
1264
1265         pass = getpwuid_alloc(ctx,uid);
1266         if (pass) {
1267                 name = talloc_strdup(ctx,pass->pw_name);
1268                 TALLOC_FREE(pass);
1269         } else {
1270                 name = talloc_asprintf(ctx,
1271                                 "%ld",
1272                                 (long int)uid);
1273         }
1274         return name;
1275 }
1276
1277 /*******************************************************************
1278  Convert a gid into a group name.
1279 ********************************************************************/
1280
1281 char *gidtoname(gid_t gid)
1282 {
1283         struct group *grp;
1284
1285         grp = getgrgid(gid);
1286         if (grp) {
1287                 return talloc_strdup(talloc_tos(), grp->gr_name);
1288         }
1289         else {
1290                 return talloc_asprintf(talloc_tos(),
1291                                         "%d",
1292                                         (int)gid);
1293         }
1294 }
1295
1296 /*******************************************************************
1297  Convert a user name into a uid.
1298 ********************************************************************/
1299
1300 uid_t nametouid(const char *name)
1301 {
1302         struct passwd *pass;
1303         char *p;
1304         uid_t u;
1305
1306         pass = Get_Pwnam_alloc(talloc_tos(), name);
1307         if (pass) {
1308                 u = pass->pw_uid;
1309                 TALLOC_FREE(pass);
1310                 return u;
1311         }
1312
1313         u = (uid_t)strtol(name, &p, 0);
1314         if ((p != name) && (*p == '\0'))
1315                 return u;
1316
1317         return (uid_t)-1;
1318 }
1319
1320 /*******************************************************************
1321  Convert a name to a gid_t if possible. Return -1 if not a group.
1322 ********************************************************************/
1323
1324 gid_t nametogid(const char *name)
1325 {
1326         struct group *grp;
1327         char *p;
1328         gid_t g;
1329
1330         g = (gid_t)strtol(name, &p, 0);
1331         if ((p != name) && (*p == '\0'))
1332                 return g;
1333
1334         grp = sys_getgrnam(name);
1335         if (grp)
1336                 return(grp->gr_gid);
1337         return (gid_t)-1;
1338 }
1339
1340 /*******************************************************************
1341  Something really nasty happened - panic !
1342 ********************************************************************/
1343
1344 void smb_panic_s3(const char *why)
1345 {
1346         char *cmd;
1347         int result;
1348
1349         DEBUG(0,("PANIC (pid %llu): %s\n",
1350                     (unsigned long long)sys_getpid(), why));
1351         log_stack_trace();
1352
1353         cmd = lp_panic_action();
1354         if (cmd && *cmd) {
1355                 DEBUG(0, ("smb_panic(): calling panic action [%s]\n", cmd));
1356                 result = system(cmd);
1357
1358                 if (result == -1)
1359                         DEBUG(0, ("smb_panic(): fork failed in panic action: %s\n",
1360                                           strerror(errno)));
1361                 else
1362                         DEBUG(0, ("smb_panic(): action returned status %d\n",
1363                                           WEXITSTATUS(result)));
1364         }
1365
1366         dump_core();
1367 }
1368
1369 /*******************************************************************
1370  Print a backtrace of the stack to the debug log. This function
1371  DELIBERATELY LEAKS MEMORY. The expectation is that you should
1372  exit shortly after calling it.
1373 ********************************************************************/
1374
1375 #ifdef HAVE_LIBUNWIND_H
1376 #include <libunwind.h>
1377 #endif
1378
1379 #ifdef HAVE_EXECINFO_H
1380 #include <execinfo.h>
1381 #endif
1382
1383 #ifdef HAVE_LIBEXC_H
1384 #include <libexc.h>
1385 #endif
1386
1387 void log_stack_trace(void)
1388 {
1389 #ifdef HAVE_LIBUNWIND
1390         /* Try to use libunwind before any other technique since on ia64
1391          * libunwind correctly walks the stack in more circumstances than
1392          * backtrace.
1393          */
1394         unw_cursor_t cursor;
1395         unw_context_t uc;
1396         unsigned i = 0;
1397
1398         char procname[256];
1399         unw_word_t ip, sp, off;
1400
1401         procname[sizeof(procname) - 1] = '\0';
1402
1403         if (unw_getcontext(&uc) != 0) {
1404                 goto libunwind_failed;
1405         }
1406
1407         if (unw_init_local(&cursor, &uc) != 0) {
1408                 goto libunwind_failed;
1409         }
1410
1411         DEBUG(0, ("BACKTRACE:\n"));
1412
1413         do {
1414             ip = sp = 0;
1415             unw_get_reg(&cursor, UNW_REG_IP, &ip);
1416             unw_get_reg(&cursor, UNW_REG_SP, &sp);
1417
1418             switch (unw_get_proc_name(&cursor,
1419                         procname, sizeof(procname) - 1, &off) ) {
1420             case 0:
1421                     /* Name found. */
1422             case -UNW_ENOMEM:
1423                     /* Name truncated. */
1424                     DEBUGADD(0, (" #%u %s + %#llx [ip=%#llx] [sp=%#llx]\n",
1425                             i, procname, (long long)off,
1426                             (long long)ip, (long long) sp));
1427                     break;
1428             default:
1429             /* case -UNW_ENOINFO: */
1430             /* case -UNW_EUNSPEC: */
1431                     /* No symbol name found. */
1432                     DEBUGADD(0, (" #%u %s [ip=%#llx] [sp=%#llx]\n",
1433                             i, "<unknown symbol>",
1434                             (long long)ip, (long long) sp));
1435             }
1436             ++i;
1437         } while (unw_step(&cursor) > 0);
1438
1439         return;
1440
1441 libunwind_failed:
1442         DEBUG(0, ("unable to produce a stack trace with libunwind\n"));
1443
1444 #elif HAVE_BACKTRACE_SYMBOLS
1445         void *backtrace_stack[BACKTRACE_STACK_SIZE];
1446         size_t backtrace_size;
1447         char **backtrace_strings;
1448
1449         /* get the backtrace (stack frames) */
1450         backtrace_size = backtrace(backtrace_stack,BACKTRACE_STACK_SIZE);
1451         backtrace_strings = backtrace_symbols(backtrace_stack, backtrace_size);
1452
1453         DEBUG(0, ("BACKTRACE: %lu stack frames:\n",
1454                   (unsigned long)backtrace_size));
1455
1456         if (backtrace_strings) {
1457                 int i;
1458
1459                 for (i = 0; i < backtrace_size; i++)
1460                         DEBUGADD(0, (" #%u %s\n", i, backtrace_strings[i]));
1461
1462                 /* Leak the backtrace_strings, rather than risk what free() might do */
1463         }
1464
1465 #elif HAVE_LIBEXC
1466
1467         /* The IRIX libexc library provides an API for unwinding the stack. See
1468          * libexc(3) for details. Apparantly trace_back_stack leaks memory, but
1469          * since we are about to abort anyway, it hardly matters.
1470          */
1471
1472 #define NAMESIZE 32 /* Arbitrary */
1473
1474         __uint64_t      addrs[BACKTRACE_STACK_SIZE];
1475         char *          names[BACKTRACE_STACK_SIZE];
1476         char            namebuf[BACKTRACE_STACK_SIZE * NAMESIZE];
1477
1478         int             i;
1479         int             levels;
1480
1481         ZERO_ARRAY(addrs);
1482         ZERO_ARRAY(names);
1483         ZERO_ARRAY(namebuf);
1484
1485         /* We need to be root so we can open our /proc entry to walk
1486          * our stack. It also helps when we want to dump core.
1487          */
1488         become_root();
1489
1490         for (i = 0; i < BACKTRACE_STACK_SIZE; i++) {
1491                 names[i] = namebuf + (i * NAMESIZE);
1492         }
1493
1494         levels = trace_back_stack(0, addrs, names,
1495                         BACKTRACE_STACK_SIZE, NAMESIZE - 1);
1496
1497         DEBUG(0, ("BACKTRACE: %d stack frames:\n", levels));
1498         for (i = 0; i < levels; i++) {
1499                 DEBUGADD(0, (" #%d 0x%llx %s\n", i, addrs[i], names[i]));
1500         }
1501 #undef NAMESIZE
1502
1503 #else
1504         DEBUG(0, ("unable to produce a stack trace on this platform\n"));
1505 #endif
1506 }
1507
1508 /*******************************************************************
1509   A readdir wrapper which just returns the file name.
1510  ********************************************************************/
1511
1512 const char *readdirname(SMB_STRUCT_DIR *p)
1513 {
1514         SMB_STRUCT_DIRENT *ptr;
1515         char *dname;
1516
1517         if (!p)
1518                 return(NULL);
1519
1520         ptr = (SMB_STRUCT_DIRENT *)sys_readdir(p);
1521         if (!ptr)
1522                 return(NULL);
1523
1524         dname = ptr->d_name;
1525
1526 #ifdef NEXT2
1527         if (telldir(p) < 0)
1528                 return(NULL);
1529 #endif
1530
1531 #ifdef HAVE_BROKEN_READDIR_NAME
1532         /* using /usr/ucb/cc is BAD */
1533         dname = dname - 2;
1534 #endif
1535
1536         return talloc_strdup(talloc_tos(), dname);
1537 }
1538
1539 /*******************************************************************
1540  Utility function used to decide if the last component
1541  of a path matches a (possibly wildcarded) entry in a namelist.
1542 ********************************************************************/
1543
1544 bool is_in_path(const char *name, name_compare_entry *namelist, bool case_sensitive)
1545 {
1546         const char *last_component;
1547
1548         /* if we have no list it's obviously not in the path */
1549         if((namelist == NULL ) || ((namelist != NULL) && (namelist[0].name == NULL))) {
1550                 return False;
1551         }
1552
1553         DEBUG(8, ("is_in_path: %s\n", name));
1554
1555         /* Get the last component of the unix name. */
1556         last_component = strrchr_m(name, '/');
1557         if (!last_component) {
1558                 last_component = name;
1559         } else {
1560                 last_component++; /* Go past '/' */
1561         }
1562
1563         for(; namelist->name != NULL; namelist++) {
1564                 if(namelist->is_wild) {
1565                         if (mask_match(last_component, namelist->name, case_sensitive)) {
1566                                 DEBUG(8,("is_in_path: mask match succeeded\n"));
1567                                 return True;
1568                         }
1569                 } else {
1570                         if((case_sensitive && (strcmp(last_component, namelist->name) == 0))||
1571                                                 (!case_sensitive && (StrCaseCmp(last_component, namelist->name) == 0))) {
1572                                 DEBUG(8,("is_in_path: match succeeded\n"));
1573                                 return True;
1574                         }
1575                 }
1576         }
1577         DEBUG(8,("is_in_path: match not found\n"));
1578         return False;
1579 }
1580
1581 /*******************************************************************
1582  Strip a '/' separated list into an array of
1583  name_compare_enties structures suitable for
1584  passing to is_in_path(). We do this for
1585  speed so we can pre-parse all the names in the list
1586  and don't do it for each call to is_in_path().
1587  namelist is modified here and is assumed to be
1588  a copy owned by the caller.
1589  We also check if the entry contains a wildcard to
1590  remove a potentially expensive call to mask_match
1591  if possible.
1592 ********************************************************************/
1593
1594 void set_namearray(name_compare_entry **ppname_array, const char *namelist)
1595 {
1596         char *name_end;
1597         char *nameptr = (char *)namelist;
1598         int num_entries = 0;
1599         int i;
1600
1601         (*ppname_array) = NULL;
1602
1603         if((nameptr == NULL ) || ((nameptr != NULL) && (*nameptr == '\0')))
1604                 return;
1605
1606         /* We need to make two passes over the string. The
1607                 first to count the number of elements, the second
1608                 to split it.
1609         */
1610
1611         while(*nameptr) {
1612                 if ( *nameptr == '/' ) {
1613                         /* cope with multiple (useless) /s) */
1614                         nameptr++;
1615                         continue;
1616                 }
1617                 /* anything left? */
1618                 if ( *nameptr == '\0' )
1619                         break;
1620
1621                 /* find the next '/' or consume remaining */
1622                 name_end = strchr_m(nameptr, '/');
1623                 if (name_end == NULL)
1624                         name_end = (char *)nameptr + strlen(nameptr);
1625
1626                 /* next segment please */
1627                 nameptr = name_end + 1;
1628                 num_entries++;
1629         }
1630
1631         if(num_entries == 0)
1632                 return;
1633
1634         if(( (*ppname_array) = SMB_MALLOC_ARRAY(name_compare_entry, num_entries + 1)) == NULL) {
1635                 DEBUG(0,("set_namearray: malloc fail\n"));
1636                 return;
1637         }
1638
1639         /* Now copy out the names */
1640         nameptr = (char *)namelist;
1641         i = 0;
1642         while(*nameptr) {
1643                 if ( *nameptr == '/' ) {
1644                         /* cope with multiple (useless) /s) */
1645                         nameptr++;
1646                         continue;
1647                 }
1648                 /* anything left? */
1649                 if ( *nameptr == '\0' )
1650                         break;
1651
1652                 /* find the next '/' or consume remaining */
1653                 name_end = strchr_m(nameptr, '/');
1654                 if (name_end)
1655                         *name_end = '\0';
1656                 else
1657                         name_end = nameptr + strlen(nameptr);
1658
1659                 (*ppname_array)[i].is_wild = ms_has_wild(nameptr);
1660                 if(((*ppname_array)[i].name = SMB_STRDUP(nameptr)) == NULL) {
1661                         DEBUG(0,("set_namearray: malloc fail (1)\n"));
1662                         return;
1663                 }
1664
1665                 /* next segment please */
1666                 nameptr = name_end + 1;
1667                 i++;
1668         }
1669
1670         (*ppname_array)[i].name = NULL;
1671
1672         return;
1673 }
1674
1675 /****************************************************************************
1676  Routine to free a namearray.
1677 ****************************************************************************/
1678
1679 void free_namearray(name_compare_entry *name_array)
1680 {
1681         int i;
1682
1683         if(name_array == NULL)
1684                 return;
1685
1686         for(i=0; name_array[i].name!=NULL; i++)
1687                 SAFE_FREE(name_array[i].name);
1688         SAFE_FREE(name_array);
1689 }
1690
1691 #undef DBGC_CLASS
1692 #define DBGC_CLASS DBGC_LOCKING
1693
1694 /****************************************************************************
1695  Simple routine to query existing file locks. Cruft in NFS and 64->32 bit mapping
1696  is dealt with in posix.c
1697  Returns True if we have information regarding this lock region (and returns
1698  F_UNLCK in *ptype if the region is unlocked). False if the call failed.
1699 ****************************************************************************/
1700
1701 bool fcntl_getlock(int fd, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype, pid_t *ppid)
1702 {
1703         SMB_STRUCT_FLOCK lock;
1704         int ret;
1705
1706         DEBUG(8,("fcntl_getlock fd=%d offset=%.0f count=%.0f type=%d\n",
1707                     fd,(double)*poffset,(double)*pcount,*ptype));
1708
1709         lock.l_type = *ptype;
1710         lock.l_whence = SEEK_SET;
1711         lock.l_start = *poffset;
1712         lock.l_len = *pcount;
1713         lock.l_pid = 0;
1714
1715         ret = sys_fcntl_ptr(fd,SMB_F_GETLK,&lock);
1716
1717         if (ret == -1) {
1718                 int sav = errno;
1719                 DEBUG(3,("fcntl_getlock: lock request failed at offset %.0f count %.0f type %d (%s)\n",
1720                         (double)*poffset,(double)*pcount,*ptype,strerror(errno)));
1721                 errno = sav;
1722                 return False;
1723         }
1724
1725         *ptype = lock.l_type;
1726         *poffset = lock.l_start;
1727         *pcount = lock.l_len;
1728         *ppid = lock.l_pid;
1729
1730         DEBUG(3,("fcntl_getlock: fd %d is returned info %d pid %u\n",
1731                         fd, (int)lock.l_type, (unsigned int)lock.l_pid));
1732         return True;
1733 }
1734
1735 #undef DBGC_CLASS
1736 #define DBGC_CLASS DBGC_ALL
1737
1738 /*******************************************************************
1739  Is the name specified one of my netbios names.
1740  Returns true if it is equal, false otherwise.
1741 ********************************************************************/
1742
1743 bool is_myname(const char *s)
1744 {
1745         int n;
1746         bool ret = False;
1747
1748         for (n=0; my_netbios_names(n); n++) {
1749                 if (strequal(my_netbios_names(n), s)) {
1750                         ret=True;
1751                         break;
1752                 }
1753         }
1754         DEBUG(8, ("is_myname(\"%s\") returns %d\n", s, ret));
1755         return(ret);
1756 }
1757
1758 /*******************************************************************
1759  Is the name specified our workgroup/domain.
1760  Returns true if it is equal, false otherwise.
1761 ********************************************************************/
1762
1763 bool is_myworkgroup(const char *s)
1764 {
1765         bool ret = False;
1766
1767         if (strequal(s, lp_workgroup())) {
1768                 ret=True;
1769         }
1770
1771         DEBUG(8, ("is_myworkgroup(\"%s\") returns %d\n", s, ret));
1772         return(ret);
1773 }
1774
1775 /*******************************************************************
1776  we distinguish between 2K and XP by the "Native Lan Manager" string
1777    WinXP => "Windows 2002 5.1"
1778    WinXP 64bit => "Windows XP 5.2"
1779    Win2k => "Windows 2000 5.0"
1780    NT4   => "Windows NT 4.0"
1781    Win9x => "Windows 4.0"
1782  Windows 2003 doesn't set the native lan manager string but
1783  they do set the domain to "Windows 2003 5.2" (probably a bug).
1784 ********************************************************************/
1785
1786 void ra_lanman_string( const char *native_lanman )
1787 {
1788         if ( strcmp( native_lanman, "Windows 2002 5.1" ) == 0 )
1789                 set_remote_arch( RA_WINXP );
1790         else if ( strcmp( native_lanman, "Windows XP 5.2" ) == 0 )
1791                 set_remote_arch( RA_WINXP64 );
1792         else if ( strcmp( native_lanman, "Windows Server 2003 5.2" ) == 0 )
1793                 set_remote_arch( RA_WIN2K3 );
1794 }
1795
1796 static const char *remote_arch_str;
1797
1798 const char *get_remote_arch_str(void)
1799 {
1800         if (!remote_arch_str) {
1801                 return "UNKNOWN";
1802         }
1803         return remote_arch_str;
1804 }
1805
1806 /*******************************************************************
1807  Set the horrid remote_arch string based on an enum.
1808 ********************************************************************/
1809
1810 void set_remote_arch(enum remote_arch_types type)
1811 {
1812         ra_type = type;
1813         switch( type ) {
1814         case RA_WFWG:
1815                 remote_arch_str = "WfWg";
1816                 break;
1817         case RA_OS2:
1818                 remote_arch_str = "OS2";
1819                 break;
1820         case RA_WIN95:
1821                 remote_arch_str = "Win95";
1822                 break;
1823         case RA_WINNT:
1824                 remote_arch_str = "WinNT";
1825                 break;
1826         case RA_WIN2K:
1827                 remote_arch_str = "Win2K";
1828                 break;
1829         case RA_WINXP:
1830                 remote_arch_str = "WinXP";
1831                 break;
1832         case RA_WINXP64:
1833                 remote_arch_str = "WinXP64";
1834                 break;
1835         case RA_WIN2K3:
1836                 remote_arch_str = "Win2K3";
1837                 break;
1838         case RA_VISTA:
1839                 remote_arch_str = "Vista";
1840                 break;
1841         case RA_SAMBA:
1842                 remote_arch_str = "Samba";
1843                 break;
1844         case RA_CIFSFS:
1845                 remote_arch_str = "CIFSFS";
1846                 break;
1847         case RA_OSX:
1848                 remote_arch_str = "OSX";
1849                 break;
1850         default:
1851                 ra_type = RA_UNKNOWN;
1852                 remote_arch_str = "UNKNOWN";
1853                 break;
1854         }
1855
1856         DEBUG(10,("set_remote_arch: Client arch is \'%s\'\n",
1857                                 remote_arch_str));
1858 }
1859
1860 /*******************************************************************
1861  Get the remote_arch type.
1862 ********************************************************************/
1863
1864 enum remote_arch_types get_remote_arch(void)
1865 {
1866         return ra_type;
1867 }
1868
1869 const char *tab_depth(int level, int depth)
1870 {
1871         if( CHECK_DEBUGLVL(level) ) {
1872                 dbgtext("%*s", depth*4, "");
1873         }
1874         return "";
1875 }
1876
1877 /*****************************************************************************
1878  Provide a checksum on a string
1879
1880  Input:  s - the null-terminated character string for which the checksum
1881              will be calculated.
1882
1883   Output: The checksum value calculated for s.
1884 *****************************************************************************/
1885
1886 int str_checksum(const char *s)
1887 {
1888         TDB_DATA key = string_tdb_data(s);
1889         return tdb_jenkins_hash(&key);
1890 }
1891
1892 /*****************************************************************
1893  Zero a memory area then free it. Used to catch bugs faster.
1894 *****************************************************************/
1895
1896 void zero_free(void *p, size_t size)
1897 {
1898         memset(p, 0, size);
1899         SAFE_FREE(p);
1900 }
1901
1902 /*****************************************************************
1903  Set our open file limit to a requested max and return the limit.
1904 *****************************************************************/
1905
1906 int set_maxfiles(int requested_max)
1907 {
1908 #if (defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE))
1909         struct rlimit rlp;
1910         int saved_current_limit;
1911
1912         if(getrlimit(RLIMIT_NOFILE, &rlp)) {
1913                 DEBUG(0,("set_maxfiles: getrlimit (1) for RLIMIT_NOFILE failed with error %s\n",
1914                         strerror(errno) ));
1915                 /* just guess... */
1916                 return requested_max;
1917         }
1918
1919         /*
1920          * Set the fd limit to be real_max_open_files + MAX_OPEN_FUDGEFACTOR to
1921          * account for the extra fd we need
1922          * as well as the log files and standard
1923          * handles etc. Save the limit we want to set in case
1924          * we are running on an OS that doesn't support this limit (AIX)
1925          * which always returns RLIM_INFINITY for rlp.rlim_max.
1926          */
1927
1928         /* Try raising the hard (max) limit to the requested amount. */
1929
1930 #if defined(RLIM_INFINITY)
1931         if (rlp.rlim_max != RLIM_INFINITY) {
1932                 int orig_max = rlp.rlim_max;
1933
1934                 if ( rlp.rlim_max < requested_max )
1935                         rlp.rlim_max = requested_max;
1936
1937                 /* This failing is not an error - many systems (Linux) don't
1938                         support our default request of 10,000 open files. JRA. */
1939
1940                 if(setrlimit(RLIMIT_NOFILE, &rlp)) {
1941                         DEBUG(3,("set_maxfiles: setrlimit for RLIMIT_NOFILE for %d max files failed with error %s\n",
1942                                 (int)rlp.rlim_max, strerror(errno) ));
1943
1944                         /* Set failed - restore original value from get. */
1945                         rlp.rlim_max = orig_max;
1946                 }
1947         }
1948 #endif
1949
1950         /* Now try setting the soft (current) limit. */
1951
1952         saved_current_limit = rlp.rlim_cur = MIN(requested_max,rlp.rlim_max);
1953
1954         if(setrlimit(RLIMIT_NOFILE, &rlp)) {
1955                 DEBUG(0,("set_maxfiles: setrlimit for RLIMIT_NOFILE for %d files failed with error %s\n",
1956                         (int)rlp.rlim_cur, strerror(errno) ));
1957                 /* just guess... */
1958                 return saved_current_limit;
1959         }
1960
1961         if(getrlimit(RLIMIT_NOFILE, &rlp)) {
1962                 DEBUG(0,("set_maxfiles: getrlimit (2) for RLIMIT_NOFILE failed with error %s\n",
1963                         strerror(errno) ));
1964                 /* just guess... */
1965                 return saved_current_limit;
1966     }
1967
1968 #if defined(RLIM_INFINITY)
1969         if(rlp.rlim_cur == RLIM_INFINITY)
1970                 return saved_current_limit;
1971 #endif
1972
1973         if((int)rlp.rlim_cur > saved_current_limit)
1974                 return saved_current_limit;
1975
1976         return rlp.rlim_cur;
1977 #else /* !defined(HAVE_GETRLIMIT) || !defined(RLIMIT_NOFILE) */
1978         /*
1979          * No way to know - just guess...
1980          */
1981         return requested_max;
1982 #endif
1983 }
1984
1985 /*****************************************************************
1986  malloc that aborts with smb_panic on fail or zero size.
1987  *****************************************************************/
1988
1989 void *smb_xmalloc_array(size_t size, unsigned int count)
1990 {
1991         void *p;
1992         if (size == 0) {
1993                 smb_panic("smb_xmalloc_array: called with zero size");
1994         }
1995         if (count >= MAX_ALLOC_SIZE/size) {
1996                 smb_panic("smb_xmalloc_array: alloc size too large");
1997         }
1998         if ((p = SMB_MALLOC(size*count)) == NULL) {
1999                 DEBUG(0, ("smb_xmalloc_array failed to allocate %lu * %lu bytes\n",
2000                         (unsigned long)size, (unsigned long)count));
2001                 smb_panic("smb_xmalloc_array: malloc failed");
2002         }
2003         return p;
2004 }
2005
2006 /*
2007   vasprintf that aborts on malloc fail
2008 */
2009
2010  int smb_xvasprintf(char **ptr, const char *format, va_list ap)
2011 {
2012         int n;
2013         va_list ap2;
2014
2015         va_copy(ap2, ap);
2016
2017         n = vasprintf(ptr, format, ap2);
2018         va_end(ap2);
2019         if (n == -1 || ! *ptr) {
2020                 smb_panic("smb_xvasprintf: out of memory");
2021         }
2022         return n;
2023 }
2024
2025 /*****************************************************************
2026  Get local hostname and cache result.
2027 *****************************************************************/
2028
2029 char *myhostname(void)
2030 {
2031         static char *ret;
2032         if (ret == NULL) {
2033                 ret = get_myname(NULL);
2034         }
2035         return ret;
2036 }
2037
2038 /**
2039  * @brief Returns an absolute path to a file concatenating the provided
2040  * @a rootpath and @a basename
2041  *
2042  * @param name Filename, relative to @a rootpath
2043  *
2044  * @retval Pointer to a string containing the full path.
2045  **/
2046
2047 static char *xx_path(const char *name, const char *rootpath)
2048 {
2049         char *fname = NULL;
2050
2051         fname = talloc_strdup(talloc_tos(), rootpath);
2052         if (!fname) {
2053                 return NULL;
2054         }
2055         trim_string(fname,"","/");
2056
2057         if (!directory_exist(fname)) {
2058                 if (!mkdir(fname,0755))
2059                         DEBUG(1, ("Unable to create directory %s for file %s. "
2060                               "Error was %s\n", fname, name, strerror(errno)));
2061         }
2062
2063         return talloc_asprintf(talloc_tos(),
2064                                 "%s/%s",
2065                                 fname,
2066                                 name);
2067 }
2068
2069 /**
2070  * @brief Returns an absolute path to a file in the Samba lock directory.
2071  *
2072  * @param name File to find, relative to LOCKDIR.
2073  *
2074  * @retval Pointer to a talloc'ed string containing the full path.
2075  **/
2076
2077 char *lock_path(const char *name)
2078 {
2079         return xx_path(name, lp_lockdir());
2080 }
2081
2082 /**
2083  * @brief Returns an absolute path to a file in the Samba pid directory.
2084  *
2085  * @param name File to find, relative to PIDDIR.
2086  *
2087  * @retval Pointer to a talloc'ed string containing the full path.
2088  **/
2089
2090 char *pid_path(const char *name)
2091 {
2092         return xx_path(name, lp_piddir());
2093 }
2094
2095 /**
2096  * @brief Returns an absolute path to a file in the Samba lib directory.
2097  *
2098  * @param name File to find, relative to LIBDIR.
2099  *
2100  * @retval Pointer to a string containing the full path.
2101  **/
2102
2103 char *lib_path(const char *name)
2104 {
2105         return talloc_asprintf(talloc_tos(), "%s/%s", get_dyn_LIBDIR(), name);
2106 }
2107
2108 /**
2109  * @brief Returns an absolute path to a file in the Samba modules directory.
2110  *
2111  * @param name File to find, relative to MODULESDIR.
2112  *
2113  * @retval Pointer to a string containing the full path.
2114  **/
2115
2116 char *modules_path(const char *name)
2117 {
2118         return talloc_asprintf(talloc_tos(), "%s/%s", get_dyn_MODULESDIR(), name);
2119 }
2120
2121 /**
2122  * @brief Returns an absolute path to a file in the Samba data directory.
2123  *
2124  * @param name File to find, relative to CODEPAGEDIR.
2125  *
2126  * @retval Pointer to a talloc'ed string containing the full path.
2127  **/
2128
2129 char *data_path(const char *name)
2130 {
2131         return talloc_asprintf(talloc_tos(), "%s/%s", get_dyn_CODEPAGEDIR(), name);
2132 }
2133
2134 /**
2135  * @brief Returns an absolute path to a file in the Samba state directory.
2136  *
2137  * @param name File to find, relative to STATEDIR.
2138  *
2139  * @retval Pointer to a talloc'ed string containing the full path.
2140  **/
2141
2142 char *state_path(const char *name)
2143 {
2144         return xx_path(name, lp_statedir());
2145 }
2146
2147 /**
2148  * @brief Returns an absolute path to a file in the Samba cache directory.
2149  *
2150  * @param name File to find, relative to CACHEDIR.
2151  *
2152  * @retval Pointer to a talloc'ed string containing the full path.
2153  **/
2154
2155 char *cache_path(const char *name)
2156 {
2157         return xx_path(name, lp_cachedir());
2158 }
2159
2160 /**
2161  * @brief Returns the platform specific shared library extension.
2162  *
2163  * @retval Pointer to a const char * containing the extension.
2164  **/
2165
2166 const char *shlib_ext(void)
2167 {
2168         return get_dyn_SHLIBEXT();
2169 }
2170
2171 /*******************************************************************
2172  Given a filename - get its directory name
2173 ********************************************************************/
2174
2175 bool parent_dirname(TALLOC_CTX *mem_ctx, const char *dir, char **parent,
2176                     const char **name)
2177 {
2178         char *p;
2179         ptrdiff_t len;
2180
2181         p = strrchr_m(dir, '/'); /* Find final '/', if any */
2182
2183         if (p == NULL) {
2184                 if (!(*parent = talloc_strdup(mem_ctx, "."))) {
2185                         return False;
2186                 }
2187                 if (name) {
2188                         *name = dir;
2189                 }
2190                 return True;
2191         }
2192
2193         len = p-dir;
2194
2195         if (!(*parent = (char *)TALLOC_MEMDUP(mem_ctx, dir, len+1))) {
2196                 return False;
2197         }
2198         (*parent)[len] = '\0';
2199
2200         if (name) {
2201                 *name = p+1;
2202         }
2203         return True;
2204 }
2205
2206 /*******************************************************************
2207  Determine if a pattern contains any Microsoft wildcard characters.
2208 *******************************************************************/
2209
2210 bool ms_has_wild(const char *s)
2211 {
2212         char c;
2213
2214         if (lp_posix_pathnames()) {
2215                 /* With posix pathnames no characters are wild. */
2216                 return False;
2217         }
2218
2219         while ((c = *s++)) {
2220                 switch (c) {
2221                 case '*':
2222                 case '?':
2223                 case '<':
2224                 case '>':
2225                 case '"':
2226                         return True;
2227                 }
2228         }
2229         return False;
2230 }
2231
2232 bool ms_has_wild_w(const smb_ucs2_t *s)
2233 {
2234         smb_ucs2_t c;
2235         if (!s) return False;
2236         while ((c = *s++)) {
2237                 switch (c) {
2238                 case UCS2_CHAR('*'):
2239                 case UCS2_CHAR('?'):
2240                 case UCS2_CHAR('<'):
2241                 case UCS2_CHAR('>'):
2242                 case UCS2_CHAR('"'):
2243                         return True;
2244                 }
2245         }
2246         return False;
2247 }
2248
2249 /*******************************************************************
2250  A wrapper that handles case sensitivity and the special handling
2251  of the ".." name.
2252 *******************************************************************/
2253
2254 bool mask_match(const char *string, const char *pattern, bool is_case_sensitive)
2255 {
2256         if (ISDOTDOT(string))
2257                 string = ".";
2258         if (ISDOT(pattern))
2259                 return False;
2260
2261         return ms_fnmatch(pattern, string, Protocol <= PROTOCOL_LANMAN2, is_case_sensitive) == 0;
2262 }
2263
2264 /*******************************************************************
2265  A wrapper that handles case sensitivity and the special handling
2266  of the ".." name. Varient that is only called by old search code which requires
2267  pattern translation.
2268 *******************************************************************/
2269
2270 bool mask_match_search(const char *string, const char *pattern, bool is_case_sensitive)
2271 {
2272         if (ISDOTDOT(string))
2273                 string = ".";
2274         if (ISDOT(pattern))
2275                 return False;
2276
2277         return ms_fnmatch(pattern, string, True, is_case_sensitive) == 0;
2278 }
2279
2280 /*******************************************************************
2281  A wrapper that handles a list of patters and calls mask_match()
2282  on each.  Returns True if any of the patterns match.
2283 *******************************************************************/
2284
2285 bool mask_match_list(const char *string, char **list, int listLen, bool is_case_sensitive)
2286 {
2287        while (listLen-- > 0) {
2288                if (mask_match(string, *list++, is_case_sensitive))
2289                        return True;
2290        }
2291        return False;
2292 }
2293
2294 /*********************************************************
2295  Recursive routine that is called by unix_wild_match.
2296 *********************************************************/
2297
2298 static bool unix_do_match(const char *regexp, const char *str)
2299 {
2300         const char *p;
2301
2302         for( p = regexp; *p && *str; ) {
2303
2304                 switch(*p) {
2305                         case '?':
2306                                 str++;
2307                                 p++;
2308                                 break;
2309
2310                         case '*':
2311
2312                                 /*
2313                                  * Look for a character matching
2314                                  * the one after the '*'.
2315                                  */
2316                                 p++;
2317                                 if(!*p)
2318                                         return true; /* Automatic match */
2319                                 while(*str) {
2320
2321                                         while(*str && (*p != *str))
2322                                                 str++;
2323
2324                                         /*
2325                                          * Patch from weidel@multichart.de. In the case of the regexp
2326                                          * '*XX*' we want to ensure there are at least 2 'X' characters
2327                                          * in the string after the '*' for a match to be made.
2328                                          */
2329
2330                                         {
2331                                                 int matchcount=0;
2332
2333                                                 /*
2334                                                  * Eat all the characters that match, but count how many there were.
2335                                                  */
2336
2337                                                 while(*str && (*p == *str)) {
2338                                                         str++;
2339                                                         matchcount++;
2340                                                 }
2341
2342                                                 /*
2343                                                  * Now check that if the regexp had n identical characters that
2344                                                  * matchcount had at least that many matches.
2345                                                  */
2346
2347                                                 while ( *(p+1) && (*(p+1) == *p)) {
2348                                                         p++;
2349                                                         matchcount--;
2350                                                 }
2351
2352                                                 if ( matchcount <= 0 )
2353                                                         return false;
2354                                         }
2355
2356                                         str--; /* We've eaten the match char after the '*' */
2357
2358                                         if(unix_do_match(p, str))
2359                                                 return true;
2360
2361                                         if(!*str)
2362                                                 return false;
2363                                         else
2364                                                 str++;
2365                                 }
2366                                 return false;
2367
2368                         default:
2369                                 if(*str != *p)
2370                                         return false;
2371                                 str++;
2372                                 p++;
2373                                 break;
2374                 }
2375         }
2376
2377         if(!*p && !*str)
2378                 return true;
2379
2380         if (!*p && str[0] == '.' && str[1] == 0)
2381                 return true;
2382
2383         if (!*str && *p == '?') {
2384                 while (*p == '?')
2385                         p++;
2386                 return(!*p);
2387         }
2388
2389         if(!*str && (*p == '*' && p[1] == '\0'))
2390                 return true;
2391
2392         return false;
2393 }
2394
2395 /*******************************************************************
2396  Simple case insensitive interface to a UNIX wildcard matcher.
2397  Returns True if match, False if not.
2398 *******************************************************************/
2399
2400 bool unix_wild_match(const char *pattern, const char *string)
2401 {
2402         TALLOC_CTX *ctx = talloc_stackframe();
2403         char *p2;
2404         char *s2;
2405         char *p;
2406         bool ret = false;
2407
2408         p2 = talloc_strdup(ctx,pattern);
2409         s2 = talloc_strdup(ctx,string);
2410         if (!p2 || !s2) {
2411                 TALLOC_FREE(ctx);
2412                 return false;
2413         }
2414         strlower_m(p2);
2415         strlower_m(s2);
2416
2417         /* Remove any *? and ** from the pattern as they are meaningless */
2418         for(p = p2; *p; p++) {
2419                 while( *p == '*' && (p[1] == '?' ||p[1] == '*')) {
2420                         memmove(&p[1], &p[2], strlen(&p[2])+1);
2421                 }
2422         }
2423
2424         if (strequal(p2,"*")) {
2425                 TALLOC_FREE(ctx);
2426                 return true;
2427         }
2428
2429         ret = unix_do_match(p2, s2);
2430         TALLOC_FREE(ctx);
2431         return ret;
2432 }
2433
2434 /**********************************************************************
2435  Converts a name to a fully qualified domain name.
2436  Returns true if lookup succeeded, false if not (then fqdn is set to name)
2437  Note we deliberately use gethostbyname here, not getaddrinfo as we want
2438  to examine the h_aliases and I don't know how to do that with getaddrinfo.
2439 ***********************************************************************/
2440
2441 bool name_to_fqdn(fstring fqdn, const char *name)
2442 {
2443         char *full = NULL;
2444         struct hostent *hp = gethostbyname(name);
2445
2446         if (!hp || !hp->h_name || !*hp->h_name) {
2447                 DEBUG(10,("name_to_fqdn: lookup for %s failed.\n", name));
2448                 fstrcpy(fqdn, name);
2449                 return false;
2450         }
2451
2452         /* Find out if the fqdn is returned as an alias
2453          * to cope with /etc/hosts files where the first
2454          * name is not the fqdn but the short name */
2455         if (hp->h_aliases && (! strchr_m(hp->h_name, '.'))) {
2456                 int i;
2457                 for (i = 0; hp->h_aliases[i]; i++) {
2458                         if (strchr_m(hp->h_aliases[i], '.')) {
2459                                 full = hp->h_aliases[i];
2460                                 break;
2461                         }
2462                 }
2463         }
2464         if (full && (StrCaseCmp(full, "localhost.localdomain") == 0)) {
2465                 DEBUG(1, ("WARNING: your /etc/hosts file may be broken!\n"));
2466                 DEBUGADD(1, ("    Specifing the machine hostname for address 127.0.0.1 may lead\n"));
2467                 DEBUGADD(1, ("    to Kerberos authentication problems as localhost.localdomain\n"));
2468                 DEBUGADD(1, ("    may end up being used instead of the real machine FQDN.\n"));
2469                 full = hp->h_name;
2470         }
2471         if (!full) {
2472                 full = hp->h_name;
2473         }
2474
2475         DEBUG(10,("name_to_fqdn: lookup for %s -> %s.\n", name, full));
2476         fstrcpy(fqdn, full);
2477         return true;
2478 }
2479
2480 /**********************************************************************
2481  Append a DATA_BLOB to a talloc'ed object
2482 ***********************************************************************/
2483
2484 void *talloc_append_blob(TALLOC_CTX *mem_ctx, void *buf, DATA_BLOB blob)
2485 {
2486         size_t old_size = 0;
2487         char *result;
2488
2489         if (blob.length == 0) {
2490                 return buf;
2491         }
2492
2493         if (buf != NULL) {
2494                 old_size = talloc_get_size(buf);
2495         }
2496
2497         result = (char *)TALLOC_REALLOC(mem_ctx, buf, old_size + blob.length);
2498         if (result == NULL) {
2499                 return NULL;
2500         }
2501
2502         memcpy(result + old_size, blob.data, blob.length);
2503         return result;
2504 }
2505
2506 uint32 map_share_mode_to_deny_mode(uint32 share_access, uint32 private_options)
2507 {
2508         switch (share_access & ~FILE_SHARE_DELETE) {
2509                 case FILE_SHARE_NONE:
2510                         return DENY_ALL;
2511                 case FILE_SHARE_READ:
2512                         return DENY_WRITE;
2513                 case FILE_SHARE_WRITE:
2514                         return DENY_READ;
2515                 case FILE_SHARE_READ|FILE_SHARE_WRITE:
2516                         return DENY_NONE;
2517         }
2518         if (private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS) {
2519                 return DENY_DOS;
2520         } else if (private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_FCB) {
2521                 return DENY_FCB;
2522         }
2523
2524         return (uint32)-1;
2525 }
2526
2527 pid_t procid_to_pid(const struct server_id *proc)
2528 {
2529         return proc->pid;
2530 }
2531
2532 static uint32 my_vnn = NONCLUSTER_VNN;
2533
2534 void set_my_vnn(uint32 vnn)
2535 {
2536         DEBUG(10, ("vnn pid %d = %u\n", (int)sys_getpid(), (unsigned int)vnn));
2537         my_vnn = vnn;
2538 }
2539
2540 uint32 get_my_vnn(void)
2541 {
2542         return my_vnn;
2543 }
2544
2545 static uint64_t my_unique_id = 0;
2546
2547 void set_my_unique_id(uint64_t unique_id)
2548 {
2549         my_unique_id = unique_id;
2550 }
2551
2552 struct server_id pid_to_procid(pid_t pid)
2553 {
2554         struct server_id result;
2555         result.pid = pid;
2556         result.unique_id = my_unique_id;
2557         result.vnn = my_vnn;
2558         return result;
2559 }
2560
2561 struct server_id procid_self(void)
2562 {
2563         return pid_to_procid(sys_getpid());
2564 }
2565
2566 bool procid_equal(const struct server_id *p1, const struct server_id *p2)
2567 {
2568         if (p1->pid != p2->pid)
2569                 return False;
2570         if (p1->vnn != p2->vnn)
2571                 return False;
2572         return True;
2573 }
2574
2575 bool cluster_id_equal(const struct server_id *id1,
2576                       const struct server_id *id2)
2577 {
2578         return procid_equal(id1, id2);
2579 }
2580
2581 bool procid_is_me(const struct server_id *pid)
2582 {
2583         if (pid->pid != sys_getpid())
2584                 return False;
2585         if (pid->vnn != my_vnn)
2586                 return False;
2587         return True;
2588 }
2589
2590 struct server_id interpret_pid(const char *pid_string)
2591 {
2592         struct server_id result;
2593         int pid;
2594         unsigned int vnn;
2595         if (sscanf(pid_string, "%u:%d", &vnn, &pid) == 2) {
2596                 result.vnn = vnn;
2597                 result.pid = pid;
2598         }
2599         else if (sscanf(pid_string, "%d", &pid) == 1) {
2600                 result.vnn = get_my_vnn();
2601                 result.pid = pid;
2602         }
2603         else {
2604                 result.vnn = NONCLUSTER_VNN;
2605                 result.pid = -1;
2606         }
2607         /* Assigning to result.pid may have overflowed
2608            Map negative pid to -1: i.e. error */
2609         if (result.pid < 0) {
2610                 result.pid = -1;
2611         }
2612         result.unique_id = 0;
2613         return result;
2614 }
2615
2616 char *procid_str(TALLOC_CTX *mem_ctx, const struct server_id *pid)
2617 {
2618         if (pid->vnn == NONCLUSTER_VNN) {
2619                 return talloc_asprintf(mem_ctx,
2620                                 "%d",
2621                                 (int)pid->pid);
2622         }
2623         else {
2624                 return talloc_asprintf(mem_ctx,
2625                                         "%u:%d",
2626                                         (unsigned)pid->vnn,
2627                                         (int)pid->pid);
2628         }
2629 }
2630
2631 char *procid_str_static(const struct server_id *pid)
2632 {
2633         return procid_str(talloc_tos(), pid);
2634 }
2635
2636 bool procid_valid(const struct server_id *pid)
2637 {
2638         return (pid->pid != -1);
2639 }
2640
2641 bool procid_is_local(const struct server_id *pid)
2642 {
2643         return pid->vnn == my_vnn;
2644 }
2645
2646 /****************************************************************
2647  Check if offset/length fit into bufsize. Should probably be
2648  merged with is_offset_safe, but this would require a rewrite
2649  of lanman.c. Later :-)
2650 ****************************************************************/
2651
2652 bool trans_oob(uint32_t bufsize, uint32_t offset, uint32_t length)
2653 {
2654         if ((offset + length < offset) || (offset + length < length)) {
2655                 /* wrap */
2656                 return true;
2657         }
2658         if ((offset > bufsize) || (offset + length > bufsize)) {
2659                 /* overflow */
2660                 return true;
2661         }
2662         return false;
2663 }
2664
2665 /****************************************************************
2666  Check if an offset into a buffer is safe.
2667  If this returns True it's safe to indirect into the byte at
2668  pointer ptr+off.
2669 ****************************************************************/
2670
2671 bool is_offset_safe(const char *buf_base, size_t buf_len, char *ptr, size_t off)
2672 {
2673         const char *end_base = buf_base + buf_len;
2674         char *end_ptr = ptr + off;
2675
2676         if (!buf_base || !ptr) {
2677                 return False;
2678         }
2679
2680         if (end_base < buf_base || end_ptr < ptr) {
2681                 return False; /* wrap. */
2682         }
2683
2684         if (end_ptr < end_base) {
2685                 return True;
2686         }
2687         return False;
2688 }
2689
2690 /****************************************************************
2691  Return a safe pointer into a buffer, or NULL.
2692 ****************************************************************/
2693
2694 char *get_safe_ptr(const char *buf_base, size_t buf_len, char *ptr, size_t off)
2695 {
2696         return is_offset_safe(buf_base, buf_len, ptr, off) ?
2697                         ptr + off : NULL;
2698 }
2699
2700 /****************************************************************
2701  Return a safe pointer into a string within a buffer, or NULL.
2702 ****************************************************************/
2703
2704 char *get_safe_str_ptr(const char *buf_base, size_t buf_len, char *ptr, size_t off)
2705 {
2706         if (!is_offset_safe(buf_base, buf_len, ptr, off)) {
2707                 return NULL;
2708         }
2709         /* Check if a valid string exists at this offset. */
2710         if (skip_string(buf_base,buf_len, ptr + off) == NULL) {
2711                 return NULL;
2712         }
2713         return ptr + off;
2714 }
2715
2716 /****************************************************************
2717  Return an SVAL at a pointer, or failval if beyond the end.
2718 ****************************************************************/
2719
2720 int get_safe_SVAL(const char *buf_base, size_t buf_len, char *ptr, size_t off, int failval)
2721 {
2722         /*
2723          * Note we use off+1 here, not off+2 as SVAL accesses ptr[0] and ptr[1],
2724          * NOT ptr[2].
2725          */
2726         if (!is_offset_safe(buf_base, buf_len, ptr, off+1)) {
2727                 return failval;
2728         }
2729         return SVAL(ptr,off);
2730 }
2731
2732 /****************************************************************
2733  Return an IVAL at a pointer, or failval if beyond the end.
2734 ****************************************************************/
2735
2736 int get_safe_IVAL(const char *buf_base, size_t buf_len, char *ptr, size_t off, int failval)
2737 {
2738         /*
2739          * Note we use off+3 here, not off+4 as IVAL accesses
2740          * ptr[0] ptr[1] ptr[2] ptr[3] NOT ptr[4].
2741          */
2742         if (!is_offset_safe(buf_base, buf_len, ptr, off+3)) {
2743                 return failval;
2744         }
2745         return IVAL(ptr,off);
2746 }
2747
2748 /****************************************************************
2749  Split DOM\user into DOM and user. Do not mix with winbind variants of that
2750  call (they take care of winbind separator and other winbind specific settings).
2751 ****************************************************************/
2752
2753 void split_domain_user(TALLOC_CTX *mem_ctx,
2754                        const char *full_name,
2755                        char **domain,
2756                        char **user)
2757 {
2758         const char *p = NULL;
2759
2760         p = strchr_m(full_name, '\\');
2761
2762         if (p != NULL) {
2763                 *domain = talloc_strndup(mem_ctx, full_name,
2764                                          PTR_DIFF(p, full_name));
2765                 *user = talloc_strdup(mem_ctx, p+1);
2766         } else {
2767                 *domain = talloc_strdup(mem_ctx, "");
2768                 *user = talloc_strdup(mem_ctx, full_name);
2769         }
2770 }
2771
2772 #if 0
2773
2774 Disable these now we have checked all code paths and ensured
2775 NULL returns on zero request. JRA.
2776
2777 /****************************************************************
2778  talloc wrapper functions that guarentee a null pointer return
2779  if size == 0.
2780 ****************************************************************/
2781
2782 #ifndef MAX_TALLOC_SIZE
2783 #define MAX_TALLOC_SIZE 0x10000000
2784 #endif
2785
2786 /*
2787  *    talloc and zero memory.
2788  *    - returns NULL if size is zero.
2789  */
2790
2791 void *_talloc_zero_zeronull(const void *ctx, size_t size, const char *name)
2792 {
2793         void *p;
2794
2795         if (size == 0) {
2796                 return NULL;
2797         }
2798
2799         p = talloc_named_const(ctx, size, name);
2800
2801         if (p) {
2802                 memset(p, '\0', size);
2803         }
2804
2805         return p;
2806 }
2807
2808 /*
2809  *   memdup with a talloc.
2810  *   - returns NULL if size is zero.
2811  */
2812
2813 void *_talloc_memdup_zeronull(const void *t, const void *p, size_t size, const char *name)
2814 {
2815         void *newp;
2816
2817         if (size == 0) {
2818                 return NULL;
2819         }
2820
2821         newp = talloc_named_const(t, size, name);
2822         if (newp) {
2823                 memcpy(newp, p, size);
2824         }
2825
2826         return newp;
2827 }
2828
2829 /*
2830  *   alloc an array, checking for integer overflow in the array size.
2831  *   - returns NULL if count or el_size are zero.
2832  */
2833
2834 void *_talloc_array_zeronull(const void *ctx, size_t el_size, unsigned count, const char *name)
2835 {
2836         if (count >= MAX_TALLOC_SIZE/el_size) {
2837                 return NULL;
2838         }
2839
2840         if (el_size == 0 || count == 0) {
2841                 return NULL;
2842         }
2843
2844         return talloc_named_const(ctx, el_size * count, name);
2845 }
2846
2847 /*
2848  *   alloc an zero array, checking for integer overflow in the array size
2849  *   - returns NULL if count or el_size are zero.
2850  */
2851
2852 void *_talloc_zero_array_zeronull(const void *ctx, size_t el_size, unsigned count, const char *name)
2853 {
2854         if (count >= MAX_TALLOC_SIZE/el_size) {
2855                 return NULL;
2856         }
2857
2858         if (el_size == 0 || count == 0) {
2859                 return NULL;
2860         }
2861
2862         return _talloc_zero(ctx, el_size * count, name);
2863 }
2864
2865 /*
2866  *   Talloc wrapper that returns NULL if size == 0.
2867  */
2868 void *talloc_zeronull(const void *context, size_t size, const char *name)
2869 {
2870         if (size == 0) {
2871                 return NULL;
2872         }
2873         return talloc_named_const(context, size, name);
2874 }
2875 #endif
2876
2877 /****************************************************************
2878  strip off leading '\\' from a hostname
2879 ****************************************************************/
2880
2881 const char *strip_hostname(const char *s)
2882 {
2883         if (!s) {
2884                 return NULL;
2885         }
2886
2887         if (strlen_m(s) < 3) {
2888                 return s;
2889         }
2890
2891         if (s[0] == '\\') s++;
2892         if (s[0] == '\\') s++;
2893
2894         return s;
2895 }
2896
2897 bool tevent_req_poll_ntstatus(struct tevent_req *req,
2898                               struct tevent_context *ev,
2899                               NTSTATUS *status)
2900 {
2901         bool ret = tevent_req_poll(req, ev);
2902         if (!ret) {
2903                 *status = map_nt_error_from_unix(errno);
2904         }
2905         return ret;
2906 }
2907
2908 bool any_nt_status_not_ok(NTSTATUS err1, NTSTATUS err2, NTSTATUS *result)
2909 {
2910         if (!NT_STATUS_IS_OK(err1)) {
2911                 *result = err1;
2912                 return true;
2913         }
2914         if (!NT_STATUS_IS_OK(err2)) {
2915                 *result = err2;
2916                 return true;
2917         }
2918         return false;
2919 }
2920
2921 int timeval_to_msec(struct timeval t)
2922 {
2923         return t.tv_sec * 1000 + (t.tv_usec+999) / 1000;
2924 }