source: vendor/current/source4/libcli/raw/rawfsinfo.c

Last change on this file was 988, checked in by Silvan Scherrer, 9 years ago

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