sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2024-12-24 21:34:56 +03:00
Code

Merge branch 'master' of ssh://git.samba.org/data/git/samba

Browse Source
This commit is contained in:
Andrew Tridgell 2009-03-17 14:19:25 +11:00
commit 467cc6927f
17 changed files with 187 additions and 275 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
lib/async_req/async_req.c
View File

@ -194,48 +194,6 @@ bool async_req_is_error(struct async_req *req, enum async_req_state *state,
return true;
}
static void async_req_timedout(struct tevent_context *ev,
struct tevent_timer *te,
struct timeval now,
void *priv)
{
struct async_req *req = talloc_get_type_abort(priv, struct async_req);
TALLOC_FREE(te);
async_req_finish(req, ASYNC_REQ_TIMED_OUT);
}
bool async_req_set_timeout(struct async_req *req, struct tevent_context *ev,
struct timeval to)
{
return (tevent_add_timer(
ev, req,
tevent_timeval_current_ofs(to.tv_sec, to.tv_usec),
async_req_timedout, req)
!= NULL);
}
struct async_req *async_wait_send(TALLOC_CTX *mem_ctx,
struct tevent_context *ev,
struct timeval to)
{
struct async_req *result;
result = async_req_new(mem_ctx);
if (result == NULL) {
return result;
}
if (!async_req_set_timeout(result, ev, to)) {
TALLOC_FREE(result);
return NULL;
}
return result;
}
bool async_wait_recv(struct async_req *req)
{
return true;
}
struct async_queue_entry {
struct async_queue_entry *prev, *next;
struct async_req_queue *queue;

9
lib/async_req/async_req.h
View File

@ -139,15 +139,6 @@ bool async_post_error(struct async_req *req, struct tevent_context *ev,
bool async_req_is_error(struct async_req *req, enum async_req_state *state,
uint64_t *error);
bool async_req_set_timeout(struct async_req *req, struct tevent_context *ev,
struct timeval to);
struct async_req *async_wait_send(TALLOC_CTX *mem_ctx,
struct tevent_context *ev,
struct timeval to);
bool async_wait_recv(struct async_req *req);
struct async_req_queue;
struct async_req_queue *async_req_queue_init(TALLOC_CTX *mem_ctx);

2
lib/replace/libreplace_network.m4
View File

@ -242,7 +242,7 @@ AC_CHECK_MEMBERS([struct sockaddr.sa_len],
dnl test for getifaddrs and freeifaddrs
AC_CACHE_CHECK([for getifaddrs and freeifaddrs],libreplace_cv_HAVE_GETIFADDRS,[
AC_TRY_COMPILE([
AC_TRY_LINK([
#include <sys/types.h>
#if STDC_HEADERS
#include <stdlib.h>

2
lib/talloc/configure.ac
View File

@ -1,5 +1,5 @@
AC_PREREQ(2.50)
AC_INIT(talloc, 1.2.1)
AC_INIT(talloc, 1.3.0)
AC_CONFIG_SRCDIR([talloc.c])
AC_SUBST(datarootdir)
AC_CONFIG_HEADER(config.h)

3
lib/talloc/talloc.h
View File

@ -94,6 +94,7 @@ typedef void TALLOC_CTX;
#define talloc_array(ctx, type, count) (type *)_talloc_array(ctx, sizeof(type), count, #type)
#define talloc_array_size(ctx, size, count) _talloc_array(ctx, size, count, __location__)
#define talloc_array_ptrtype(ctx, ptr, count) (_TALLOC_TYPEOF(ptr))talloc_array_size(ctx, sizeof(*(ptr)), count)
#define talloc_array_length(ctx) ((ctx) ? talloc_get_size(ctx)/sizeof(*ctx) : 0)
#define talloc_realloc(ctx, p, type, count) (type *)_talloc_realloc_array(ctx, p, sizeof(type), count, #type)
#define talloc_realloc_size(ctx, ptr, size) _talloc_realloc(ctx, ptr, size, __location__)
@ -115,6 +116,8 @@ typedef void TALLOC_CTX;
#define talloc_append_string(c, s, a) (s?talloc_strdup_append(s,a):talloc_strdup(c, a))
#endif
#define TALLOC_FREE(ctx) do { talloc_free(ctx); ctx=NULL; } while(0)
/* The following definitions come from talloc.c */
void *_talloc(const void *context, size_t size);
void *talloc_pool(const void *context, size_t size);

2
nsswitch/pam_winbind.h
View File

@ -171,6 +171,8 @@ struct pwb_context {
uint32_t ctrl;
};
#ifndef TALLOC_FREE
#define TALLOC_FREE(ctx) do { talloc_free(ctx); ctx=NULL; } while(0)
#endif
#define TALLOC_ZERO_P(ctx, type) (type *)_talloc_zero(ctx, sizeof(type), #type)
#define TALLOC_P(ctx, type) (type *)talloc_named_const(ctx, sizeof(type), #type)

2
source3/configure.in
View File

@ -31,7 +31,7 @@ if test "x$enable_external_libtalloc" != xno
then
PKG_CHECK_MODULES(TALLOC, talloc >= 1.3.0,
[ enable_external_libtalloc=yes ],
[ if x$enable_external_libtalloc = xyes; then
[ if test x$enable_external_libtalloc = xyes; then
AC_MSG_ERROR([Unable to find libtalloc])
else
enable_external_libtalloc=no

30
source3/include/proto.h
View File

@ -1072,26 +1072,26 @@ const char *my_netbios_names(int i);
bool set_netbios_aliases(const char **str_array);
bool init_names(void);
struct user_auth_info *user_auth_info_init(TALLOC_CTX *mem_ctx);
const char *get_cmdline_auth_info_username(struct user_auth_info *auth_info);
const char *get_cmdline_auth_info_username(const struct user_auth_info *auth_info);
void set_cmdline_auth_info_username(struct user_auth_info *auth_info,
const char *username);
void set_cmdline_auth_info_password(struct user_auth_info *auth_info,
const char *password);
const char *get_cmdline_auth_info_password(struct user_auth_info *auth_info);
const char *get_cmdline_auth_info_password(const struct user_auth_info *auth_info);
bool set_cmdline_auth_info_signing_state(struct user_auth_info *auth_info,
const char *arg);
int get_cmdline_auth_info_signing_state(struct user_auth_info *auth_info);
int get_cmdline_auth_info_signing_state(const struct user_auth_info *auth_info);
void set_cmdline_auth_info_use_kerberos(struct user_auth_info *auth_info,
bool b);
bool get_cmdline_auth_info_use_kerberos(struct user_auth_info *auth_info);
bool get_cmdline_auth_info_use_kerberos(const struct user_auth_info *auth_info);
void set_cmdline_auth_info_use_krb5_ticket(struct user_auth_info *auth_info);
void set_cmdline_auth_info_smb_encrypt(struct user_auth_info *auth_info);
void set_cmdline_auth_info_use_machine_account(struct user_auth_info *auth_info);
bool get_cmdline_auth_info_got_pass(struct user_auth_info *auth_info);
bool get_cmdline_auth_info_smb_encrypt(struct user_auth_info *auth_info);
bool get_cmdline_auth_info_use_machine_account(struct user_auth_info *auth_info);
bool get_cmdline_auth_info_got_pass(const struct user_auth_info *auth_info);
bool get_cmdline_auth_info_smb_encrypt(const struct user_auth_info *auth_info);
bool get_cmdline_auth_info_use_machine_account(const struct user_auth_info *auth_info);
struct user_auth_info *get_cmdline_auth_info_copy(TALLOC_CTX *mem_ctx,
struct user_auth_info *info);
const struct user_auth_info *info);
bool set_cmdline_auth_info_machine_account_creds(struct user_auth_info *auth_info);
bool add_gid_to_array_unique(TALLOC_CTX *mem_ctx, gid_t gid,
gid_t **gids, size_t *num_gids);
@ -1396,13 +1396,13 @@ struct tevent_req *open_socket_out_send(TALLOC_CTX *mem_ctx,
uint16_t port,
int timeout);
NTSTATUS open_socket_out_recv(struct tevent_req *req, int *pfd);
struct async_req *open_socket_out_defer_send(TALLOC_CTX *mem_ctx,
struct event_context *ev,
struct timeval wait_time,
const struct sockaddr_storage *pss,
uint16_t port,
int timeout);
NTSTATUS open_socket_out_defer_recv(struct async_req *req, int *pfd);
struct tevent_req *open_socket_out_defer_send(TALLOC_CTX *mem_ctx,
struct event_context *ev,
struct timeval wait_time,
const struct sockaddr_storage *pss,
uint16_t port,
int timeout);
NTSTATUS open_socket_out_defer_recv(struct tevent_req *req, int *pfd);
bool open_any_socket_out(struct sockaddr_storage *addrs, int num_addrs,
int timeout, int *fd_index, int *fd);
int open_udp_socket(const char *host, int port);

2
source3/include/smb_macros.h
View File

@ -256,7 +256,9 @@ NULL returns on zero request. JRA.
#define TALLOC_REALLOC(ctx, ptr, count) _talloc_realloc(ctx, ptr, count, __location__)
#define TALLOC_REALLOC_ARRAY(ctx, ptr, type, count) (type *)_talloc_realloc_array(ctx, ptr, sizeof(type), count, #type)
#define talloc_destroy(ctx) talloc_free(ctx)
#ifndef TALLOC_FREE
#define TALLOC_FREE(ctx) do { talloc_free(ctx); ctx=NULL; } while(0)
#endif
/* only define PARANOID_MALLOC_CHECKER with --enable-developer */

17
source3/include/wbc_async.h
View File

@ -22,23 +22,18 @@
#include "nsswitch/libwbclient/wbclient.h"
struct wb_context {
struct async_req_queue *queue;
int fd;
bool is_priv;
};
struct wb_context;
struct async_req *wb_trans_send(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
struct wb_context *wb_ctx, bool need_priv,
struct winbindd_request *wb_req);
wbcErr wb_trans_recv(struct async_req *req, TALLOC_CTX *mem_ctx,
struct tevent_req *wb_trans_send(TALLOC_CTX *mem_ctx,
struct tevent_context *ev,
struct wb_context *wb_ctx, bool need_priv,
struct winbindd_request *wb_req);
wbcErr wb_trans_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
struct winbindd_response **presponse);
struct wb_context *wb_context_init(TALLOC_CTX *mem_ctx);
/* Definitions from wb_reqtrans.c */
bool async_req_is_wbcerr(struct async_req *req, wbcErr *pwbc_err);
wbcErr map_wbc_err_from_errno(int error);
wbcErr async_req_simple_recv_wbcerr(struct async_req *req);
bool tevent_req_is_wbcerr(struct tevent_req *req, wbcErr *pwbc_err);
wbcErr tevent_req_simple_recv_wbcerr(struct tevent_req *req);

16
source3/lib/util.c
View File

@ -290,7 +290,7 @@ struct user_auth_info *user_auth_info_init(TALLOC_CTX *mem_ctx)
return result;
}
const char *get_cmdline_auth_info_username(struct user_auth_info *auth_info)
const char *get_cmdline_auth_info_username(const struct user_auth_info *auth_info)
{
if (!auth_info->username) {
return "";
@ -308,7 +308,7 @@ void set_cmdline_auth_info_username(struct user_auth_info *auth_info,
}
}
const char *get_cmdline_auth_info_password(struct user_auth_info *auth_info)
const char *get_cmdline_auth_info_password(const struct user_auth_info *auth_info)
{
if (!auth_info->password) {
return "";
@ -346,7 +346,7 @@ bool set_cmdline_auth_info_signing_state(struct user_auth_info *auth_info,
return true;
}
int get_cmdline_auth_info_signing_state(struct user_auth_info *auth_info)
int get_cmdline_auth_info_signing_state(const struct user_auth_info *auth_info)
{
return auth_info->signing_state;
}
@ -357,7 +357,7 @@ void set_cmdline_auth_info_use_kerberos(struct user_auth_info *auth_info,
auth_info->use_kerberos = b;
}
bool get_cmdline_auth_info_use_kerberos(struct user_auth_info *auth_info)
bool get_cmdline_auth_info_use_kerberos(const struct user_auth_info *auth_info)
{
return auth_info->use_kerberos;
}
@ -380,23 +380,23 @@ void set_cmdline_auth_info_use_machine_account(struct user_auth_info *auth_info)
auth_info->use_machine_account = true;
}
bool get_cmdline_auth_info_got_pass(struct user_auth_info *auth_info)
bool get_cmdline_auth_info_got_pass(const struct user_auth_info *auth_info)
{
return auth_info->got_pass;
}
bool get_cmdline_auth_info_smb_encrypt(struct user_auth_info *auth_info)
bool get_cmdline_auth_info_smb_encrypt(const struct user_auth_info *auth_info)
{
return auth_info->smb_encrypt;
}
bool get_cmdline_auth_info_use_machine_account(struct user_auth_info *auth_info)
bool get_cmdline_auth_info_use_machine_account(const struct user_auth_info *auth_info)
{
return auth_info->use_machine_account;
}
struct user_auth_info *get_cmdline_auth_info_copy(TALLOC_CTX *mem_ctx,
struct user_auth_info *src)
const struct user_auth_info *src)
{
struct user_auth_info *result;

83
source3/lib/util_sock.c
View File

@ -1152,22 +1152,22 @@ struct open_socket_out_defer_state {
int fd;
};
static void open_socket_out_defer_waited(struct async_req *subreq);
static void open_socket_out_defer_waited(struct tevent_req *subreq);
static void open_socket_out_defer_connected(struct tevent_req *subreq);
struct async_req *open_socket_out_defer_send(TALLOC_CTX *mem_ctx,
struct event_context *ev,
struct timeval wait_time,
const struct sockaddr_storage *pss,
uint16_t port,
int timeout)
struct tevent_req *open_socket_out_defer_send(TALLOC_CTX *mem_ctx,
struct event_context *ev,
struct timeval wait_time,
const struct sockaddr_storage *pss,
uint16_t port,
int timeout)
{
struct async_req *result, *subreq;
struct tevent_req *req, *subreq;
struct open_socket_out_defer_state *state;
NTSTATUS status;
if (!async_req_setup(mem_ctx, &result, &state,
struct open_socket_out_defer_state)) {
req = tevent_req_create(mem_ctx, &state,
struct open_socket_out_defer_state);
if (req == NULL) {
return NULL;
}
state->ev = ev;
@ -1175,73 +1175,66 @@ struct async_req *open_socket_out_defer_send(TALLOC_CTX *mem_ctx,
state->port = port;
state->timeout = timeout;
subreq = async_wait_send(state, ev, wait_time);
subreq = tevent_wakeup_send(
state, ev,
timeval_current_ofs(wait_time.tv_sec, wait_time.tv_usec));
if (subreq == NULL) {
status = NT_STATUS_NO_MEMORY;
goto post_status;
}
subreq->async.fn = open_socket_out_defer_waited;
subreq->async.priv = result;
return result;
post_status:
if (!async_post_ntstatus(result, ev, status)) {
goto fail;
}
return result;
tevent_req_set_callback(subreq, open_socket_out_defer_waited, req);
return req;
fail:
TALLOC_FREE(result);
TALLOC_FREE(req);
return NULL;
}
static void open_socket_out_defer_waited(struct async_req *subreq)
static void open_socket_out_defer_waited(struct tevent_req *subreq)
{
struct async_req *req = talloc_get_type_abort(
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);
struct tevent_req *subreq2;
struct tevent_req *req = tevent_req_callback_data(
subreq, struct tevent_req);
struct open_socket_out_defer_state *state = tevent_req_data(
req, struct open_socket_out_defer_state);
bool ret;
ret = async_wait_recv(subreq);
ret = tevent_wakeup_recv(subreq);
TALLOC_FREE(subreq);
if (!ret) {
async_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
return;
}
subreq2 = open_socket_out_send(state, state->ev, &state->ss,
state->port, state->timeout);
if (async_req_nomem(subreq2, req)) {
subreq = open_socket_out_send(state, state->ev, &state->ss,
state->port, state->timeout);
if (tevent_req_nomem(subreq, req)) {
return;
}
tevent_req_set_callback(subreq2, open_socket_out_defer_connected, req);
tevent_req_set_callback(subreq, open_socket_out_defer_connected, req);
}
static void open_socket_out_defer_connected(struct tevent_req *subreq)
{
struct async_req *req =
tevent_req_callback_data(subreq, struct async_req);
struct open_socket_out_defer_state *state = talloc_get_type_abort(
req->private_data, struct open_socket_out_defer_state);
struct tevent_req *req = tevent_req_callback_data(
subreq, struct tevent_req);
struct open_socket_out_defer_state *state = tevent_req_data(
req, struct open_socket_out_defer_state);
NTSTATUS status;
status = open_socket_out_recv(subreq, &state->fd);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
async_req_nterror(req, status);
tevent_req_nterror(req, status);
return;
}
async_req_done(req);
tevent_req_done(req);
}
NTSTATUS open_socket_out_defer_recv(struct async_req *req, int *pfd)
NTSTATUS open_socket_out_defer_recv(struct tevent_req *req, int *pfd)
{
struct open_socket_out_defer_state *state = talloc_get_type_abort(
req->private_data, struct open_socket_out_defer_state);
struct open_socket_out_defer_state *state = tevent_req_data(
req, struct open_socket_out_defer_state);
NTSTATUS status;
if (async_req_is_nterror(req, &status)) {
if (tevent_req_is_nterror(req, &status)) {
return status;
}
*pfd = state->fd;

37
source3/lib/wb_reqtrans.c
View File

@ -25,32 +25,6 @@
#undef DBGC_CLASS
#define DBGC_CLASS DBGC_WINBIND
bool async_req_is_wbcerr(struct async_req *req, wbcErr *pwbc_err)
{
enum async_req_state state;
uint64_t error;
if (!async_req_is_error(req, &state, &error)) {
*pwbc_err = WBC_ERR_SUCCESS;
return false;
}
switch (state) {
case ASYNC_REQ_USER_ERROR:
*pwbc_err = error;
break;
case ASYNC_REQ_TIMED_OUT:
*pwbc_err = WBC_ERR_UNKNOWN_FAILURE;
break;
case ASYNC_REQ_NO_MEMORY:
*pwbc_err = WBC_ERR_NO_MEMORY;
break;
default:
*pwbc_err = WBC_ERR_UNKNOWN_FAILURE;
break;
}
return true;
}
wbcErr map_wbc_err_from_errno(int error)
{
switch(error) {
@ -65,17 +39,6 @@ wbcErr map_wbc_err_from_errno(int error)
}
}
wbcErr async_req_simple_recv_wbcerr(struct async_req *req)
{
wbcErr wbc_err;
if (async_req_is_wbcerr(req, &wbc_err)) {
return wbc_err;
}
return WBC_ERR_SUCCESS;
}
bool tevent_req_is_wbcerr(struct tevent_req *req, wbcErr *pwbc_err)
{
enum tevent_req_state state;

145
source3/lib/wbclient.c
View File

@ -20,6 +20,12 @@
#include "includes.h"
#include "wbc_async.h"
struct wb_context {
struct tevent_queue *queue;
int fd;
bool is_priv;
};
static int make_nonstd_fd(int fd)
{
int i;
@ -138,7 +144,7 @@ struct wb_context *wb_context_init(TALLOC_CTX *mem_ctx)
if (result == NULL) {
return NULL;
}
result->queue = async_req_queue_init(result);
result->queue = tevent_queue_create(result, "wb_trans");
if (result->queue == NULL) {
TALLOC_FREE(result);
return NULL;
@ -545,43 +551,18 @@ struct wb_trans_state {
static void wb_trans_connect_done(struct tevent_req *subreq);
static void wb_trans_done(struct tevent_req *subreq);
static void wb_trans_retry_wait_done(struct async_req *subreq);
static void wb_trans_retry_wait_done(struct tevent_req *subreq);
static void wb_trigger_trans(struct async_req *req)
struct tevent_req *wb_trans_send(TALLOC_CTX *mem_ctx,
struct tevent_context *ev,
struct wb_context *wb_ctx, bool need_priv,
struct winbindd_request *wb_req)
{
struct wb_trans_state *state = talloc_get_type_abort(
req->private_data, struct wb_trans_state);
struct tevent_req *subreq;
if ((state->wb_ctx->fd == -1)
|| (state->need_priv && !state->wb_ctx->is_priv)) {
subreq = wb_open_pipe_send(state, state->ev, state->wb_ctx,
state->need_priv);
if (async_req_nomem(subreq, req)) {
return;
}
tevent_req_set_callback(subreq, wb_trans_connect_done, req);
return;
}
subreq = wb_int_trans_send(state, state->ev, NULL, state->wb_ctx->fd,
state->wb_req);
if (async_req_nomem(subreq, req)) {
return;
}
tevent_req_set_callback(subreq, wb_trans_done, req);
}
struct async_req *wb_trans_send(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
struct wb_context *wb_ctx, bool need_priv,
struct winbindd_request *wb_req)
{
struct async_req *result;
struct tevent_req *req, *subreq;
struct wb_trans_state *state;
if (!async_req_setup(mem_ctx, &result, &state,
struct wb_trans_state)) {
req = tevent_req_create(mem_ctx, &state, struct wb_trans_state);
if (req == NULL) {
return NULL;
}
state->wb_ctx = wb_ctx;
@ -590,21 +571,32 @@ struct async_req *wb_trans_send(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
state->num_retries = 10;
state->need_priv = need_priv;
if (!async_req_enqueue(wb_ctx->queue, ev, result, wb_trigger_trans)) {
if ((wb_ctx->fd == -1) || (need_priv && !wb_ctx->is_priv)) {
subreq = wb_open_pipe_send(state, ev, wb_ctx, need_priv);
if (subreq == NULL) {
goto fail;
}
tevent_req_set_callback(subreq, wb_trans_connect_done, req);
return req;
}
subreq = wb_int_trans_send(state, ev, wb_ctx->queue, wb_ctx->fd,
wb_req);
if (subreq == NULL) {
goto fail;
}
return result;
tevent_req_set_callback(subreq, wb_trans_done, req);
return req;
fail:
TALLOC_FREE(result);
TALLOC_FREE(req);
return NULL;
}
static bool wb_trans_retry(struct async_req *req,
static bool wb_trans_retry(struct tevent_req *req,
struct wb_trans_state *state,
wbcErr wbc_err)
{
struct async_req *subreq;
struct tevent_req *subreq;
if (WBC_ERROR_IS_OK(wbc_err)) {
return false;
@ -615,13 +607,13 @@ static bool wb_trans_retry(struct async_req *req,
* Winbind not around or we can't connect to the pipe. Fail
* immediately.
*/
async_req_error(req, wbc_err);
tevent_req_error(req, wbc_err);
return true;
}
state->num_retries -= 1;
if (state->num_retries == 0) {
async_req_error(req, wbc_err);
tevent_req_error(req, wbc_err);
return true;
}
@ -634,47 +626,44 @@ static bool wb_trans_retry(struct async_req *req,
state->wb_ctx->fd = -1;
}
subreq = async_wait_send(state, state->ev, timeval_set(1, 0));
if (async_req_nomem(subreq, req)) {
subreq = tevent_wakeup_send(state, state->ev,
timeval_current_ofs(1, 0));
if (tevent_req_nomem(subreq, req)) {
return true;
}
subreq->async.fn = wb_trans_retry_wait_done;
subreq->async.priv = req;
tevent_req_set_callback(subreq, wb_trans_retry_wait_done, req);
return true;
}
static void wb_trans_retry_wait_done(struct async_req *subreq)
static void wb_trans_retry_wait_done(struct tevent_req *subreq)
{
struct async_req *req = talloc_get_type_abort(
subreq->async.priv, struct async_req);
struct wb_trans_state *state = talloc_get_type_abort(
req->private_data, struct wb_trans_state);
struct tevent_req *subreq2;
struct tevent_req *req = tevent_req_callback_data(
subreq, struct tevent_req);
struct wb_trans_state *state = tevent_req_data(
req, struct wb_trans_state);
bool ret;
ret = async_wait_recv(subreq);
ret = tevent_wakeup_recv(subreq);
TALLOC_FREE(subreq);
if (ret) {
async_req_error(req, WBC_ERR_UNKNOWN_FAILURE);
if (!ret) {
tevent_req_error(req, WBC_ERR_UNKNOWN_FAILURE);
return;
}
subreq2 = wb_open_pipe_send(state, state->ev, state->wb_ctx,
state->need_priv);
if (async_req_nomem(subreq2, req)) {
subreq = wb_open_pipe_send(state, state->ev, state->wb_ctx,
state->need_priv);
if (tevent_req_nomem(subreq, req)) {
return;
}
tevent_req_set_callback(subreq2, wb_trans_connect_done, req);
tevent_req_set_callback(subreq, wb_trans_connect_done, req);
}
static void wb_trans_connect_done(struct tevent_req *subreq)
{
struct async_req *req = tevent_req_callback_data(
subreq, struct async_req);
struct wb_trans_state *state = talloc_get_type_abort(
req->private_data, struct wb_trans_state);
struct tevent_req *subreq2;
struct tevent_req *req = tevent_req_callback_data(
subreq, struct tevent_req);
struct wb_trans_state *state = tevent_req_data(
req, struct wb_trans_state);
wbcErr wbc_err;
wbc_err = wb_open_pipe_recv(subreq);
@ -684,20 +673,20 @@ static void wb_trans_connect_done(struct tevent_req *subreq)
return;
}
subreq2 = wb_int_trans_send(state, state->ev, NULL, state->wb_ctx->fd,
state->wb_req);
if (async_req_nomem(subreq2, req)) {
subreq = wb_int_trans_send(state, state->ev, NULL, state->wb_ctx->fd,
state->wb_req);
if (tevent_req_nomem(subreq, req)) {
return;
}
tevent_req_set_callback(subreq2, wb_trans_done, req);
tevent_req_set_callback(subreq, wb_trans_done, req);
}
static void wb_trans_done(struct tevent_req *subreq)
{
struct async_req *req = tevent_req_callback_data(
subreq, struct async_req);
struct wb_trans_state *state = talloc_get_type_abort(
req->private_data, struct wb_trans_state);
struct tevent_req *req = tevent_req_callback_data(
subreq, struct tevent_req);
struct wb_trans_state *state = tevent_req_data(
req, struct wb_trans_state);
wbcErr wbc_err;
wbc_err = wb_int_trans_recv(subreq, state, &state->wb_resp);
@ -707,17 +696,17 @@ static void wb_trans_done(struct tevent_req *subreq)
return;
}
async_req_done(req);
tevent_req_done(req);
}
wbcErr wb_trans_recv(struct async_req *req, TALLOC_CTX *mem_ctx,
wbcErr wb_trans_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
struct winbindd_response **presponse)
{
struct wb_trans_state *state = talloc_get_type_abort(
req->private_data, struct wb_trans_state);
struct wb_trans_state *state = tevent_req_data(
req, struct wb_trans_state);
wbcErr wbc_err;
if (async_req_is_wbcerr(req, &wbc_err)) {
if (tevent_req_is_wbcerr(req, &wbc_err)) {
return wbc_err;
}

2
source3/libaddns/dns.h
View File

@ -133,7 +133,9 @@ void *talloc_zeronull(const void *context, size_t size, const char *name);
#define TALLOC_REALLOC(ctx, ptr, count) _talloc_realloc(ctx, ptr, count, __location__)
#define TALLOC_REALLOC_ARRAY(ctx, ptr, type, count) (type *)_talloc_realloc_array(ctx, ptr, sizeof(type), count, #type)
#define talloc_destroy(ctx) talloc_free(ctx)
#ifndef TALLOC_FREE
#define TALLOC_FREE(ctx) do { talloc_free(ctx); ctx=NULL; } while(0)
#endif
/*******************************************************************
Type definitions for int16, int32, uint16 and uint32. Needed

59
source3/libsmb/cliconnect.c
View File

@ -1785,15 +1785,20 @@ bool cli_session_request(struct cli_state *cli,
return(True);
}
static void smb_sock_connected(struct async_req *req)
struct fd_struct {
int fd;
};
static void smb_sock_connected(struct tevent_req *req)
{
int *pfd = (int *)req->async.priv;
struct fd_struct *pfd = tevent_req_callback_data(
req, struct fd_struct);
int fd;
NTSTATUS status;
status = open_socket_out_defer_recv(req, &fd);
if (NT_STATUS_IS_OK(status)) {
*pfd = fd;
pfd->fd = fd;
}
}
@ -1801,10 +1806,9 @@ static NTSTATUS open_smb_socket(const struct sockaddr_storage *pss,
uint16_t *port, int timeout, int *pfd)
{
struct event_context *ev;
struct async_req *r139, *r445;
int fd139 = -1;
int fd445 = -1;
NTSTATUS status;
struct tevent_req *r139, *r445;
struct fd_struct *fd139, *fd445;
NTSTATUS status = NT_STATUS_NO_MEMORY;
if (*port != 0) {
return open_socket_out(pss, *port, timeout, pfd);
@ -1815,43 +1819,54 @@ static NTSTATUS open_smb_socket(const struct sockaddr_storage *pss,
return NT_STATUS_NO_MEMORY;
}
fd139 = talloc(ev, struct fd_struct);
if (fd139 == NULL) {
goto done;
}
fd139->fd = -1;
fd445 = talloc(ev, struct fd_struct);
if (fd445 == NULL) {
goto done;
}
fd445->fd = -1;
r445 = open_socket_out_defer_send(ev, ev, timeval_set(0, 0),
pss, 445, timeout);
r139 = open_socket_out_defer_send(ev, ev, timeval_set(0, 3000),
pss, 139, timeout);
if ((r445 == NULL) || (r139 == NULL)) {
status = NT_STATUS_NO_MEMORY;
goto done;
}
r445->async.fn = smb_sock_connected;
r445->async.priv = &fd445;
r139->async.fn = smb_sock_connected;
r139->async.priv = &fd139;
tevent_req_set_callback(r445, smb_sock_connected, fd445);
tevent_req_set_callback(r139, smb_sock_connected, fd139);
while ((fd139 == -1) && (r139->state < ASYNC_REQ_DONE)
&& (fd445 == -1) && (r445->state < ASYNC_REQ_DONE)) {
while ((fd139->fd == -1)
&& tevent_req_is_in_progress(r139)
&& (fd445->fd == -1)
&& tevent_req_is_in_progress(r445)) {
event_loop_once(ev);
}
if ((fd139 != -1) && (fd445 != -1)) {
close(fd139);
fd139 = -1;
if ((fd139->fd != -1) && (fd445->fd != -1)) {
close(fd139->fd);
fd139->fd = -1;
}
if (fd445 != -1) {
if (fd445->fd != -1) {
*port = 445;
*pfd = fd445;
*pfd = fd445->fd;
status = NT_STATUS_OK;
goto done;
}
if (fd139 != -1) {
if (fd139->fd != -1) {
*port = 139;
*pfd = fd139;
*pfd = fd139->fd;
status = NT_STATUS_OK;
goto done;
}
status = open_socket_out_defer_recv(r445, &fd445);
status = open_socket_out_defer_recv(r445, &fd445->fd);
done:
TALLOC_FREE(ev);
return status;

9
source3/torture/torture.c
View File

@ -5613,11 +5613,11 @@ static bool run_local_memcache(int dummy)
return ret;
}
static void wbclient_done(struct async_req *req)
static void wbclient_done(struct tevent_req *req)
{
wbcErr wbc_err;
struct winbindd_response *wb_resp;
int *i = (int *)req->async.priv;
int *i = (int *)tevent_req_callback_data_void(req);
wbc_err = wb_trans_recv(req, req, &wb_resp);
TALLOC_FREE(req);
@ -5654,14 +5654,13 @@ static bool run_local_wbclient(int dummy)
goto fail;
}
for (j=0; j<5; j++) {
struct async_req *req;
struct tevent_req *req;
req = wb_trans_send(ev, ev, wb_ctx[i],
(j % 2) == 0, &wb_req);
if (req == NULL) {
goto fail;
}
req->async.fn = wbclient_done;
req->async.priv = &i;
tevent_req_set_callback(req, wbclient_done, &i);
}
}