return len;
}
+static bool cli_state_set_seqnum(struct cli_state *cli, uint16_t mid, uint32_t seqnum)
+{
+ struct cli_state_seqnum *c;
+
+ for (c = cli->seqnum; c; c = c->next) {
+ if (c->mid == mid) {
+ c->seqnum = seqnum;
+ return true;
+ }
+ }
+
+ c = talloc_zero(cli, struct cli_state_seqnum);
+ if (!c) {
+ return false;
+ }
+
+ c->mid = mid;
+ c->seqnum = seqnum;
+ c->persistent = false;
+ DLIST_ADD_END(cli->seqnum, c, struct cli_state_seqnum *);
+
+ return true;
+}
+
+bool cli_state_seqnum_persistent(struct cli_state *cli,
+ uint16_t mid)
+{
+ struct cli_state_seqnum *c;
+
+ for (c = cli->seqnum; c; c = c->next) {
+ if (c->mid == mid) {
+ c->persistent = true;
+ return true;
+ }
+ }
+
+ return false;
+}
+
+bool cli_state_seqnum_remove(struct cli_state *cli,
+ uint16_t mid)
+{
+ struct cli_state_seqnum *c;
+
+ for (c = cli->seqnum; c; c = c->next) {
+ if (c->mid == mid) {
+ DLIST_REMOVE(cli->seqnum, c);
+ TALLOC_FREE(c);
+ return true;
+ }
+ }
+
+ return false;
+}
+
+static uint32_t cli_state_get_seqnum(struct cli_state *cli, uint16_t mid)
+{
+ struct cli_state_seqnum *c;
+
+ for (c = cli->seqnum; c; c = c->next) {
+ if (c->mid == mid) {
+ uint32_t seqnum = c->seqnum;
+ if (!c->persistent) {
+ DLIST_REMOVE(cli->seqnum, c);
+ TALLOC_FREE(c);
+ }
+ return seqnum;
+ }
+ }
+
+ return 0;
+}
+
/****************************************************************************
Recv an smb.
****************************************************************************/
bool cli_receive_smb(struct cli_state *cli)
{
ssize_t len;
+ uint16_t mid;
+ uint32_t seqnum;
/* fd == -1 causes segfaults -- Tom (tom@ninja.nl) */
if (cli->fd == -1)
if (cli->oplock_handler) {
int fnum = SVAL(cli->inbuf,smb_vwv2);
unsigned char level = CVAL(cli->inbuf,smb_vwv3+1);
- if (!cli->oplock_handler(cli, fnum, level)) {
+ if (!NT_STATUS_IS_OK(cli->oplock_handler(cli, fnum, level))) {
return false;
}
}
return false;
}
- if (!cli_check_sign_mac(cli, cli->inbuf)) {
+ mid = SVAL(cli->inbuf,smb_mid);
+ seqnum = cli_state_get_seqnum(cli, mid);
+
+ if (!cli_check_sign_mac(cli, cli->inbuf, seqnum+1)) {
/*
* If we get a signature failure in sessionsetup, then
* the server sometimes just reflects the sent signature
set_smb_read_error(&cli->smb_rw_error, SMB_READ_OK);
- status = read_socket_with_timeout(
+ status = read_fd_with_timeout(
cli->fd, buffer, len, len, cli->timeout, NULL);
if (NT_STATUS_IS_OK(status)) {
return len;
ssize_t ret;
char *buf_out = cli->outbuf;
bool enc_on = cli_encryption_on(cli);
+ uint32_t seqnum;
/* fd == -1 causes segfaults -- Tom (tom@ninja.nl) */
if (cli->fd == -1)
return false;
- cli_calculate_sign_mac(cli, cli->outbuf);
+ cli_calculate_sign_mac(cli, cli->outbuf, &seqnum);
+
+ if (!cli_state_set_seqnum(cli, cli->mid, seqnum)) {
+ DEBUG(0,("Failed to store mid[%u]/seqnum[%u]\n",
+ (unsigned int)cli->mid,
+ (unsigned int)seqnum));
+ return false;
+ }
if (enc_on) {
NTSTATUS status = cli_encrypt_message(cli, cli->outbuf,
return false;
}
- iov[0].iov_base = cli->outbuf;
+ iov[0].iov_base = (void *)cli->outbuf;
iov[0].iov_len = len;
- iov[1].iov_base = CONST_DISCARD(char *, p);
+ iov[1].iov_base = CONST_DISCARD(void *, p);
iov[1].iov_len = extradata;
nwritten = write_data_iov(cli->fd, iov, 2);
cli->bufsize = CLI_BUFFER_SIZE+4;
cli->max_xmit = cli->bufsize;
cli->outbuf = (char *)SMB_MALLOC(cli->bufsize+SAFETY_MARGIN);
+ cli->seqnum = 0;
cli->inbuf = (char *)SMB_MALLOC(cli->bufsize+SAFETY_MARGIN);
cli->oplock_handler = cli_oplock_ack;
cli->case_sensitive = false;
#endif
/* initialise signing */
- cli->sign_info.allow_smb_signing = allow_smb_signing;
- cli->sign_info.mandatory_signing = mandatory_signing;
- cli_null_set_signing(cli);
+ cli->signing_state = smb_signing_init(cli,
+ allow_smb_signing,
+ mandatory_signing);
+ if (!cli->signing_state) {
+ goto error;
+ }
+
+ cli->outgoing = tevent_queue_create(cli, "cli_outgoing");
+ if (cli->outgoing == NULL) {
+ goto error;
+ }
+ cli->pending = NULL;
cli->initialised = 1;
Shutdown a client structure.
****************************************************************************/
-void cli_shutdown(struct cli_state *cli)
+static void _cli_shutdown(struct cli_state *cli)
{
- if (cli->prev == NULL) {
- /*
- * Possible head of a DFS list,
- * shutdown all subsidiary DFS
- * connections.
- */
- struct cli_state *p, *next;
-
- for (p = cli->next; p; p = next) {
- next = p->next;
- cli_shutdown(p);
- }
- } else {
- /*
- * We're a subsidiary connection.
- * Just remove ourselves from the
- * DFS list.
- */
- DLIST_REMOVE(cli->prev, cli);
- }
-
cli_nt_pipes_close(cli);
/*
SAFE_FREE(cli->outbuf);
SAFE_FREE(cli->inbuf);
- cli_free_signing_context(cli);
data_blob_free(&cli->secblob);
data_blob_free(&cli->user_session_key);
cli->fd = -1;
cli->smb_rw_error = SMB_READ_OK;
+ /*
+ * Need to free pending first, they remove themselves
+ */
+ while (cli->pending) {
+ talloc_free(cli->pending[0]);
+ }
TALLOC_FREE(cli);
}
+void cli_shutdown(struct cli_state *cli)
+{
+ struct cli_state *cli_head;
+ if (cli == NULL) {
+ return;
+ }
+ DLIST_HEAD(cli, cli_head);
+ if (cli_head == cli) {
+ /*
+ * head of a DFS list, shutdown all subsidiary DFS
+ * connections.
+ */
+ struct cli_state *p, *next;
+
+ for (p = cli_head->next; p; p = next) {
+ next = p->next;
+ DLIST_REMOVE(cli_head, p);
+ _cli_shutdown(p);
+ }
+ } else {
+ DLIST_REMOVE(cli_head, cli);
+ }
+
+ _cli_shutdown(cli);
+}
+
/****************************************************************************
Set socket options on a open connection.
****************************************************************************/
return true;
}
-/**
- * @brief: Collect a echo reply
- * @param[in] req The corresponding async request
- *
- * There might be more than one echo reply. This helper pulls the reply out of
- * the data stream. If all expected replies have arrived, declare the
- * async_req done.
- */
-
-static void cli_echo_recv_helper(struct async_req *req)
-{
- struct cli_request *cli_req;
- uint8_t wct;
- uint16_t *vwv;
- uint16_t num_bytes;
- uint8_t *bytes;
- NTSTATUS status;
+struct cli_echo_state {
+ uint16_t vwv[1];
+ DATA_BLOB data;
+ int num_echos;
+};
- status = cli_pull_reply(req, &wct, &vwv, &num_bytes, &bytes);
- if (!NT_STATUS_IS_OK(status)) {
- async_req_nterror(req, status);
- return;
- }
+static void cli_echo_done(struct tevent_req *subreq);
- cli_req = talloc_get_type_abort(req->private_data, struct cli_request);
+struct tevent_req *cli_echo_send(TALLOC_CTX *mem_ctx, struct event_context *ev,
+ struct cli_state *cli, uint16_t num_echos,
+ DATA_BLOB data)
+{
+ struct tevent_req *req, *subreq;
+ struct cli_echo_state *state;
- if ((num_bytes != cli_req->data.echo.data.length)
- || (memcmp(cli_req->data.echo.data.data, bytes,
- num_bytes) != 0)) {
- async_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
- return;
+ req = tevent_req_create(mem_ctx, &state, struct cli_echo_state);
+ if (req == NULL) {
+ return NULL;
}
+ SSVAL(state->vwv, 0, num_echos);
+ state->data = data;
+ state->num_echos = num_echos;
- cli_req->data.echo.num_echos -= 1;
-
- if (cli_req->data.echo.num_echos == 0) {
- client_set_trans_sign_state_off(cli_req->cli, cli_req->mid);
- async_req_done(req);
- return;
+ subreq = cli_smb_send(state, ev, cli, SMBecho, 0, 1, state->vwv,
+ data.length, data.data);
+ if (subreq == NULL) {
+ goto fail;
}
-
- return;
+ tevent_req_set_callback(subreq, cli_echo_done, req);
+ return req;
+ fail:
+ TALLOC_FREE(req);
+ return NULL;
}
-/**
- * @brief Send SMBEcho requests
- * @param[in] mem_ctx The memory context to put the async_req on
- * @param[in] ev The event context that will call us back
- * @param[in] cli The connection to send the echo to
- * @param[in] num_echos How many times do we want to get the reply?
- * @param[in] data The data we want to get back
- * @retval The async request
- */
-
-struct async_req *cli_echo_send(TALLOC_CTX *mem_ctx, struct event_context *ev,
- struct cli_state *cli, uint16_t num_echos,
- DATA_BLOB data)
+static void cli_echo_done(struct tevent_req *subreq)
{
- uint16_t vwv[1];
- uint8_t *data_copy;
- struct async_req *result;
- struct cli_request *req;
-
- SSVAL(vwv, 0, num_echos);
+ struct tevent_req *req = tevent_req_callback_data(
+ subreq, struct tevent_req);
+ struct cli_echo_state *state = tevent_req_data(
+ req, struct cli_echo_state);
+ NTSTATUS status;
+ uint32_t num_bytes;
+ uint8_t *bytes;
+ uint8_t *inbuf;
- data_copy = (uint8_t *)talloc_memdup(mem_ctx, data.data, data.length);
- if (data_copy == NULL) {
- return NULL;
+ status = cli_smb_recv(subreq, state, &inbuf, 0, NULL, NULL,
+ &num_bytes, &bytes);
+ if (!NT_STATUS_IS_OK(status)) {
+ tevent_req_nterror(req, status);
+ return;
}
-
- result = cli_request_send(mem_ctx, ev, cli, SMBecho, 0, 1, vwv, 0,
- data.length, data.data);
- if (result == NULL) {
- TALLOC_FREE(data_copy);
- return NULL;
+ if ((num_bytes != state->data.length)
+ || (memcmp(bytes, state->data.data, num_bytes) != 0)) {
+ tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
+ return;
}
- req = talloc_get_type_abort(result->private_data, struct cli_request);
-
- client_set_trans_sign_state_on(cli, req->mid);
- req->data.echo.num_echos = num_echos;
- req->data.echo.data.data = talloc_move(req, &data_copy);
- req->data.echo.data.length = data.length;
-
- req->recv_helper.fn = cli_echo_recv_helper;
+ state->num_echos -=1;
+ if (state->num_echos == 0) {
+ tevent_req_done(req);
+ return;
+ }
- return result;
+ if (!cli_smb_req_set_pending(subreq)) {
+ tevent_req_nterror(req, NT_STATUS_NO_MEMORY);
+ return;
+ }
}
/**
* @retval Did the server reply correctly?
*/
-NTSTATUS cli_echo_recv(struct async_req *req)
+NTSTATUS cli_echo_recv(struct tevent_req *req)
{
- return async_req_simple_recv_ntstatus(req);
+ return tevent_req_simple_recv_ntstatus(req);
}
/**
{
TALLOC_CTX *frame = talloc_stackframe();
struct event_context *ev;
- struct async_req *req;
- NTSTATUS status = NT_STATUS_NO_MEMORY;
+ struct tevent_req *req;
+ NTSTATUS status = NT_STATUS_OK;
- if (cli->fd_event != NULL) {
+ if (cli_has_async_calls(cli)) {
/*
* Can't use sync call while an async call is in flight
*/
- cli_set_error(cli, NT_STATUS_INVALID_PARAMETER);
+ status = NT_STATUS_INVALID_PARAMETER;
goto fail;
}
ev = event_context_init(frame);
if (ev == NULL) {
+ status = NT_STATUS_NO_MEMORY;
goto fail;
}
req = cli_echo_send(frame, ev, cli, num_echos, data);
if (req == NULL) {
+ status = NT_STATUS_NO_MEMORY;
goto fail;
}
- while (req->state < ASYNC_REQ_DONE) {
- event_loop_once(ev);
+ if (!tevent_req_poll(req, ev)) {
+ status = map_nt_error_from_unix(errno);
+ goto fail;
}
status = cli_echo_recv(req);
-
fail:
TALLOC_FREE(frame);
+ if (!NT_STATUS_IS_OK(status)) {
+ cli_set_error(cli, status);
+ }
return status;
}
return false;
}
+
+NTSTATUS cli_smb(TALLOC_CTX *mem_ctx, struct cli_state *cli,
+ uint8_t smb_command, uint8_t additional_flags,
+ uint8_t wct, uint16_t *vwv,
+ uint32_t num_bytes, const uint8_t *bytes,
+ struct tevent_req **result_parent,
+ uint8_t min_wct, uint8_t *pwct, uint16_t **pvwv,
+ uint32_t *pnum_bytes, uint8_t **pbytes)
+{
+ struct tevent_context *ev;
+ struct tevent_req *req = NULL;
+ NTSTATUS status = NT_STATUS_NO_MEMORY;
+
+ if (cli_has_async_calls(cli)) {
+ return NT_STATUS_INVALID_PARAMETER;
+ }
+ ev = tevent_context_init(mem_ctx);
+ if (ev == NULL) {
+ goto fail;
+ }
+ req = cli_smb_send(mem_ctx, ev, cli, smb_command, additional_flags,
+ wct, vwv, num_bytes, bytes);
+ if (req == NULL) {
+ goto fail;
+ }
+ if (!tevent_req_poll_ntstatus(req, ev, &status)) {
+ goto fail;
+ }
+ status = cli_smb_recv(req, NULL, NULL, min_wct, pwct, pvwv,
+ pnum_bytes, pbytes);
+fail:
+ TALLOC_FREE(ev);
+ if (NT_STATUS_IS_OK(status)) {
+ *result_parent = req;
+ }
+ return status;
+}