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