source3/torture/rpctorture.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    SMB client
   4    Copyright (C) Andrew Tridgell 1994-1998
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18 */
  19
  20 #include "includes.h"
  21
  22 #ifndef REGISTER
  23 #define REGISTER 0
  24 #endif
  25
  26 extern pstring global_myname;
  27
  28 extern file_info def_finfo;
  29
  30 #define CNV_LANG(s) dos2unix_format(s,False)
  31 #define CNV_INPUT(s) unix2dos_format(s,True)
  32
  33 static struct cli_state smbcli;
  34 struct cli_state *smb_cli = &smbcli;
  35
  36 FILE *out_hnd;
  37
  38 static pstring password; /* local copy only, if one is entered */
  39
  40 /****************************************************************************
  41 initialise smb client structure
  42 ****************************************************************************/
  43 void rpcclient_init(void)
  44 {
  45         memset((char *)smb_cli, '\0', sizeof(smb_cli));
  46         cli_initialise(smb_cli);
  47         smb_cli->capabilities |= CAP_NT_SMBS;
  48 }
  49
  50 /****************************************************************************
  51 make smb client connection
  52 ****************************************************************************/
  53 static bool rpcclient_connect(struct client_info *info)
  54 {
  55         struct nmb_name calling;
  56         struct nmb_name called;
  57
  58         make_nmb_name(&called , dns_to_netbios_name(info->dest_host ), info->name_type);
  59         make_nmb_name(&calling, dns_to_netbios_name(info->myhostname), 0x0);
  60
  61         if (!cli_establish_connection(smb_cli,
  62                                   info->dest_host, &info->dest_ip,
  63                                   &calling, &called,
  64                                   info->share, info->svc_type,
  65                                   False, True))
  66         {
  67                 DEBUG(0,("rpcclient_connect: connection failed\n"));
  68                 cli_shutdown(smb_cli);
  69                 return False;
  70         }
  71
  72         return True;
  73 }
  74
  75 /****************************************************************************
  76 stop the smb connection(s?)
  77 ****************************************************************************/
  78 static void rpcclient_stop(void)
  79 {
  80         cli_shutdown(smb_cli);
  81 }
  82
  83 /****************************************************************************
  84   log in as an nt user, log out again.
  85 ****************************************************************************/
  86 void run_enums_test(int num_ops, struct client_info *cli_info, struct cli_state *cli)
  87 {
  88         pstring cmd;
  89         int i;
  90
  91         /* establish connections.  nothing to stop these being re-established. */
  92         rpcclient_connect(cli_info);
  93
  94         DEBUG(5,("rpcclient_connect: cli->fd:%d\n", cli->fd));
  95         if (cli->fd <= 0)
  96         {
  97                 fprintf(out_hnd, "warning: connection could not be established to %s<%02x>\n",
  98                                  cli_info->dest_host, cli_info->name_type);
  99                 return;
 100         }
 101
 102         for (i = 0; i < num_ops; i++)
 103         {
 104                 set_first_token("");
 105                 cmd_srv_enum_sess(cli_info);
 106                 set_first_token("");
 107                 cmd_srv_enum_shares(cli_info);
 108                 set_first_token("");
 109                 cmd_srv_enum_files(cli_info);
 110
 111                 if (password[0] != 0)
 112                 {
 113                         slprintf(cmd, sizeof(cmd)-1, "1");
 114                         set_first_token(cmd);
 115                 }
 116                 else
 117                 {
 118                         set_first_token("");
 119                 }
 120                 cmd_srv_enum_conn(cli_info);
 121         }
 122
 123         rpcclient_stop();
 124
 125 }
 126
 127 /****************************************************************************
 128   log in as an nt user, log out again.
 129 ****************************************************************************/
 130 void run_ntlogin_test(int num_ops, struct client_info *cli_info, struct cli_state *cli)
 131 {
 132         pstring cmd;
 133         int i;
 134
 135         /* establish connections.  nothing to stop these being re-established. */
 136         rpcclient_connect(cli_info);
 137
 138         DEBUG(5,("rpcclient_connect: cli->fd:%d\n", cli->fd));
 139         if (cli->fd <= 0)
 140         {
 141                 fprintf(out_hnd, "warning: connection could not be established to %s<%02x>\n",
 142                                  cli_info->dest_host, cli_info->name_type);
 143                 return;
 144         }
 145
 146         for (i = 0; i < num_ops; i++)
 147         {
 148                 slprintf(cmd, sizeof(cmd)-1, "%s %s", cli->user_name, password);
 149                 set_first_token(cmd);
 150
 151                 cmd_netlogon_login_test(cli_info);
 152         }
 153
 154         rpcclient_stop();
 155
 156 }
 157
 158 /****************************************************************************
 159   runs n simultaneous functions.
 160 ****************************************************************************/
 161 static void create_procs(int nprocs, int numops,
 162                 struct client_info *cli_info, struct cli_state *cli,
 163                 void (*fn)(int, struct client_info *, struct cli_state *))
 164 {
 165         int i, status;
 166
 167         for (i=0;i<nprocs;i++)
 168         {
 169                 if (fork() == 0)
 170                 {
 171                         pid_t mypid = getpid();
 172                         sys_srandom(mypid ^ time(NULL));
 173                         fn(numops, cli_info, cli);
 174                         fflush(out_hnd);
 175                         _exit(0);
 176                 }
 177         }
 178
 179         for (i=0;i<nprocs;i++)
 180         {
 181                 waitpid(0, &status, 0);
 182         }
 183 }
 184 /****************************************************************************
 185 usage on the program - OUT OF DATE!
 186 ****************************************************************************/
 187 static void usage(char *pname)
 188 {
 189   fprintf(out_hnd, "Usage: %s service <password> [-d debuglevel] [-l log] ",
 190            pname);
 191
 192   fprintf(out_hnd, "\nVersion %s\n",SAMBA_VERSION_STRING);
 193   fprintf(out_hnd, "\t-d debuglevel         set the debuglevel\n");
 194   fprintf(out_hnd, "\t-l log basename.      Basename for log/debug files\n");
 195   fprintf(out_hnd, "\t-n netbios name.      Use this name as my netbios name\n");
 196   fprintf(out_hnd, "\t-m max protocol       set the max protocol level\n");
 197   fprintf(out_hnd, "\t-I dest IP            use this IP to connect to\n");
 198   fprintf(out_hnd, "\t-E                    write messages to stderr instead of stdout\n");
 199   fprintf(out_hnd, "\t-U username           set the network username\n");
 200   fprintf(out_hnd, "\t-W workgroup          set the workgroup name\n");
 201   fprintf(out_hnd, "\t-t terminal code      terminal i/o code {sjis|euc|jis7|jis8|junet|hex}\n");
 202   fprintf(out_hnd, "\n");
 203 }
 204
 205 enum client_action
 206 {
 207         CLIENT_NONE,
 208         CLIENT_IPC,
 209         CLIENT_SVC
 210 };
 211
 212 /****************************************************************************
 213   main program
 214 ****************************************************************************/
 215  int main(int argc,char *argv[])
 216 {
 217         char *pname = argv[0];
 218         int opt;
 219         extern char *optarg;
 220         extern int optind;
 221         pstring term_code;
 222         bool got_pass = False;
 223         char *cmd_str="";
 224         enum client_action cli_action = CLIENT_NONE;
 225         int nprocs = 1;
 226         int numops = 100;
 227         pstring logfile;
 228         TALLOC_CTX *frame = talloc_stackframe();
 229
 230         struct client_info cli_info;
 231
 232         out_hnd = stdout;
 233
 234         rpcclient_init();
 235
 236 #ifdef KANJI
 237         pstrcpy(term_code, KANJI);
 238 #else /* KANJI */
 239         *term_code = 0;
 240 #endif /* KANJI */
 241
 242         if (!lp_load(dyn_CONFIGFILE,True, False, False, True))
 243         {
 244                 fprintf(stderr, "Can't load %s - run testparm to debug it\n", dyn_CONFIGFILE);
 245         }
 246
 247         DEBUGLEVEL = 0;
 248
 249         cli_info.put_total_size = 0;
 250         cli_info.put_total_time_ms = 0;
 251         cli_info.get_total_size = 0;
 252         cli_info.get_total_time_ms = 0;
 253
 254         cli_info.dir_total = 0;
 255         cli_info.newer_than = 0;
 256         cli_info.archive_level = 0;
 257         cli_info.print_mode = 1;
 258
 259         cli_info.translation = False;
 260         cli_info.recurse_dir = False;
 261         cli_info.lowercase = False;
 262         cli_info.prompt = True;
 263         cli_info.abort_mget = True;
 264
 265         cli_info.dest_ip.s_addr = 0;
 266         cli_info.name_type = 0x20;
 267
 268         pstrcpy(cli_info.cur_dir , "\\");
 269         pstrcpy(cli_info.file_sel, "");
 270         pstrcpy(cli_info.base_dir, "");
 271         pstrcpy(smb_cli->domain, "");
 272         pstrcpy(smb_cli->user_name, "");
 273         pstrcpy(cli_info.myhostname, "");
 274         pstrcpy(cli_info.dest_host, "");
 275
 276         pstrcpy(cli_info.svc_type, "A:");
 277         pstrcpy(cli_info.share, "");
 278         pstrcpy(cli_info.service, "");
 279
 280         ZERO_STRUCT(cli_info.dom.level3_sid);
 281         pstrcpy(cli_info.dom.level3_dom, "");
 282         ZERO_STRUCT(cli_info.dom.level5_sid);
 283         pstrcpy(cli_info.dom.level5_dom, "");
 284
 285         {
 286                 int i;
 287                 for (i=0; i<PI_MAX_PIPES; i++)
 288                         smb_cli->pipes[i].fnum   = 0xffff;
 289         }
 290
 291         setup_logging(pname, True);
 292
 293         global_myname = get_myname(global_myname);
 294         if (!global_myname) {
 295                 fprintf(stderr, "Failed to get my hostname.\n");
 296         }
 297
 298         password[0] = 0;
 299
 300         if (argc < 2)
 301         {
 302                 usage(pname);
 303                 exit(1);
 304         }
 305
 306         if (*argv[1] != '-')
 307         {
 308                 pstrcpy(cli_info.service, argv[1]);
 309                 /* Convert any '/' characters in the service name to '\' characters */
 310                 string_replace( cli_info.service, '/','\\');
 311                 argc--;
 312                 argv++;
 313
 314                 DEBUG(1,("service: %s\n", cli_info.service));
 315
 316                 if (count_chars(cli_info.service,'\\') < 3)
 317                 {
 318                         usage(pname);
 319                         printf("\n%s: Not enough '\\' characters in service\n", cli_info.service);
 320                         exit(1);
 321                 }
 322
 323                 /*
 324                 if (count_chars(cli_info.service,'\\') > 3)
 325                 {
 326                         usage(pname);
 327                         printf("\n%s: Too many '\\' characters in service\n", cli_info.service);
 328                         exit(1);
 329                 }
 330                 */
 331
 332                 if (argc > 1 && (*argv[1] != '-'))
 333                 {
 334                         got_pass = True;
 335                         pstrcpy(password,argv[1]);
 336                         memset(argv[1],'X',strlen(argv[1]));
 337                         argc--;
 338                         argv++;
 339                 }
 340
 341                 cli_action = CLIENT_SVC;
 342         }
 343
 344         while ((opt = getopt(argc, argv,"s:O:M:S:i:N:o:n:d:l:hI:EB:U:L:t:m:W:T:D:c:")) != EOF)
 345         {
 346                 switch (opt)
 347                 {
 348                         case 'm':
 349                         {
 350                                 /* FIXME ... max_protocol seems to be funny here */
 351
 352                                 int max_protocol = 0;
 353                                 max_protocol = interpret_protocol(optarg,max_protocol);
 354                                 fprintf(stderr, "max protocol not currently supported\n");
 355                                 break;
 356                         }
 357
 358                         case 'O':
 359                         {
 360                                 lp_do_parameter(-1, "socket options", optarg);
 361                                 break;
 362                         }
 363
 364                         case 'S':
 365                         {
 366                                 pstrcpy(cli_info.dest_host,optarg);
 367                                 strupper_m(cli_info.dest_host);
 368                                 cli_action = CLIENT_IPC;
 369                                 break;
 370                         }
 371
 372                         case 'i':
 373                         {
 374                                 pstrcpy(scope, optarg);
 375                                 break;
 376                         }
 377
 378                         case 'U':
 379                         {
 380                                 char *lp;
 381                                 pstrcpy(smb_cli->user_name,optarg);
 382                                 if ((lp=strchr_m(smb_cli->user_name,'%')))
 383                                 {
 384                                         *lp = 0;
 385                                         pstrcpy(password,lp+1);
 386                                         got_pass = True;
 387                                         memset(strchr_m(optarg,'%')+1,'X',strlen(password));
 388                                 }
 389                                 break;
 390                         }
 391
 392                         case 'W':
 393                         {
 394                                 pstrcpy(smb_cli->domain,optarg);
 395                                 break;
 396                         }
 397
 398                         case 'E':
 399                         {
 400                                 dbf = x_stderr;
 401                                 break;
 402                         }
 403
 404                         case 'I':
 405                         {
 406                                 (void)interpret_addr2(&cli_info.dest_ip, optarg);
 407                                 if (is_zero_ip(cli_info.dest_ip))
 408                                 {
 409                                         exit(1);
 410                                 }
 411                                 break;
 412                         }
 413
 414                         case 'N':
 415                         {
 416                                 nprocs = atoi(optarg);
 417                                 break;
 418                         }
 419
 420                         case 'o':
 421                         {
 422                                 numops = atoi(optarg);
 423                                 break;
 424                         }
 425
 426                         case 'n':
 427                         {
 428                                 fstrcpy(global_myname, optarg);
 429                                 break;
 430                         }
 431
 432                         case 'd':
 433                         {
 434                                 if (*optarg == 'A')
 435                                         DEBUGLEVEL = 10000;
 436                                 else
 437                                         DEBUGLEVEL = atoi(optarg);
 438                                 break;
 439                         }
 440
 441                         case 'l':
 442                         {
 443                                 slprintf(logfile, sizeof(logfile)-1,
 444                                          "%s.client",optarg);
 445                                 lp_set_logfile(logfile);
 446                                 break;
 447                         }
 448
 449                         case 'c':
 450                         {
 451                                 cmd_str = optarg;
 452                                 got_pass = True;
 453                                 break;
 454                         }
 455
 456                         case 'h':
 457                         {
 458                                 usage(pname);
 459                                 exit(0);
 460                                 break;
 461                         }
 462
 463                         case 's':
 464                         {
 465                                 pstrcpy(dyn_CONFIGFILE, optarg);
 466                                 break;
 467                         }
 468
 469                         case 't':
 470                         {
 471                                 pstrcpy(term_code, optarg);
 472                                 break;
 473                         }
 474
 475                         default:
 476                         {
 477                                 usage(pname);
 478                                 exit(1);
 479                                 break;
 480                         }
 481                 }
 482         }
 483
 484         if (cli_action == CLIENT_NONE)
 485         {
 486                 usage(pname);
 487                 exit(1);
 488         }
 489
 490         strupper_m(global_myname);
 491         fstrcpy(cli_info.myhostname, global_myname);
 492
 493         DEBUG(3,("%s client started (version %s)\n",current_timestring(False),SAMBA_VERSION_STRING));
 494
 495         if (*smb_cli->domain == 0)
 496         {
 497                 pstrcpy(smb_cli->domain,lp_workgroup());
 498         }
 499         strupper_m(smb_cli->domain);
 500
 501         load_interfaces();
 502
 503         if (cli_action == CLIENT_IPC)
 504         {
 505                 pstrcpy(cli_info.share, "IPC$");
 506                 pstrcpy(cli_info.svc_type, "IPC");
 507         }
 508
 509         fstrcpy(cli_info.mach_acct, cli_info.myhostname);
 510         strupper_m(cli_info.mach_acct);
 511         fstrcat(cli_info.mach_acct, "$");
 512
 513         /* set the password cache info */
 514         if (got_pass)
 515         {
 516                 if (password[0] == 0)
 517                 {
 518                         pwd_set_nullpwd(&(smb_cli->pwd));
 519                 }
 520                 else
 521                 {
 522                         pwd_make_lm_nt_16(&(smb_cli->pwd), password); /* generate 16 byte hashes */
 523                 }
 524         }
 525         else
 526         {
 527                 char *pwd = getpass("Enter Password:");
 528                 safe_strcpy(password, pwd, sizeof(password));
 529                 pwd_make_lm_nt_16(&(smb_cli->pwd), password); /* generate 16 byte hashes */
 530         }
 531
 532         create_procs(nprocs, numops, &cli_info, smb_cli, run_enums_test);
 533
 534         if (password[0] != 0)
 535         {
 536                 create_procs(nprocs, numops, &cli_info, smb_cli, run_ntlogin_test);
 537         }
 538
 539         fflush(out_hnd);
 540
 541         return(0);
 542 }