source4/torture/util_smb.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    SMB torture tester utility functions
   4    Copyright (C) Andrew Tridgell 2003
   5    Copyright (C) Jelmer Vernooij 2006
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20
  21 #include "includes.h"
  22 #include "lib/cmdline/popt_common.h"
  23 #include "libcli/raw/libcliraw.h"
  24 #include "libcli/raw/raw_proto.h"
  25 #include "libcli/raw/ioctl.h"
  26 #include "libcli/libcli.h"
  27 #include "system/filesys.h"
  28 #include "system/shmem.h"
  29 #include "system/wait.h"
  30 #include "system/time.h"
  31 #include "torture/torture.h"
  32 #include "../lib/util/dlinklist.h"
  33 #include "auth/credentials/credentials.h"
  34 #include "libcli/resolve/resolve.h"
  35 #include "param/param.h"
  36 #include "libcli/security/security.h"
  37 #include "libcli/util/clilsa.h"
  38
  39
  40 /**
  41   setup a directory ready for a test
  42 */
  43 _PUBLIC_ bool torture_setup_dir(struct smbcli_state *cli, const char *dname)
  44 {
  45         smb_raw_exit(cli->session);
  46         if (smbcli_deltree(cli->tree, dname) == -1 ||
  47             NT_STATUS_IS_ERR(smbcli_mkdir(cli->tree, dname))) {
  48                 printf("Unable to setup %s - %s\n", dname, smbcli_errstr(cli->tree));
  49                 return false;
  50         }
  51         return true;
  52 }
  53
  54 /*
  55   create a directory, returning a handle to it
  56 */
  57 NTSTATUS create_directory_handle(struct smbcli_tree *tree, const char *dname, int *fnum)
  58 {
  59         NTSTATUS status;
  60         union smb_open io;
  61         TALLOC_CTX *mem_ctx;
  62
  63         mem_ctx = talloc_named_const(tree, 0, "create_directory_handle");
  64
  65         io.generic.level = RAW_OPEN_NTCREATEX;
  66         io.ntcreatex.in.root_fid.fnum = 0;
  67         io.ntcreatex.in.flags = 0;
  68         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
  69         io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
  70         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
  71         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;
  72         io.ntcreatex.in.alloc_size = 0;
  73         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
  74         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
  75         io.ntcreatex.in.security_flags = 0;
  76         io.ntcreatex.in.fname = dname;
  77
  78         status = smb_raw_open(tree, mem_ctx, &io);
  79         talloc_free(mem_ctx);
  80
  81         if (NT_STATUS_IS_OK(status)) {
  82                 *fnum = io.ntcreatex.out.file.fnum;
  83         }
  84
  85         return status;
  86 }
  87
  88
  89 /**
  90   sometimes we need a fairly complex file to work with, so we can test
  91   all possible attributes.
  92 */
  93 _PUBLIC_ int create_complex_file(struct smbcli_state *cli, TALLOC_CTX *mem_ctx, const char *fname)
  94 {
  95         int fnum;
  96         char buf[7] = "abc";
  97         union smb_setfileinfo setfile;
  98         union smb_fileinfo fileinfo;
  99         time_t t = (time(NULL) & ~1);
 100         NTSTATUS status;
 101
 102         smbcli_unlink(cli->tree, fname);
 103         fnum = smbcli_nt_create_full(cli->tree, fname, 0,
 104                                      SEC_RIGHTS_FILE_ALL,
 105                                      FILE_ATTRIBUTE_NORMAL,
 106                                      NTCREATEX_SHARE_ACCESS_DELETE|
 107                                      NTCREATEX_SHARE_ACCESS_READ|
 108                                      NTCREATEX_SHARE_ACCESS_WRITE,
 109                                      NTCREATEX_DISP_OVERWRITE_IF,
 110                                      0, 0);
 111         if (fnum == -1) return -1;
 112
 113         smbcli_write(cli->tree, fnum, 0, buf, 0, sizeof(buf));
 114
 115         if (strchr(fname, ':') == NULL) {
 116                 /* setup some EAs */
 117                 setfile.generic.level = RAW_SFILEINFO_EA_SET;
 118                 setfile.generic.in.file.fnum = fnum;
 119                 setfile.ea_set.in.num_eas = 2;
 120                 setfile.ea_set.in.eas = talloc_array(mem_ctx, struct ea_struct, 2);
 121                 setfile.ea_set.in.eas[0].flags = 0;
 122                 setfile.ea_set.in.eas[0].name.s = "EAONE";
 123                 setfile.ea_set.in.eas[0].value = data_blob_talloc(mem_ctx, "VALUE1", 6);
 124                 setfile.ea_set.in.eas[1].flags = 0;
 125                 setfile.ea_set.in.eas[1].name.s = "SECONDEA";
 126                 setfile.ea_set.in.eas[1].value = data_blob_talloc(mem_ctx, "ValueTwo", 8);
 127                 status = smb_raw_setfileinfo(cli->tree, &setfile);
 128                 if (!NT_STATUS_IS_OK(status)) {
 129                         printf("Failed to setup EAs\n");
 130                 }
 131         }
 132
 133         /* make sure all the timestamps aren't the same, and are also
 134            in different DST zones*/
 135         setfile.generic.level = RAW_SFILEINFO_SETATTRE;
 136         setfile.generic.in.file.fnum = fnum;
 137
 138         setfile.setattre.in.create_time = t + 9*30*24*60*60;
 139         setfile.setattre.in.access_time = t + 6*30*24*60*60;
 140         setfile.setattre.in.write_time  = t + 3*30*24*60*60;
 141
 142         status = smb_raw_setfileinfo(cli->tree, &setfile);
 143         if (!NT_STATUS_IS_OK(status)) {
 144                 printf("Failed to setup file times - %s\n", nt_errstr(status));
 145         }
 146
 147         /* make sure all the timestamps aren't the same */
 148         fileinfo.generic.level = RAW_FILEINFO_GETATTRE;
 149         fileinfo.generic.in.file.fnum = fnum;
 150
 151         status = smb_raw_fileinfo(cli->tree, mem_ctx, &fileinfo);
 152         if (!NT_STATUS_IS_OK(status)) {
 153                 printf("Failed to query file times - %s\n", nt_errstr(status));
 154         }
 155
 156         if (setfile.setattre.in.create_time != fileinfo.getattre.out.create_time) {
 157                 printf("create_time not setup correctly\n");
 158         }
 159         if (setfile.setattre.in.access_time != fileinfo.getattre.out.access_time) {
 160                 printf("access_time not setup correctly\n");
 161         }
 162         if (setfile.setattre.in.write_time != fileinfo.getattre.out.write_time) {
 163                 printf("write_time not setup correctly\n");
 164         }
 165
 166         return fnum;
 167 }
 168
 169
 170 /*
 171   sometimes we need a fairly complex directory to work with, so we can test
 172   all possible attributes.
 173 */
 174 int create_complex_dir(struct smbcli_state *cli, TALLOC_CTX *mem_ctx, const char *dname)
 175 {
 176         int fnum;
 177         union smb_setfileinfo setfile;
 178         union smb_fileinfo fileinfo;
 179         time_t t = (time(NULL) & ~1);
 180         NTSTATUS status;
 181
 182         smbcli_deltree(cli->tree, dname);
 183         fnum = smbcli_nt_create_full(cli->tree, dname, 0,
 184                                      SEC_RIGHTS_DIR_ALL,
 185                                      FILE_ATTRIBUTE_DIRECTORY,
 186                                      NTCREATEX_SHARE_ACCESS_READ|
 187                                      NTCREATEX_SHARE_ACCESS_WRITE,
 188                                      NTCREATEX_DISP_OPEN_IF,
 189                                      NTCREATEX_OPTIONS_DIRECTORY, 0);
 190         if (fnum == -1) return -1;
 191
 192         if (strchr(dname, ':') == NULL) {
 193                 /* setup some EAs */
 194                 setfile.generic.level = RAW_SFILEINFO_EA_SET;
 195                 setfile.generic.in.file.fnum = fnum;
 196                 setfile.ea_set.in.num_eas = 2;
 197                 setfile.ea_set.in.eas = talloc_array(mem_ctx, struct ea_struct, 2);
 198                 setfile.ea_set.in.eas[0].flags = 0;
 199                 setfile.ea_set.in.eas[0].name.s = "EAONE";
 200                 setfile.ea_set.in.eas[0].value = data_blob_talloc(mem_ctx, "VALUE1", 6);
 201                 setfile.ea_set.in.eas[1].flags = 0;
 202                 setfile.ea_set.in.eas[1].name.s = "SECONDEA";
 203                 setfile.ea_set.in.eas[1].value = data_blob_talloc(mem_ctx, "ValueTwo", 8);
 204                 status = smb_raw_setfileinfo(cli->tree, &setfile);
 205                 if (!NT_STATUS_IS_OK(status)) {
 206                         printf("Failed to setup EAs\n");
 207                 }
 208         }
 209
 210         /* make sure all the timestamps aren't the same, and are also
 211            in different DST zones*/
 212         setfile.generic.level = RAW_SFILEINFO_SETATTRE;
 213         setfile.generic.in.file.fnum = fnum;
 214
 215         setfile.setattre.in.create_time = t + 9*30*24*60*60;
 216         setfile.setattre.in.access_time = t + 6*30*24*60*60;
 217         setfile.setattre.in.write_time  = t + 3*30*24*60*60;
 218
 219         status = smb_raw_setfileinfo(cli->tree, &setfile);
 220         if (!NT_STATUS_IS_OK(status)) {
 221                 printf("Failed to setup file times - %s\n", nt_errstr(status));
 222         }
 223
 224         /* make sure all the timestamps aren't the same */
 225         fileinfo.generic.level = RAW_FILEINFO_GETATTRE;
 226         fileinfo.generic.in.file.fnum = fnum;
 227
 228         status = smb_raw_fileinfo(cli->tree, mem_ctx, &fileinfo);
 229         if (!NT_STATUS_IS_OK(status)) {
 230                 printf("Failed to query file times - %s\n", nt_errstr(status));
 231         }
 232
 233         if (setfile.setattre.in.create_time != fileinfo.getattre.out.create_time) {
 234                 printf("create_time not setup correctly\n");
 235         }
 236         if (setfile.setattre.in.access_time != fileinfo.getattre.out.access_time) {
 237                 printf("access_time not setup correctly\n");
 238         }
 239         if (setfile.setattre.in.write_time != fileinfo.getattre.out.write_time) {
 240                 printf("write_time not setup correctly\n");
 241         }
 242
 243         return fnum;
 244 }
 245
 246
 247
 248 /* return a pointer to a anonymous shared memory segment of size "size"
 249    which will persist across fork() but will disappear when all processes
 250    exit
 251
 252    The memory is not zeroed
 253
 254    This function uses system5 shared memory. It takes advantage of a property
 255    that the memory is not destroyed if it is attached when the id is removed
 256    */
 257 void *shm_setup(int size)
 258 {
 259         int shmid;
 260         void *ret;
 261
 262 #ifdef __QNXNTO__
 263         shmid = shm_open("private", O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
 264         if (shmid == -1) {
 265                 printf("can't get shared memory\n");
 266                 exit(1);
 267         }
 268         shm_unlink("private");
 269         if (ftruncate(shmid, size) == -1) {
 270                 printf("can't set shared memory size\n");
 271                 exit(1);
 272         }
 273         ret = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, shmid, 0);
 274         if (ret == MAP_FAILED) {
 275                 printf("can't map shared memory\n");
 276                 exit(1);
 277         }
 278 #else
 279         shmid = shmget(IPC_PRIVATE, size, SHM_R | SHM_W);
 280         if (shmid == -1) {
 281                 printf("can't get shared memory\n");
 282                 exit(1);
 283         }
 284         ret = (void *)shmat(shmid, 0, 0);
 285         if (!ret || ret == (void *)-1) {
 286                 printf("can't attach to shared memory\n");
 287                 return NULL;
 288         }
 289         /* the following releases the ipc, but note that this process
 290            and all its children will still have access to the memory, its
 291            just that the shmid is no longer valid for other shm calls. This
 292            means we don't leave behind lots of shm segments after we exit
 293
 294            See Stevens "advanced programming in unix env" for details
 295            */
 296         shmctl(shmid, IPC_RMID, 0);
 297 #endif
 298
 299         return ret;
 300 }
 301
 302
 303 /**
 304   check that a wire string matches the flags specified
 305   not 100% accurate, but close enough for testing
 306 */
 307 bool wire_bad_flags(struct smb_wire_string *str, int flags,
 308                     struct smbcli_transport *transport)
 309 {
 310         bool server_unicode;
 311         int len;
 312         if (!str || !str->s) return true;
 313         len = strlen(str->s);
 314         if (flags & STR_TERMINATE) len++;
 315
 316         server_unicode = (transport->negotiate.capabilities&CAP_UNICODE)?true:false;
 317         if (getenv("CLI_FORCE_ASCII") || !transport->options.unicode) {
 318                 server_unicode = false;
 319         }
 320
 321         if ((flags & STR_UNICODE) || server_unicode) {
 322                 len *= 2;
 323         } else if (flags & STR_TERMINATE_ASCII) {
 324                 len++;
 325         }
 326         if (str->private_length != len) {
 327                 printf("Expected wire_length %d but got %d for '%s'\n",
 328                        len, str->private_length, str->s);
 329                 return true;
 330         }
 331         return false;
 332 }
 333
 334 /*
 335   dump a all_info QFILEINFO structure
 336 */
 337 void dump_all_info(TALLOC_CTX *mem_ctx, union smb_fileinfo *finfo)
 338 {
 339         d_printf("\tcreate_time:    %s\n", nt_time_string(mem_ctx, finfo->all_info.out.create_time));
 340         d_printf("\taccess_time:    %s\n", nt_time_string(mem_ctx, finfo->all_info.out.access_time));
 341         d_printf("\twrite_time:     %s\n", nt_time_string(mem_ctx, finfo->all_info.out.write_time));
 342         d_printf("\tchange_time:    %s\n", nt_time_string(mem_ctx, finfo->all_info.out.change_time));
 343         d_printf("\tattrib:         0x%x\n", finfo->all_info.out.attrib);
 344         d_printf("\talloc_size:     %llu\n", (long long)finfo->all_info.out.alloc_size);
 345         d_printf("\tsize:           %llu\n", (long long)finfo->all_info.out.size);
 346         d_printf("\tnlink:          %u\n", finfo->all_info.out.nlink);
 347         d_printf("\tdelete_pending: %u\n", finfo->all_info.out.delete_pending);
 348         d_printf("\tdirectory:      %u\n", finfo->all_info.out.directory);
 349         d_printf("\tea_size:        %u\n", finfo->all_info.out.ea_size);
 350         d_printf("\tfname:          '%s'\n", finfo->all_info.out.fname.s);
 351 }
 352
 353 /*
 354   dump file infor by name
 355 */
 356 void torture_all_info(struct smbcli_tree *tree, const char *fname)
 357 {
 358         TALLOC_CTX *mem_ctx = talloc_named(tree, 0, "%s", fname);
 359         union smb_fileinfo finfo;
 360         NTSTATUS status;
 361
 362         finfo.generic.level = RAW_FILEINFO_ALL_INFO;
 363         finfo.generic.in.file.path = fname;
 364         status = smb_raw_pathinfo(tree, mem_ctx, &finfo);
 365         if (!NT_STATUS_IS_OK(status)) {
 366                 d_printf("%s - %s\n", fname, nt_errstr(status));
 367                 return;
 368         }
 369
 370         d_printf("%s:\n", fname);
 371         dump_all_info(mem_ctx, &finfo);
 372         talloc_free(mem_ctx);
 373 }
 374
 375
 376 /*
 377   set a attribute on a file
 378 */
 379 bool torture_set_file_attribute(struct smbcli_tree *tree, const char *fname, uint16_t attrib)
 380 {
 381         union smb_setfileinfo sfinfo;
 382         NTSTATUS status;
 383
 384         ZERO_STRUCT(sfinfo.basic_info.in);
 385         sfinfo.basic_info.level = RAW_SFILEINFO_BASIC_INFORMATION;
 386         sfinfo.basic_info.in.file.path = fname;
 387         sfinfo.basic_info.in.attrib = attrib;
 388         status = smb_raw_setpathinfo(tree, &sfinfo);
 389         return NT_STATUS_IS_OK(status);
 390 }
 391
 392
 393 /*
 394   set a file descriptor as sparse
 395 */
 396 NTSTATUS torture_set_sparse(struct smbcli_tree *tree, int fnum)
 397 {
 398         union smb_ioctl nt;
 399         NTSTATUS status;
 400         TALLOC_CTX *mem_ctx;
 401
 402         mem_ctx = talloc_named_const(tree, 0, "torture_set_sparse");
 403         if (!mem_ctx) {
 404                 return NT_STATUS_NO_MEMORY;
 405         }
 406
 407         nt.ntioctl.level = RAW_IOCTL_NTIOCTL;
 408         nt.ntioctl.in.function = FSCTL_SET_SPARSE;
 409         nt.ntioctl.in.file.fnum = fnum;
 410         nt.ntioctl.in.fsctl = true;
 411         nt.ntioctl.in.filter = 0;
 412         nt.ntioctl.in.max_data = 0;
 413         nt.ntioctl.in.blob = data_blob(NULL, 0);
 414
 415         status = smb_raw_ioctl(tree, mem_ctx, &nt);
 416
 417         talloc_free(mem_ctx);
 418
 419         return status;
 420 }
 421
 422 /*
 423   check that an EA has the right value
 424 */
 425 NTSTATUS torture_check_ea(struct smbcli_state *cli,
 426                           const char *fname, const char *eaname, const char *value)
 427 {
 428         union smb_fileinfo info;
 429         NTSTATUS status;
 430         struct ea_name ea;
 431         TALLOC_CTX *mem_ctx = talloc_new(cli);
 432
 433         info.ea_list.level = RAW_FILEINFO_EA_LIST;
 434         info.ea_list.in.file.path = fname;
 435         info.ea_list.in.num_names = 1;
 436         info.ea_list.in.ea_names = &ea;
 437
 438         ea.name.s = eaname;
 439
 440         status = smb_raw_pathinfo(cli->tree, mem_ctx, &info);
 441         if (!NT_STATUS_IS_OK(status)) {
 442                 talloc_free(mem_ctx);
 443                 return status;
 444         }
 445
 446         if (info.ea_list.out.num_eas != 1) {
 447                 printf("Expected 1 ea in ea_list\n");
 448                 talloc_free(mem_ctx);
 449                 return NT_STATUS_EA_CORRUPT_ERROR;
 450         }
 451
 452         if (strcasecmp_m(eaname, info.ea_list.out.eas[0].name.s) != 0) {
 453                 printf("Expected ea '%s' not '%s' in ea_list\n",
 454                        eaname, info.ea_list.out.eas[0].name.s);
 455                 talloc_free(mem_ctx);
 456                 return NT_STATUS_EA_CORRUPT_ERROR;
 457         }
 458
 459         if (value == NULL) {
 460                 if (info.ea_list.out.eas[0].value.length != 0) {
 461                         printf("Expected zero length ea for %s\n", eaname);
 462                         talloc_free(mem_ctx);
 463                         return NT_STATUS_EA_CORRUPT_ERROR;
 464                 }
 465                 talloc_free(mem_ctx);
 466                 return NT_STATUS_OK;
 467         }
 468
 469         if (strlen(value) == info.ea_list.out.eas[0].value.length &&
 470             memcmp(value, info.ea_list.out.eas[0].value.data,
 471                    info.ea_list.out.eas[0].value.length) == 0) {
 472                 talloc_free(mem_ctx);
 473                 return NT_STATUS_OK;
 474         }
 475
 476         printf("Expected value '%s' not '%*.*s' for ea %s\n",
 477                value,
 478                (int)info.ea_list.out.eas[0].value.length,
 479                (int)info.ea_list.out.eas[0].value.length,
 480                info.ea_list.out.eas[0].value.data,
 481                eaname);
 482
 483         talloc_free(mem_ctx);
 484
 485         return NT_STATUS_EA_CORRUPT_ERROR;
 486 }
 487
 488 _PUBLIC_ bool torture_open_connection_share(TALLOC_CTX *mem_ctx,
 489                                    struct smbcli_state **c,
 490                                    struct torture_context *tctx,
 491                                    const char *hostname,
 492                                    const char *sharename,
 493                                    struct tevent_context *ev)
 494 {
 495         NTSTATUS status;
 496
 497         struct smbcli_options options;
 498         struct smbcli_session_options session_options;
 499
 500         lp_smbcli_options(tctx->lp_ctx, &options);
 501         lp_smbcli_session_options(tctx->lp_ctx, &session_options);
 502
 503         options.use_oplocks = torture_setting_bool(tctx, "use_oplocks", true);
 504         options.use_level2_oplocks = torture_setting_bool(tctx, "use_level2_oplocks", true);
 505
 506         status = smbcli_full_connection(mem_ctx, c, hostname,
 507                                         lp_smb_ports(tctx->lp_ctx),
 508                                         sharename, NULL,
 509                                         lp_socket_options(tctx->lp_ctx),
 510                                         cmdline_credentials,
 511                                         lp_resolve_context(tctx->lp_ctx),
 512                                         ev, &options, &session_options,
 513                                         lp_iconv_convenience(tctx->lp_ctx),
 514                                         lp_gensec_settings(tctx, tctx->lp_ctx));
 515         if (!NT_STATUS_IS_OK(status)) {
 516                 printf("Failed to open connection - %s\n", nt_errstr(status));
 517                 return false;
 518         }
 519
 520         return true;
 521 }
 522
 523 _PUBLIC_ bool torture_get_conn_index(int conn_index,
 524                                      TALLOC_CTX *mem_ctx,
 525                                      struct torture_context *tctx,
 526                                      char **host, char **share)
 527 {
 528         char **unc_list = NULL;
 529         int num_unc_names = 0;
 530         const char *p;
 531
 532         (*host) = talloc_strdup(mem_ctx, torture_setting_string(tctx, "host", NULL));
 533         (*share) = talloc_strdup(mem_ctx, torture_setting_string(tctx, "share", NULL));
 534
 535         p = torture_setting_string(tctx, "unclist", NULL);
 536         if (!p) {
 537                 return true;
 538         }
 539
 540         unc_list = file_lines_load(p, &num_unc_names, 0, NULL);
 541         if (!unc_list || num_unc_names <= 0) {
 542                 DEBUG(0,("Failed to load unc names list from '%s'\n", p));
 543                 return false;
 544         }
 545
 546         if (!smbcli_parse_unc(unc_list[conn_index % num_unc_names],
 547                               mem_ctx, host, share)) {
 548                 DEBUG(0, ("Failed to parse UNC name %s\n",
 549                           unc_list[conn_index % num_unc_names]));
 550                 return false;
 551         }
 552
 553         talloc_free(unc_list);
 554         return true;
 555 }
 556
 557
 558
 559 _PUBLIC_ bool torture_open_connection_ev(struct smbcli_state **c,
 560                                          int conn_index,
 561                                          struct torture_context *tctx,
 562                                          struct tevent_context *ev)
 563 {
 564         char *host, *share;
 565         bool ret;
 566
 567         if (!torture_get_conn_index(conn_index, ev, tctx, &host, &share)) {
 568                 return false;
 569         }
 570
 571         ret = torture_open_connection_share(NULL, c, tctx, host, share, ev);
 572         talloc_free(host);
 573         talloc_free(share);
 574
 575         return ret;
 576 }
 577
 578 _PUBLIC_ bool torture_open_connection(struct smbcli_state **c, struct torture_context *tctx, int conn_index)
 579 {
 580         return torture_open_connection_ev(c, conn_index, tctx, tctx->ev);
 581 }
 582
 583
 584
 585 _PUBLIC_ bool torture_close_connection(struct smbcli_state *c)
 586 {
 587         bool ret = true;
 588         if (!c) return true;
 589         if (NT_STATUS_IS_ERR(smbcli_tdis(c))) {
 590                 printf("tdis failed (%s)\n", smbcli_errstr(c->tree));
 591                 ret = false;
 592         }
 593         talloc_free(c);
 594         return ret;
 595 }
 596
 597
 598 /* check if the server produced the expected error code */
 599 _PUBLIC_ bool check_error(const char *location, struct smbcli_state *c,
 600                  uint8_t eclass, uint32_t ecode, NTSTATUS nterr)
 601 {
 602         NTSTATUS status;
 603
 604         status = smbcli_nt_error(c->tree);
 605         if (NT_STATUS_IS_DOS(status)) {
 606                 int classnum, num;
 607                 classnum = NT_STATUS_DOS_CLASS(status);
 608                 num = NT_STATUS_DOS_CODE(status);
 609                 if (eclass != classnum || ecode != num) {
 610                         printf("unexpected error code %s\n", nt_errstr(status));
 611                         printf(" expected %s or %s (at %s)\n",
 612                                nt_errstr(NT_STATUS_DOS(eclass, ecode)),
 613                                nt_errstr(nterr), location);
 614                         return false;
 615                 }
 616         } else {
 617                 if (!NT_STATUS_EQUAL(nterr, status)) {
 618                         printf("unexpected error code %s\n", nt_errstr(status));
 619                         printf(" expected %s (at %s)\n", nt_errstr(nterr), location);
 620                         return false;
 621                 }
 622         }
 623
 624         return true;
 625 }
 626
 627 static struct smbcli_state *current_cli;
 628 static int procnum; /* records process count number when forking */
 629
 630 static void sigcont(int sig)
 631 {
 632 }
 633
 634 double torture_create_procs(struct torture_context *tctx,
 635                                                         bool (*fn)(struct torture_context *, struct smbcli_state *, int), bool *result)
 636 {
 637         int i, status;
 638         volatile pid_t *child_status;
 639         volatile bool *child_status_out;
 640         int synccount;
 641         int tries = 8;
 642         int torture_nprocs = torture_setting_int(tctx, "nprocs", 4);
 643         double start_time_limit = 10 + (torture_nprocs * 1.5);
 644         struct timeval tv;
 645
 646         *result = true;
 647
 648         synccount = 0;
 649
 650         signal(SIGCONT, sigcont);
 651
 652         child_status = (volatile pid_t *)shm_setup(sizeof(pid_t)*torture_nprocs);
 653         if (!child_status) {
 654                 printf("Failed to setup shared memory\n");
 655                 return -1;
 656         }
 657
 658         child_status_out = (volatile bool *)shm_setup(sizeof(bool)*torture_nprocs);
 659         if (!child_status_out) {
 660                 printf("Failed to setup result status shared memory\n");
 661                 return -1;
 662         }
 663
 664         for (i = 0; i < torture_nprocs; i++) {
 665                 child_status[i] = 0;
 666                 child_status_out[i] = true;
 667         }
 668
 669         tv = timeval_current();
 670
 671         for (i=0;i<torture_nprocs;i++) {
 672                 procnum = i;
 673                 if (fork() == 0) {
 674                         char *myname;
 675
 676                         pid_t mypid = getpid();
 677                         srandom(((int)mypid) ^ ((int)time(NULL)));
 678
 679                         if (asprintf(&myname, "CLIENT%d", i) == -1) {
 680                                 printf("asprintf failed\n");
 681                                 return -1;
 682                         }
 683                         lp_set_cmdline(tctx->lp_ctx, "netbios name", myname);
 684                         free(myname);
 685
 686
 687                         while (1) {
 688                                 if (torture_open_connection(&current_cli, tctx, i)) {
 689                                         break;
 690                                 }
 691                                 if (tries-- == 0) {
 692                                         printf("pid %d failed to start\n", (int)getpid());
 693                                         _exit(1);
 694                                 }
 695                                 msleep(100);
 696                         }
 697
 698                         child_status[i] = getpid();
 699
 700                         pause();
 701
 702                         if (child_status[i]) {
 703                                 printf("Child %d failed to start!\n", i);
 704                                 child_status_out[i] = 1;
 705                                 _exit(1);
 706                         }
 707
 708                         child_status_out[i] = fn(tctx, current_cli, i);
 709                         _exit(0);
 710                 }
 711         }
 712
 713         do {
 714                 synccount = 0;
 715                 for (i=0;i<torture_nprocs;i++) {
 716                         if (child_status[i]) synccount++;
 717                 }
 718                 if (synccount == torture_nprocs) break;
 719                 msleep(100);
 720         } while (timeval_elapsed(&tv) < start_time_limit);
 721
 722         if (synccount != torture_nprocs) {
 723                 printf("FAILED TO START %d CLIENTS (started %d)\n", torture_nprocs, synccount);
 724                 *result = false;
 725                 return timeval_elapsed(&tv);
 726         }
 727
 728         printf("Starting %d clients\n", torture_nprocs);
 729
 730         /* start the client load */
 731         tv = timeval_current();
 732         for (i=0;i<torture_nprocs;i++) {
 733                 child_status[i] = 0;
 734         }
 735
 736         printf("%d clients started\n", torture_nprocs);
 737
 738         kill(0, SIGCONT);
 739
 740         for (i=0;i<torture_nprocs;i++) {
 741                 int ret;
 742                 while ((ret=waitpid(0, &status, 0)) == -1 && errno == EINTR) /* noop */ ;
 743                 if (ret == -1 || WEXITSTATUS(status) != 0) {
 744                         *result = false;
 745                 }
 746         }
 747
 748         printf("\n");
 749
 750         for (i=0;i<torture_nprocs;i++) {
 751                 if (!child_status_out[i]) {
 752                         *result = false;
 753                 }
 754         }
 755         return timeval_elapsed(&tv);
 756 }
 757
 758 static bool wrap_smb_multi_test(struct torture_context *torture,
 759                                                                 struct torture_tcase *tcase,
 760                                                                 struct torture_test *test)
 761 {
 762         bool (*fn)(struct torture_context *, struct smbcli_state *, int ) = test->fn;
 763         bool result;
 764
 765         torture_create_procs(torture, fn, &result);
 766
 767         return result;
 768 }
 769
 770 _PUBLIC_ struct torture_test *torture_suite_add_smb_multi_test(
 771                                                                         struct torture_suite *suite,
 772                                                                         const char *name,
 773                                                                         bool (*run) (struct torture_context *,
 774                                                                                                  struct smbcli_state *,
 775                                                                                                 int i))
 776 {
 777         struct torture_test *test;
 778         struct torture_tcase *tcase;
 779
 780         tcase = torture_suite_add_tcase(suite, name);
 781
 782         test = talloc(tcase, struct torture_test);
 783
 784         test->name = talloc_strdup(test, name);
 785         test->description = NULL;
 786         test->run = wrap_smb_multi_test;
 787         test->fn = run;
 788         test->dangerous = false;
 789
 790         DLIST_ADD_END(tcase->tests, test, struct torture_test *);
 791
 792         return test;
 793
 794 }
 795
 796 static bool wrap_simple_2smb_test(struct torture_context *torture_ctx,
 797                                                                         struct torture_tcase *tcase,
 798                                                                         struct torture_test *test)
 799 {
 800         bool (*fn) (struct torture_context *, struct smbcli_state *,
 801                                 struct smbcli_state *);
 802         bool ret;
 803
 804         struct smbcli_state *cli1, *cli2;
 805
 806         if (!torture_open_connection(&cli1, torture_ctx, 0) ||
 807                 !torture_open_connection(&cli2, torture_ctx, 1))
 808                 return false;
 809
 810         fn = test->fn;
 811
 812         ret = fn(torture_ctx, cli1, cli2);
 813
 814         talloc_free(cli1);
 815         talloc_free(cli2);
 816
 817         return ret;
 818 }
 819
 820
 821
 822 _PUBLIC_ struct torture_test *torture_suite_add_2smb_test(
 823                                                                         struct torture_suite *suite,
 824                                                                         const char *name,
 825                                                                         bool (*run) (struct torture_context *,
 826                                                                                                 struct smbcli_state *,
 827                                                                                                 struct smbcli_state *))
 828 {
 829         struct torture_test *test;
 830         struct torture_tcase *tcase;
 831
 832         tcase = torture_suite_add_tcase(suite, name);
 833
 834         test = talloc(tcase, struct torture_test);
 835
 836         test->name = talloc_strdup(test, name);
 837         test->description = NULL;
 838         test->run = wrap_simple_2smb_test;
 839         test->fn = run;
 840         test->dangerous = false;
 841
 842         DLIST_ADD_END(tcase->tests, test, struct torture_test *);
 843
 844         return test;
 845
 846 }
 847
 848 static bool wrap_simple_1smb_test(struct torture_context *torture_ctx,
 849                                                                         struct torture_tcase *tcase,
 850                                                                         struct torture_test *test)
 851 {
 852         bool (*fn) (struct torture_context *, struct smbcli_state *);
 853         bool ret;
 854
 855         struct smbcli_state *cli1;
 856
 857         if (!torture_open_connection(&cli1, torture_ctx, 0))
 858                 return false;
 859
 860         fn = test->fn;
 861
 862         ret = fn(torture_ctx, cli1);
 863
 864         talloc_free(cli1);
 865
 866         return ret;
 867 }
 868
 869 _PUBLIC_ struct torture_test *torture_suite_add_1smb_test(
 870                                 struct torture_suite *suite,
 871                                 const char *name,
 872                                 bool (*run) (struct torture_context *, struct smbcli_state *))
 873 {
 874         struct torture_test *test;
 875         struct torture_tcase *tcase;
 876
 877         tcase = torture_suite_add_tcase(suite, name);
 878
 879         test = talloc(tcase, struct torture_test);
 880
 881         test->name = talloc_strdup(test, name);
 882         test->description = NULL;
 883         test->run = wrap_simple_1smb_test;
 884         test->fn = run;
 885         test->dangerous = false;
 886
 887         DLIST_ADD_END(tcase->tests, test, struct torture_test *);
 888
 889         return test;
 890 }
 891
 892
 893 NTSTATUS torture_second_tcon(TALLOC_CTX *mem_ctx,
 894                              struct smbcli_session *session,
 895                              const char *sharename,
 896                              struct smbcli_tree **res)
 897 {
 898         union smb_tcon tcon;
 899         struct smbcli_tree *result;
 900         TALLOC_CTX *tmp_ctx;
 901         NTSTATUS status;
 902
 903         if ((tmp_ctx = talloc_new(mem_ctx)) == NULL) {
 904                 return NT_STATUS_NO_MEMORY;
 905         }
 906
 907         result = smbcli_tree_init(session, tmp_ctx, false);
 908         if (result == NULL) {
 909                 talloc_free(tmp_ctx);
 910                 return NT_STATUS_NO_MEMORY;
 911         }
 912
 913         tcon.generic.level = RAW_TCON_TCONX;
 914         tcon.tconx.in.flags = 0;
 915
 916         /* Ignore share mode security here */
 917         tcon.tconx.in.password = data_blob(NULL, 0);
 918         tcon.tconx.in.path = sharename;
 919         tcon.tconx.in.device = "?????";
 920
 921         status = smb_raw_tcon(result, tmp_ctx, &tcon);
 922         if (!NT_STATUS_IS_OK(status)) {
 923                 talloc_free(tmp_ctx);
 924                 return status;
 925         }
 926
 927         result->tid = tcon.tconx.out.tid;
 928         *res = talloc_steal(mem_ctx, result);
 929         talloc_free(tmp_ctx);
 930         return NT_STATUS_OK;
 931 }
 932
 933 /*
 934    a wrapper around smblsa_sid_check_privilege, that tries to take
 935    account of the fact that the lsa privileges calls don't expand
 936    group memberships, using an explicit check for administrator. There
 937    must be a better way ...
 938  */
 939 NTSTATUS torture_check_privilege(struct smbcli_state *cli,
 940                                  const char *sid_str,
 941                                  const char *privilege)
 942 {
 943         struct dom_sid *sid;
 944         TALLOC_CTX *tmp_ctx = talloc_new(cli);
 945         uint32_t rid;
 946         NTSTATUS status;
 947
 948         sid = dom_sid_parse_talloc(tmp_ctx, sid_str);
 949         if (sid == NULL) {
 950                 talloc_free(tmp_ctx);
 951                 return NT_STATUS_INVALID_SID;
 952         }
 953
 954         status = dom_sid_split_rid(tmp_ctx, sid, NULL, &rid);
 955         NT_STATUS_NOT_OK_RETURN_AND_FREE(status, tmp_ctx);
 956
 957         if (rid == DOMAIN_RID_ADMINISTRATOR) {
 958                 /* assume the administrator has them all */
 959                 return NT_STATUS_OK;
 960         }
 961
 962         talloc_free(tmp_ctx);
 963
 964         return smblsa_sid_check_privilege(cli, sid_str, privilege);
 965 }