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; 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 {
struct async_queue_entry *prev, *next; struct async_queue_entry *prev, *next;
struct async_req_queue *queue; 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, bool async_req_is_error(struct async_req *req, enum async_req_state *state,
uint64_t *error); 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;
struct async_req_queue *async_req_queue_init(TALLOC_CTX *mem_ctx); 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 dnl test for getifaddrs and freeifaddrs
AC_CACHE_CHECK([for getifaddrs and freeifaddrs],libreplace_cv_HAVE_GETIFADDRS,[ AC_CACHE_CHECK([for getifaddrs and freeifaddrs],libreplace_cv_HAVE_GETIFADDRS,[
AC_TRY_COMPILE([ AC_TRY_LINK([
#include <sys/types.h> #include <sys/types.h>
#if STDC_HEADERS #if STDC_HEADERS
#include <stdlib.h> #include <stdlib.h>

2
lib/talloc/configure.ac
View File

@ -1,5 +1,5 @@
AC_PREREQ(2.50) AC_PREREQ(2.50)
AC_INIT(talloc, 1.2.1) AC_INIT(talloc, 1.3.0)
AC_CONFIG_SRCDIR([talloc.c]) AC_CONFIG_SRCDIR([talloc.c])
AC_SUBST(datarootdir) AC_SUBST(datarootdir)
AC_CONFIG_HEADER(config.h) 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(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_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_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(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__) #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)) #define talloc_append_string(c, s, a) (s?talloc_strdup_append(s,a):talloc_strdup(c, a))
#endif #endif
#define TALLOC_FREE(ctx) do { talloc_free(ctx); ctx=NULL; } while(0)
/* The following definitions come from talloc.c */ /* The following definitions come from talloc.c */
void *_talloc(const void *context, size_t size); void *_talloc(const void *context, size_t size);
void *talloc_pool(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; uint32_t ctrl;
}; };
#ifndef TALLOC_FREE
#define TALLOC_FREE(ctx) do { talloc_free(ctx); ctx=NULL; } while(0) #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_ZERO_P(ctx, type) (type *)_talloc_zero(ctx, sizeof(type), #type)
#define TALLOC_P(ctx, type) (type *)talloc_named_const(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 then
PKG_CHECK_MODULES(TALLOC, talloc >= 1.3.0, PKG_CHECK_MODULES(TALLOC, talloc >= 1.3.0,
[ enable_external_libtalloc=yes ], [ 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]) AC_MSG_ERROR([Unable to find libtalloc])
else else
enable_external_libtalloc=no 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 set_netbios_aliases(const char **str_array);
bool init_names(void); bool init_names(void);
struct user_auth_info *user_auth_info_init(TALLOC_CTX *mem_ctx); 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, void set_cmdline_auth_info_username(struct user_auth_info *auth_info,
const char *username); const char *username);
void set_cmdline_auth_info_password(struct user_auth_info *auth_info, void set_cmdline_auth_info_password(struct user_auth_info *auth_info,
const char *password); 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, bool set_cmdline_auth_info_signing_state(struct user_auth_info *auth_info,
const char *arg); 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, void set_cmdline_auth_info_use_kerberos(struct user_auth_info *auth_info,
bool b); 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_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_smb_encrypt(struct user_auth_info *auth_info);
void set_cmdline_auth_info_use_machine_account(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_got_pass(const struct user_auth_info *auth_info);
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);
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);
struct user_auth_info *get_cmdline_auth_info_copy(TALLOC_CTX *mem_ctx, 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 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, bool add_gid_to_array_unique(TALLOC_CTX *mem_ctx, gid_t gid,
gid_t **gids, size_t *num_gids); 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, uint16_t port,
int timeout); int timeout);
NTSTATUS open_socket_out_recv(struct tevent_req *req, int *pfd); NTSTATUS open_socket_out_recv(struct tevent_req *req, int *pfd);
struct async_req *open_socket_out_defer_send(TALLOC_CTX *mem_ctx, struct tevent_req *open_socket_out_defer_send(TALLOC_CTX *mem_ctx,
struct event_context *ev, struct event_context *ev,
struct timeval wait_time, struct timeval wait_time,
const struct sockaddr_storage *pss, const struct sockaddr_storage *pss,
uint16_t port, uint16_t port,
int timeout); int timeout);
NTSTATUS open_socket_out_defer_recv(struct async_req *req, int *pfd); NTSTATUS open_socket_out_defer_recv(struct tevent_req *req, int *pfd);
bool open_any_socket_out(struct sockaddr_storage *addrs, int num_addrs, bool open_any_socket_out(struct sockaddr_storage *addrs, int num_addrs,
int timeout, int *fd_index, int *fd); int timeout, int *fd_index, int *fd);
int open_udp_socket(const char *host, int port); 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(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_REALLOC_ARRAY(ctx, ptr, type, count) (type *)_talloc_realloc_array(ctx, ptr, sizeof(type), count, #type)
#define talloc_destroy(ctx) talloc_free(ctx) #define talloc_destroy(ctx) talloc_free(ctx)
#ifndef TALLOC_FREE
#define TALLOC_FREE(ctx) do { talloc_free(ctx); ctx=NULL; } while(0) #define TALLOC_FREE(ctx) do { talloc_free(ctx); ctx=NULL; } while(0)
#endif
/* only define PARANOID_MALLOC_CHECKER with --enable-developer */ /* 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" #include "nsswitch/libwbclient/wbclient.h"
struct wb_context { struct wb_context;
struct async_req_queue *queue;
int fd;
bool is_priv;
};
struct async_req *wb_trans_send(TALLOC_CTX *mem_ctx, struct tevent_context *ev, struct tevent_req *wb_trans_send(TALLOC_CTX *mem_ctx,
struct wb_context *wb_ctx, bool need_priv, struct tevent_context *ev,
struct winbindd_request *wb_req); struct wb_context *wb_ctx, bool need_priv,
wbcErr wb_trans_recv(struct async_req *req, TALLOC_CTX *mem_ctx, struct winbindd_request *wb_req);
wbcErr wb_trans_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
struct winbindd_response **presponse); struct winbindd_response **presponse);
struct wb_context *wb_context_init(TALLOC_CTX *mem_ctx); struct wb_context *wb_context_init(TALLOC_CTX *mem_ctx);
/* Definitions from wb_reqtrans.c */ /* 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 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); bool tevent_req_is_wbcerr(struct tevent_req *req, wbcErr *pwbc_err);
wbcErr tevent_req_simple_recv_wbcerr(struct tevent_req *req); 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; 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) { if (!auth_info->username) {
return ""; 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) { if (!auth_info->password) {
return ""; return "";
@ -346,7 +346,7 @@ bool set_cmdline_auth_info_signing_state(struct user_auth_info *auth_info,
return true; 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; 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; 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; 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; 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; 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; 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; return auth_info->use_machine_account;
} }
struct user_auth_info *get_cmdline_auth_info_copy(TALLOC_CTX *mem_ctx, 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; 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; 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); static void open_socket_out_defer_connected(struct tevent_req *subreq);
struct async_req *open_socket_out_defer_send(TALLOC_CTX *mem_ctx, struct tevent_req *open_socket_out_defer_send(TALLOC_CTX *mem_ctx,
struct event_context *ev, struct event_context *ev,
struct timeval wait_time, struct timeval wait_time,
const struct sockaddr_storage *pss, const struct sockaddr_storage *pss,
uint16_t port, uint16_t port,
int timeout) int timeout)
{ {
struct async_req *result, *subreq; struct tevent_req *req, *subreq;
struct open_socket_out_defer_state *state; struct open_socket_out_defer_state *state;
NTSTATUS status;
if (!async_req_setup(mem_ctx, &result, &state, req = tevent_req_create(mem_ctx, &state,
struct open_socket_out_defer_state)) { struct open_socket_out_defer_state);
if (req == NULL) {
return NULL; return NULL;
} }
state->ev = ev; state->ev = ev;
@ -1175,73 +1175,66 @@ struct async_req *open_socket_out_defer_send(TALLOC_CTX *mem_ctx,
state->port = port; state->port = port;
state->timeout = timeout; 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) { 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; goto fail;
} }
return result; tevent_req_set_callback(subreq, open_socket_out_defer_waited, req);
return req;
fail: fail:
TALLOC_FREE(result); TALLOC_FREE(req);
return NULL; 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( struct tevent_req *req = tevent_req_callback_data(
subreq->async.priv, struct async_req); subreq, struct tevent_req);
struct open_socket_out_defer_state *state = talloc_get_type_abort( struct open_socket_out_defer_state *state = tevent_req_data(
req->private_data, struct open_socket_out_defer_state); req, struct open_socket_out_defer_state);
struct tevent_req *subreq2;
bool ret; bool ret;
ret = async_wait_recv(subreq); ret = tevent_wakeup_recv(subreq);
TALLOC_FREE(subreq); TALLOC_FREE(subreq);
if (!ret) { if (!ret) {
async_req_nterror(req, NT_STATUS_INTERNAL_ERROR); tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
return; return;
} }
subreq2 = open_socket_out_send(state, state->ev, &state->ss, subreq = open_socket_out_send(state, state->ev, &state->ss,
state->port, state->timeout); state->port, state->timeout);
if (async_req_nomem(subreq2, req)) { if (tevent_req_nomem(subreq, req)) {
return; 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) static void open_socket_out_defer_connected(struct tevent_req *subreq)
{ {
struct async_req *req = struct tevent_req *req = tevent_req_callback_data(
tevent_req_callback_data(subreq, struct async_req); subreq, struct tevent_req);
struct open_socket_out_defer_state *state = talloc_get_type_abort( struct open_socket_out_defer_state *state = tevent_req_data(
req->private_data, struct open_socket_out_defer_state); req, struct open_socket_out_defer_state);
NTSTATUS status; NTSTATUS status;
status = open_socket_out_recv(subreq, &state->fd); status = open_socket_out_recv(subreq, &state->fd);
TALLOC_FREE(subreq); TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) { if (!NT_STATUS_IS_OK(status)) {
async_req_nterror(req, status); tevent_req_nterror(req, status);
return; 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( struct open_socket_out_defer_state *state = tevent_req_data(
req->private_data, struct open_socket_out_defer_state); req, struct open_socket_out_defer_state);
NTSTATUS status; NTSTATUS status;
if (async_req_is_nterror(req, &status)) { if (tevent_req_is_nterror(req, &status)) {
return status; return status;
} }
*pfd = state->fd; *pfd = state->fd;

37
source3/lib/wb_reqtrans.c
View File

@ -25,32 +25,6 @@
#undef DBGC_CLASS #undef DBGC_CLASS
#define DBGC_CLASS DBGC_WINBIND #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) wbcErr map_wbc_err_from_errno(int error)
{ {
switch(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) bool tevent_req_is_wbcerr(struct tevent_req *req, wbcErr *pwbc_err)
{ {
enum tevent_req_state state; enum tevent_req_state state;

145
source3/lib/wbclient.c
View File

@ -20,6 +20,12 @@
#include "includes.h" #include "includes.h"
#include "wbc_async.h" #include "wbc_async.h"
struct wb_context {
struct tevent_queue *queue;
int fd;
bool is_priv;
};
static int make_nonstd_fd(int fd) static int make_nonstd_fd(int fd)
{ {
int i; int i;
@ -138,7 +144,7 @@ struct wb_context *wb_context_init(TALLOC_CTX *mem_ctx)
if (result == NULL) { if (result == NULL) {
return NULL; return NULL;
} }
result->queue = async_req_queue_init(result); result->queue = tevent_queue_create(result, "wb_trans");
if (result->queue == NULL) { if (result->queue == NULL) {
TALLOC_FREE(result); TALLOC_FREE(result);
return NULL; return NULL;
@ -545,43 +551,18 @@ struct wb_trans_state {
static void wb_trans_connect_done(struct tevent_req *subreq); static void wb_trans_connect_done(struct tevent_req *subreq);
static void wb_trans_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( struct tevent_req *req, *subreq;
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 wb_trans_state *state; struct wb_trans_state *state;
if (!async_req_setup(mem_ctx, &result, &state, req = tevent_req_create(mem_ctx, &state, struct wb_trans_state);
struct wb_trans_state)) { if (req == NULL) {
return NULL; return NULL;
} }
state->wb_ctx = wb_ctx; 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->num_retries = 10;
state->need_priv = need_priv; 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; goto fail;
} }
return result; tevent_req_set_callback(subreq, wb_trans_done, req);
return req;
fail: fail:
TALLOC_FREE(result); TALLOC_FREE(req);
return NULL; 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, struct wb_trans_state *state,
wbcErr wbc_err) wbcErr wbc_err)
{ {
struct async_req *subreq; struct tevent_req *subreq;
if (WBC_ERROR_IS_OK(wbc_err)) { if (WBC_ERROR_IS_OK(wbc_err)) {
return false; 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 * Winbind not around or we can't connect to the pipe. Fail
* immediately. * immediately.
*/ */
async_req_error(req, wbc_err); tevent_req_error(req, wbc_err);
return true; return true;
} }
state->num_retries -= 1; state->num_retries -= 1;
if (state->num_retries == 0) { if (state->num_retries == 0) {
async_req_error(req, wbc_err); tevent_req_error(req, wbc_err);
return true; return true;
} }
@ -634,47 +626,44 @@ static bool wb_trans_retry(struct async_req *req,
state->wb_ctx->fd = -1; state->wb_ctx->fd = -1;
} }
subreq = async_wait_send(state, state->ev, timeval_set(1, 0)); subreq = tevent_wakeup_send(state, state->ev,
if (async_req_nomem(subreq, req)) { timeval_current_ofs(1, 0));
if (tevent_req_nomem(subreq, req)) {
return true; return true;
} }
tevent_req_set_callback(subreq, wb_trans_retry_wait_done, req);
subreq->async.fn = wb_trans_retry_wait_done;
subreq->async.priv = req;
return true; 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( struct tevent_req *req = tevent_req_callback_data(
subreq->async.priv, struct async_req); subreq, struct tevent_req);
struct wb_trans_state *state = talloc_get_type_abort( struct wb_trans_state *state = tevent_req_data(
req->private_data, struct wb_trans_state); req, struct wb_trans_state);
struct tevent_req *subreq2;
bool ret; bool ret;
ret = async_wait_recv(subreq); ret = tevent_wakeup_recv(subreq);
TALLOC_FREE(subreq); TALLOC_FREE(subreq);
if (ret) { if (!ret) {
async_req_error(req, WBC_ERR_UNKNOWN_FAILURE); tevent_req_error(req, WBC_ERR_UNKNOWN_FAILURE);
return; return;
} }
subreq2 = wb_open_pipe_send(state, state->ev, state->wb_ctx, subreq = wb_open_pipe_send(state, state->ev, state->wb_ctx,
state->need_priv); state->need_priv);
if (async_req_nomem(subreq2, req)) { if (tevent_req_nomem(subreq, req)) {
return; 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) static void wb_trans_connect_done(struct tevent_req *subreq)
{ {
struct async_req *req = tevent_req_callback_data( struct tevent_req *req = tevent_req_callback_data(
subreq, struct async_req); subreq, struct tevent_req);
struct wb_trans_state *state = talloc_get_type_abort( struct wb_trans_state *state = tevent_req_data(
req->private_data, struct wb_trans_state); req, struct wb_trans_state);
struct tevent_req *subreq2;
wbcErr wbc_err; wbcErr wbc_err;
wbc_err = wb_open_pipe_recv(subreq); wbc_err = wb_open_pipe_recv(subreq);
@ -684,20 +673,20 @@ static void wb_trans_connect_done(struct tevent_req *subreq)
return; return;
} }
subreq2 = wb_int_trans_send(state, state->ev, NULL, state->wb_ctx->fd, subreq = wb_int_trans_send(state, state->ev, NULL, state->wb_ctx->fd,
state->wb_req); state->wb_req);
if (async_req_nomem(subreq2, req)) { if (tevent_req_nomem(subreq, req)) {
return; 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) static void wb_trans_done(struct tevent_req *subreq)
{ {
struct async_req *req = tevent_req_callback_data( struct tevent_req *req = tevent_req_callback_data(
subreq, struct async_req); subreq, struct tevent_req);
struct wb_trans_state *state = talloc_get_type_abort( struct wb_trans_state *state = tevent_req_data(
req->private_data, struct wb_trans_state); req, struct wb_trans_state);
wbcErr wbc_err; wbcErr wbc_err;
wbc_err = wb_int_trans_recv(subreq, state, &state->wb_resp); 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; 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 winbindd_response **presponse)
{ {
struct wb_trans_state *state = talloc_get_type_abort( struct wb_trans_state *state = tevent_req_data(
req->private_data, struct wb_trans_state); req, struct wb_trans_state);
wbcErr wbc_err; wbcErr wbc_err;
if (async_req_is_wbcerr(req, &wbc_err)) { if (tevent_req_is_wbcerr(req, &wbc_err)) {
return 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(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_REALLOC_ARRAY(ctx, ptr, type, count) (type *)_talloc_realloc_array(ctx, ptr, sizeof(type), count, #type)
#define talloc_destroy(ctx) talloc_free(ctx) #define talloc_destroy(ctx) talloc_free(ctx)
#ifndef TALLOC_FREE
#define TALLOC_FREE(ctx) do { talloc_free(ctx); ctx=NULL; } while(0) #define TALLOC_FREE(ctx) do { talloc_free(ctx); ctx=NULL; } while(0)
#endif
/******************************************************************* /*******************************************************************
Type definitions for int16, int32, uint16 and uint32. Needed 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); 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; int fd;
NTSTATUS status; NTSTATUS status;
status = open_socket_out_defer_recv(req, &fd); status = open_socket_out_defer_recv(req, &fd);
if (NT_STATUS_IS_OK(status)) { 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) uint16_t *port, int timeout, int *pfd)
{ {
struct event_context *ev; struct event_context *ev;
struct async_req *r139, *r445; struct tevent_req *r139, *r445;
int fd139 = -1; struct fd_struct *fd139, *fd445;
int fd445 = -1; NTSTATUS status = NT_STATUS_NO_MEMORY;
NTSTATUS status;
if (*port != 0) { if (*port != 0) {
return open_socket_out(pss, *port, timeout, pfd); 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; 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), r445 = open_socket_out_defer_send(ev, ev, timeval_set(0, 0),
pss, 445, timeout); pss, 445, timeout);
r139 = open_socket_out_defer_send(ev, ev, timeval_set(0, 3000), r139 = open_socket_out_defer_send(ev, ev, timeval_set(0, 3000),
pss, 139, timeout); pss, 139, timeout);
if ((r445 == NULL) || (r139 == NULL)) { if ((r445 == NULL) || (r139 == NULL)) {
status = NT_STATUS_NO_MEMORY;
goto done; goto done;
} }
r445->async.fn = smb_sock_connected; tevent_req_set_callback(r445, smb_sock_connected, fd445);
r445->async.priv = &fd445; tevent_req_set_callback(r139, smb_sock_connected, fd139);
r139->async.fn = smb_sock_connected;
r139->async.priv = &fd139;
while ((fd139 == -1) && (r139->state < ASYNC_REQ_DONE) while ((fd139->fd == -1)
&& (fd445 == -1) && (r445->state < ASYNC_REQ_DONE)) { && tevent_req_is_in_progress(r139)
&& (fd445->fd == -1)
&& tevent_req_is_in_progress(r445)) {
event_loop_once(ev); event_loop_once(ev);
} }
if ((fd139 != -1) && (fd445 != -1)) { if ((fd139->fd != -1) && (fd445->fd != -1)) {
close(fd139); close(fd139->fd);
fd139 = -1; fd139->fd = -1;
} }
if (fd445 != -1) { if (fd445->fd != -1) {
*port = 445; *port = 445;
*pfd = fd445; *pfd = fd445->fd;
status = NT_STATUS_OK; status = NT_STATUS_OK;
goto done; goto done;
} }
if (fd139 != -1) { if (fd139->fd != -1) {
*port = 139; *port = 139;
*pfd = fd139; *pfd = fd139->fd;
status = NT_STATUS_OK; status = NT_STATUS_OK;
goto done; goto done;
} }
status = open_socket_out_defer_recv(r445, &fd445); status = open_socket_out_defer_recv(r445, &fd445->fd);
done: done:
TALLOC_FREE(ev); TALLOC_FREE(ev);
return status; return status;

9
source3/torture/torture.c
View File

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