source/torture/basic/aliases.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    SMB trans2 alias scanner
   4    Copyright (C) Andrew Tridgell 2003
   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 2 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, write to the Free Software
  18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19 */
  20
  21 #include "includes.h"
  22
  23 int create_complex_file(struct smbcli_state *cli, TALLOC_CTX *mem_ctx, const char *fname);
  24
  25 struct trans2_blobs {
  26         struct trans2_blobs *next, *prev;
  27         uint16_t level;
  28         DATA_BLOB params, data;
  29 };
  30
  31 /* look for aliases for a query */
  32 static void gen_aliases(struct smbcli_state *cli, struct smb_trans2 *t2, int level_offset)
  33 {
  34         TALLOC_CTX *mem_ctx;
  35         uint16_t level;
  36         struct trans2_blobs *alias_blobs = NULL;
  37         struct trans2_blobs *t2b, *t2b2;
  38         int count=0, alias_count=0;
  39
  40         mem_ctx = talloc_init("aliases");
  41
  42         for (level=0;level<2000;level++) {
  43                 NTSTATUS status;
  44
  45                 SSVAL(t2->in.params.data, level_offset, level);
  46
  47                 status = smb_raw_trans2(cli->tree, mem_ctx, t2);
  48                 if (!NT_STATUS_IS_OK(status)) continue;
  49
  50                 t2b = talloc(mem_ctx, sizeof(*t2b));
  51                 t2b->level = level;
  52                 t2b->params = t2->out.params;
  53                 t2b->data = t2->out.data;
  54                 DLIST_ADD(alias_blobs, t2b);
  55                 d_printf("\tFound level %4u (0x%03x) of size %3d (0x%02x)\n",
  56                          level, level,
  57                          t2b->data.length, t2b->data.length);
  58                 count++;
  59         }
  60
  61         d_printf("Found %d levels with success status\n", count);
  62
  63         for (t2b=alias_blobs; t2b; t2b=t2b->next) {
  64                 for (t2b2=alias_blobs; t2b2; t2b2=t2b2->next) {
  65                         if (t2b->level >= t2b2->level) continue;
  66                         if (data_blob_equal(&t2b->params, &t2b2->params) &&
  67                             data_blob_equal(&t2b->data, &t2b2->data)) {
  68                                 printf("\tLevel %u (0x%x) and level %u (0x%x) are possible aliases\n",
  69                                        t2b->level, t2b->level, t2b2->level, t2b2->level);
  70                                 alias_count++;
  71                         }
  72                 }
  73         }
  74
  75         d_printf("Found %d aliased levels\n", alias_count);
  76
  77         talloc_destroy(mem_ctx);
  78 }
  79
  80 /* look for qfsinfo aliases */
  81 static void qfsinfo_aliases(struct smbcli_state *cli)
  82 {
  83         struct smb_trans2 t2;
  84         uint16_t setup = TRANSACT2_QFSINFO;
  85
  86         d_printf("\nChecking for QFSINFO aliases\n");
  87
  88         t2.in.max_param = 0;
  89         t2.in.max_data = 0x8000;
  90         t2.in.max_setup = 0;
  91         t2.in.flags = 0;
  92         t2.in.timeout = 0;
  93         t2.in.setup_count = 1;
  94         t2.in.setup = &setup;
  95         t2.in.params = data_blob(NULL, 2);
  96         t2.in.data = data_blob(NULL, 0);
  97
  98         gen_aliases(cli, &t2, 0);
  99 }
 100
 101 /* look for qfileinfo aliases */
 102 static void qfileinfo_aliases(struct smbcli_state *cli)
 103 {
 104         struct smb_trans2 t2;
 105         uint16_t setup = TRANSACT2_QFILEINFO;
 106         const char *fname = "\\qfileinfo_aliases.txt";
 107         int fnum;
 108
 109         d_printf("\nChecking for QFILEINFO aliases\n");
 110
 111         t2.in.max_param = 2;
 112         t2.in.max_data = 0x8000;
 113         t2.in.max_setup = 0;
 114         t2.in.flags = 0;
 115         t2.in.timeout = 0;
 116         t2.in.setup_count = 1;
 117         t2.in.setup = &setup;
 118         t2.in.params = data_blob(NULL, 4);
 119         t2.in.data = data_blob(NULL, 0);
 120
 121         smbcli_unlink(cli->tree, fname);
 122         fnum = create_complex_file(cli, cli, fname);
 123         if (fnum == -1) {
 124                 printf("ERROR: open of %s failed (%s)\n", fname, smbcli_errstr(cli->tree));
 125         }
 126
 127         smbcli_write(cli->tree, fnum, 0, (char *)&t2, 0, sizeof(t2));
 128
 129         SSVAL(t2.in.params.data, 0, fnum);
 130
 131         gen_aliases(cli, &t2, 2);
 132
 133         smbcli_close(cli->tree, fnum);
 134         smbcli_unlink(cli->tree, fname);
 135 }
 136
 137
 138 /* look for qpathinfo aliases */
 139 static void qpathinfo_aliases(struct smbcli_state *cli)
 140 {
 141         struct smb_trans2 t2;
 142         uint16_t setup = TRANSACT2_QPATHINFO;
 143         const char *fname = "\\qpathinfo_aliases.txt";
 144         int fnum;
 145         TALLOC_CTX *mem_ctx;
 146
 147         mem_ctx = talloc_init("qpathinfo");
 148
 149         d_printf("\nChecking for QPATHINFO aliases\n");
 150
 151         t2.in.max_param = 2;
 152         t2.in.max_data = 0x8000;
 153         t2.in.max_setup = 0;
 154         t2.in.flags = 0;
 155         t2.in.timeout = 0;
 156         t2.in.setup_count = 1;
 157         t2.in.setup = &setup;
 158         t2.in.params = data_blob_talloc(mem_ctx, NULL, 6);
 159         t2.in.data = data_blob(NULL, 0);
 160
 161         smbcli_unlink(cli->tree, fname);
 162         fnum = create_complex_file(cli, cli, fname);
 163         if (fnum == -1) {
 164                 printf("ERROR: open of %s failed (%s)\n", fname, smbcli_errstr(cli->tree));
 165         }
 166
 167         smbcli_write(cli->tree, fnum, 0, (char *)&t2, 0, sizeof(t2));
 168         smbcli_close(cli->tree, fnum);
 169
 170         SIVAL(t2.in.params.data, 2, 0);
 171
 172         smbcli_blob_append_string(cli->session, mem_ctx, &t2.in.params,
 173                                fname, STR_TERMINATE);
 174
 175         gen_aliases(cli, &t2, 0);
 176
 177         smbcli_unlink(cli->tree, fname);
 178         talloc_destroy(mem_ctx);
 179 }
 180
 181
 182 /* look for trans2 findfirst aliases */
 183 static void findfirst_aliases(struct smbcli_state *cli)
 184 {
 185         struct smb_trans2 t2;
 186         uint16_t setup = TRANSACT2_FINDFIRST;
 187         const char *fname = "\\findfirst_aliases.txt";
 188         int fnum;
 189         TALLOC_CTX *mem_ctx;
 190
 191         mem_ctx = talloc_init("findfirst");
 192
 193         d_printf("\nChecking for FINDFIRST aliases\n");
 194
 195         t2.in.max_param = 16;
 196         t2.in.max_data = 0x8000;
 197         t2.in.max_setup = 0;
 198         t2.in.flags = 0;
 199         t2.in.timeout = 0;
 200         t2.in.setup_count = 1;
 201         t2.in.setup = &setup;
 202         t2.in.params = data_blob_talloc(mem_ctx, NULL, 12);
 203         t2.in.data = data_blob(NULL, 0);
 204
 205         smbcli_unlink(cli->tree, fname);
 206         fnum = create_complex_file(cli, cli, fname);
 207         if (fnum == -1) {
 208                 printf("ERROR: open of %s failed (%s)\n", fname, smbcli_errstr(cli->tree));
 209         }
 210
 211         smbcli_write(cli->tree, fnum, 0, (char *)&t2, 0, sizeof(t2));
 212         smbcli_close(cli->tree, fnum);
 213
 214         SSVAL(t2.in.params.data, 0, 0);
 215         SSVAL(t2.in.params.data, 2, 1);
 216         SSVAL(t2.in.params.data, 4, FLAG_TRANS2_FIND_CLOSE);
 217         SSVAL(t2.in.params.data, 6, 0);
 218         SIVAL(t2.in.params.data, 8, 0);
 219
 220         smbcli_blob_append_string(cli->session, mem_ctx, &t2.in.params,
 221                                fname, STR_TERMINATE);
 222
 223         gen_aliases(cli, &t2, 6);
 224
 225         smbcli_unlink(cli->tree, fname);
 226         talloc_destroy(mem_ctx);
 227 }
 228
 229
 230
 231 /* look for aliases for a set function */
 232 static void gen_set_aliases(struct smbcli_state *cli, struct smb_trans2 *t2, int level_offset)
 233 {
 234         TALLOC_CTX *mem_ctx;
 235         uint16_t level;
 236         struct trans2_blobs *alias_blobs = NULL;
 237         struct trans2_blobs *t2b;
 238         int count=0, dsize;
 239
 240         mem_ctx = talloc_init("aliases");
 241
 242         for (level=1;level<1100;level++) {
 243                 NTSTATUS status, status1;
 244                 SSVAL(t2->in.params.data, level_offset, level);
 245
 246                 status1 = NT_STATUS_OK;
 247
 248                 for (dsize=2; dsize<1024; dsize += 2) {
 249                         data_blob_free(&t2->in.data);
 250                         t2->in.data = data_blob(NULL, dsize);
 251                         data_blob_clear(&t2->in.data);
 252                         status = smb_raw_trans2(cli->tree, mem_ctx, t2);
 253                         /* some error codes mean that this whole level doesn't exist */
 254                         if (NT_STATUS_EQUAL(NT_STATUS_INVALID_LEVEL, status) ||
 255                             NT_STATUS_EQUAL(NT_STATUS_INVALID_INFO_CLASS, status) ||
 256                             NT_STATUS_EQUAL(NT_STATUS_NOT_SUPPORTED, status)) {
 257                                 break;
 258                         }
 259                         if (NT_STATUS_IS_OK(status)) break;
 260
 261                         /* invalid parameter means that the level exists at this
 262                            size, but the contents are wrong (not surprising with
 263                            all zeros!) */
 264                         if (NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)) break;
 265
 266                         /* this is the usual code for 'wrong size' */
 267                         if (NT_STATUS_EQUAL(status, NT_STATUS_INFO_LENGTH_MISMATCH)) {
 268                                 continue;
 269                         }
 270
 271                         if (!NT_STATUS_EQUAL(status, status1)) {
 272                                 printf("level=%d size=%d %s\n", level, dsize, nt_errstr(status));
 273                         }
 274                         status1 = status;
 275                 }
 276
 277                 if (!NT_STATUS_IS_OK(status) &&
 278                     !NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)) continue;
 279
 280                 t2b = talloc(mem_ctx, sizeof(*t2b));
 281                 t2b->level = level;
 282                 t2b->params = t2->out.params;
 283                 t2b->data = t2->out.data;
 284                 DLIST_ADD(alias_blobs, t2b);
 285                 d_printf("\tFound level %4u (0x%03x) of size %3d (0x%02x)\n",
 286                          level, level,
 287                          t2->in.data.length, t2->in.data.length);
 288                 count++;
 289         }
 290
 291         d_printf("Found %d valid levels\n", count);
 292         talloc_destroy(mem_ctx);
 293 }
 294
 295
 296
 297 /* look for setfileinfo aliases */
 298 static void setfileinfo_aliases(struct smbcli_state *cli)
 299 {
 300         struct smb_trans2 t2;
 301         uint16_t setup = TRANSACT2_SETFILEINFO;
 302         const char *fname = "\\setfileinfo_aliases.txt";
 303         int fnum;
 304
 305         d_printf("\nChecking for SETFILEINFO aliases\n");
 306
 307         t2.in.max_param = 2;
 308         t2.in.max_data = 0;
 309         t2.in.max_setup = 0;
 310         t2.in.flags = 0;
 311         t2.in.timeout = 0;
 312         t2.in.setup_count = 1;
 313         t2.in.setup = &setup;
 314         t2.in.params = data_blob(NULL, 6);
 315         t2.in.data = data_blob(NULL, 0);
 316
 317         smbcli_unlink(cli->tree, fname);
 318         fnum = create_complex_file(cli, cli, fname);
 319         if (fnum == -1) {
 320                 printf("ERROR: open of %s failed (%s)\n", fname, smbcli_errstr(cli->tree));
 321         }
 322
 323         smbcli_write(cli->tree, fnum, 0, (char *)&t2, 0, sizeof(t2));
 324
 325         SSVAL(t2.in.params.data, 0, fnum);
 326         SSVAL(t2.in.params.data, 4, 0);
 327
 328         gen_set_aliases(cli, &t2, 2);
 329
 330         smbcli_close(cli->tree, fnum);
 331         smbcli_unlink(cli->tree, fname);
 332 }
 333
 334 /* look for setpathinfo aliases */
 335 static void setpathinfo_aliases(struct smbcli_state *cli)
 336 {
 337         struct smb_trans2 t2;
 338         uint16_t setup = TRANSACT2_SETPATHINFO;
 339         const char *fname = "\\setpathinfo_aliases.txt";
 340         int fnum;
 341         TALLOC_CTX *mem_ctx;
 342
 343         mem_ctx = talloc_init("findfirst");
 344
 345         d_printf("\nChecking for SETPATHINFO aliases\n");
 346
 347         t2.in.max_param = 32;
 348         t2.in.max_data = 0x8000;
 349         t2.in.max_setup = 0;
 350         t2.in.flags = 0;
 351         t2.in.timeout = 0;
 352         t2.in.setup_count = 1;
 353         t2.in.setup = &setup;
 354         t2.in.params = data_blob_talloc(mem_ctx, NULL, 4);
 355         t2.in.data = data_blob(NULL, 0);
 356
 357         smbcli_unlink(cli->tree, fname);
 358
 359         fnum = create_complex_file(cli, cli, fname);
 360         if (fnum == -1) {
 361                 printf("ERROR: open of %s failed (%s)\n", fname, smbcli_errstr(cli->tree));
 362         }
 363
 364         smbcli_write(cli->tree, fnum, 0, (char *)&t2, 0, sizeof(t2));
 365         smbcli_close(cli->tree, fnum);
 366
 367         SSVAL(t2.in.params.data, 2, 0);
 368
 369         smbcli_blob_append_string(cli->session, mem_ctx, &t2.in.params,
 370                                fname, STR_TERMINATE);
 371
 372         gen_set_aliases(cli, &t2, 0);
 373
 374         if (NT_STATUS_IS_ERR(smbcli_unlink(cli->tree, fname))) {
 375                 printf("unlink: %s\n", smbcli_errstr(cli->tree));
 376         }
 377         talloc_destroy(mem_ctx);
 378 }
 379
 380
 381 /* look for aliased info levels in trans2 calls */
 382 BOOL torture_trans2_aliases(int dummy)
 383 {
 384         struct smbcli_state *cli;
 385
 386         if (!torture_open_connection(&cli)) {
 387                 return False;
 388         }
 389
 390
 391         qfsinfo_aliases(cli);
 392         qfileinfo_aliases(cli);
 393         qpathinfo_aliases(cli);
 394         findfirst_aliases(cli);
 395         setfileinfo_aliases(cli);
 396         setpathinfo_aliases(cli);
 397
 398         if (!torture_close_connection(cli)) {
 399                 return False;
 400         }
 401
 402         return True;
 403 }