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 blobs;
1664                 } in;
1665                 struct {
1666                         union smb_handle file;
1667
1668                         /* static body buffer 88 (0x58) bytes */
1669                         /* uint16_t buffer_code;  0x59 = 0x58 + 1 */
1670                         uint8_t oplock_level;
1671                         uint8_t reserved;
1672                         uint32_t create_action;
1673                         NTTIME   create_time;
1674                         NTTIME   access_time;
1675                         NTTIME   write_time;
1676                         NTTIME   change_time;
1677                         uint64_t alloc_size;
1678                         uint64_t size;
1679                         uint32_t file_attr;
1680                         uint32_t reserved2;
1681                         /* struct smb2_handle handle;*/
1682                         /* uint32_t blob_ofs; */
1683                         /* uint32_t blob_size; */
1684
1685                         /* optional return values matching tagged values in the call */
1686                         uint32_t maximal_access;
1687                         uint8_t on_disk_id[32];
1688                         struct smb2_lease lease_response;
1689
1690                         /* tagged blobs in the reply */
1691                         struct smb2_create_blobs blobs;
1692                 } out;
1693         } smb2;
1694 };
1695
1696
1697
1698 enum smb_read_level {
1699         RAW_READ_READBRAW,
1700         RAW_READ_LOCKREAD,
1701         RAW_READ_READ,
1702         RAW_READ_READX,
1703         RAW_READ_SMB2
1704 };
1705
1706 #define RAW_READ_GENERIC RAW_READ_READX
1707
1708 /* union for read() backend call
1709
1710    note that .infoX.out.data will be allocated before the backend is
1711    called. It will be big enough to hold the maximum size asked for
1712 */
1713 union smb_read {
1714         /* SMBreadX (and generic) interface */
1715         struct {
1716                 enum smb_read_level level;
1717                 struct {
1718                         union smb_handle file;
1719                         uint64_t offset;
1720                         uint32_t mincnt; /* enforced on SMB2, 16 bit on SMB */
1721                         uint32_t maxcnt;
1722                         uint16_t remaining;
1723                         bool read_for_execute;
1724                 } in;
1725                 struct {
1726                         uint8_t *data;
1727                         uint16_t remaining;
1728                         uint16_t compaction_mode;
1729                         uint32_t nread;
1730                 } out;
1731         } readx, generic;
1732
1733         /* SMBreadbraw interface */
1734         struct {
1735                 enum smb_read_level level;
1736                 struct {
1737                         union smb_handle file;
1738                         uint64_t offset;
1739                         uint16_t  maxcnt;
1740                         uint16_t  mincnt;
1741                         uint32_t  timeout;
1742                 } in;
1743                 struct {
1744                         uint8_t *data;
1745                         uint32_t nread;
1746                 } out;
1747         } readbraw;
1748
1749
1750         /* SMBlockandread interface */
1751         struct {
1752                 enum smb_read_level level;
1753                 struct {
1754                         union smb_handle file;
1755                         uint16_t count;
1756                         uint32_t offset;
1757                         uint16_t remaining;
1758                 } in;
1759                 struct {
1760                         uint8_t *data;
1761                         uint16_t nread;
1762                 } out;
1763         } lockread;
1764
1765         /* SMBread interface */
1766         struct {
1767                 enum smb_read_level level;
1768                 struct {
1769                         union smb_handle file;
1770                         uint16_t count;
1771                         uint32_t offset;
1772                         uint16_t remaining;
1773                 } in;
1774                 struct {
1775                         uint8_t *data;
1776                         uint16_t nread;
1777                 } out;
1778         } read;
1779
1780         /* SMB2 Read */
1781         struct smb2_read {
1782                 enum smb_read_level level;
1783                 struct {
1784                         union smb_handle file;
1785
1786                         /* static body buffer 48 (0x30) bytes */
1787                         /* uint16_t buffer_code;  0x31 = 0x30 + 1 */
1788                         uint8_t _pad;
1789                         uint8_t reserved;
1790                         uint32_t length;
1791                         uint64_t offset;
1792                         /* struct smb2_handle handle; */
1793                         uint32_t min_count;
1794                         uint32_t channel;
1795                         uint32_t remaining;
1796                         /* the docs give no indication of what
1797                            these channel variables are for */
1798                         uint16_t channel_offset;
1799                         uint16_t channel_length;
1800                 } in;
1801                 struct {
1802                         /* static body buffer 16 (0x10) bytes */
1803                         /* uint16_t buffer_code;  0x11 = 0x10 + 1 */
1804                         /* uint8_t data_ofs; */
1805                         /* uint8_t reserved; */
1806                         /* uint32_t data_size; */
1807                         uint32_t remaining;
1808                         uint32_t reserved;
1809
1810                         /* dynamic body */
1811                         DATA_BLOB data;
1812                 } out;
1813         } smb2;
1814 };
1815
1816
1817 enum smb_write_level {
1818         RAW_WRITE_WRITEUNLOCK,
1819         RAW_WRITE_WRITE,
1820         RAW_WRITE_WRITEX,
1821         RAW_WRITE_WRITECLOSE,
1822         RAW_WRITE_SPLWRITE,
1823         RAW_WRITE_SMB2
1824 };
1825
1826 #define RAW_WRITE_GENERIC RAW_WRITE_WRITEX
1827
1828 /* union for write() backend call
1829 */
1830 union smb_write {
1831         /* SMBwriteX interface */
1832         struct {
1833                 enum smb_write_level level;
1834                 struct {
1835                         union smb_handle file;
1836                         uint64_t offset;
1837                         uint16_t wmode;
1838                         uint16_t remaining;
1839                         uint32_t count;
1840                         const uint8_t *data;
1841                 } in;
1842                 struct {
1843                         uint32_t nwritten;
1844                         uint16_t remaining;
1845                 } out;
1846         } writex, generic;
1847
1848         /* SMBwriteunlock interface */
1849         struct {
1850                 enum smb_write_level level;
1851                 struct {
1852                         union smb_handle file;
1853                         uint16_t count;
1854                         uint32_t offset;
1855                         uint16_t remaining;
1856                         const uint8_t *data;
1857                 } in;
1858                 struct {
1859                         uint32_t nwritten;
1860                 } out;
1861         } writeunlock;
1862
1863         /* SMBwrite interface */
1864         struct {
1865                 enum smb_write_level level;
1866                 struct {
1867                         union smb_handle file;
1868                         uint16_t count;
1869                         uint32_t offset;
1870                         uint16_t remaining;
1871                         const uint8_t *data;
1872                 } in;
1873                 struct {
1874                         uint16_t nwritten;
1875                 } out;
1876         } write;
1877
1878         /* SMBwriteclose interface */
1879         struct {
1880                 enum smb_write_level level;
1881                 struct {
1882                         union smb_handle file;
1883                         uint16_t count;
1884                         uint32_t offset;
1885                         time_t mtime;
1886                         const uint8_t *data;
1887                 } in;
1888                 struct {
1889                         uint16_t nwritten;
1890                 } out;
1891         } writeclose;
1892
1893         /* SMBsplwrite interface */
1894         struct {
1895                 enum smb_write_level level;
1896                 struct {
1897                         union smb_handle file;
1898                         uint16_t count;
1899                         const uint8_t *data;
1900                 } in;
1901         } splwrite;
1902
1903         /* SMB2 Write */
1904         struct smb2_write {
1905                 enum smb_write_level level;
1906                 struct {
1907                         union smb_handle file;
1908
1909                         /* static body buffer 48 (0x30) bytes */
1910                         /* uint16_t buffer_code;  0x31 = 0x30 + 1 */
1911                         /* uint16_t data_ofs; */
1912                         /* uint32_t data_size; */
1913                         uint64_t offset;
1914                         /* struct smb2_handle handle; */
1915                         uint64_t unknown1; /* 0xFFFFFFFFFFFFFFFF */
1916                         uint64_t unknown2; /* 0xFFFFFFFFFFFFFFFF */
1917
1918                         /* dynamic body */
1919                         DATA_BLOB data;
1920                 } in;
1921                 struct {
1922                         /* static body buffer 17 (0x11) bytes */
1923                         /* uint16_t buffer_code;  0x11 = 0x10 + 1*/
1924                         uint16_t _pad;
1925                         uint32_t nwritten;
1926                         uint64_t unknown1; /* 0x0000000000000000 */
1927                 } out;
1928         } smb2;
1929 };
1930
1931
1932 enum smb_lock_level {
1933         RAW_LOCK_LOCK,
1934         RAW_LOCK_UNLOCK,
1935         RAW_LOCK_LOCKX,
1936         RAW_LOCK_SMB2,
1937         RAW_LOCK_SMB2_BREAK
1938 };
1939
1940 #define RAW_LOCK_GENERIC RAW_LOCK_LOCKX
1941
1942 /* union for lock() backend call
1943 */
1944 union smb_lock {
1945         /* SMBlockingX and generic interface */
1946         struct {
1947                 enum smb_lock_level level;
1948                 struct {
1949                         union smb_handle file;
1950                         uint16_t mode;
1951                         uint32_t timeout;
1952                         uint16_t ulock_cnt;
1953                         uint16_t lock_cnt;
1954                         struct smb_lock_entry {
1955                                 uint32_t pid; /* 16 bits in SMB1 */
1956                                 uint64_t offset;
1957                                 uint64_t count;
1958                         } *locks; /* unlocks are first in the arrray */
1959                 } in;
1960         } generic, lockx;
1961
1962         /* SMBlock and SMBunlock interface */
1963         struct {
1964                 enum smb_lock_level level;
1965                 struct {
1966                         union smb_handle file;
1967                         uint32_t count;
1968                         uint32_t offset;
1969                 } in;
1970         } lock, unlock;
1971
1972         /* SMB2 Lock */
1973         struct smb2_lock {
1974                 enum smb_lock_level level;
1975                 struct {
1976                         union smb_handle file;
1977
1978                         /* static body buffer 48 (0x30) bytes */
1979                         /* uint16_t buffer_code;  0x30 */
1980                         uint16_t lock_count;
1981                         uint32_t reserved;
1982                         /* struct smb2_handle handle; */
1983                         struct smb2_lock_element {
1984                                 uint64_t offset;
1985                                 uint64_t length;
1986                                 uint32_t flags;
1987                                 uint32_t reserved;
1988                         } *locks;
1989                 } in;
1990                 struct {
1991                         /* static body buffer 4 (0x04) bytes */
1992                         /* uint16_t buffer_code;  0x04 */
1993                         uint16_t reserved;
1994                 } out;
1995         } smb2;
1996
1997         /* SMB2 Break */
1998         struct smb2_break {
1999                 enum smb_lock_level level;
2000                 struct {
2001                         union smb_handle file;
2002
2003                         /* static body buffer 24 (0x18) bytes */
2004                         uint8_t oplock_level;
2005                         uint8_t reserved;
2006                         uint32_t reserved2;
2007                         /* struct smb2_handle handle; */
2008                 } in, out;
2009         } smb2_break;
2010
2011         /* SMB2 Lease Break Ack (same opcode as smb2_break) */
2012         struct smb2_lease_break_ack {
2013                 struct {
2014                         uint32_t reserved;
2015                         struct smb2_lease lease;
2016                 } in, out;
2017         } smb2_lease_break_ack;
2018 };
2019
2020
2021 enum smb_close_level {
2022         RAW_CLOSE_CLOSE,
2023         RAW_CLOSE_SPLCLOSE,
2024         RAW_CLOSE_SMB2,
2025         RAW_CLOSE_GENERIC,
2026 };
2027
2028 /*
2029   union for close() backend call
2030 */
2031 union smb_close {
2032         /* generic interface */
2033         struct {
2034                 enum smb_close_level level;
2035                 struct {
2036                         union smb_handle file;
2037                         time_t write_time;
2038 #define SMB2_CLOSE_FLAGS_FULL_INFORMATION (1<<0)
2039                         uint16_t flags; /* SMB2_CLOSE_FLAGS_* */
2040                 } in;
2041                 struct {
2042                         uint16_t flags;
2043                         NTTIME   create_time;
2044                         NTTIME   access_time;
2045                         NTTIME   write_time;
2046                         NTTIME   change_time;
2047                         uint64_t alloc_size;
2048                         uint64_t size;
2049                         uint32_t file_attr;
2050                 } out;
2051         } generic;
2052
2053         /* SMBclose interface */
2054         struct {
2055                 enum smb_close_level level;
2056                 struct {
2057                         union smb_handle file;
2058                         time_t write_time;
2059                 } in;
2060         } close;
2061
2062         /* SMBsplclose interface - empty! */
2063         struct {
2064                 enum smb_close_level level;
2065                 struct {
2066                         union smb_handle file;
2067                 } in;
2068         } splclose;
2069
2070         /* SMB2 Close */
2071         struct smb2_close {
2072                 enum smb_close_level level;
2073                 struct {
2074                         union smb_handle file;
2075
2076                         /* static body buffer 24 (0x18) bytes */
2077                         /* uint16_t buffer_code;  0x18 */
2078                         uint16_t flags; /* SMB2_CLOSE_FLAGS_* */
2079                         uint32_t _pad;
2080                 } in;
2081                 struct {
2082                         /* static body buffer 60 (0x3C) bytes */
2083                         /* uint16_t buffer_code;  0x3C */
2084                         uint16_t flags;
2085                         uint32_t _pad;
2086                         NTTIME   create_time;
2087                         NTTIME   access_time;
2088                         NTTIME   write_time;
2089                         NTTIME   change_time;
2090                         uint64_t alloc_size;
2091                         uint64_t size;
2092                         uint32_t file_attr;
2093                 } out;
2094         } smb2;
2095 };
2096
2097
2098 enum smb_lpq_level {RAW_LPQ_GENERIC, RAW_LPQ_RETQ};
2099
2100 /*
2101   union for lpq() backend
2102 */
2103 union smb_lpq {
2104         /* generic interface */
2105         struct {
2106                 enum smb_lpq_level level;
2107
2108         } generic;
2109
2110
2111         /* SMBsplretq interface */
2112         struct {
2113                 enum smb_lpq_level level;
2114
2115                 struct {
2116                         uint16_t maxcount;
2117                         uint16_t startidx;
2118                 } in;
2119                 struct {
2120                         uint16_t count;
2121                         uint16_t restart_idx;
2122                         struct {
2123                                 time_t time;
2124                                 uint8_t status;
2125                                 uint16_t job;
2126                                 uint32_t size;
2127                                 char *user;
2128                         } *queue;
2129                 } out;
2130         } retq;
2131 };
2132
2133 enum smb_ioctl_level {
2134         RAW_IOCTL_IOCTL,
2135         RAW_IOCTL_NTIOCTL,
2136         RAW_IOCTL_SMB2,
2137         RAW_IOCTL_SMB2_NO_HANDLE
2138 };
2139
2140 /*
2141   union for ioctl() backend
2142 */
2143 union smb_ioctl {
2144         /* generic interface */
2145         struct {
2146                 enum smb_ioctl_level level;
2147                 struct {
2148                         union smb_handle file;
2149                 } in;
2150         } generic;
2151
2152         /* struct for SMBioctl */
2153         struct {
2154                 enum smb_ioctl_level level;
2155                 struct {
2156                         union smb_handle file;
2157                         uint32_t request;
2158                 } in;
2159                 struct {
2160                         DATA_BLOB blob;
2161                 } out;
2162         } ioctl;
2163
2164
2165         /* struct for NT ioctl call */
2166         struct {
2167                 enum smb_ioctl_level level;
2168                 struct {
2169                         union smb_handle file;
2170                         uint32_t function;
2171                         bool fsctl;
2172                         uint8_t filter;
2173                         uint32_t max_data;
2174                         DATA_BLOB blob;
2175                 } in;
2176                 struct {
2177                         DATA_BLOB blob;
2178                 } out;
2179         } ntioctl;
2180
2181         /* SMB2 Ioctl */
2182         struct smb2_ioctl {
2183                 enum smb_ioctl_level level;
2184                 struct {
2185                         union smb_handle file;
2186
2187                         /* static body buffer 56 (0x38) bytes */
2188                         /* uint16_t buffer_code;  0x39 = 0x38 + 1 */
2189                         uint16_t _pad;
2190                         uint32_t function;
2191                         /*struct smb2_handle handle;*/
2192                         /* uint32_t out_ofs; */
2193                         /* uint32_t out_size; */
2194                         uint32_t unknown2;
2195                         /* uint32_t in_ofs; */
2196                         /* uint32_t in_size; */
2197                         uint32_t max_response_size;
2198                         uint64_t flags;
2199
2200                         /* dynamic body */
2201                         DATA_BLOB out;
2202                         DATA_BLOB in;
2203                 } in;
2204                 struct {
2205                         union smb_handle file;
2206
2207                         /* static body buffer 48 (0x30) bytes */
2208                         /* uint16_t buffer_code;  0x31 = 0x30 + 1 */
2209                         uint16_t _pad;
2210                         uint32_t function;
2211                         /* struct smb2_handle handle; */
2212                         /* uint32_t in_ofs; */
2213                         /* uint32_t in_size; */
2214                         /* uint32_t out_ofs; */
2215                         /* uint32_t out_size; */
2216                         uint32_t unknown2;
2217                         uint32_t unknown3;
2218
2219                         /* dynamic body */
2220                         DATA_BLOB in;
2221                         DATA_BLOB out;
2222                 } out;
2223         } smb2;
2224 };
2225
2226 enum smb_flush_level {
2227         RAW_FLUSH_FLUSH,
2228         RAW_FLUSH_ALL,
2229         RAW_FLUSH_SMB2
2230 };
2231
2232 union smb_flush {
2233         /* struct for SMBflush */
2234         struct {
2235                 enum smb_flush_level level;
2236                 struct {
2237                         union smb_handle file;
2238                 } in;
2239         } flush, generic;
2240
2241         /* SMBflush with 0xFFFF wildcard fnum */
2242         struct {
2243                 enum smb_flush_level level;
2244         } flush_all;
2245
2246         /* SMB2 Flush */
2247         struct smb2_flush {
2248                 enum smb_flush_level level;
2249                 struct {
2250                         union smb_handle file;
2251                         uint16_t reserved1;
2252                         uint32_t reserved2;
2253                 } in;
2254                 struct {
2255                         uint16_t reserved;
2256                 } out;
2257         } smb2;
2258 };
2259
2260 /* struct for SMBcopy */
2261 struct smb_copy {
2262         struct {
2263                 uint16_t tid2;
2264                 uint16_t ofun;
2265                 uint16_t flags;
2266                 const char *path1;
2267                 const char *path2;
2268         } in;
2269         struct {
2270                 uint16_t count;
2271         } out;
2272 };
2273
2274
2275 /* struct for transact/transact2 call */
2276 struct smb_trans2 {
2277         struct {
2278                 uint16_t max_param;
2279                 uint16_t max_data;
2280                 uint8_t  max_setup;
2281                 uint16_t flags;
2282                 uint32_t timeout;
2283                 uint8_t  setup_count;
2284                 uint16_t *setup;
2285                 const char *trans_name; /* SMBtrans only */
2286                 DATA_BLOB params;
2287                 DATA_BLOB data;
2288         } in;
2289
2290         struct {
2291                 uint8_t  setup_count;
2292                 uint16_t *setup;
2293                 DATA_BLOB params;
2294                 DATA_BLOB data;
2295         } out;
2296 };
2297
2298 /* struct for nttransact2 call */
2299 struct smb_nttrans {
2300         struct {
2301                 uint8_t  max_setup;
2302                 uint32_t max_param;
2303                 uint32_t max_data;
2304                 uint8_t setup_count;
2305                 uint16_t function;
2306                 uint8_t  *setup;
2307                 DATA_BLOB params;
2308                 DATA_BLOB data;
2309         } in;
2310
2311         struct {
2312                 uint8_t  setup_count; /* in units of 16 bit words */
2313                 uint8_t  *setup;
2314                 DATA_BLOB params;
2315                 DATA_BLOB data;
2316         } out;
2317 };
2318
2319 enum smb_notify_level {
2320         RAW_NOTIFY_NTTRANS,
2321         RAW_NOTIFY_SMB2
2322 };
2323
2324 union smb_notify {
2325         /* struct for nttrans change notify call */
2326         struct {
2327                 enum smb_notify_level level;
2328
2329                 struct {
2330                         union smb_handle file;
2331                         uint32_t buffer_size;
2332                         uint32_t completion_filter;
2333                         bool recursive;
2334                 } in;
2335
2336                 struct {
2337                         uint32_t num_changes;
2338                         struct notify_changes {
2339                                 uint32_t action;
2340                                 struct smb_wire_string name;
2341                         } *changes;
2342                 } out;
2343         } nttrans;
2344
2345         struct smb2_notify {
2346                 enum smb_notify_level level;
2347
2348                 struct {
2349                         union smb_handle file;
2350                         /* static body buffer 32 (0x20) bytes */
2351                         /* uint16_t buffer_code;  0x32 */
2352                         uint16_t recursive;
2353                         uint32_t buffer_size;
2354                         /*struct  smb2_handle file;*/
2355                         uint32_t completion_filter;
2356                         uint32_t unknown;
2357                 } in;
2358
2359                 struct {
2360                         /* static body buffer 8 (0x08) bytes */
2361                         /* uint16_t buffer_code; 0x09 = 0x08 + 1 */
2362                         /* uint16_t blob_ofs; */
2363                         /* uint16_t blob_size; */
2364
2365                         /* dynamic body */
2366                         /*DATA_BLOB blob;*/
2367
2368                         /* DATA_BLOB content */
2369                         uint32_t num_changes;
2370                         struct notify_changes *changes;
2371                 } out;
2372         } smb2;
2373 };
2374
2375 enum smb_search_level {
2376         RAW_SEARCH_SEARCH,      /* SMBsearch */
2377         RAW_SEARCH_FFIRST,      /* SMBffirst */
2378         RAW_SEARCH_FUNIQUE,     /* SMBfunique */
2379         RAW_SEARCH_TRANS2,      /* SMBtrans2 */
2380         RAW_SEARCH_SMB2         /* SMB2 Find */
2381 };
2382
2383 enum smb_search_data_level {
2384         RAW_SEARCH_DATA_GENERIC                 = 0x10000, /* only used in the smbcli_ code */
2385         RAW_SEARCH_DATA_SEARCH,
2386         RAW_SEARCH_DATA_STANDARD                = SMB_FIND_STANDARD,
2387         RAW_SEARCH_DATA_EA_SIZE                 = SMB_FIND_EA_SIZE,
2388         RAW_SEARCH_DATA_EA_LIST                 = SMB_FIND_EA_LIST,
2389         RAW_SEARCH_DATA_DIRECTORY_INFO          = SMB_FIND_DIRECTORY_INFO,
2390         RAW_SEARCH_DATA_FULL_DIRECTORY_INFO     = SMB_FIND_FULL_DIRECTORY_INFO,
2391         RAW_SEARCH_DATA_NAME_INFO               = SMB_FIND_NAME_INFO,
2392         RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO     = SMB_FIND_BOTH_DIRECTORY_INFO,
2393         RAW_SEARCH_DATA_ID_FULL_DIRECTORY_INFO  = SMB_FIND_ID_FULL_DIRECTORY_INFO,
2394         RAW_SEARCH_DATA_ID_BOTH_DIRECTORY_INFO  = SMB_FIND_ID_BOTH_DIRECTORY_INFO,
2395         RAW_SEARCH_DATA_UNIX_INFO               = SMB_FIND_UNIX_INFO,
2396         RAW_SEARCH_DATA_UNIX_INFO2              = SMB_FIND_UNIX_INFO2
2397 };
2398
2399 /* union for file search */
2400 union smb_search_first {
2401         struct {
2402                 enum smb_search_level level;
2403                 enum smb_search_data_level data_level;
2404         } generic;
2405
2406         /* search (old) findfirst interface.
2407            Also used for ffirst and funique. */
2408         struct {
2409                 enum smb_search_level level;
2410                 enum smb_search_data_level data_level;
2411
2412                 struct {
2413                         uint16_t max_count;
2414                         uint16_t search_attrib;
2415                         const char *pattern;
2416                 } in;
2417                 struct {
2418                         int16_t count;
2419                 } out;
2420         } search_first;
2421
2422         /* trans2 findfirst interface */
2423         struct {
2424                 enum smb_search_level level;
2425                 enum smb_search_data_level data_level;
2426
2427                 struct {
2428                         uint16_t search_attrib;
2429                         uint16_t max_count;
2430                         uint16_t flags;
2431                         uint32_t storage_type;
2432                         const char *pattern;
2433
2434                         /* the ea names are only used for RAW_SEARCH_EA_LIST */
2435                         uint_t num_names;
2436                         struct ea_name *ea_names;
2437                 } in;
2438                 struct {
2439                         uint16_t handle;
2440                         uint16_t count;
2441                         uint16_t end_of_search;
2442                 } out;
2443         } t2ffirst;
2444
2445         /* SMB2 Find */
2446         struct smb2_find {
2447                 enum smb_search_level level;
2448                 enum smb_search_data_level data_level;
2449                 struct {
2450                         union smb_handle file;
2451
2452                         /* static body buffer 32 (0x20) bytes */
2453                         /* uint16_t buffer_code;  0x21 = 0x20 + 1 */
2454                         uint8_t level;
2455                         uint8_t continue_flags; /* SMB2_CONTINUE_FLAG_* */
2456                         uint32_t file_index;
2457                         /* struct smb2_handle handle; */
2458                         /* uint16_t pattern_ofs; */
2459                         /* uint16_t pattern_size; */
2460                         uint32_t max_response_size;
2461
2462                         /* dynamic body */
2463                         const char *pattern;
2464                 } in;
2465                 struct {
2466                         /* static body buffer 8 (0x08) bytes */
2467                         /* uint16_t buffer_code;  0x08 */
2468                         /* uint16_t blob_ofs; */
2469                         /* uint32_t blob_size; */
2470
2471                         /* dynamic body */
2472                         DATA_BLOB blob;
2473                 } out;
2474         } smb2;
2475 };
2476
2477 /* union for file search continue */
2478 union smb_search_next {
2479         struct {
2480                 enum smb_search_level level;
2481                 enum smb_search_data_level data_level;
2482         } generic;
2483
2484         /* search (old) findnext interface. Also used
2485            for ffirst when continuing */
2486         struct {
2487                 enum smb_search_level level;
2488                 enum smb_search_data_level data_level;
2489
2490                 struct {
2491                         uint16_t max_count;
2492                         uint16_t search_attrib;
2493                         struct smb_search_id {
2494                                 uint8_t reserved;
2495                                 char name[11];
2496                                 uint8_t handle;
2497                                 uint32_t server_cookie;
2498                                 uint32_t client_cookie;
2499                         } id;
2500                 } in;
2501                 struct {
2502                         uint16_t count;
2503                 } out;
2504         } search_next;
2505
2506         /* trans2 findnext interface */
2507         struct {
2508                 enum smb_search_level level;
2509                 enum smb_search_data_level data_level;
2510
2511                 struct {
2512                         uint16_t handle;
2513                         uint16_t max_count;
2514                         uint32_t resume_key;
2515                         uint16_t flags;
2516                         const char *last_name;
2517
2518                         /* the ea names are only used for RAW_SEARCH_EA_LIST */
2519                         uint_t num_names;
2520                         struct ea_name *ea_names;
2521                 } in;
2522                 struct {
2523                         uint16_t count;
2524                         uint16_t end_of_search;
2525                 } out;
2526         } t2fnext;
2527
2528         /* SMB2 Find */
2529         struct smb2_find smb2;
2530 };
2531
2532 /* union for search reply file data */
2533 union smb_search_data {
2534         /*
2535          * search (old) findfirst
2536          * RAW_SEARCH_DATA_SEARCH
2537          */
2538         struct {
2539                 uint16_t attrib;
2540                 time_t write_time;
2541                 uint32_t size;
2542                 struct smb_search_id id;
2543                 const char *name;
2544         } search;
2545
2546         /* trans2 findfirst RAW_SEARCH_DATA_STANDARD level */
2547         struct {
2548                 uint32_t resume_key;
2549                 time_t create_time;
2550                 time_t access_time;
2551                 time_t write_time;
2552                 uint32_t size;
2553                 uint32_t alloc_size;
2554                 uint16_t attrib;
2555                 struct smb_wire_string name;
2556         } standard;
2557
2558         /* trans2 findfirst RAW_SEARCH_DATA_EA_SIZE level */
2559         struct {
2560                 uint32_t resume_key;
2561                 time_t create_time;
2562                 time_t access_time;
2563                 time_t write_time;
2564                 uint32_t size;
2565                 uint32_t alloc_size;
2566                 uint16_t attrib;
2567                 uint32_t ea_size;
2568                 struct smb_wire_string name;
2569         } ea_size;
2570
2571         /* trans2 findfirst RAW_SEARCH_DATA_EA_LIST level */
2572         struct {
2573                 uint32_t resume_key;
2574                 time_t create_time;
2575                 time_t access_time;
2576                 time_t write_time;
2577                 uint32_t size;
2578                 uint32_t alloc_size;
2579                 uint16_t attrib;
2580                 struct smb_ea_list eas;
2581                 struct smb_wire_string name;
2582         } ea_list;
2583
2584         /* RAW_SEARCH_DATA_DIRECTORY_INFO interface */
2585         struct {
2586                 uint32_t file_index;
2587                 NTTIME create_time;
2588                 NTTIME access_time;
2589                 NTTIME write_time;
2590                 NTTIME change_time;
2591                 uint64_t  size;
2592                 uint64_t  alloc_size;
2593                 uint32_t   attrib;
2594                 struct smb_wire_string name;
2595         } directory_info;
2596
2597         /* RAW_SEARCH_DATA_FULL_DIRECTORY_INFO interface */
2598         struct {
2599                 uint32_t file_index;
2600                 NTTIME create_time;
2601                 NTTIME access_time;
2602                 NTTIME write_time;
2603                 NTTIME change_time;
2604                 uint64_t  size;
2605                 uint64_t  alloc_size;
2606                 uint32_t   attrib;
2607                 uint32_t   ea_size;
2608                 struct smb_wire_string name;
2609         } full_directory_info;
2610
2611         /* RAW_SEARCH_DATA_NAME_INFO interface */
2612         struct {
2613                 uint32_t file_index;
2614                 struct smb_wire_string name;
2615         } name_info;
2616
2617         /* RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO interface */
2618         struct {
2619                 uint32_t file_index;
2620                 NTTIME create_time;
2621                 NTTIME access_time;
2622                 NTTIME write_time;
2623                 NTTIME change_time;
2624                 uint64_t  size;
2625                 uint64_t  alloc_size;
2626                 uint32_t   attrib;
2627                 uint32_t   ea_size;
2628                 struct smb_wire_string short_name;
2629                 struct smb_wire_string name;
2630         } both_directory_info;
2631
2632         /* RAW_SEARCH_DATA_ID_FULL_DIRECTORY_INFO interface */
2633         struct {
2634                 uint32_t file_index;
2635                 NTTIME create_time;
2636                 NTTIME access_time;
2637                 NTTIME write_time;
2638                 NTTIME change_time;
2639                 uint64_t size;
2640                 uint64_t alloc_size;
2641                 uint32_t attrib;
2642                 uint32_t ea_size;
2643                 uint64_t file_id;
2644                 struct smb_wire_string name;
2645         } id_full_directory_info;
2646
2647         /* RAW_SEARCH_DATA_ID_BOTH_DIRECTORY_INFO interface */
2648         struct {
2649                 uint32_t file_index;
2650                 NTTIME create_time;
2651                 NTTIME access_time;
2652                 NTTIME write_time;
2653                 NTTIME change_time;
2654                 uint64_t size;
2655                 uint64_t alloc_size;
2656                 uint32_t  attrib;
2657                 uint32_t  ea_size;
2658                 uint64_t file_id;
2659                 struct smb_wire_string short_name;
2660                 struct smb_wire_string name;
2661         } id_both_directory_info;
2662
2663         /* RAW_SEARCH_DATA_UNIX_INFO interface */
2664         struct {
2665                 uint32_t file_index;
2666                 uint64_t size;
2667                 uint64_t alloc_size;
2668                 NTTIME status_change_time;
2669                 NTTIME access_time;
2670                 NTTIME change_time;
2671                 uint64_t uid;
2672                 uint64_t gid;
2673                 uint32_t file_type;
2674                 uint64_t dev_major;
2675                 uint64_t dev_minor;
2676                 uint64_t unique_id;
2677                 uint64_t permissions;
2678                 uint64_t nlink;
2679                 const char *name;
2680         } unix_info;
2681
2682         /* RAW_SEARCH_DATA_UNIX_INFO2 interface */
2683         struct {
2684                 uint32_t file_index;
2685                 uint64_t end_of_file;
2686                 uint64_t num_bytes;
2687                 NTTIME status_change_time;
2688                 NTTIME access_time;
2689                 NTTIME change_time;
2690                 uint64_t uid;
2691                 uint64_t gid;
2692                 uint32_t file_type;
2693                 uint64_t dev_major;
2694                 uint64_t dev_minor;
2695                 uint64_t unique_id;
2696                 uint64_t permissions;
2697                 uint64_t nlink;
2698                 NTTIME create_time;
2699                 uint32_t file_flags;
2700                 uint32_t flags_mask;
2701                 struct smb_wire_string name;
2702         } unix_info2;
2703 };
2704
2705 /* Callback function passed to the raw search interface. */
2706 typedef bool (*smbcli_search_callback)(void *private_data, const union smb_search_data *file);
2707
2708 enum smb_search_close_level {RAW_FINDCLOSE_GENERIC, RAW_FINDCLOSE_FCLOSE, RAW_FINDCLOSE_FINDCLOSE};
2709
2710 /* union for file search close */
2711 union smb_search_close {
2712         struct {
2713                 enum smb_search_close_level level;
2714         } generic;
2715
2716         /* SMBfclose (old search) interface */
2717         struct {
2718                 enum smb_search_close_level level;
2719
2720                 struct {
2721                         /* max_count and search_attrib are not used, but are present */
2722                         uint16_t max_count;
2723                         uint16_t search_attrib;
2724                         struct smb_search_id id;
2725                 } in;
2726         } fclose;
2727
2728         /* SMBfindclose interface */
2729         struct {
2730                 enum smb_search_close_level level;
2731
2732                 struct {
2733                         uint16_t handle;
2734                 } in;
2735         } findclose;
2736 };
2737
2738
2739 /*
2740   struct for SMBecho call
2741 */
2742 struct smb_echo {
2743         struct {
2744                 uint16_t repeat_count;
2745                 uint16_t size;
2746                 uint8_t *data;
2747         } in;
2748         struct {
2749                 uint16_t count;
2750                 uint16_t sequence_number;
2751                 uint16_t size;
2752                 uint8_t *data;
2753         } out;
2754 };
2755
2756 /*
2757   struct for shadow copy volumes
2758  */
2759 struct smb_shadow_copy {
2760         struct {
2761                 union smb_handle file;
2762                 uint32_t max_data;
2763         } in;
2764         struct {
2765                 uint32_t num_volumes;
2766                 uint32_t num_names;
2767                 const char **names;
2768         } out;
2769 };
2770
2771 #endif /* __LIBCLI_RAW_INTERFACES_H__ */