source4/libcli/raw/interfaces.h

   1 /*
   2    Unix SMB/CIFS implementation.
   3    SMB request interface structures
   4    Copyright (C) Andrew Tridgell                        2003
   5    Copyright (C) James J Myers 2003 <myersjj@samba.org>
   6    Copyright (C) James Peach 2007
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #ifndef __LIBCLI_RAW_INTERFACES_H__
  23 #define __LIBCLI_RAW_INTERFACES_H__
  24
  25 #include "libcli/raw/smb.h"
  26 #include "../libcli/smb/smb_common.h"
  27 #include "librpc/gen_ndr/misc.h" /* for struct GUID */
  28
  29 /* this structure is just a wrapper for a string, the only reason we
  30    bother with this is that it allows us to check the length provided
  31    on the wire in testsuite test code to ensure that we are
  32    terminating names in the same way that win2003 is. The *ONLY* time
  33    you should ever look at the 'private_length' field in this
  34    structure is inside compliance test code, in all other cases just
  35    use the null terminated char* as the definitive definition of the
  36    string
  37
  38    also note that this structure is only used in packets where there
  39    is an explicit length provided on the wire (hence the name). That
  40    length is placed in 'private_length'. For packets where the length
  41    is always determined by NULL or packet termination a normal char*
  42    is used in the structure definition.
  43  */
  44 struct smb_wire_string {
  45         uint32_t private_length;
  46         const char *s;
  47 };
  48
  49 /*
  50  * SMB2 uses a 16Byte handle,
  51  * (we can maybe use struct GUID later)
  52  */
  53 struct smb2_handle {
  54         uint64_t data[2];
  55 };
  56
  57 /*
  58   SMB2 lease structure (per MS-SMB2 2.2.13)
  59 */
  60 struct smb2_lease_key {
  61         uint64_t data[2];
  62 };
  63
  64 struct smb2_lease {
  65         struct smb2_lease_key lease_key;
  66         uint32_t lease_state;
  67         uint32_t lease_flags; /* should be 0 */
  68         uint64_t lease_duration; /* should be 0 */
  69 };
  70
  71 struct smb2_lease_break {
  72         struct smb2_lease current_lease;
  73         uint32_t break_flags;
  74         uint32_t new_lease_state;
  75         uint32_t break_reason; /* should be 0 */
  76         uint32_t access_mask_hint; /* should be 0 */
  77         uint32_t share_mask_hint; /* should be 0 */
  78 };
  79
  80 struct ntvfs_handle;
  81
  82 /*
  83  * a generic container for file handles or file pathes
  84  * for qfileinfo/setfileinfo and qpathinfo/setpathinfo
  85 */
  86 union smb_handle_or_path {
  87         /*
  88          * this is used for
  89          * the qpathinfo and setpathinfo
  90          * calls
  91          */
  92         const char *path;
  93         /*
  94          * this is used as file handle in SMB
  95          */
  96         uint16_t fnum;
  97
  98         /*
  99          * this is used as file handle in SMB2
 100          */
 101         struct smb2_handle handle;
 102
 103         /*
 104          * this is used as generic file handle for the NTVFS layer
 105          */
 106         struct ntvfs_handle *ntvfs;
 107 };
 108
 109 /*
 110  a generic container for file handles
 111 */
 112 union smb_handle {
 113         /*
 114          * this is used as file handle in SMB
 115          */
 116         uint16_t fnum;
 117
 118         /*
 119          * this is used as file handle in SMB2
 120          */
 121         struct smb2_handle handle;
 122
 123         /*
 124          * this is used as generic file handle for the NTVFS layer
 125          */
 126         struct ntvfs_handle *ntvfs;
 127 };
 128
 129 /*
 130   this header defines the structures and unions used between the SMB
 131   parser and the backends.
 132 */
 133
 134 /* struct used for SMBlseek call */
 135 union smb_seek {
 136         struct {
 137                 struct {
 138                         union smb_handle file;
 139                         uint16_t mode;
 140                         int32_t  offset; /* signed */
 141                 } in;
 142                 struct {
 143                         int32_t offset;
 144                 } out;
 145         } lseek, generic;
 146 };
 147
 148 /* struct used in unlink() call */
 149 union smb_unlink {
 150         struct {
 151                 struct {
 152                         const char *pattern;
 153                         uint16_t attrib;
 154                 } in;
 155         } unlink;
 156 };
 157
 158
 159 /* struct used in chkpath() call */
 160 union smb_chkpath {
 161         struct {
 162                 struct {
 163                         const char *path;
 164                 } in;
 165         } chkpath;
 166 };
 167
 168 enum smb_mkdir_level {RAW_MKDIR_GENERIC, RAW_MKDIR_MKDIR, RAW_MKDIR_T2MKDIR};
 169
 170 /* union used in mkdir() call */
 171 union smb_mkdir {
 172         /* generic level */
 173         struct {
 174                 enum smb_mkdir_level level;
 175         } generic;
 176
 177         struct {
 178                 enum smb_mkdir_level level;
 179                 struct {
 180                         const char *path;
 181                 } in;
 182         } mkdir;
 183
 184         struct {
 185                 enum smb_mkdir_level level;
 186                 struct {
 187                         const char *path;
 188                         unsigned int num_eas;
 189                         struct ea_struct *eas;
 190                 } in;
 191         } t2mkdir;
 192 };
 193
 194 /* struct used in rmdir() call */
 195 struct smb_rmdir {
 196         struct {
 197                 const char *path;
 198         } in;
 199 };
 200
 201 /* struct used in rename() call */
 202 enum smb_rename_level {RAW_RENAME_RENAME, RAW_RENAME_NTRENAME, RAW_RENAME_NTTRANS};
 203
 204 union smb_rename {
 205         struct {
 206                 enum smb_rename_level level;
 207         } generic;
 208
 209         /* SMBrename interface */
 210         struct {
 211                 enum smb_rename_level level;
 212
 213                 struct {
 214                         const char *pattern1;
 215                         const char *pattern2;
 216                         uint16_t attrib;
 217                 } in;
 218         } rename;
 219
 220
 221         /* SMBntrename interface */
 222         struct {
 223                 enum smb_rename_level level;
 224
 225                 struct {
 226                         uint16_t attrib;
 227                         uint16_t flags; /* see RENAME_FLAG_* */
 228                         uint32_t cluster_size;
 229                         const char *old_name;
 230                         const char *new_name;
 231                 } in;
 232         } ntrename;
 233
 234         /* NT TRANS rename interface */
 235         struct {
 236                 enum smb_rename_level level;
 237
 238                 struct {
 239                         union smb_handle file;
 240                         uint16_t flags;/* see RENAME_REPLACE_IF_EXISTS */
 241                         const char *new_name;
 242                 } in;
 243         } nttrans;
 244 };
 245
 246 enum smb_tcon_level {
 247         RAW_TCON_TCON,
 248         RAW_TCON_TCONX,
 249         RAW_TCON_SMB2
 250 };
 251
 252 /* union used in tree connect call */
 253 union smb_tcon {
 254         /* generic interface */
 255         struct {
 256                 enum smb_tcon_level level;
 257         } generic;
 258
 259         /* SMBtcon interface */
 260         struct {
 261                 enum smb_tcon_level level;
 262
 263                 struct {
 264                         const char *service;
 265                         const char *password;
 266                         const char *dev;
 267                 } in;
 268                 struct {
 269                         uint16_t max_xmit;
 270                         uint16_t tid;
 271                 } out;
 272         } tcon;
 273
 274         /* SMBtconX interface */
 275         struct {
 276                 enum smb_tcon_level level;
 277
 278                 struct {
 279                         uint16_t flags;
 280                         DATA_BLOB password;
 281                         const char *path;
 282                         const char *device;
 283                 } in;
 284                 struct {
 285                         uint16_t options;
 286                         char *dev_type;
 287                         char *fs_type;
 288                         uint16_t tid;
 289                 } out;
 290         } tconx;
 291
 292         /* SMB2 TreeConnect */
 293         struct smb2_tree_connect {
 294                 enum smb_tcon_level level;
 295
 296                 struct {
 297                         /* static body buffer 8 (0x08) bytes */
 298                         uint16_t reserved;
 299                         /* uint16_t path_ofs */
 300                         /* uint16_t path_size */
 301                                 /* dynamic body */
 302                         const char *path; /* as non-terminated UTF-16 on the wire */
 303                 } in;
 304                 struct {
 305                         /* static body buffer 16 (0x10) bytes */
 306                         /* uint16_t buffer_code;  0x10 */
 307                         uint8_t share_type;
 308                         uint8_t reserved;
 309                         uint32_t flags;
 310                         uint32_t capabilities;
 311                         uint32_t access_mask;
 312
 313                         /* extracted from the SMB2 header */
 314                         uint32_t tid;
 315                 } out;
 316         } smb2;
 317 };
 318
 319
 320 enum smb_sesssetup_level {
 321         RAW_SESSSETUP_OLD,
 322         RAW_SESSSETUP_NT1,
 323         RAW_SESSSETUP_SPNEGO,
 324         RAW_SESSSETUP_SMB2
 325 };
 326
 327 /* union used in session_setup call */
 328 union smb_sesssetup {
 329         /* the pre-NT1 interface */
 330         struct {
 331                 enum smb_sesssetup_level level;
 332
 333                 struct {
 334                         uint16_t bufsize;
 335                         uint16_t mpx_max;
 336                         uint16_t vc_num;
 337                         uint32_t sesskey;
 338                         DATA_BLOB password;
 339                         const char *user;
 340                         const char *domain;
 341                         const char *os;
 342                         const char *lanman;
 343                 } in;
 344                 struct {
 345                         uint16_t action;
 346                         uint16_t vuid;
 347                         char *os;
 348                         char *lanman;
 349                         char *domain;
 350                 } out;
 351         } old;
 352
 353         /* the NT1 interface */
 354         struct {
 355                 enum smb_sesssetup_level level;
 356
 357                 struct {
 358                         uint16_t bufsize;
 359                         uint16_t mpx_max;
 360                         uint16_t vc_num;
 361                         uint32_t sesskey;
 362                         uint32_t capabilities;
 363                         DATA_BLOB password1;
 364                         DATA_BLOB password2;
 365                         const char *user;
 366                         const char *domain;
 367                         const char *os;
 368                         const char *lanman;
 369                 } in;
 370                 struct {
 371                         uint16_t action;
 372                         uint16_t vuid;
 373                         char *os;
 374                         char *lanman;
 375                         char *domain;
 376                 } out;
 377         } nt1;
 378
 379
 380         /* the SPNEGO interface */
 381         struct {
 382                 enum smb_sesssetup_level level;
 383
 384                 struct {
 385                         uint16_t bufsize;
 386                         uint16_t mpx_max;
 387                         uint16_t vc_num;
 388                         uint32_t sesskey;
 389                         uint32_t capabilities;
 390                         DATA_BLOB secblob;
 391                         const char *os;
 392                         const char *lanman;
 393                         const char *workgroup;
 394                 } in;
 395                 struct {
 396                         uint16_t action;
 397                         DATA_BLOB secblob;
 398                         char *os;
 399                         char *lanman;
 400                         char *workgroup;
 401                         uint16_t vuid;
 402                 } out;
 403         } spnego;
 404
 405         /* SMB2 SessionSetup */
 406         struct smb2_session_setup {
 407                 enum smb_sesssetup_level level;
 408
 409                 struct {
 410                         /* static body 24 (0x18) bytes */
 411                         uint8_t vc_number;
 412                         uint8_t security_mode;
 413                         uint32_t capabilities;
 414                         uint32_t channel;
 415                         /* uint16_t secblob_ofs */
 416                         /* uint16_t secblob_size */
 417                         uint64_t previous_sessionid;
 418                         /* dynamic body */
 419                         DATA_BLOB secblob;
 420                 } in;
 421                 struct {
 422                         /* body buffer 8 (0x08) bytes */
 423                         uint16_t session_flags;
 424                         /* uint16_t secblob_ofs */
 425                         /* uint16_t secblob_size */
 426                         /* dynamic body */
 427                         DATA_BLOB secblob;
 428
 429                         /* extracted from the SMB2 header */
 430                         uint64_t uid;
 431                 } out;
 432         } smb2;
 433 };
 434
 435 /* Note that the specified enum values are identical to the actual info-levels used
 436  * on the wire.
 437  */
 438 enum smb_fileinfo_level {
 439                      RAW_FILEINFO_GENERIC                    = 0xF000,
 440                      RAW_FILEINFO_GETATTR,                   /* SMBgetatr */
 441                      RAW_FILEINFO_GETATTRE,                  /* SMBgetattrE */
 442                      RAW_FILEINFO_SEC_DESC,                  /* NT_TRANSACT_QUERY_SECURITY_DESC */
 443                      RAW_FILEINFO_STANDARD                   = SMB_QFILEINFO_STANDARD,
 444                      RAW_FILEINFO_EA_SIZE                    = SMB_QFILEINFO_EA_SIZE,
 445                      RAW_FILEINFO_EA_LIST                    = SMB_QFILEINFO_EA_LIST,
 446                      RAW_FILEINFO_ALL_EAS                    = SMB_QFILEINFO_ALL_EAS,
 447                      RAW_FILEINFO_IS_NAME_VALID              = SMB_QFILEINFO_IS_NAME_VALID,
 448                      RAW_FILEINFO_BASIC_INFO                 = SMB_QFILEINFO_BASIC_INFO,
 449                      RAW_FILEINFO_STANDARD_INFO              = SMB_QFILEINFO_STANDARD_INFO,
 450                      RAW_FILEINFO_EA_INFO                    = SMB_QFILEINFO_EA_INFO,
 451                      RAW_FILEINFO_NAME_INFO                  = SMB_QFILEINFO_NAME_INFO,
 452                      RAW_FILEINFO_ALL_INFO                   = SMB_QFILEINFO_ALL_INFO,
 453                      RAW_FILEINFO_ALT_NAME_INFO              = SMB_QFILEINFO_ALT_NAME_INFO,
 454                      RAW_FILEINFO_STREAM_INFO                = SMB_QFILEINFO_STREAM_INFO,
 455                      RAW_FILEINFO_COMPRESSION_INFO           = SMB_QFILEINFO_COMPRESSION_INFO,
 456                      RAW_FILEINFO_UNIX_BASIC                 = SMB_QFILEINFO_UNIX_BASIC,
 457                      RAW_FILEINFO_UNIX_INFO2                 = SMB_QFILEINFO_UNIX_INFO2,
 458                      RAW_FILEINFO_UNIX_LINK                  = SMB_QFILEINFO_UNIX_LINK,
 459                      RAW_FILEINFO_BASIC_INFORMATION          = SMB_QFILEINFO_BASIC_INFORMATION,
 460                      RAW_FILEINFO_STANDARD_INFORMATION       = SMB_QFILEINFO_STANDARD_INFORMATION,
 461                      RAW_FILEINFO_INTERNAL_INFORMATION       = SMB_QFILEINFO_INTERNAL_INFORMATION,
 462                      RAW_FILEINFO_EA_INFORMATION             = SMB_QFILEINFO_EA_INFORMATION,
 463                      RAW_FILEINFO_ACCESS_INFORMATION         = SMB_QFILEINFO_ACCESS_INFORMATION,
 464                      RAW_FILEINFO_NAME_INFORMATION           = SMB_QFILEINFO_NAME_INFORMATION,
 465                      RAW_FILEINFO_POSITION_INFORMATION       = SMB_QFILEINFO_POSITION_INFORMATION,
 466                      RAW_FILEINFO_MODE_INFORMATION           = SMB_QFILEINFO_MODE_INFORMATION,
 467                      RAW_FILEINFO_ALIGNMENT_INFORMATION      = SMB_QFILEINFO_ALIGNMENT_INFORMATION,
 468                      RAW_FILEINFO_ALL_INFORMATION            = SMB_QFILEINFO_ALL_INFORMATION,
 469                      RAW_FILEINFO_ALT_NAME_INFORMATION       = SMB_QFILEINFO_ALT_NAME_INFORMATION,
 470                      RAW_FILEINFO_STREAM_INFORMATION         = SMB_QFILEINFO_STREAM_INFORMATION,
 471                      RAW_FILEINFO_COMPRESSION_INFORMATION    = SMB_QFILEINFO_COMPRESSION_INFORMATION,
 472                      RAW_FILEINFO_NETWORK_OPEN_INFORMATION   = SMB_QFILEINFO_NETWORK_OPEN_INFORMATION,
 473                      RAW_FILEINFO_ATTRIBUTE_TAG_INFORMATION  = SMB_QFILEINFO_ATTRIBUTE_TAG_INFORMATION,
 474                      /* SMB2 specific levels */
 475                      RAW_FILEINFO_SMB2_ALL_EAS               = 0x0f01,
 476                      RAW_FILEINFO_SMB2_ALL_INFORMATION       = 0x1201
 477 };
 478
 479 /* union used in qfileinfo() and qpathinfo() backend calls */
 480 union smb_fileinfo {
 481         /* generic interface:
 482          * matches RAW_FILEINFO_GENERIC */
 483         struct {
 484                 enum smb_fileinfo_level level;
 485                 struct {
 486                         union smb_handle_or_path file;
 487                 } in;
 488                 struct {
 489                         uint32_t attrib;
 490                         uint32_t ea_size;
 491                         unsigned int num_eas;
 492                         struct ea_struct {
 493                                 uint8_t flags;
 494                                 struct smb_wire_string name;
 495                                 DATA_BLOB value;
 496                         } *eas;
 497                         NTTIME create_time;
 498                         NTTIME access_time;
 499                         NTTIME write_time;
 500                         NTTIME change_time;
 501                         uint64_t alloc_size;
 502                         uint64_t size;
 503                         uint32_t nlink;
 504                         struct smb_wire_string fname;
 505                         struct smb_wire_string alt_fname;
 506                         uint8_t delete_pending;
 507                         uint8_t directory;
 508                         uint64_t compressed_size;
 509                         uint16_t format;
 510                         uint8_t unit_shift;
 511                         uint8_t chunk_shift;
 512                         uint8_t cluster_shift;
 513                         uint64_t file_id;
 514                         uint32_t access_flags; /* seen 0x001f01ff from w2k3 */
 515                         uint64_t position;
 516                         uint32_t mode;
 517                         uint32_t alignment_requirement;
 518                         uint32_t reparse_tag;
 519                         unsigned int num_streams;
 520                         struct stream_struct {
 521                                 uint64_t size;
 522                                 uint64_t alloc_size;
 523                                 struct smb_wire_string stream_name;
 524                         } *streams;
 525                 } out;
 526         } generic;
 527
 528
 529         /* SMBgetatr interface:
 530          * matches RAW_FILEINFO_GETATTR */
 531         struct {
 532                 enum smb_fileinfo_level level;
 533                 struct {
 534                         union smb_handle_or_path file;
 535                 } in;
 536                 struct {
 537                         uint16_t attrib;
 538                         uint32_t size;
 539                         time_t write_time;
 540                 } out;
 541         } getattr;
 542
 543         /* SMBgetattrE and  RAW_FILEINFO_STANDARD interface */
 544         struct {
 545                 enum smb_fileinfo_level level;
 546                 struct {
 547                         union smb_handle_or_path file;
 548                 } in;
 549                 struct {
 550                         time_t create_time;
 551                         time_t access_time;
 552                         time_t write_time;
 553                         uint32_t size;
 554                         uint32_t alloc_size;
 555                         uint16_t attrib;
 556                 } out;
 557         } getattre, standard;
 558
 559         /* trans2 RAW_FILEINFO_EA_SIZE interface */
 560         struct {
 561                 enum smb_fileinfo_level level;
 562                 struct {
 563                         union smb_handle_or_path file;
 564                 } in;
 565                 struct {
 566                         time_t create_time;
 567                         time_t access_time;
 568                         time_t write_time;
 569                         uint32_t size;
 570                         uint32_t alloc_size;
 571                         uint16_t attrib;
 572                         uint32_t ea_size;
 573                 } out;
 574         } ea_size;
 575
 576         /* trans2 RAW_FILEINFO_EA_LIST interface */
 577         struct {
 578                 enum smb_fileinfo_level level;
 579                 struct {
 580                         union smb_handle_or_path file;
 581                         unsigned int num_names;
 582                         struct ea_name {
 583                                 struct smb_wire_string name;
 584                         } *ea_names;
 585                 } in;
 586
 587                 struct smb_ea_list {
 588                         unsigned int num_eas;
 589                         struct ea_struct *eas;
 590                 } out;
 591         } ea_list;
 592
 593         /* trans2 RAW_FILEINFO_ALL_EAS and RAW_FILEINFO_FULL_EA_INFORMATION interfaces */
 594         struct {
 595                 enum smb_fileinfo_level level;
 596                 struct {
 597                         union smb_handle_or_path file;
 598                         /* SMB2 only - SMB2_CONTINUE_FLAG_* */
 599                         uint8_t continue_flags;
 600                 } in;
 601                 struct smb_ea_list out;
 602         } all_eas;
 603
 604         /* trans2 qpathinfo RAW_FILEINFO_IS_NAME_VALID interface
 605            only valid for a QPATHNAME call - no returned data */
 606         struct {
 607                 enum smb_fileinfo_level level;
 608                 struct {
 609                         union smb_handle_or_path file;
 610                 } in;
 611         } is_name_valid;
 612
 613         /* RAW_FILEINFO_BASIC_INFO and RAW_FILEINFO_BASIC_INFORMATION interfaces */
 614         struct {
 615                 enum smb_fileinfo_level level;
 616                 struct {
 617                         union smb_handle_or_path file;
 618                 } in;
 619                 struct {
 620                         NTTIME create_time;
 621                         NTTIME access_time;
 622                         NTTIME write_time;
 623                         NTTIME change_time;
 624                         uint32_t attrib;
 625                 } out;
 626         } basic_info;
 627
 628
 629         /* RAW_FILEINFO_STANDARD_INFO and RAW_FILEINFO_STANDARD_INFORMATION interfaces */
 630         struct {
 631                 enum smb_fileinfo_level level;
 632                 struct {
 633                         union smb_handle_or_path file;
 634                 } in;
 635                 struct {
 636                         uint64_t alloc_size;
 637                         uint64_t size;
 638                         uint32_t nlink;
 639                         bool delete_pending;
 640                         bool directory;
 641                 } out;
 642         } standard_info;
 643
 644         /* RAW_FILEINFO_EA_INFO and RAW_FILEINFO_EA_INFORMATION interfaces */
 645         struct {
 646                 enum smb_fileinfo_level level;
 647                 struct {
 648                         union smb_handle_or_path file;
 649                 } in;
 650                 struct {
 651                         uint32_t ea_size;
 652                 } out;
 653         } ea_info;
 654
 655         /* RAW_FILEINFO_NAME_INFO and RAW_FILEINFO_NAME_INFORMATION interfaces */
 656         struct {
 657                 enum smb_fileinfo_level level;
 658                 struct {
 659                         union smb_handle_or_path file;
 660                 } in;
 661                 struct {
 662                         struct smb_wire_string fname;
 663                 } out;
 664         } name_info;
 665
 666         /* RAW_FILEINFO_ALL_INFO and RAW_FILEINFO_ALL_INFORMATION interfaces */
 667         struct {
 668                 enum smb_fileinfo_level level;
 669                 struct {
 670                         union smb_handle_or_path file;
 671                 } in;
 672                 struct {
 673                         NTTIME create_time;
 674                         NTTIME access_time;
 675                         NTTIME write_time;
 676                         NTTIME change_time;
 677                         uint32_t attrib;
 678                         uint64_t alloc_size;
 679                         uint64_t size;
 680                         uint32_t nlink;
 681                         uint8_t delete_pending;
 682                         uint8_t directory;
 683                         uint32_t ea_size;
 684                         struct smb_wire_string fname;
 685                 } out;
 686         } all_info;
 687
 688         /* RAW_FILEINFO_SMB2_ALL_INFORMATION interface */
 689         struct {
 690                 enum smb_fileinfo_level level;
 691                 struct {
 692                         union smb_handle_or_path file;
 693                 } in;
 694                 struct {
 695                         NTTIME   create_time;
 696                         NTTIME   access_time;
 697                         NTTIME   write_time;
 698                         NTTIME   change_time;
 699                         uint32_t attrib;
 700                         uint32_t unknown1;
 701                         uint64_t alloc_size;
 702                         uint64_t size;
 703                         uint32_t nlink;
 704                         uint8_t  delete_pending;
 705                         uint8_t  directory;
 706                         /* uint16_t _pad; */
 707                         uint64_t file_id;
 708                         uint32_t ea_size;
 709                         uint32_t access_mask;
 710                         uint64_t position;
 711                         uint32_t mode;
 712                         uint32_t alignment_requirement;
 713                         struct smb_wire_string fname;
 714                 } out;
 715         } all_info2;
 716
 717         /* RAW_FILEINFO_ALT_NAME_INFO and RAW_FILEINFO_ALT_NAME_INFORMATION interfaces */
 718         struct {
 719                 enum smb_fileinfo_level level;
 720                 struct {
 721                         union smb_handle_or_path file;
 722                 } in;
 723                 struct {
 724                         struct smb_wire_string fname;
 725                 } out;
 726         } alt_name_info;
 727
 728         /* RAW_FILEINFO_STREAM_INFO and RAW_FILEINFO_STREAM_INFORMATION interfaces */
 729         struct {
 730                 enum smb_fileinfo_level level;
 731                 struct {
 732                         union smb_handle_or_path file;
 733                 } in;
 734                 struct stream_information {
 735                         unsigned int num_streams;
 736                         struct stream_struct *streams;
 737                 } out;
 738         } stream_info;
 739
 740         /* RAW_FILEINFO_COMPRESSION_INFO and RAW_FILEINFO_COMPRESSION_INFORMATION interfaces */
 741         struct {
 742                 enum smb_fileinfo_level level;
 743                 struct {
 744                         union smb_handle_or_path file;
 745                 } in;
 746                 struct {
 747                         uint64_t compressed_size;
 748                         uint16_t format;
 749                         uint8_t unit_shift;
 750                         uint8_t chunk_shift;
 751                         uint8_t cluster_shift;
 752                 } out;
 753         } compression_info;
 754
 755         /* RAW_FILEINFO_UNIX_BASIC interface */
 756         struct {
 757                 enum smb_fileinfo_level level;
 758                 struct {
 759                         union smb_handle_or_path file;
 760                 } in;
 761                 struct {
 762                         uint64_t end_of_file;
 763                         uint64_t num_bytes;
 764                         NTTIME status_change_time;
 765                         NTTIME access_time;
 766                         NTTIME change_time;
 767                         uint64_t uid;
 768                         uint64_t gid;
 769                         uint32_t file_type;
 770                         uint64_t dev_major;
 771                         uint64_t dev_minor;
 772                         uint64_t unique_id;
 773                         uint64_t permissions;
 774                         uint64_t nlink;
 775                 } out;
 776         } unix_basic_info;
 777
 778         /* RAW_FILEINFO_UNIX_INFO2 interface */
 779         struct {
 780                 enum smb_fileinfo_level level;
 781                 struct {
 782                         union smb_handle_or_path file;
 783                 } in;
 784                 struct {
 785                         uint64_t end_of_file;
 786                         uint64_t num_bytes;
 787                         NTTIME status_change_time;
 788                         NTTIME access_time;
 789                         NTTIME change_time;
 790                         uint64_t uid;
 791                         uint64_t gid;
 792                         uint32_t file_type;
 793                         uint64_t dev_major;
 794                         uint64_t dev_minor;
 795                         uint64_t unique_id;
 796                         uint64_t permissions;
 797                         uint64_t nlink;
 798                         NTTIME create_time;
 799                         uint32_t file_flags;
 800                         uint32_t flags_mask;
 801                 } out;
 802         } unix_info2;
 803
 804         /* RAW_FILEINFO_UNIX_LINK interface */
 805         struct {
 806                 enum smb_fileinfo_level level;
 807                 struct {
 808                         union smb_handle_or_path file;
 809                 } in;
 810                 struct {
 811                         struct smb_wire_string link_dest;
 812                 } out;
 813         } unix_link_info;
 814
 815         /* RAW_FILEINFO_INTERNAL_INFORMATION interface */
 816         struct {
 817                 enum smb_fileinfo_level level;
 818                 struct {
 819                         union smb_handle_or_path file;
 820                 } in;
 821                 struct {
 822                         uint64_t file_id;
 823                 } out;
 824         } internal_information;
 825
 826         /* RAW_FILEINFO_ACCESS_INFORMATION interface */
 827         struct {
 828                 enum smb_fileinfo_level level;
 829                 struct {
 830                         union smb_handle_or_path file;
 831                 } in;
 832                 struct {
 833                         uint32_t access_flags;
 834                 } out;
 835         } access_information;
 836
 837         /* RAW_FILEINFO_POSITION_INFORMATION interface */
 838         struct {
 839                 enum smb_fileinfo_level level;
 840                 struct {
 841                         union smb_handle_or_path file;
 842                 } in;
 843                 struct {
 844                         uint64_t position;
 845                 } out;
 846         } position_information;
 847
 848         /* RAW_FILEINFO_MODE_INFORMATION interface */
 849         struct {
 850                 enum smb_fileinfo_level level;
 851                 struct {
 852                         union smb_handle_or_path file;
 853                 } in;
 854                 struct {
 855                         uint32_t mode;
 856                 } out;
 857         } mode_information;
 858
 859         /* RAW_FILEINFO_ALIGNMENT_INFORMATION interface */
 860         struct {
 861                 enum smb_fileinfo_level level;
 862                 struct {
 863                         union smb_handle_or_path file;
 864                 } in;
 865                 struct {
 866                         uint32_t alignment_requirement;
 867                 } out;
 868         } alignment_information;
 869
 870         /* RAW_FILEINFO_NETWORK_OPEN_INFORMATION interface */
 871         struct {
 872                 enum smb_fileinfo_level level;
 873                 struct {
 874                         union smb_handle_or_path file;
 875                 } in;
 876                 struct {
 877                         NTTIME create_time;
 878                         NTTIME access_time;
 879                         NTTIME write_time;
 880                         NTTIME change_time;
 881                         uint64_t alloc_size;
 882                         uint64_t size;
 883                         uint32_t attrib;
 884                 } out;
 885         } network_open_information;
 886
 887
 888         /* RAW_FILEINFO_ATTRIBUTE_TAG_INFORMATION interface */
 889         struct {
 890                 enum smb_fileinfo_level level;
 891                 struct {
 892                         union smb_handle_or_path file;
 893                 } in;
 894                 struct {
 895                         uint32_t attrib;
 896                         uint32_t reparse_tag;
 897                 } out;
 898         } attribute_tag_information;
 899
 900         /* RAW_FILEINFO_SEC_DESC */
 901         struct {
 902                 enum smb_fileinfo_level level;
 903                 struct {
 904                         union smb_handle_or_path file;
 905                         uint32_t secinfo_flags;
 906                 } in;
 907                 struct {
 908                         struct security_descriptor *sd;
 909                 } out;
 910         } query_secdesc;
 911 };
 912
 913
 914 enum smb_setfileinfo_level {
 915         RAW_SFILEINFO_GENERIC                 = 0xF000,
 916         RAW_SFILEINFO_SETATTR,                /* SMBsetatr */
 917         RAW_SFILEINFO_SETATTRE,               /* SMBsetattrE */
 918         RAW_SFILEINFO_SEC_DESC,               /* NT_TRANSACT_SET_SECURITY_DESC */
 919         RAW_SFILEINFO_STANDARD                = SMB_SFILEINFO_STANDARD,
 920         RAW_SFILEINFO_EA_SET                  = SMB_SFILEINFO_EA_SET,
 921         RAW_SFILEINFO_BASIC_INFO              = SMB_SFILEINFO_BASIC_INFO,
 922         RAW_SFILEINFO_DISPOSITION_INFO        = SMB_SFILEINFO_DISPOSITION_INFO,
 923         RAW_SFILEINFO_ALLOCATION_INFO         = SMB_SFILEINFO_ALLOCATION_INFO,
 924         RAW_SFILEINFO_END_OF_FILE_INFO        = SMB_SFILEINFO_END_OF_FILE_INFO,
 925         RAW_SFILEINFO_UNIX_BASIC              = SMB_SFILEINFO_UNIX_BASIC,
 926         RAW_SFILEINFO_UNIX_INFO2              = SMB_SFILEINFO_UNIX_INFO2,
 927         RAW_SFILEINFO_UNIX_LINK               = SMB_SET_FILE_UNIX_LINK,
 928         RAW_SFILEINFO_UNIX_HLINK              = SMB_SET_FILE_UNIX_HLINK,
 929         RAW_SFILEINFO_BASIC_INFORMATION       = SMB_SFILEINFO_BASIC_INFORMATION,
 930         RAW_SFILEINFO_RENAME_INFORMATION      = SMB_SFILEINFO_RENAME_INFORMATION,
 931         RAW_SFILEINFO_LINK_INFORMATION        = SMB_SFILEINFO_LINK_INFORMATION,
 932         RAW_SFILEINFO_DISPOSITION_INFORMATION = SMB_SFILEINFO_DISPOSITION_INFORMATION,
 933         RAW_SFILEINFO_POSITION_INFORMATION    = SMB_SFILEINFO_POSITION_INFORMATION,
 934         RAW_SFILEINFO_FULL_EA_INFORMATION     = SMB_SFILEINFO_FULL_EA_INFORMATION,
 935         RAW_SFILEINFO_MODE_INFORMATION        = SMB_SFILEINFO_MODE_INFORMATION,
 936         RAW_SFILEINFO_ALLOCATION_INFORMATION  = SMB_SFILEINFO_ALLOCATION_INFORMATION,
 937         RAW_SFILEINFO_END_OF_FILE_INFORMATION = SMB_SFILEINFO_END_OF_FILE_INFORMATION,
 938         RAW_SFILEINFO_PIPE_INFORMATION        = SMB_SFILEINFO_PIPE_INFORMATION,
 939         RAW_SFILEINFO_VALID_DATA_INFORMATION  = SMB_SFILEINFO_VALID_DATA_INFORMATION,
 940         RAW_SFILEINFO_SHORT_NAME_INFORMATION  = SMB_SFILEINFO_SHORT_NAME_INFORMATION,
 941         RAW_SFILEINFO_1025                    = SMB_SFILEINFO_1025,
 942         RAW_SFILEINFO_1027                    = SMB_SFILEINFO_1027,
 943         RAW_SFILEINFO_1029                    = SMB_SFILEINFO_1029,
 944         RAW_SFILEINFO_1030                    = SMB_SFILEINFO_1030,
 945         RAW_SFILEINFO_1031                    = SMB_SFILEINFO_1031,
 946         RAW_SFILEINFO_1032                    = SMB_SFILEINFO_1032,
 947         RAW_SFILEINFO_1036                    = SMB_SFILEINFO_1036,
 948         RAW_SFILEINFO_1041                    = SMB_SFILEINFO_1041,
 949         RAW_SFILEINFO_1042                    = SMB_SFILEINFO_1042,
 950         RAW_SFILEINFO_1043                    = SMB_SFILEINFO_1043,
 951         RAW_SFILEINFO_1044                    = SMB_SFILEINFO_1044,
 952
 953         /* cope with breakage in SMB2 */
 954         RAW_SFILEINFO_RENAME_INFORMATION_SMB2 = SMB_SFILEINFO_RENAME_INFORMATION|0x80000000,
 955 };
 956
 957 /* union used in setfileinfo() and setpathinfo() calls */
 958 union smb_setfileinfo {
 959         /* generic interface */
 960         struct {
 961                 enum smb_setfileinfo_level level;
 962                 struct {
 963                         union smb_handle_or_path file;
 964                 } in;
 965         } generic;
 966
 967         /* RAW_SFILEINFO_SETATTR (SMBsetatr) interface - only via setpathinfo() */
 968         struct {
 969                 enum smb_setfileinfo_level level;
 970                 struct {
 971                         union smb_handle_or_path file;
 972                         uint16_t attrib;
 973                         time_t write_time;
 974                 } in;
 975         } setattr;
 976
 977         /* RAW_SFILEINFO_SETATTRE (SMBsetattrE) interface - only via setfileinfo()
 978            also RAW_SFILEINFO_STANDARD */
 979         struct {
 980                 enum smb_setfileinfo_level level;
 981                 struct {
 982                         union smb_handle_or_path file;
 983                         time_t create_time;
 984                         time_t access_time;
 985                         time_t write_time;
 986                         /* notice that size, alloc_size and attrib are not settable,
 987                            unlike the corresponding qfileinfo level */
 988                 } in;
 989         } setattre, standard;
 990
 991         /* RAW_SFILEINFO_EA_SET interface */
 992         struct {
 993                 enum smb_setfileinfo_level level;
 994                 struct {
 995                         union smb_handle_or_path file;
 996                         unsigned int num_eas;
 997                         struct ea_struct *eas;
 998                 } in;
 999         } ea_set;
1000
1001         /* RAW_SFILEINFO_BASIC_INFO and
1002            RAW_SFILEINFO_BASIC_INFORMATION interfaces */
1003         struct {
1004                 enum smb_setfileinfo_level level;
1005                 struct {
1006                         union smb_handle_or_path file;
1007                         NTTIME create_time;
1008                         NTTIME access_time;
1009                         NTTIME write_time;
1010                         NTTIME change_time;
1011                         uint32_t attrib;
1012                         uint32_t reserved;
1013                 } in;
1014         } basic_info;
1015
1016         /* RAW_SFILEINFO_DISPOSITION_INFO and
1017            RAW_SFILEINFO_DISPOSITION_INFORMATION interfaces */
1018         struct {
1019                 enum smb_setfileinfo_level level;
1020                 struct {
1021                         union smb_handle_or_path file;
1022                         bool delete_on_close;
1023                 } in;
1024         } disposition_info;
1025
1026         /* RAW_SFILEINFO_ALLOCATION_INFO and
1027            RAW_SFILEINFO_ALLOCATION_INFORMATION interfaces */
1028         struct {
1029                 enum smb_setfileinfo_level level;
1030                 struct {
1031                         union smb_handle_or_path file;
1032                         /* w2k3 rounds this up to nearest 4096 */
1033                         uint64_t alloc_size;
1034                 } in;
1035         } allocation_info;
1036
1037         /* RAW_SFILEINFO_END_OF_FILE_INFO and
1038            RAW_SFILEINFO_END_OF_FILE_INFORMATION interfaces */
1039         struct {
1040                 enum smb_setfileinfo_level level;
1041                 struct {
1042                         union smb_handle_or_path file;
1043                         uint64_t size;
1044                 } in;
1045         } end_of_file_info;
1046
1047         /* RAW_SFILEINFO_RENAME_INFORMATION interface */
1048         struct {
1049                 enum smb_setfileinfo_level level;
1050                 struct {
1051                         union smb_handle_or_path file;
1052                         uint8_t overwrite;
1053                         uint64_t root_fid;
1054                         const char *new_name;
1055                 } in;
1056         } rename_information;
1057
1058         /* RAW_SFILEINFO_LINK_INFORMATION interface */
1059         struct {
1060                 enum smb_setfileinfo_level level;
1061                 struct {
1062                         union smb_handle_or_path file;
1063                         uint8_t overwrite;
1064                         uint64_t root_fid;
1065                         const char *new_name;
1066                 } in;
1067         } link_information;
1068
1069         /* RAW_SFILEINFO_POSITION_INFORMATION interface */
1070         struct {
1071                 enum smb_setfileinfo_level level;
1072                 struct {
1073                         union smb_handle_or_path file;
1074                         uint64_t position;
1075                 } in;
1076         } position_information;
1077
1078         /* RAW_SFILEINFO_MODE_INFORMATION interface */
1079         struct {
1080                 enum smb_setfileinfo_level level;
1081                 struct {
1082                         union smb_handle_or_path file;
1083                         /* valid values seem to be 0, 2, 4 and 6 */
1084                         uint32_t mode;
1085                 } in;
1086         } mode_information;
1087
1088         /* RAW_SFILEINFO_UNIX_BASIC interface */
1089         struct {
1090                 enum smb_setfileinfo_level level;
1091                 struct {
1092                         union smb_handle_or_path file;
1093                         uint32_t mode; /* yuck - this field remains to fix compile of libcli/clifile.c */
1094                         uint64_t end_of_file;
1095                         uint64_t num_bytes;
1096                         NTTIME status_change_time;
1097                         NTTIME access_time;
1098                         NTTIME change_time;
1099                         uint64_t uid;
1100                         uint64_t gid;
1101                         uint32_t file_type;
1102                         uint64_t dev_major;
1103                         uint64_t dev_minor;
1104                         uint64_t unique_id;
1105                         uint64_t permissions;
1106                         uint64_t nlink;
1107                 } in;
1108         } unix_basic;
1109
1110         /* RAW_SFILEINFO_UNIX_INFO2 interface */
1111         struct {
1112                 enum smb_setfileinfo_level level;
1113                 struct {
1114                         union smb_handle_or_path file;
1115                         uint64_t end_of_file;
1116                         uint64_t num_bytes;
1117                         NTTIME status_change_time;
1118                         NTTIME access_time;
1119                         NTTIME change_time;
1120                         uint64_t uid;
1121                         uint64_t gid;
1122                         uint32_t file_type;
1123                         uint64_t dev_major;
1124                         uint64_t dev_minor;
1125                         uint64_t unique_id;
1126                         uint64_t permissions;
1127                         uint64_t nlink;
1128                         NTTIME create_time;
1129                         uint32_t file_flags;
1130                         uint32_t flags_mask;
1131                 } in;
1132         } unix_info2;
1133
1134         /* RAW_SFILEINFO_UNIX_LINK, RAW_SFILEINFO_UNIX_HLINK interface */
1135         struct {
1136                 enum smb_setfileinfo_level level;
1137                 struct {
1138                         union smb_handle_or_path file;
1139                         const char *link_dest;
1140                 } in;
1141         } unix_link, unix_hlink;
1142
1143         /* RAW_FILEINFO_SET_SEC_DESC */
1144         struct {
1145                 enum smb_setfileinfo_level level;
1146                 struct {
1147                         union smb_handle_or_path file;
1148                         uint32_t secinfo_flags;
1149                         struct security_descriptor *sd;
1150                 } in;
1151         } set_secdesc;
1152
1153         /* RAW_SFILEINFO_FULL_EA_INFORMATION */
1154         struct {
1155                 enum smb_setfileinfo_level level;
1156                 struct {
1157                         union smb_handle_or_path file;
1158                         struct smb_ea_list eas;
1159                 } in;
1160         } full_ea_information;
1161 };
1162
1163
1164 enum smb_fsinfo_level {
1165                    RAW_QFS_GENERIC                        = 0xF000,
1166                    RAW_QFS_DSKATTR,                         /* SMBdskattr */
1167                    RAW_QFS_ALLOCATION                     = SMB_QFS_ALLOCATION,
1168                    RAW_QFS_VOLUME                         = SMB_QFS_VOLUME,
1169                    RAW_QFS_VOLUME_INFO                    = SMB_QFS_VOLUME_INFO,
1170                    RAW_QFS_SIZE_INFO                      = SMB_QFS_SIZE_INFO,
1171                    RAW_QFS_DEVICE_INFO                    = SMB_QFS_DEVICE_INFO,
1172                    RAW_QFS_ATTRIBUTE_INFO                 = SMB_QFS_ATTRIBUTE_INFO,
1173                    RAW_QFS_UNIX_INFO                      = SMB_QFS_UNIX_INFO,
1174                    RAW_QFS_VOLUME_INFORMATION             = SMB_QFS_VOLUME_INFORMATION,
1175                    RAW_QFS_SIZE_INFORMATION               = SMB_QFS_SIZE_INFORMATION,
1176                    RAW_QFS_DEVICE_INFORMATION             = SMB_QFS_DEVICE_INFORMATION,
1177                    RAW_QFS_ATTRIBUTE_INFORMATION          = SMB_QFS_ATTRIBUTE_INFORMATION,
1178                    RAW_QFS_QUOTA_INFORMATION              = SMB_QFS_QUOTA_INFORMATION,
1179                    RAW_QFS_FULL_SIZE_INFORMATION          = SMB_QFS_FULL_SIZE_INFORMATION,
1180                    RAW_QFS_OBJECTID_INFORMATION           = SMB_QFS_OBJECTID_INFORMATION};
1181
1182
1183 /* union for fsinfo() backend call. Note that there are no in
1184    structures, as this call only contains out parameters */
1185 union smb_fsinfo {
1186         /* generic interface */
1187         struct {
1188                 enum smb_fsinfo_level level;
1189                 struct smb2_handle handle; /* only for smb2 */
1190
1191                 struct {
1192                         uint32_t block_size;
1193                         uint64_t blocks_total;
1194                         uint64_t blocks_free;
1195                         uint32_t fs_id;
1196                         NTTIME create_time;
1197                         uint32_t serial_number;
1198                         uint32_t fs_attr;
1199                         uint32_t max_file_component_length;
1200                         uint32_t device_type;
1201                         uint32_t device_characteristics;
1202                         uint64_t quota_soft;
1203                         uint64_t quota_hard;
1204                         uint64_t quota_flags;
1205                         struct GUID guid;
1206                         char *volume_name;
1207                         char *fs_type;
1208                 } out;
1209         } generic;
1210
1211         /* SMBdskattr interface */
1212         struct {
1213                 enum smb_fsinfo_level level;
1214
1215                 struct {
1216                         uint16_t units_total;
1217                         uint16_t blocks_per_unit;
1218                         uint16_t block_size;
1219                         uint16_t units_free;
1220                 } out;
1221         } dskattr;
1222
1223         /* trans2 RAW_QFS_ALLOCATION interface */
1224         struct {
1225                 enum smb_fsinfo_level level;
1226
1227                 struct {
1228                         uint32_t fs_id;
1229                         uint32_t sectors_per_unit;
1230                         uint32_t total_alloc_units;
1231                         uint32_t avail_alloc_units;
1232                         uint16_t bytes_per_sector;
1233                 } out;
1234         } allocation;
1235
1236         /* TRANS2 RAW_QFS_VOLUME interface */
1237         struct {
1238                 enum smb_fsinfo_level level;
1239
1240                 struct {
1241                         uint32_t serial_number;
1242                         struct smb_wire_string volume_name;
1243                 } out;
1244         } volume;
1245
1246         /* TRANS2 RAW_QFS_VOLUME_INFO and RAW_QFS_VOLUME_INFORMATION interfaces */
1247         struct {
1248                 enum smb_fsinfo_level level;
1249                 struct smb2_handle handle; /* only for smb2 */
1250
1251                 struct {
1252                         NTTIME create_time;
1253                         uint32_t serial_number;
1254                         struct smb_wire_string volume_name;
1255                 } out;
1256         } volume_info;
1257
1258         /* trans2 RAW_QFS_SIZE_INFO and RAW_QFS_SIZE_INFORMATION interfaces */
1259         struct {
1260                 enum smb_fsinfo_level level;
1261                 struct smb2_handle handle; /* only for smb2 */
1262
1263                 struct {
1264                         uint64_t total_alloc_units;
1265                         uint64_t avail_alloc_units; /* maps to call_avail_alloc_units */
1266                         uint32_t sectors_per_unit;
1267                         uint32_t bytes_per_sector;
1268                 } out;
1269         } size_info;
1270
1271         /* TRANS2 RAW_QFS_DEVICE_INFO and RAW_QFS_DEVICE_INFORMATION interfaces */
1272         struct {
1273                 enum smb_fsinfo_level level;
1274                 struct smb2_handle handle; /* only for smb2 */
1275
1276                 struct {
1277                         uint32_t device_type;
1278                         uint32_t characteristics;
1279                 } out;
1280         } device_info;
1281
1282
1283         /* TRANS2 RAW_QFS_ATTRIBUTE_INFO and RAW_QFS_ATTRIBUTE_INFORMATION interfaces */
1284         struct {
1285                 enum smb_fsinfo_level level;
1286                 struct smb2_handle handle; /* only for smb2 */
1287
1288                 struct {
1289                         uint32_t fs_attr;
1290                         uint32_t max_file_component_length;
1291                         struct smb_wire_string fs_type;
1292                 } out;
1293         } attribute_info;
1294
1295
1296         /* TRANS2 RAW_QFS_UNIX_INFO interface */
1297         struct {
1298                 enum smb_fsinfo_level level;
1299
1300                 struct {
1301                         uint16_t major_version;
1302                         uint16_t minor_version;
1303                         uint64_t capability;
1304                 } out;
1305         } unix_info;
1306
1307         /* trans2 RAW_QFS_QUOTA_INFORMATION interface */
1308         struct {
1309                 enum smb_fsinfo_level level;
1310                 struct smb2_handle handle; /* only for smb2 */
1311
1312                 struct {
1313                         uint64_t unknown[3];
1314                         uint64_t quota_soft;
1315                         uint64_t quota_hard;
1316                         uint64_t quota_flags;
1317                 } out;
1318         } quota_information;
1319
1320         /* trans2 RAW_QFS_FULL_SIZE_INFORMATION interface */
1321         struct {
1322                 enum smb_fsinfo_level level;
1323                 struct smb2_handle handle; /* only for smb2 */
1324
1325                 struct {
1326                         uint64_t total_alloc_units;
1327                         uint64_t call_avail_alloc_units;
1328                         uint64_t actual_avail_alloc_units;
1329                         uint32_t sectors_per_unit;
1330                         uint32_t bytes_per_sector;
1331                 } out;
1332         } full_size_information;
1333
1334         /* trans2 RAW_QFS_OBJECTID_INFORMATION interface */
1335         struct {
1336                 enum smb_fsinfo_level level;
1337                 struct smb2_handle handle; /* only for smb2 */
1338
1339                 struct {
1340                         struct GUID  guid;
1341                         uint64_t unknown[6];
1342                 } out;
1343         } objectid_information;
1344 };
1345
1346
1347
1348 enum smb_open_level {
1349         RAW_OPEN_OPEN,
1350         RAW_OPEN_OPENX,
1351         RAW_OPEN_MKNEW,
1352         RAW_OPEN_CREATE,
1353         RAW_OPEN_CTEMP,
1354         RAW_OPEN_SPLOPEN,
1355         RAW_OPEN_NTCREATEX,
1356         RAW_OPEN_T2OPEN,
1357         RAW_OPEN_NTTRANS_CREATE,
1358         RAW_OPEN_OPENX_READX,
1359         RAW_OPEN_NTCREATEX_READX,
1360         RAW_OPEN_SMB2
1361 };
1362
1363 /* the generic interface is defined to be equal to the NTCREATEX interface */
1364 #define RAW_OPEN_GENERIC RAW_OPEN_NTCREATEX
1365
1366 /* union for open() backend call */
1367 union smb_open {
1368 /*
1369  * because the *.out.file structs are not aligned to the same offset for each level
1370  * we provide a hepler macro that should be used to find the current smb_handle structure
1371  */
1372 #define SMB_OPEN_OUT_FILE(op, file) do { \
1373         switch (op->generic.level) { \
1374         case RAW_OPEN_OPEN: \
1375                 file = &op->openold.out.file; \
1376                 break; \
1377         case RAW_OPEN_OPENX: \
1378                 file = &op->openx.out.file; \
1379                 break; \
1380         case RAW_OPEN_MKNEW: \
1381                 file = &op->mknew.out.file; \
1382                 break; \
1383         case RAW_OPEN_CREATE: \
1384                 file = &op->create.out.file; \
1385                 break; \
1386         case RAW_OPEN_CTEMP: \
1387                 file = &op->ctemp.out.file; \
1388                 break; \
1389         case RAW_OPEN_SPLOPEN: \
1390                 file = &op->splopen.out.file; \
1391                 break; \
1392         case RAW_OPEN_NTCREATEX: \
1393                 file = &op->ntcreatex.out.file; \
1394                 break; \
1395         case RAW_OPEN_T2OPEN: \
1396                 file = &op->t2open.out.file; \
1397                 break; \
1398         case RAW_OPEN_NTTRANS_CREATE: \
1399                 file = &op->nttrans.out.file; \
1400                 break; \
1401         case RAW_OPEN_OPENX_READX: \
1402                 file = &op->openxreadx.out.file; \
1403                 break; \
1404         case RAW_OPEN_NTCREATEX_READX: \
1405                 file = &op->ntcreatexreadx.out.file; \
1406                 break; \
1407         case RAW_OPEN_SMB2: \
1408                 file = &op->smb2.out.file; \
1409                 break; \
1410         default: \
1411                 /* this must be a programmer error */ \
1412                 file = NULL; \
1413                 break; \
1414         } \
1415 } while (0)
1416         /* SMBNTCreateX, nttrans and generic interface */
1417         struct {
1418                 enum smb_open_level level;
1419                 struct {
1420                         uint32_t flags;
1421                         union smb_handle root_fid;
1422                         uint32_t access_mask;
1423                         uint64_t alloc_size;
1424                         uint32_t file_attr;
1425                         uint32_t share_access;
1426                         uint32_t open_disposition;
1427                         uint32_t create_options;
1428                         uint32_t impersonation;
1429                         uint8_t  security_flags;
1430                         /* NOTE: fname can also be a pointer to a
1431                          uint64_t file_id if create_options has the
1432                          NTCREATEX_OPTIONS_OPEN_BY_FILE_ID flag set */
1433                         const char *fname;
1434
1435                         /* these last 2 elements are only used in the
1436                            NTTRANS varient of the call */
1437                         struct security_descriptor *sec_desc;
1438                         struct smb_ea_list *ea_list;
1439
1440                         /* some optional parameters from the SMB2 varient */
1441                         bool query_maximal_access;
1442
1443                         /* private flags for internal use only */
1444                         uint8_t private_flags;
1445                 } in;
1446                 struct {
1447                         union smb_handle file;
1448                         uint8_t oplock_level;
1449                         uint32_t create_action;
1450                         NTTIME create_time;
1451                         NTTIME access_time;
1452                         NTTIME write_time;
1453                         NTTIME change_time;
1454                         uint32_t attrib;
1455                         uint64_t alloc_size;
1456                         uint64_t size;
1457                         uint16_t file_type;
1458                         uint16_t ipc_state;
1459                         uint8_t  is_directory;
1460
1461                         /* optional return values matching SMB2 tagged
1462                            values in the call */
1463                         uint32_t maximal_access;
1464                 } out;
1465         } ntcreatex, nttrans, generic;
1466
1467         /* TRANS2_OPEN interface */
1468         struct {
1469                 enum smb_open_level level;
1470                 struct {
1471                         uint16_t flags;
1472                         uint16_t open_mode;
1473                         uint16_t search_attrs;
1474                         uint16_t file_attrs;
1475                         time_t write_time;
1476                         uint16_t open_func;
1477                         uint32_t size;
1478                         uint32_t timeout;
1479                         const char *fname;
1480                         unsigned int num_eas;
1481                         struct ea_struct *eas;
1482                 } in;
1483                 struct {
1484                         union smb_handle file;
1485                         uint16_t attrib;
1486                         time_t write_time;
1487                         uint32_t size;
1488                         uint16_t access;
1489                         uint16_t ftype;
1490                         uint16_t devstate;
1491                         uint16_t action;
1492                         uint32_t file_id;
1493                 } out;
1494         } t2open;
1495
1496         /* SMBopen interface */
1497         struct {
1498                 enum smb_open_level level;
1499                 struct {
1500                         uint16_t open_mode;
1501                         uint16_t search_attrs;
1502                         const char *fname;
1503                 } in;
1504                 struct {
1505                         union smb_handle file;
1506                         uint16_t attrib;
1507                         time_t write_time;
1508                         uint32_t size;
1509                         uint16_t rmode;
1510                 } out;
1511         } openold;
1512
1513         /* SMBopenX interface */
1514         struct {
1515                 enum smb_open_level level;
1516                 struct {
1517                         uint16_t flags;
1518                         uint16_t open_mode;
1519                         uint16_t search_attrs; /* not honoured by win2003 */
1520                         uint16_t file_attrs;
1521                         time_t write_time; /* not honoured by win2003 */
1522                         uint16_t open_func;
1523                         uint32_t size; /* note that this sets the
1524                                         initial file size, not
1525                                         just allocation size */
1526                         uint32_t timeout; /* not honoured by win2003 */
1527                         const char *fname;
1528                 } in;
1529                 struct {
1530                         union smb_handle file;
1531                         uint16_t attrib;
1532                         time_t write_time;
1533                         uint32_t size;
1534                         uint16_t access;
1535                         uint16_t ftype;
1536                         uint16_t devstate;
1537                         uint16_t action;
1538                         uint32_t unique_fid;
1539                         uint32_t access_mask;
1540                         uint32_t unknown;
1541                 } out;
1542         } openx;
1543
1544         /* SMBmknew interface */
1545         struct {
1546                 enum smb_open_level level;
1547                 struct {
1548                         uint16_t attrib;
1549                         time_t write_time;
1550                         const char *fname;
1551                 } in;
1552                 struct {
1553                         union smb_handle file;
1554                 } out;
1555         } mknew, create;
1556
1557         /* SMBctemp interface */
1558         struct {
1559                 enum smb_open_level level;
1560                 struct {
1561                         uint16_t attrib;
1562                         time_t write_time;
1563                         const char *directory;
1564                 } in;
1565                 struct {
1566                         union smb_handle file;
1567                         /* temp name, relative to directory */
1568                         char *name;
1569                 } out;
1570         } ctemp;
1571
1572         /* SMBsplopen interface */
1573         struct {
1574                 enum smb_open_level level;
1575                 struct {
1576                         uint16_t setup_length;
1577                         uint16_t mode;
1578                         const char *ident;
1579                 } in;
1580                 struct {
1581                         union smb_handle file;
1582                 } out;
1583         } splopen;
1584
1585
1586         /* chained OpenX/ReadX interface */
1587         struct {
1588                 enum smb_open_level level;
1589                 struct {
1590                         uint16_t flags;
1591                         uint16_t open_mode;
1592                         uint16_t search_attrs; /* not honoured by win2003 */
1593                         uint16_t file_attrs;
1594                         time_t write_time; /* not honoured by win2003 */
1595                         uint16_t open_func;
1596                         uint32_t size; /* note that this sets the
1597                                         initial file size, not
1598                                         just allocation size */
1599                         uint32_t timeout; /* not honoured by win2003 */
1600                         const char *fname;
1601
1602                         /* readx part */
1603                         uint64_t offset;
1604                         uint16_t mincnt;
1605                         uint32_t maxcnt;
1606                         uint16_t remaining;
1607                 } in;
1608                 struct {
1609                         union smb_handle file;
1610                         uint16_t attrib;
1611                         time_t write_time;
1612                         uint32_t size;
1613                         uint16_t access;
1614                         uint16_t ftype;
1615                         uint16_t devstate;
1616                         uint16_t action;
1617                         uint32_t unique_fid;
1618                         uint32_t access_mask;
1619                         uint32_t unknown;
1620
1621                         /* readx part */
1622                         uint8_t *data;
1623                         uint16_t remaining;
1624                         uint16_t compaction_mode;
1625                         uint16_t nread;
1626                 } out;
1627         } openxreadx;
1628
1629         /* chained NTCreateX/ReadX interface */
1630         struct {
1631                 enum smb_open_level level;
1632                 struct {
1633                         uint32_t flags;
1634                         union smb_handle root_fid;
1635                         uint32_t access_mask;
1636                         uint64_t alloc_size;
1637                         uint32_t file_attr;
1638                         uint32_t share_access;
1639                         uint32_t open_disposition;
1640                         uint32_t create_options;
1641                         uint32_t impersonation;
1642                         uint8_t  security_flags;
1643                         /* NOTE: fname can also be a pointer to a
1644                          uint64_t file_id if create_options has the
1645                          NTCREATEX_OPTIONS_OPEN_BY_FILE_ID flag set */
1646                         const char *fname;
1647
1648                         /* readx part */
1649                         uint64_t offset;
1650                         uint16_t mincnt;
1651                         uint32_t maxcnt;
1652                         uint16_t remaining;
1653                 } in;
1654                 struct {
1655                         union smb_handle file;
1656                         uint8_t oplock_level;
1657                         uint32_t create_action;
1658                         NTTIME create_time;
1659                         NTTIME access_time;
1660                         NTTIME write_time;
1661                         NTTIME change_time;
1662                         uint32_t attrib;
1663                         uint64_t alloc_size;
1664                         uint64_t size;
1665                         uint16_t file_type;
1666                         uint16_t ipc_state;
1667                         uint8_t  is_directory;
1668
1669                         /* readx part */
1670                         uint8_t *data;
1671                         uint16_t remaining;
1672                         uint16_t compaction_mode;
1673                         uint16_t nread;
1674                 } out;
1675         } ntcreatexreadx;
1676
1677 #define SMB2_CREATE_FLAG_REQUEST_OPLOCK           0x0100
1678 #define SMB2_CREATE_FLAG_REQUEST_EXCLUSIVE_OPLOCK 0x0800
1679 #define SMB2_CREATE_FLAG_GRANT_OPLOCK             0x0001
1680 #define SMB2_CREATE_FLAG_GRANT_EXCLUSIVE_OPLOCK   0x0080
1681
1682         /* SMB2 Create */
1683         struct smb2_create {
1684                 enum smb_open_level level;
1685                 struct {
1686                         /* static body buffer 56 (0x38) bytes */
1687                         uint8_t  security_flags;      /* SMB2_SECURITY_* */
1688                         uint8_t  oplock_level;        /* SMB2_OPLOCK_LEVEL_* */
1689                         uint32_t impersonation_level; /* SMB2_IMPERSONATION_* */
1690                         uint64_t create_flags;
1691                         uint64_t reserved;
1692                         uint32_t desired_access;
1693                         uint32_t file_attributes;
1694                         uint32_t share_access; /* NTCREATEX_SHARE_ACCESS_* */
1695                         uint32_t create_disposition; /* NTCREATEX_DISP_* */
1696                         uint32_t create_options; /* NTCREATEX_OPTIONS_* */
1697
1698                         /* uint16_t fname_ofs */
1699                         /* uint16_t fname_size */
1700                         /* uint32_t blob_ofs; */
1701                         /* uint32_t blob_size; */
1702
1703                         /* dynamic body */
1704                         const char *fname;
1705
1706                         /* now some optional parameters - encoded as tagged blobs */
1707                         struct smb_ea_list eas;
1708                         uint64_t alloc_size;
1709                         struct security_descriptor *sec_desc;
1710                         bool   durable_open;
1711                         struct smb2_handle *durable_handle;
1712                         bool   query_maximal_access;
1713                         NTTIME timewarp;
1714                         bool   query_on_disk_id;
1715                         struct smb2_lease *lease_request;
1716
1717                         /* and any additional blobs the caller wants */
1718                         struct smb2_create_blobs blobs;
1719                 } in;
1720                 struct {
1721                         union smb_handle file;
1722
1723                         /* static body buffer 88 (0x58) bytes */
1724                         /* uint16_t buffer_code;  0x59 = 0x58 + 1 */
1725                         uint8_t oplock_level;
1726                         uint8_t reserved;
1727                         uint32_t create_action;
1728                         NTTIME   create_time;
1729                         NTTIME   access_time;
1730                         NTTIME   write_time;
1731                         NTTIME   change_time;
1732                         uint64_t alloc_size;
1733                         uint64_t size;
1734                         uint32_t file_attr;
1735                         uint32_t reserved2;
1736                         /* struct smb2_handle handle;*/
1737                         /* uint32_t blob_ofs; */
1738                         /* uint32_t blob_size; */
1739
1740                         /* optional return values matching tagged values in the call */
1741                         uint32_t maximal_access;
1742                         uint8_t on_disk_id[32];
1743                         struct smb2_lease lease_response;
1744
1745                         /* tagged blobs in the reply */
1746                         struct smb2_create_blobs blobs;
1747                 } out;
1748         } smb2;
1749 };
1750
1751
1752
1753 enum smb_read_level {
1754         RAW_READ_READBRAW,
1755         RAW_READ_LOCKREAD,
1756         RAW_READ_READ,
1757         RAW_READ_READX,
1758         RAW_READ_SMB2
1759 };
1760
1761 #define RAW_READ_GENERIC RAW_READ_READX
1762
1763 /* union for read() backend call
1764
1765    note that .infoX.out.data will be allocated before the backend is
1766    called. It will be big enough to hold the maximum size asked for
1767 */
1768 union smb_read {
1769         /* SMBreadX (and generic) interface */
1770         struct {
1771                 enum smb_read_level level;
1772                 struct {
1773                         union smb_handle file;
1774                         uint64_t offset;
1775                         uint32_t mincnt; /* enforced on SMB2, 16 bit on SMB */
1776                         uint32_t maxcnt;
1777                         uint16_t remaining;
1778                         bool read_for_execute;
1779                 } in;
1780                 struct {
1781                         uint8_t *data;
1782                         uint16_t remaining;
1783                         uint16_t compaction_mode;
1784                         uint32_t nread;
1785                 } out;
1786         } readx, generic;
1787
1788         /* SMBreadbraw interface */
1789         struct {
1790                 enum smb_read_level level;
1791                 struct {
1792                         union smb_handle file;
1793                         uint64_t offset;
1794                         uint16_t  maxcnt;
1795                         uint16_t  mincnt;
1796                         uint32_t  timeout;
1797                 } in;
1798                 struct {
1799                         uint8_t *data;
1800                         uint32_t nread;
1801                 } out;
1802         } readbraw;
1803
1804
1805         /* SMBlockandread interface */
1806         struct {
1807                 enum smb_read_level level;
1808                 struct {
1809                         union smb_handle file;
1810                         uint16_t count;
1811                         uint32_t offset;
1812                         uint16_t remaining;
1813                 } in;
1814                 struct {
1815                         uint8_t *data;
1816                         uint16_t nread;
1817                 } out;
1818         } lockread;
1819
1820         /* SMBread interface */
1821         struct {
1822                 enum smb_read_level level;
1823                 struct {
1824                         union smb_handle file;
1825                         uint16_t count;
1826                         uint32_t offset;
1827                         uint16_t remaining;
1828                 } in;
1829                 struct {
1830                         uint8_t *data;
1831                         uint16_t nread;
1832                 } out;
1833         } read;
1834
1835         /* SMB2 Read */
1836         struct smb2_read {
1837                 enum smb_read_level level;
1838                 struct {
1839                         union smb_handle file;
1840
1841                         /* static body buffer 48 (0x30) bytes */
1842                         /* uint16_t buffer_code;  0x31 = 0x30 + 1 */
1843                         uint8_t _pad;
1844                         uint8_t reserved;
1845                         uint32_t length;
1846                         uint64_t offset;
1847                         /* struct smb2_handle handle; */
1848                         uint32_t min_count;
1849                         uint32_t channel;
1850                         uint32_t remaining;
1851                         /* the docs give no indication of what
1852                            these channel variables are for */
1853                         uint16_t channel_offset;
1854                         uint16_t channel_length;
1855                 } in;
1856                 struct {
1857                         /* static body buffer 16 (0x10) bytes */
1858                         /* uint16_t buffer_code;  0x11 = 0x10 + 1 */
1859                         /* uint8_t data_ofs; */
1860                         /* uint8_t reserved; */
1861                         /* uint32_t data_size; */
1862                         uint32_t remaining;
1863                         uint32_t reserved;
1864
1865                         /* dynamic body */
1866                         DATA_BLOB data;
1867                 } out;
1868         } smb2;
1869 };
1870
1871
1872 enum smb_write_level {
1873         RAW_WRITE_WRITEUNLOCK,
1874         RAW_WRITE_WRITE,
1875         RAW_WRITE_WRITEX,
1876         RAW_WRITE_WRITECLOSE,
1877         RAW_WRITE_SPLWRITE,
1878         RAW_WRITE_SMB2
1879 };
1880
1881 #define RAW_WRITE_GENERIC RAW_WRITE_WRITEX
1882
1883 /* union for write() backend call
1884 */
1885 union smb_write {
1886         /* SMBwriteX interface */
1887         struct {
1888                 enum smb_write_level level;
1889                 struct {
1890                         union smb_handle file;
1891                         uint64_t offset;
1892                         uint16_t wmode;
1893                         uint16_t remaining;
1894                         uint32_t count;
1895                         const uint8_t *data;
1896                 } in;
1897                 struct {
1898                         uint32_t nwritten;
1899                         uint16_t remaining;
1900                 } out;
1901         } writex, generic;
1902
1903         /* SMBwriteunlock interface */
1904         struct {
1905                 enum smb_write_level level;
1906                 struct {
1907                         union smb_handle file;
1908                         uint16_t count;
1909                         uint32_t offset;
1910                         uint16_t remaining;
1911                         const uint8_t *data;
1912                 } in;
1913                 struct {
1914                         uint32_t nwritten;
1915                 } out;
1916         } writeunlock;
1917
1918         /* SMBwrite interface */
1919         struct {
1920                 enum smb_write_level level;
1921                 struct {
1922                         union smb_handle file;
1923                         uint16_t count;
1924                         uint32_t offset;
1925                         uint16_t remaining;
1926                         const uint8_t *data;
1927                 } in;
1928                 struct {
1929                         uint16_t nwritten;
1930                 } out;
1931         } write;
1932
1933         /* SMBwriteclose interface */
1934         struct {
1935                 enum smb_write_level level;
1936                 struct {
1937                         union smb_handle file;
1938                         uint16_t count;
1939                         uint32_t offset;
1940                         time_t mtime;
1941                         const uint8_t *data;
1942                 } in;
1943                 struct {
1944                         uint16_t nwritten;
1945                 } out;
1946         } writeclose;
1947
1948         /* SMBsplwrite interface */
1949         struct {
1950                 enum smb_write_level level;
1951                 struct {
1952                         union smb_handle file;
1953                         uint16_t count;
1954                         const uint8_t *data;
1955                 } in;
1956         } splwrite;
1957
1958         /* SMB2 Write */
1959         struct smb2_write {
1960                 enum smb_write_level level;
1961                 struct {
1962                         union smb_handle file;
1963
1964                         /* static body buffer 48 (0x30) bytes */
1965                         /* uint16_t buffer_code;  0x31 = 0x30 + 1 */
1966                         /* uint16_t data_ofs; */
1967                         /* uint32_t data_size; */
1968                         uint64_t offset;
1969                         /* struct smb2_handle handle; */
1970                         uint64_t unknown1; /* 0xFFFFFFFFFFFFFFFF */
1971                         uint64_t unknown2; /* 0xFFFFFFFFFFFFFFFF */
1972
1973                         /* dynamic body */
1974                         DATA_BLOB data;
1975                 } in;
1976                 struct {
1977                         /* static body buffer 17 (0x11) bytes */
1978                         /* uint16_t buffer_code;  0x11 = 0x10 + 1*/
1979                         uint16_t _pad;
1980                         uint32_t nwritten;
1981                         uint64_t unknown1; /* 0x0000000000000000 */
1982                 } out;
1983         } smb2;
1984 };
1985
1986
1987 enum smb_lock_level {
1988         RAW_LOCK_LOCK,
1989         RAW_LOCK_UNLOCK,
1990         RAW_LOCK_LOCKX,
1991         RAW_LOCK_SMB2,
1992         RAW_LOCK_SMB2_BREAK
1993 };
1994
1995 #define RAW_LOCK_GENERIC RAW_LOCK_LOCKX
1996
1997 /* union for lock() backend call
1998 */
1999 union smb_lock {
2000         /* SMBlockingX and generic interface */
2001         struct {
2002                 enum smb_lock_level level;
2003                 struct {
2004                         union smb_handle file;
2005                         uint16_t mode;
2006                         uint32_t timeout;
2007                         uint16_t ulock_cnt;
2008                         uint16_t lock_cnt;
2009                         struct smb_lock_entry {
2010                                 uint32_t pid; /* 16 bits in SMB1 */
2011                                 uint64_t offset;
2012                                 uint64_t count;
2013                         } *locks; /* unlocks are first in the arrray */
2014                 } in;
2015         } generic, lockx;
2016
2017         /* SMBlock and SMBunlock interface */
2018         struct {
2019                 enum smb_lock_level level;
2020                 struct {
2021                         union smb_handle file;
2022                         uint32_t count;
2023                         uint32_t offset;
2024                 } in;
2025         } lock, unlock;
2026
2027         /* SMB2 Lock */
2028         struct smb2_lock {
2029                 enum smb_lock_level level;
2030                 struct {
2031                         union smb_handle file;
2032
2033                         /* static body buffer 48 (0x30) bytes */
2034                         /* uint16_t buffer_code;  0x30 */
2035                         uint16_t lock_count;
2036                         uint32_t lock_sequence;
2037                         /* struct smb2_handle handle; */
2038                         struct smb2_lock_element {
2039                                 uint64_t offset;
2040                                 uint64_t length;
2041                                 uint32_t flags;
2042                                 uint32_t reserved;
2043                         } *locks;
2044                 } in;
2045                 struct {
2046                         /* static body buffer 4 (0x04) bytes */
2047                         /* uint16_t buffer_code;  0x04 */
2048                         uint16_t reserved;
2049                 } out;
2050         } smb2;
2051
2052         /* SMB2 Break */
2053         struct smb2_break {
2054                 enum smb_lock_level level;
2055                 struct {
2056                         union smb_handle file;
2057
2058                         /* static body buffer 24 (0x18) bytes */
2059                         uint8_t oplock_level;
2060                         uint8_t reserved;
2061                         uint32_t reserved2;
2062                         /* struct smb2_handle handle; */
2063                 } in, out;
2064         } smb2_break;
2065
2066         /* SMB2 Lease Break Ack (same opcode as smb2_break) */
2067         struct smb2_lease_break_ack {
2068                 struct {
2069                         uint32_t reserved;
2070                         struct smb2_lease lease;
2071                 } in, out;
2072         } smb2_lease_break_ack;
2073 };
2074
2075
2076 enum smb_close_level {
2077         RAW_CLOSE_CLOSE,
2078         RAW_CLOSE_SPLCLOSE,
2079         RAW_CLOSE_SMB2,
2080         RAW_CLOSE_GENERIC,
2081 };
2082
2083 /*
2084   union for close() backend call
2085 */
2086 union smb_close {
2087         /* generic interface */
2088         struct {
2089                 enum smb_close_level level;
2090                 struct {
2091                         union smb_handle file;
2092                         time_t write_time;
2093                         uint16_t flags; /* SMB2_CLOSE_FLAGS_* */
2094                 } in;
2095                 struct {
2096                         uint16_t flags;
2097                         NTTIME   create_time;
2098                         NTTIME   access_time;
2099                         NTTIME   write_time;
2100                         NTTIME   change_time;
2101                         uint64_t alloc_size;
2102                         uint64_t size;
2103                         uint32_t file_attr;
2104                 } out;
2105         } generic;
2106
2107         /* SMBclose interface */
2108         struct {
2109                 enum smb_close_level level;
2110                 struct {
2111                         union smb_handle file;
2112                         time_t write_time;
2113                 } in;
2114         } close;
2115
2116         /* SMBsplclose interface - empty! */
2117         struct {
2118                 enum smb_close_level level;
2119                 struct {
2120                         union smb_handle file;
2121                 } in;
2122         } splclose;
2123
2124         /* SMB2 Close */
2125         struct smb2_close {
2126                 enum smb_close_level level;
2127                 struct {
2128                         union smb_handle file;
2129
2130                         /* static body buffer 24 (0x18) bytes */
2131                         /* uint16_t buffer_code;  0x18 */
2132                         uint16_t flags; /* SMB2_CLOSE_FLAGS_* */
2133                         uint32_t _pad;
2134                 } in;
2135                 struct {
2136                         /* static body buffer 60 (0x3C) bytes */
2137                         /* uint16_t buffer_code;  0x3C */
2138                         uint16_t flags;
2139                         uint32_t _pad;
2140                         NTTIME   create_time;
2141                         NTTIME   access_time;
2142                         NTTIME   write_time;
2143                         NTTIME   change_time;
2144                         uint64_t alloc_size;
2145                         uint64_t size;
2146                         uint32_t file_attr;
2147                 } out;
2148         } smb2;
2149 };
2150
2151
2152 enum smb_lpq_level {RAW_LPQ_GENERIC, RAW_LPQ_RETQ};
2153
2154 /*
2155   union for lpq() backend
2156 */
2157 union smb_lpq {
2158         /* generic interface */
2159         struct {
2160                 enum smb_lpq_level level;
2161
2162         } generic;
2163
2164
2165         /* SMBsplretq interface */
2166         struct {
2167                 enum smb_lpq_level level;
2168
2169                 struct {
2170                         uint16_t maxcount;
2171                         uint16_t startidx;
2172                 } in;
2173                 struct {
2174                         uint16_t count;
2175                         uint16_t restart_idx;
2176                         struct {
2177                                 time_t time;
2178                                 uint8_t status;
2179                                 uint16_t job;
2180                                 uint32_t size;
2181                                 char *user;
2182                         } *queue;
2183                 } out;
2184         } retq;
2185 };
2186
2187 enum smb_ioctl_level {
2188         RAW_IOCTL_IOCTL,
2189         RAW_IOCTL_NTIOCTL,
2190         RAW_IOCTL_SMB2,
2191         RAW_IOCTL_SMB2_NO_HANDLE
2192 };
2193
2194 /*
2195   union for ioctl() backend
2196 */
2197 union smb_ioctl {
2198         /* generic interface */
2199         struct {
2200                 enum smb_ioctl_level level;
2201                 struct {
2202                         union smb_handle file;
2203                 } in;
2204         } generic;
2205
2206         /* struct for SMBioctl */
2207         struct {
2208                 enum smb_ioctl_level level;
2209                 struct {
2210                         union smb_handle file;
2211                         uint32_t request;
2212                 } in;
2213                 struct {
2214                         DATA_BLOB blob;
2215                 } out;
2216         } ioctl;
2217
2218
2219         /* struct for NT ioctl call */
2220         struct {
2221                 enum smb_ioctl_level level;
2222                 struct {
2223                         union smb_handle file;
2224                         uint32_t function;
2225                         bool fsctl;
2226                         uint8_t filter;
2227                         uint32_t max_data;
2228                         DATA_BLOB blob;
2229                 } in;
2230                 struct {
2231                         DATA_BLOB blob;
2232                 } out;
2233         } ntioctl;
2234
2235         /* SMB2 Ioctl */
2236         struct smb2_ioctl {
2237                 enum smb_ioctl_level level;
2238                 struct {
2239                         union smb_handle file;
2240
2241                         /* static body buffer 56 (0x38) bytes */
2242                         /* uint16_t buffer_code;  0x39 = 0x38 + 1 */
2243                         uint16_t _pad;
2244                         uint32_t function;
2245                         /*struct smb2_handle handle;*/
2246                         /* uint32_t out_ofs; */
2247                         /* uint32_t out_size; */
2248                         uint32_t unknown2;
2249                         /* uint32_t in_ofs; */
2250                         /* uint32_t in_size; */
2251                         uint32_t max_response_size;
2252                         uint64_t flags;
2253
2254                         /* dynamic body */
2255                         DATA_BLOB out;
2256                         DATA_BLOB in;
2257                 } in;
2258                 struct {
2259                         union smb_handle file;
2260
2261                         /* static body buffer 48 (0x30) bytes */
2262                         /* uint16_t buffer_code;  0x31 = 0x30 + 1 */
2263                         uint16_t _pad;
2264                         uint32_t function;
2265                         /* struct smb2_handle handle; */
2266                         /* uint32_t in_ofs; */
2267                         /* uint32_t in_size; */
2268                         /* uint32_t out_ofs; */
2269                         /* uint32_t out_size; */
2270                         uint32_t unknown2;
2271                         uint32_t unknown3;
2272
2273                         /* dynamic body */
2274                         DATA_BLOB in;
2275                         DATA_BLOB out;
2276                 } out;
2277         } smb2;
2278 };
2279
2280 enum smb_flush_level {
2281         RAW_FLUSH_FLUSH,
2282         RAW_FLUSH_ALL,
2283         RAW_FLUSH_SMB2
2284 };
2285
2286 union smb_flush {
2287         /* struct for SMBflush */
2288         struct {
2289                 enum smb_flush_level level;
2290                 struct {
2291                         union smb_handle file;
2292                 } in;
2293         } flush, generic;
2294
2295         /* SMBflush with 0xFFFF wildcard fnum */
2296         struct {
2297                 enum smb_flush_level level;
2298         } flush_all;
2299
2300         /* SMB2 Flush */
2301         struct smb2_flush {
2302                 enum smb_flush_level level;
2303                 struct {
2304                         union smb_handle file;
2305                         uint16_t reserved1;
2306                         uint32_t reserved2;
2307                 } in;
2308                 struct {
2309                         uint16_t reserved;
2310                 } out;
2311         } smb2;
2312 };
2313
2314 /* struct for SMBcopy */
2315 struct smb_copy {
2316         struct {
2317                 uint16_t tid2;
2318                 uint16_t ofun;
2319                 uint16_t flags;
2320                 const char *path1;
2321                 const char *path2;
2322         } in;
2323         struct {
2324                 uint16_t count;
2325         } out;
2326 };
2327
2328
2329 /* struct for transact/transact2 call */
2330 struct smb_trans2 {
2331         struct {
2332                 uint16_t max_param;
2333                 uint16_t max_data;
2334                 uint8_t  max_setup;
2335                 uint16_t flags;
2336                 uint32_t timeout;
2337                 uint8_t  setup_count;
2338                 uint16_t *setup;
2339                 const char *trans_name; /* SMBtrans only */
2340                 DATA_BLOB params;
2341                 DATA_BLOB data;
2342         } in;
2343
2344         struct {
2345                 uint8_t  setup_count;
2346                 uint16_t *setup;
2347                 DATA_BLOB params;
2348                 DATA_BLOB data;
2349         } out;
2350 };
2351
2352 /* struct for nttransact2 call */
2353 struct smb_nttrans {
2354         struct {
2355                 uint8_t  max_setup;
2356                 uint32_t max_param;
2357                 uint32_t max_data;
2358                 uint8_t setup_count;
2359                 uint16_t function;
2360                 uint8_t  *setup;
2361                 DATA_BLOB params;
2362                 DATA_BLOB data;
2363         } in;
2364
2365         struct {
2366                 uint8_t  setup_count; /* in units of 16 bit words */
2367                 uint8_t  *setup;
2368                 DATA_BLOB params;
2369                 DATA_BLOB data;
2370         } out;
2371 };
2372
2373 enum smb_notify_level {
2374         RAW_NOTIFY_NTTRANS,
2375         RAW_NOTIFY_SMB2
2376 };
2377
2378 union smb_notify {
2379         /* struct for nttrans change notify call */
2380         struct {
2381                 enum smb_notify_level level;
2382
2383                 struct {
2384                         union smb_handle file;
2385                         uint32_t buffer_size;
2386                         uint32_t completion_filter;
2387                         bool recursive;
2388                 } in;
2389
2390                 struct {
2391                         uint32_t num_changes;
2392                         struct notify_changes {
2393                                 uint32_t action;
2394                                 struct smb_wire_string name;
2395                         } *changes;
2396                 } out;
2397         } nttrans;
2398
2399         struct smb2_notify {
2400                 enum smb_notify_level level;
2401
2402                 struct {
2403                         union smb_handle file;
2404                         /* static body buffer 32 (0x20) bytes */
2405                         /* uint16_t buffer_code;  0x32 */
2406                         uint16_t recursive;
2407                         uint32_t buffer_size;
2408                         /*struct  smb2_handle file;*/
2409                         uint32_t completion_filter;
2410                         uint32_t unknown;
2411                 } in;
2412
2413                 struct {
2414                         /* static body buffer 8 (0x08) bytes */
2415                         /* uint16_t buffer_code; 0x09 = 0x08 + 1 */
2416                         /* uint16_t blob_ofs; */
2417                         /* uint16_t blob_size; */
2418
2419                         /* dynamic body */
2420                         /*DATA_BLOB blob;*/
2421
2422                         /* DATA_BLOB content */
2423                         uint32_t num_changes;
2424                         struct notify_changes *changes;
2425                 } out;
2426         } smb2;
2427 };
2428
2429 enum smb_search_level {
2430         RAW_SEARCH_SEARCH,      /* SMBsearch */
2431         RAW_SEARCH_FFIRST,      /* SMBffirst */
2432         RAW_SEARCH_FUNIQUE,     /* SMBfunique */
2433         RAW_SEARCH_TRANS2,      /* SMBtrans2 */
2434         RAW_SEARCH_SMB2         /* SMB2 Find */
2435 };
2436
2437 enum smb_search_data_level {
2438         RAW_SEARCH_DATA_GENERIC                 = 0x10000, /* only used in the smbcli_ code */
2439         RAW_SEARCH_DATA_SEARCH,
2440         RAW_SEARCH_DATA_STANDARD                = SMB_FIND_STANDARD,
2441         RAW_SEARCH_DATA_EA_SIZE                 = SMB_FIND_EA_SIZE,
2442         RAW_SEARCH_DATA_EA_LIST                 = SMB_FIND_EA_LIST,
2443         RAW_SEARCH_DATA_DIRECTORY_INFO          = SMB_FIND_DIRECTORY_INFO,
2444         RAW_SEARCH_DATA_FULL_DIRECTORY_INFO     = SMB_FIND_FULL_DIRECTORY_INFO,
2445         RAW_SEARCH_DATA_NAME_INFO               = SMB_FIND_NAME_INFO,
2446         RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO     = SMB_FIND_BOTH_DIRECTORY_INFO,
2447         RAW_SEARCH_DATA_ID_FULL_DIRECTORY_INFO  = SMB_FIND_ID_FULL_DIRECTORY_INFO,
2448         RAW_SEARCH_DATA_ID_BOTH_DIRECTORY_INFO  = SMB_FIND_ID_BOTH_DIRECTORY_INFO,
2449         RAW_SEARCH_DATA_UNIX_INFO               = SMB_FIND_UNIX_INFO,
2450         RAW_SEARCH_DATA_UNIX_INFO2              = SMB_FIND_UNIX_INFO2
2451 };
2452
2453 /* union for file search */
2454 union smb_search_first {
2455         struct {
2456                 enum smb_search_level level;
2457                 enum smb_search_data_level data_level;
2458         } generic;
2459
2460         /* search (old) findfirst interface.
2461            Also used for ffirst and funique. */
2462         struct {
2463                 enum smb_search_level level;
2464                 enum smb_search_data_level data_level;
2465
2466                 struct {
2467                         uint16_t max_count;
2468                         uint16_t search_attrib;
2469                         const char *pattern;
2470                 } in;
2471                 struct {
2472                         int16_t count;
2473                 } out;
2474         } search_first;
2475
2476         /* trans2 findfirst interface */
2477         struct {
2478                 enum smb_search_level level;
2479                 enum smb_search_data_level data_level;
2480
2481                 struct {
2482                         uint16_t search_attrib;
2483                         uint16_t max_count;
2484                         uint16_t flags;
2485                         uint32_t storage_type;
2486                         const char *pattern;
2487
2488                         /* the ea names are only used for RAW_SEARCH_EA_LIST */
2489                         unsigned int num_names;
2490                         struct ea_name *ea_names;
2491                 } in;
2492                 struct {
2493                         uint16_t handle;
2494                         uint16_t count;
2495                         uint16_t end_of_search;
2496                 } out;
2497         } t2ffirst;
2498
2499         /* SMB2 Find */
2500         struct smb2_find {
2501                 enum smb_search_level level;
2502                 enum smb_search_data_level data_level;
2503                 struct {
2504                         union smb_handle file;
2505
2506                         /* static body buffer 32 (0x20) bytes */
2507                         /* uint16_t buffer_code;  0x21 = 0x20 + 1 */
2508                         uint8_t level;
2509                         uint8_t continue_flags; /* SMB2_CONTINUE_FLAG_* */
2510                         uint32_t file_index;
2511                         /* struct smb2_handle handle; */
2512                         /* uint16_t pattern_ofs; */
2513                         /* uint16_t pattern_size; */
2514                         uint32_t max_response_size;
2515
2516                         /* dynamic body */
2517                         const char *pattern;
2518                 } in;
2519                 struct {
2520                         /* static body buffer 8 (0x08) bytes */
2521                         /* uint16_t buffer_code;  0x08 */
2522                         /* uint16_t blob_ofs; */
2523                         /* uint32_t blob_size; */
2524
2525                         /* dynamic body */
2526                         DATA_BLOB blob;
2527                 } out;
2528         } smb2;
2529 };
2530
2531 /* union for file search continue */
2532 union smb_search_next {
2533         struct {
2534                 enum smb_search_level level;
2535                 enum smb_search_data_level data_level;
2536         } generic;
2537
2538         /* search (old) findnext interface. Also used
2539            for ffirst when continuing */
2540         struct {
2541                 enum smb_search_level level;
2542                 enum smb_search_data_level data_level;
2543
2544                 struct {
2545                         uint16_t max_count;
2546                         uint16_t search_attrib;
2547                         struct smb_search_id {
2548                                 uint8_t reserved;
2549                                 char name[11];
2550                                 uint8_t handle;
2551                                 uint32_t server_cookie;
2552                                 uint32_t client_cookie;
2553                         } id;
2554                 } in;
2555                 struct {
2556                         uint16_t count;
2557                 } out;
2558         } search_next;
2559
2560         /* trans2 findnext interface */
2561         struct {
2562                 enum smb_search_level level;
2563                 enum smb_search_data_level data_level;
2564
2565                 struct {
2566                         uint16_t handle;
2567                         uint16_t max_count;
2568                         uint32_t resume_key;
2569                         uint16_t flags;
2570                         const char *last_name;
2571
2572                         /* the ea names are only used for RAW_SEARCH_EA_LIST */
2573                         unsigned int num_names;
2574                         struct ea_name *ea_names;
2575                 } in;
2576                 struct {
2577                         uint16_t count;
2578                         uint16_t end_of_search;
2579                 } out;
2580         } t2fnext;
2581
2582         /* SMB2 Find */
2583         struct smb2_find smb2;
2584 };
2585
2586 /* union for search reply file data */
2587 union smb_search_data {
2588         /*
2589          * search (old) findfirst
2590          * RAW_SEARCH_DATA_SEARCH
2591          */
2592         struct {
2593                 uint16_t attrib;
2594                 time_t write_time;
2595                 uint32_t size;
2596                 struct smb_search_id id;
2597                 const char *name;
2598         } search;
2599
2600         /* trans2 findfirst RAW_SEARCH_DATA_STANDARD level */
2601         struct {
2602                 uint32_t resume_key;
2603                 time_t create_time;
2604                 time_t access_time;
2605                 time_t write_time;
2606                 uint32_t size;
2607                 uint32_t alloc_size;
2608                 uint16_t attrib;
2609                 struct smb_wire_string name;
2610         } standard;
2611
2612         /* trans2 findfirst RAW_SEARCH_DATA_EA_SIZE level */
2613         struct {
2614                 uint32_t resume_key;
2615                 time_t create_time;
2616                 time_t access_time;
2617                 time_t write_time;
2618                 uint32_t size;
2619                 uint32_t alloc_size;
2620                 uint16_t attrib;
2621                 uint32_t ea_size;
2622                 struct smb_wire_string name;
2623         } ea_size;
2624
2625         /* trans2 findfirst RAW_SEARCH_DATA_EA_LIST level */
2626         struct {
2627                 uint32_t resume_key;
2628                 time_t create_time;
2629                 time_t access_time;
2630                 time_t write_time;
2631                 uint32_t size;
2632                 uint32_t alloc_size;
2633                 uint16_t attrib;
2634                 struct smb_ea_list eas;
2635                 struct smb_wire_string name;
2636         } ea_list;
2637
2638         /* RAW_SEARCH_DATA_DIRECTORY_INFO interface */
2639         struct {
2640                 uint32_t file_index;
2641                 NTTIME create_time;
2642                 NTTIME access_time;
2643                 NTTIME write_time;
2644                 NTTIME change_time;
2645                 uint64_t  size;
2646                 uint64_t  alloc_size;
2647                 uint32_t   attrib;
2648                 struct smb_wire_string name;
2649         } directory_info;
2650
2651         /* RAW_SEARCH_DATA_FULL_DIRECTORY_INFO interface */
2652         struct {
2653                 uint32_t file_index;
2654                 NTTIME create_time;
2655                 NTTIME access_time;
2656                 NTTIME write_time;
2657                 NTTIME change_time;
2658                 uint64_t  size;
2659                 uint64_t  alloc_size;
2660                 uint32_t   attrib;
2661                 uint32_t   ea_size;
2662                 struct smb_wire_string name;
2663         } full_directory_info;
2664
2665         /* RAW_SEARCH_DATA_NAME_INFO interface */
2666         struct {
2667                 uint32_t file_index;
2668                 struct smb_wire_string name;
2669         } name_info;
2670
2671         /* RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO interface */
2672         struct {
2673                 uint32_t file_index;
2674                 NTTIME create_time;
2675                 NTTIME access_time;
2676                 NTTIME write_time;
2677                 NTTIME change_time;
2678                 uint64_t  size;
2679                 uint64_t  alloc_size;
2680                 uint32_t   attrib;
2681                 uint32_t   ea_size;
2682                 struct smb_wire_string short_name;
2683                 struct smb_wire_string name;
2684         } both_directory_info;
2685
2686         /* RAW_SEARCH_DATA_ID_FULL_DIRECTORY_INFO interface */
2687         struct {
2688                 uint32_t file_index;
2689                 NTTIME create_time;
2690                 NTTIME access_time;
2691                 NTTIME write_time;
2692                 NTTIME change_time;
2693                 uint64_t size;
2694                 uint64_t alloc_size;
2695                 uint32_t attrib;
2696                 uint32_t ea_size;
2697                 uint64_t file_id;
2698                 struct smb_wire_string name;
2699         } id_full_directory_info;
2700
2701         /* RAW_SEARCH_DATA_ID_BOTH_DIRECTORY_INFO interface */
2702         struct {
2703                 uint32_t file_index;
2704                 NTTIME create_time;
2705                 NTTIME access_time;
2706                 NTTIME write_time;
2707                 NTTIME change_time;
2708                 uint64_t size;
2709                 uint64_t alloc_size;
2710                 uint32_t  attrib;
2711                 uint32_t  ea_size;
2712                 uint64_t file_id;
2713                 struct smb_wire_string short_name;
2714                 struct smb_wire_string name;
2715         } id_both_directory_info;
2716
2717         /* RAW_SEARCH_DATA_UNIX_INFO interface */
2718         struct {
2719                 uint32_t file_index;
2720                 uint64_t size;
2721                 uint64_t alloc_size;
2722                 NTTIME status_change_time;
2723                 NTTIME access_time;
2724                 NTTIME change_time;
2725                 uint64_t uid;
2726                 uint64_t gid;
2727                 uint32_t file_type;
2728                 uint64_t dev_major;
2729                 uint64_t dev_minor;
2730                 uint64_t unique_id;
2731                 uint64_t permissions;
2732                 uint64_t nlink;
2733                 const char *name;
2734         } unix_info;
2735
2736         /* RAW_SEARCH_DATA_UNIX_INFO2 interface */
2737         struct {
2738                 uint32_t file_index;
2739                 uint64_t end_of_file;
2740                 uint64_t num_bytes;
2741                 NTTIME status_change_time;
2742                 NTTIME access_time;
2743                 NTTIME change_time;
2744                 uint64_t uid;
2745                 uint64_t gid;
2746                 uint32_t file_type;
2747                 uint64_t dev_major;
2748                 uint64_t dev_minor;
2749                 uint64_t unique_id;
2750                 uint64_t permissions;
2751                 uint64_t nlink;
2752                 NTTIME create_time;
2753                 uint32_t file_flags;
2754                 uint32_t flags_mask;
2755                 struct smb_wire_string name;
2756         } unix_info2;
2757 };
2758
2759 /* Callback function passed to the raw search interface. */
2760 typedef bool (*smbcli_search_callback)(void *private_data, const union smb_search_data *file);
2761
2762 enum smb_search_close_level {RAW_FINDCLOSE_GENERIC, RAW_FINDCLOSE_FCLOSE, RAW_FINDCLOSE_FINDCLOSE};
2763
2764 /* union for file search close */
2765 union smb_search_close {
2766         struct {
2767                 enum smb_search_close_level level;
2768         } generic;
2769
2770         /* SMBfclose (old search) interface */
2771         struct {
2772                 enum smb_search_close_level level;
2773
2774                 struct {
2775                         /* max_count and search_attrib are not used, but are present */
2776                         uint16_t max_count;
2777                         uint16_t search_attrib;
2778                         struct smb_search_id id;
2779                 } in;
2780         } fclose;
2781
2782         /* SMBfindclose interface */
2783         struct {
2784                 enum smb_search_close_level level;
2785
2786                 struct {
2787                         uint16_t handle;
2788                 } in;
2789         } findclose;
2790 };
2791
2792
2793 /*
2794   struct for SMBecho call
2795 */
2796 struct smb_echo {
2797         struct {
2798                 uint16_t repeat_count;
2799                 uint16_t size;
2800                 uint8_t *data;
2801         } in;
2802         struct {
2803                 uint16_t count;
2804                 uint16_t sequence_number;
2805                 uint16_t size;
2806                 uint8_t *data;
2807         } out;
2808 };
2809
2810 /*
2811   struct for shadow copy volumes
2812  */
2813 struct smb_shadow_copy {
2814         struct {
2815                 union smb_handle file;
2816                 uint32_t max_data;
2817         } in;
2818         struct {
2819                 uint32_t num_volumes;
2820                 uint32_t num_names;
2821                 const char **names;
2822         } out;
2823 };
2824
2825 #endif /* __LIBCLI_RAW_INTERFACES_H__ */