2 Unix SMB/CIFS implementation.
4 Copyright (C) Stefan (metze) Metzmacher 2003
5 Copyright (C) Jeremy Allison 2007
6 Copyright (C) Andrew Bartlett 2011
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.
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.
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/>.
23 #include "libsmb/libsmb.h"
24 #include "../lib/util/tevent_ntstatus.h"
25 #include "async_smb.h"
27 #include "auth_generic.h"
28 #include "auth/gensec/gensec.h"
29 #include "../libcli/smb/smbXcli_base.h"
30 #include "auth/credentials/credentials.h"
31 #include "../librpc/gen_ndr/ndr_security.h"
33 /****************************************************************************
34 Get UNIX extensions version info.
35 ****************************************************************************/
37 struct cli_unix_extensions_version_state {
38 struct cli_state *cli;
41 uint16_t major, minor;
42 uint32_t caplow, caphigh;
45 static void cli_unix_extensions_version_done(struct tevent_req *subreq);
47 struct tevent_req *cli_unix_extensions_version_send(TALLOC_CTX *mem_ctx,
48 struct tevent_context *ev,
49 struct cli_state *cli)
51 struct tevent_req *req, *subreq;
52 struct cli_unix_extensions_version_state *state;
54 req = tevent_req_create(mem_ctx, &state,
55 struct cli_unix_extensions_version_state);
60 SSVAL(state->setup, 0, TRANSACT2_QFSINFO);
61 SSVAL(state->param, 0, SMB_QUERY_CIFS_UNIX_INFO);
63 subreq = cli_trans_send(state, ev, cli, 0, SMBtrans2,
68 if (tevent_req_nomem(subreq, req)) {
69 return tevent_req_post(req, ev);
71 tevent_req_set_callback(subreq, cli_unix_extensions_version_done, req);
75 static void cli_unix_extensions_version_done(struct tevent_req *subreq)
77 struct tevent_req *req = tevent_req_callback_data(
78 subreq, struct tevent_req);
79 struct cli_unix_extensions_version_state *state = tevent_req_data(
80 req, struct cli_unix_extensions_version_state);
85 status = cli_trans_recv(subreq, state, NULL, NULL, 0, NULL,
86 NULL, 0, NULL, &data, 12, &num_data);
88 if (!NT_STATUS_IS_OK(status)) {
89 tevent_req_nterror(req, status);
93 state->major = SVAL(data, 0);
94 state->minor = SVAL(data, 2);
95 state->caplow = IVAL(data, 4);
96 state->caphigh = IVAL(data, 8);
101 NTSTATUS cli_unix_extensions_version_recv(struct tevent_req *req,
102 uint16_t *pmajor, uint16_t *pminor,
106 struct cli_unix_extensions_version_state *state = tevent_req_data(
107 req, struct cli_unix_extensions_version_state);
110 if (tevent_req_is_nterror(req, &status)) {
113 *pmajor = state->major;
114 *pminor = state->minor;
115 *pcaplow = state->caplow;
116 *pcaphigh = state->caphigh;
117 state->cli->server_posix_capabilities = *pcaplow;
121 NTSTATUS cli_unix_extensions_version(struct cli_state *cli, uint16_t *pmajor,
122 uint16_t *pminor, uint32_t *pcaplow,
125 TALLOC_CTX *frame = talloc_stackframe();
126 struct tevent_context *ev;
127 struct tevent_req *req;
128 NTSTATUS status = NT_STATUS_OK;
130 if (smbXcli_conn_has_async_calls(cli->conn)) {
132 * Can't use sync call while an async call is in flight
134 status = NT_STATUS_INVALID_PARAMETER;
138 ev = samba_tevent_context_init(frame);
140 status = NT_STATUS_NO_MEMORY;
144 req = cli_unix_extensions_version_send(frame, ev, cli);
146 status = NT_STATUS_NO_MEMORY;
150 if (!tevent_req_poll_ntstatus(req, ev, &status)) {
154 status = cli_unix_extensions_version_recv(req, pmajor, pminor, pcaplow,
161 /****************************************************************************
162 Set UNIX extensions capabilities.
163 ****************************************************************************/
165 struct cli_set_unix_extensions_capabilities_state {
166 struct cli_state *cli;
172 static void cli_set_unix_extensions_capabilities_done(
173 struct tevent_req *subreq);
175 struct tevent_req *cli_set_unix_extensions_capabilities_send(
176 TALLOC_CTX *mem_ctx, struct tevent_context *ev, struct cli_state *cli,
177 uint16_t major, uint16_t minor, uint32_t caplow, uint32_t caphigh)
179 struct tevent_req *req, *subreq;
180 struct cli_set_unix_extensions_capabilities_state *state;
182 req = tevent_req_create(
184 struct cli_set_unix_extensions_capabilities_state);
190 SSVAL(state->setup+0, 0, TRANSACT2_SETFSINFO);
192 SSVAL(state->param, 0, 0);
193 SSVAL(state->param, 2, SMB_SET_CIFS_UNIX_INFO);
195 SSVAL(state->data, 0, major);
196 SSVAL(state->data, 2, minor);
197 SIVAL(state->data, 4, caplow);
198 SIVAL(state->data, 8, caphigh);
200 subreq = cli_trans_send(state, ev, cli, 0, SMBtrans2,
204 state->data, 12, 560);
205 if (tevent_req_nomem(subreq, req)) {
206 return tevent_req_post(req, ev);
208 tevent_req_set_callback(
209 subreq, cli_set_unix_extensions_capabilities_done, req);
213 static void cli_set_unix_extensions_capabilities_done(
214 struct tevent_req *subreq)
216 struct tevent_req *req = tevent_req_callback_data(
217 subreq, struct tevent_req);
218 struct cli_set_unix_extensions_capabilities_state *state = tevent_req_data(
219 req, struct cli_set_unix_extensions_capabilities_state);
221 NTSTATUS status = cli_trans_recv(subreq, NULL, NULL, NULL, 0, NULL,
222 NULL, 0, NULL, NULL, 0, NULL);
223 if (NT_STATUS_IS_OK(status)) {
224 state->cli->requested_posix_capabilities = IVAL(state->data, 4);
226 tevent_req_simple_finish_ntstatus(subreq, status);
229 NTSTATUS cli_set_unix_extensions_capabilities_recv(struct tevent_req *req)
231 return tevent_req_simple_recv_ntstatus(req);
234 NTSTATUS cli_set_unix_extensions_capabilities(struct cli_state *cli,
235 uint16_t major, uint16_t minor,
236 uint32_t caplow, uint32_t caphigh)
238 struct tevent_context *ev;
239 struct tevent_req *req;
240 NTSTATUS status = NT_STATUS_NO_MEMORY;
242 if (smbXcli_conn_has_async_calls(cli->conn)) {
243 return NT_STATUS_INVALID_PARAMETER;
245 ev = samba_tevent_context_init(talloc_tos());
249 req = cli_set_unix_extensions_capabilities_send(
250 ev, ev, cli, major, minor, caplow, caphigh);
254 if (!tevent_req_poll_ntstatus(req, ev, &status)) {
257 status = cli_set_unix_extensions_capabilities_recv(req);
263 struct cli_get_fs_attr_info_state {
269 static void cli_get_fs_attr_info_done(struct tevent_req *subreq);
271 struct tevent_req *cli_get_fs_attr_info_send(TALLOC_CTX *mem_ctx,
272 struct tevent_context *ev,
273 struct cli_state *cli)
275 struct tevent_req *subreq, *req;
276 struct cli_get_fs_attr_info_state *state;
278 req = tevent_req_create(mem_ctx, &state,
279 struct cli_get_fs_attr_info_state);
283 SSVAL(state->setup+0, 0, TRANSACT2_QFSINFO);
284 SSVAL(state->param+0, 0, SMB_QUERY_FS_ATTRIBUTE_INFO);
286 subreq = cli_trans_send(state, ev, cli, 0, SMBtrans2,
291 if (tevent_req_nomem(subreq, req)) {
292 return tevent_req_post(req, ev);
294 tevent_req_set_callback(subreq, cli_get_fs_attr_info_done, req);
298 static void cli_get_fs_attr_info_done(struct tevent_req *subreq)
300 struct tevent_req *req = tevent_req_callback_data(
301 subreq, struct tevent_req);
302 struct cli_get_fs_attr_info_state *state = tevent_req_data(
303 req, struct cli_get_fs_attr_info_state);
308 status = cli_trans_recv(subreq, talloc_tos(), NULL, NULL, 0, NULL,
309 NULL, 0, NULL, &data, 12, &num_data);
311 if (!NT_STATUS_IS_OK(status)) {
312 tevent_req_nterror(req, status);
315 state->fs_attr = IVAL(data, 0);
317 tevent_req_done(req);
320 NTSTATUS cli_get_fs_attr_info_recv(struct tevent_req *req, uint32_t *fs_attr)
322 struct cli_get_fs_attr_info_state *state = tevent_req_data(
323 req, struct cli_get_fs_attr_info_state);
326 if (tevent_req_is_nterror(req, &status)) {
329 *fs_attr = state->fs_attr;
333 NTSTATUS cli_get_fs_attr_info(struct cli_state *cli, uint32_t *fs_attr)
335 struct tevent_context *ev;
336 struct tevent_req *req;
337 NTSTATUS status = NT_STATUS_NO_MEMORY;
339 if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
340 return cli_smb2_get_fs_attr_info(cli, fs_attr);
343 if (smbXcli_conn_has_async_calls(cli->conn)) {
344 return NT_STATUS_INVALID_PARAMETER;
346 ev = samba_tevent_context_init(talloc_tos());
350 req = cli_get_fs_attr_info_send(ev, ev, cli);
354 if (!tevent_req_poll_ntstatus(req, ev, &status)) {
357 status = cli_get_fs_attr_info_recv(req, fs_attr);
363 NTSTATUS cli_get_fs_volume_info(struct cli_state *cli,
366 uint32_t *pserial_number,
370 uint16_t recv_flags2;
374 uint32_t rdata_count;
376 char *volume_name = NULL;
378 SSVAL(setup, 0, TRANSACT2_QFSINFO);
379 SSVAL(param,0,SMB_QUERY_FS_VOLUME_INFO);
381 status = cli_trans(talloc_tos(), cli, SMBtrans2,
389 &rdata, 18, &rdata_count);
390 if (!NT_STATUS_IS_OK(status)) {
396 ts = interpret_long_date((char *)rdata);
399 if (pserial_number) {
400 *pserial_number = IVAL(rdata,8);
402 nlen = IVAL(rdata,12);
403 if (nlen > (rdata_count - 18)) {
405 return NT_STATUS_INVALID_NETWORK_RESPONSE;
408 clistr_pull_talloc(mem_ctx,
414 if (volume_name == NULL) {
415 status = map_nt_error_from_unix(errno);
420 /* todo: but not yet needed
421 * return the other stuff
424 *_volume_name = volume_name;
429 NTSTATUS cli_get_fs_full_size_info(struct cli_state *cli,
430 uint64_t *total_allocation_units,
431 uint64_t *caller_allocation_units,
432 uint64_t *actual_allocation_units,
433 uint64_t *sectors_per_allocation_unit,
434 uint64_t *bytes_per_sector)
438 uint8_t *rdata = NULL;
439 uint32_t rdata_count;
442 SSVAL(setup, 0, TRANSACT2_QFSINFO);
443 SSVAL(param, 0, SMB_FS_FULL_SIZE_INFORMATION);
445 status = cli_trans(talloc_tos(), cli, SMBtrans2,
447 setup, 1, 0, /* setup */
448 param, 2, 0, /* param */
449 NULL, 0, 560, /* data */
451 NULL, 0, NULL, /* rsetup */
452 NULL, 0, NULL, /* rparam */
453 &rdata, 32, &rdata_count); /* rdata */
454 if (!NT_STATUS_IS_OK(status)) {
458 if (total_allocation_units) {
459 *total_allocation_units = BIG_UINT(rdata, 0);
461 if (caller_allocation_units) {
462 *caller_allocation_units = BIG_UINT(rdata,8);
464 if (actual_allocation_units) {
465 *actual_allocation_units = BIG_UINT(rdata,16);
467 if (sectors_per_allocation_unit) {
468 *sectors_per_allocation_unit = IVAL(rdata,24);
470 if (bytes_per_sector) {
471 *bytes_per_sector = IVAL(rdata,28);
479 NTSTATUS cli_get_posix_fs_info(struct cli_state *cli,
480 uint32_t *optimal_transfer_size,
481 uint32_t *block_size,
482 uint64_t *total_blocks,
483 uint64_t *blocks_available,
484 uint64_t *user_blocks_available,
485 uint64_t *total_file_nodes,
486 uint64_t *free_file_nodes,
487 uint64_t *fs_identifier)
491 uint8_t *rdata = NULL;
492 uint32_t rdata_count;
495 SSVAL(setup, 0, TRANSACT2_QFSINFO);
496 SSVAL(param,0,SMB_QUERY_POSIX_FS_INFO);
498 status = cli_trans(talloc_tos(), cli, SMBtrans2, NULL, 0, 0, 0,
503 NULL, 0, NULL, /* rsetup */
504 NULL, 0, NULL, /* rparam */
505 &rdata, 56, &rdata_count);
506 if (!NT_STATUS_IS_OK(status)) {
510 if (optimal_transfer_size) {
511 *optimal_transfer_size = IVAL(rdata, 0);
514 *block_size = IVAL(rdata,4);
517 *total_blocks = BIG_UINT(rdata,8);
519 if (blocks_available) {
520 *blocks_available = BIG_UINT(rdata,16);
522 if (user_blocks_available) {
523 *user_blocks_available = BIG_UINT(rdata,24);
525 if (total_file_nodes) {
526 *total_file_nodes = BIG_UINT(rdata,32);
528 if (free_file_nodes) {
529 *free_file_nodes = BIG_UINT(rdata,40);
532 *fs_identifier = BIG_UINT(rdata,48);
537 /****************************************************************************
538 Do a UNIX extensions SMB_QUERY_POSIX_WHOAMI call.
539 ****************************************************************************/
541 struct posix_whoami_state {
551 struct dom_sid *sids;
554 static void cli_posix_whoami_done(struct tevent_req *subreq);
556 struct tevent_req *cli_posix_whoami_send(TALLOC_CTX *mem_ctx,
557 struct tevent_context *ev,
558 struct cli_state *cli)
560 struct tevent_req *req = NULL, *subreq = NULL;
561 struct posix_whoami_state *state = NULL;
563 req = tevent_req_create(mem_ctx, &state, struct posix_whoami_state);
568 /* Setup setup word. */
569 SSVAL(state->setup, 0, TRANSACT2_QFSINFO);
570 SSVAL(state->param, 0, SMB_QUERY_POSIX_WHOAMI);
572 state->max_rdata = 62*1024;
574 subreq = cli_trans_send(state, /* mem ctx. */
576 cli, /* cli_state. */
577 0, /* additional_flags2 */
578 SMBtrans2, /* cmd. */
579 NULL, /* pipe name. */
583 state->setup, /* setup. */
584 1, /* num setup uint16_t words. */
585 0, /* max returned setup. */
586 state->param, /* param. */
588 0, /* max returned param. */
591 state->max_rdata); /* max returned data. */
593 if (tevent_req_nomem(subreq, req)) {
594 return tevent_req_post(req, ev);
596 tevent_req_set_callback(subreq, cli_posix_whoami_done, req);
600 static void cli_posix_whoami_done(struct tevent_req *subreq)
602 struct tevent_req *req = tevent_req_callback_data(
603 subreq, struct tevent_req);
604 struct posix_whoami_state *state = tevent_req_data(
605 req, struct posix_whoami_state);
606 uint8_t *rdata = NULL;
608 uint32_t num_rdata = 0;
612 status = cli_trans_recv(subreq,
625 if (tevent_req_nterror(req, status)) {
630 * Not strictly needed - cli_trans_recv()
631 * will ensure at least 40 bytes here. Added
632 * as more of a reminder to be careful when
633 * parsing network packets in C.
636 if (num_rdata < 40 || rdata + num_rdata < rdata) {
637 tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
641 state->guest = (IVAL(rdata, 0) & SMB_WHOAMI_GUEST);
642 state->uid = BVAL(rdata, 8);
643 state->gid = BVAL(rdata, 16);
644 state->num_gids = IVAL(rdata, 24);
645 state->num_sids = IVAL(rdata, 28);
647 state->gids = talloc_array(state, uint64_t, state->num_gids);
648 if (tevent_req_nomem(state->gids, req)) {
651 state->sids = talloc_array(state, struct dom_sid, state->num_sids);
652 if (tevent_req_nomem(state->sids, req)) {
658 for (i = 0; i < state->num_gids; i++) {
659 if (p + 8 > rdata + num_rdata) {
660 tevent_req_nterror(req,
661 NT_STATUS_INVALID_NETWORK_RESPONSE);
664 state->gids[i] = BVAL(p, 0);
668 num_rdata -= (p - rdata);
670 for (i = 0; i < state->num_sids; i++) {
672 DATA_BLOB in = data_blob_const(p, num_rdata);
673 enum ndr_err_code ndr_err;
675 ndr_err = ndr_pull_struct_blob(&in,
678 (ndr_pull_flags_fn_t)ndr_pull_dom_sid);
679 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
680 tevent_req_nterror(req,
681 NT_STATUS_INVALID_NETWORK_RESPONSE);
685 sid_size = ndr_size_dom_sid(&state->sids[i], 0);
687 if (sid_size > num_rdata) {
688 tevent_req_nterror(req,
689 NT_STATUS_INVALID_NETWORK_RESPONSE);
694 num_rdata -= sid_size;
696 tevent_req_done(req);
699 NTSTATUS cli_posix_whoami_recv(struct tevent_req *req,
706 struct dom_sid **psids,
710 struct posix_whoami_state *state = tevent_req_data(
711 req, struct posix_whoami_state);
713 if (tevent_req_is_nterror(req, &status)) {
724 *pnum_gids = state->num_gids;
727 *pgids = talloc_move(mem_ctx, &state->gids);
730 *pnum_sids = state->num_sids;
733 *psids = talloc_move(mem_ctx, &state->sids);
736 *pguest = state->guest;
741 NTSTATUS cli_posix_whoami(struct cli_state *cli,
748 struct dom_sid **sids,
751 TALLOC_CTX *frame = talloc_stackframe();
752 struct tevent_context *ev = NULL;
753 struct tevent_req *req = NULL;
754 NTSTATUS status = NT_STATUS_OK;
756 if (smbXcli_conn_has_async_calls(cli->conn)) {
758 * Can't use sync call while an async call is in flight
760 status = NT_STATUS_INVALID_PARAMETER;
764 ev = samba_tevent_context_init(frame);
766 status = NT_STATUS_NO_MEMORY;
770 req = cli_posix_whoami_send(frame,
774 status = NT_STATUS_NO_MEMORY;
778 if (!tevent_req_poll_ntstatus(req, ev, &status)) {
782 status = cli_posix_whoami_recv(req,