source/libcli/raw/rawfileinfo.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    client trans2 operations
   4    Copyright (C) James Myers 2003
   5    Copyright (C) Andrew Tridgell 2003
   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 #include "includes.h"
  23 #include "libcli/raw/libcliraw.h"
  24 #include "librpc/gen_ndr/ndr_security.h"
  25
  26 /* local macros to make the code more readable */
  27 #define FINFO_CHECK_MIN_SIZE(size) if (blob->length < (size)) { \
  28       DEBUG(1,("Unexpected FILEINFO reply size %d for level %u - expected min of %d\n", \
  29                (int)blob->length, parms->generic.level, (size))); \
  30       return NT_STATUS_INFO_LENGTH_MISMATCH; \
  31 }
  32 #define FINFO_CHECK_SIZE(size) if (blob->length != (size)) { \
  33       DEBUG(1,("Unexpected FILEINFO reply size %d for level %u - expected %d\n", \
  34                (int)blob->length, parms->generic.level, (size))); \
  35       return NT_STATUS_INFO_LENGTH_MISMATCH; \
  36 }
  37
  38 /*
  39   parse a stream information structure
  40 */
  41 NTSTATUS smbcli_parse_stream_info(DATA_BLOB blob, TALLOC_CTX *mem_ctx,
  42                                   struct stream_information *io)
  43 {
  44         uint32_t ofs = 0;
  45         io->num_streams = 0;
  46         io->streams = NULL;
  47
  48         while (blob.length - ofs >= 24) {
  49                 uint_t n = io->num_streams;
  50                 uint32_t nlen, len;
  51                 ssize_t size;
  52                 void *vstr;
  53                 io->streams =
  54                         talloc_realloc(mem_ctx, io->streams, struct stream_struct, n+1);
  55                 if (!io->streams) {
  56                         return NT_STATUS_NO_MEMORY;
  57                 }
  58                 nlen                      = IVAL(blob.data, ofs + 0x04);
  59                 io->streams[n].size       = BVAL(blob.data, ofs + 0x08);
  60                 io->streams[n].alloc_size = BVAL(blob.data, ofs + 0x10);
  61                 if (nlen > blob.length - (ofs + 24)) {
  62                         return NT_STATUS_INFO_LENGTH_MISMATCH;
  63                 }
  64                 size = convert_string_talloc(io->streams, CH_UTF16, CH_UNIX,
  65                                              blob.data+ofs+24, nlen, &vstr);
  66                 if (size == -1) {
  67                         return NT_STATUS_ILLEGAL_CHARACTER;
  68                 }
  69                 io->streams[n].stream_name.s = (const char *)vstr;
  70                 io->streams[n].stream_name.private_length = nlen;
  71                 io->num_streams++;
  72                 len = IVAL(blob.data, ofs);
  73                 if (len > blob.length - ofs) {
  74                         return NT_STATUS_INFO_LENGTH_MISMATCH;
  75                 }
  76                 if (len == 0) break;
  77                 ofs += len;
  78         }
  79
  80         return NT_STATUS_OK;
  81 }
  82
  83 /*
  84   parse the fsinfo 'passthru' level replies
  85 */
  86 NTSTATUS smb_raw_fileinfo_passthru_parse(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx,
  87                                          enum smb_fileinfo_level level,
  88                                          union smb_fileinfo *parms)
  89 {
  90         switch (level) {
  91         case RAW_FILEINFO_BASIC_INFORMATION:
  92                 /* some servers return 40 bytes and some 36. w2k3 return 40, so thats
  93                    what we should do, but we need to accept 36 */
  94                 if (blob->length != 36) {
  95                         FINFO_CHECK_SIZE(40);
  96                 }
  97                 parms->basic_info.out.create_time = smbcli_pull_nttime(blob->data, 0);
  98                 parms->basic_info.out.access_time = smbcli_pull_nttime(blob->data, 8);
  99                 parms->basic_info.out.write_time  = smbcli_pull_nttime(blob->data, 16);
 100                 parms->basic_info.out.change_time = smbcli_pull_nttime(blob->data, 24);
 101                 parms->basic_info.out.attrib      = IVAL(blob->data, 32);
 102                 return NT_STATUS_OK;
 103
 104         case RAW_FILEINFO_STANDARD_INFORMATION:
 105                 FINFO_CHECK_SIZE(24);
 106                 parms->standard_info.out.alloc_size =     BVAL(blob->data, 0);
 107                 parms->standard_info.out.size =           BVAL(blob->data, 8);
 108                 parms->standard_info.out.nlink =          IVAL(blob->data, 16);
 109                 parms->standard_info.out.delete_pending = CVAL(blob->data, 20);
 110                 parms->standard_info.out.directory =      CVAL(blob->data, 21);
 111                 return NT_STATUS_OK;
 112
 113         case RAW_FILEINFO_EA_INFORMATION:
 114                 FINFO_CHECK_SIZE(4);
 115                 parms->ea_info.out.ea_size = IVAL(blob->data, 0);
 116                 return NT_STATUS_OK;
 117
 118         case RAW_FILEINFO_NAME_INFORMATION:
 119                 FINFO_CHECK_MIN_SIZE(4);
 120                 smbcli_blob_pull_string(NULL, mem_ctx, blob,
 121                                         &parms->name_info.out.fname, 0, 4, STR_UNICODE);
 122                 return NT_STATUS_OK;
 123
 124         case RAW_FILEINFO_ALL_INFORMATION:
 125                 FINFO_CHECK_MIN_SIZE(72);
 126                 parms->all_info.out.create_time =           smbcli_pull_nttime(blob->data, 0);
 127                 parms->all_info.out.access_time =           smbcli_pull_nttime(blob->data, 8);
 128                 parms->all_info.out.write_time =            smbcli_pull_nttime(blob->data, 16);
 129                 parms->all_info.out.change_time =           smbcli_pull_nttime(blob->data, 24);
 130                 parms->all_info.out.attrib =                IVAL(blob->data, 32);
 131                 parms->all_info.out.alloc_size =            BVAL(blob->data, 40);
 132                 parms->all_info.out.size =                  BVAL(blob->data, 48);
 133                 parms->all_info.out.nlink =                 IVAL(blob->data, 56);
 134                 parms->all_info.out.delete_pending =        CVAL(blob->data, 60);
 135                 parms->all_info.out.directory =             CVAL(blob->data, 61);
 136 #if 1
 137                 parms->all_info.out.ea_size =               IVAL(blob->data, 64);
 138                 smbcli_blob_pull_string(NULL, mem_ctx, blob,
 139                                         &parms->all_info.out.fname, 68, 72, STR_UNICODE);
 140 #else
 141                 /* this is what the CIFS spec says - and its totally
 142                    wrong, but its useful having it here so we can
 143                    quickly adapt to broken servers when running
 144                    tests */
 145                 parms->all_info.out.ea_size =               IVAL(blob->data, 72);
 146                 /* access flags 4 bytes at 76
 147                    current_position 8 bytes at 80
 148                    mode 4 bytes at 88
 149                    alignment 4 bytes at 92
 150                 */
 151                 smbcli_blob_pull_string(NULL, mem_ctx, blob,
 152                                         &parms->all_info.out.fname, 96, 100, STR_UNICODE);
 153 #endif
 154                 return NT_STATUS_OK;
 155
 156         case RAW_FILEINFO_ALT_NAME_INFORMATION:
 157                 FINFO_CHECK_MIN_SIZE(4);
 158                 smbcli_blob_pull_string(NULL, mem_ctx, blob,
 159                                         &parms->alt_name_info.out.fname, 0, 4, STR_UNICODE);
 160                 return NT_STATUS_OK;
 161
 162         case RAW_FILEINFO_STREAM_INFORMATION:
 163                 return smbcli_parse_stream_info(*blob, mem_ctx, &parms->stream_info.out);
 164
 165         case RAW_FILEINFO_INTERNAL_INFORMATION:
 166                 FINFO_CHECK_SIZE(8);
 167                 parms->internal_information.out.file_id = BVAL(blob->data, 0);
 168                 return NT_STATUS_OK;
 169
 170         case RAW_FILEINFO_ACCESS_INFORMATION:
 171                 FINFO_CHECK_SIZE(4);
 172                 parms->access_information.out.access_flags = IVAL(blob->data, 0);
 173                 return NT_STATUS_OK;
 174
 175         case RAW_FILEINFO_POSITION_INFORMATION:
 176                 FINFO_CHECK_SIZE(8);
 177                 parms->position_information.out.position = BVAL(blob->data, 0);
 178                 return NT_STATUS_OK;
 179
 180         case RAW_FILEINFO_MODE_INFORMATION:
 181                 FINFO_CHECK_SIZE(4);
 182                 parms->mode_information.out.mode = IVAL(blob->data, 0);
 183                 return NT_STATUS_OK;
 184
 185         case RAW_FILEINFO_ALIGNMENT_INFORMATION:
 186                 FINFO_CHECK_SIZE(4);
 187                 parms->alignment_information.out.alignment_requirement
 188                         = IVAL(blob->data, 0);
 189                 return NT_STATUS_OK;
 190
 191         case RAW_FILEINFO_COMPRESSION_INFORMATION:
 192                 FINFO_CHECK_SIZE(16);
 193                 parms->compression_info.out.compressed_size = BVAL(blob->data,  0);
 194                 parms->compression_info.out.format          = SVAL(blob->data,  8);
 195                 parms->compression_info.out.unit_shift      = CVAL(blob->data, 10);
 196                 parms->compression_info.out.chunk_shift     = CVAL(blob->data, 11);
 197                 parms->compression_info.out.cluster_shift   = CVAL(blob->data, 12);
 198                 /* 3 bytes of padding */
 199                 return NT_STATUS_OK;
 200
 201         case RAW_FILEINFO_NETWORK_OPEN_INFORMATION:
 202                 FINFO_CHECK_SIZE(56);
 203                 parms->network_open_information.out.create_time = smbcli_pull_nttime(blob->data,  0);
 204                 parms->network_open_information.out.access_time = smbcli_pull_nttime(blob->data,  8);
 205                 parms->network_open_information.out.write_time =  smbcli_pull_nttime(blob->data, 16);
 206                 parms->network_open_information.out.change_time = smbcli_pull_nttime(blob->data, 24);
 207                 parms->network_open_information.out.alloc_size =             BVAL(blob->data, 32);
 208                 parms->network_open_information.out.size =                   BVAL(blob->data, 40);
 209                 parms->network_open_information.out.attrib =                 IVAL(blob->data, 48);
 210                 return NT_STATUS_OK;
 211
 212         case RAW_FILEINFO_ATTRIBUTE_TAG_INFORMATION:
 213                 FINFO_CHECK_SIZE(8);
 214                 parms->attribute_tag_information.out.attrib =      IVAL(blob->data, 0);
 215                 parms->attribute_tag_information.out.reparse_tag = IVAL(blob->data, 4);
 216                 return NT_STATUS_OK;
 217
 218         case RAW_FILEINFO_SMB2_ALL_EAS:
 219                 FINFO_CHECK_MIN_SIZE(4);
 220                 return ea_pull_list_chained(blob, mem_ctx,
 221                                             &parms->all_eas.out.num_eas,
 222                                             &parms->all_eas.out.eas);
 223
 224         case RAW_FILEINFO_SMB2_ALL_INFORMATION:
 225                 FINFO_CHECK_MIN_SIZE(0x64);
 226                 parms->all_info2.out.create_time    = smbcli_pull_nttime(blob->data, 0x00);
 227                 parms->all_info2.out.access_time    = smbcli_pull_nttime(blob->data, 0x08);
 228                 parms->all_info2.out.write_time     = smbcli_pull_nttime(blob->data, 0x10);
 229                 parms->all_info2.out.change_time    = smbcli_pull_nttime(blob->data, 0x18);
 230                 parms->all_info2.out.attrib         = IVAL(blob->data, 0x20);
 231                 parms->all_info2.out.unknown1       = IVAL(blob->data, 0x24);
 232                 parms->all_info2.out.alloc_size     = BVAL(blob->data, 0x28);
 233                 parms->all_info2.out.size           = BVAL(blob->data, 0x30);
 234                 parms->all_info2.out.nlink          = IVAL(blob->data, 0x38);
 235                 parms->all_info2.out.delete_pending = CVAL(blob->data, 0x3C);
 236                 parms->all_info2.out.directory      = CVAL(blob->data, 0x3D);
 237                 /* 0x3E-0x3F padding */
 238                 parms->all_info2.out.file_id        = BVAL(blob->data, 0x40);
 239                 parms->all_info2.out.ea_size        = IVAL(blob->data, 0x48);
 240                 parms->all_info2.out.access_mask    = IVAL(blob->data, 0x4C);
 241                 parms->all_info2.out.position       = BVAL(blob->data, 0x50);
 242                 parms->all_info2.out.mode           = BVAL(blob->data, 0x58);
 243                 smbcli_blob_pull_string(NULL, mem_ctx, blob,
 244                                         &parms->all_info2.out.fname, 0x60, 0x64, STR_UNICODE);
 245                 return NT_STATUS_OK;
 246
 247         case RAW_FILEINFO_SEC_DESC: {
 248                 NTSTATUS status;
 249
 250                 parms->query_secdesc.out.sd = talloc(mem_ctx, struct security_descriptor);
 251                 NT_STATUS_HAVE_NO_MEMORY(parms->query_secdesc.out.sd);
 252
 253                 status = ndr_pull_struct_blob(blob, mem_ctx,
 254                                               parms->query_secdesc.out.sd,
 255                                               (ndr_pull_flags_fn_t)ndr_pull_security_descriptor);
 256                 NT_STATUS_NOT_OK_RETURN(status);
 257
 258                 return NT_STATUS_OK;
 259         }
 260
 261         default:
 262                 break;
 263         }
 264
 265         return NT_STATUS_INVALID_LEVEL;
 266 }
 267
 268
 269 /****************************************************************************
 270  Handle qfileinfo/qpathinfo trans2 backend.
 271 ****************************************************************************/
 272 static NTSTATUS smb_raw_info_backend(struct smbcli_session *session,
 273                                      TALLOC_CTX *mem_ctx,
 274                                      union smb_fileinfo *parms,
 275                                      DATA_BLOB *blob)
 276 {
 277         switch (parms->generic.level) {
 278         case RAW_FILEINFO_GENERIC:
 279         case RAW_FILEINFO_GETATTR:
 280         case RAW_FILEINFO_GETATTRE:
 281         case RAW_FILEINFO_SEC_DESC:
 282                 /* not handled here */
 283                 return NT_STATUS_INVALID_LEVEL;
 284
 285         case RAW_FILEINFO_STANDARD:
 286                 FINFO_CHECK_SIZE(22);
 287                 parms->standard.out.create_time = raw_pull_dos_date2(session->transport,
 288                                                                      blob->data +  0);
 289                 parms->standard.out.access_time = raw_pull_dos_date2(session->transport,
 290                                                                      blob->data +  4);
 291                 parms->standard.out.write_time =  raw_pull_dos_date2(session->transport,
 292                                                                      blob->data +  8);
 293                 parms->standard.out.size =        IVAL(blob->data,             12);
 294                 parms->standard.out.alloc_size =  IVAL(blob->data,             16);
 295                 parms->standard.out.attrib =      SVAL(blob->data,             20);
 296                 return NT_STATUS_OK;
 297
 298         case RAW_FILEINFO_EA_SIZE:
 299                 FINFO_CHECK_SIZE(26);
 300                 parms->ea_size.out.create_time = raw_pull_dos_date2(session->transport,
 301                                                                     blob->data +  0);
 302                 parms->ea_size.out.access_time = raw_pull_dos_date2(session->transport,
 303                                                                     blob->data +  4);
 304                 parms->ea_size.out.write_time =  raw_pull_dos_date2(session->transport,
 305                                                                     blob->data +  8);
 306                 parms->ea_size.out.size =        IVAL(blob->data,             12);
 307                 parms->ea_size.out.alloc_size =  IVAL(blob->data,             16);
 308                 parms->ea_size.out.attrib =      SVAL(blob->data,             20);
 309                 parms->ea_size.out.ea_size =     IVAL(blob->data,             22);
 310                 return NT_STATUS_OK;
 311
 312         case RAW_FILEINFO_EA_LIST:
 313                 FINFO_CHECK_MIN_SIZE(4);
 314                 return ea_pull_list(blob, mem_ctx,
 315                                     &parms->ea_list.out.num_eas,
 316                                     &parms->ea_list.out.eas);
 317
 318         case RAW_FILEINFO_ALL_EAS:
 319                 FINFO_CHECK_MIN_SIZE(4);
 320                 return ea_pull_list(blob, mem_ctx,
 321                                     &parms->all_eas.out.num_eas,
 322                                     &parms->all_eas.out.eas);
 323
 324         case RAW_FILEINFO_IS_NAME_VALID:
 325                 /* no data! */
 326                 FINFO_CHECK_SIZE(0);
 327                 return NT_STATUS_OK;
 328
 329         case RAW_FILEINFO_BASIC_INFO:
 330         case RAW_FILEINFO_BASIC_INFORMATION:
 331                 return smb_raw_fileinfo_passthru_parse(blob, mem_ctx,
 332                                                        RAW_FILEINFO_BASIC_INFORMATION, parms);
 333
 334         case RAW_FILEINFO_STANDARD_INFO:
 335         case RAW_FILEINFO_STANDARD_INFORMATION:
 336                 return smb_raw_fileinfo_passthru_parse(blob, mem_ctx,
 337                                                        RAW_FILEINFO_STANDARD_INFORMATION, parms);
 338
 339         case RAW_FILEINFO_EA_INFO:
 340         case RAW_FILEINFO_EA_INFORMATION:
 341                 return smb_raw_fileinfo_passthru_parse(blob, mem_ctx,
 342                                                        RAW_FILEINFO_EA_INFORMATION, parms);
 343
 344         case RAW_FILEINFO_NAME_INFO:
 345         case RAW_FILEINFO_NAME_INFORMATION:
 346                 return smb_raw_fileinfo_passthru_parse(blob, mem_ctx,
 347                                                        RAW_FILEINFO_NAME_INFORMATION, parms);
 348
 349         case RAW_FILEINFO_ALL_INFO:
 350         case RAW_FILEINFO_ALL_INFORMATION:
 351                 return smb_raw_fileinfo_passthru_parse(blob, mem_ctx,
 352                                                        RAW_FILEINFO_ALL_INFORMATION, parms);
 353
 354         case RAW_FILEINFO_ALT_NAME_INFO:
 355         case RAW_FILEINFO_ALT_NAME_INFORMATION:
 356                 return smb_raw_fileinfo_passthru_parse(blob, mem_ctx,
 357                                                        RAW_FILEINFO_ALT_NAME_INFORMATION, parms);
 358
 359         case RAW_FILEINFO_STREAM_INFO:
 360         case RAW_FILEINFO_STREAM_INFORMATION:
 361                 return smb_raw_fileinfo_passthru_parse(blob, mem_ctx,
 362                                                        RAW_FILEINFO_STREAM_INFORMATION, parms);
 363
 364         case RAW_FILEINFO_INTERNAL_INFORMATION:
 365                 return smb_raw_fileinfo_passthru_parse(blob, mem_ctx,
 366                                                        RAW_FILEINFO_INTERNAL_INFORMATION, parms);
 367
 368         case RAW_FILEINFO_ACCESS_INFORMATION:
 369                 return smb_raw_fileinfo_passthru_parse(blob, mem_ctx,
 370                                                        RAW_FILEINFO_ACCESS_INFORMATION, parms);
 371
 372         case RAW_FILEINFO_POSITION_INFORMATION:
 373                 return smb_raw_fileinfo_passthru_parse(blob, mem_ctx,
 374                                                        RAW_FILEINFO_POSITION_INFORMATION, parms);
 375
 376         case RAW_FILEINFO_MODE_INFORMATION:
 377                 return smb_raw_fileinfo_passthru_parse(blob, mem_ctx,
 378                                                        RAW_FILEINFO_MODE_INFORMATION, parms);
 379
 380         case RAW_FILEINFO_ALIGNMENT_INFORMATION:
 381                 return smb_raw_fileinfo_passthru_parse(blob, mem_ctx,
 382                                                        RAW_FILEINFO_ALIGNMENT_INFORMATION, parms);
 383
 384         case RAW_FILEINFO_COMPRESSION_INFO:
 385         case RAW_FILEINFO_COMPRESSION_INFORMATION:
 386                 return smb_raw_fileinfo_passthru_parse(blob, mem_ctx,
 387                                                        RAW_FILEINFO_COMPRESSION_INFORMATION, parms);
 388
 389         case RAW_FILEINFO_UNIX_BASIC:
 390                 FINFO_CHECK_SIZE(100);
 391                 parms->unix_basic_info.out.end_of_file        =            BVAL(blob->data,  0);
 392                 parms->unix_basic_info.out.num_bytes          =            BVAL(blob->data,  8);
 393                 parms->unix_basic_info.out.status_change_time = smbcli_pull_nttime(blob->data, 16);
 394                 parms->unix_basic_info.out.access_time        = smbcli_pull_nttime(blob->data, 24);
 395                 parms->unix_basic_info.out.change_time        = smbcli_pull_nttime(blob->data, 32);
 396                 parms->unix_basic_info.out.uid                =            BVAL(blob->data, 40);
 397                 parms->unix_basic_info.out.gid                =            BVAL(blob->data, 48);
 398                 parms->unix_basic_info.out.file_type          =            IVAL(blob->data, 52);
 399                 parms->unix_basic_info.out.dev_major          =            BVAL(blob->data, 60);
 400                 parms->unix_basic_info.out.dev_minor          =            BVAL(blob->data, 68);
 401                 parms->unix_basic_info.out.unique_id          =            BVAL(blob->data, 76);
 402                 parms->unix_basic_info.out.permissions        =            BVAL(blob->data, 84);
 403                 parms->unix_basic_info.out.nlink              =            BVAL(blob->data, 92);
 404                 return NT_STATUS_OK;
 405
 406         case RAW_FILEINFO_UNIX_INFO2:
 407                 FINFO_CHECK_SIZE(116);
 408                 parms->unix_info2.out.end_of_file       = BVAL(blob->data,  0);
 409                 parms->unix_info2.out.num_bytes         = BVAL(blob->data,  8);
 410                 parms->unix_info2.out.status_change_time = smbcli_pull_nttime(blob->data, 16);
 411                 parms->unix_info2.out.access_time       = smbcli_pull_nttime(blob->data, 24);
 412                 parms->unix_info2.out.change_time       = smbcli_pull_nttime(blob->data, 32);
 413                 parms->unix_info2.out.uid               = BVAL(blob->data, 40);
 414                 parms->unix_info2.out.gid               = BVAL(blob->data, 48);
 415                 parms->unix_info2.out.file_type         = IVAL(blob->data, 52);
 416                 parms->unix_info2.out.dev_major         = BVAL(blob->data, 60);
 417                 parms->unix_info2.out.dev_minor         = BVAL(blob->data, 68);
 418                 parms->unix_info2.out.unique_id         = BVAL(blob->data, 76);
 419                 parms->unix_info2.out.permissions       = BVAL(blob->data, 84);
 420                 parms->unix_info2.out.nlink             = BVAL(blob->data, 92);
 421                 parms->unix_info2.out.create_time       = smbcli_pull_nttime(blob->data, 100);
 422                 parms->unix_info2.out.file_flags        = IVAL(blob->data, 108);
 423                 parms->unix_info2.out.flags_mask        = IVAL(blob->data, 112);
 424                 return NT_STATUS_OK;
 425
 426         case RAW_FILEINFO_UNIX_LINK:
 427                 smbcli_blob_pull_string(session, mem_ctx, blob,
 428                                      &parms->unix_link_info.out.link_dest, 0, 4, STR_UNICODE);
 429                 return NT_STATUS_OK;
 430
 431         case RAW_FILEINFO_NETWORK_OPEN_INFORMATION:
 432                 return smb_raw_fileinfo_passthru_parse(blob, mem_ctx,
 433                                                        RAW_FILEINFO_NETWORK_OPEN_INFORMATION, parms);
 434
 435         case RAW_FILEINFO_ATTRIBUTE_TAG_INFORMATION:
 436                 return smb_raw_fileinfo_passthru_parse(blob, mem_ctx,
 437                                                        RAW_FILEINFO_ATTRIBUTE_TAG_INFORMATION, parms);
 438
 439         case RAW_FILEINFO_SMB2_ALL_INFORMATION:
 440                 return smb_raw_fileinfo_passthru_parse(blob, mem_ctx,
 441                                                        RAW_FILEINFO_SMB2_ALL_INFORMATION, parms);
 442
 443         case RAW_FILEINFO_SMB2_ALL_EAS:
 444                 return smb_raw_fileinfo_passthru_parse(blob, mem_ctx,
 445                                                        RAW_FILEINFO_SMB2_ALL_EAS, parms);
 446
 447         }
 448
 449         return NT_STATUS_INVALID_LEVEL;
 450 }
 451
 452
 453 /****************************************************************************
 454  Very raw query file info - returns param/data blobs - (async send)
 455 ****************************************************************************/
 456 static struct smbcli_request *smb_raw_fileinfo_blob_send(struct smbcli_tree *tree,
 457                                                          uint16_t fnum,
 458                                                          uint16_t info_level,
 459                                                          DATA_BLOB data)
 460 {
 461         struct smb_trans2 tp;
 462         uint16_t setup = TRANSACT2_QFILEINFO;
 463         struct smbcli_request *req;
 464         TALLOC_CTX *mem_ctx = talloc_init("raw_fileinfo");
 465
 466         tp.in.max_setup = 0;
 467         tp.in.flags = 0;
 468         tp.in.timeout = 0;
 469         tp.in.setup_count = 1;
 470         tp.in.data = data;
 471         tp.in.max_param = 2;
 472         tp.in.max_data = 0xFFFF;
 473         tp.in.setup = &setup;
 474
 475         tp.in.params = data_blob_talloc(mem_ctx, NULL, 4);
 476         if (!tp.in.params.data) {
 477                 talloc_free(mem_ctx);
 478                 return NULL;
 479         }
 480
 481         SSVAL(tp.in.params.data, 0, fnum);
 482         SSVAL(tp.in.params.data, 2, info_level);
 483
 484         req = smb_raw_trans2_send(tree, &tp);
 485
 486         talloc_free(mem_ctx);
 487
 488         return req;
 489 }
 490
 491
 492 /****************************************************************************
 493  Very raw query file info - returns param/data blobs - (async recv)
 494 ****************************************************************************/
 495 static NTSTATUS smb_raw_fileinfo_blob_recv(struct smbcli_request *req,
 496                                            TALLOC_CTX *mem_ctx,
 497                                            DATA_BLOB *blob)
 498 {
 499         struct smb_trans2 tp;
 500         NTSTATUS status = smb_raw_trans2_recv(req, mem_ctx, &tp);
 501         if (NT_STATUS_IS_OK(status)) {
 502                 *blob = tp.out.data;
 503         }
 504         return status;
 505 }
 506
 507 /****************************************************************************
 508  Very raw query path info - returns param/data blobs (async send)
 509 ****************************************************************************/
 510 static struct smbcli_request *smb_raw_pathinfo_blob_send(struct smbcli_tree *tree,
 511                                                          const char *fname,
 512                                                          uint16_t info_level,
 513                                                          DATA_BLOB data)
 514 {
 515         struct smb_trans2 tp;
 516         uint16_t setup = TRANSACT2_QPATHINFO;
 517         struct smbcli_request *req;
 518         TALLOC_CTX *mem_ctx = talloc_init("raw_pathinfo");
 519
 520         tp.in.max_setup = 0;
 521         tp.in.flags = 0;
 522         tp.in.timeout = 0;
 523         tp.in.setup_count = 1;
 524         tp.in.data = data;
 525         tp.in.max_param = 2;
 526         tp.in.max_data = 0xFFFF;
 527         tp.in.setup = &setup;
 528
 529         tp.in.params = data_blob_talloc(mem_ctx, NULL, 6);
 530         if (!tp.in.params.data) {
 531                 talloc_free(mem_ctx);
 532                 return NULL;
 533         }
 534
 535         SSVAL(tp.in.params.data, 0, info_level);
 536         SIVAL(tp.in.params.data, 2, 0);
 537         smbcli_blob_append_string(tree->session, mem_ctx, &tp.in.params,
 538                                fname, STR_TERMINATE);
 539
 540         req = smb_raw_trans2_send(tree, &tp);
 541
 542         talloc_free(mem_ctx);
 543
 544         return req;
 545 }
 546
 547 /****************************************************************************
 548  send a SMBgetatr (async send)
 549 ****************************************************************************/
 550 static struct smbcli_request *smb_raw_getattr_send(struct smbcli_tree *tree,
 551                                                 union smb_fileinfo *parms)
 552 {
 553         struct smbcli_request *req;
 554
 555         req = smbcli_request_setup(tree, SMBgetatr, 0, 0);
 556         if (!req) return NULL;
 557
 558         smbcli_req_append_ascii4(req, parms->getattr.in.file.path, STR_TERMINATE);
 559
 560         if (!smbcli_request_send(req)) {
 561                 smbcli_request_destroy(req);
 562                 return NULL;
 563         }
 564
 565         return req;
 566 }
 567
 568 /****************************************************************************
 569  send a SMBgetatr (async recv)
 570 ****************************************************************************/
 571 static NTSTATUS smb_raw_getattr_recv(struct smbcli_request *req,
 572                                      union smb_fileinfo *parms)
 573 {
 574         if (!smbcli_request_receive(req) ||
 575             smbcli_request_is_error(req)) {
 576                 return smbcli_request_destroy(req);
 577         }
 578
 579         SMBCLI_CHECK_WCT(req, 10);
 580         parms->getattr.out.attrib =     SVAL(req->in.vwv, VWV(0));
 581         parms->getattr.out.write_time = raw_pull_dos_date3(req->transport,
 582                                                            req->in.vwv + VWV(1));
 583         parms->getattr.out.size =       IVAL(req->in.vwv, VWV(3));
 584
 585 failed:
 586         return smbcli_request_destroy(req);
 587 }
 588
 589
 590 /****************************************************************************
 591  Handle SMBgetattrE (async send)
 592 ****************************************************************************/
 593 static struct smbcli_request *smb_raw_getattrE_send(struct smbcli_tree *tree,
 594                                                  union smb_fileinfo *parms)
 595 {
 596         struct smbcli_request *req;
 597
 598         req = smbcli_request_setup(tree, SMBgetattrE, 1, 0);
 599         if (!req) return NULL;
 600
 601         SSVAL(req->out.vwv, VWV(0), parms->getattre.in.file.fnum);
 602         if (!smbcli_request_send(req)) {
 603                 smbcli_request_destroy(req);
 604                 return NULL;
 605         }
 606
 607         return req;
 608 }
 609
 610 /****************************************************************************
 611  Handle SMBgetattrE (async send)
 612 ****************************************************************************/
 613 static NTSTATUS smb_raw_getattrE_recv(struct smbcli_request *req,
 614                                       union smb_fileinfo *parms)
 615 {
 616         if (!smbcli_request_receive(req) ||
 617             smbcli_request_is_error(req)) {
 618                 return smbcli_request_destroy(req);
 619         }
 620
 621         SMBCLI_CHECK_WCT(req, 11);
 622         parms->getattre.out.create_time =   raw_pull_dos_date2(req->transport,
 623                                                                req->in.vwv + VWV(0));
 624         parms->getattre.out.access_time =   raw_pull_dos_date2(req->transport,
 625                                                                req->in.vwv + VWV(2));
 626         parms->getattre.out.write_time  =   raw_pull_dos_date2(req->transport,
 627                                                                req->in.vwv + VWV(4));
 628         parms->getattre.out.size =          IVAL(req->in.vwv,             VWV(6));
 629         parms->getattre.out.alloc_size =    IVAL(req->in.vwv,             VWV(8));
 630         parms->getattre.out.attrib =        SVAL(req->in.vwv,             VWV(10));
 631
 632 failed:
 633         return smbcli_request_destroy(req);
 634 }
 635
 636
 637 /****************************************************************************
 638  Query file info (async send)
 639 ****************************************************************************/
 640 struct smbcli_request *smb_raw_fileinfo_send(struct smbcli_tree *tree,
 641                                              union smb_fileinfo *parms)
 642 {
 643         DATA_BLOB data;
 644         struct smbcli_request *req;
 645
 646         /* pass off the non-trans2 level to specialised functions */
 647         if (parms->generic.level == RAW_FILEINFO_GETATTRE) {
 648                 return smb_raw_getattrE_send(tree, parms);
 649         }
 650         if (parms->generic.level == RAW_FILEINFO_SEC_DESC) {
 651                 return smb_raw_query_secdesc_send(tree, parms);
 652         }
 653         if (parms->generic.level >= RAW_FILEINFO_GENERIC) {
 654                 return NULL;
 655         }
 656
 657         data = data_blob(NULL, 0);
 658
 659         if (parms->generic.level == RAW_FILEINFO_EA_LIST) {
 660                 if (!ea_push_name_list(tree,
 661                                        &data,
 662                                        parms->ea_list.in.num_names,
 663                                        parms->ea_list.in.ea_names)) {
 664                         return NULL;
 665                 }
 666         }
 667
 668         req = smb_raw_fileinfo_blob_send(tree,
 669                                          parms->generic.in.file.fnum,
 670                                          parms->generic.level, data);
 671
 672         data_blob_free(&data);
 673
 674         return req;
 675 }
 676
 677 /****************************************************************************
 678  Query file info (async recv)
 679 ****************************************************************************/
 680 NTSTATUS smb_raw_fileinfo_recv(struct smbcli_request *req,
 681                                TALLOC_CTX *mem_ctx,
 682                                union smb_fileinfo *parms)
 683 {
 684         DATA_BLOB blob;
 685         NTSTATUS status;
 686         struct smbcli_session *session = req?req->session:NULL;
 687
 688         if (parms->generic.level == RAW_FILEINFO_GETATTRE) {
 689                 return smb_raw_getattrE_recv(req, parms);
 690         }
 691         if (parms->generic.level == RAW_FILEINFO_SEC_DESC) {
 692                 return smb_raw_query_secdesc_recv(req, mem_ctx, parms);
 693         }
 694         if (parms->generic.level == RAW_FILEINFO_GETATTR) {
 695                 return smb_raw_getattr_recv(req, parms);
 696         }
 697
 698         status = smb_raw_fileinfo_blob_recv(req, mem_ctx, &blob);
 699         if (!NT_STATUS_IS_OK(status)) {
 700                 return status;
 701         }
 702
 703         return smb_raw_info_backend(session, mem_ctx, parms, &blob);
 704 }
 705
 706 /****************************************************************************
 707  Query file info (sync interface)
 708 ****************************************************************************/
 709 NTSTATUS smb_raw_fileinfo(struct smbcli_tree *tree,
 710                           TALLOC_CTX *mem_ctx,
 711                           union smb_fileinfo *parms)
 712 {
 713         struct smbcli_request *req = smb_raw_fileinfo_send(tree, parms);
 714         return smb_raw_fileinfo_recv(req, mem_ctx, parms);
 715 }
 716
 717 /****************************************************************************
 718  Query path info (async send)
 719 ****************************************************************************/
 720 struct smbcli_request *smb_raw_pathinfo_send(struct smbcli_tree *tree,
 721                                              union smb_fileinfo *parms)
 722 {
 723         DATA_BLOB data;
 724         struct smbcli_request *req;
 725
 726         if (parms->generic.level == RAW_FILEINFO_GETATTR) {
 727                 return smb_raw_getattr_send(tree, parms);
 728         }
 729         if (parms->generic.level >= RAW_FILEINFO_GENERIC) {
 730                 return NULL;
 731         }
 732
 733         data = data_blob(NULL, 0);
 734
 735         if (parms->generic.level == RAW_FILEINFO_EA_LIST) {
 736                 if (!ea_push_name_list(tree,
 737                                        &data,
 738                                        parms->ea_list.in.num_names,
 739                                        parms->ea_list.in.ea_names)) {
 740                         return NULL;
 741                 }
 742         }
 743
 744         req = smb_raw_pathinfo_blob_send(tree, parms->generic.in.file.path,
 745                                          parms->generic.level, data);
 746         data_blob_free(&data);
 747
 748         return req;
 749 }
 750
 751 /****************************************************************************
 752  Query path info (async recv)
 753 ****************************************************************************/
 754 NTSTATUS smb_raw_pathinfo_recv(struct smbcli_request *req,
 755                                TALLOC_CTX *mem_ctx,
 756                                union smb_fileinfo *parms)
 757 {
 758         /* recv is idential to fileinfo */
 759         return smb_raw_fileinfo_recv(req, mem_ctx, parms);
 760 }
 761
 762 /****************************************************************************
 763  Query path info (sync interface)
 764 ****************************************************************************/
 765 NTSTATUS smb_raw_pathinfo(struct smbcli_tree *tree,
 766                           TALLOC_CTX *mem_ctx,
 767                           union smb_fileinfo *parms)
 768 {
 769         struct smbcli_request *req = smb_raw_pathinfo_send(tree, parms);
 770         return smb_raw_pathinfo_recv(req, mem_ctx, parms);
 771 }