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

Merge branch 'v4-0-test' of ssh://git.samba.org/data/git/samba into 4-0-local

Browse Source 
(This used to be commit 60579269d1)
This commit is contained in:
Andrew Bartlett 2008-05-17 21:16:22 +10:00
commit d975cd9d8c
14 changed files with 359 additions and 133 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
source4/build/smb_build/makefile.pm
View File

@ -238,6 +238,8 @@ sub write($$)
$self->_prepare_mk_files();
$self->output("ALL_OBJS = " . array2oneperline($self->{all_objs}) . "\n");
open(MAKEFILE,">$file") || die ("Can't open $file\n");
print MAKEFILE $self->{output};
close(MAKEFILE);

93
source4/build/tests/unixsock.c
View File

@ -1,93 +0,0 @@
/* -*- c-file-style: "linux" -*-
*
* Try creating a Unix-domain socket, opening it, and reading from it.
* The POSIX name for these is AF_LOCAL/PF_LOCAL.
*
* This is used by the Samba autoconf scripts to detect systems which
* don't have Unix-domain sockets, such as (probably) VMS, or systems
* on which they are broken under some conditions, such as RedHat 7.0
* (unpatched). We can't build WinBind there at the moment.
*
* Coding standard says to always use exit() for this, not return, so
* we do.
*
* Martin Pool <mbp@samba.org>, June 2000. */
/* TODO: Look for AF_LOCAL (most standard), AF_UNIX, and AF_FILE. */
#include <stdio.h>
#ifdef HAVE_SYS_SOCKET_H
# include <sys/socket.h>
#endif
#ifdef HAVE_SYS_UN_H
# include <sys/un.h>
#endif
#ifdef HAVE_SYS_TYPES_H
# include <sys/types.h>
#endif
#if HAVE_SYS_WAIT_H
# include <sys/wait.h>
#endif
#if HAVE_ERRNO_DECL
# include <errno.h>
#else
extern int errno;
#endif
static int bind_socket(char const *filename)
{
int sock_fd;
struct sockaddr_un name;
size_t size;
/* Create the socket. */
if ((sock_fd = socket(PF_LOCAL, SOCK_STREAM, 0)) < 0) {
perror ("socket(PF_LOCAL, SOCK_STREAM)");
exit(1);
}
/* Bind a name to the socket. */
name.sun_family = AF_LOCAL;
strncpy(name.sun_path, filename, sizeof (name.sun_path));
/* The size of the address is
the offset of the start of the filename,
plus its length,
plus one for the terminating null byte.
Alternatively you can just do:
size = SUN_LEN (&name);
*/
size = SUN_LEN(&name);
/* XXX: This probably won't work on unfriendly libcs */
if (bind(sock_fd, (struct sockaddr *) &name, size) < 0) {
perror ("bind");
exit(1);
}
return sock_fd;
}
int main(void)
{
int sock_fd;
int kid;
char const *filename = "conftest.unixsock.sock";
/* abolish hanging */
alarm(15); /* secs */
if ((sock_fd = bind_socket(filename)) < 0)
exit(1);
/* the socket will be deleted when autoconf cleans up these
files. */
exit(0);
}

2
source4/lib/ldb_wrap.c
View File

