source4/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
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  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 = 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_LINK:
 407                 smbcli_blob_pull_string(session, mem_ctx, blob,
 408                                      &parms->unix_link_info.out.link_dest, 0, 4, STR_UNICODE);
 409                 return NT_STATUS_OK;
 410
 411         case RAW_FILEINFO_NETWORK_OPEN_INFORMATION:
 412                 return smb_raw_fileinfo_passthru_parse(blob, mem_ctx,
 413                                                        RAW_FILEINFO_NETWORK_OPEN_INFORMATION, parms);
 414
 415         case RAW_FILEINFO_ATTRIBUTE_TAG_INFORMATION:
 416                 return smb_raw_fileinfo_passthru_parse(blob, mem_ctx,
 417                                                        RAW_FILEINFO_ATTRIBUTE_TAG_INFORMATION, parms);
 418
 419         case RAW_FILEINFO_SMB2_ALL_INFORMATION:
 420                 return smb_raw_fileinfo_passthru_parse(blob, mem_ctx,
 421                                                        RAW_FILEINFO_SMB2_ALL_INFORMATION, parms);
 422
 423         case RAW_FILEINFO_SMB2_ALL_EAS:
 424                 return smb_raw_fileinfo_passthru_parse(blob, mem_ctx,
 425                                                        RAW_FILEINFO_SMB2_ALL_EAS, parms);
 426
 427         }
 428
 429         return NT_STATUS_INVALID_LEVEL;
 430 }
 431
 432
 433 /****************************************************************************
 434  Very raw query file info - returns param/data blobs - (async send)
 435 ****************************************************************************/
 436 static struct smbcli_request *smb_raw_fileinfo_blob_send(struct smbcli_tree *tree,
 437                                                          uint16_t fnum,
 438                                                          uint16_t info_level,
 439                                                          DATA_BLOB data)
 440 {
 441         struct smb_trans2 tp;
 442         uint16_t setup = TRANSACT2_QFILEINFO;
 443         struct smbcli_request *req;
 444         TALLOC_CTX *mem_ctx = talloc_init("raw_fileinfo");
 445
 446         tp.in.max_setup = 0;
 447         tp.in.flags = 0;
 448         tp.in.timeout = 0;
 449         tp.in.setup_count = 1;
 450         tp.in.data = data;
 451         tp.in.max_param = 2;
 452         tp.in.max_data = 0xFFFF;
 453         tp.in.setup = &setup;
 454
 455         tp.in.params = data_blob_talloc(mem_ctx, NULL, 4);
 456         if (!tp.in.params.data) {
 457                 talloc_free(mem_ctx);
 458                 return NULL;
 459         }
 460
 461         SSVAL(tp.in.params.data, 0, fnum);
 462         SSVAL(tp.in.params.data, 2, info_level);
 463
 464         req = smb_raw_trans2_send(tree, &tp);
 465
 466         talloc_free(mem_ctx);
 467
 468         return req;
 469 }
 470
 471
 472 /****************************************************************************
 473  Very raw query file info - returns param/data blobs - (async recv)
 474 ****************************************************************************/
 475 static NTSTATUS smb_raw_fileinfo_blob_recv(struct smbcli_request *req,
 476                                            TALLOC_CTX *mem_ctx,
 477                                            DATA_BLOB *blob)
 478 {
 479         struct smb_trans2 tp;
 480         NTSTATUS status = smb_raw_trans2_recv(req, mem_ctx, &tp);
 481         if (NT_STATUS_IS_OK(status)) {
 482                 *blob = tp.out.data;
 483         }
 484         return status;
 485 }
 486
 487 /****************************************************************************
 488  Very raw query path info - returns param/data blobs (async send)
 489 ****************************************************************************/
 490 static struct smbcli_request *smb_raw_pathinfo_blob_send(struct smbcli_tree *tree,
 491                                                          const char *fname,
 492                                                          uint16_t info_level,
 493                                                          DATA_BLOB data)
 494 {
 495         struct smb_trans2 tp;
 496         uint16_t setup = TRANSACT2_QPATHINFO;
 497         struct smbcli_request *req;
 498         TALLOC_CTX *mem_ctx = talloc_init("raw_pathinfo");
 499
 500         tp.in.max_setup = 0;
 501         tp.in.flags = 0;
 502         tp.in.timeout = 0;
 503         tp.in.setup_count = 1;
 504         tp.in.data = data;
 505         tp.in.max_param = 2;
 506         tp.in.max_data = 0xFFFF;
 507         tp.in.setup = &setup;
 508
 509         tp.in.params = data_blob_talloc(mem_ctx, NULL, 6);
 510         if (!tp.in.params.data) {
 511                 talloc_free(mem_ctx);
 512                 return NULL;
 513         }
 514
 515         SSVAL(tp.in.params.data, 0, info_level);
 516         SIVAL(tp.in.params.data, 2, 0);
 517         smbcli_blob_append_string(tree->session, mem_ctx, &tp.in.params,
 518                                fname, STR_TERMINATE);
 519
 520         req = smb_raw_trans2_send(tree, &tp);
 521
 522         talloc_free(mem_ctx);
 523
 524         return req;
 525 }
 526
 527 /****************************************************************************
 528  send a SMBgetatr (async send)
 529 ****************************************************************************/
 530 static struct smbcli_request *smb_raw_getattr_send(struct smbcli_tree *tree,
 531                                                 union smb_fileinfo *parms)
 532 {
 533         struct smbcli_request *req;
 534
 535         req = smbcli_request_setup(tree, SMBgetatr, 0, 0);
 536         if (!req) return NULL;
 537
 538         smbcli_req_append_ascii4(req, parms->getattr.in.file.path, STR_TERMINATE);
 539
 540         if (!smbcli_request_send(req)) {
 541                 smbcli_request_destroy(req);
 542                 return NULL;
 543         }
 544
 545         return req;
 546 }
 547
 548 /****************************************************************************
 549  send a SMBgetatr (async recv)
 550 ****************************************************************************/
 551 static NTSTATUS smb_raw_getattr_recv(struct smbcli_request *req,
 552                                      union smb_fileinfo *parms)
 553 {
 554         if (!smbcli_request_receive(req) ||
 555             smbcli_request_is_error(req)) {
 556                 return smbcli_request_destroy(req);
 557         }
 558
 559         SMBCLI_CHECK_WCT(req, 10);
 560         parms->getattr.out.attrib =     SVAL(req->in.vwv, VWV(0));
 561         parms->getattr.out.write_time = raw_pull_dos_date3(req->transport,
 562                                                            req->in.vwv + VWV(1));
 563         parms->getattr.out.size =       IVAL(req->in.vwv, VWV(3));
 564
 565 failed:
 566         return smbcli_request_destroy(req);
 567 }
 568
 569
 570 /****************************************************************************
 571  Handle SMBgetattrE (async send)
 572 ****************************************************************************/
 573 static struct smbcli_request *smb_raw_getattrE_send(struct smbcli_tree *tree,
 574                                                  union smb_fileinfo *parms)
 575 {
 576         struct smbcli_request *req;
 577
 578         req = smbcli_request_setup(tree, SMBgetattrE, 1, 0);
 579         if (!req) return NULL;
 580
 581         SSVAL(req->out.vwv, VWV(0), parms->getattre.in.file.fnum);
 582         if (!smbcli_request_send(req)) {
 583                 smbcli_request_destroy(req);
 584                 return NULL;
 585         }
 586
 587         return req;
 588 }
 589
 590 /****************************************************************************
 591  Handle SMBgetattrE (async send)
 592 ****************************************************************************/
 593 static NTSTATUS smb_raw_getattrE_recv(struct smbcli_request *req,
 594                                       union smb_fileinfo *parms)
 595 {
 596         if (!smbcli_request_receive(req) ||
 597             smbcli_request_is_error(req)) {
 598                 return smbcli_request_destroy(req);
 599         }
 600
 601         SMBCLI_CHECK_WCT(req, 11);
 602         parms->getattre.out.create_time =   raw_pull_dos_date2(req->transport,
 603                                                                req->in.vwv + VWV(0));
 604         parms->getattre.out.access_time =   raw_pull_dos_date2(req->transport,
 605                                                                req->in.vwv + VWV(2));
 606         parms->getattre.out.write_time  =   raw_pull_dos_date2(req->transport,
 607                                                                req->in.vwv + VWV(4));
 608         parms->getattre.out.size =          IVAL(req->in.vwv,             VWV(6));
 609         parms->getattre.out.alloc_size =    IVAL(req->in.vwv,             VWV(8));
 610         parms->getattre.out.attrib =        SVAL(req->in.vwv,             VWV(10));
 611
 612 failed:
 613         return smbcli_request_destroy(req);
 614 }
 615
 616
 617 /****************************************************************************
 618  Query file info (async send)
 619 ****************************************************************************/
 620 struct smbcli_request *smb_raw_fileinfo_send(struct smbcli_tree *tree,
 621                                              union smb_fileinfo *parms)
 622 {
 623         DATA_BLOB data;
 624         struct smbcli_request *req;
 625
 626         /* pass off the non-trans2 level to specialised functions */
 627         if (parms->generic.level == RAW_FILEINFO_GETATTRE) {
 628                 return smb_raw_getattrE_send(tree, parms);
 629         }
 630         if (parms->generic.level == RAW_FILEINFO_SEC_DESC) {
 631                 return smb_raw_query_secdesc_send(tree, parms);
 632         }
 633         if (parms->generic.level >= RAW_FILEINFO_GENERIC) {
 634                 return NULL;
 635         }
 636
 637         data = data_blob(NULL, 0);
 638
 639         if (parms->generic.level == RAW_FILEINFO_EA_LIST) {
 640                 if (!ea_push_name_list(tree,
 641                                        &data,
 642                                        parms->ea_list.in.num_names,
 643                                        parms->ea_list.in.ea_names)) {
 644                         return NULL;
 645                 }
 646         }
 647
 648         req = smb_raw_fileinfo_blob_send(tree,
 649                                          parms->generic.in.file.fnum,
 650                                          parms->generic.level, data);
 651
 652         data_blob_free(&data);
 653
 654         return req;
 655 }
 656
 657 /****************************************************************************
 658  Query file info (async recv)
 659 ****************************************************************************/
 660 NTSTATUS smb_raw_fileinfo_recv(struct smbcli_request *req,
 661                                TALLOC_CTX *mem_ctx,
 662                                union smb_fileinfo *parms)
 663 {
 664         DATA_BLOB blob;
 665         NTSTATUS status;
 666         struct smbcli_session *session = req?req->session:NULL;
 667
 668         if (parms->generic.level == RAW_FILEINFO_GETATTRE) {
 669                 return smb_raw_getattrE_recv(req, parms);
 670         }
 671         if (parms->generic.level == RAW_FILEINFO_SEC_DESC) {
 672                 return smb_raw_query_secdesc_recv(req, mem_ctx, parms);
 673         }
 674         if (parms->generic.level == RAW_FILEINFO_GETATTR) {
 675                 return smb_raw_getattr_recv(req, parms);
 676         }
 677
 678         status = smb_raw_fileinfo_blob_recv(req, mem_ctx, &blob);
 679         if (!NT_STATUS_IS_OK(status)) {
 680                 return status;
 681         }
 682
 683         return smb_raw_info_backend(session, mem_ctx, parms, &blob);
 684 }
 685
 686 /****************************************************************************
 687  Query file info (sync interface)
 688 ****************************************************************************/
 689 NTSTATUS smb_raw_fileinfo(struct smbcli_tree *tree,
 690                           TALLOC_CTX *mem_ctx,
 691                           union smb_fileinfo *parms)
 692 {
 693         struct smbcli_request *req = smb_raw_fileinfo_send(tree, parms);
 694         return smb_raw_fileinfo_recv(req, mem_ctx, parms);
 695 }
 696
 697 /****************************************************************************
 698  Query path info (async send)
 699 ****************************************************************************/
 700 struct smbcli_request *smb_raw_pathinfo_send(struct smbcli_tree *tree,
 701                                              union smb_fileinfo *parms)
 702 {
 703         DATA_BLOB data;
 704         struct smbcli_request *req;
 705
 706         if (parms->generic.level == RAW_FILEINFO_GETATTR) {
 707                 return smb_raw_getattr_send(tree, parms);
 708         }
 709         if (parms->generic.level >= RAW_FILEINFO_GENERIC) {
 710                 return NULL;
 711         }
 712
 713         data = data_blob(NULL, 0);
 714
 715         if (parms->generic.level == RAW_FILEINFO_EA_LIST) {
 716                 if (!ea_push_name_list(tree,
 717                                        &data,
 718                                        parms->ea_list.in.num_names,
 719                                        parms->ea_list.in.ea_names)) {
 720                         return NULL;
 721                 }
 722         }
 723
 724         req = smb_raw_pathinfo_blob_send(tree, parms->generic.in.file.path,
 725                                          parms->generic.level, data);
 726         data_blob_free(&data);
 727
 728         return req;
 729 }
 730
 731 /****************************************************************************
 732  Query path info (async recv)
 733 ****************************************************************************/
 734 NTSTATUS smb_raw_pathinfo_recv(struct smbcli_request *req,
 735                                TALLOC_CTX *mem_ctx,
 736                                union smb_fileinfo *parms)
 737 {
 738         /* recv is idential to fileinfo */
 739         return smb_raw_fileinfo_recv(req, mem_ctx, parms);
 740 }
 741
 742 /****************************************************************************
 743  Query path info (sync interface)
 744 ****************************************************************************/
 745 NTSTATUS smb_raw_pathinfo(struct smbcli_tree *tree,
 746                           TALLOC_CTX *mem_ctx,
 747                           union smb_fileinfo *parms)
 748 {
 749         struct smbcli_request *req = smb_raw_pathinfo_send(tree, parms);
 750         return smb_raw_pathinfo_recv(req, mem_ctx, parms);
 751 }