?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s4:ntvfs/ipc/vfs_ipc.c - add more "const" in order to fix warnings
[Samba/ekacnet.git] / source4 / ntvfs / ipc / vfs_ipc.c
blob676f545832e24f5ef444fb27d06f0359e093335d
1 /*
2 Unix SMB/CIFS implementation.
3 default IPC$ NTVFS backend
4
5 Copyright (C) Andrew Tridgell 2003
6 Copyright (C) Stefan (metze) Metzmacher 2004-2005
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 this implements the IPC$ backend, called by the NTVFS subsystem to
23 handle requests on IPC$ shares
24 */
25
26
27 #include "includes.h"
28 #include "../lib/util/dlinklist.h"
29 #include "ntvfs/ntvfs.h"
30 #include "../librpc/gen_ndr/rap.h"
31 #include "ntvfs/ipc/proto.h"
32 #include "libcli/raw/ioctl.h"
33 #include "param/param.h"
34 #include "../lib/tsocket/tsocket.h"
35 #include "../libcli/named_pipe_auth/npa_tstream.h"
36 #include "auth/auth.h"
37 #include "auth/auth_sam_reply.h"
38 #include "lib/socket/socket.h"
39 #include "auth/credentials/credentials.h"
40 #include "auth/credentials/credentials_krb5.h"
41 #include <gssapi/gssapi.h>
42 #include "system/locale.h"
43
44 /* this is the private structure used to keep the state of an open
45 ipc$ connection. It needs to keep information about all open
46 pipes */
47 struct ipc_private {
48 struct ntvfs_module_context *ntvfs;
49
50 /* a list of open pipes */
51 struct pipe_state {
52 struct pipe_state *next, *prev;
53 struct ipc_private *ipriv;
54 const char *pipe_name;
55 struct ntvfs_handle *handle;
56 struct tstream_context *npipe;
57 uint16_t file_type;
58 uint16_t device_state;
59 uint64_t allocation_size;
60 struct tevent_queue *write_queue;
61 struct tevent_queue *read_queue;
62 } *pipe_list;
63 };
64
65
66 /*
67 find a open pipe give a file handle
68 */
69 static struct pipe_state *pipe_state_find(struct ipc_private *ipriv, struct ntvfs_handle *handle)
70 {
71 struct pipe_state *s;
72 void *p;
73
74 p = ntvfs_handle_get_backend_data(handle, ipriv->ntvfs);
75 if (!p) return NULL;
76
77 s = talloc_get_type(p, struct pipe_state);
78 if (!s) return NULL;
79
80 return s;
81 }
82
83 /*
84 find a open pipe give a wire fnum
85 */
86 static struct pipe_state *pipe_state_find_key(struct ipc_private *ipriv, struct ntvfs_request *req, const DATA_BLOB *key)
87 {
88 struct ntvfs_handle *h;
89
90 h = ntvfs_handle_search_by_wire_key(ipriv->ntvfs, req, key);
91 if (!h) return NULL;
92
93 return pipe_state_find(ipriv, h);
94 }
95
96
97 /*
98 connect to a share - always works
99 */
100 static NTSTATUS ipc_connect(struct ntvfs_module_context *ntvfs,
101 struct ntvfs_request *req,
102 union smb_tcon* tcon)
103 {
104 struct ipc_private *ipriv;
105 const char *sharename;
106
107 switch (tcon->generic.level) {
108 case RAW_TCON_TCON:
109 sharename = tcon->tcon.in.service;
110 break;
111 case RAW_TCON_TCONX:
112 sharename = tcon->tconx.in.path;
113 break;
114 case RAW_TCON_SMB2:
115 sharename = tcon->smb2.in.path;
116 break;
117 default:
118 return NT_STATUS_INVALID_LEVEL;
119 }
120
121 if (strncmp(sharename, "\\\\", 2) == 0) {
122 char *p = strchr(sharename+2, '\\');
123 if (p) {
124 sharename = p + 1;
125 }
126 }
127
128 ntvfs->ctx->fs_type = talloc_strdup(ntvfs->ctx, "IPC");
129 NT_STATUS_HAVE_NO_MEMORY(ntvfs->ctx->fs_type);
130
131 ntvfs->ctx->dev_type = talloc_strdup(ntvfs->ctx, "IPC");
132 NT_STATUS_HAVE_NO_MEMORY(ntvfs->ctx->dev_type);
133
134 if (tcon->generic.level == RAW_TCON_TCONX) {
135 tcon->tconx.out.fs_type = ntvfs->ctx->fs_type;
136 tcon->tconx.out.dev_type = ntvfs->ctx->dev_type;
137 }
138
139 /* prepare the private state for this connection */
140 ipriv = talloc(ntvfs, struct ipc_private);
141 NT_STATUS_HAVE_NO_MEMORY(ipriv);
142
143 ntvfs->private_data = ipriv;
144
145 ipriv->ntvfs = ntvfs;
146 ipriv->pipe_list = NULL;
147
148 return NT_STATUS_OK;
149 }
150
151 /*
152 disconnect from a share
153 */
154 static NTSTATUS ipc_disconnect(struct ntvfs_module_context *ntvfs)
155 {
156 return NT_STATUS_OK;
157 }
158
159 /*
160 delete a file
161 */
162 static NTSTATUS ipc_unlink(struct ntvfs_module_context *ntvfs,
163 struct ntvfs_request *req,
164 union smb_unlink *unl)
165 {
166 return NT_STATUS_ACCESS_DENIED;
167 }
168
169 /*
170 check if a directory exists
171 */
172 static NTSTATUS ipc_chkpath(struct ntvfs_module_context *ntvfs,
173 struct ntvfs_request *req,
174 union smb_chkpath *cp)
175 {
176 return NT_STATUS_ACCESS_DENIED;
177 }
178
179 /*
180 return info on a pathname
181 */
182 static NTSTATUS ipc_qpathinfo(struct ntvfs_module_context *ntvfs,
183 struct ntvfs_request *req, union smb_fileinfo *info)
184 {
185 switch (info->generic.level) {
186 case RAW_FILEINFO_GENERIC:
187 return NT_STATUS_INVALID_DEVICE_REQUEST;
188 case RAW_FILEINFO_GETATTR:
189 return NT_STATUS_ACCESS_DENIED;
190 default:
191 return ntvfs_map_qpathinfo(ntvfs, req, info);
192 }
193 }
194
195 /*
196 set info on a pathname
197 */
198 static NTSTATUS ipc_setpathinfo(struct ntvfs_module_context *ntvfs,
199 struct ntvfs_request *req, union smb_setfileinfo *st)
200 {
201 return NT_STATUS_ACCESS_DENIED;
202 }
203
204
205 /*
206 destroy a open pipe structure
207 */
208 static int ipc_fd_destructor(struct pipe_state *p)
209 {
210 DLIST_REMOVE(p->ipriv->pipe_list, p);
211 ntvfs_handle_remove_backend_data(p->handle, p->ipriv->ntvfs);
212 return 0;
213 }
214
215 struct ipc_open_state {
216 struct ipc_private *ipriv;
217 struct pipe_state *p;
218 struct ntvfs_request *req;
219 union smb_open *oi;
220 struct netr_SamInfo3 *info3;
221 };
222
223 static void ipc_open_done(struct tevent_req *subreq);
224
225 /*
226 check the pipename is valid
227 */
228 static NTSTATUS validate_pipename(const char *name)
229 {
230 while (*name) {
231 if (!isalnum(*name)) return NT_STATUS_INVALID_PARAMETER;
232 name++;
233 }
234 return NT_STATUS_OK;
235 }
236
237 /*
238 open a file - used for MSRPC pipes
239 */
240 static NTSTATUS ipc_open(struct ntvfs_module_context *ntvfs,
241 struct ntvfs_request *req, union smb_open *oi)
242 {
243 NTSTATUS status;
244 struct pipe_state *p;
245 struct ipc_private *ipriv = talloc_get_type_abort(ntvfs->private_data,
246 struct ipc_private);
247 struct ntvfs_handle *h;
248 struct ipc_open_state *state;
249 struct tevent_req *subreq;
250 const char *fname;
251 const char *directory;
252 const struct tsocket_address *client_addr;
253 const struct tsocket_address *server_addr;
254 int ret;
255 DATA_BLOB delegated_creds = data_blob_null;
256
257 switch (oi->generic.level) {
258 case RAW_OPEN_NTCREATEX:
259 case RAW_OPEN_NTTRANS_CREATE:
260 fname = oi->ntcreatex.in.fname;
261 break;
262 case RAW_OPEN_OPENX:
263 fname = oi->openx.in.fname;
264 break;
265 case RAW_OPEN_SMB2:
266 fname = oi->smb2.in.fname;
267 break;
268 default:
269 return NT_STATUS_NOT_SUPPORTED;
270 }
271
272 directory = talloc_asprintf(req, "%s/np",
273 lp_ncalrpc_dir(ipriv->ntvfs->ctx->lp_ctx));
274 NT_STATUS_HAVE_NO_MEMORY(directory);
275
276 state = talloc(req, struct ipc_open_state);
277 NT_STATUS_HAVE_NO_MEMORY(state);
278
279 status = ntvfs_handle_new(ntvfs, req, &h);
280 NT_STATUS_NOT_OK_RETURN(status);
281
282 p = talloc(h, struct pipe_state);
283 NT_STATUS_HAVE_NO_MEMORY(p);
284
285 while (fname[0] == '\\') fname++;
286
287 /* check for valid characters in name */
288 fname = strlower_talloc(p, fname);
289
290 status = validate_pipename(fname);
291 NT_STATUS_NOT_OK_RETURN(status);
292
293 p->pipe_name = talloc_asprintf(p, "\\pipe\\%s", fname);
294 NT_STATUS_HAVE_NO_MEMORY(p->pipe_name);
295
296 p->handle = h;
297 p->ipriv = ipriv;
298
299 p->write_queue = tevent_queue_create(p, "ipc_write_queue");
300 NT_STATUS_HAVE_NO_MEMORY(p->write_queue);
301
302 p->read_queue = tevent_queue_create(p, "ipc_read_queue");
303 NT_STATUS_HAVE_NO_MEMORY(p->read_queue);
304
305 state->ipriv = ipriv;
306 state->p = p;
307 state->req = req;
308 state->oi = oi;
309
310 status = auth_convert_server_info_saminfo3(state,
311 req->session_info->server_info,
312 &state->info3);
313 NT_STATUS_NOT_OK_RETURN(status);
314
315 client_addr = ntvfs_get_local_address(ipriv->ntvfs);
316 server_addr = ntvfs_get_remote_address(ipriv->ntvfs);
317
318 if (req->session_info->credentials) {
319 struct gssapi_creds_container *gcc;
320 OM_uint32 gret;
321 OM_uint32 minor_status;
322 gss_buffer_desc cred_token;
323 const char *error_string;
324
325 ret = cli_credentials_get_client_gss_creds(req->session_info->credentials,
326 ipriv->ntvfs->ctx->event_ctx,
327 ipriv->ntvfs->ctx->lp_ctx,
328 &gcc, &error_string);
329 if (ret) {
330 goto skip;
331 }
332
333 gret = gss_export_cred(&minor_status,
334 gcc->creds,
335 &cred_token);
336 if (gret != GSS_S_COMPLETE) {
337 return NT_STATUS_INTERNAL_ERROR;
338 }
339
340 if (cred_token.length) {
341 delegated_creds = data_blob_talloc(req,
342 cred_token.value,
343 cred_token.length);
344 gss_release_buffer(&minor_status, &cred_token);
345 NT_STATUS_HAVE_NO_MEMORY(delegated_creds.data);
346 }
347 }
348
349 skip:
350
351 subreq = tstream_npa_connect_send(p,
352 ipriv->ntvfs->ctx->event_ctx,
353 directory,
354 fname,
355 client_addr,
356 NULL,
357 server_addr,
358 NULL,
359 state->info3,
360 req->session_info->session_key,
361 delegated_creds);
362 NT_STATUS_HAVE_NO_MEMORY(subreq);
363 tevent_req_set_callback(subreq, ipc_open_done, state);
364
365 req->async_states->state |= NTVFS_ASYNC_STATE_ASYNC;
366 return NT_STATUS_OK;
367 }
368
369 static void ipc_open_done(struct tevent_req *subreq)
370 {
371 struct ipc_open_state *state = tevent_req_callback_data(subreq,
372 struct ipc_open_state);
373 struct ipc_private *ipriv = state->ipriv;
374 struct pipe_state *p = state->p;
375 struct ntvfs_request *req = state->req;
376 union smb_open *oi = state->oi;
377 int ret;
378 int sys_errno;
379 NTSTATUS status;
380
381 ret = tstream_npa_connect_recv(subreq, &sys_errno,
382 p, &p->npipe,
383 &p->file_type,
384 &p->device_state,
385 &p->allocation_size);
386 TALLOC_FREE(subreq);
387 if (ret == -1) {
388 status = map_nt_error_from_unix(sys_errno);
389 goto reply;
390 }
391
392 DLIST_ADD(ipriv->pipe_list, p);
393 talloc_set_destructor(p, ipc_fd_destructor);
394
395 status = ntvfs_handle_set_backend_data(p->handle, ipriv->ntvfs, p);
396 if (!NT_STATUS_IS_OK(status)) {
397 goto reply;
398 }
399
400 switch (oi->generic.level) {
401 case RAW_OPEN_NTCREATEX:
402 ZERO_STRUCT(oi->ntcreatex.out);
403 oi->ntcreatex.out.file.ntvfs = p->handle;
404 oi->ntcreatex.out.oplock_level = 0;
405 oi->ntcreatex.out.create_action = NTCREATEX_ACTION_EXISTED;
406 oi->ntcreatex.out.create_time = 0;
407 oi->ntcreatex.out.access_time = 0;
408 oi->ntcreatex.out.write_time = 0;
409 oi->ntcreatex.out.change_time = 0;
410 oi->ntcreatex.out.attrib = FILE_ATTRIBUTE_NORMAL;
411 oi->ntcreatex.out.alloc_size = p->allocation_size;
412 oi->ntcreatex.out.size = 0;
413 oi->ntcreatex.out.file_type = p->file_type;
414 oi->ntcreatex.out.ipc_state = p->device_state;
415 oi->ntcreatex.out.is_directory = 0;
416 break;
417 case RAW_OPEN_OPENX:
418 ZERO_STRUCT(oi->openx.out);
419 oi->openx.out.file.ntvfs = p->handle;
420 oi->openx.out.attrib = FILE_ATTRIBUTE_NORMAL;
421 oi->openx.out.write_time = 0;
422 oi->openx.out.size = 0;
423 oi->openx.out.access = 0;
424 oi->openx.out.ftype = p->file_type;
425 oi->openx.out.devstate = p->device_state;
426 oi->openx.out.action = 0;
427 oi->openx.out.unique_fid = 0;
428 oi->openx.out.access_mask = 0;
429 oi->openx.out.unknown = 0;
430 break;
431 case RAW_OPEN_SMB2:
432 ZERO_STRUCT(oi->smb2.out);
433 oi->smb2.out.file.ntvfs = p->handle;
434 oi->smb2.out.oplock_level = oi->smb2.in.oplock_level;
435 oi->smb2.out.create_action = NTCREATEX_ACTION_EXISTED;
436 oi->smb2.out.create_time = 0;
437 oi->smb2.out.access_time = 0;
438 oi->smb2.out.write_time = 0;
439 oi->smb2.out.change_time = 0;
440 oi->smb2.out.alloc_size = p->allocation_size;
441 oi->smb2.out.size = 0;
442 oi->smb2.out.file_attr = FILE_ATTRIBUTE_NORMAL;
443 oi->smb2.out.reserved2 = 0;
444 break;
445 default:
446 break;
447 }
448
449 reply:
450 req->async_states->status = status;
451 req->async_states->send_fn(req);
452 }
453
454 /*
455 create a directory
456 */
457 static NTSTATUS ipc_mkdir(struct ntvfs_module_context *ntvfs,
458 struct ntvfs_request *req, union smb_mkdir *md)
459 {
460 return NT_STATUS_ACCESS_DENIED;
461 }
462
463 /*
464 remove a directory
465 */
466 static NTSTATUS ipc_rmdir(struct ntvfs_module_context *ntvfs,
467 struct ntvfs_request *req, struct smb_rmdir *rd)
468 {
469 return NT_STATUS_ACCESS_DENIED;
470 }
471
472 /*
473 rename a set of files
474 */
475 static NTSTATUS ipc_rename(struct ntvfs_module_context *ntvfs,
476 struct ntvfs_request *req, union smb_rename *ren)
477 {
478 return NT_STATUS_ACCESS_DENIED;
479 }
480
481 /*
482 copy a set of files
483 */
484 static NTSTATUS ipc_copy(struct ntvfs_module_context *ntvfs,
485 struct ntvfs_request *req, struct smb_copy *cp)
486 {
487 return NT_STATUS_ACCESS_DENIED;
488 }
489
490 struct ipc_readv_next_vector_state {
491 uint8_t *buf;
492 size_t len;
493 off_t ofs;
494 size_t remaining;
495 };
496
497 static void ipc_readv_next_vector_init(struct ipc_readv_next_vector_state *s,
498 uint8_t *buf, size_t len)
499 {
500 ZERO_STRUCTP(s);
501
502 s->buf = buf;
503 s->len = MIN(len, UINT16_MAX);
504 }
505
506 static int ipc_readv_next_vector(struct tstream_context *stream,
507 void *private_data,
508 TALLOC_CTX *mem_ctx,
509 struct iovec **_vector,
510 size_t *count)
511 {
512 struct ipc_readv_next_vector_state *state =
513 (struct ipc_readv_next_vector_state *)private_data;
514 struct iovec *vector;
515 ssize_t pending;
516 size_t wanted;
517
518 if (state->ofs == state->len) {
519 *_vector = NULL;
520 *count = 0;
521 return 0;
522 }
523
524 pending = tstream_pending_bytes(stream);
525 if (pending == -1) {
526 return -1;
527 }
528
529 if (pending == 0 && state->ofs != 0) {
530 /* return a short read */
531 *_vector = NULL;
532 *count = 0;
533 return 0;
534 }
535
536 if (pending == 0) {
537 /* we want at least one byte and recheck again */
538 wanted = 1;
539 } else {
540 size_t missing = state->len - state->ofs;
541 if (pending > missing) {
542 /* there's more available */
543 state->remaining = pending - missing;
544 wanted = missing;
545 } else {
546 /* read what we can get and recheck in the next cycle */
547 wanted = pending;
548 }
549 }
550
551 vector = talloc_array(mem_ctx, struct iovec, 1);
552 if (!vector) {
553 return -1;
554 }
555
556 vector[0].iov_base = state->buf + state->ofs;
557 vector[0].iov_len = wanted;
558
559 state->ofs += wanted;
560
561 *_vector = vector;
562 *count = 1;
563 return 0;
564 }
565
566 struct ipc_read_state {
567 struct ipc_private *ipriv;
568 struct pipe_state *p;
569 struct ntvfs_request *req;
570 union smb_read *rd;
571 struct ipc_readv_next_vector_state next_vector;
572 };
573
574 static void ipc_read_done(struct tevent_req *subreq);
575
576 /*
577 read from a file
578 */
579 static NTSTATUS ipc_read(struct ntvfs_module_context *ntvfs,
580 struct ntvfs_request *req, union smb_read *rd)
581 {
582 struct ipc_private *ipriv = talloc_get_type_abort(ntvfs->private_data,
583 struct ipc_private);
584 struct pipe_state *p;
585 struct ipc_read_state *state;
586 struct tevent_req *subreq;
587
588 if (rd->generic.level != RAW_READ_GENERIC) {
589 return ntvfs_map_read(ntvfs, req, rd);
590 }
591
592 p = pipe_state_find(ipriv, rd->readx.in.file.ntvfs);
593 if (!p) {
594 return NT_STATUS_INVALID_HANDLE;
595 }
596
597 state = talloc(req, struct ipc_read_state);
598 NT_STATUS_HAVE_NO_MEMORY(state);
599
600 state->ipriv = ipriv;
601 state->p = p;
602 state->req = req;
603 state->rd = rd;
604
605 /* rd->readx.out.data is already allocated */
606 ipc_readv_next_vector_init(&state->next_vector,
607 rd->readx.out.data,
608 rd->readx.in.maxcnt);
609
610 subreq = tstream_readv_pdu_queue_send(req,
611 ipriv->ntvfs->ctx->event_ctx,
612 p->npipe,
613 p->read_queue,
614 ipc_readv_next_vector,
615 &state->next_vector);
616 NT_STATUS_HAVE_NO_MEMORY(subreq);
617 tevent_req_set_callback(subreq, ipc_read_done, state);
618
619 req->async_states->state |= NTVFS_ASYNC_STATE_ASYNC;
620 return NT_STATUS_OK;
621 }
622
623 static void ipc_read_done(struct tevent_req *subreq)
624 {
625 struct ipc_read_state *state =
626 tevent_req_callback_data(subreq,
627 struct ipc_read_state);
628 struct ntvfs_request *req = state->req;
629 union smb_read *rd = state->rd;
630 int ret;
631 int sys_errno;
632 NTSTATUS status;
633
634 ret = tstream_readv_pdu_queue_recv(subreq, &sys_errno);
635 TALLOC_FREE(subreq);
636 if (ret == -1) {
637 status = map_nt_error_from_unix(sys_errno);
638 goto reply;
639 }
640
641 status = NT_STATUS_OK;
642 if (state->next_vector.remaining > 0) {
643 status = STATUS_BUFFER_OVERFLOW;
644 }
645
646 rd->readx.out.remaining = state->next_vector.remaining;
647 rd->readx.out.compaction_mode = 0;
648 rd->readx.out.nread = ret;
649
650 reply:
651 req->async_states->status = status;
652 req->async_states->send_fn(req);
653 }
654
655 struct ipc_write_state {
656 struct ipc_private *ipriv;
657 struct pipe_state *p;
658 struct ntvfs_request *req;
659 union smb_write *wr;
660 struct iovec iov;
661 };
662
663 static void ipc_write_done(struct tevent_req *subreq);
664
665 /*
666 write to a file
667 */
668 static NTSTATUS ipc_write(struct ntvfs_module_context *ntvfs,
669 struct ntvfs_request *req, union smb_write *wr)
670 {
671 struct ipc_private *ipriv = talloc_get_type_abort(ntvfs->private_data,
672 struct ipc_private);
673 struct pipe_state *p;
674 struct tevent_req *subreq;
675 struct ipc_write_state *state;
676
677 if (wr->generic.level != RAW_WRITE_GENERIC) {
678 return ntvfs_map_write(ntvfs, req, wr);
679 }
680
681 p = pipe_state_find(ipriv, wr->writex.in.file.ntvfs);
682 if (!p) {
683 return NT_STATUS_INVALID_HANDLE;
684 }
685
686 state = talloc(req, struct ipc_write_state);
687 NT_STATUS_HAVE_NO_MEMORY(state);
688
689 state->ipriv = ipriv;
690 state->p = p;
691 state->req = req;
692 state->wr = wr;
693 state->iov.iov_base = discard_const_p(void, wr->writex.in.data);
694 state->iov.iov_len = wr->writex.in.count;
695
696 subreq = tstream_writev_queue_send(state,
697 ipriv->ntvfs->ctx->event_ctx,
698 p->npipe,
699 p->write_queue,
700 &state->iov, 1);
701 NT_STATUS_HAVE_NO_MEMORY(subreq);
702 tevent_req_set_callback(subreq, ipc_write_done, state);
703
704 req->async_states->state |= NTVFS_ASYNC_STATE_ASYNC;
705 return NT_STATUS_OK;
706 }
707
708 static void ipc_write_done(struct tevent_req *subreq)
709 {
710 struct ipc_write_state *state =
711 tevent_req_callback_data(subreq,
712 struct ipc_write_state);
713 struct ntvfs_request *req = state->req;
714 union smb_write *wr = state->wr;
715 int ret;
716 int sys_errno;
717 NTSTATUS status;
718
719 ret = tstream_writev_queue_recv(subreq, &sys_errno);
720 TALLOC_FREE(subreq);
721 if (ret == -1) {
722 status = map_nt_error_from_unix(sys_errno);
723 goto reply;
724 }
725
726 status = NT_STATUS_OK;
727
728 wr->writex.out.nwritten = ret;
729 wr->writex.out.remaining = 0;
730
731 reply:
732 req->async_states->status = status;
733 req->async_states->send_fn(req);
734 }
735
736 /*
737 seek in a file
738 */
739 static NTSTATUS ipc_seek(struct ntvfs_module_context *ntvfs,
740 struct ntvfs_request *req,
741 union smb_seek *io)
742 {
743 return NT_STATUS_ACCESS_DENIED;
744 }
745
746 /*
747 flush a file
748 */
749 static NTSTATUS ipc_flush(struct ntvfs_module_context *ntvfs,
750 struct ntvfs_request *req,
751 union smb_flush *io)
752 {
753 return NT_STATUS_ACCESS_DENIED;
754 }
755
756 /*
757 close a file
758 */
759 static NTSTATUS ipc_close(struct ntvfs_module_context *ntvfs,
760 struct ntvfs_request *req, union smb_close *io)
761 {
762 struct ipc_private *ipriv = talloc_get_type_abort(ntvfs->private_data,
763 struct ipc_private);
764 struct pipe_state *p;
765
766 if (io->generic.level != RAW_CLOSE_CLOSE) {
767 return ntvfs_map_close(ntvfs, req, io);
768 }
769
770 p = pipe_state_find(ipriv, io->close.in.file.ntvfs);
771 if (!p) {
772 return NT_STATUS_INVALID_HANDLE;
773 }
774
775 talloc_free(p);
776
777 return NT_STATUS_OK;
778 }
779
780 /*
781 exit - closing files
782 */
783 static NTSTATUS ipc_exit(struct ntvfs_module_context *ntvfs,
784 struct ntvfs_request *req)
785 {
786 struct ipc_private *ipriv = talloc_get_type_abort(ntvfs->private_data,
787 struct ipc_private);
788 struct pipe_state *p, *next;
789
790 for (p=ipriv->pipe_list; p; p=next) {
791 next = p->next;
792 if (p->handle->session_info == req->session_info &&
793 p->handle->smbpid == req->smbpid) {
794 talloc_free(p);
795 }
796 }
797
798 return NT_STATUS_OK;
799 }
800
801 /*
802 logoff - closing files open by the user
803 */
804 static NTSTATUS ipc_logoff(struct ntvfs_module_context *ntvfs,
805 struct ntvfs_request *req)
806 {
807 struct ipc_private *ipriv = talloc_get_type_abort(ntvfs->private_data,
808 struct ipc_private);
809 struct pipe_state *p, *next;
810
811 for (p=ipriv->pipe_list; p; p=next) {
812 next = p->next;
813 if (p->handle->session_info == req->session_info) {
814 talloc_free(p);
815 }
816 }
817
818 return NT_STATUS_OK;
819 }
820
821 /*
822 setup for an async call
823 */
824 static NTSTATUS ipc_async_setup(struct ntvfs_module_context *ntvfs,
825 struct ntvfs_request *req,
826 void *private_data)
827 {
828 return NT_STATUS_OK;
829 }
830
831 /*
832 cancel an async call
833 */
834 static NTSTATUS ipc_cancel(struct ntvfs_module_context *ntvfs,
835 struct ntvfs_request *req)
836 {
837 return NT_STATUS_UNSUCCESSFUL;
838 }
839
840 /*
841 lock a byte range
842 */
843 static NTSTATUS ipc_lock(struct ntvfs_module_context *ntvfs,
844 struct ntvfs_request *req, union smb_lock *lck)
845 {
846 return NT_STATUS_ACCESS_DENIED;
847 }
848
849 /*
850 set info on a open file
851 */
852 static NTSTATUS ipc_setfileinfo(struct ntvfs_module_context *ntvfs,
853 struct ntvfs_request *req, union smb_setfileinfo *info)
854 {
855 return NT_STATUS_ACCESS_DENIED;
856 }
857
858 /*
859 query info on a open file
860 */
861 static NTSTATUS ipc_qfileinfo(struct ntvfs_module_context *ntvfs,
862 struct ntvfs_request *req, union smb_fileinfo *info)
863 {
864 struct ipc_private *ipriv = talloc_get_type_abort(ntvfs->private_data,
865 struct ipc_private);
866 struct pipe_state *p = pipe_state_find(ipriv, info->generic.in.file.ntvfs);
867 if (!p) {
868 return NT_STATUS_INVALID_HANDLE;
869 }
870 switch (info->generic.level) {
871 case RAW_FILEINFO_GENERIC:
872 {
873 ZERO_STRUCT(info->generic.out);
874 info->generic.out.attrib = FILE_ATTRIBUTE_NORMAL;
875 info->generic.out.fname.s = strrchr(p->pipe_name, '\\');
876 info->generic.out.alloc_size = 4096;
877 info->generic.out.nlink = 1;
878 /* What the heck? Match Win2k3: IPC$ pipes are delete pending */
879 info->generic.out.delete_pending = 1;
880 return NT_STATUS_OK;
881 }
882 case RAW_FILEINFO_ALT_NAME_INFO:
883 case RAW_FILEINFO_ALT_NAME_INFORMATION:
884 case RAW_FILEINFO_STREAM_INFO:
885 case RAW_FILEINFO_STREAM_INFORMATION:
886 case RAW_FILEINFO_COMPRESSION_INFO:
887 case RAW_FILEINFO_COMPRESSION_INFORMATION:
888 case RAW_FILEINFO_NETWORK_OPEN_INFORMATION:
889 case RAW_FILEINFO_ATTRIBUTE_TAG_INFORMATION:
890 return NT_STATUS_INVALID_PARAMETER;
891 case RAW_FILEINFO_ALL_EAS:
892 return NT_STATUS_ACCESS_DENIED;
893 default:
894 return ntvfs_map_qfileinfo(ntvfs, req, info);
895 }
896
897 return NT_STATUS_ACCESS_DENIED;
898 }
899
900
901 /*
902 return filesystem info
903 */
904 static NTSTATUS ipc_fsinfo(struct ntvfs_module_context *ntvfs,
905 struct ntvfs_request *req, union smb_fsinfo *fs)
906 {
907 return NT_STATUS_ACCESS_DENIED;
908 }
909
910 /*
911 return print queue info
912 */
913 static NTSTATUS ipc_lpq(struct ntvfs_module_context *ntvfs,
914 struct ntvfs_request *req, union smb_lpq *lpq)
915 {
916 return NT_STATUS_ACCESS_DENIED;
917 }
918
919 /*
920 list files in a directory matching a wildcard pattern
921 */
922 static NTSTATUS ipc_search_first(struct ntvfs_module_context *ntvfs,
923 struct ntvfs_request *req, union smb_search_first *io,
924 void *search_private,
925 bool (*callback)(void *, const union smb_search_data *))
926 {
927 return NT_STATUS_ACCESS_DENIED;
928 }
929
930 /*
931 continue listing files in a directory
932 */
933 static NTSTATUS ipc_search_next(struct ntvfs_module_context *ntvfs,
934 struct ntvfs_request *req, union smb_search_next *io,
935 void *search_private,
936 bool (*callback)(void *, const union smb_search_data *))
937 {
938 return NT_STATUS_ACCESS_DENIED;
939 }
940
941 /*
942 end listing files in a directory
943 */
944 static NTSTATUS ipc_search_close(struct ntvfs_module_context *ntvfs,
945 struct ntvfs_request *req, union smb_search_close *io)
946 {
947 return NT_STATUS_ACCESS_DENIED;
948 }
949
950 struct ipc_trans_state {
951 struct ipc_private *ipriv;
952 struct pipe_state *p;
953 struct ntvfs_request *req;
954 struct smb_trans2 *trans;
955 struct iovec writev_iov;
956 struct ipc_readv_next_vector_state next_vector;
957 };
958
959 static void ipc_trans_writev_done(struct tevent_req *subreq);
960 static void ipc_trans_readv_done(struct tevent_req *subreq);
961
962 /* SMBtrans - handle a DCERPC command */
963 static NTSTATUS ipc_dcerpc_cmd(struct ntvfs_module_context *ntvfs,
964 struct ntvfs_request *req, struct smb_trans2 *trans)
965 {
966 struct ipc_private *ipriv = talloc_get_type_abort(ntvfs->private_data,
967 struct ipc_private);
968 struct pipe_state *p;
969 DATA_BLOB fnum_key;
970 uint16_t fnum;
971 struct ipc_trans_state *state;
972 struct tevent_req *subreq;
973
974 /*
975 * the fnum is in setup[1], a 16 bit value
976 * the setup[*] values are already in host byteorder
977 * but ntvfs_handle_search_by_wire_key() expects
978 * network byteorder
979 */
980 SSVAL(&fnum, 0, trans->in.setup[1]);
981 fnum_key = data_blob_const(&fnum, 2);
982
983 p = pipe_state_find_key(ipriv, req, &fnum_key);
984 if (!p) {
985 return NT_STATUS_INVALID_HANDLE;
986 }
987
988 /*
989 * Trans requests are only allowed
990 * if no other Trans or Read is active
991 */
992 if (tevent_queue_length(p->read_queue) > 0) {
993 return NT_STATUS_PIPE_BUSY;
994 }
995
996 state = talloc(req, struct ipc_trans_state);
997 NT_STATUS_HAVE_NO_MEMORY(state);
998
999 trans->out.setup_count = 0;
1000 trans->out.setup = NULL;
1001 trans->out.params = data_blob(NULL, 0);
1002 trans->out.data = data_blob_talloc(req, NULL, trans->in.max_data);
1003 NT_STATUS_HAVE_NO_MEMORY(trans->out.data.data);
1004
1005 state->ipriv = ipriv;
1006 state->p = p;
1007 state->req = req;
1008 state->trans = trans;
1009 state->writev_iov.iov_base = trans->in.data.data;
1010 state->writev_iov.iov_len = trans->in.data.length;
1011
1012 ipc_readv_next_vector_init(&state->next_vector,
1013 trans->out.data.data,
1014 trans->out.data.length);
1015
1016 subreq = tstream_writev_queue_send(state,
1017 ipriv->ntvfs->ctx->event_ctx,
1018 p->npipe,
1019 p->write_queue,
1020 &state->writev_iov, 1);
1021 NT_STATUS_HAVE_NO_MEMORY(subreq);
1022 tevent_req_set_callback(subreq, ipc_trans_writev_done, state);
1023
1024 req->async_states->state |= NTVFS_ASYNC_STATE_ASYNC;
1025 return NT_STATUS_OK;
1026 }
1027
1028 static void ipc_trans_writev_done(struct tevent_req *subreq)
1029 {
1030 struct ipc_trans_state *state =
1031 tevent_req_callback_data(subreq,
1032 struct ipc_trans_state);
1033 struct ipc_private *ipriv = state->ipriv;
1034 struct pipe_state *p = state->p;
1035 struct ntvfs_request *req = state->req;
1036 int ret;
1037 int sys_errno;
1038 NTSTATUS status;
1039
1040 ret = tstream_writev_queue_recv(subreq, &sys_errno);
1041 TALLOC_FREE(subreq);
1042 if (ret == 0) {
1043 status = NT_STATUS_PIPE_DISCONNECTED;
1044 goto reply;
1045 } else if (ret == -1) {
1046 status = map_nt_error_from_unix(sys_errno);
1047 goto reply;
1048 }
1049
1050 subreq = tstream_readv_pdu_queue_send(state,
1051 ipriv->ntvfs->ctx->event_ctx,
1052 p->npipe,
1053 p->read_queue,
1054 ipc_readv_next_vector,
1055 &state->next_vector);
1056 if (!subreq) {
1057 status = NT_STATUS_NO_MEMORY;
1058 goto reply;
1059 }
1060 tevent_req_set_callback(subreq, ipc_trans_readv_done, state);
1061 return;
1062
1063 reply:
1064 req->async_states->status = status;
1065 req->async_states->send_fn(req);
1066 }
1067
1068 static void ipc_trans_readv_done(struct tevent_req *subreq)
1069 {
1070 struct ipc_trans_state *state =
1071 tevent_req_callback_data(subreq,
1072 struct ipc_trans_state);
1073 struct ntvfs_request *req = state->req;
1074 struct smb_trans2 *trans = state->trans;
1075 int ret;
1076 int sys_errno;
1077 NTSTATUS status;
1078
1079 ret = tstream_readv_pdu_queue_recv(subreq, &sys_errno);
1080 TALLOC_FREE(subreq);
1081 if (ret == -1) {
1082 status = map_nt_error_from_unix(sys_errno);
1083 goto reply;
1084 }
1085
1086 status = NT_STATUS_OK;
1087 if (state->next_vector.remaining > 0) {
1088 status = STATUS_BUFFER_OVERFLOW;
1089 }
1090
1091 trans->out.data.length = ret;
1092
1093 reply:
1094 req->async_states->status = status;
1095 req->async_states->send_fn(req);
1096 }
1097
1098 /* SMBtrans - set named pipe state */
1099 static NTSTATUS ipc_set_nm_pipe_state(struct ntvfs_module_context *ntvfs,
1100 struct ntvfs_request *req, struct smb_trans2 *trans)
1101 {
1102 struct ipc_private *ipriv = talloc_get_type_abort(ntvfs->private_data,
1103 struct ipc_private);
1104 struct pipe_state *p;
1105 DATA_BLOB fnum_key;
1106
1107 /* the fnum is in setup[1] */
1108 fnum_key = data_blob_const(&trans->in.setup[1], sizeof(trans->in.setup[1]));
1109
1110 p = pipe_state_find_key(ipriv, req, &fnum_key);
1111 if (!p) {
1112 return NT_STATUS_INVALID_HANDLE;
1113 }
1114
1115 if (trans->in.params.length != 2) {
1116 return NT_STATUS_INVALID_PARAMETER;
1117 }
1118
1119 /*
1120 * TODO: pass this to the tstream_npa logic
1121 */
1122 p->device_state = SVAL(trans->in.params.data, 0);
1123
1124 trans->out.setup_count = 0;
1125 trans->out.setup = NULL;
1126 trans->out.params = data_blob(NULL, 0);
1127 trans->out.data = data_blob(NULL, 0);
1128
1129 return NT_STATUS_OK;
1130 }
1131
1132
1133 /* SMBtrans - used to provide access to SMB pipes */
1134 static NTSTATUS ipc_trans(struct ntvfs_module_context *ntvfs,
1135 struct ntvfs_request *req, struct smb_trans2 *trans)
1136 {
1137 NTSTATUS status;
1138
1139 if (strequal(trans->in.trans_name, "\\PIPE\\LANMAN"))
1140 return ipc_rap_call(req, ntvfs->ctx->event_ctx, ntvfs->ctx->lp_ctx, trans);
1141
1142 if (trans->in.setup_count != 2) {
1143 return NT_STATUS_INVALID_PARAMETER;
1144 }
1145
1146 switch (trans->in.setup[0]) {
1147 case TRANSACT_SETNAMEDPIPEHANDLESTATE:
1148 status = ipc_set_nm_pipe_state(ntvfs, req, trans);
1149 break;
1150 case TRANSACT_DCERPCCMD:
1151 status = ipc_dcerpc_cmd(ntvfs, req, trans);
1152 break;
1153 default:
1154 status = NT_STATUS_INVALID_PARAMETER;
1155 break;
1156 }
1157
1158 return status;
1159 }
1160
1161 struct ipc_ioctl_state {
1162 struct ipc_private *ipriv;
1163 struct pipe_state *p;
1164 struct ntvfs_request *req;
1165 union smb_ioctl *io;
1166 struct iovec writev_iov;
1167 struct ipc_readv_next_vector_state next_vector;
1168 };
1169
1170 static void ipc_ioctl_writev_done(struct tevent_req *subreq);
1171 static void ipc_ioctl_readv_done(struct tevent_req *subreq);
1172
1173 static NTSTATUS ipc_ioctl_smb2(struct ntvfs_module_context *ntvfs,
1174 struct ntvfs_request *req, union smb_ioctl *io)
1175 {
1176 struct ipc_private *ipriv = talloc_get_type_abort(ntvfs->private_data,
1177 struct ipc_private);
1178 struct pipe_state *p;
1179 struct ipc_ioctl_state *state;
1180 struct tevent_req *subreq;
1181
1182 switch (io->smb2.in.function) {
1183 case FSCTL_NAMED_PIPE_READ_WRITE:
1184 break;
1185
1186 default:
1187 return NT_STATUS_FS_DRIVER_REQUIRED;
1188 }
1189
1190 p = pipe_state_find(ipriv, io->smb2.in.file.ntvfs);
1191 if (!p) {
1192 return NT_STATUS_INVALID_HANDLE;
1193 }
1194
1195 /*
1196 * Trans requests are only allowed
1197 * if no other Trans or Read is active
1198 */
1199 if (tevent_queue_length(p->read_queue) > 0) {
1200 return NT_STATUS_PIPE_BUSY;
1201 }
1202
1203 state = talloc(req, struct ipc_ioctl_state);
1204 NT_STATUS_HAVE_NO_MEMORY(state);
1205
1206 io->smb2.out._pad = 0;
1207 io->smb2.out.function = io->smb2.in.function;
1208 io->smb2.out.unknown2 = 0;
1209 io->smb2.out.unknown3 = 0;
1210 io->smb2.out.in = io->smb2.in.out;
1211 io->smb2.out.out = data_blob_talloc(req, NULL, io->smb2.in.max_response_size);
1212 NT_STATUS_HAVE_NO_MEMORY(io->smb2.out.out.data);
1213
1214 state->ipriv = ipriv;
1215 state->p = p;
1216 state->req = req;
1217 state->io = io;
1218 state->writev_iov.iov_base = io->smb2.in.out.data;
1219 state->writev_iov.iov_len = io->smb2.in.out.length;
1220
1221 ipc_readv_next_vector_init(&state->next_vector,
1222 io->smb2.out.out.data,
1223 io->smb2.out.out.length);
1224
1225 subreq = tstream_writev_queue_send(state,
1226 ipriv->ntvfs->ctx->event_ctx,
1227 p->npipe,
1228 p->write_queue,
1229 &state->writev_iov, 1);
1230 NT_STATUS_HAVE_NO_MEMORY(subreq);
1231 tevent_req_set_callback(subreq, ipc_ioctl_writev_done, state);
1232
1233 req->async_states->state |= NTVFS_ASYNC_STATE_ASYNC;
1234 return NT_STATUS_OK;
1235 }
1236
1237 static void ipc_ioctl_writev_done(struct tevent_req *subreq)
1238 {
1239 struct ipc_ioctl_state *state =
1240 tevent_req_callback_data(subreq,
1241 struct ipc_ioctl_state);
1242 struct ipc_private *ipriv = state->ipriv;
1243 struct pipe_state *p = state->p;
1244 struct ntvfs_request *req = state->req;
1245 int ret;
1246 int sys_errno;
1247 NTSTATUS status;
1248
1249 ret = tstream_writev_queue_recv(subreq, &sys_errno);
1250 TALLOC_FREE(subreq);
1251 if (ret == -1) {
1252 status = map_nt_error_from_unix(sys_errno);
1253 goto reply;
1254 }
1255
1256 subreq = tstream_readv_pdu_queue_send(state,
1257 ipriv->ntvfs->ctx->event_ctx,
1258 p->npipe,
1259 p->read_queue,
1260 ipc_readv_next_vector,
1261 &state->next_vector);
1262 if (!subreq) {
1263 status = NT_STATUS_NO_MEMORY;
1264 goto reply;
1265 }
1266 tevent_req_set_callback(subreq, ipc_ioctl_readv_done, state);
1267 return;
1268
1269 reply:
1270 req->async_states->status = status;
1271 req->async_states->send_fn(req);
1272 }
1273
1274 static void ipc_ioctl_readv_done(struct tevent_req *subreq)
1275 {
1276 struct ipc_ioctl_state *state =
1277 tevent_req_callback_data(subreq,
1278 struct ipc_ioctl_state);
1279 struct ntvfs_request *req = state->req;
1280 union smb_ioctl *io = state->io;
1281 int ret;
1282 int sys_errno;
1283 NTSTATUS status;
1284
1285 ret = tstream_readv_pdu_queue_recv(subreq, &sys_errno);
1286 TALLOC_FREE(subreq);
1287 if (ret == -1) {
1288 status = map_nt_error_from_unix(sys_errno);
1289 goto reply;
1290 }
1291
1292 status = NT_STATUS_OK;
1293 if (state->next_vector.remaining > 0) {
1294 status = STATUS_BUFFER_OVERFLOW;
1295 }
1296
1297 io->smb2.out.out.length = ret;
1298
1299 reply:
1300 req->async_states->status = status;
1301 req->async_states->send_fn(req);
1302 }
1303
1304 /*
1305 ioctl interface
1306 */
1307 static NTSTATUS ipc_ioctl(struct ntvfs_module_context *ntvfs,
1308 struct ntvfs_request *req, union smb_ioctl *io)
1309 {
1310 switch (io->generic.level) {
1311 case RAW_IOCTL_SMB2:
1312 return ipc_ioctl_smb2(ntvfs, req, io);
1313
1314 case RAW_IOCTL_SMB2_NO_HANDLE:
1315 return NT_STATUS_FS_DRIVER_REQUIRED;
1316
1317 default:
1318 return NT_STATUS_ACCESS_DENIED;
1319 }
1320
1321 return NT_STATUS_ACCESS_DENIED;
1322 }
1323
1324
1325 /*
1326 initialialise the IPC backend, registering ourselves with the ntvfs subsystem
1327 */
1328 NTSTATUS ntvfs_ipc_init(void)
1329 {
1330 NTSTATUS ret;
1331 struct ntvfs_ops ops;
1332 NTVFS_CURRENT_CRITICAL_SIZES(vers);
1333
1334 ZERO_STRUCT(ops);
1335
1336 /* fill in the name and type */
1337 ops.name = "default";
1338 ops.type = NTVFS_IPC;
1339
1340 /* fill in all the operations */
1341 ops.connect = ipc_connect;
1342 ops.disconnect = ipc_disconnect;
1343 ops.unlink = ipc_unlink;
1344 ops.chkpath = ipc_chkpath;
1345 ops.qpathinfo = ipc_qpathinfo;
1346 ops.setpathinfo = ipc_setpathinfo;
1347 ops.open = ipc_open;
1348 ops.mkdir = ipc_mkdir;
1349 ops.rmdir = ipc_rmdir;
1350 ops.rename = ipc_rename;
1351 ops.copy = ipc_copy;
1352 ops.ioctl = ipc_ioctl;
1353 ops.read = ipc_read;
1354 ops.write = ipc_write;
1355 ops.seek = ipc_seek;
1356 ops.flush = ipc_flush;
1357 ops.close = ipc_close;
1358 ops.exit = ipc_exit;
1359 ops.lock = ipc_lock;
1360 ops.setfileinfo = ipc_setfileinfo;
1361 ops.qfileinfo = ipc_qfileinfo;
1362 ops.fsinfo = ipc_fsinfo;
1363 ops.lpq = ipc_lpq;
1364 ops.search_first = ipc_search_first;
1365 ops.search_next = ipc_search_next;
1366 ops.search_close = ipc_search_close;
1367 ops.trans = ipc_trans;
1368 ops.logoff = ipc_logoff;
1369 ops.async_setup = ipc_async_setup;
1370 ops.cancel = ipc_cancel;
1371
1372 /* register ourselves with the NTVFS subsystem. */
1373 ret = ntvfs_register(&ops, &vers);
1374
1375 if (!NT_STATUS_IS_OK(ret)) {
1376 DEBUG(0,("Failed to register IPC backend!\n"));
1377 return ret;
1378 }
1379
1380 return ret;
1381 }