@ -44,7 +44,7 @@ static void ldb_wrap_debug(void *context, enum ldb_debug_level level,
static void ldb_wrap_debug(void *context, enum ldb_debug_level level,
const char *fmt, va_list ap)
{
int samba_level;
int samba_level = -1;
char *s = NULL;
switch (level) {
case LDB_DEBUG_FATAL:

1
source4/lib/replace/libreplace.m4
View File

@ -96,7 +96,6 @@ fi
AC_CHECK_HEADERS(sys/syslog.h syslog.h)
AC_CHECK_HEADERS(sys/time.h time.h)
AC_CHECK_HEADERS(stdarg.h vararg.h)
AC_CHECK_HEADERS(sys/sockio.h sys/un.h)
AC_CHECK_HEADERS(sys/mount.h mntent.h)
AC_CHECK_HEADERS(stropts.h)

41
source4/lib/replace/libreplace_network.m4
View File

@ -8,6 +8,7 @@ LIBREPLACE_NETWORK_LIBS=""
AC_CHECK_HEADERS(sys/socket.h netinet/in.h netdb.h arpa/inet.h)
AC_CHECK_HEADERS(netinet/ip.h netinet/tcp.h netinet/in_systm.h netinet/in_ip.h)
AC_CHECK_HEADERS(sys/sockio.h sys/un.h)
dnl we need to check that net/if.h really can be used, to cope with hpux
dnl where including it always fails
@ -62,6 +63,46 @@ AC_CHECK_MEMBER(struct sockaddr_storage.__ss_family,
fi
fi
AC_CACHE_CHECK([for sin_len in sock],libreplace_cv_HAVE_SOCK_SIN_LEN,[
AC_TRY_COMPILE(
[
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
],[
struct sockaddr_in sock; sock.sin_len = sizeof(sock);
],[
libreplace_cv_HAVE_SOCK_SIN_LEN=yes
],[
libreplace_cv_HAVE_SOCK_SIN_LEN=no
])
])
if test x"$libreplace_cv_HAVE_SOCK_SIN_LEN" = x"yes"; then
AC_DEFINE(HAVE_SOCK_SIN_LEN,1,[Whether the sockaddr_in struct has a sin_len property])
fi
############################################
# check for unix domain sockets
AC_CACHE_CHECK([for unix domain sockets],libreplace_cv_HAVE_UNIXSOCKET,[
AC_TRY_COMPILE([
#include <sys/types.h>
#include <stdlib.h>
#include <stddef.h>
#include <sys/socket.h>
#include <sys/un.h>
],[
struct sockaddr_un sunaddr;
sunaddr.sun_family = AF_UNIX;
],[
libreplace_cv_HAVE_UNIXSOCKET=yes
],[
libreplace_cv_HAVE_UNIXSOCKET=no
])
])
if test x"$libreplace_cv_HAVE_UNIXSOCKET" = x"yes"; then
AC_DEFINE(HAVE_UNIXSOCKET,1,[If we need to build with unixscoket support])
fi
dnl The following test is roughl taken from the cvs sources.
dnl
dnl If we can't find connect, try looking in -lsocket, -lnsl, and -linet.

38
source4/lib/socket/config.m4
View File

@ -1,44 +1,12 @@
AC_CHECK_FUNCS(writev)
AC_CHECK_FUNCS(readv)
AC_CACHE_CHECK([for sin_len in sock],samba_cv_HAVE_SOCK_SIN_LEN,[
AC_TRY_COMPILE([#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>],
[struct sockaddr_in sock; sock.sin_len = sizeof(sock);],
samba_cv_HAVE_SOCK_SIN_LEN=yes,samba_cv_HAVE_SOCK_SIN_LEN=no)])
if test x"$samba_cv_HAVE_SOCK_SIN_LEN" = x"yes"; then
AC_DEFINE(HAVE_SOCK_SIN_LEN,1,[Whether the sockaddr_in struct has a sin_len property])
fi
############################################
# check for unix domain sockets
AC_CACHE_CHECK([for unix domain sockets],samba_cv_unixsocket, [
AC_TRY_COMPILE([
#include <sys/types.h>
#include <stdlib.h>
#include <stddef.h>
#include <sys/socket.h>
#include <sys/un.h>],
[
struct sockaddr_un sunaddr;
sunaddr.sun_family = AF_UNIX;
],
samba_cv_unixsocket=yes,samba_cv_unixsocket=no)])
# done by AC_LIBREPLACE_NETWORK_CHECKS
SMB_ENABLE(socket_unix, NO)
if test x"$samba_cv_unixsocket" = x"yes"; then
SMB_ENABLE(socket_unix, YES)
AC_DEFINE(HAVE_UNIXSOCKET,1,[If we need to build with unixscoket support])
fi
AC_CACHE_CHECK([for AF_LOCAL socket support], samba_cv_HAVE_WORKING_AF_LOCAL, [
AC_TRY_RUN([#include "${srcdir-.}/build/tests/unixsock.c"],
samba_cv_HAVE_WORKING_AF_LOCAL=yes,
samba_cv_HAVE_WORKING_AF_LOCAL=no,
samba_cv_HAVE_WORKING_AF_LOCAL=cross)])
if test x"$samba_cv_HAVE_WORKING_AF_LOCAL" != xno
then
AC_DEFINE(HAVE_WORKING_AF_LOCAL, 1, [Define if you have working AF_LOCAL sockets])
if test x"$libreplace_cv_HAVE_UNIXSOCKET" = x"yes"; then
SMB_ENABLE(socket_unix, YES)
fi
dnl test for ipv6 using the gethostbyname2() function. That should be sufficient

1
source4/librpc/idl/dcerpc.idl
View File

@ -116,6 +116,7 @@ interface dcerpc
uint16 context_id;
uint8 cancel_count;
uint32 status;
[flag(NDR_REMAINING)] DATA_BLOB _pad;
} dcerpc_fault;
/* the auth types we know about */

12
source4/rpc_server/dcerpc_server.c
View File

@ -445,6 +445,7 @@ static NTSTATUS dcesrv_fault(struct dcesrv_call_state *call, uint32_t fault_code
{
struct ncacn_packet pkt;
struct data_blob_list_item *rep;
uint8_t zeros[4];
NTSTATUS status;
/* setup a bind_ack */
@ -458,6 +459,9 @@ static NTSTATUS dcesrv_fault(struct dcesrv_call_state *call, uint32_t fault_code
pkt.u.fault.cancel_count = 0;
pkt.u.fault.status = fault_code;
ZERO_STRUCT(zeros);
pkt.u.fault._pad = data_blob_const(zeros, sizeof(zeros));
rep = talloc(call, struct data_blob_list_item);
if (!rep) {
return NT_STATUS_NO_MEMORY;
@ -684,6 +688,7 @@ static NTSTATUS dcesrv_alter_new_context(struct dcesrv_call_state *call, uint32_
struct dcesrv_connection_context *context;
const struct dcesrv_interface *iface;
struct GUID uuid, *transfer_syntax_uuid;
NTSTATUS status;
if_version = call->pkt.u.alter.ctx_list[0].abstract_syntax.if_version;
uuid = call->pkt.u.alter.ctx_list[0].abstract_syntax.uuid;
@ -717,6 +722,13 @@ static NTSTATUS dcesrv_alter_new_context(struct dcesrv_call_state *call, uint32_
DLIST_ADD(call->conn->contexts, context);
call->context = context;
if (iface) {
status = iface->bind(call, iface);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
}
return NT_STATUS_OK;
}

2
source4/smbd/service_stream.c
View File

@ -119,6 +119,7 @@ void stream_io_handler_callback(void *private, uint16_t flags)
a server connection
*/
NTSTATUS stream_new_connection_merge(struct event_context *ev,
struct loadparm_context *lp_ctx,
const struct model_ops *model_ops,
struct socket_context *sock,
const struct stream_server_ops *stream_ops,
@ -140,6 +141,7 @@ NTSTATUS stream_new_connection_merge(struct event_context *ev,
srv_conn->ops = stream_ops;
srv_conn->msg_ctx = msg_ctx;
srv_conn->event.ctx = ev;
srv_conn->lp_ctx = lp_ctx;
srv_conn->event.fde = event_add_fd(ev, srv_conn, socket_get_fd(sock),
EVENT_FD_READ,
stream_io_handler_fde, srv_conn);

6
source4/smbd/service_stream.h
View File

@ -50,6 +50,12 @@ struct stream_connection {
struct messaging_context *msg_ctx;
struct loadparm_context *lp_ctx;
/*
* this transport layer session info, normally NULL
* which means the same as an anonymous session info
*/
struct auth_session_info *session_info;
bool processing;
const char *terminate;
};

1
source4/torture/rpc/rpc.c
View File

@ -399,6 +399,7 @@ NTSTATUS torture_rpc_init(void)
torture_suite_add_simple_test(suite, "SAMSYNC", torture_rpc_samsync);
torture_suite_add_simple_test(suite, "SCHANNEL", torture_rpc_schannel);
torture_suite_add_simple_test(suite, "SCHANNEL2", torture_rpc_schannel2);
torture_suite_add_simple_test(suite, "BENCH-SCHANNEL1", torture_rpc_schannel_bench1);
torture_suite_add_suite(suite, torture_rpc_srvsvc(suite));
torture_suite_add_suite(suite, torture_rpc_svcctl(suite));
torture_suite_add_suite(suite, torture_rpc_samr_accessmask(suite));

285
source4/torture/rpc/schannel.c
View File

@ -33,6 +33,8 @@
#include "param/param.h"
#include "librpc/rpc/dcerpc_proto.h"
#include "auth/gensec/gensec.h"
#include "libcli/composite/composite.h"
#include "lib/events/events.h"
#define TEST_MACHINE_NAME "schannel"
@ -484,3 +486,286 @@ bool torture_rpc_schannel2(struct torture_context *torture)
return true;
}
struct torture_schannel_bench;
struct torture_schannel_bench_conn {
struct torture_schannel_bench *s;
int index;
struct cli_credentials *wks_creds;
struct dcerpc_pipe *pipe;
struct netr_LogonSamLogonEx r;
struct netr_NetworkInfo ninfo;
TALLOC_CTX *tmp;
uint64_t total;
uint32_t count;
};
struct torture_schannel_bench {
struct torture_context *tctx;
bool progress;
int timelimit;
int nprocs;
int nconns;
struct torture_schannel_bench_conn *conns;
struct test_join *join_ctx1;
struct cli_credentials *wks_creds1;
struct test_join *join_ctx2;
struct cli_credentials *wks_creds2;
struct cli_credentials *user1_creds;
struct cli_credentials *user2_creds;
struct dcerpc_binding *b;
NTSTATUS error;
uint64_t total;
uint32_t count;
bool stopped;
};
static void torture_schannel_bench_connected(struct composite_context *c)
{
struct torture_schannel_bench_conn *conn =
(struct torture_schannel_bench_conn *)c->async.private_data;
struct torture_schannel_bench *s = talloc_get_type(conn->s,
struct torture_schannel_bench);
s->error = dcerpc_pipe_connect_b_recv(c, s->conns, &conn->pipe);
torture_comment(s->tctx, "conn[%u]: %s\n", conn->index, nt_errstr(s->error));
if (NT_STATUS_IS_OK(s->error)) {
s->nconns++;
}
}
static void torture_schannel_bench_recv(struct rpc_request *req);
static bool torture_schannel_bench_start(struct torture_schannel_bench_conn *conn)
{
struct torture_schannel_bench *s = conn->s;
NTSTATUS status;
DATA_BLOB names_blob, chal, lm_resp, nt_resp;
int flags = CLI_CRED_NTLM_AUTH;
struct rpc_request *req;
struct cli_credentials *user_creds;
if (conn->total % 2) {
user_creds = s->user1_creds;
} else {
user_creds = s->user2_creds;
}
if (lp_client_lanman_auth(s->tctx->lp_ctx)) {
flags |= CLI_CRED_LANMAN_AUTH;
}
if (lp_client_ntlmv2_auth(s->tctx->lp_ctx)) {
flags |= CLI_CRED_NTLMv2_AUTH;
}
talloc_free(conn->tmp);
conn->tmp = talloc_new(s);
ZERO_STRUCT(conn->ninfo);
ZERO_STRUCT(conn->r);
cli_credentials_get_ntlm_username_domain(user_creds, conn->tmp,
&conn->ninfo.identity_info.account_name.string,
&conn->ninfo.identity_info.domain_name.string);
generate_random_buffer(conn->ninfo.challenge,
sizeof(conn->ninfo.challenge));
chal = data_blob_const(conn->ninfo.challenge,
sizeof(conn->ninfo.challenge));
names_blob = NTLMv2_generate_names_blob(conn->tmp, lp_iconv_convenience(s->tctx->lp_ctx),
cli_credentials_get_workstation(conn->wks_creds),
cli_credentials_get_domain(conn->wks_creds));
status = cli_credentials_get_ntlm_response(user_creds, conn->tmp,
&flags,
chal,
names_blob,
&lm_resp, &nt_resp,
NULL, NULL);
torture_assert_ntstatus_ok(s->tctx, status,
"cli_credentials_get_ntlm_response failed");
conn->ninfo.lm.data = lm_resp.data;
conn->ninfo.lm.length = lm_resp.length;
conn->ninfo.nt.data = nt_resp.data;
conn->ninfo.nt.length = nt_resp.length;
conn->ninfo.identity_info.parameter_control = 0;
conn->ninfo.identity_info.logon_id_low = 0;
conn->ninfo.identity_info.logon_id_high = 0;
conn->ninfo.identity_info.workstation.string = cli_credentials_get_workstation(conn->wks_creds);
conn->r.in.server_name = talloc_asprintf(conn->tmp, "\\\\%s", dcerpc_server_name(conn->pipe));
conn->r.in.computer_name = cli_credentials_get_workstation(conn->wks_creds);
conn->r.in.logon_level = 2;
conn->r.in.logon.network = &conn->ninfo;
conn->r.in.flags = 0;
conn->r.in.validation_level = 2;
req = dcerpc_netr_LogonSamLogonEx_send(conn->pipe, conn->tmp, &conn->r);
torture_assert(s->tctx, req, "Failed to setup LogonSamLogonEx request");
req->async.callback = torture_schannel_bench_recv;
req->async.private_data = conn;
return true;
}
static void torture_schannel_bench_recv(struct rpc_request *req)
{
bool ret;
struct torture_schannel_bench_conn *conn =
(struct torture_schannel_bench_conn *)req->async.private_data;
struct torture_schannel_bench *s = talloc_get_type(conn->s,
struct torture_schannel_bench);
s->error = dcerpc_ndr_request_recv(req);
if (!NT_STATUS_IS_OK(s->error)) {
return;
}
conn->total++;
conn->count++;
if (s->stopped) {
return;
}
ret = torture_schannel_bench_start(conn);
if (!ret) {
s->error = NT_STATUS_INTERNAL_ERROR;
}
}
/*
test multiple schannel connection in parallel
*/
bool torture_rpc_schannel_bench1(struct torture_context *torture)
{
bool ret = true;
NTSTATUS status;
const char *binding = torture_setting_string(torture, "binding", NULL);
struct torture_schannel_bench *s;
struct timeval start;
struct timeval end;
int i;
const char *tmp;
s = talloc_zero(torture, struct torture_schannel_bench);
s->tctx = torture;
s->progress = torture_setting_bool(torture, "progress", true);
s->timelimit = torture_setting_int(torture, "timelimit", 10);
s->nprocs = torture_setting_int(torture, "nprocs", 4);
s->conns = talloc_zero_array(s, struct torture_schannel_bench_conn, s->nprocs);
s->user1_creds = (struct cli_credentials *)talloc_memdup(s,
cmdline_credentials,
sizeof(*s->user1_creds));
tmp = torture_setting_string(s->tctx, "extra_user1", NULL);
if (tmp) {
cli_credentials_parse_string(s->user1_creds, tmp, CRED_SPECIFIED);
}
s->user2_creds = (struct cli_credentials *)talloc_memdup(s,
cmdline_credentials,
sizeof(*s->user1_creds));
tmp = torture_setting_string(s->tctx, "extra_user2", NULL);
if (tmp) {
cli_credentials_parse_string(s->user1_creds, tmp, CRED_SPECIFIED);
}
s->join_ctx1 = torture_join_domain(s->tctx, talloc_asprintf(s, "%sb", TEST_MACHINE_NAME),
ACB_WSTRUST, &s->wks_creds1);
torture_assert(torture, s->join_ctx1 != NULL,
"Failed to join domain with acct_flags=ACB_WSTRUST");
s->join_ctx2 = torture_join_domain(s->tctx, talloc_asprintf(s, "%sc", TEST_MACHINE_NAME),
ACB_WSTRUST, &s->wks_creds2);
torture_assert(torture, s->join_ctx2 != NULL,
"Failed to join domain with acct_flags=ACB_WSTRUST");
cli_credentials_set_kerberos_state(s->wks_creds1, CRED_DONT_USE_KERBEROS);
cli_credentials_set_kerberos_state(s->wks_creds2, CRED_DONT_USE_KERBEROS);
for (i=0; i < s->nprocs; i++) {
s->conns[i].s = s;
s->conns[i].index = i;
s->conns[i].wks_creds = (struct cli_credentials *)talloc_memdup(
s->conns, s->wks_creds1,sizeof(*s->wks_creds1));
if ((i % 2) && (torture_setting_bool(torture, "multijoin", false))) {
memcpy(s->conns[i].wks_creds, s->wks_creds2,
talloc_get_size(s->conns[i].wks_creds));
}
s->conns[i].wks_creds->netlogon_creds = NULL;
}
status = dcerpc_parse_binding(s, binding, &s->b);
torture_assert_ntstatus_ok(torture, status, "Bad binding string");
s->b->flags &= ~DCERPC_AUTH_OPTIONS;
s->b->flags |= DCERPC_SCHANNEL | DCERPC_SIGN;
torture_comment(torture, "Opening %d connections in parallel\n", s->nprocs);
for (i=0; i < s->nprocs; i++) {
#if 1
s->error = dcerpc_pipe_connect_b(s->conns, &s->conns[i].pipe, s->b,
&ndr_table_netlogon,
s->conns[i].wks_creds,
torture->ev, torture->lp_ctx);
torture_assert_ntstatus_ok(torture, s->error, "Failed to connect with schannel");
#else
/*
* This path doesn't work against windows,
* because of windows drops the connections
* which haven't reached a session setup yet
*
* The same as the reset on zero vc stuff.
*/
struct composite_context *c;
c = dcerpc_pipe_connect_b_send(s->conns, s->b,
&ndr_table_netlogon,
s->conns[i].wks_creds,
torture->ev,
torture->lp_ctx);
torture_assert(torture, c != NULL, "Failed to setup connect");
c->async.fn = torture_schannel_bench_connected;
c->async.private_data = &s->conns[i];
}
while (NT_STATUS_IS_OK(s->error) && s->nprocs != s->nconns) {
int ev_ret = event_loop_once(torture->ev);
torture_assert(torture, ev_ret == 0, "event_loop_once failed");
#endif
}
torture_assert_ntstatus_ok(torture, s->error, "Failed establish a connect");
torture_comment(torture, "Start looping LogonSamLogonEx on %d connections for %d secs\n",
s->nprocs, s->timelimit);
for (i=0; i < s->nprocs; i++) {
ret = torture_schannel_bench_start(&s->conns[i]);
torture_assert(torture, ret, "Failed to setup LogonSamLogonEx");
}
start = timeval_current();
end = timeval_add(&start, s->timelimit, 0);
while (NT_STATUS_IS_OK(s->error) && !timeval_expired(&end)) {
int ev_ret = event_loop_once(torture->ev);
torture_assert(torture, ev_ret == 0, "event_loop_once failed");
}
torture_assert_ntstatus_ok(torture, s->error, "Failed some request");
s->stopped = true;
talloc_free(s->conns);
for (i=0; i < s->nprocs; i++) {
s->total += s->conns[i].total;
}
torture_comment(torture,
"Total ops[%llu] (%u ops/s)\n",
(unsigned long long)s->total,
(unsigned)s->total/s->timelimit);
torture_leave_domain(s->join_ctx1);
torture_leave_domain(s->join_ctx2);
return true;
}

6
source4/torture/rpc/testjoin.c
View File

@ -508,9 +508,11 @@ _PUBLIC_ void torture_leave_domain(struct test_join *join)
/* Delete machine account */
status = dcerpc_samr_DeleteUser(join->p, join, &d);
if (!NT_STATUS_IS_OK(status)) {
printf("Delete of machine account failed\n");
printf("Delete of machine account %s failed\n",
join->netbios_name);
} else {
printf("Delete of machine account was successful.\n");
printf("Delete of machine account %s was successful.\n",
join->netbios_name);
}
if (join->libnet_r) {

2
source4/wrepl_server/wrepl_in_connection.c
View File

@ -230,7 +230,7 @@ NTSTATUS wreplsrv_in_connection_merge(struct wreplsrv_partner *partner,
wrepl_in->service = service;
wrepl_in->partner = partner;
status = stream_new_connection_merge(service->task->event_ctx, model_ops,
status = stream_new_connection_merge(service->task->event_ctx, service->task->lp_ctx, model_ops,
sock, &wreplsrv_stream_ops, service->task->msg_ctx,
wrepl_in, &conn);
NT_STATUS_NOT_OK_RETURN(status);