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                         uint_t 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                         uint_t 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                         uint_t 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                         uint_t num_names;
 582                         struct ea_name {
 583                                 struct smb_wire_string name;
 584                         } *ea_names;
 585                 } in;
 586
 587                 struct smb_ea_list {
 588                         uint_t 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                         uint_t 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_SFILEINFO_UNIX_LINK,
 928         RAW_SFILEINFO_UNIX_HLINK              = SMB_SFILEINFO_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                         uint_t 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_SMB2
1360 };
1361
1362 /* the generic interface is defined to be equal to the NTCREATEX interface */
1363 #define RAW_OPEN_GENERIC RAW_OPEN_NTCREATEX
1364
1365 /* union for open() backend call */
1366 union smb_open {
1367 /*
1368  * because the *.out.file structs are not aligned to the same offset for each level
1369  * we provide a hepler macro that should be used to find the current smb_handle structure
1370  */
1371 #define SMB_OPEN_OUT_FILE(op, file) do { \
1372         switch (op->generic.level) { \
1373         case RAW_OPEN_OPEN: \
1374                 file = &op->openold.out.file; \
1375                 break; \
1376         case RAW_OPEN_OPENX: \
1377                 file = &op->openx.out.file; \
1378                 break; \
1379         case RAW_OPEN_MKNEW: \
1380                 file = &op->mknew.out.file; \
1381                 break; \
1382         case RAW_OPEN_CREATE: \
1383                 file = &op->create.out.file; \
1384                 break; \
1385         case RAW_OPEN_CTEMP: \
1386                 file = &op->ctemp.out.file; \
1387                 break; \
1388         case RAW_OPEN_SPLOPEN: \
1389                 file = &op->splopen.out.file; \
1390                 break; \
1391         case RAW_OPEN_NTCREATEX: \
1392                 file = &op->ntcreatex.out.file; \
1393                 break; \
1394         case RAW_OPEN_T2OPEN: \
1395                 file = &op->t2open.out.file; \
1396                 break; \
1397         case RAW_OPEN_NTTRANS_CREATE: \
1398                 file = &op->nttrans.out.file; \
1399                 break; \
1400         case RAW_OPEN_OPENX_READX: \
1401                 file = &op->openxreadx.out.file; \
1402                 break; \
1403         case RAW_OPEN_SMB2: \
1404                 file = &op->smb2.out.file; \
1405                 break; \
1406         default: \
1407                 /* this must be a programmer error */ \
1408                 file = NULL; \
1409                 break; \
1410         } \
1411 } while (0)
1412         /* SMBNTCreateX, nttrans and generic interface */
1413         struct {
1414                 enum smb_open_level level;
1415                 struct {
1416                         uint32_t flags;
1417                         uint32_t root_fid;
1418                         uint32_t access_mask;
1419                         uint64_t alloc_size;
1420                         uint32_t file_attr;
1421                         uint32_t share_access;
1422                         uint32_t open_disposition;
1423                         uint32_t create_options;
1424                         uint32_t impersonation;
1425                         uint8_t  security_flags;
1426                         /* NOTE: fname can also be a pointer to a
1427                          uint64_t file_id if create_options has the
1428                          NTCREATEX_OPTIONS_OPEN_BY_FILE_ID flag set */
1429                         const char *fname;
1430
1431                         /* these last 2 elements are only used in the
1432                            NTTRANS varient of the call */
1433                         struct security_descriptor *sec_desc;
1434                         struct smb_ea_list *ea_list;
1435
1436                         /* some optional parameters from the SMB2 varient */
1437                         bool query_maximal_access;
1438                 } in;
1439                 struct {
1440                         union smb_handle file;
1441                         uint8_t oplock_level;
1442                         uint32_t create_action;
1443                         NTTIME create_time;
1444                         NTTIME access_time;
1445                         NTTIME write_time;
1446                         NTTIME change_time;
1447                         uint32_t attrib;
1448                         uint64_t alloc_size;
1449                         uint64_t size;
1450                         uint16_t file_type;
1451                         uint16_t ipc_state;
1452                         uint8_t  is_directory;
1453
1454                         /* optional return values matching SMB2 tagged
1455                            values in the call */
1456                         uint32_t maximal_access;
1457                 } out;
1458         } ntcreatex, nttrans, generic;
1459
1460         /* TRANS2_OPEN interface */
1461         struct {
1462                 enum smb_open_level level;
1463                 struct {
1464                         uint16_t flags;
1465                         uint16_t open_mode;
1466                         uint16_t search_attrs;
1467                         uint16_t file_attrs;
1468                         time_t write_time;
1469                         uint16_t open_func;
1470                         uint32_t size;
1471                         uint32_t timeout;
1472                         const char *fname;
1473                         uint_t num_eas;
1474                         struct ea_struct *eas;
1475                 } in;
1476                 struct {
1477                         union smb_handle file;
1478                         uint16_t attrib;
1479                         time_t write_time;
1480                         uint32_t size;
1481                         uint16_t access;
1482                         uint16_t ftype;
1483                         uint16_t devstate;
1484                         uint16_t action;
1485                         uint32_t file_id;
1486                 } out;
1487         } t2open;
1488
1489         /* SMBopen interface */
1490         struct {
1491                 enum smb_open_level level;
1492                 struct {
1493                         uint16_t open_mode;
1494                         uint16_t search_attrs;
1495                         const char *fname;
1496                 } in;
1497                 struct {
1498                         union smb_handle file;
1499                         uint16_t attrib;
1500                         time_t write_time;
1501                         uint32_t size;
1502                         uint16_t rmode;
1503                 } out;
1504         } openold;
1505
1506         /* SMBopenX interface */
1507         struct {
1508                 enum smb_open_level level;
1509                 struct {
1510                         uint16_t flags;
1511                         uint16_t open_mode;
1512                         uint16_t search_attrs; /* not honoured by win2003 */
1513                         uint16_t file_attrs;
1514                         time_t write_time; /* not honoured by win2003 */
1515                         uint16_t open_func;
1516                         uint32_t size; /* note that this sets the
1517                                         initial file size, not
1518                                         just allocation size */
1519                         uint32_t timeout; /* not honoured by win2003 */
1520                         const char *fname;
1521                 } in;
1522                 struct {
1523                         union smb_handle file;
1524                         uint16_t attrib;
1525                         time_t write_time;
1526                         uint32_t size;
1527                         uint16_t access;
1528                         uint16_t ftype;
1529                         uint16_t devstate;
1530                         uint16_t action;
1531                         uint32_t unique_fid;
1532                         uint32_t access_mask;
1533                         uint32_t unknown;
1534                 } out;
1535         } openx;
1536
1537         /* SMBmknew interface */
1538         struct {
1539                 enum smb_open_level level;
1540                 struct {
1541                         uint16_t attrib;
1542                         time_t write_time;
1543                         const char *fname;
1544                 } in;
1545                 struct {
1546                         union smb_handle file;
1547                 } out;
1548         } mknew, create;
1549
1550         /* SMBctemp interface */
1551         struct {
1552                 enum smb_open_level level;
1553                 struct {
1554                         uint16_t attrib;
1555                         time_t write_time;
1556                         const char *directory;
1557                 } in;
1558                 struct {
1559                         union smb_handle file;
1560                         /* temp name, relative to directory */
1561                         char *name;
1562                 } out;
1563         } ctemp;
1564
1565         /* SMBsplopen interface */
1566         struct {
1567                 enum smb_open_level level;
1568                 struct {
1569                         uint16_t setup_length;
1570                         uint16_t mode;
1571                         const char *ident;
1572                 } in;
1573                 struct {
1574                         union smb_handle file;
1575                 } out;
1576         } splopen;
1577
1578
1579         /* chained OpenX/ReadX interface */
1580         struct {
1581                 enum smb_open_level level;
1582                 struct {
1583                         uint16_t flags;
1584                         uint16_t open_mode;
1585                         uint16_t search_attrs; /* not honoured by win2003 */
1586                         uint16_t file_attrs;
1587                         time_t write_time; /* not honoured by win2003 */
1588                         uint16_t open_func;
1589                         uint32_t size; /* note that this sets the
1590                                         initial file size, not
1591                                         just allocation size */
1592                         uint32_t timeout; /* not honoured by win2003 */
1593                         const char *fname;
1594
1595                         /* readx part */
1596                         uint64_t offset;
1597                         uint16_t mincnt;
1598                         uint32_t maxcnt;
1599                         uint16_t remaining;
1600                 } in;
1601                 struct {
1602                         union smb_handle file;
1603                         uint16_t attrib;
1604                         time_t write_time;
1605                         uint32_t size;
1606                         uint16_t access;
1607                         uint16_t ftype;
1608                         uint16_t devstate;
1609                         uint16_t action;
1610                         uint32_t unique_fid;
1611                         uint32_t access_mask;
1612                         uint32_t unknown;
1613
1614                         /* readx part */
1615                         uint8_t *data;
1616                         uint16_t remaining;
1617                         uint16_t compaction_mode;
1618                         uint16_t nread;
1619                 } out;
1620         } openxreadx;
1621
1622 #define SMB2_CREATE_FLAG_REQUEST_OPLOCK           0x0100
1623 #define SMB2_CREATE_FLAG_REQUEST_EXCLUSIVE_OPLOCK 0x0800
1624 #define SMB2_CREATE_FLAG_GRANT_OPLOCK             0x0001
1625 #define SMB2_CREATE_FLAG_GRANT_EXCLUSIVE_OPLOCK   0x0080
1626
1627         /* SMB2 Create */
1628         struct smb2_create {
1629                 enum smb_open_level level;
1630                 struct {
1631                         /* static body buffer 56 (0x38) bytes */
1632                         uint8_t  security_flags;      /* SMB2_SECURITY_* */
1633                         uint8_t  oplock_level;        /* SMB2_OPLOCK_LEVEL_* */
1634                         uint32_t impersonation_level; /* SMB2_IMPERSONATION_* */
1635                         uint64_t create_flags;
1636                         uint64_t reserved;
1637                         uint32_t desired_access;
1638                         uint32_t file_attributes;
1639                         uint32_t share_access; /* NTCREATEX_SHARE_ACCESS_* */
1640                         uint32_t create_disposition; /* NTCREATEX_DISP_* */
1641                         uint32_t create_options; /* NTCREATEX_OPTIONS_* */
1642
1643                         /* uint16_t fname_ofs */
1644                         /* uint16_t fname_size */
1645                         /* uint32_t blob_ofs; */
1646                         /* uint32_t blob_size; */
1647
1648                         /* dynamic body */
1649                         const char *fname;
1650
1651                         /* now some optional parameters - encoded as tagged blobs */
1652                         struct smb_ea_list eas;
1653                         uint64_t alloc_size;
1654                         struct security_descriptor *sec_desc;
1655                         bool   durable_open;
1656                         struct smb2_handle *durable_handle;
1657                         bool   query_maximal_access;
1658                         NTTIME timewarp;
1659                         bool   query_on_disk_id;
1660                         struct smb2_lease *lease_request;
1661
1662                         /* and any additional blobs the caller wants */
1663                         struct smb2_create_blobs {
1664                                 uint32_t num_blobs;
1665                                 struct smb2_create_blob {
1666                                         const char *tag;
1667                                         DATA_BLOB data;
1668                                 } *blobs;
1669                         } blobs;
1670                 } in;
1671                 struct {
1672                         union smb_handle file;
1673
1674                         /* static body buffer 88 (0x58) bytes */
1675                         /* uint16_t buffer_code;  0x59 = 0x58 + 1 */
1676                         uint8_t oplock_level;
1677                         uint8_t reserved;
1678                         uint32_t create_action;
1679                         NTTIME   create_time;
1680                         NTTIME   access_time;
1681                         NTTIME   write_time;
1682                         NTTIME   change_time;
1683                         uint64_t alloc_size;
1684                         uint64_t size;
1685                         uint32_t file_attr;
1686                         uint32_t reserved2;
1687                         /* struct smb2_handle handle;*/
1688                         /* uint32_t blob_ofs; */
1689                         /* uint32_t blob_size; */
1690
1691                         /* optional return values matching tagged values in the call */
1692                         uint32_t maximal_access;
1693                         uint8_t on_disk_id[32];
1694                         struct smb2_lease lease_response;
1695
1696                         /* tagged blobs in the reply */
1697                         struct smb2_create_blobs blobs;
1698                 } out;
1699         } smb2;
1700 };
1701
1702
1703
1704 enum smb_read_level {
1705         RAW_READ_READBRAW,
1706         RAW_READ_LOCKREAD,
1707         RAW_READ_READ,
1708         RAW_READ_READX,
1709         RAW_READ_SMB2
1710 };
1711
1712 #define RAW_READ_GENERIC RAW_READ_READX
1713
1714 /* union for read() backend call
1715
1716    note that .infoX.out.data will be allocated before the backend is
1717    called. It will be big enough to hold the maximum size asked for
1718 */
1719 union smb_read {
1720         /* SMBreadX (and generic) interface */
1721         struct {
1722                 enum smb_read_level level;
1723                 struct {
1724                         union smb_handle file;
1725                         uint64_t offset;
1726                         uint32_t mincnt; /* enforced on SMB2, 16 bit on SMB */
1727                         uint32_t maxcnt;
1728                         uint16_t remaining;
1729                         bool read_for_execute;
1730                 } in;
1731                 struct {
1732                         uint8_t *data;
1733                         uint16_t remaining;
1734                         uint16_t compaction_mode;
1735                         uint32_t nread;
1736                 } out;
1737         } readx, generic;
1738
1739         /* SMBreadbraw interface */
1740         struct {
1741                 enum smb_read_level level;
1742                 struct {
1743                         union smb_handle file;
1744                         uint64_t offset;
1745                         uint16_t  maxcnt;
1746                         uint16_t  mincnt;
1747                         uint32_t  timeout;
1748                 } in;
1749                 struct {
1750                         uint8_t *data;
1751                         uint32_t nread;
1752                 } out;
1753         } readbraw;
1754
1755
1756         /* SMBlockandread interface */
1757         struct {
1758                 enum smb_read_level level;
1759                 struct {
1760                         union smb_handle file;
1761                         uint16_t count;
1762                         uint32_t offset;
1763                         uint16_t remaining;
1764                 } in;
1765                 struct {
1766                         uint8_t *data;
1767                         uint16_t nread;
1768                 } out;
1769         } lockread;
1770
1771         /* SMBread interface */
1772         struct {
1773                 enum smb_read_level level;
1774                 struct {
1775                         union smb_handle file;
1776                         uint16_t count;
1777                         uint32_t offset;
1778                         uint16_t remaining;
1779                 } in;
1780                 struct {
1781                         uint8_t *data;
1782                         uint16_t nread;
1783                 } out;
1784         } read;
1785
1786         /* SMB2 Read */
1787         struct smb2_read {
1788                 enum smb_read_level level;
1789                 struct {
1790                         union smb_handle file;
1791
1792                         /* static body buffer 48 (0x30) bytes */
1793                         /* uint16_t buffer_code;  0x31 = 0x30 + 1 */
1794                         uint8_t _pad;
1795                         uint8_t reserved;
1796                         uint32_t length;
1797                         uint64_t offset;
1798                         /* struct smb2_handle handle; */
1799                         uint32_t min_count;
1800                         uint32_t channel;
1801                         uint32_t remaining;
1802                         /* the docs give no indication of what
1803                            these channel variables are for */
1804                         uint16_t channel_offset;
1805                         uint16_t channel_length;
1806                 } in;
1807                 struct {
1808                         /* static body buffer 16 (0x10) bytes */
1809                         /* uint16_t buffer_code;  0x11 = 0x10 + 1 */
1810                         /* uint8_t data_ofs; */
1811                         /* uint8_t reserved; */
1812                         /* uint32_t data_size; */
1813                         uint32_t remaining;
1814                         uint32_t reserved;
1815
1816                         /* dynamic body */
1817                         DATA_BLOB data;
1818                 } out;
1819         } smb2;
1820 };
1821
1822
1823 enum smb_write_level {
1824         RAW_WRITE_WRITEUNLOCK,
1825         RAW_WRITE_WRITE,
1826         RAW_WRITE_WRITEX,
1827         RAW_WRITE_WRITECLOSE,
1828         RAW_WRITE_SPLWRITE,
1829         RAW_WRITE_SMB2
1830 };
1831
1832 #define RAW_WRITE_GENERIC RAW_WRITE_WRITEX
1833
1834 /* union for write() backend call
1835 */
1836 union smb_write {
1837         /* SMBwriteX interface */
1838         struct {
1839                 enum smb_write_level level;
1840                 struct {
1841                         union smb_handle file;
1842                         uint64_t offset;
1843                         uint16_t wmode;
1844                         uint16_t remaining;
1845                         uint32_t count;
1846                         const uint8_t *data;
1847                 } in;
1848                 struct {
1849                         uint32_t nwritten;
1850                         uint16_t remaining;
1851                 } out;
1852         } writex, generic;
1853
1854         /* SMBwriteunlock interface */
1855         struct {
1856                 enum smb_write_level level;
1857                 struct {
1858                         union smb_handle file;
1859                         uint16_t count;
1860                         uint32_t offset;
1861                         uint16_t remaining;
1862                         const uint8_t *data;
1863                 } in;
1864                 struct {
1865                         uint32_t nwritten;
1866                 } out;
1867         } writeunlock;
1868
1869         /* SMBwrite interface */
1870         struct {
1871                 enum smb_write_level level;
1872                 struct {
1873                         union smb_handle file;
1874                         uint16_t count;
1875                         uint32_t offset;
1876                         uint16_t remaining;
1877                         const uint8_t *data;
1878                 } in;
1879                 struct {
1880                         uint16_t nwritten;
1881                 } out;
1882         } write;
1883
1884         /* SMBwriteclose interface */
1885         struct {
1886                 enum smb_write_level level;
1887                 struct {
1888                         union smb_handle file;
1889                         uint16_t count;
1890                         uint32_t offset;
1891                         time_t mtime;
1892                         const uint8_t *data;
1893                 } in;
1894                 struct {
1895                         uint16_t nwritten;
1896                 } out;
1897         } writeclose;
1898
1899         /* SMBsplwrite interface */
1900         struct {
1901                 enum smb_write_level level;
1902                 struct {
1903                         union smb_handle file;
1904                         uint16_t count;
1905                         const uint8_t *data;
1906                 } in;
1907         } splwrite;
1908
1909         /* SMB2 Write */
1910         struct smb2_write {
1911                 enum smb_write_level level;
1912                 struct {
1913                         union smb_handle file;
1914
1915                         /* static body buffer 48 (0x30) bytes */
1916                         /* uint16_t buffer_code;  0x31 = 0x30 + 1 */
1917                         /* uint16_t data_ofs; */
1918                         /* uint32_t data_size; */
1919                         uint64_t offset;
1920                         /* struct smb2_handle handle; */
1921                         uint64_t unknown1; /* 0xFFFFFFFFFFFFFFFF */
1922                         uint64_t unknown2; /* 0xFFFFFFFFFFFFFFFF */
1923
1924                         /* dynamic body */
1925                         DATA_BLOB data;
1926                 } in;
1927                 struct {
1928                         /* static body buffer 17 (0x11) bytes */
1929                         /* uint16_t buffer_code;  0x11 = 0x10 + 1*/
1930                         uint16_t _pad;
1931                         uint32_t nwritten;
1932                         uint64_t unknown1; /* 0x0000000000000000 */
1933                 } out;
1934         } smb2;
1935 };
1936
1937
1938 enum smb_lock_level {
1939         RAW_LOCK_LOCK,
1940         RAW_LOCK_UNLOCK,
1941         RAW_LOCK_LOCKX,
1942         RAW_LOCK_SMB2,
1943         RAW_LOCK_SMB2_BREAK
1944 };
1945
1946 #define RAW_LOCK_GENERIC RAW_LOCK_LOCKX
1947
1948 /* union for lock() backend call
1949 */
1950 union smb_lock {
1951         /* SMBlockingX and generic interface */
1952         struct {
1953                 enum smb_lock_level level;
1954                 struct {
1955                         union smb_handle file;
1956                         uint16_t mode;
1957                         uint32_t timeout;
1958                         uint16_t ulock_cnt;
1959                         uint16_t lock_cnt;
1960                         struct smb_lock_entry {
1961                                 uint32_t pid; /* 16 bits in SMB1 */
1962                                 uint64_t offset;
1963                                 uint64_t count;
1964                         } *locks; /* unlocks are first in the arrray */
1965                 } in;
1966         } generic, lockx;
1967
1968         /* SMBlock and SMBunlock interface */
1969         struct {
1970                 enum smb_lock_level level;
1971                 struct {
1972                         union smb_handle file;
1973                         uint32_t count;
1974                         uint32_t offset;
1975                 } in;
1976         } lock, unlock;
1977
1978         /* SMB2 Lock */
1979         struct smb2_lock {
1980                 enum smb_lock_level level;
1981                 struct {
1982                         union smb_handle file;
1983
1984                         /* static body buffer 48 (0x30) bytes */
1985                         /* uint16_t buffer_code;  0x30 */
1986                         uint16_t lock_count;
1987                         uint32_t reserved;
1988                         /* struct smb2_handle handle; */
1989                         struct smb2_lock_element {
1990                                 uint64_t offset;
1991                                 uint64_t length;
1992                                 uint32_t flags;
1993                                 uint32_t reserved;
1994                         } *locks;
1995                 } in;
1996                 struct {
1997                         /* static body buffer 4 (0x04) bytes */
1998                         /* uint16_t buffer_code;  0x04 */
1999                         uint16_t reserved;
2000                 } out;
2001         } smb2;
2002
2003         /* SMB2 Break */
2004         struct smb2_break {
2005                 enum smb_lock_level level;
2006                 struct {
2007                         union smb_handle file;
2008
2009                         /* static body buffer 24 (0x18) bytes */
2010                         uint8_t oplock_level;
2011                         uint8_t reserved;
2012                         uint32_t reserved2;
2013                         /* struct smb2_handle handle; */
2014                 } in, out;
2015         } smb2_break;
2016
2017         /* SMB2 Lease Break Ack (same opcode as smb2_break) */
2018         struct smb2_lease_break_ack {
2019                 struct {
2020                         uint32_t reserved;
2021                         struct smb2_lease lease;
2022                 } in, out;
2023         } smb2_lease_break_ack;
2024 };
2025
2026
2027 enum smb_close_level {
2028         RAW_CLOSE_CLOSE,
2029         RAW_CLOSE_SPLCLOSE,
2030         RAW_CLOSE_SMB2,
2031         RAW_CLOSE_GENERIC,
2032 };
2033
2034 /*
2035   union for close() backend call
2036 */
2037 union smb_close {
2038         /* generic interface */
2039         struct {
2040                 enum smb_close_level level;
2041                 struct {
2042                         union smb_handle file;
2043                         time_t write_time;
2044 #define SMB2_CLOSE_FLAGS_FULL_INFORMATION (1<<0)
2045                         uint16_t flags; /* SMB2_CLOSE_FLAGS_* */
2046                 } in;
2047                 struct {
2048                         uint16_t flags;
2049                         NTTIME   create_time;
2050                         NTTIME   access_time;
2051                         NTTIME   write_time;
2052                         NTTIME   change_time;
2053                         uint64_t alloc_size;
2054                         uint64_t size;
2055                         uint32_t file_attr;
2056                 } out;
2057         } generic;
2058
2059         /* SMBclose interface */
2060         struct {
2061                 enum smb_close_level level;
2062                 struct {
2063                         union smb_handle file;
2064                         time_t write_time;
2065                 } in;
2066         } close;
2067
2068         /* SMBsplclose interface - empty! */
2069         struct {
2070                 enum smb_close_level level;
2071                 struct {
2072                         union smb_handle file;
2073                 } in;
2074         } splclose;
2075
2076         /* SMB2 Close */
2077         struct smb2_close {
2078                 enum smb_close_level level;
2079                 struct {
2080                         union smb_handle file;
2081
2082                         /* static body buffer 24 (0x18) bytes */
2083                         /* uint16_t buffer_code;  0x18 */
2084                         uint16_t flags; /* SMB2_CLOSE_FLAGS_* */
2085                         uint32_t _pad;
2086                 } in;
2087                 struct {
2088                         /* static body buffer 60 (0x3C) bytes */
2089                         /* uint16_t buffer_code;  0x3C */
2090                         uint16_t flags;
2091                         uint32_t _pad;
2092                         NTTIME   create_time;
2093                         NTTIME   access_time;
2094                         NTTIME   write_time;
2095                         NTTIME   change_time;
2096                         uint64_t alloc_size;
2097                         uint64_t size;
2098                         uint32_t file_attr;
2099                 } out;
2100         } smb2;
2101 };
2102
2103
2104 enum smb_lpq_level {RAW_LPQ_GENERIC, RAW_LPQ_RETQ};
2105
2106 /*
2107   union for lpq() backend
2108 */
2109 union smb_lpq {
2110         /* generic interface */
2111         struct {
2112                 enum smb_lpq_level level;
2113
2114         } generic;
2115
2116
2117         /* SMBsplretq interface */
2118         struct {
2119                 enum smb_lpq_level level;
2120
2121                 struct {
2122                         uint16_t maxcount;
2123                         uint16_t startidx;
2124                 } in;
2125                 struct {
2126                         uint16_t count;
2127                         uint16_t restart_idx;
2128                         struct {
2129                                 time_t time;
2130                                 uint8_t status;
2131                                 uint16_t job;
2132                                 uint32_t size;
2133                                 char *user;
2134                         } *queue;
2135                 } out;
2136         } retq;
2137 };
2138
2139 enum smb_ioctl_level {
2140         RAW_IOCTL_IOCTL,
2141         RAW_IOCTL_NTIOCTL,
2142         RAW_IOCTL_SMB2,
2143         RAW_IOCTL_SMB2_NO_HANDLE
2144 };
2145
2146 /*
2147   union for ioctl() backend
2148 */
2149 union smb_ioctl {
2150         /* generic interface */
2151         struct {
2152                 enum smb_ioctl_level level;
2153                 struct {
2154                         union smb_handle file;
2155                 } in;
2156         } generic;
2157
2158         /* struct for SMBioctl */
2159         struct {
2160                 enum smb_ioctl_level level;
2161                 struct {
2162                         union smb_handle file;
2163                         uint32_t request;
2164                 } in;
2165                 struct {
2166                         DATA_BLOB blob;
2167                 } out;
2168         } ioctl;
2169
2170
2171         /* struct for NT ioctl call */
2172         struct {
2173                 enum smb_ioctl_level level;
2174                 struct {
2175                         union smb_handle file;
2176                         uint32_t function;
2177                         bool fsctl;
2178                         uint8_t filter;
2179                         uint32_t max_data;
2180                         DATA_BLOB blob;
2181                 } in;
2182                 struct {
2183                         DATA_BLOB blob;
2184                 } out;
2185         } ntioctl;
2186
2187         /* SMB2 Ioctl */
2188         struct smb2_ioctl {
2189                 enum smb_ioctl_level level;
2190                 struct {
2191                         union smb_handle file;
2192
2193                         /* static body buffer 56 (0x38) bytes */
2194                         /* uint16_t buffer_code;  0x39 = 0x38 + 1 */
2195                         uint16_t _pad;
2196                         uint32_t function;
2197                         /*struct smb2_handle handle;*/
2198                         /* uint32_t out_ofs; */
2199                         /* uint32_t out_size; */
2200                         uint32_t unknown2;
2201                         /* uint32_t in_ofs; */
2202                         /* uint32_t in_size; */
2203                         uint32_t max_response_size;
2204                         uint64_t flags;
2205
2206                         /* dynamic body */
2207                         DATA_BLOB out;
2208                         DATA_BLOB in;
2209                 } in;
2210                 struct {
2211                         union smb_handle file;
2212
2213                         /* static body buffer 48 (0x30) bytes */
2214                         /* uint16_t buffer_code;  0x31 = 0x30 + 1 */
2215                         uint16_t _pad;
2216                         uint32_t function;
2217                         /* struct smb2_handle handle; */
2218                         /* uint32_t in_ofs; */
2219                         /* uint32_t in_size; */
2220                         /* uint32_t out_ofs; */
2221                         /* uint32_t out_size; */
2222                         uint32_t unknown2;
2223                         uint32_t unknown3;
2224
2225                         /* dynamic body */
2226                         DATA_BLOB in;
2227                         DATA_BLOB out;
2228                 } out;
2229         } smb2;
2230 };
2231
2232 enum smb_flush_level {
2233         RAW_FLUSH_FLUSH,
2234         RAW_FLUSH_ALL,
2235         RAW_FLUSH_SMB2
2236 };
2237
2238 union smb_flush {
2239         /* struct for SMBflush */
2240         struct {
2241                 enum smb_flush_level level;
2242                 struct {
2243                         union smb_handle file;
2244                 } in;
2245         } flush, generic;
2246
2247         /* SMBflush with 0xFFFF wildcard fnum */
2248         struct {
2249                 enum smb_flush_level level;
2250         } flush_all;
2251
2252         /* SMB2 Flush */
2253         struct smb2_flush {
2254                 enum smb_flush_level level;
2255                 struct {
2256                         union smb_handle file;
2257                         uint16_t reserved1;
2258                         uint32_t reserved2;
2259                 } in;
2260                 struct {
2261                         uint16_t reserved;
2262                 } out;
2263         } smb2;
2264 };
2265
2266 /* struct for SMBcopy */
2267 struct smb_copy {
2268         struct {
2269                 uint16_t tid2;
2270                 uint16_t ofun;
2271                 uint16_t flags;
2272                 const char *path1;
2273                 const char *path2;
2274         } in;
2275         struct {
2276                 uint16_t count;
2277         } out;
2278 };
2279
2280
2281 /* struct for transact/transact2 call */
2282 struct smb_trans2 {
2283         struct {
2284                 uint16_t max_param;
2285                 uint16_t max_data;
2286                 uint8_t  max_setup;
2287                 uint16_t flags;
2288                 uint32_t timeout;
2289                 uint8_t  setup_count;
2290                 uint16_t *setup;
2291                 const char *trans_name; /* SMBtrans only */
2292                 DATA_BLOB params;
2293                 DATA_BLOB data;
2294         } in;
2295
2296         struct {
2297                 uint8_t  setup_count;
2298                 uint16_t *setup;
2299                 DATA_BLOB params;
2300                 DATA_BLOB data;
2301         } out;
2302 };
2303
2304 /* struct for nttransact2 call */
2305 struct smb_nttrans {
2306         struct {
2307                 uint8_t  max_setup;
2308                 uint32_t max_param;
2309                 uint32_t max_data;
2310                 uint8_t setup_count;
2311                 uint16_t function;
2312                 uint8_t  *setup;
2313                 DATA_BLOB params;
2314                 DATA_BLOB data;
2315         } in;
2316
2317         struct {
2318                 uint8_t  setup_count; /* in units of 16 bit words */
2319                 uint8_t  *setup;
2320                 DATA_BLOB params;
2321                 DATA_BLOB data;
2322         } out;
2323 };
2324
2325 enum smb_notify_level {
2326         RAW_NOTIFY_NTTRANS,
2327         RAW_NOTIFY_SMB2
2328 };
2329
2330 union smb_notify {
2331         /* struct for nttrans change notify call */
2332         struct {
2333                 enum smb_notify_level level;
2334
2335                 struct {
2336                         union smb_handle file;
2337                         uint32_t buffer_size;
2338                         uint32_t completion_filter;
2339                         bool recursive;
2340                 } in;
2341
2342                 struct {
2343                         uint32_t num_changes;
2344                         struct notify_changes {
2345                                 uint32_t action;
2346                                 struct smb_wire_string name;
2347                         } *changes;
2348                 } out;
2349         } nttrans;
2350
2351         struct smb2_notify {
2352                 enum smb_notify_level level;
2353
2354                 struct {
2355                         union smb_handle file;
2356                         /* static body buffer 32 (0x20) bytes */
2357                         /* uint16_t buffer_code;  0x32 */
2358                         uint16_t recursive;
2359                         uint32_t buffer_size;
2360                         /*struct  smb2_handle file;*/
2361                         uint32_t completion_filter;
2362                         uint32_t unknown;
2363                 } in;
2364
2365                 struct {
2366                         /* static body buffer 8 (0x08) bytes */
2367                         /* uint16_t buffer_code; 0x09 = 0x08 + 1 */
2368                         /* uint16_t blob_ofs; */
2369                         /* uint16_t blob_size; */
2370
2371                         /* dynamic body */
2372                         /*DATA_BLOB blob;*/
2373
2374                         /* DATA_BLOB content */
2375                         uint32_t num_changes;
2376                         struct notify_changes *changes;
2377                 } out;
2378         } smb2;
2379 };
2380
2381 enum smb_search_level {
2382         RAW_SEARCH_SEARCH,      /* SMBsearch */
2383         RAW_SEARCH_FFIRST,      /* SMBffirst */
2384         RAW_SEARCH_FUNIQUE,     /* SMBfunique */
2385         RAW_SEARCH_TRANS2,      /* SMBtrans2 */
2386         RAW_SEARCH_SMB2         /* SMB2 Find */
2387 };
2388
2389 enum smb_search_data_level {
2390         RAW_SEARCH_DATA_GENERIC                 = 0x10000, /* only used in the smbcli_ code */
2391         RAW_SEARCH_DATA_SEARCH,
2392         RAW_SEARCH_DATA_STANDARD                = SMB_FIND_STANDARD,
2393         RAW_SEARCH_DATA_EA_SIZE                 = SMB_FIND_EA_SIZE,
2394         RAW_SEARCH_DATA_EA_LIST                 = SMB_FIND_EA_LIST,
2395         RAW_SEARCH_DATA_DIRECTORY_INFO          = SMB_FIND_DIRECTORY_INFO,
2396         RAW_SEARCH_DATA_FULL_DIRECTORY_INFO     = SMB_FIND_FULL_DIRECTORY_INFO,
2397         RAW_SEARCH_DATA_NAME_INFO               = SMB_FIND_NAME_INFO,
2398         RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO     = SMB_FIND_BOTH_DIRECTORY_INFO,
2399         RAW_SEARCH_DATA_ID_FULL_DIRECTORY_INFO  = SMB_FIND_ID_FULL_DIRECTORY_INFO,
2400         RAW_SEARCH_DATA_ID_BOTH_DIRECTORY_INFO  = SMB_FIND_ID_BOTH_DIRECTORY_INFO,
2401         RAW_SEARCH_DATA_UNIX_INFO               = SMB_FIND_UNIX_INFO,
2402         RAW_SEARCH_DATA_UNIX_INFO2              = SMB_FIND_UNIX_INFO2
2403 };
2404
2405 /* union for file search */
2406 union smb_search_first {
2407         struct {
2408                 enum smb_search_level level;
2409                 enum smb_search_data_level data_level;
2410         } generic;
2411
2412         /* search (old) findfirst interface.
2413            Also used for ffirst and funique. */
2414         struct {
2415                 enum smb_search_level level;
2416                 enum smb_search_data_level data_level;
2417
2418                 struct {
2419                         uint16_t max_count;
2420                         uint16_t search_attrib;
2421                         const char *pattern;
2422                 } in;
2423                 struct {
2424                         int16_t count;
2425                 } out;
2426         } search_first;
2427
2428         /* trans2 findfirst interface */
2429         struct {
2430                 enum smb_search_level level;
2431                 enum smb_search_data_level data_level;
2432
2433                 struct {
2434                         uint16_t search_attrib;
2435                         uint16_t max_count;
2436                         uint16_t flags;
2437                         uint32_t storage_type;
2438                         const char *pattern;
2439
2440                         /* the ea names are only used for RAW_SEARCH_EA_LIST */
2441                         uint_t num_names;
2442                         struct ea_name *ea_names;
2443                 } in;
2444                 struct {
2445                         uint16_t handle;
2446                         uint16_t count;
2447                         uint16_t end_of_search;
2448                 } out;
2449         } t2ffirst;
2450
2451         /* SMB2 Find */
2452         struct smb2_find {
2453                 enum smb_search_level level;
2454                 enum smb_search_data_level data_level;
2455                 struct {
2456                         union smb_handle file;
2457
2458                         /* static body buffer 32 (0x20) bytes */
2459                         /* uint16_t buffer_code;  0x21 = 0x20 + 1 */
2460                         uint8_t level;
2461                         uint8_t continue_flags; /* SMB2_CONTINUE_FLAG_* */
2462                         uint32_t file_index;
2463                         /* struct smb2_handle handle; */
2464                         /* uint16_t pattern_ofs; */
2465                         /* uint16_t pattern_size; */
2466                         uint32_t max_response_size;
2467
2468                         /* dynamic body */
2469                         const char *pattern;
2470                 } in;
2471                 struct {
2472                         /* static body buffer 8 (0x08) bytes */
2473                         /* uint16_t buffer_code;  0x08 */
2474                         /* uint16_t blob_ofs; */
2475                         /* uint32_t blob_size; */
2476
2477                         /* dynamic body */
2478                         DATA_BLOB blob;
2479                 } out;
2480         } smb2;
2481 };
2482
2483 /* union for file search continue */
2484 union smb_search_next {
2485         struct {
2486                 enum smb_search_level level;
2487                 enum smb_search_data_level data_level;
2488         } generic;
2489
2490         /* search (old) findnext interface. Also used
2491            for ffirst when continuing */
2492         struct {
2493                 enum smb_search_level level;
2494                 enum smb_search_data_level data_level;
2495
2496                 struct {
2497                         uint16_t max_count;
2498                         uint16_t search_attrib;
2499                         struct smb_search_id {
2500                                 uint8_t reserved;
2501                                 char name[11];
2502                                 uint8_t handle;
2503                                 uint32_t server_cookie;
2504                                 uint32_t client_cookie;
2505                         } id;
2506                 } in;
2507                 struct {
2508                         uint16_t count;
2509                 } out;
2510         } search_next;
2511
2512         /* trans2 findnext interface */
2513         struct {
2514                 enum smb_search_level level;
2515                 enum smb_search_data_level data_level;
2516
2517                 struct {
2518                         uint16_t handle;
2519                         uint16_t max_count;
2520                         uint32_t resume_key;
2521                         uint16_t flags;
2522                         const char *last_name;
2523
2524                         /* the ea names are only used for RAW_SEARCH_EA_LIST */
2525                         uint_t num_names;
2526                         struct ea_name *ea_names;
2527                 } in;
2528                 struct {
2529                         uint16_t count;
2530                         uint16_t end_of_search;
2531                 } out;
2532         } t2fnext;
2533
2534         /* SMB2 Find */
2535         struct smb2_find smb2;
2536 };
2537
2538 /* union for search reply file data */
2539 union smb_search_data {
2540         /*
2541          * search (old) findfirst
2542          * RAW_SEARCH_DATA_SEARCH
2543          */
2544         struct {
2545                 uint16_t attrib;
2546                 time_t write_time;
2547                 uint32_t size;
2548                 struct smb_search_id id;
2549                 const char *name;
2550         } search;
2551
2552         /* trans2 findfirst RAW_SEARCH_DATA_STANDARD level */
2553         struct {
2554                 uint32_t resume_key;
2555                 time_t create_time;
2556                 time_t access_time;
2557                 time_t write_time;
2558                 uint32_t size;
2559                 uint32_t alloc_size;
2560                 uint16_t attrib;
2561                 struct smb_wire_string name;
2562         } standard;
2563
2564         /* trans2 findfirst RAW_SEARCH_DATA_EA_SIZE level */
2565         struct {
2566                 uint32_t resume_key;
2567                 time_t create_time;
2568                 time_t access_time;
2569                 time_t write_time;
2570                 uint32_t size;
2571                 uint32_t alloc_size;
2572                 uint16_t attrib;
2573                 uint32_t ea_size;
2574                 struct smb_wire_string name;
2575         } ea_size;
2576
2577         /* trans2 findfirst RAW_SEARCH_DATA_EA_LIST level */
2578         struct {
2579                 uint32_t resume_key;
2580                 time_t create_time;
2581                 time_t access_time;
2582                 time_t write_time;
2583                 uint32_t size;
2584                 uint32_t alloc_size;
2585                 uint16_t attrib;
2586                 struct smb_ea_list eas;
2587                 struct smb_wire_string name;
2588         } ea_list;
2589
2590         /* RAW_SEARCH_DATA_DIRECTORY_INFO interface */
2591         struct {
2592                 uint32_t file_index;
2593                 NTTIME create_time;
2594                 NTTIME access_time;
2595                 NTTIME write_time;
2596                 NTTIME change_time;
2597                 uint64_t  size;
2598                 uint64_t  alloc_size;
2599                 uint32_t   attrib;
2600                 struct smb_wire_string name;
2601         } directory_info;
2602
2603         /* RAW_SEARCH_DATA_FULL_DIRECTORY_INFO interface */
2604         struct {
2605                 uint32_t file_index;
2606                 NTTIME create_time;
2607                 NTTIME access_time;
2608                 NTTIME write_time;
2609                 NTTIME change_time;
2610                 uint64_t  size;
2611                 uint64_t  alloc_size;
2612                 uint32_t   attrib;
2613                 uint32_t   ea_size;
2614                 struct smb_wire_string name;
2615         } full_directory_info;
2616
2617         /* RAW_SEARCH_DATA_NAME_INFO interface */
2618         struct {
2619                 uint32_t file_index;
2620                 struct smb_wire_string name;
2621         } name_info;
2622
2623         /* RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO interface */
2624         struct {
2625                 uint32_t file_index;
2626                 NTTIME create_time;
2627                 NTTIME access_time;
2628                 NTTIME write_time;
2629                 NTTIME change_time;
2630                 uint64_t  size;
2631                 uint64_t  alloc_size;
2632                 uint32_t   attrib;
2633                 uint32_t   ea_size;
2634                 struct smb_wire_string short_name;
2635                 struct smb_wire_string name;
2636         } both_directory_info;
2637
2638         /* RAW_SEARCH_DATA_ID_FULL_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                 uint32_t ea_size;
2649                 uint64_t file_id;
2650                 struct smb_wire_string name;
2651         } id_full_directory_info;
2652
2653         /* RAW_SEARCH_DATA_ID_BOTH_DIRECTORY_INFO interface */
2654         struct {
2655                 uint32_t file_index;
2656                 NTTIME create_time;
2657                 NTTIME access_time;
2658                 NTTIME write_time;
2659                 NTTIME change_time;
2660                 uint64_t size;
2661                 uint64_t alloc_size;
2662                 uint32_t  attrib;
2663                 uint32_t  ea_size;
2664                 uint64_t file_id;
2665                 struct smb_wire_string short_name;
2666                 struct smb_wire_string name;
2667         } id_both_directory_info;
2668
2669         /* RAW_SEARCH_DATA_UNIX_INFO interface */
2670         struct {
2671                 uint32_t file_index;
2672                 uint64_t size;
2673                 uint64_t alloc_size;
2674                 NTTIME status_change_time;
2675                 NTTIME access_time;
2676                 NTTIME change_time;
2677                 uint64_t uid;
2678                 uint64_t gid;
2679                 uint32_t file_type;
2680                 uint64_t dev_major;
2681                 uint64_t dev_minor;
2682                 uint64_t unique_id;
2683                 uint64_t permissions;
2684                 uint64_t nlink;
2685                 const char *name;
2686         } unix_info;
2687
2688         /* RAW_SEARCH_DATA_UNIX_INFO2 interface */
2689         struct {
2690                 uint32_t file_index;
2691                 uint64_t end_of_file;
2692                 uint64_t num_bytes;
2693                 NTTIME status_change_time;
2694                 NTTIME access_time;
2695                 NTTIME change_time;
2696                 uint64_t uid;
2697                 uint64_t gid;
2698                 uint32_t file_type;
2699                 uint64_t dev_major;
2700                 uint64_t dev_minor;
2701                 uint64_t unique_id;
2702                 uint64_t permissions;
2703                 uint64_t nlink;
2704                 NTTIME create_time;
2705                 uint32_t file_flags;
2706                 uint32_t flags_mask;
2707                 struct smb_wire_string name;
2708         } unix_info2;
2709 };
2710
2711 /* Callback function passed to the raw search interface. */
2712 typedef bool (*smbcli_search_callback)(void *private_data, const union smb_search_data *file);
2713
2714 enum smb_search_close_level {RAW_FINDCLOSE_GENERIC, RAW_FINDCLOSE_FCLOSE, RAW_FINDCLOSE_FINDCLOSE};
2715
2716 /* union for file search close */
2717 union smb_search_close {
2718         struct {
2719                 enum smb_search_close_level level;
2720         } generic;
2721
2722         /* SMBfclose (old search) interface */
2723         struct {
2724                 enum smb_search_close_level level;
2725
2726                 struct {
2727                         /* max_count and search_attrib are not used, but are present */
2728                         uint16_t max_count;
2729                         uint16_t search_attrib;
2730                         struct smb_search_id id;
2731                 } in;
2732         } fclose;
2733
2734         /* SMBfindclose interface */
2735         struct {
2736                 enum smb_search_close_level level;
2737
2738                 struct {
2739                         uint16_t handle;
2740                 } in;
2741         } findclose;
2742 };
2743
2744
2745 /*
2746   struct for SMBecho call
2747 */
2748 struct smb_echo {
2749         struct {
2750                 uint16_t repeat_count;
2751                 uint16_t size;
2752                 uint8_t *data;
2753         } in;
2754         struct {
2755                 uint16_t count;
2756                 uint16_t sequence_number;
2757                 uint16_t size;
2758                 uint8_t *data;
2759         } out;
2760 };
2761
2762 /*
2763   struct for shadow copy volumes
2764  */
2765 struct smb_shadow_copy {
2766         struct {
2767                 union smb_handle file;
2768                 uint32_t max_data;
2769         } in;
2770         struct {
2771                 uint32_t num_volumes;
2772                 uint32_t num_names;
2773                 const char **names;
2774         } out;
2775 };
2776
2777 #endif /* __LIBCLI_RAW_INTERFACES_H__ */