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