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