char *async_req_print(TALLOC_CTX *mem_ctx, struct async_req *req)
{
- return talloc_asprintf(mem_ctx, "async_req: state=%d, status=%s, "
- "priv=%s", req->state, nt_errstr(req->status),
+ return talloc_asprintf(mem_ctx, "async_req: state=%d, error=%d, "
+ "priv=%s", req->state, (int)req->error,
talloc_get_name(req->private_data));
}
void async_req_done(struct async_req *req)
{
- req->status = NT_STATUS_OK;
+ req->error = 0;
req->state = ASYNC_REQ_DONE;
if (req->async.fn != NULL) {
req->async.fn(req);
* function with the appropriate status code.
*/
-void async_req_error(struct async_req *req, NTSTATUS status)
+void async_req_error(struct async_req *req, uint32_t error)
{
- req->status = status;
+ req->error = error;
req->state = ASYNC_REQ_ERROR;
if (req->async.fn != NULL) {
req->async.fn(req);
struct async_req *req = talloc_get_type_abort(priv, struct async_req);
TALLOC_FREE(te);
- if (NT_STATUS_IS_OK(req->status)) {
+ if (req->error == 0) {
async_req_done(req);
}
else {
- async_req_error(req, req->status);
+ async_req_error(req, req->error);
}
}
* conventions, independent of whether the request was actually deferred.
*/
-bool async_post_status(struct async_req *req, struct tevent_context *ev,
- NTSTATUS status)
+bool async_post_error(struct async_req *req, struct tevent_context *ev,
+ uint32_t error)
{
- req->status = status;
+ req->error = error;
if (tevent_add_timer(ev, req, timeval_zero(),
async_trigger, req) == NULL) {
return true;
}
-/**
- * @brief Helper function for nomem check
- * @param[in] p The pointer to be checked
- * @param[in] req The request being processed
- *
- * Convenience helper to easily check alloc failure within a callback
- * implementing the next step of an async request.
- *
- * Call pattern would be
- * \code
- * p = talloc(mem_ctx, bla);
- * if (async_req_nomem(p, req)) {
- * return;
- * }
- * \endcode
- */
-
-bool async_req_nomem(const void *p, struct async_req *req)
-{
- if (p != NULL) {
- return false;
- }
- async_req_error(req, NT_STATUS_NO_MEMORY);
- return true;
-}
-
-bool async_req_is_error(struct async_req *req, NTSTATUS *status)
+bool async_req_is_error(struct async_req *req, uint32_t *error)
{
if (req->state < ASYNC_REQ_DONE) {
- *status = NT_STATUS_INTERNAL_ERROR;
return true;
}
if (req->state == ASYNC_REQ_ERROR) {
- *status = req->status;
+ *error = req->error;
return true;
}
return false;
}
-NTSTATUS async_req_simple_recv(struct async_req *req)
-{
- NTSTATUS status;
-
- if (async_req_is_error(req, &status)) {
- return status;
- }
- return NT_STATUS_OK;
-}
-
static void async_req_timedout(struct tevent_context *ev,
struct tevent_timer *te,
struct timeval now,
struct async_req *req = talloc_get_type_abort(
priv, struct async_req);
TALLOC_FREE(te);
- async_req_error(req, NT_STATUS_IO_TIMEOUT);
+ async_req_nterror(req, NT_STATUS_IO_TIMEOUT);
}
bool async_req_set_timeout(struct async_req *req, struct tevent_context *ev,
return result;
}
-NTSTATUS async_wait_recv(struct async_req *req)
+bool async_wait_recv(struct async_req *req)
{
- return NT_STATUS_OK;
+ return true;
}
struct async_queue_entry {
#ifndef __ASYNC_REQ_H__
#define __ASYNC_REQ_H__
-#include "includes.h"
+#include "lib/talloc/talloc.h"
/**
* An async request moves between the following 4 states:
* @brief status code when finished
*
* This status can be queried in the async completion function. It
- * will be set to NT_STATUS_OK when everything went fine.
+ * will be set to 0 when everything went fine.
**/
- NTSTATUS status;
+ uint32_t error;
/**
* @brief What to do on completion
void async_req_done(struct async_req *req);
-void async_req_error(struct async_req *req, NTSTATUS status);
+void async_req_error(struct async_req *req, uint32_t error);
-bool async_post_status(struct async_req *req, struct tevent_context *ev,
- NTSTATUS status);
+bool async_post_error(struct async_req *req, struct tevent_context *ev,
+ uint32_t error);
-bool async_req_nomem(const void *p, struct async_req *req);
-
-bool async_req_is_error(struct async_req *req, NTSTATUS *status);
-
-NTSTATUS async_req_simple_recv(struct async_req *req);
+bool async_req_is_error(struct async_req *req, uint32_t *error);
bool async_req_set_timeout(struct async_req *req, struct tevent_context *ev,
struct timeval to);
struct tevent_context *ev,
struct timeval to);
-NTSTATUS async_wait_recv(struct async_req *req);
+bool async_wait_recv(struct async_req *req);
struct async_req_queue;
--- /dev/null
+/*
+ Unix SMB/CIFS implementation.
+ NTSTATUS wrappers for async_req.h
+ Copyright (C) Volker Lendecke 2008, 2009
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "includes.h"
+#include "lib/tevent/tevent.h"
+#include "lib/talloc/talloc.h"
+#include "lib/util/dlinklist.h"
+#include "lib/async_req/async_req_ntstatus.h"
+
+/**
+ * @brief Helper function for nomem check
+ * @param[in] p The pointer to be checked
+ * @param[in] req The request being processed
+ *
+ * Convenience helper to easily check alloc failure within a callback
+ * implementing the next step of an async request.
+ *
+ * Call pattern would be
+ * \code
+ * p = talloc(mem_ctx, bla);
+ * if (async_req_ntnomem(p, req)) {
+ * return;
+ * }
+ * \endcode
+ */
+
+bool async_req_ntnomem(const void *p, struct async_req *req)
+{
+ if (p != NULL) {
+ return false;
+ }
+ async_req_nterror(req, NT_STATUS_NO_MEMORY);
+ return true;
+}
+
+void async_req_nterror(struct async_req *req, NTSTATUS status)
+{
+ async_req_error(req, NT_STATUS_V(status));
+}
+
+bool async_post_ntstatus(struct async_req *req, struct tevent_context *ev,
+ NTSTATUS status)
+{
+ return async_post_error(req, ev, NT_STATUS_V(status));
+}
+
+bool async_req_is_nterror(struct async_req *req, NTSTATUS *status)
+{
+ uint32_t error = NT_STATUS_V(NT_STATUS_INTERNAL_ERROR);
+
+ if (async_req_is_error(req, &error)) {
+ *status = NT_STATUS(error);
+ return true;
+ }
+ return false;
+}
+
+NTSTATUS async_req_simple_recv_ntstatus(struct async_req *req)
+{
+ NTSTATUS status;
+
+ if (async_req_is_nterror(req, &status)) {
+ return status;
+ }
+ return NT_STATUS_OK;
+}
--- /dev/null
+/*
+ Unix SMB/CIFS implementation.
+ NTSTATUS wrappers for async_req.h
+ Copyright (C) Volker Lendecke 2008, 2009
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef __ASYNC_REQ_NTSTATUS_H__
+#define __ASYNC_REQ_NTSTATUS_H__
+
+#include "lib/async_req/async_req.h"
+#include "includes.h"
+
+void async_req_nterror(struct async_req *req, NTSTATUS status);
+
+bool async_post_ntstatus(struct async_req *req, struct tevent_context *ev,
+ NTSTATUS status);
+
+bool async_req_is_nterror(struct async_req *req, NTSTATUS *status);
+
+NTSTATUS async_req_simple_recv_ntstatus(struct async_req *req);
+
+bool async_req_ntnomem(const void *p, struct async_req *req);
+
+#endif
struct param_send *p = &state->param.param_send;
if (state->syscall_type != ASYNC_SYSCALL_SEND) {
- async_req_error(req, NT_STATUS_INTERNAL_ERROR);
+ async_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
return;
}
struct param_sendall *p = &state->param.param_sendall;
if (state->syscall_type != ASYNC_SYSCALL_SENDALL) {
- async_req_error(req, NT_STATUS_INTERNAL_ERROR);
+ async_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
return;
}
state->sys_errno = errno;
if (state->result.result_ssize_t == -1) {
- async_req_error(req, map_nt_error_from_unix(state->sys_errno));
+ async_req_nterror(req, map_nt_error_from_unix(state->sys_errno));
return;
}
if (state->result.result_ssize_t == 0) {
- async_req_error(req, NT_STATUS_END_OF_FILE);
+ async_req_nterror(req, NT_STATUS_END_OF_FILE);
return;
}
p->sent += state->result.result_ssize_t;
if (p->sent > p->length) {
- async_req_error(req, NT_STATUS_INTERNAL_ERROR);
+ async_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
return;
}
NTSTATUS sendall_recv(struct async_req *req)
{
- return async_req_simple_recv(req);
+ return async_req_simple_recv_ntstatus(req);
}
/**
struct param_recv *p = &state->param.param_recv;
if (state->syscall_type != ASYNC_SYSCALL_RECV) {
- async_req_error(req, NT_STATUS_INTERNAL_ERROR);
+ async_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
return;
}
struct param_recvall *p = &state->param.param_recvall;
if (state->syscall_type != ASYNC_SYSCALL_RECVALL) {
- async_req_error(req, NT_STATUS_INTERNAL_ERROR);
+ async_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
return;
}
state->sys_errno = errno;
if (state->result.result_ssize_t == -1) {
- async_req_error(req, map_nt_error_from_unix(state->sys_errno));
+ async_req_nterror(req, map_nt_error_from_unix(state->sys_errno));
return;
}
if (state->result.result_ssize_t == 0) {
- async_req_error(req, NT_STATUS_END_OF_FILE);
+ async_req_nterror(req, NT_STATUS_END_OF_FILE);
return;
}
p->received += state->result.result_ssize_t;
if (p->received > p->length) {
- async_req_error(req, NT_STATUS_INTERNAL_ERROR);
+ async_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
return;
}
NTSTATUS recvall_recv(struct async_req *req)
{
- return async_req_simple_recv(req);
+ return async_req_simple_recv_ntstatus(req);
}
struct async_connect_state {
status = map_nt_error_from_unix(state->sys_errno);
post_status:
fcntl(fd, F_SETFL, state->old_sockflags);
- if (!async_post_status(result, ev, status)) {
+ if (!async_post_ntstatus(result, ev, status)) {
goto fail;
}
return result;
DEBUG(10, ("connect returned %s\n", strerror(errno)));
fcntl(state->fd, F_SETFL, state->old_sockflags);
- async_req_error(req, map_nt_error_from_unix(state->sys_errno));
+ async_req_nterror(req, map_nt_error_from_unix(state->sys_errno));
return;
}
*perrno = state->sys_errno;
- if (async_req_is_error(req, &status)) {
+ if (async_req_is_nterror(req, &status)) {
return status;
}
if (state->sys_errno == 0) {
[SUBSYSTEM::LIBASYNC_REQ]
-LIBASYNC_REQ_OBJ_FILES = $(addprefix ../lib/async_req/, async_req.o async_sock.o)
+LIBASYNC_REQ_OBJ_FILES = $(addprefix ../lib/async_req/, async_req.o async_sock.o async_req_ntstatus.o)
lib/messages_ctdbd.o lib/packet.o lib/ctdbd_conn.o \
lib/interfaces.o lib/memcache.o \
lib/util_transfer_file.o ../lib/async_req/async_req.o \
- ../lib/async_req/async_sock.o \
+ ../lib/async_req/async_sock.o ../lib/async_req/async_req_ntstatus.o \
$(TDB_LIB_OBJ) \
$(VERSION_OBJ) lib/charcnv.o lib/debug.o lib/fault.o \
lib/interface.o lib/pidfile.o \
#include "ctdbd_conn.h"
#include "../lib/util/talloc_stack.h"
#include "memcache.h"
-#include "../lib/async_req/async_req.h"
+#include "../lib/async_req/async_req_ntstatus.h"
#include "async_smb.h"
#include "../lib/async_req/async_sock.h"
#include "services.h"
return result;
post_status:
- if (!async_post_status(result, ev, status)) {
+ if (!async_post_ntstatus(result, ev, status)) {
goto fail;
}
return result;
subreq = async_connect_send(state, state->ev, state->fd,
(struct sockaddr *)&state->ss,
state->salen);
- if (async_req_nomem(subreq, req)) {
+ if (async_req_ntnomem(subreq, req)) {
return;
}
if (!async_req_set_timeout(subreq, state->ev,
timeval_set(0, state->wait_nsec))) {
- async_req_error(req, NT_STATUS_NO_MEMORY);
+ async_req_nterror(req, NT_STATUS_NO_MEMORY);
return;
}
subreq->async.fn = open_socket_out_connected;
#endif
/* real error */
- async_req_error(req, map_nt_error_from_unix(sys_errno));
+ async_req_nterror(req, map_nt_error_from_unix(sys_errno));
}
NTSTATUS open_socket_out_recv(struct async_req *req, int *pfd)
req->private_data, struct open_socket_out_state);
NTSTATUS status;
- if (async_req_is_error(req, &status)) {
+ if (async_req_is_nterror(req, &status)) {
return status;
}
*pfd = state->fd;
return result;
post_status:
- if (!async_post_status(result, ev, status)) {
+ if (!async_post_ntstatus(result, ev, status)) {
goto fail;
}
return result;
subreq->async.priv, struct async_req);
struct open_socket_out_defer_state *state = talloc_get_type_abort(
req->private_data, struct open_socket_out_defer_state);
- NTSTATUS status;
+ bool ret;
- status = async_wait_recv(subreq);
+ ret = async_wait_recv(subreq);
TALLOC_FREE(subreq);
- if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ if (!ret) {
+ async_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
return;
}
subreq = open_socket_out_send(state, state->ev, &state->ss,
state->port, state->timeout);
- if (async_req_nomem(subreq, req)) {
+ if (async_req_ntnomem(subreq, req)) {
return;
}
subreq->async.fn = open_socket_out_defer_connected;
status = open_socket_out_recv(subreq, &state->fd);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
async_req_done(req);
req->private_data, struct open_socket_out_defer_state);
NTSTATUS status;
- if (async_req_is_error(req, &status)) {
+ if (async_req_is_nterror(req, &status)) {
return status;
}
*pfd = state->fd;
status = recvall_recv(subreq);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
DEBUG(0, ("wb_req_read_len: Invalid request size received: "
"%d (expected %d)\n", (int)state->wb_req->length,
(int)sizeof(struct winbindd_request)));
- async_req_error(req, NT_STATUS_INVALID_BUFFER_SIZE);
+ async_req_nterror(req, NT_STATUS_INVALID_BUFFER_SIZE);
return;
}
subreq = recvall_send(
req, state->ev, state->fd, (uint32 *)(state->wb_req)+1,
sizeof(struct winbindd_request) - sizeof(uint32), 0);
- if (async_req_nomem(subreq, req)) {
+ if (async_req_ntnomem(subreq, req)) {
return;
}
status = recvall_recv(subreq);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
DEBUG(3, ("Got request with %d bytes extra data on "
"unprivileged socket\n",
(int)state->wb_req->extra_len));
- async_req_error(req, NT_STATUS_INVALID_BUFFER_SIZE);
+ async_req_nterror(req, NT_STATUS_INVALID_BUFFER_SIZE);
return;
}
state->wb_req->extra_data.data = TALLOC_ARRAY(
state->wb_req, char, state->wb_req->extra_len + 1);
- if (async_req_nomem(state->wb_req->extra_data.data, req)) {
+ if (async_req_ntnomem(state->wb_req->extra_data.data, req)) {
return;
}
subreq = recvall_send(
req, state->ev, state->fd, state->wb_req->extra_data.data,
state->wb_req->extra_len, 0);
- if (async_req_nomem(subreq, req)) {
+ if (async_req_ntnomem(subreq, req)) {
return;
}
status = recvall_recv(subreq);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
async_req_done(req);
req->private_data, struct req_read_state);
NTSTATUS status;
- if (async_req_is_error(req, &status)) {
+ if (async_req_is_nterror(req, &status)) {
return status;
}
*preq = talloc_move(mem_ctx, &state->wb_req);
status = sendall_recv(subreq);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
subreq = sendall_send(state, state->ev, state->fd,
state->wb_req->extra_data.data,
state->wb_req->extra_len, 0);
- if (async_req_nomem(subreq, req)) {
+ if (async_req_ntnomem(subreq, req)) {
return;
}
status = sendall_recv(subreq);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
NTSTATUS wb_req_write_recv(struct async_req *req)
{
- return async_req_simple_recv(req);
+ return async_req_simple_recv_ntstatus(req);
}
struct resp_read_state {
status = recvall_recv(subreq);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
"%d (expected at least%d)\n",
(int)state->wb_resp->length,
(int)sizeof(struct winbindd_response)));
- async_req_error(req, NT_STATUS_INVALID_BUFFER_SIZE);
+ async_req_nterror(req, NT_STATUS_INVALID_BUFFER_SIZE);
return;
}
subreq = recvall_send(
req, state->ev, state->fd, (uint32 *)(state->wb_resp)+1,
sizeof(struct winbindd_response) - sizeof(uint32), 0);
- if (async_req_nomem(subreq, req)) {
+ if (async_req_ntnomem(subreq, req)) {
return;
}
status = recvall_recv(subreq);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
state->wb_resp->extra_data.data = TALLOC_ARRAY(
state->wb_resp, char, extra_len+1);
- if (async_req_nomem(state->wb_resp->extra_data.data, req)) {
+ if (async_req_ntnomem(state->wb_resp->extra_data.data, req)) {
return;
}
((char *)state->wb_resp->extra_data.data)[extra_len] = 0;
subreq = recvall_send(
req, state->ev, state->fd, state->wb_resp->extra_data.data,
extra_len, 0);
- if (async_req_nomem(subreq, req)) {
+ if (async_req_ntnomem(subreq, req)) {
return;
}
status = recvall_recv(subreq);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
async_req_done(req);
req->private_data, struct resp_read_state);
NTSTATUS status;
- if (async_req_is_error(req, &status)) {
+ if (async_req_is_nterror(req, &status)) {
return status;
}
*presp = talloc_move(mem_ctx, &state->wb_resp);
status = sendall_recv(subreq);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
state, state->ev, state->fd,
state->wb_resp->extra_data.data,
state->wb_resp->length - sizeof(struct winbindd_response), 0);
- if (async_req_nomem(subreq, req)) {
+ if (async_req_ntnomem(subreq, req)) {
return;
}
status = sendall_recv(subreq);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
NTSTATUS wb_resp_write_recv(struct async_req *req)
{
- return async_req_simple_recv(req);
+ return async_req_simple_recv_ntstatus(req);
}
if (req == NULL) {
return NULL;
}
- if (async_post_status(req, ev, status)) {
+ if (async_post_ntstatus(req, ev, status)) {
return req;
}
TALLOC_FREE(req);
}
if (winbind_closed_fd(fd)) {
- if (!async_post_status(result, ev,
- NT_STATUS_PIPE_DISCONNECTED)) {
+ if (!async_post_ntstatus(result, ev,
+ NT_STATUS_PIPE_DISCONNECTED)) {
goto fail;
}
return result;
status = wb_req_write_recv(subreq);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
subreq = wb_resp_read_send(state, state->ev, state->fd);
if (subreq == NULL) {
- async_req_error(req, NT_STATUS_NO_MEMORY);
+ async_req_nterror(req, NT_STATUS_NO_MEMORY);
}
subreq->async.fn = wb_int_trans_read_done;
subreq->async.priv = req;
status = wb_resp_read_recv(subreq, state, &state->wb_resp);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
req->private_data, struct wb_int_trans_state);
NTSTATUS status;
- if (async_req_is_error(req, &status)) {
+ if (async_req_is_nterror(req, &status)) {
return status;
}
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
state->wb_ctx->is_priv = true;
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
subreq = wb_int_trans_send(state, state->ev, state->wb_ctx->fd,
&state->wb_req);
- if (async_req_nomem(subreq, req)) {
+ if (async_req_ntnomem(subreq, req)) {
return;
}
status = wb_int_trans_recv(subreq, state, &wb_resp);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
subreq = wb_int_trans_send(state, state->ev, state->wb_ctx->fd,
&state->wb_req);
- if (async_req_nomem(subreq, req)) {
+ if (async_req_ntnomem(subreq, req)) {
return;
}
status = wb_int_trans_recv(subreq, state, &wb_resp);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
subreq = wb_connect_send(state, state->ev, state->wb_ctx,
(char *)wb_resp->extra_data.data);
TALLOC_FREE(wb_resp);
- if (async_req_nomem(subreq, req)) {
+ if (async_req_ntnomem(subreq, req)) {
return;
}
status = wb_connect_recv(subreq);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
state->wb_ctx->is_priv = true;
static NTSTATUS wb_open_pipe_recv(struct async_req *req)
{
- return async_req_simple_recv(req);
+ return async_req_simple_recv_ntstatus(req);
}
struct wb_trans_state {
subreq = wb_open_pipe_send(state, state->ev, state->wb_ctx,
state->need_priv);
- if (async_req_nomem(subreq, req)) {
+ if (async_req_ntnomem(subreq, req)) {
return;
}
subreq->async.fn = wb_trans_connect_done;
subreq = wb_int_trans_send(state, state->ev, state->wb_ctx->fd,
state->wb_req);
- if (async_req_nomem(subreq, req)) {
+ if (async_req_ntnomem(subreq, req)) {
return;
}
subreq->async.fn = wb_trans_done;
* Winbind not around or we can't connect to the pipe. Fail
* immediately.
*/
- async_req_error(req, status);
+ async_req_nterror(req, status);
return true;
}
state->num_retries -= 1;
if (state->num_retries == 0) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return true;
}
}
subreq = async_wait_send(state, state->ev, timeval_set(1, 0));
- if (async_req_nomem(subreq, req)) {
+ if (async_req_ntnomem(subreq, req)) {
return true;
}
subreq->async.priv, struct async_req);
struct wb_trans_state *state = talloc_get_type_abort(
req->private_data, struct wb_trans_state);
- NTSTATUS status;
+ bool ret;
- status = async_wait_recv(subreq);
+ ret = async_wait_recv(subreq);
TALLOC_FREE(subreq);
- if (!NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
- async_req_error(req, status);
+ if (ret) {
+ async_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
return;
}
subreq = wb_open_pipe_send(state, state->ev, state->wb_ctx,
state->need_priv);
- if (async_req_nomem(subreq, req)) {
+ if (async_req_ntnomem(subreq, req)) {
return;
}
subreq->async.fn = wb_trans_connect_done;
subreq = wb_int_trans_send(state, state->ev, state->wb_ctx->fd,
state->wb_req);
- if (async_req_nomem(subreq, req)) {
+ if (async_req_ntnomem(subreq, req)) {
return;
}
req->private_data, struct wb_trans_state);
NTSTATUS status;
- if (async_req_is_error(req, &status)) {
+ if (async_req_is_nterror(req, &status)) {
return status;
}
nt_errstr(status)));
for (req = cli->outstanding_requests; req; req = req->next) {
- async_req_error(req->async[0], status);
+ async_req_nterror(req->async[0], status);
}
return;
}
num_async = req->num_async;
for (i=0; i<num_async; i++) {
- async_req_error(req->async[i], status);
+ async_req_nterror(req->async[i], status);
}
}
TALLOC_FREE(cli->fd_event);
uint8_t *p;
NTSTATUS status;
- if (async_req_is_error(req, &status)) {
+ if (async_req_is_nterror(req, &status)) {
return status;
}
access_denied:
result = async_req_new(mem_ctx);
- if (async_post_status(result, ev, NT_STATUS_ACCESS_DENIED)) {
+ if (async_post_ntstatus(result, ev, NT_STATUS_ACCESS_DENIED)) {
return result;
}
TALLOC_FREE(result);
uint8_t *bytes;
NTSTATUS status;
- if (async_req_is_error(req, &status)) {
+ if (async_req_is_nterror(req, &status)) {
return status;
}
NTSTATUS status;
uint16_t protnum;
- if (async_req_is_error(req, &status)) {
+ if (async_req_is_nterror(req, &status)) {
return status;
}
status = cli_pull_reply(req, &wct, &vwv, &num_bytes, &bytes);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
if ((num_bytes != cli_req->data.echo.data.length)
|| (memcmp(cli_req->data.echo.data.data, bytes,
num_bytes) != 0)) {
- async_req_error(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
+ async_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
return;
}
NTSTATUS cli_echo_recv(struct async_req *req)
{
- return async_req_simple_recv(req);
+ return async_req_simple_recv_ntstatus(req);
}
/**
uint8_t *bytes;
NTSTATUS status;
- if (async_req_is_error(req, &status)) {
+ if (async_req_is_nterror(req, &status)) {
return status;
}
uint8_t *bytes;
NTSTATUS status;
- if (async_req_is_error(req, &status)) {
+ if (async_req_is_nterror(req, &status)) {
return status;
}
uint8_t *bytes;
NTSTATUS status;
- if (async_req_is_error(req, &status)) {
+ if (async_req_is_nterror(req, &status)) {
return status;
}
NTSTATUS status;
size_t size;
- if (async_req_is_error(req, &status)) {
+ if (async_req_is_nterror(req, &status)) {
return status;
}
state->top_req = 0;
if (size == 0) {
- if (!async_post_status(result, ev, NT_STATUS_OK)) {
+ if (!async_post_ntstatus(result, ev, NT_STATUS_OK)) {
goto failed;
}
return result;
status = cli_read_andx_recv(read_req, &read_state->data.read.received,
&read_state->data.read.rcvbuf);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(state->req, status);
+ async_req_nterror(state->req, status);
return;
}
top_read->data.read.received,
state->priv);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(state->req, status);
+ async_req_nterror(state->req, status);
return;
}
state->pushed += top_read->data.read.received;
state->start_offset + state->requested,
request_thistime);
- if (async_req_nomem(new_req, state->req)) {
+ if (async_req_ntnomem(new_req, state->req)) {
return;
}
req->private_data, struct cli_pull_state);
NTSTATUS status;
- if (async_req_is_error(req, &status)) {
+ if (async_req_is_nterror(req, &status)) {
return status;
}
*received = state->pushed;
NTSTATUS status;
size_t written;
- if (async_req_is_error(req, &status)) {
+ if (async_req_is_nterror(req, &status)) {
return status;
}
status = cli_write_andx_recv(subreq, &written);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
state->written += written;
if (state->written > state->size) {
- async_req_error(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
+ async_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
return;
}
state->buf + state->written,
state->offset + state->written, to_write);
if (subreq == NULL) {
- async_req_error(req, NT_STATUS_NO_MEMORY);
+ async_req_nterror(req, NT_STATUS_NO_MEMORY);
return;
}
static NTSTATUS cli_writeall_recv(struct async_req *req)
{
- return async_req_simple_recv(req);
+ return async_req_simple_recv_ntstatus(req);
}
struct cli_push_state {
}
if (i == 0) {
- if (!async_post_status(result, ev, NT_STATUS_OK)) {
+ if (!async_post_ntstatus(result, ev, NT_STATUS_OK)) {
goto failed;
}
return result;
}
if (i == state->num_reqs) {
- async_req_error(state->req, NT_STATUS_INTERNAL_ERROR);
+ async_req_nterror(state->req, NT_STATUS_INTERNAL_ERROR);
return;
}
TALLOC_FREE(state->reqs[i]);
req = NULL;
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(state->req, status);
+ async_req_nterror(state->req, status);
return;
}
state->reqs, state->ev, state->cli, state->fnum,
state->mode, buf, state->start_offset + state->sent, to_write);
if (state->reqs[i] == NULL) {
- async_req_error(state->req, NT_STATUS_NO_MEMORY);
+ async_req_nterror(state->req, NT_STATUS_NO_MEMORY);
return;
}
NTSTATUS cli_push_recv(struct async_req *req)
{
- return async_req_simple_recv(req);
+ return async_req_simple_recv_ntstatus(req);
}
NTSTATUS cli_push(struct cli_state *cli, uint16_t fnum, uint16_t mode,
{
state->secondary_request_ctx = talloc_new(state);
if (state->secondary_request_ctx == NULL) {
- async_req_error(req, NT_STATUS_NO_MEMORY);
+ async_req_nterror(req, NT_STATUS_NO_MEMORY);
return;
}
cli_req = cli_ship_trans(state->secondary_request_ctx, state);
if (cli_req == NULL) {
- async_req_error(req, NT_STATUS_NO_MEMORY);
+ async_req_nterror(req, NT_STATUS_NO_MEMORY);
return;
}
}
*/
if (NT_STATUS_IS_ERR(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
state->rsetup = (uint16_t *)TALLOC_MEMDUP(
state, setup, sizeof(uint16_t) * num_setup);
if (state->rsetup == NULL) {
- async_req_error(req, NT_STATUS_NO_MEMORY);
+ async_req_nterror(req, NT_STATUS_NO_MEMORY);
return;
}
}
if (!NT_STATUS_IS_OK(status)) {
DEBUG(10, ("Pulling params failed: %s\n", nt_errstr(status)));
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
if (!NT_STATUS_IS_OK(status)) {
DEBUG(10, ("Pulling data failed: %s\n", nt_errstr(status)));
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
cli_req->recv_helper.priv, struct cli_trans_state);
NTSTATUS status;
- if (async_req_is_error(req, &status)) {
+ if (async_req_is_nterror(req, &status)) {
return status;
}
status = state->transport->read_recv(subreq, &received);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
state->data + state->num_read,
state->size - state->num_read,
state->transport->priv);
- if (async_req_nomem(subreq, req)) {
+ if (async_req_ntnomem(subreq, req)) {
return;
}
subreq->async.fn = rpc_read_done;
static NTSTATUS rpc_read_recv(struct async_req *req)
{
- return async_req_simple_recv(req);
+ return async_req_simple_recv_ntstatus(req);
}
struct rpc_write_state {
status = state->transport->write_recv(subreq, &written);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
state->data + state->num_written,
state->size - state->num_written,
state->transport->priv);
- if (async_req_nomem(subreq, req)) {
+ if (async_req_ntnomem(subreq, req)) {
return;
}
subreq->async.fn = rpc_write_done;
static NTSTATUS rpc_write_recv(struct async_req *req)
{
- return async_req_simple_recv(req);
+ return async_req_simple_recv_ntstatus(req);
}
status = NT_STATUS_OK;
post_status:
- if (async_post_status(result, ev, status)) {
+ if (async_post_ntstatus(result, ev, status)) {
return result;
}
TALLOC_FREE(result);
status = rpc_read_recv(subreq);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
status = parse_rpc_header(state->cli, state->prhdr, state->pdu);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
if (!rpc_grow_buffer(state->pdu, state->prhdr->frag_len)) {
- async_req_error(req, NT_STATUS_NO_MEMORY);
+ async_req_nterror(req, NT_STATUS_NO_MEMORY);
return;
}
state, state->ev, state->cli->transport,
(uint8_t *)(prs_data_p(state->pdu) + RPC_HEADER_LEN),
state->prhdr->frag_len - RPC_HEADER_LEN);
- if (async_req_nomem(subreq, req)) {
+ if (async_req_ntnomem(subreq, req)) {
return;
}
subreq->async.fn = get_complete_frag_got_rest;
status = rpc_read_recv(subreq);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
async_req_done(req);
static NTSTATUS get_complete_frag_recv(struct async_req *req)
{
- return async_req_simple_recv(req);
+ return async_req_simple_recv_ntstatus(req);
}
/****************************************************************************
status = NT_STATUS_INVALID_PARAMETER;
post_status:
- if (async_post_status(result, ev, status)) {
+ if (async_post_ntstatus(result, ev, status)) {
return result;
}
fail:
&state->rdata_len);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
async_req_done(req);
status = rpc_write_recv(subreq);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
state->rdata = TALLOC_ARRAY(state, uint8_t, RPC_HEADER_LEN);
- if (async_req_nomem(state->rdata, req)) {
+ if (async_req_ntnomem(state->rdata, req)) {
return;
}
subreq = state->transport->read_send(state, state->ev, state->rdata,
RPC_HEADER_LEN,
state->transport->priv);
- if (async_req_nomem(subreq, req)) {
+ if (async_req_ntnomem(subreq, req)) {
return;
}
subreq->async.fn = cli_api_pipe_read_done;
status = state->transport->read_recv(subreq, &received);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
state->rdata_len = received;
req->private_data, struct cli_api_pipe_state);
NTSTATUS status;
- if (async_req_is_error(req, &status)) {
+ if (async_req_is_nterror(req, &status)) {
return status;
}
return result;
post_status:
- if (async_post_status(result, ev, status)) {
+ if (async_post_ntstatus(result, ev, status)) {
return result;
}
TALLOC_FREE(result);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(5, ("cli_api_pipe failed: %s\n", nt_errstr(status)));
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
*/
rdata_copy = (char *)memdup(rdata, rdata_len);
TALLOC_FREE(rdata);
- if (async_req_nomem(rdata_copy, req)) {
+ if (async_req_ntnomem(rdata_copy, req)) {
return;
}
prs_give_memory(&state->incoming_frag, rdata_copy, rdata_len, true);
/* Ensure we have enough data for a pdu. */
subreq = get_complete_frag_send(state, state->ev, state->cli,
&state->rhdr, &state->incoming_frag);
- if (async_req_nomem(subreq, req)) {
+ if (async_req_ntnomem(subreq, req)) {
return;
}
subreq->async.fn = rpc_api_pipe_got_pdu;
if (!NT_STATUS_IS_OK(status)) {
DEBUG(5, ("get_complete_frag failed: %s\n",
nt_errstr(status)));
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
nt_errstr(status)));
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
"%s\n",
state->incoming_pdu.bigendian_data?"big":"little",
state->incoming_frag.bigendian_data?"big":"little"));
- async_req_error(req, NT_STATUS_INVALID_PARAMETER);
+ async_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
return;
}
/* Now copy the data portion out of the pdu into rbuf. */
if (!prs_force_grow(&state->incoming_pdu, rdata_len)) {
- async_req_error(req, NT_STATUS_NO_MEMORY);
+ async_req_nterror(req, NT_STATUS_NO_MEMORY);
return;
}
status = cli_pipe_reset_current_pdu(state->cli, &state->rhdr,
&state->incoming_frag);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
subreq = get_complete_frag_send(state, state->ev, state->cli,
&state->rhdr, &state->incoming_frag);
- if (async_req_nomem(subreq, req)) {
+ if (async_req_ntnomem(subreq, req)) {
return;
}
subreq->async.fn = rpc_api_pipe_got_pdu;
req->private_data, struct rpc_api_pipe_state);
NTSTATUS status;
- if (async_req_is_error(req, &status)) {
+ if (async_req_is_nterror(req, &status)) {
return status;
}
return result;
post_status:
- if (async_post_status(result, ev, status)) {
+ if (async_post_ntstatus(result, ev, status)) {
return result;
}
TALLOC_FREE(result);
status = rpc_write_recv(subreq);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
status = prepare_next_frag(state, &is_last_frag);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
subreq = rpc_api_pipe_send(state, state->ev, state->cli,
&state->outgoing_frag,
RPC_RESPONSE);
- if (async_req_nomem(subreq, req)) {
+ if (async_req_ntnomem(subreq, req)) {
return;
}
subreq->async.fn = rpc_api_pipe_req_done;
state->cli->transport,
(uint8_t *)prs_data_p(&state->outgoing_frag),
prs_offset(&state->outgoing_frag));
- if (async_req_nomem(subreq, req)) {
+ if (async_req_ntnomem(subreq, req)) {
return;
}
subreq->async.fn = rpc_api_pipe_req_write_done;
status = rpc_api_pipe_recv(subreq, state, &state->reply_pdu);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
async_req_done(req);
req->private_data, struct rpc_api_pipe_req_state);
NTSTATUS status;
- if (async_req_is_error(req, &status)) {
+ if (async_req_is_nterror(req, &status)) {
/*
* We always have to initialize to reply pdu, even if there is
* none. The rpccli_* caller routines expect this.
return result;
post_status:
- if (async_post_status(result, ev, status)) {
+ if (async_post_ntstatus(result, ev, status)) {
return result;
}
TALLOC_FREE(result);
DEBUG(3, ("rpc_pipe_bind: %s bind request returned %s\n",
rpccli_pipe_txt(debug_ctx(), state->cli),
nt_errstr(status)));
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
if (!smb_io_rpc_hdr("hdr", &hdr, &reply_pdu, 0)) {
DEBUG(0, ("rpc_pipe_bind: failed to unmarshall RPC_HDR.\n"));
prs_mem_free(&reply_pdu);
- async_req_error(req, NT_STATUS_BUFFER_TOO_SMALL);
+ async_req_nterror(req, NT_STATUS_BUFFER_TOO_SMALL);
return;
}
DEBUG(0, ("rpc_pipe_bind: Failed to unmarshall "
"RPC_HDR_BA.\n"));
prs_mem_free(&reply_pdu);
- async_req_error(req, NT_STATUS_BUFFER_TOO_SMALL);
+ async_req_nterror(req, NT_STATUS_BUFFER_TOO_SMALL);
return;
}
if (!check_bind_response(&hdr_ba, &state->cli->transfer_syntax)) {
DEBUG(2, ("rpc_pipe_bind: check_bind_response failed.\n"));
prs_mem_free(&reply_pdu);
- async_req_error(req, NT_STATUS_BUFFER_TOO_SMALL);
+ async_req_nterror(req, NT_STATUS_BUFFER_TOO_SMALL);
return;
}
&reply_pdu);
prs_mem_free(&reply_pdu);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
}
break;
&reply_pdu);
prs_mem_free(&reply_pdu);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
}
break;
DEBUG(0,("cli_finish_bind_auth: unknown auth type %u\n",
(unsigned int)state->cli->auth->auth_type));
prs_mem_free(&reply_pdu);
- async_req_error(req, NT_STATUS_INTERNAL_ERROR);
+ async_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
}
}
status = rpc_write_recv(subreq);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
async_req_done(req);
status = rpc_api_pipe_recv(subreq, talloc_tos(), &reply_pdu);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
if (!smb_io_rpc_hdr("rpc_hdr ", &hdr, &reply_pdu, 0)) {
DEBUG(0, ("rpc_finish_spnego_ntlmssp_bind: Failed to "
"unmarshall RPC_HDR.\n"));
- async_req_error(req, NT_STATUS_BUFFER_TOO_SMALL);
+ async_req_nterror(req, NT_STATUS_BUFFER_TOO_SMALL);
return;
}
if (!prs_set_offset(
&reply_pdu,
hdr.frag_len - hdr.auth_len - RPC_HDR_AUTH_LEN)) {
- async_req_error(req, NT_STATUS_INVALID_PARAMETER);
+ async_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
return;
}
if (!smb_io_rpc_hdr_auth("hdr_auth", &hdr_auth, &reply_pdu, 0)) {
- async_req_error(req, NT_STATUS_INVALID_PARAMETER);
+ async_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
return;
}
OID_NTLMSSP, &tmp_blob)) {
data_blob_free(&server_spnego_response);
data_blob_free(&tmp_blob);
- async_req_error(req, NT_STATUS_INVALID_PARAMETER);
+ async_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
return;
}
NTSTATUS rpc_pipe_bind_recv(struct async_req *req)
{
- return async_req_simple_recv(req);
+ return async_req_simple_recv_ntstatus(req);
}
NTSTATUS rpc_pipe_bind(struct rpc_pipe_client *cli,
status = cli_write_andx_recv(subreq, &state->written);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
async_req_done(req);
req->private_data, struct rpc_np_write_state);
NTSTATUS status;
- if (async_req_is_error(req, &status)) {
+ if (async_req_is_nterror(req, &status)) {
return status;
}
*pwritten = state->written;
}
if (!NT_STATUS_IS_OK(status)) {
TALLOC_FREE(subreq);
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
if (state->received > state->size) {
TALLOC_FREE(subreq);
- async_req_error(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
+ async_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
return;
}
req->private_data, struct rpc_np_read_state);
NTSTATUS status;
- if (async_req_is_error(req, &status)) {
+ if (async_req_is_nterror(req, &status)) {
return status;
}
*preceived = state->received;
&state->rdata, &state->rdata_len);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
async_req_done(req);
req->private_data, struct rpc_np_trans_state);
NTSTATUS status;
- if (async_req_is_error(req, &status)) {
+ if (async_req_is_nterror(req, &status)) {
return status;
}
*prdata = talloc_move(mem_ctx, &state->rdata);
status = cli_ntcreate_recv(subreq, &state->transport_np->fnum);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
req->private_data, struct rpc_transport_np_init_state);
NTSTATUS status;
- if (async_req_is_error(req, &status)) {
+ if (async_req_is_nterror(req, &status)) {
return status;
}
status = cli_negprot_recv(subreq);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
subreq = cli_session_setup_guest_send(state, state->ev, state->cli);
- if (async_req_nomem(subreq, req)) {
+ if (async_req_ntnomem(subreq, req)) {
return;
}
subreq->async.fn = get_anon_ipc_sesssetup_done;
status = cli_session_setup_guest_recv(subreq);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
subreq = cli_tcon_andx_send(state, state->ev, state->cli,
"IPC$", "IPC", NULL, 0);
- if (async_req_nomem(subreq, req)) {
+ if (async_req_ntnomem(subreq, req)) {
return;
}
subreq->async.fn = get_anon_ipc_tcon_done;
status = cli_tcon_andx_recv(subreq);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
async_req_done(req);
static NTSTATUS get_anon_ipc_recv(struct async_req *req)
{
- return async_req_simple_recv(req);
+ return async_req_simple_recv_ntstatus(req);
}
struct rpc_cli_smbd_conn_init_state {
if (stdout_pipe[1] != -1) {
close(stdout_pipe[1]);
}
- if (async_post_status(result, ev, status)) {
+ if (async_post_ntstatus(result, ev, status)) {
return result;
}
TALLOC_FREE(result);
status = get_anon_ipc_recv(subreq);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
async_req_done(req);
req->private_data, struct rpc_cli_smbd_conn_init_state);
NTSTATUS status;
- if (async_req_is_error(req, &status)) {
+ if (async_req_is_nterror(req, &status)) {
return status;
}
*pconn = talloc_move(mem_ctx, &state->conn);
status = state->sub_transp->write_recv(subreq, &state->written);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
async_req_done(req);
req->private_data, struct rpc_smbd_write_state);
NTSTATUS status;
- if (async_req_is_error(req, &status)) {
+ if (async_req_is_nterror(req, &status)) {
return status;
}
*pwritten = state->written;
status = state->sub_transp->read_recv(subreq, &state->received);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
async_req_done(req);
req->private_data, struct rpc_smbd_read_state);
NTSTATUS status;
- if (async_req_is_error(req, &status)) {
+ if (async_req_is_nterror(req, &status)) {
return status;
}
*preceived = state->received;
&state->transport_smbd->sub_transp);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
async_req_done(req);
req->private_data, struct rpc_transport_smbd_init_state);
NTSTATUS status;
- if (async_req_is_error(req, &status)) {
+ if (async_req_is_nterror(req, &status)) {
return status;
}
status = NT_STATUS_INVALID_HANDLE;
post_status:
- if (async_post_status(result, ev, status)) {
+ if (async_post_ntstatus(result, ev, status)) {
return result;
}
fail:
status = sendall_recv(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
async_req_done(req);
req->private_data, struct np_write_state);
NTSTATUS status;
- if (async_req_is_error(req, &status)) {
+ if (async_req_is_nterror(req, &status)) {
return status;
}
*pnwritten = state->nwritten;
status = NT_STATUS_INVALID_HANDLE;
post_status:
- if (async_post_status(result, ev, status)) {
+ if (async_post_ntstatus(result, ev, status)) {
return result;
}
fail:
status = recvall_recv(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
async_req_done(req);
req->private_data, struct np_read_state);
NTSTATUS status;
- if (async_req_is_error(req, &status)) {
+ if (async_req_is_nterror(req, &status)) {
return status;
}
*nread = state->nread;