size_t total_size;
};
+static void writev_trigger(struct tevent_req *req, void *private_data);
static void writev_handler(struct tevent_context *ev, struct tevent_fd *fde,
uint16_t flags, void *private_data);
struct tevent_req *writev_send(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
- int fd, struct iovec *iov, int count)
+ struct tevent_queue *queue, int fd,
+ struct iovec *iov, int count)
{
struct tevent_req *result;
struct writev_state *state;
goto fail;
}
+ /*
+ * This if () should go away once our callers are converted to always
+ * pass in a queue.
+ */
+
+ if (queue != NULL) {
+ if (!tevent_queue_add(queue, ev, result, writev_trigger,
+ NULL)) {
+ goto fail;
+ }
+ return result;
+ }
+
fde = tevent_add_fd(ev, state, fd, TEVENT_FD_WRITE, writev_handler,
result);
if (fde == NULL) {
goto fail;
}
return result;
-
fail:
TALLOC_FREE(result);
return NULL;
}
+static void writev_trigger(struct tevent_req *req, void *private_data)
+{
+ struct writev_state *state = tevent_req_data(req, struct writev_state);
+ struct tevent_fd *fde;
+
+ fde = tevent_add_fd(state->ev, state, state->fd, TEVENT_FD_WRITE,
+ writev_handler, req);
+ if (fde == NULL) {
+ tevent_req_error(req, ENOMEM);
+ }
+}
+
static void writev_handler(struct tevent_context *ev, struct tevent_fd *fde,
uint16_t flags, void *private_data)
{
int async_connect_recv(struct tevent_req *req, int *perrno);
struct tevent_req *writev_send(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
- int fd, struct iovec *iov, int count);
+ struct tevent_queue *queue, int fd,
+ struct iovec *iov, int count);
ssize_t writev_recv(struct tevent_req *req, int *perrno);
struct tevent_req *read_packet_send(TALLOC_CTX *mem_ctx,
/*
* FD00::5357:5FXX
*/
-static const struct in6_addr swrap_ipv6 =
-{ { {
-0xFD,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-0x00,0x00,0x00,0x00,0x53,0x57,0x5F,0x00
-} } };
+static const struct in6_addr *swrap_ipv6(void)
+{
+ static struct in6_addr v;
+ static int initialized;
+ int ret;
+
+ if (initialized) {
+ return &v;
+ }
+ initialized = 1;
+
+ ret = inet_pton(AF_INET6, "FD00::5357:5F00", &v);
+ if (ret <= 0) {
+ abort();
+ }
+
+ return &v;
+}
#endif
static struct sockaddr *sockaddr_dup(const void *data, socklen_t len)
int bound;
int bcast;
int is_server;
+ int connected;
char *path;
char *tmp_path;
memset(in2, 0, sizeof(*in2));
in2->sin6_family = AF_INET6;
- in2->sin6_addr = swrap_ipv6;
+ in2->sin6_addr = *swrap_ipv6();
in2->sin6_addr.s6_addr[15] = iface;
in2->sin6_port = htons(prt);
cmp = in->sin6_addr;
cmp.s6_addr[15] = 0;
- if (IN6_ARE_ADDR_EQUAL(&swrap_ipv6, &cmp)) {
+ if (IN6_ARE_ADDR_EQUAL(swrap_ipv6(), &cmp)) {
iface = in->sin6_addr.s6_addr[15];
} else {
errno = ENETUNREACH;
cmp = in->sin6_addr;
cmp.s6_addr[15] = 0;
- if (IN6_ARE_ADDR_EQUAL(&swrap_ipv6, &cmp)) {
+ if (IN6_IS_ADDR_UNSPECIFIED(&in->sin6_addr)) {
+ iface = socket_wrapper_default_iface();
+ } else if (IN6_ARE_ADDR_EQUAL(swrap_ipv6(), &cmp)) {
iface = in->sin6_addr.s6_addr[15];
} else {
errno = EADDRNOTAVAIL;
child_si->protocol = parent_si->protocol;
child_si->bound = 1;
child_si->is_server = 1;
+ child_si->connected = 1;
child_si->peername_len = len;
child_si->peername = sockaddr_dup(my_addr, len);
/* using sendto() or connect() on an unbound socket would give the
recipient no way to reply, as unlike UDP and TCP, a unix domain
socket can't auto-assign emphemeral port numbers, so we need to
- assign it here */
-static int swrap_auto_bind(struct socket_info *si)
+ assign it here.
+ Note: this might change the family from ipv6 to ipv4
+*/
+static int swrap_auto_bind(struct socket_info *si, int family)
{
struct sockaddr_un un_addr;
int i;
un_addr.sun_family = AF_UNIX;
- switch (si->family) {
+ switch (family) {
case AF_INET: {
struct sockaddr_in in;
case AF_INET6: {
struct sockaddr_in6 in6;
+ if (si->family != family) {
+ errno = ENETUNREACH;
+ return -1;
+ }
+
switch (si->type) {
case SOCK_STREAM:
type = SOCKET_TYPE_CHAR_TCP_V6;
memset(&in6, 0, sizeof(in6));
in6.sin6_family = AF_INET6;
- in6.sin6_addr = swrap_ipv6;
+ in6.sin6_addr = *swrap_ipv6();
in6.sin6_addr.s6_addr[15] = socket_wrapper_default_iface();
si->myname_len = sizeof(in6);
si->myname = sockaddr_dup(&in6, si->myname_len);
return -1;
}
+ si->family = family;
set_port(si->family, port, si->myname);
return 0;
}
if (si->bound == 0) {
- ret = swrap_auto_bind(si);
+ ret = swrap_auto_bind(si, serv_addr->sa_family);
if (ret == -1) return -1;
}
if (ret == 0) {
si->peername_len = addrlen;
si->peername = sockaddr_dup(serv_addr, addrlen);
+ si->connected = 1;
+ }
+ if (si->type != SOCK_STREAM) {
+ return ret;
+ }
+
+ if (ret == 0) {
swrap_dump_packet(si, serv_addr, SWRAP_CONNECT_RECV, NULL, 0);
swrap_dump_packet(si, serv_addr, SWRAP_CONNECT_ACK, NULL, 0);
} else {
socklen_t un_addrlen = sizeof(un_addr);
int ret;
struct socket_info *si = find_socket_info(s);
+ struct sockaddr_storage ss;
+ socklen_t ss_len = sizeof(ss);
if (!si) {
return real_recvfrom(s, buf, len, flags, from, fromlen);
}
+ if (!from) {
+ from = (struct sockaddr *)&ss;
+ fromlen = &ss_len;
+ }
+
len = MIN(len, 1500);
/* irix 6.4 forgets to null terminate the sun_path string :-( */
return real_sendto(s, buf, len, flags, to, tolen);
}
+ if (si->connected) {
+ if (to) {
+ errno = EISCONN;
+ return -1;
+ }
+
+ to = si->peername;
+ tolen = si->peername_len;
+ }
+
len = MIN(len, 1500);
switch (si->type) {
break;
case SOCK_DGRAM:
if (si->bound == 0) {
- ret = swrap_auto_bind(si);
+ ret = swrap_auto_bind(si, si->family);
if (ret == -1) return -1;
}
_PUBLIC_ ssize_t iconv_talloc(TALLOC_CTX *ctx,
smb_iconv_t cd,
void const *src, size_t srclen,
- void **dest)
+ void *dst)
{
size_t i_len, o_len, destlen;
+ void **dest = (void **)dst;
size_t retval;
const char *inbuf = (const char *)src;
char *outbuf, *ob;
struct smb_iconv_convenience *ic,
charset_t from, charset_t to,
void const *src, size_t srclen,
- void **dest, size_t *converted_size,
+ void *dst, size_t *converted_size,
bool allow_badcharcnv)
{
+ void **dest = (void **)dst;
smb_iconv_t descriptor;
ssize_t ret;
bool convert_string_talloc(TALLOC_CTX *ctx,
charset_t from, charset_t to,
void const *src, size_t srclen,
- void **dest, size_t *converted_size,
+ void *dest, size_t *converted_size,
bool allow_badcharcnv);
size_t convert_string(charset_t from, charset_t to,
ssize_t iconv_talloc(TALLOC_CTX *mem_ctx,
smb_iconv_t cd,
void const *src, size_t srclen,
- void **dest);
+ void *dest);
extern struct smb_iconv_convenience *global_iconv_convenience;
struct smb_iconv_convenience *ic,
charset_t from, charset_t to,
void const *src, size_t srclen,
- void **dest, size_t *converted_size, bool allow_badcharcnv);
+ void *dest, size_t *converted_size, bool allow_badcharcnv);
/* iconv */
smb_iconv_t smb_iconv_open(const char *tocode, const char *fromcode);
int smb_iconv_close(smb_iconv_t cd);
_PUBLIC_ bool convert_string_talloc(TALLOC_CTX *ctx,
charset_t from, charset_t to,
void const *src, size_t srclen,
- void **dest, size_t *converted_size,
+ void *dest, size_t *converted_size,
bool allow_badcharcnv)
{
return convert_string_talloc_convenience(ctx, get_iconv_convenience(),
%{_mandir}/man1/vfstest.1*
%{_mandir}/man5/smbpasswd.5*
%{_mandir}/man7/samba.7*
+%{_mandir}/man7/winbind_krb5_locator.7*
%{_mandir}/man8/nmbd.8*
%{_mandir}/man8/pdbedit.8*
%{_mandir}/man8/smbd.8*
%{_bindir}/rpcclient
%{_bindir}/smbcacls
+%{_bindir}/sharesec
%{_bindir}/findsmb
%{_bindir}/smbcquotas
%{_bindir}/nmblookup
%{_mandir}/man1/nmblookup.1*
%{_mandir}/man1/rpcclient.1*
%{_mandir}/man1/smbcacls.1*
+%{_mandir}/man1/sharesec.1*
%{_mandir}/man1/smbclient.1*
%{_mandir}/man1/smbtar.1*
%{_mandir}/man1/smbtree.1*
%attr(755,root,root) /%{_libarch}/libnss_winbind.so*
%attr(755,root,root) /%{_libarch}/security/pam_winbind.so
%attr(755,root,root) /%{_libarch}/security/pam_smbpass.so
+/usr/share/locale/de/LC_MESSAGES/pam_winbind.mo
%{_includedir}/libsmbclient.h
%{_libarchdir}/libsmbclient.*
%{_bindir}/ldbdel
%{_bindir}/ldbedit
%{_bindir}/ldbmodify
+%{_bindir}/ldbrename
%{_bindir}/ldbsearch
%{_mandir}/man1/profiles.1*
%{_mandir}/man1/ldbdel.1*
%{_mandir}/man1/ldbedit.1*
%{_mandir}/man1/ldbmodify.1*
+%{_mandir}/man1/ldbrename.1*
%{_mandir}/man1/ldbsearch.1*
%changelog
# information that is created by mkversion in advance.
#
# This is a standalone wrapper for update-pkginfo, which
-# is ususally called from release-scripts/create-tarball.
+# is usually called from release-scripts/create-tarball.
# This allows for testing some aspects of packaging without
# the need to go through all of create-tarball.
#
uint32_t max_rdata_len,
void *priv);
/**
- * Get the result from the read_send operation.
+ * Get the result from the trans_send operation.
*/
NTSTATUS (*trans_recv)(struct async_req *req, TALLOC_CTX *mem_ctx,
uint8_t **prdata, uint32_t *prdata_len);
bool convert_string_allocate(TALLOC_CTX *ctx, charset_t from, charset_t to,
void const *src, size_t srclen, void *dst,
size_t *converted_size, bool allow_bad_conv);
-bool convert_string_talloc(TALLOC_CTX *ctx, charset_t from, charset_t to,
- void const *src, size_t srclen, void **dst,
- size_t *converted_size, bool allow_bad_conv);
size_t unix_strupper(const char *src, size_t srclen, char *dest, size_t destlen);
char *strdup_upper(const char *s);
char *talloc_strdup_upper(TALLOC_CTX *ctx, const char *s);
struct async_req *wb_trans_send(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
struct wb_context *wb_ctx, bool need_priv,
- const struct winbindd_request *wb_req);
+ struct winbindd_request *wb_req);
wbcErr wb_trans_recv(struct async_req *req, TALLOC_CTX *mem_ctx,
struct winbindd_response **presponse);
struct wb_context *wb_context_init(TALLOC_CTX *mem_ctx);
wbcErr map_wbc_err_from_errno(int error);
wbcErr async_req_simple_recv_wbcerr(struct async_req *req);
-struct async_req *wb_req_read_send(TALLOC_CTX *mem_ctx,
- struct tevent_context *ev,
- int fd, size_t max_extra_data);
+bool tevent_req_is_wbcerr(struct tevent_req *req, wbcErr *pwbc_err);
+wbcErr tevent_req_simple_recv_wbcerr(struct tevent_req *req);
-wbcErr wb_req_read_recv(struct async_req *req, TALLOC_CTX *mem_ctx,
+struct tevent_req *wb_req_read_send(TALLOC_CTX *mem_ctx,
+ struct tevent_context *ev,
+ int fd, size_t max_extra_data);
+wbcErr wb_req_read_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
struct winbindd_request **preq);
-struct async_req *wb_req_write_send(TALLOC_CTX *mem_ctx,
- struct tevent_context *ev, int fd,
- struct winbindd_request *wb_req);
+struct tevent_req *wb_req_write_send(TALLOC_CTX *mem_ctx,
+ struct tevent_context *ev,
+ struct tevent_queue *queue, int fd,
+ struct winbindd_request *wb_req);
+wbcErr wb_req_write_recv(struct tevent_req *req);
-wbcErr wb_req_write_recv(struct async_req *req);
-
-struct async_req *wb_resp_read_send(TALLOC_CTX *mem_ctx,
- struct tevent_context *ev, int fd);
-
-wbcErr wb_resp_read_recv(struct async_req *req, TALLOC_CTX *mem_ctx,
+struct tevent_req *wb_resp_read_send(TALLOC_CTX *mem_ctx,
+ struct tevent_context *ev, int fd);
+wbcErr wb_resp_read_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
struct winbindd_response **presp);
-struct async_req *wb_resp_write_send(TALLOC_CTX *mem_ctx,
- struct tevent_context *ev, int fd,
- struct winbindd_response *wb_resp);
-
-wbcErr wb_resp_write_recv(struct async_req *req);
+struct tevent_req *wb_resp_write_send(TALLOC_CTX *mem_ctx,
+ struct tevent_context *ev, int fd,
+ struct winbindd_response *wb_resp);
+wbcErr wb_resp_write_recv(struct tevent_req *req);
#endif /*_WBC_ASYNC_H_*/
* converted.
*/
bool convert_string_talloc(TALLOC_CTX *ctx, charset_t from, charset_t to,
- void const *src, size_t srclen, void **dst,
+ void const *src, size_t srclen, void *dst,
size_t *converted_size, bool allow_bad_conv)
{
void **dest = (void **)dst;
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
-
-/* working out the interfaces for a OS is an incredibly non-portable
- thing. We have several possible implementations below, and autoconf
- tries each of them to see what works
-
- Note that this file does _not_ include includes.h. That is so this code
- can be called directly from the autoconf tests. That also means
- this code cannot use any of the normal Samba debug stuff or defines.
- This is standalone code.
-
-*/
-
-#ifndef AUTOCONF_TEST
-#include "config.h"
-#endif
-
-#include <unistd.h>
-#include <stdio.h>
-#include <sys/types.h>
-#include <netdb.h>
-#include <sys/ioctl.h>
-#include <netdb.h>
-#include <sys/ioctl.h>
-#include <sys/time.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-
-#ifdef HAVE_IFADDRS_H
-#include <ifaddrs.h>
-#endif
-
-#ifdef HAVE_SYS_TIME_H
-#include <sys/time.h>
-#endif
-
-#ifndef SIOCGIFCONF
-#ifdef HAVE_SYS_SOCKIO_H
-#include <sys/sockio.h>
-#endif
-#endif
-
-#ifdef HAVE_STDLIB_H
-#include <stdlib.h>
-#endif
-
-#ifdef HAVE_STRING_H
-#include <string.h>
-#endif
-
-#ifdef HAVE_STRINGS_H
-#include <strings.h>
-#endif
-
-#ifdef __COMPAR_FN_T
-#define QSORT_CAST (__compar_fn_t)
-#endif
-
-#ifndef QSORT_CAST
-#define QSORT_CAST (int (*)(const void *, const void *))
-#endif
-
-#ifdef HAVE_NET_IF_H
-#include <net/if.h>
-#endif
-
-#define SOCKET_WRAPPER_NOT_REPLACE
-#include "interfaces.h"
-#include "../replace/replace.h"
-
-/****************************************************************************
- Utility functions.
-****************************************************************************/
+#include "includes.h"
/****************************************************************************
Create a struct sockaddr_storage with the netmask bits set to 1.
printf("TEST: init\n");
werr = smbconf_init_txt(mem_ctx, &conf_ctx, filename);
if (!W_ERROR_IS_OK(werr)) {
- printf("FAIL: text backend\[ failed: %s\n", win_errstr(werr));
+ printf("FAIL: text backend failed: %s\n", win_errstr(werr));
ret = false;
goto done;
}
#undef DBGC_CLASS
#define DBGC_CLASS DBGC_WINBIND
-struct req_read_state {
- struct winbindd_request *wb_req;
- size_t max_extra_data;
-};
-
bool async_req_is_wbcerr(struct async_req *req, wbcErr *pwbc_err)
{
enum async_req_state state;
return WBC_ERR_SUCCESS;
}
+bool tevent_req_is_wbcerr(struct tevent_req *req, wbcErr *pwbc_err)
+{
+ enum tevent_req_state state;
+ uint64_t error;
+ if (!tevent_req_is_error(req, &state, &error)) {
+ *pwbc_err = WBC_ERR_SUCCESS;
+ return false;
+ }
+
+ switch (state) {
+ case TEVENT_REQ_USER_ERROR:
+ *pwbc_err = error;
+ break;
+ case TEVENT_REQ_TIMED_OUT:
+ *pwbc_err = WBC_ERR_UNKNOWN_FAILURE;
+ break;
+ case TEVENT_REQ_NO_MEMORY:
+ *pwbc_err = WBC_ERR_NO_MEMORY;
+ break;
+ default:
+ *pwbc_err = WBC_ERR_UNKNOWN_FAILURE;
+ break;
+ }
+ return true;
+}
+
+wbcErr tevent_req_simple_recv_wbcerr(struct tevent_req *req)
+{
+ wbcErr wbc_err;
+
+ if (tevent_req_is_wbcerr(req, &wbc_err)) {
+ return wbc_err;
+ }
+
+ return WBC_ERR_SUCCESS;
+}
+
+struct req_read_state {
+ struct winbindd_request *wb_req;
+ size_t max_extra_data;
+};
+
static ssize_t wb_req_more(uint8_t *buf, size_t buflen, void *private_data);
static void wb_req_read_done(struct tevent_req *subreq);
-struct async_req *wb_req_read_send(TALLOC_CTX *mem_ctx,
- struct tevent_context *ev,
- int fd, size_t max_extra_data)
+struct tevent_req *wb_req_read_send(TALLOC_CTX *mem_ctx,
+ struct tevent_context *ev,
+ int fd, size_t max_extra_data)
{
- struct async_req *result;
- struct tevent_req *subreq;
+ struct tevent_req *result, *subreq;
struct req_read_state *state;
- if (!async_req_setup(mem_ctx, &result, &state,
- struct req_read_state)) {
+ result = tevent_req_create(mem_ctx, &state, struct req_read_state);
+ if (result == NULL) {
return NULL;
}
state->max_extra_data = max_extra_data;
static void wb_req_read_done(struct tevent_req *subreq)
{
- struct async_req *req =
- tevent_req_callback_data(subreq, struct async_req);
- struct req_read_state *state = talloc_get_type_abort(
- req->private_data, struct req_read_state);
+ struct tevent_req *req = tevent_req_callback_data(
+ subreq, struct tevent_req);
+ struct req_read_state *state = tevent_req_data(
+ req, struct req_read_state);
int err;
ssize_t ret;
uint8_t *buf;
ret = read_packet_recv(subreq, state, &buf, &err);
TALLOC_FREE(subreq);
if (ret == -1) {
- async_req_error(req, map_wbc_err_from_errno(err));
+ tevent_req_error(req, map_wbc_err_from_errno(err));
return;
}
} else {
state->wb_req->extra_data.data = NULL;
}
- async_req_done(req);
+ tevent_req_done(req);
}
-wbcErr wb_req_read_recv(struct async_req *req, TALLOC_CTX *mem_ctx,
+wbcErr wb_req_read_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
struct winbindd_request **preq)
{
- struct req_read_state *state = talloc_get_type_abort(
- req->private_data, struct req_read_state);
+ struct req_read_state *state = tevent_req_data(
+ req, struct req_read_state);
wbcErr wbc_err;
- if (async_req_is_wbcerr(req, &wbc_err)) {
+ if (tevent_req_is_wbcerr(req, &wbc_err)) {
return wbc_err;
}
*preq = talloc_move(mem_ctx, &state->wb_req);
static void wb_req_write_done(struct tevent_req *subreq);
-struct async_req *wb_req_write_send(TALLOC_CTX *mem_ctx,
- struct tevent_context *ev, int fd,
- struct winbindd_request *wb_req)
+struct tevent_req *wb_req_write_send(TALLOC_CTX *mem_ctx,
+ struct tevent_context *ev,
+ struct tevent_queue *queue, int fd,
+ struct winbindd_request *wb_req)
{
- struct async_req *result;
- struct tevent_req *subreq;
+ struct tevent_req *result, *subreq;
struct req_write_state *state;
int count = 1;
- if (!async_req_setup(mem_ctx, &result, &state,
- struct req_write_state)) {
+ result = tevent_req_create(mem_ctx, &state, struct req_write_state);
+ if (result == NULL) {
return NULL;
}
count = 2;
}
- subreq = writev_send(state, ev, fd, state->iov, count);
+ subreq = writev_send(state, ev, queue, fd, state->iov, count);
if (subreq == NULL) {
goto fail;
}
static void wb_req_write_done(struct tevent_req *subreq)
{
- struct async_req *req =
- tevent_req_callback_data(subreq, struct async_req);
+ struct tevent_req *req = tevent_req_callback_data(
+ subreq, struct tevent_req);
int err;
ssize_t ret;
ret = writev_recv(subreq, &err);
TALLOC_FREE(subreq);
if (ret < 0) {
- async_req_error(req, map_wbc_err_from_errno(err));
+ tevent_req_error(req, map_wbc_err_from_errno(err));
return;
}
- async_req_done(req);
+ tevent_req_done(req);
}
-wbcErr wb_req_write_recv(struct async_req *req)
+wbcErr wb_req_write_recv(struct tevent_req *req)
{
- return async_req_simple_recv_wbcerr(req);
+ return tevent_req_simple_recv_wbcerr(req);
}
struct resp_read_state {
static ssize_t wb_resp_more(uint8_t *buf, size_t buflen, void *private_data);
static void wb_resp_read_done(struct tevent_req *subreq);
-struct async_req *wb_resp_read_send(TALLOC_CTX *mem_ctx,
- struct tevent_context *ev, int fd)
+struct tevent_req *wb_resp_read_send(TALLOC_CTX *mem_ctx,
+ struct tevent_context *ev, int fd)
{
- struct async_req *result;
- struct tevent_req *subreq;
+ struct tevent_req *result, *subreq;
struct resp_read_state *state;
- if (!async_req_setup(mem_ctx, &result, &state,
- struct resp_read_state)) {
+ result = tevent_req_create(mem_ctx, &state, struct resp_read_state);
+ if (result == NULL) {
return NULL;
}
static void wb_resp_read_done(struct tevent_req *subreq)
{
- struct async_req *req =
- tevent_req_callback_data(subreq, struct async_req);
- struct resp_read_state *state = talloc_get_type_abort(
- req->private_data, struct resp_read_state);
+ struct tevent_req *req = tevent_req_callback_data(
+ subreq, struct tevent_req);
+ struct resp_read_state *state = tevent_req_data(
+ req, struct resp_read_state);
uint8_t *buf;
int err;
ssize_t ret;
ret = read_packet_recv(subreq, state, &buf, &err);
TALLOC_FREE(subreq);
if (ret == -1) {
- async_req_error(req, map_wbc_err_from_errno(err));
+ tevent_req_error(req, map_wbc_err_from_errno(err));
return;
}
} else {
state->wb_resp->extra_data.data = NULL;
}
- async_req_done(req);
+ tevent_req_done(req);
}
-wbcErr wb_resp_read_recv(struct async_req *req, TALLOC_CTX *mem_ctx,
+wbcErr wb_resp_read_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
struct winbindd_response **presp)
{
- struct resp_read_state *state = talloc_get_type_abort(
- req->private_data, struct resp_read_state);
+ struct resp_read_state *state = tevent_req_data(
+ req, struct resp_read_state);
wbcErr wbc_err;
- if (async_req_is_wbcerr(req, &wbc_err)) {
+ if (tevent_req_is_wbcerr(req, &wbc_err)) {
return wbc_err;
}
*presp = talloc_move(mem_ctx, &state->wb_resp);
static void wb_resp_write_done(struct tevent_req *subreq);
-struct async_req *wb_resp_write_send(TALLOC_CTX *mem_ctx,
- struct tevent_context *ev, int fd,
- struct winbindd_response *wb_resp)
+struct tevent_req *wb_resp_write_send(TALLOC_CTX *mem_ctx,
+ struct tevent_context *ev, int fd,
+ struct winbindd_response *wb_resp)
{
- struct async_req *result;
- struct tevent_req *subreq;
+ struct tevent_req *result, *subreq;
struct resp_write_state *state;
int count = 1;
- if (!async_req_setup(mem_ctx, &result, &state,
- struct resp_write_state)) {
+ result = tevent_req_create(mem_ctx, &state, struct resp_write_state);
+ if (result == NULL) {
return NULL;
}
count = 2;
}
- subreq = writev_send(state, ev, fd, state->iov, count);
+ subreq = writev_send(state, ev, NULL, fd, state->iov, count);
if (subreq == NULL) {
goto fail;
}
static void wb_resp_write_done(struct tevent_req *subreq)
{
- struct async_req *req =
- tevent_req_callback_data(subreq, struct async_req);
+ struct tevent_req *req = tevent_req_callback_data(
+ subreq, struct tevent_req);
int err;
ssize_t ret;
ret = writev_recv(subreq, &err);
TALLOC_FREE(subreq);
if (ret < 0) {
- async_req_error(req, map_wbc_err_from_errno(err));
+ tevent_req_error(req, map_wbc_err_from_errno(err));
return;
}
- async_req_done(req);
+ tevent_req_done(req);
}
-wbcErr wb_resp_write_recv(struct async_req *req)
+wbcErr wb_resp_write_recv(struct tevent_req *req)
{
- return async_req_simple_recv_wbcerr(req);
+ return tevent_req_simple_recv_wbcerr(req);
}
static void wbc_connect_connected(struct tevent_req *subreq);
-static struct async_req *wb_connect_send(TALLOC_CTX *mem_ctx,
+static struct tevent_req *wb_connect_send(TALLOC_CTX *mem_ctx,
struct tevent_context *ev,
struct wb_context *wb_ctx,
const char *dir)
{
- struct async_req *result;
- struct tevent_req *subreq;
+ struct tevent_req *result, *subreq;
struct wb_connect_state *state;
struct sockaddr_un sunaddr;
struct stat st;
char *path = NULL;
wbcErr wbc_err;
- if (!async_req_setup(mem_ctx, &result, &state,
- struct wb_connect_state)) {
+ result = tevent_req_create(mem_ctx, &state, struct wb_connect_state);
+ if (result == NULL) {
return NULL;
}
return result;
- nomem:
- wbc_err = WBC_ERR_NO_MEMORY;
post_status:
- if (async_post_error(result, ev, wbc_err)) {
- return result;
- }
+ tevent_req_error(result, wbc_err);
+ return tevent_req_post(result, ev);
+ nomem:
TALLOC_FREE(result);
return NULL;
}
static void wbc_connect_connected(struct tevent_req *subreq)
{
- struct async_req *req =
- tevent_req_callback_data(subreq, struct async_req);
+ struct tevent_req *req = tevent_req_callback_data(
+ subreq, struct tevent_req);
int res, err;
res = async_connect_recv(subreq, &err);
TALLOC_FREE(subreq);
if (res == -1) {
- async_req_error(req, map_wbc_err_from_errno(err));
+ tevent_req_error(req, map_wbc_err_from_errno(err));
return;
}
- async_req_done(req);
-}
-
-static wbcErr wb_connect_recv(struct async_req *req)
-{
- return async_req_simple_recv_wbcerr(req);
+ tevent_req_done(req);
}
-static struct winbindd_request *winbindd_request_copy(
- TALLOC_CTX *mem_ctx,
- const struct winbindd_request *req)
+static wbcErr wb_connect_recv(struct tevent_req *req)
{
- struct winbindd_request *result;
-
- result = (struct winbindd_request *)TALLOC_MEMDUP(
- mem_ctx, req, sizeof(struct winbindd_request));
- if (result == NULL) {
- return NULL;
- }
-
- if (result->extra_len == 0) {
- return result;
- }
-
- result->extra_data.data = (char *)TALLOC_MEMDUP(
- result, result->extra_data.data, result->extra_len);
- if (result->extra_data.data == NULL) {
- TALLOC_FREE(result);
- return NULL;
- }
- return result;
+ return tevent_req_simple_recv_wbcerr(req);
}
struct wb_int_trans_state {
struct winbindd_response *wb_resp;
};
-static void wb_int_trans_write_done(struct async_req *subreq);
-static void wb_int_trans_read_done(struct async_req *subreq);
+static void wb_int_trans_write_done(struct tevent_req *subreq);
+static void wb_int_trans_read_done(struct tevent_req *subreq);
-static struct async_req *wb_int_trans_send(TALLOC_CTX *mem_ctx,
- struct tevent_context *ev, int fd,
- struct winbindd_request *wb_req)
+static struct tevent_req *wb_int_trans_send(TALLOC_CTX *mem_ctx,
+ struct tevent_context *ev,
+ struct tevent_queue *queue, int fd,
+ struct winbindd_request *wb_req)
{
- struct async_req *result;
- struct async_req *subreq;
+ struct tevent_req *result, *subreq;
struct wb_int_trans_state *state;
- if (!async_req_setup(mem_ctx, &result, &state,
- struct wb_int_trans_state)) {
+ result = tevent_req_create(mem_ctx, &state,
+ struct wb_int_trans_state);
+ if (result == NULL) {
return NULL;
}
if (winbind_closed_fd(fd)) {
- if (!async_post_error(result, ev,
- WBC_ERR_WINBIND_NOT_AVAILABLE)) {
- goto fail;
- }
- return result;
+ tevent_req_error(result, WBC_ERR_WINBIND_NOT_AVAILABLE);
+ return tevent_req_post(result, ev);
}
state->ev = ev;
state->fd = fd;
state->wb_req = wb_req;
-
state->wb_req->length = sizeof(struct winbindd_request);
state->wb_req->pid = getpid();
- subreq = wb_req_write_send(state, state->ev, state->fd, state->wb_req);
+ subreq = wb_req_write_send(state, state->ev, queue, state->fd,
+ state->wb_req);
if (subreq == NULL) {
goto fail;
}
- subreq->async.fn = wb_int_trans_write_done;
- subreq->async.priv = result;
+ tevent_req_set_callback(subreq, wb_int_trans_write_done, result);
return result;
return NULL;
}
-static void wb_int_trans_write_done(struct async_req *subreq)
+static void wb_int_trans_write_done(struct tevent_req *subreq)
{
- struct async_req *req = talloc_get_type_abort(
- subreq->async.priv, struct async_req);
- struct wb_int_trans_state *state = talloc_get_type_abort(
- req->private_data, struct wb_int_trans_state);
+ struct tevent_req *req = tevent_req_callback_data(
+ subreq, struct tevent_req);
+ struct wb_int_trans_state *state = tevent_req_data(
+ req, struct wb_int_trans_state);
wbcErr wbc_err;
wbc_err = wb_req_write_recv(subreq);
TALLOC_FREE(subreq);
if (!WBC_ERROR_IS_OK(wbc_err)) {
- async_req_error(req, wbc_err);
+ tevent_req_error(req, wbc_err);
return;
}
subreq = wb_resp_read_send(state, state->ev, state->fd);
- if (subreq == NULL) {
- async_req_error(req, WBC_ERR_NO_MEMORY);
+ if (tevent_req_nomem(subreq, req)) {
+ return;
}
- subreq->async.fn = wb_int_trans_read_done;
- subreq->async.priv = req;
+ tevent_req_set_callback(subreq, wb_int_trans_read_done, req);
}
-static void wb_int_trans_read_done(struct async_req *subreq)
+static void wb_int_trans_read_done(struct tevent_req *subreq)
{
- struct async_req *req = talloc_get_type_abort(
- subreq->async.priv, struct async_req);
- struct wb_int_trans_state *state = talloc_get_type_abort(
- req->private_data, struct wb_int_trans_state);
+ struct tevent_req *req = tevent_req_callback_data(
+ subreq, struct tevent_req);
+ struct wb_int_trans_state *state = tevent_req_data(
+ req, struct wb_int_trans_state);
wbcErr wbc_err;
wbc_err = wb_resp_read_recv(subreq, state, &state->wb_resp);
TALLOC_FREE(subreq);
if (!WBC_ERROR_IS_OK(wbc_err)) {
- async_req_error(req, wbc_err);
+ tevent_req_error(req, wbc_err);
return;
}
- async_req_done(req);
+ tevent_req_done(req);
}
-static wbcErr wb_int_trans_recv(struct async_req *req,
+static wbcErr wb_int_trans_recv(struct tevent_req *req,
TALLOC_CTX *mem_ctx,
struct winbindd_response **presponse)
{
- struct wb_int_trans_state *state = talloc_get_type_abort(
- req->private_data, struct wb_int_trans_state);
+ struct wb_int_trans_state *state = tevent_req_data(
+ req, struct wb_int_trans_state);
wbcErr wbc_err;
- if (async_req_is_wbcerr(req, &wbc_err)) {
+ if (tevent_req_is_wbcerr(req, &wbc_err)) {
return wbc_err;
}
struct winbindd_request wb_req;
};
-static void wb_open_pipe_connect_nonpriv_done(struct async_req *subreq);
-static void wb_open_pipe_ping_done(struct async_req *subreq);
-static void wb_open_pipe_getpriv_done(struct async_req *subreq);
-static void wb_open_pipe_connect_priv_done(struct async_req *subreq);
+static void wb_open_pipe_connect_nonpriv_done(struct tevent_req *subreq);
+static void wb_open_pipe_ping_done(struct tevent_req *subreq);
+static void wb_open_pipe_getpriv_done(struct tevent_req *subreq);
+static void wb_open_pipe_connect_priv_done(struct tevent_req *subreq);
-static struct async_req *wb_open_pipe_send(TALLOC_CTX *mem_ctx,
- struct tevent_context *ev,
- struct wb_context *wb_ctx,
- bool need_priv)
+static struct tevent_req *wb_open_pipe_send(TALLOC_CTX *mem_ctx,
+ struct tevent_context *ev,
+ struct wb_context *wb_ctx,
+ bool need_priv)
{
- struct async_req *result;
- struct async_req *subreq;
+ struct tevent_req *result, *subreq;
struct wb_open_pipe_state *state;
- if (!async_req_setup(mem_ctx, &result, &state,
- struct wb_open_pipe_state)) {
+ result = tevent_req_create(mem_ctx, &state, struct wb_open_pipe_state);
+ if (result == NULL) {
return NULL;
}
state->wb_ctx = wb_ctx;
if (subreq == NULL) {
goto fail;
}
-
- subreq->async.fn = wb_open_pipe_connect_nonpriv_done;
- subreq->async.priv = result;
+ tevent_req_set_callback(subreq, wb_open_pipe_connect_nonpriv_done,
+ result);
return result;
fail:
return NULL;
}
-static void wb_open_pipe_connect_nonpriv_done(struct async_req *subreq)
+static void wb_open_pipe_connect_nonpriv_done(struct tevent_req *subreq)
{
- struct async_req *req = talloc_get_type_abort(
- subreq->async.priv, struct async_req);
- struct wb_open_pipe_state *state = talloc_get_type_abort(
- req->private_data, struct wb_open_pipe_state);
+ struct tevent_req *req = tevent_req_callback_data(
+ subreq, struct tevent_req);
+ struct wb_open_pipe_state *state = tevent_req_data(
+ req, struct wb_open_pipe_state);
wbcErr wbc_err;
wbc_err = wb_connect_recv(subreq);
TALLOC_FREE(subreq);
if (!WBC_ERROR_IS_OK(wbc_err)) {
state->wb_ctx->is_priv = true;
- async_req_error(req, wbc_err);
+ tevent_req_error(req, wbc_err);
return;
}
ZERO_STRUCT(state->wb_req);
state->wb_req.cmd = WINBINDD_INTERFACE_VERSION;
- subreq = wb_int_trans_send(state, state->ev, state->wb_ctx->fd,
+ subreq = wb_int_trans_send(state, state->ev, NULL, state->wb_ctx->fd,
&state->wb_req);
- if (async_req_nomem(subreq, req)) {
+ if (tevent_req_nomem(subreq, req)) {
return;
}
-
- subreq->async.fn = wb_open_pipe_ping_done;
- subreq->async.priv = req;
+ tevent_req_set_callback(subreq, wb_open_pipe_ping_done, req);
}
-static void wb_open_pipe_ping_done(struct async_req *subreq)
+static void wb_open_pipe_ping_done(struct tevent_req *subreq)
{
- struct async_req *req = talloc_get_type_abort(
- subreq->async.priv, struct async_req);
- struct wb_open_pipe_state *state = talloc_get_type_abort(
- req->private_data, struct wb_open_pipe_state);
+ struct tevent_req *req = tevent_req_callback_data(
+ subreq, struct tevent_req);
+ struct wb_open_pipe_state *state = tevent_req_data(
+ req, struct wb_open_pipe_state);
struct winbindd_response *wb_resp;
wbcErr wbc_err;
wbc_err = wb_int_trans_recv(subreq, state, &wb_resp);
TALLOC_FREE(subreq);
if (!WBC_ERROR_IS_OK(wbc_err)) {
- async_req_error(req, wbc_err);
+ tevent_req_error(req, wbc_err);
return;
}
if (!state->need_priv) {
- async_req_done(req);
+ tevent_req_done(req);
return;
}
state->wb_req.cmd = WINBINDD_PRIV_PIPE_DIR;
- subreq = wb_int_trans_send(state, state->ev, state->wb_ctx->fd,
+ subreq = wb_int_trans_send(state, state->ev, NULL, state->wb_ctx->fd,
&state->wb_req);
- if (async_req_nomem(subreq, req)) {
+ if (tevent_req_nomem(subreq, req)) {
return;
}
-
- subreq->async.fn = wb_open_pipe_getpriv_done;
- subreq->async.priv = req;
+ tevent_req_set_callback(subreq, wb_open_pipe_getpriv_done, req);
}
-static void wb_open_pipe_getpriv_done(struct async_req *subreq)
+static void wb_open_pipe_getpriv_done(struct tevent_req *subreq)
{
- struct async_req *req = talloc_get_type_abort(
- subreq->async.priv, struct async_req);
- struct wb_open_pipe_state *state = talloc_get_type_abort(
- req->private_data, struct wb_open_pipe_state);
+ struct tevent_req *req = tevent_req_callback_data(
+ subreq, struct tevent_req);
+ struct wb_open_pipe_state *state = tevent_req_data(
+ req, struct wb_open_pipe_state);
struct winbindd_response *wb_resp = NULL;
wbcErr wbc_err;
wbc_err = wb_int_trans_recv(subreq, state, &wb_resp);
TALLOC_FREE(subreq);
if (!WBC_ERROR_IS_OK(wbc_err)) {
- async_req_error(req, wbc_err);
+ tevent_req_error(req, wbc_err);
return;
}
state->wb_ctx->fd = -1;
subreq = wb_connect_send(state, state->ev, state->wb_ctx,
- (char *)wb_resp->extra_data.data);
+ (char *)wb_resp->extra_data.data);
TALLOC_FREE(wb_resp);
- if (async_req_nomem(subreq, req)) {
+ if (tevent_req_nomem(subreq, req)) {
return;
}
-
- subreq->async.fn = wb_open_pipe_connect_priv_done;
- subreq->async.priv = req;
+ tevent_req_set_callback(subreq, wb_open_pipe_connect_priv_done, req);
}
-static void wb_open_pipe_connect_priv_done(struct async_req *subreq)
+static void wb_open_pipe_connect_priv_done(struct tevent_req *subreq)
{
- struct async_req *req = talloc_get_type_abort(
- subreq->async.priv, struct async_req);
- struct wb_open_pipe_state *state = talloc_get_type_abort(
- req->private_data, struct wb_open_pipe_state);
+ struct tevent_req *req = tevent_req_callback_data(
+ subreq, struct tevent_req);
+ struct wb_open_pipe_state *state = tevent_req_data(
+ req, struct wb_open_pipe_state);
wbcErr wbc_err;
wbc_err = wb_connect_recv(subreq);
TALLOC_FREE(subreq);
if (!WBC_ERROR_IS_OK(wbc_err)) {
- async_req_error(req, wbc_err);
+ tevent_req_error(req, wbc_err);
return;
}
state->wb_ctx->is_priv = true;
- async_req_done(req);
+ tevent_req_done(req);
}
-static wbcErr wb_open_pipe_recv(struct async_req *req)
+static wbcErr wb_open_pipe_recv(struct tevent_req *req)
{
- return async_req_simple_recv_wbcerr(req);
+ return tevent_req_simple_recv_wbcerr(req);
}
struct wb_trans_state {
bool need_priv;
};
-static void wb_trans_connect_done(struct async_req *subreq);
-static void wb_trans_done(struct async_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_retry_wait_done(struct async_req *subreq);
static void wb_trigger_trans(struct async_req *req)
{
struct wb_trans_state *state = talloc_get_type_abort(
req->private_data, struct wb_trans_state);
- struct async_req *subreq;
+ struct tevent_req *subreq;
if ((state->wb_ctx->fd == -1)
|| (state->need_priv && !state->wb_ctx->is_priv)) {
if (async_req_nomem(subreq, req)) {
return;
}
- subreq->async.fn = wb_trans_connect_done;
- subreq->async.priv = req;
+ tevent_req_set_callback(subreq, wb_trans_connect_done, req);
return;
}
- subreq = wb_int_trans_send(state, state->ev, state->wb_ctx->fd,
+ subreq = wb_int_trans_send(state, state->ev, NULL, state->wb_ctx->fd,
state->wb_req);
if (async_req_nomem(subreq, req)) {
return;
}
- subreq->async.fn = wb_trans_done;
- subreq->async.priv = req;
+ 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,
- const struct winbindd_request *wb_req)
+ struct winbindd_request *wb_req)
{
struct async_req *result;
struct wb_trans_state *state;
}
state->wb_ctx = wb_ctx;
state->ev = ev;
- state->wb_req = winbindd_request_copy(state, wb_req);
- if (state->wb_req == NULL) {
- goto fail;
- }
+ state->wb_req = wb_req;
state->num_retries = 10;
state->need_priv = need_priv;
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;
bool ret;
ret = async_wait_recv(subreq);
return;
}
- subreq = wb_open_pipe_send(state, state->ev, state->wb_ctx,
- state->need_priv);
- if (async_req_nomem(subreq, req)) {
+ subreq2 = wb_open_pipe_send(state, state->ev, state->wb_ctx,
+ state->need_priv);
+ if (async_req_nomem(subreq2, req)) {
return;
}
- subreq->async.fn = wb_trans_connect_done;
- subreq->async.priv = req;
+ tevent_req_set_callback(subreq2, wb_trans_connect_done, req);
}
-static void wb_trans_connect_done(struct async_req *subreq)
+static void wb_trans_connect_done(struct tevent_req *subreq)
{
- struct async_req *req = talloc_get_type_abort(
- subreq->async.priv, struct async_req);
+ 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;
wbcErr wbc_err;
wbc_err = wb_open_pipe_recv(subreq);
return;
}
- subreq = wb_int_trans_send(state, state->ev, state->wb_ctx->fd,
- state->wb_req);
- if (async_req_nomem(subreq, req)) {
+ subreq2 = wb_int_trans_send(state, state->ev, NULL, state->wb_ctx->fd,
+ state->wb_req);
+ if (async_req_nomem(subreq2, req)) {
return;
}
-
- subreq->async.fn = wb_trans_done;
- subreq->async.priv = req;
+ tevent_req_set_callback(subreq2, wb_trans_done, req);
}
-static void wb_trans_done(struct async_req *subreq)
+static void wb_trans_done(struct tevent_req *subreq)
{
- struct async_req *req = talloc_get_type_abort(
- subreq->async.priv, struct async_req);
+ 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);
wbcErr wbc_err;
req->private_data, struct np_write_state);
struct tevent_req *subreq;
- subreq = writev_send(state, state->ev, state->p->fd, &state->iov, 1);
+ subreq = writev_send(state, state->ev, NULL, state->p->fd,
+ &state->iov, 1);
if (async_req_nomem(subreq, req)) {
return;
}
export SAMBA4SHAREDDIR
export SMBTORTURE4
-if test x"$LD_LIBRARY_PATH" != x""; then
- LD_LIBRARY_PATH="$BINDIR:$SAMBA4SHAREDDIR:$LD_LIBRARY_PATH"
-else
- LD_LIBRARY_PATH="$BINDIR:$SAMBA4SHAREDDIR"
+if [ -z "$LIB_PATH_VAR" ] ; then
+ echo "Warning: LIB_PATH_VAR not set. Using best guess LD_LIBRARY_PATH." >&2
+ LIB_PATH_VAR=LD_LIBRARY_PATH
+ export LIB_PATH_VAR
fi
-echo "LD_LIBRARY_PATH=$LD_LIBRARY_PATH"
-export LD_LIBRARY_PATH
+
+eval $LIB_PATH_VAR=$BINDIR:$SAMBA4SHAREDDIR:\$$LIB_PATH_VAR
+export $LIB_PATH_VAR
##
## verify that we were built with --enable-socket-wrapper
git.samba.org / kai / samba.git / commitdiff