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
  24 /* local macros to make the code more readable */
  25 #define FINFO_CHECK_MIN_SIZE(size) if (blob->length < (size)) { \
  26       DEBUG(1,("Unexpected FILEINFO reply size %d for level %u - expected min of %d\n", \
  27                blob->length, parms->generic.level, (size))); \
  28       return NT_STATUS_INFO_LENGTH_MISMATCH; \
  29 }
  30 #define FINFO_CHECK_SIZE(size) if (blob->length != (size)) { \
  31       DEBUG(1,("Unexpected FILEINFO reply size %d for level %u - expected %d\n", \
  32                blob->length, parms->generic.level, (size))); \
  33       return NT_STATUS_INFO_LENGTH_MISMATCH; \
  34 }
  35
  36 /****************************************************************************
  37  Handle qfileinfo/qpathinfo trans2 backend.
  38 ****************************************************************************/
  39 static NTSTATUS smb_raw_info_backend(struct cli_session *session,
  40                                      TALLOC_CTX *mem_ctx,
  41                                      union smb_fileinfo *parms,
  42                                      DATA_BLOB *blob)
  43 {
  44         uint_t len, ofs;
  45
  46         switch (parms->generic.level) {
  47         case RAW_FILEINFO_GENERIC:
  48         case RAW_FILEINFO_GETATTR:
  49         case RAW_FILEINFO_GETATTRE:
  50                 /* not handled here */
  51                 return NT_STATUS_INVALID_LEVEL;
  52
  53         case RAW_FILEINFO_STANDARD:
  54                 FINFO_CHECK_SIZE(22);
  55                 parms->standard.out.create_time = make_unix_date2(blob->data +  0);
  56                 parms->standard.out.access_time = make_unix_date2(blob->data +  4);
  57                 parms->standard.out.write_time =  make_unix_date2(blob->data +  8);
  58                 parms->standard.out.size =        IVAL(blob->data,             12);
  59                 parms->standard.out.alloc_size =  IVAL(blob->data,             16);
  60                 parms->standard.out.attrib =      SVAL(blob->data,             20);
  61                 return NT_STATUS_OK;
  62
  63         case RAW_FILEINFO_EA_SIZE:
  64                 FINFO_CHECK_SIZE(26);
  65                 parms->ea_size.out.create_time = make_unix_date2(blob->data +  0);
  66                 parms->ea_size.out.access_time = make_unix_date2(blob->data +  4);
  67                 parms->ea_size.out.write_time =  make_unix_date2(blob->data +  8);
  68                 parms->ea_size.out.size =        IVAL(blob->data,             12);
  69                 parms->ea_size.out.alloc_size =  IVAL(blob->data,             16);
  70                 parms->ea_size.out.attrib =      SVAL(blob->data,             20);
  71                 parms->ea_size.out.ea_size =     IVAL(blob->data,             22);
  72                 return NT_STATUS_OK;
  73
  74         case RAW_FILEINFO_ALL_EAS:
  75                 FINFO_CHECK_MIN_SIZE(4);
  76                 return ea_pull_list(blob, mem_ctx,
  77                                     &parms->all_eas.out.num_eas,
  78                                     &parms->all_eas.out.eas);
  79
  80         case RAW_FILEINFO_IS_NAME_VALID:
  81                 /* no data! */
  82                 FINFO_CHECK_SIZE(0);
  83                 return NT_STATUS_OK;
  84
  85         case RAW_FILEINFO_BASIC_INFO:
  86         case RAW_FILEINFO_BASIC_INFORMATION:
  87                 /* some servers return 40 bytes and some 36. w2k3 return 40, so thats
  88                    what we should do, but we need to accept 36 */
  89                 if (blob->length != 36) {
  90                         FINFO_CHECK_SIZE(40);
  91                 }
  92                 parms->basic_info.out.create_time = cli_pull_nttime(blob->data, 0);
  93                 parms->basic_info.out.access_time = cli_pull_nttime(blob->data, 8);
  94                 parms->basic_info.out.write_time =  cli_pull_nttime(blob->data, 16);
  95                 parms->basic_info.out.change_time = cli_pull_nttime(blob->data, 24);
  96                 parms->basic_info.out.attrib =                 IVAL(blob->data, 32);
  97                 return NT_STATUS_OK;
  98
  99         case RAW_FILEINFO_STANDARD_INFO:
 100         case RAW_FILEINFO_STANDARD_INFORMATION:
 101                 FINFO_CHECK_SIZE(24);
 102                 parms->standard_info.out.alloc_size =     BVAL(blob->data, 0);
 103                 parms->standard_info.out.size =           BVAL(blob->data, 8);
 104                 parms->standard_info.out.nlink =          IVAL(blob->data, 16);
 105                 parms->standard_info.out.delete_pending = CVAL(blob->data, 20);
 106                 parms->standard_info.out.directory =      CVAL(blob->data, 21);
 107                 return NT_STATUS_OK;
 108
 109         case RAW_FILEINFO_EA_INFO:
 110         case RAW_FILEINFO_EA_INFORMATION:
 111                 FINFO_CHECK_SIZE(4);
 112                 parms->ea_info.out.ea_size = IVAL(blob->data, 0);
 113                 return NT_STATUS_OK;
 114
 115         case RAW_FILEINFO_NAME_INFO:
 116         case RAW_FILEINFO_NAME_INFORMATION:
 117                 FINFO_CHECK_MIN_SIZE(4);
 118                 cli_blob_pull_string(session, mem_ctx, blob,
 119                                      &parms->name_info.out.fname, 0, 4, STR_UNICODE);
 120                 return NT_STATUS_OK;
 121
 122         case RAW_FILEINFO_ALL_INFO:
 123         case RAW_FILEINFO_ALL_INFORMATION:
 124                 FINFO_CHECK_MIN_SIZE(72);
 125                 parms->all_info.out.create_time =           cli_pull_nttime(blob->data, 0);
 126                 parms->all_info.out.access_time =           cli_pull_nttime(blob->data, 8);
 127                 parms->all_info.out.write_time =            cli_pull_nttime(blob->data, 16);
 128                 parms->all_info.out.change_time =           cli_pull_nttime(blob->data, 24);
 129                 parms->all_info.out.attrib =                IVAL(blob->data, 32);
 130                 parms->all_info.out.alloc_size =            BVAL(blob->data, 40);
 131                 parms->all_info.out.size =                  BVAL(blob->data, 48);
 132                 parms->all_info.out.nlink =                 IVAL(blob->data, 56);
 133                 parms->all_info.out.delete_pending =        CVAL(blob->data, 60);
 134                 parms->all_info.out.directory =             CVAL(blob->data, 61);
 135                 parms->all_info.out.ea_size =               IVAL(blob->data, 64);
 136                 cli_blob_pull_string(session, mem_ctx, blob,
 137                                      &parms->all_info.out.fname, 68, 72, STR_UNICODE);
 138                 return NT_STATUS_OK;
 139
 140         case RAW_FILEINFO_ALT_NAME_INFO:
 141         case RAW_FILEINFO_ALT_NAME_INFORMATION:
 142                 FINFO_CHECK_MIN_SIZE(4);
 143                 cli_blob_pull_string(session, mem_ctx, blob,
 144                                      &parms->alt_name_info.out.fname, 0, 4, STR_UNICODE);
 145                 return NT_STATUS_OK;
 146
 147         case RAW_FILEINFO_STREAM_INFO:
 148         case RAW_FILEINFO_STREAM_INFORMATION:
 149                 FINFO_CHECK_MIN_SIZE(0);
 150                 ofs = 0;
 151                 parms->stream_info.out.num_streams = 0;
 152                 parms->stream_info.out.streams = NULL;
 153
 154                 while (blob->length - ofs >= 24) {
 155                         uint_t n = parms->stream_info.out.num_streams;
 156                         parms->stream_info.out.streams =
 157                                 talloc_realloc(mem_ctx,parms->stream_info.out.streams,
 158                                                (n+1) * sizeof(parms->stream_info.out.streams[0]));
 159                         if (!parms->stream_info.out.streams) {
 160                                 return NT_STATUS_NO_MEMORY;
 161                         }
 162                         parms->stream_info.out.streams[n].size =       BVAL(blob->data, ofs +  8);
 163                         parms->stream_info.out.streams[n].alloc_size = BVAL(blob->data, ofs + 16);
 164                         cli_blob_pull_string(session, mem_ctx, blob,
 165                                              &parms->stream_info.out.streams[n].stream_name,
 166                                              ofs+4, ofs+24, STR_UNICODE);
 167                         parms->stream_info.out.num_streams++;
 168                         len = IVAL(blob->data, ofs);
 169                         if (len > blob->length - ofs) return NT_STATUS_INFO_LENGTH_MISMATCH;
 170                         if (len == 0) break;
 171                         ofs += len;
 172                 }
 173                 return NT_STATUS_OK;
 174
 175         case RAW_FILEINFO_INTERNAL_INFORMATION:
 176                 FINFO_CHECK_SIZE(8);
 177                 parms->internal_information.out.device = IVAL(blob->data, 0);
 178                 parms->internal_information.out.inode =  IVAL(blob->data, 4);
 179                 return NT_STATUS_OK;
 180
 181         case RAW_FILEINFO_ACCESS_INFORMATION:
 182                 FINFO_CHECK_SIZE(4);
 183                 parms->access_information.out.access_flags = IVAL(blob->data, 0);
 184                 return NT_STATUS_OK;
 185
 186         case RAW_FILEINFO_POSITION_INFORMATION:
 187                 FINFO_CHECK_SIZE(8);
 188                 parms->position_information.out.position = BVAL(blob->data, 0);
 189                 return NT_STATUS_OK;
 190
 191         case RAW_FILEINFO_MODE_INFORMATION:
 192                 FINFO_CHECK_SIZE(4);
 193                 parms->mode_information.out.mode = IVAL(blob->data, 0);
 194                 return NT_STATUS_OK;
 195
 196         case RAW_FILEINFO_ALIGNMENT_INFORMATION:
 197                 FINFO_CHECK_SIZE(4);
 198                 parms->alignment_information.out.alignment_requirement
 199                         = IVAL(blob->data, 0);
 200                 return NT_STATUS_OK;
 201
 202         case RAW_FILEINFO_COMPRESSION_INFO:
 203         case RAW_FILEINFO_COMPRESSION_INFORMATION:
 204                 FINFO_CHECK_SIZE(16);
 205                 parms->compression_info.out.compressed_size = BVAL(blob->data,  0);
 206                 parms->compression_info.out.format          = SVAL(blob->data,  8);
 207                 parms->compression_info.out.unit_shift      = CVAL(blob->data, 10);
 208                 parms->compression_info.out.chunk_shift     = CVAL(blob->data, 11);
 209                 parms->compression_info.out.cluster_shift   = CVAL(blob->data, 12);
 210                 /* 3 bytes of padding */
 211                 return NT_STATUS_OK;
 212
 213         case RAW_FILEINFO_UNIX_BASIC:
 214                 FINFO_CHECK_SIZE(100);
 215                 parms->unix_basic_info.out.end_of_file        =            BVAL(blob->data,  0);
 216                 parms->unix_basic_info.out.num_bytes          =            BVAL(blob->data,  8);
 217                 parms->unix_basic_info.out.status_change_time = cli_pull_nttime(blob->data, 16);
 218                 parms->unix_basic_info.out.access_time        = cli_pull_nttime(blob->data, 24);
 219                 parms->unix_basic_info.out.change_time        = cli_pull_nttime(blob->data, 32);
 220                 parms->unix_basic_info.out.uid                =            BVAL(blob->data, 40);
 221                 parms->unix_basic_info.out.gid                =            BVAL(blob->data, 48);
 222                 parms->unix_basic_info.out.file_type          =            IVAL(blob->data, 52);
 223                 parms->unix_basic_info.out.dev_major          =            BVAL(blob->data, 60);
 224                 parms->unix_basic_info.out.dev_minor          =            BVAL(blob->data, 68);
 225                 parms->unix_basic_info.out.unique_id          =            BVAL(blob->data, 76);
 226                 parms->unix_basic_info.out.permissions        =            BVAL(blob->data, 84);
 227                 parms->unix_basic_info.out.nlink              =            BVAL(blob->data, 92);
 228                 return NT_STATUS_OK;
 229
 230         case RAW_FILEINFO_UNIX_LINK:
 231                 FINFO_CHECK_MIN_SIZE(0);
 232                 cli_blob_pull_string(session, mem_ctx, blob,
 233                                      &parms->unix_link_info.out.link_dest, 0, 4, STR_UNICODE);
 234                 return NT_STATUS_OK;
 235
 236         case RAW_FILEINFO_NETWORK_OPEN_INFORMATION:
 237                 FINFO_CHECK_SIZE(56);
 238                 parms->network_open_information.out.create_time = cli_pull_nttime(blob->data,  0);
 239                 parms->network_open_information.out.access_time = cli_pull_nttime(blob->data,  8);
 240                 parms->network_open_information.out.write_time =  cli_pull_nttime(blob->data, 16);
 241                 parms->network_open_information.out.change_time = cli_pull_nttime(blob->data, 24);
 242                 parms->network_open_information.out.alloc_size =             BVAL(blob->data, 32);
 243                 parms->network_open_information.out.size =                   BVAL(blob->data, 40);
 244                 parms->network_open_information.out.attrib =                 IVAL(blob->data, 48);
 245                 return NT_STATUS_OK;
 246
 247         case RAW_FILEINFO_ATTRIBUTE_TAG_INFORMATION:
 248                 FINFO_CHECK_SIZE(8);
 249                 parms->attribute_tag_information.out.attrib =      IVAL(blob->data, 0);
 250                 parms->attribute_tag_information.out.reparse_tag = IVAL(blob->data, 4);
 251                 return NT_STATUS_OK;
 252         }
 253
 254         return NT_STATUS_INVALID_LEVEL;
 255 }
 256
 257 /****************************************************************************
 258  Very raw query file info - returns param/data blobs - (async send)
 259 ****************************************************************************/
 260 static struct cli_request *smb_raw_fileinfo_blob_send(struct cli_tree *tree,
 261                                                       uint16 fnum, uint16 info_level)
 262 {
 263         struct smb_trans2 tp;
 264         uint16 setup = TRANSACT2_QFILEINFO;
 265         struct cli_request *req;
 266         TALLOC_CTX *mem_ctx = talloc_init("raw_fileinfo");
 267
 268         tp.in.max_setup = 0;
 269         tp.in.flags = 0;
 270         tp.in.timeout = 0;
 271         tp.in.setup_count = 1;
 272         tp.in.data = data_blob(NULL, 0);
 273         tp.in.max_param = 2;
 274         tp.in.max_data = 0xFFFF;
 275         tp.in.setup = &setup;
 276
 277         tp.in.params = data_blob_talloc(mem_ctx, NULL, 4);
 278         if (!tp.in.params.data) {
 279                 talloc_destroy(mem_ctx);
 280                 return NULL;
 281         }
 282
 283         SIVAL(tp.in.params.data, 0, fnum);
 284         SSVAL(tp.in.params.data, 2, info_level);
 285
 286         req = smb_raw_trans2_send(tree, &tp);
 287
 288         talloc_destroy(mem_ctx);
 289
 290         return req;
 291 }
 292
 293
 294 /****************************************************************************
 295  Very raw query file info - returns param/data blobs - (async recv)
 296 ****************************************************************************/
 297 static NTSTATUS smb_raw_fileinfo_blob_recv(struct cli_request *req,
 298                                            TALLOC_CTX *mem_ctx,
 299                                            DATA_BLOB *blob)
 300 {
 301         struct smb_trans2 tp;
 302         NTSTATUS status = smb_raw_trans2_recv(req, mem_ctx, &tp);
 303         if (NT_STATUS_IS_OK(status)) {
 304                 *blob = tp.out.data;
 305         }
 306         return status;
 307 }
 308
 309 /****************************************************************************
 310  Very raw query path info - returns param/data blobs (async send)
 311 ****************************************************************************/
 312 static struct cli_request *smb_raw_pathinfo_blob_send(struct cli_tree *tree,
 313                                                       const char *fname,
 314                                                       uint16 info_level)
 315 {
 316         struct smb_trans2 tp;
 317         uint16 setup = TRANSACT2_QPATHINFO;
 318         struct cli_request *req;
 319         TALLOC_CTX *mem_ctx = talloc_init("raw_pathinfo");
 320
 321         tp.in.max_setup = 0;
 322         tp.in.flags = 0;
 323         tp.in.timeout = 0;
 324         tp.in.setup_count = 1;
 325         tp.in.data = data_blob(NULL, 0);
 326         tp.in.max_param = 2;
 327         tp.in.max_data = 0xFFFF;
 328         tp.in.setup = &setup;
 329
 330         tp.in.params = data_blob_talloc(mem_ctx, NULL, 6);
 331         if (!tp.in.params.data) {
 332                 talloc_destroy(mem_ctx);
 333                 return NULL;
 334         }
 335
 336         SSVAL(tp.in.params.data, 0, info_level);
 337         SIVAL(tp.in.params.data, 2, 0);
 338         cli_blob_append_string(tree->session, mem_ctx, &tp.in.params,
 339                                fname, STR_TERMINATE);
 340
 341         req = smb_raw_trans2_send(tree, &tp);
 342
 343         talloc_destroy(mem_ctx);
 344
 345         return req;
 346 }
 347
 348 /****************************************************************************
 349  send a SMBgetatr (async send)
 350 ****************************************************************************/
 351 static struct cli_request *smb_raw_getattr_send(struct cli_tree *tree,
 352                                                 union smb_fileinfo *parms)
 353 {
 354         struct cli_request *req;
 355
 356         req = cli_request_setup(tree, SMBgetatr, 0, 0);
 357         if (!req) return NULL;
 358
 359         cli_req_append_ascii4(req, parms->getattr.in.fname, STR_TERMINATE);
 360
 361         if (!cli_request_send(req)) {
 362                 cli_request_destroy(req);
 363                 return NULL;
 364         }
 365
 366         return req;
 367 }
 368
 369 /****************************************************************************
 370  send a SMBgetatr (async recv)
 371 ****************************************************************************/
 372 static NTSTATUS smb_raw_getattr_recv(struct cli_request *req,
 373                                      union smb_fileinfo *parms)
 374 {
 375         if (!cli_request_receive(req) ||
 376             cli_request_is_error(req)) {
 377                 return cli_request_destroy(req);
 378         }
 379
 380         CLI_CHECK_WCT(req, 10);
 381         parms->getattr.out.attrib =     SVAL(req->in.vwv, VWV(0));
 382         parms->getattr.out.write_time = make_unix_date3(req->in.vwv + VWV(1));
 383         parms->getattr.out.size =       IVAL(req->in.vwv, VWV(3));
 384
 385 failed:
 386         return cli_request_destroy(req);
 387 }
 388
 389
 390 /****************************************************************************
 391  Handle SMBgetattrE (async send)
 392 ****************************************************************************/
 393 static struct cli_request *smb_raw_getattrE_send(struct cli_tree *tree,
 394                                                  union smb_fileinfo *parms)
 395 {
 396         struct cli_request *req;
 397
 398         req = cli_request_setup(tree, SMBgetattrE, 1, 0);
 399         if (!req) return NULL;
 400
 401         SSVAL(req->out.vwv, VWV(0), parms->getattre.in.fnum);
 402         if (!cli_request_send(req)) {
 403                 cli_request_destroy(req);
 404                 return NULL;
 405         }
 406
 407         return req;
 408 }
 409
 410 /****************************************************************************
 411  Handle SMBgetattrE (async send)
 412 ****************************************************************************/
 413 static NTSTATUS smb_raw_getattrE_recv(struct cli_request *req,
 414                                       union smb_fileinfo *parms)
 415 {
 416         if (!cli_request_receive(req) ||
 417             cli_request_is_error(req)) {
 418                 return cli_request_destroy(req);
 419         }
 420
 421         CLI_CHECK_WCT(req, 11);
 422         parms->getattre.out.create_time =      make_unix_date2(req->in.vwv + VWV(0));
 423         parms->getattre.out.access_time =      make_unix_date2(req->in.vwv + VWV(2));
 424         parms->getattre.out.write_time  =      make_unix_date2(req->in.vwv + VWV(4));
 425         parms->getattre.out.size =       IVAL(req->in.vwv, VWV(6));
 426         parms->getattre.out.alloc_size = IVAL(req->in.vwv, VWV(8));
 427         parms->getattre.out.attrib =     SVAL(req->in.vwv, VWV(10));
 428
 429 failed:
 430         return cli_request_destroy(req);
 431 }
 432
 433
 434 /****************************************************************************
 435  Query file info (async send)
 436 ****************************************************************************/
 437 struct cli_request *smb_raw_fileinfo_send(struct cli_tree *tree,
 438                                           union smb_fileinfo *parms)
 439 {
 440         /* pass off the non-trans2 level to specialised functions */
 441         if (parms->generic.level == RAW_FILEINFO_GETATTRE) {
 442                 return smb_raw_getattrE_send(tree, parms);
 443         }
 444         if (parms->generic.level >= RAW_FILEINFO_GENERIC) {
 445                 return NULL;
 446         }
 447
 448         return smb_raw_fileinfo_blob_send(tree,
 449                                           parms->generic.in.fnum,
 450                                           parms->generic.level);
 451 }
 452
 453 /****************************************************************************
 454  Query file info (async recv)
 455 ****************************************************************************/
 456 NTSTATUS smb_raw_fileinfo_recv(struct cli_request *req,
 457                                TALLOC_CTX *mem_ctx,
 458                                union smb_fileinfo *parms)
 459 {
 460         DATA_BLOB blob;
 461         NTSTATUS status;
 462         struct cli_session *session = req?req->session:NULL;
 463
 464         if (parms->generic.level == RAW_FILEINFO_GETATTRE) {
 465                 return smb_raw_getattrE_recv(req, parms);
 466         }
 467         if (parms->generic.level == RAW_FILEINFO_GETATTR) {
 468                 return smb_raw_getattr_recv(req, parms);
 469         }
 470
 471         status = smb_raw_fileinfo_blob_recv(req, mem_ctx, &blob);
 472         if (!NT_STATUS_IS_OK(status)) {
 473                 return status;
 474         }
 475
 476         return smb_raw_info_backend(session, mem_ctx, parms, &blob);
 477 }
 478
 479 /****************************************************************************
 480  Query file info (sync interface)
 481 ****************************************************************************/
 482 NTSTATUS smb_raw_fileinfo(struct cli_tree *tree,
 483                           TALLOC_CTX *mem_ctx,
 484                           union smb_fileinfo *parms)
 485 {
 486         struct cli_request *req = smb_raw_fileinfo_send(tree, parms);
 487         return smb_raw_fileinfo_recv(req, mem_ctx, parms);
 488 }
 489
 490 /****************************************************************************
 491  Query path info (async send)
 492 ****************************************************************************/
 493 struct cli_request *smb_raw_pathinfo_send(struct cli_tree *tree,
 494                                           union smb_fileinfo *parms)
 495 {
 496         if (parms->generic.level == RAW_FILEINFO_GETATTR) {
 497                 return smb_raw_getattr_send(tree, parms);
 498         }
 499         if (parms->generic.level >= RAW_FILEINFO_GENERIC) {
 500                 return NULL;
 501         }
 502
 503         return smb_raw_pathinfo_blob_send(tree, parms->generic.in.fname,
 504                                           parms->generic.level);
 505 }
 506
 507 /****************************************************************************
 508  Query path info (async recv)
 509 ****************************************************************************/
 510 NTSTATUS smb_raw_pathinfo_recv(struct cli_request *req,
 511                                TALLOC_CTX *mem_ctx,
 512                                union smb_fileinfo *parms)
 513 {
 514         /* recv is idential to fileinfo */
 515         return smb_raw_fileinfo_recv(req, mem_ctx, parms);
 516 }
 517
 518 /****************************************************************************
 519  Query path info (sync interface)
 520 ****************************************************************************/
 521 NTSTATUS smb_raw_pathinfo(struct cli_tree *tree,
 522                           TALLOC_CTX *mem_ctx,
 523                           union smb_fileinfo *parms)
 524 {
 525         struct cli_request *req = smb_raw_pathinfo_send(tree, parms);
 526         return smb_raw_pathinfo_recv(req, mem_ctx, parms);
 527 }