source4/libcli/raw/rawfsinfo.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    RAW_QFS_* operations
   5
   6    Copyright (C) Andrew Tridgell 2003
   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 "libcli/raw/raw_proto.h"
  25 #include "librpc/gen_ndr/ndr_misc.h"
  26
  27 /****************************************************************************
  28  Query FS Info - SMBdskattr call (async send)
  29 ****************************************************************************/
  30 static struct smbcli_request *smb_raw_dskattr_send(struct smbcli_tree *tree,
  31                                                 union smb_fsinfo *fsinfo)
  32 {
  33         struct smbcli_request *req;
  34
  35         req = smbcli_request_setup(tree, SMBdskattr, 0, 0);
  36
  37         if (!smbcli_request_send(req)) {
  38                 smbcli_request_destroy(req);
  39                 return NULL;
  40         }
  41
  42         return req;
  43 }
  44
  45 /****************************************************************************
  46  Query FS Info - SMBdskattr call (async recv)
  47 ****************************************************************************/
  48 static NTSTATUS smb_raw_dskattr_recv(struct smbcli_request *req,
  49                                      union smb_fsinfo *fsinfo)
  50 {
  51         if (!smbcli_request_receive(req) ||
  52             smbcli_request_is_error(req)) {
  53                 goto failed;
  54         }
  55
  56         SMBCLI_CHECK_WCT(req, 5);
  57         fsinfo->dskattr.out.units_total =     SVAL(req->in.vwv, VWV(0));
  58         fsinfo->dskattr.out.blocks_per_unit = SVAL(req->in.vwv, VWV(1));
  59         fsinfo->dskattr.out.block_size =      SVAL(req->in.vwv, VWV(2));
  60         fsinfo->dskattr.out.units_free =      SVAL(req->in.vwv, VWV(3));
  61
  62 failed:
  63         return smbcli_request_destroy(req);
  64 }
  65
  66
  67 /****************************************************************************
  68  RAW_QFS_ trans2 interface via blobs (async send)
  69 ****************************************************************************/
  70 static struct smbcli_request *smb_raw_qfsinfo_send(struct smbcli_tree *tree,
  71                                                 TALLOC_CTX *mem_ctx,
  72                                                 uint16_t info_level)
  73 {
  74         struct smb_trans2 tp;
  75         uint16_t setup = TRANSACT2_QFSINFO;
  76
  77         tp.in.max_setup = 0;
  78         tp.in.flags = 0;
  79         tp.in.timeout = 0;
  80         tp.in.setup_count = 1;
  81         tp.in.max_param = 0;
  82         tp.in.max_data = 0xFFFF;
  83         tp.in.setup = &setup;
  84         tp.in.data = data_blob(NULL, 0);
  85         tp.in.timeout = 0;
  86
  87         tp.in.params = data_blob_talloc(mem_ctx, NULL, 2);
  88         if (!tp.in.params.data) {
  89                 return NULL;
  90         }
  91         SSVAL(tp.in.params.data, 0, info_level);
  92
  93         return smb_raw_trans2_send(tree, &tp);
  94 }
  95
  96 /****************************************************************************
  97  RAW_QFS_ trans2 interface via blobs (async recv)
  98 ****************************************************************************/
  99 static NTSTATUS smb_raw_qfsinfo_blob_recv(struct smbcli_request *req,
 100                                           TALLOC_CTX *mem_ctx,
 101                                           DATA_BLOB *blob)
 102 {
 103         struct smb_trans2 tp;
 104         NTSTATUS status;
 105
 106         status = smb_raw_trans2_recv(req, mem_ctx, &tp);
 107
 108         if (NT_STATUS_IS_OK(status)) {
 109                 (*blob) = tp.out.data;
 110         }
 111
 112         return status;
 113 }
 114
 115
 116 /* local macros to make the code more readable */
 117 #define QFS_CHECK_MIN_SIZE(size) if (blob.length < (size)) { \
 118       DEBUG(1,("Unexpected QFS reply size %d for level %u - expected min of %d\n", \
 119                (int)blob.length, fsinfo->generic.level, (size))); \
 120       status = NT_STATUS_INFO_LENGTH_MISMATCH; \
 121       goto failed; \
 122 }
 123 #define QFS_CHECK_SIZE(size) if (blob.length != (size)) { \
 124       DEBUG(1,("Unexpected QFS reply size %d for level %u - expected %d\n", \
 125                (int)blob.length, fsinfo->generic.level, (size))); \
 126       status = NT_STATUS_INFO_LENGTH_MISMATCH; \
 127       goto failed; \
 128 }
 129
 130
 131 /****************************************************************************
 132  Query FSInfo raw interface (async send)
 133 ****************************************************************************/
 134 struct smbcli_request *smb_raw_fsinfo_send(struct smbcli_tree *tree,
 135                                         TALLOC_CTX *mem_ctx,
 136                                         union smb_fsinfo *fsinfo)
 137 {
 138         uint16_t info_level;
 139
 140         /* handle the only non-trans2 call separately */
 141         if (fsinfo->generic.level == RAW_QFS_DSKATTR) {
 142                 return smb_raw_dskattr_send(tree, fsinfo);
 143         }
 144         if (fsinfo->generic.level >= RAW_QFS_GENERIC) {
 145                 return NULL;
 146         }
 147
 148         /* the headers map the trans2 levels direct to info levels */
 149         info_level = (uint16_t)fsinfo->generic.level;
 150
 151         return smb_raw_qfsinfo_send(tree, mem_ctx, info_level);
 152 }
 153
 154 /*
 155   parse the fsinfo 'passthru' level replies
 156 */
 157 NTSTATUS smb_raw_fsinfo_passthru_parse(DATA_BLOB blob, TALLOC_CTX *mem_ctx,
 158                                        enum smb_fsinfo_level level,
 159                                        union smb_fsinfo *fsinfo)
 160 {
 161         NTSTATUS status = NT_STATUS_OK;
 162         int i;
 163
 164         /* parse the results */
 165         switch (level) {
 166         case RAW_QFS_VOLUME_INFORMATION:
 167                 QFS_CHECK_MIN_SIZE(18);
 168                 fsinfo->volume_info.out.create_time   = smbcli_pull_nttime(blob.data, 0);
 169                 fsinfo->volume_info.out.serial_number = IVAL(blob.data, 8);
 170                 smbcli_blob_pull_string(NULL, mem_ctx, &blob,
 171                                         &fsinfo->volume_info.out.volume_name,
 172                                         12, 18, STR_UNICODE);
 173                 break;
 174
 175         case RAW_QFS_SIZE_INFORMATION:
 176                 QFS_CHECK_SIZE(24);
 177                 fsinfo->size_info.out.total_alloc_units = BVAL(blob.data,  0);
 178                 fsinfo->size_info.out.avail_alloc_units = BVAL(blob.data,  8);
 179                 fsinfo->size_info.out.sectors_per_unit =  IVAL(blob.data, 16);
 180                 fsinfo->size_info.out.bytes_per_sector =  IVAL(blob.data, 20);
 181                 break;
 182
 183         case RAW_QFS_DEVICE_INFORMATION:
 184                 QFS_CHECK_SIZE(8);
 185                 fsinfo->device_info.out.device_type     = IVAL(blob.data,  0);
 186                 fsinfo->device_info.out.characteristics = IVAL(blob.data,  4);
 187                 break;
 188
 189         case RAW_QFS_ATTRIBUTE_INFORMATION:
 190                 QFS_CHECK_MIN_SIZE(12);
 191                 fsinfo->attribute_info.out.fs_attr   =                 IVAL(blob.data, 0);
 192                 fsinfo->attribute_info.out.max_file_component_length = IVAL(blob.data, 4);
 193                 smbcli_blob_pull_string(NULL, mem_ctx, &blob,
 194                                         &fsinfo->attribute_info.out.fs_type,
 195                                         8, 12, STR_UNICODE);
 196                 break;
 197
 198         case RAW_QFS_QUOTA_INFORMATION:
 199                 QFS_CHECK_SIZE(48);
 200                 fsinfo->quota_information.out.unknown[0] =  BVAL(blob.data,  0);
 201                 fsinfo->quota_information.out.unknown[1] =  BVAL(blob.data,  8);
 202                 fsinfo->quota_information.out.unknown[2] =  BVAL(blob.data, 16);
 203                 fsinfo->quota_information.out.quota_soft =  BVAL(blob.data, 24);
 204                 fsinfo->quota_information.out.quota_hard =  BVAL(blob.data, 32);
 205                 fsinfo->quota_information.out.quota_flags = BVAL(blob.data, 40);
 206                 break;
 207
 208         case RAW_QFS_FULL_SIZE_INFORMATION:
 209                 QFS_CHECK_SIZE(32);
 210                 fsinfo->full_size_information.out.total_alloc_units =        BVAL(blob.data,  0);
 211                 fsinfo->full_size_information.out.call_avail_alloc_units =   BVAL(blob.data,  8);
 212                 fsinfo->full_size_information.out.actual_avail_alloc_units = BVAL(blob.data, 16);
 213                 fsinfo->full_size_information.out.sectors_per_unit =         IVAL(blob.data, 24);
 214                 fsinfo->full_size_information.out.bytes_per_sector =         IVAL(blob.data, 28);
 215                 break;
 216
 217         case RAW_QFS_OBJECTID_INFORMATION: {
 218                 DATA_BLOB b2 = data_blob_const(blob.data, MIN(16, blob.length));
 219                 QFS_CHECK_SIZE(64);
 220                 status = GUID_from_ndr_blob(&b2, &fsinfo->objectid_information.out.guid);
 221                 NT_STATUS_NOT_OK_RETURN(status);
 222                 for (i=0;i<6;i++) {
 223                         fsinfo->objectid_information.out.unknown[i] = BVAL(blob.data, 16 + i*8);
 224                 }
 225                 break;
 226         }
 227
 228         default:
 229                 status = NT_STATUS_INVALID_INFO_CLASS;
 230         }
 231
 232 failed:
 233         return status;
 234 }
 235
 236
 237 /****************************************************************************
 238  Query FSInfo raw interface (async recv)
 239 ****************************************************************************/
 240 NTSTATUS smb_raw_fsinfo_recv(struct smbcli_request *req,
 241                              TALLOC_CTX *mem_ctx,
 242                              union smb_fsinfo *fsinfo)
 243 {
 244         DATA_BLOB blob;
 245         NTSTATUS status;
 246         struct smbcli_session *session = req?req->session:NULL;
 247
 248         if (fsinfo->generic.level == RAW_QFS_DSKATTR) {
 249                 return smb_raw_dskattr_recv(req, fsinfo);
 250         }
 251
 252         status = smb_raw_qfsinfo_blob_recv(req, mem_ctx, &blob);
 253         if (!NT_STATUS_IS_OK(status)) {
 254                 return status;
 255         }
 256
 257         /* parse the results */
 258         switch (fsinfo->generic.level) {
 259         case RAW_QFS_GENERIC:
 260         case RAW_QFS_DSKATTR:
 261                 /* handled above */
 262                 break;
 263
 264         case RAW_QFS_ALLOCATION:
 265                 QFS_CHECK_SIZE(18);
 266                 fsinfo->allocation.out.fs_id =             IVAL(blob.data,  0);
 267                 fsinfo->allocation.out.sectors_per_unit =  IVAL(blob.data,  4);
 268                 fsinfo->allocation.out.total_alloc_units = IVAL(blob.data,  8);
 269                 fsinfo->allocation.out.avail_alloc_units = IVAL(blob.data, 12);
 270                 fsinfo->allocation.out.bytes_per_sector =  SVAL(blob.data, 16);
 271                 break;
 272
 273         case RAW_QFS_VOLUME:
 274                 QFS_CHECK_MIN_SIZE(5);
 275                 fsinfo->volume.out.serial_number = IVAL(blob.data, 0);
 276                 smbcli_blob_pull_string(session, mem_ctx, &blob,
 277                                      &fsinfo->volume.out.volume_name,
 278                                      4, 5, STR_LEN8BIT | STR_NOALIGN);
 279                 break;
 280
 281         case RAW_QFS_VOLUME_INFO:
 282         case RAW_QFS_VOLUME_INFORMATION:
 283                 return smb_raw_fsinfo_passthru_parse(blob, mem_ctx,
 284                                                      RAW_QFS_VOLUME_INFORMATION, fsinfo);
 285
 286         case RAW_QFS_SIZE_INFO:
 287         case RAW_QFS_SIZE_INFORMATION:
 288                 return smb_raw_fsinfo_passthru_parse(blob, mem_ctx,
 289                                                      RAW_QFS_SIZE_INFORMATION, fsinfo);
 290
 291         case RAW_QFS_DEVICE_INFO:
 292         case RAW_QFS_DEVICE_INFORMATION:
 293                 return smb_raw_fsinfo_passthru_parse(blob, mem_ctx,
 294                                                      RAW_QFS_DEVICE_INFORMATION, fsinfo);
 295
 296         case RAW_QFS_ATTRIBUTE_INFO:
 297         case RAW_QFS_ATTRIBUTE_INFORMATION:
 298                 return smb_raw_fsinfo_passthru_parse(blob, mem_ctx,
 299                                                      RAW_QFS_ATTRIBUTE_INFORMATION, fsinfo);
 300
 301         case RAW_QFS_UNIX_INFO:
 302                 QFS_CHECK_SIZE(12);
 303                 fsinfo->unix_info.out.major_version = SVAL(blob.data, 0);
 304                 fsinfo->unix_info.out.minor_version = SVAL(blob.data, 2);
 305                 fsinfo->unix_info.out.capability    = SVAL(blob.data, 4);
 306                 break;
 307
 308         case RAW_QFS_QUOTA_INFORMATION:
 309                 return smb_raw_fsinfo_passthru_parse(blob, mem_ctx,
 310                                                      RAW_QFS_QUOTA_INFORMATION, fsinfo);
 311
 312         case RAW_QFS_FULL_SIZE_INFORMATION:
 313                 return smb_raw_fsinfo_passthru_parse(blob, mem_ctx,
 314                                                      RAW_QFS_FULL_SIZE_INFORMATION, fsinfo);
 315
 316         case RAW_QFS_OBJECTID_INFORMATION:
 317                 return smb_raw_fsinfo_passthru_parse(blob, mem_ctx,
 318                                                      RAW_QFS_OBJECTID_INFORMATION, fsinfo);
 319         }
 320
 321 failed:
 322         return status;
 323 }
 324
 325 /****************************************************************************
 326  Query FSInfo raw interface (sync interface)
 327 ****************************************************************************/
 328 _PUBLIC_ NTSTATUS smb_raw_fsinfo(struct smbcli_tree *tree,
 329                         TALLOC_CTX *mem_ctx,
 330                         union smb_fsinfo *fsinfo)
 331 {
 332         struct smbcli_request *req = smb_raw_fsinfo_send(tree, mem_ctx, fsinfo);
 333         return smb_raw_fsinfo_recv(req, mem_ctx, fsinfo);
 334 }
 335
 336 /****************************************************************************
 337  Set FSInfo raw interface (async recv)
 338 ****************************************************************************/
 339 static NTSTATUS smb_raw_setfsinfo_recv(struct smbcli_request *req,
 340                              TALLOC_CTX *mem_ctx,
 341                              union smb_setfsinfo *set_fsinfo)
 342 {
 343         DATA_BLOB blob = data_blob_null;
 344         NTSTATUS status;
 345
 346         if (set_fsinfo->generic.level != RAW_SETFS_UNIX_INFO) {
 347                 return NT_STATUS_INVALID_PARAMETER;
 348         }
 349
 350         status = smb_raw_qfsinfo_blob_recv(req, mem_ctx, &blob);
 351         data_blob_free(&blob);
 352         return status;
 353 }
 354
 355 /****************************************************************************
 356  Set FSInfo raw interface (async send)
 357 ****************************************************************************/
 358 static struct smbcli_request *smb_raw_setfsinfo_send(struct smbcli_tree *tree,
 359                                                 TALLOC_CTX *mem_ctx,
 360                                                 union smb_setfsinfo *set_fsinfo)
 361 {
 362         struct smb_trans2 tp;
 363         uint16_t info_level;
 364         uint16_t setup = TRANSACT2_SETFSINFO;
 365
 366         if (set_fsinfo->generic.level != RAW_SETFS_UNIX_INFO) {
 367                 return NULL;
 368         }
 369         tp.in.max_setup = 0;
 370         tp.in.flags = 0;
 371         tp.in.timeout = 0;
 372         tp.in.setup_count = 1;
 373         tp.in.max_param = 0;
 374         tp.in.max_data = 0xFFFF;
 375         tp.in.setup = &setup;
 376         tp.in.timeout = 0;
 377
 378         tp.in.params = data_blob_talloc(mem_ctx, NULL, 4);
 379         if (!tp.in.params.data) {
 380                 return NULL;
 381         }
 382         info_level = (uint16_t)set_fsinfo->generic.level;
 383         SSVAL(tp.in.params.data, 0, 0);
 384         SSVAL(tp.in.params.data, 2, info_level);
 385
 386         tp.in.data = data_blob_talloc(mem_ctx, NULL, 12);
 387         if (!tp.in.data.data) {
 388                 return NULL;
 389         }
 390
 391         SSVAL(tp.in.data.data, 0, set_fsinfo->unix_info.in.major_version);
 392         SSVAL(tp.in.data.data, 2, set_fsinfo->unix_info.in.minor_version);
 393         SBVAL(tp.in.data.data, 4, set_fsinfo->unix_info.in.capability);
 394
 395         return smb_raw_trans2_send(tree, &tp);
 396 }
 397
 398 /****************************************************************************
 399  Set FSInfo raw interface (sync interface)
 400 ****************************************************************************/
 401 _PUBLIC_ NTSTATUS smb_raw_setfsinfo(struct smbcli_tree *tree,
 402                         TALLOC_CTX *mem_ctx,
 403                         union smb_setfsinfo *set_fsinfo)
 404 {
 405         struct smbcli_request *req = smb_raw_setfsinfo_send(tree, mem_ctx, set_fsinfo);
 406         return smb_raw_setfsinfo_recv(req, mem_ctx, set_fsinfo);
 407 }