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