docs-xml: fix pid directory example
[Samba/gebeck_regimport.git] / libcli / smb / smb2cli_query_info.c
blob80cec9c3cc9a066a600f168f23fece6b6c541249
1 /*
2 Unix SMB/CIFS implementation.
3 smb2 lib
4 Copyright (C) Stefan Metzmacher 2012
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
20 #include "includes.h"
21 #include "system/network.h"
22 #include "lib/util/tevent_ntstatus.h"
23 #include "smb_common.h"
24 #include "smbXcli_base.h"
26 struct smb2cli_query_info_state {
27 uint8_t fixed[0x28];
28 uint8_t dyn_pad[1];
29 uint32_t max_output_length;
30 struct iovec *recv_iov;
31 DATA_BLOB out_output_buffer;
34 static void smb2cli_query_info_done(struct tevent_req *subreq);
36 struct tevent_req *smb2cli_query_info_send(TALLOC_CTX *mem_ctx,
37 struct tevent_context *ev,
38 struct smbXcli_conn *conn,
39 uint32_t timeout_msec,
40 struct smbXcli_session *session,
41 struct smbXcli_tcon *tcon,
42 uint8_t in_info_type,
43 uint8_t in_file_info_class,
44 uint32_t in_max_output_length,
45 const DATA_BLOB *in_input_buffer,
46 uint32_t in_additional_info,
47 uint32_t in_flags,
48 uint64_t in_fid_persistent,
49 uint64_t in_fid_volatile)
51 struct tevent_req *req, *subreq;
52 struct smb2cli_query_info_state *state;
53 uint8_t *fixed;
54 uint8_t *dyn;
55 size_t dyn_len;
56 uint16_t input_buffer_offset = 0;
57 uint32_t input_buffer_length = 0;
59 req = tevent_req_create(mem_ctx, &state,
60 struct smb2cli_query_info_state);
61 if (req == NULL) {
62 return NULL;
64 state->max_output_length = in_max_output_length;
66 if (in_input_buffer) {
67 input_buffer_offset = SMB2_HDR_BODY+0x28;
68 input_buffer_length = in_input_buffer->length;
71 fixed = state->fixed;
73 SSVAL(fixed, 0x00, 0x29);
74 SCVAL(fixed, 0x02, in_info_type);
75 SCVAL(fixed, 0x03, in_file_info_class); /* reserved */
76 SIVAL(fixed, 0x04, in_max_output_length);
77 SSVAL(fixed, 0x08, input_buffer_offset);
78 SSVAL(fixed, 0x0A, 0); /* reserved */
79 SIVAL(fixed, 0x0C, input_buffer_length);
80 SIVAL(fixed, 0x10, in_additional_info);
81 SIVAL(fixed, 0x14, in_flags);
82 SBVAL(fixed, 0x18, in_fid_persistent);
83 SBVAL(fixed, 0x20, in_fid_volatile);
85 if (input_buffer_length > 0) {
86 dyn = in_input_buffer->data;
87 dyn_len = in_input_buffer->length;
88 } else {
89 dyn = state->dyn_pad;
90 dyn_len = sizeof(state->dyn_pad);
93 subreq = smb2cli_req_send(state, ev, conn, SMB2_OP_GETINFO,
94 0, 0, /* flags */
95 timeout_msec,
96 tcon,
97 session,
98 state->fixed, sizeof(state->fixed),
99 dyn, dyn_len);
100 if (tevent_req_nomem(subreq, req)) {
101 return tevent_req_post(req, ev);
103 tevent_req_set_callback(subreq, smb2cli_query_info_done, req);
104 return req;
107 static void smb2cli_query_info_done(struct tevent_req *subreq)
109 struct tevent_req *req =
110 tevent_req_callback_data(subreq,
111 struct tevent_req);
112 struct smb2cli_query_info_state *state =
113 tevent_req_data(req,
114 struct smb2cli_query_info_state);
115 NTSTATUS status;
116 struct iovec *iov;
117 uint8_t *fixed;
118 uint8_t *dyn;
119 size_t dyn_len;
120 uint32_t dyn_ofs = SMB2_HDR_BODY + 0x08;
121 uint32_t output_buffer_offset;
122 uint32_t output_buffer_length;
123 static const struct smb2cli_req_expected_response expected[] = {
125 .status = NT_STATUS_OK,
126 .body_size = 0x09
129 .status = STATUS_BUFFER_OVERFLOW,
130 .body_size = 0x09
134 status = smb2cli_req_recv(subreq, state, &iov,
135 expected, ARRAY_SIZE(expected));
136 if (tevent_req_nterror(req, status)) {
137 return;
140 state->recv_iov = iov;
141 fixed = (uint8_t *)iov[1].iov_base;
142 dyn = (uint8_t *)iov[2].iov_base;
143 dyn_len = iov[2].iov_len;
145 output_buffer_offset = SVAL(fixed, 0x02);
146 output_buffer_length = IVAL(fixed, 0x04);
148 if ((output_buffer_offset > 0) && (output_buffer_length > 0)) {
149 if (output_buffer_offset != dyn_ofs) {
150 tevent_req_nterror(
151 req, NT_STATUS_INVALID_NETWORK_RESPONSE);
152 return;
155 if (output_buffer_length < dyn_len) {
156 tevent_req_nterror(
157 req, NT_STATUS_INVALID_NETWORK_RESPONSE);
158 return;
161 if (output_buffer_length > state->max_output_length) {
162 tevent_req_nterror(
163 req, NT_STATUS_INVALID_NETWORK_RESPONSE);
164 return;
167 state->out_output_buffer.data = dyn;
168 state->out_output_buffer.length = output_buffer_length;
171 tevent_req_done(req);
174 NTSTATUS smb2cli_query_info_recv(struct tevent_req *req,
175 TALLOC_CTX *mem_ctx,
176 DATA_BLOB *out_output_buffer)
178 struct smb2cli_query_info_state *state =
179 tevent_req_data(req,
180 struct smb2cli_query_info_state);
181 NTSTATUS status;
183 if (tevent_req_is_nterror(req, &status)) {
184 tevent_req_received(req);
185 return status;
188 talloc_steal(mem_ctx, state->recv_iov);
189 if (out_output_buffer) {
190 *out_output_buffer = state->out_output_buffer;
193 tevent_req_received(req);
194 return NT_STATUS_OK;
197 NTSTATUS smb2cli_query_info(struct smbXcli_conn *conn,
198 uint32_t timeout_msec,
199 struct smbXcli_session *session,
200 struct smbXcli_tcon *tcon,
201 uint8_t in_info_type,
202 uint8_t in_file_info_class,
203 uint32_t in_max_output_length,
204 const DATA_BLOB *in_input_buffer,
205 uint32_t in_additional_info,
206 uint32_t in_flags,
207 uint64_t in_fid_persistent,
208 uint64_t in_fid_volatile,
209 TALLOC_CTX *mem_ctx,
210 DATA_BLOB *out_output_buffer)
212 TALLOC_CTX *frame = talloc_stackframe();
213 struct tevent_context *ev;
214 struct tevent_req *req;
215 NTSTATUS status = NT_STATUS_NO_MEMORY;
217 if (smbXcli_conn_has_async_calls(conn)) {
219 * Can't use sync call while an async call is in flight
221 status = NT_STATUS_INVALID_PARAMETER_MIX;
222 goto fail;
224 ev = tevent_context_init(frame);
225 if (ev == NULL) {
226 goto fail;
228 req = smb2cli_query_info_send(frame, ev,
229 conn, timeout_msec,
230 session, tcon,
231 in_info_type,
232 in_file_info_class,
233 in_max_output_length,
234 in_input_buffer,
235 in_additional_info,
236 in_flags,
237 in_fid_persistent,
238 in_fid_volatile);
239 if (req == NULL) {
240 goto fail;
242 if (!tevent_req_poll_ntstatus(req, ev, &status)) {
243 goto fail;
245 status = smb2cli_query_info_recv(req, mem_ctx,
246 out_output_buffer);
247 fail:
248 TALLOC_FREE(frame);
249 return status;