?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3:smbd: change blocking.c to use fsp_fnum_dbg() for fsp->fnum logging.
[Samba/gebeck_regimport.git] / source3 / smbd / smb2_find.c
blob187a5ffa655a2bfb81d3bb6c1c9bb4a2ad67a681
1 /*
2 Unix SMB/CIFS implementation.
3 Core SMB2 server
4
5 Copyright (C) Stefan Metzmacher 2009
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 3 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, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include "includes.h"
22 #include "smbd/smbd.h"
23 #include "smbd/globals.h"
24 #include "../libcli/smb/smb_common.h"
25 #include "trans2.h"
26 #include "../lib/util/tevent_ntstatus.h"
27
28 static struct tevent_req *smbd_smb2_find_send(TALLOC_CTX *mem_ctx,
29 struct tevent_context *ev,
30 struct smbd_smb2_request *smb2req,
31 struct files_struct *in_fsp,
32 uint8_t in_file_info_class,
33 uint8_t in_flags,
34 uint32_t in_file_index,
35 uint32_t in_output_buffer_length,
36 const char *in_file_name);
37 static NTSTATUS smbd_smb2_find_recv(struct tevent_req *req,
38 TALLOC_CTX *mem_ctx,
39 DATA_BLOB *out_output_buffer);
40
41 static void smbd_smb2_request_find_done(struct tevent_req *subreq);
42 NTSTATUS smbd_smb2_request_process_find(struct smbd_smb2_request *req)
43 {
44 NTSTATUS status;
45 const uint8_t *inbody;
46 int i = req->current_idx;
47 uint8_t in_file_info_class;
48 uint8_t in_flags;
49 uint32_t in_file_index;
50 uint64_t in_file_id_persistent;
51 uint64_t in_file_id_volatile;
52 struct files_struct *in_fsp;
53 uint16_t in_file_name_offset;
54 uint16_t in_file_name_length;
55 DATA_BLOB in_file_name_buffer;
56 char *in_file_name_string;
57 size_t in_file_name_string_size;
58 uint32_t in_output_buffer_length;
59 struct tevent_req *subreq;
60 bool ok;
61
62 status = smbd_smb2_request_verify_sizes(req, 0x21);
63 if (!NT_STATUS_IS_OK(status)) {
64 return smbd_smb2_request_error(req, status);
65 }
66 inbody = (const uint8_t *)req->in.vector[i+1].iov_base;
67
68 in_file_info_class = CVAL(inbody, 0x02);
69 in_flags = CVAL(inbody, 0x03);
70 in_file_index = IVAL(inbody, 0x04);
71 in_file_id_persistent = BVAL(inbody, 0x08);
72 in_file_id_volatile = BVAL(inbody, 0x10);
73 in_file_name_offset = SVAL(inbody, 0x18);
74 in_file_name_length = SVAL(inbody, 0x1A);
75 in_output_buffer_length = IVAL(inbody, 0x1C);
76
77 if (in_file_name_offset == 0 && in_file_name_length == 0) {
78 /* This is ok */
79 } else if (in_file_name_offset !=
80 (SMB2_HDR_BODY + req->in.vector[i+1].iov_len)) {
81 return smbd_smb2_request_error(req, NT_STATUS_INVALID_PARAMETER);
82 }
83
84 if (in_file_name_length > req->in.vector[i+2].iov_len) {
85 return smbd_smb2_request_error(req, NT_STATUS_INVALID_PARAMETER);
86 }
87
88 /* The output header is 8 bytes. */
89 if (in_output_buffer_length <= 8) {
90 return smbd_smb2_request_error(req, NT_STATUS_INVALID_PARAMETER);
91 }
92
93 DEBUG(10,("smbd_smb2_request_find_done: in_output_buffer_length = %u\n",
94 (unsigned int)in_output_buffer_length ));
95
96 /* Take into account the output header. */
97 in_output_buffer_length -= 8;
98
99 in_file_name_buffer.data = (uint8_t *)req->in.vector[i+2].iov_base;
100 in_file_name_buffer.length = in_file_name_length;
101
102 ok = convert_string_talloc(req, CH_UTF16, CH_UNIX,
103 in_file_name_buffer.data,
104 in_file_name_buffer.length,
105 &in_file_name_string,
106 &in_file_name_string_size);
107 if (!ok) {
108 return smbd_smb2_request_error(req, NT_STATUS_ILLEGAL_CHARACTER);
109 }
110
111 if (in_file_name_buffer.length == 0) {
112 in_file_name_string_size = 0;
113 }
114
115 if (strlen(in_file_name_string) != in_file_name_string_size) {
116 return smbd_smb2_request_error(req, NT_STATUS_OBJECT_NAME_INVALID);
117 }
118
119 in_fsp = file_fsp_smb2(req, in_file_id_persistent, in_file_id_volatile);
120 if (in_fsp == NULL) {
121 return smbd_smb2_request_error(req, NT_STATUS_FILE_CLOSED);
122 }
123
124 subreq = smbd_smb2_find_send(req, req->sconn->ev_ctx,
125 req, in_fsp,
126 in_file_info_class,
127 in_flags,
128 in_file_index,
129 in_output_buffer_length,
130 in_file_name_string);
131 if (subreq == NULL) {
132 return smbd_smb2_request_error(req, NT_STATUS_NO_MEMORY);
133 }
134 tevent_req_set_callback(subreq, smbd_smb2_request_find_done, req);
135
136 return smbd_smb2_request_pending_queue(req, subreq, 500);
137 }
138
139 static void smbd_smb2_request_find_done(struct tevent_req *subreq)
140 {
141 struct smbd_smb2_request *req = tevent_req_callback_data(subreq,
142 struct smbd_smb2_request);
143 DATA_BLOB outbody;
144 DATA_BLOB outdyn;
145 uint16_t out_output_buffer_offset;
146 DATA_BLOB out_output_buffer = data_blob_null;
147 NTSTATUS status;
148 NTSTATUS error; /* transport error */
149
150 status = smbd_smb2_find_recv(subreq,
151 req,
152 &out_output_buffer);
153 TALLOC_FREE(subreq);
154 if (!NT_STATUS_IS_OK(status)) {
155 error = smbd_smb2_request_error(req, status);
156 if (!NT_STATUS_IS_OK(error)) {
157 smbd_server_connection_terminate(req->sconn,
158 nt_errstr(error));
159 return;
160 }
161 return;
162 }
163
164 out_output_buffer_offset = SMB2_HDR_BODY + 0x08;
165
166 outbody = data_blob_talloc(req->out.vector, NULL, 0x08);
167 if (outbody.data == NULL) {
168 error = smbd_smb2_request_error(req, NT_STATUS_NO_MEMORY);
169 if (!NT_STATUS_IS_OK(error)) {
170 smbd_server_connection_terminate(req->sconn,
171 nt_errstr(error));
172 return;
173 }
174 return;
175 }
176
177 SSVAL(outbody.data, 0x00, 0x08 + 1); /* struct size */
178 SSVAL(outbody.data, 0x02,
179 out_output_buffer_offset); /* output buffer offset */
180 SIVAL(outbody.data, 0x04,
181 out_output_buffer.length); /* output buffer length */
182
183 DEBUG(10,("smbd_smb2_request_find_done: out_output_buffer.length = %u\n",
184 (unsigned int)out_output_buffer.length ));
185
186 outdyn = out_output_buffer;
187
188 error = smbd_smb2_request_done(req, outbody, &outdyn);
189 if (!NT_STATUS_IS_OK(error)) {
190 smbd_server_connection_terminate(req->sconn,
191 nt_errstr(error));
192 return;
193 }
194 }
195
196 struct smbd_smb2_find_state {
197 struct smbd_smb2_request *smb2req;
198 DATA_BLOB out_output_buffer;
199 };
200
201 static struct tevent_req *smbd_smb2_find_send(TALLOC_CTX *mem_ctx,
202 struct tevent_context *ev,
203 struct smbd_smb2_request *smb2req,
204 struct files_struct *fsp,
205 uint8_t in_file_info_class,
206 uint8_t in_flags,
207 uint32_t in_file_index,
208 uint32_t in_output_buffer_length,
209 const char *in_file_name)
210 {
211 struct tevent_req *req;
212 struct smbd_smb2_find_state *state;
213 struct smb_request *smbreq;
214 connection_struct *conn = smb2req->tcon->compat_conn;
215 NTSTATUS status;
216 NTSTATUS empty_status;
217 uint32_t info_level;
218 uint32_t max_count;
219 char *pdata;
220 char *base_data;
221 char *end_data;
222 int last_entry_off = 0;
223 int off = 0;
224 uint32_t num = 0;
225 uint32_t dirtype = FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_DIRECTORY;
226 bool dont_descend = false;
227 bool ask_sharemode = true;
228
229 req = tevent_req_create(mem_ctx, &state,
230 struct smbd_smb2_find_state);
231 if (req == NULL) {
232 return NULL;
233 }
234 state->smb2req = smb2req;
235 state->out_output_buffer = data_blob_null;
236
237 DEBUG(10,("smbd_smb2_find_send: %s - fnum[%d]\n",
238 fsp_str_dbg(fsp), fsp->fnum));
239
240 smbreq = smbd_smb2_fake_smb_request(smb2req);
241 if (tevent_req_nomem(smbreq, req)) {
242 return tevent_req_post(req, ev);
243 }
244
245 if (!fsp->is_directory) {
246 tevent_req_nterror(req, NT_STATUS_NOT_SUPPORTED);
247 return tevent_req_post(req, ev);
248 }
249
250 if (strcmp(in_file_name, "") == 0) {
251 tevent_req_nterror(req, NT_STATUS_OBJECT_NAME_INVALID);
252 return tevent_req_post(req, ev);
253 }
254 if (strcmp(in_file_name, "\\") == 0) {
255 tevent_req_nterror(req, NT_STATUS_OBJECT_NAME_INVALID);
256 return tevent_req_post(req, ev);
257 }
258 if (strcmp(in_file_name, "/") == 0) {
259 tevent_req_nterror(req, NT_STATUS_OBJECT_NAME_INVALID);
260 return tevent_req_post(req, ev);
261 }
262
263 if (in_output_buffer_length > smb2req->sconn->smb2.max_trans) {
264 DEBUG(2,("smbd_smb2_find_send: "
265 "client ignored max trans:%s: 0x%08X: 0x%08X\n",
266 __location__, in_output_buffer_length,
267 smb2req->sconn->smb2.max_trans));
268 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
269 return tevent_req_post(req, ev);
270 }
271
272 status = smbd_smb2_request_verify_creditcharge(smb2req,
273 in_output_buffer_length);
274
275 if (!NT_STATUS_IS_OK(status)) {
276 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
277 return tevent_req_post(req, ev);
278 }
279
280 switch (in_file_info_class) {
281 case SMB2_FIND_DIRECTORY_INFO:
282 info_level = SMB_FIND_FILE_DIRECTORY_INFO;
283 break;
284
285 case SMB2_FIND_FULL_DIRECTORY_INFO:
286 info_level = SMB_FIND_FILE_FULL_DIRECTORY_INFO;
287 break;
288
289 case SMB2_FIND_BOTH_DIRECTORY_INFO:
290 info_level = SMB_FIND_FILE_BOTH_DIRECTORY_INFO;
291 break;
292
293 case SMB2_FIND_NAME_INFO:
294 info_level = SMB_FIND_FILE_NAMES_INFO;
295 break;
296
297 case SMB2_FIND_ID_BOTH_DIRECTORY_INFO:
298 info_level = SMB_FIND_ID_BOTH_DIRECTORY_INFO;
299 break;
300
301 case SMB2_FIND_ID_FULL_DIRECTORY_INFO:
302 info_level = SMB_FIND_ID_FULL_DIRECTORY_INFO;
303 break;
304
305 default:
306 tevent_req_nterror(req, NT_STATUS_INVALID_INFO_CLASS);
307 return tevent_req_post(req, ev);
308 }
309
310 if (in_flags & SMB2_CONTINUE_FLAG_REOPEN) {
311 dptr_CloseDir(fsp);
312 }
313
314 if (fsp->dptr == NULL) {
315 bool wcard_has_wild;
316
317 wcard_has_wild = ms_has_wild(in_file_name);
318
319 status = dptr_create(conn,
320 NULL, /* req */
321 fsp,
322 fsp->fsp_name->base_name,
323 false, /* old_handle */
324 false, /* expect_close */
325 0, /* spid */
326 in_file_name, /* wcard */
327 wcard_has_wild,
328 dirtype,
329 &fsp->dptr);
330 if (!NT_STATUS_IS_OK(status)) {
331 tevent_req_nterror(req, status);
332 return tevent_req_post(req, ev);
333 }
334
335 empty_status = NT_STATUS_NO_SUCH_FILE;
336 } else {
337 empty_status = STATUS_NO_MORE_FILES;
338 }
339
340 if (in_flags & SMB2_CONTINUE_FLAG_RESTART) {
341 dptr_SeekDir(fsp->dptr, 0);
342 }
343
344 if (in_flags & SMB2_CONTINUE_FLAG_SINGLE) {
345 max_count = 1;
346 } else {
347 max_count = UINT16_MAX;
348 }
349
350 #define DIR_ENTRY_SAFETY_MARGIN 4096
351
352 state->out_output_buffer = data_blob_talloc(state, NULL,
353 in_output_buffer_length + DIR_ENTRY_SAFETY_MARGIN);
354 if (tevent_req_nomem(state->out_output_buffer.data, req)) {
355 return tevent_req_post(req, ev);
356 }
357
358 state->out_output_buffer.length = 0;
359 pdata = (char *)state->out_output_buffer.data;
360 base_data = pdata;
361 /*
362 * end_data must include the safety margin as it's what is
363 * used to determine if pushed strings have been truncated.
364 */
365 end_data = pdata + in_output_buffer_length + DIR_ENTRY_SAFETY_MARGIN - 1;
366 last_entry_off = 0;
367 off = 0;
368 num = 0;
369
370 DEBUG(8,("smbd_smb2_find_send: dirpath=<%s> dontdescend=<%s>, "
371 "in_output_buffer_length = %u\n",
372 fsp->fsp_name->base_name, lp_dontdescend(SNUM(conn)),
373 (unsigned int)in_output_buffer_length ));
374 if (in_list(fsp->fsp_name->base_name,lp_dontdescend(SNUM(conn)),
375 conn->case_sensitive)) {
376 dont_descend = true;
377 }
378
379 ask_sharemode = lp_parm_bool(SNUM(conn),
380 "smbd", "search ask sharemode",
381 true);
382
383 while (true) {
384 bool ok;
385 bool got_exact_match = false;
386 bool out_of_space = false;
387 int space_remaining = in_output_buffer_length - off;
388
389 SMB_ASSERT(space_remaining >= 0);
390
391 ok = smbd_dirptr_lanman2_entry(state,
392 conn,
393 fsp->dptr,
394 smbreq->flags2,
395 in_file_name,
396 dirtype,
397 info_level,
398 false, /* requires_resume_key */
399 dont_descend,
400 ask_sharemode,
401 8, /* align to 8 bytes */
402 false, /* no padding */
403 &pdata,
404 base_data,
405 end_data,
406 space_remaining,
407 &out_of_space,
408 &got_exact_match,
409 &last_entry_off,
410 NULL);
411
412 off = (int)PTR_DIFF(pdata, base_data);
413
414 if (!ok) {
415 if (num > 0) {
416 SIVAL(state->out_output_buffer.data, last_entry_off, 0);
417 tevent_req_done(req);
418 return tevent_req_post(req, ev);
419 } else if (out_of_space) {
420 tevent_req_nterror(req, NT_STATUS_INFO_LENGTH_MISMATCH);
421 return tevent_req_post(req, ev);
422 } else {
423 tevent_req_nterror(req, empty_status);
424 return tevent_req_post(req, ev);
425 }
426 }
427
428 num++;
429 state->out_output_buffer.length = off;
430
431 if (num < max_count) {
432 continue;
433 }
434
435 SIVAL(state->out_output_buffer.data, last_entry_off, 0);
436 tevent_req_done(req);
437 return tevent_req_post(req, ev);
438 }
439
440 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
441 return tevent_req_post(req, ev);
442 }
443
444 static NTSTATUS smbd_smb2_find_recv(struct tevent_req *req,
445 TALLOC_CTX *mem_ctx,
446 DATA_BLOB *out_output_buffer)
447 {
448 NTSTATUS status;
449 struct smbd_smb2_find_state *state = tevent_req_data(req,
450 struct smbd_smb2_find_state);
451
452 if (tevent_req_is_nterror(req, &status)) {
453 tevent_req_received(req);
454 return status;
455 }
456
457 *out_output_buffer = state->out_output_buffer;
458 talloc_steal(mem_ctx, out_output_buffer->data);
459
460 tevent_req_received(req);
461 return NT_STATUS_OK;
462 }
reg import