sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2025-03-09 08:58:35 +03:00
Code

Merge branch 'master' into wspp-schema

Browse Source
This commit is contained in:
Andrew Tridgell 2009-03-31 11:58:37 +11:00
commit 631e688c82
149 changed files with 6762 additions and 2896 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

69
docs-xml/manpages-3/vfs_dirsort.8.xml Normal file
View File

@ -0,0 +1,69 @@
<?xml version="1.0" encoding="iso-8859-1"?>
<!DOCTYPE refentry PUBLIC "-//Samba-Team//DTD DocBook V4.2-Based Variant V1.0//EN" "http://www.samba.org/samba/DTD/samba-doc">
<refentry id="vfs_dirsort.8">
<refmeta>
<refentrytitle>vfs_dirsort</refentrytitle>
<manvolnum>8</manvolnum>
<refmiscinfo class="source">Samba</refmiscinfo>
<refmiscinfo class="manual">System Administration tools</refmiscinfo>
<refmiscinfo class="version">3.3</refmiscinfo>
</refmeta>
<refnamediv>
<refname>vfs_dirsort</refname>
<refpurpose>Sort directory contents</refpurpose>
</refnamediv>
<refsynopsisdiv>
<cmdsynopsis>
<command>vfs objects = dirsort</command>
</cmdsynopsis>
</refsynopsisdiv>
<refsect1>
<title>DESCRIPTION</title>
<para>This VFS module is part of the
<citerefentry><refentrytitle>samba</refentrytitle>
<manvolnum>7</manvolnum></citerefentry> suite.</para>
<para>The <command>vfs_dirsort</command> module sorts directory
entries alphabetically before sending them to the client.</para>
<para>Please be aware that adding this module might have negative
performance implications for large directories.</para>
</refsect1>
<refsect1>
<title>EXAMPLES</title>
<para>Sort directories for all shares:</para>
<programlisting>
<smbconfsection name="[global]"/>
<smbconfoption name="vfs objects">dirsort</smbconfoption>
</programlisting>
</refsect1>
<refsect1>
<title>VERSION</title>
<para>This man page is correct for version 3.3 of the Samba suite.
</para>
</refsect1>
<refsect1>
<title>AUTHOR</title>
<para>The original Samba software and related utilities
were created by Andrew Tridgell. Samba is now developed
by the Samba Team as an Open Source project similar
to the way the Linux kernel is developed.</para>
</refsect1>
</refentry>

2
examples/libsmbclient/testbrowse.c
View File

@ -197,7 +197,7 @@ get_auth_data_with_context_fn(SMBCCTX * context,
char * pPassword,
int maxLenPassword)
{
printf("Authenticating with context 0x%lx", context);
printf("Authenticating with context %p", context);
if (context != NULL) {
char *user_data = smbc_getOptionUserData(context);
printf(" with user data %s", user_data);

21
examples/libsmbclient/testfstatvfs.c
View File

@ -75,13 +75,20 @@ int main(int argc, char * argv[])
printf("\n");
printf("Block Size: %lu\n", statvfsbuf.f_bsize);
printf("Fragment Size: %lu\n", statvfsbuf.f_frsize);
printf("Blocks: %llu\n", statvfsbuf.f_blocks);
printf("Free Blocks: %llu\n", statvfsbuf.f_bfree);
printf("Available Blocks: %llu\n", statvfsbuf.f_bavail);
printf("Files : %llu\n", statvfsbuf.f_files);
printf("Free Files: %llu\n", statvfsbuf.f_ffree);
printf("Available Files: %llu\n", statvfsbuf.f_favail);
printf("File System ID: %lu\n", statvfsbuf.f_fsid);
printf("Blocks: %llu\n",
(unsigned long long) statvfsbuf.f_blocks);
printf("Free Blocks: %llu\n",
(unsigned long long) statvfsbuf.f_bfree);
printf("Available Blocks: %llu\n",
(unsigned long long) statvfsbuf.f_bavail);
printf("Files : %llu\n",
(unsigned long long) statvfsbuf.f_files);
printf("Free Files: %llu\n",
(unsigned long long) statvfsbuf.f_ffree);
printf("Available Files: %llu\n",
(unsigned long long) statvfsbuf.f_favail);
printf("File System ID: %lu\n",
(unsigned long) statvfsbuf.f_fsid);
printf("\n");
printf("Flags: 0x%lx\n", statvfsbuf.f_flag);

12
examples/libsmbclient/testsmbc.c
View File

@ -21,6 +21,7 @@
#include <stdio.h>
#include <errno.h>
#include <time.h>
#include <sys/time.h>
#include <string.h>
#include <unistd.h>
@ -33,8 +34,12 @@ int global_id = 0;
void print_list_fn(struct print_job_info *pji)
{
fprintf(stdout, "Print job: ID: %u, Prio: %u, Size: %u, User: %s, Name: %s\n",
pji->id, pji->priority, pji->size, pji->user, pji->name);
fprintf(stdout, "Print job: ID: %u, Prio: %u, Size: %lu, User: %s, Name: %s\n",
pji->id,
pji->priority,
(unsigned long) pji->size,
pji->user,
pji->name);
global_id = pji->id;
@ -137,7 +142,8 @@ int main(int argc, char *argv[])
}
fprintf(stdout, "Wrote %d bytes to file: %s\n", sizeof(buff), buff);
fprintf(stdout, "Wrote %lu bytes to file: %s\n",
(unsigned long) sizeof(buff), buff);
/* Now, seek the file back to offset 0 */

21
examples/libsmbclient/teststatvfs.c
View File

@ -49,13 +49,20 @@ int main(int argc, char * argv[])
printf("\n");
printf("Block Size: %lu\n", statvfsbuf.f_bsize);
printf("Fragment Size: %lu\n", statvfsbuf.f_frsize);
printf("Blocks: %llu\n", statvfsbuf.f_blocks);
printf("Free Blocks: %llu\n", statvfsbuf.f_bfree);
printf("Available Blocks: %llu\n", statvfsbuf.f_bavail);
printf("Files : %llu\n", statvfsbuf.f_files);
printf("Free Files: %llu\n", statvfsbuf.f_ffree);
printf("Available Files: %llu\n", statvfsbuf.f_favail);
printf("File System ID: %lu\n", statvfsbuf.f_fsid);
printf("Blocks: %llu\n",
(unsigned long long) statvfsbuf.f_blocks);
printf("Free Blocks: %llu\n",
(unsigned long long) statvfsbuf.f_bfree);
printf("Available Blocks: %llu\n",
(unsigned long long) statvfsbuf.f_bavail);
printf("Files : %llu\n",
(unsigned long long) statvfsbuf.f_files);
printf("Free Files: %llu\n",
(unsigned long long) statvfsbuf.f_ffree);
printf("Available Files: %llu\n",
(unsigned long long) statvfsbuf.f_favail);
printf("File System ID: %lu\n",
(unsigned long) statvfsbuf.f_fsid);
printf("\n");
printf("Flags: 0x%lx\n", statvfsbuf.f_flag);

4
lib/replace/libreplace_network.m4
View File

@ -170,7 +170,7 @@ fi
# The following tests need LIBS="${LIBREPLACE_NETWORK_LIBS}"
old_LIBS=$LIBS
LIBS="${LIBREPLACE_NETWORK_LIBS}"
SAVE_CPPFLAGS="$CPPFLAGS"
libreplace_SAVE_CPPFLAGS="$CPPFLAGS"
CPPFLAGS="$CPPFLAGS -I$libreplacedir"
AC_CHECK_FUNCS(socketpair,[],[LIBREPLACE_NETWORK_OBJS="${LIBREPLACE_NETWORK_OBJS} socketpair.o"])
@ -381,7 +381,7 @@ if test x"$libreplace_cv_HAVE_IPV6" = x"yes"; then
fi
LIBS=$old_LIBS
CPPFLAGS="$SAVE_CPPFLAGS"
CPPFLAGS="$libreplace_SAVE_CPPFLAGS"
LIBREPLACEOBJ="${LIBREPLACEOBJ} ${LIBREPLACE_NETWORK_OBJS}"

56
lib/socket_wrapper/socket_wrapper.c
View File

@ -218,6 +218,7 @@ struct socket_info
int bcast;
int is_server;
int connected;
int defer_connect;
char *path;
char *tmp_path;
@ -1686,10 +1687,15 @@ _PUBLIC_ int swrap_connect(int s, const struct sockaddr *serv_addr, socklen_t ad
ret = sockaddr_convert_to_un(si, (const struct sockaddr *)serv_addr, addrlen, &un_addr, 0, NULL);
if (ret == -1) return -1;
swrap_dump_packet(si, serv_addr, SWRAP_CONNECT_SEND, NULL, 0);
if (si->type == SOCK_DGRAM) {
si->defer_connect = 1;
ret = 0;
} else {
swrap_dump_packet(si, serv_addr, SWRAP_CONNECT_SEND, NULL, 0);
ret = real_connect(s, (struct sockaddr *)&un_addr,
sizeof(struct sockaddr_un));
ret = real_connect(s, (struct sockaddr *)&un_addr,
sizeof(struct sockaddr_un));
}
/* to give better errors */
if (ret == -1 && errno == ENOENT) {
@ -1917,7 +1923,22 @@ _PUBLIC_ ssize_t swrap_sendto(int s, const void *buf, size_t len, int flags, con
return len;
}
if (si->defer_connect) {
ret = real_connect(s, (struct sockaddr *)&un_addr,
sizeof(un_addr));
/* to give better errors */
if (ret == -1 && errno == ENOENT) {
errno = EHOSTUNREACH;
}
if (ret == -1) {
return ret;
}
si->defer_connect = 0;
}
ret = real_sendto(s, buf, len, flags, (struct sockaddr *)&un_addr, sizeof(un_addr));
break;
default:
@ -2002,6 +2023,33 @@ _PUBLIC_ ssize_t swrap_send(int s, const void *buf, size_t len, int flags)
len = MIN(len, 1500);
if (si->defer_connect) {
struct sockaddr_un un_addr;
int bcast = 0;
if (si->bound == 0) {
ret = swrap_auto_bind(si, si->family);
if (ret == -1) return -1;
}
ret = sockaddr_convert_to_un(si, si->peername, si->peername_len,
&un_addr, 0, &bcast);
if (ret == -1) return -1;
ret = real_connect(s, (struct sockaddr *)&un_addr,
sizeof(un_addr));
/* to give better errors */
if (ret == -1 && errno == ENOENT) {
errno = EHOSTUNREACH;
}
if (ret == -1) {
return ret;
}
si->defer_connect = 0;
}
ret = real_send(s, buf, len, flags);
if (ret == -1) {

2
lib/talloc/talloc.h
View File

@ -94,7 +94,7 @@ typedef void TALLOC_CTX;
#define talloc_array(ctx, type, count) (type *)_talloc_array(ctx, sizeof(type), count, #type)
#define talloc_array_size(ctx, size, count) _talloc_array(ctx, size, count, __location__)
#define talloc_array_ptrtype(ctx, ptr, count) (_TALLOC_TYPEOF(ptr))talloc_array_size(ctx, sizeof(*(ptr)), count)
#define talloc_array_length(ctx) ((ctx) ? talloc_get_size(ctx)/sizeof(*ctx) : 0)
#define talloc_array_length(ctx) (talloc_get_size(ctx)/sizeof(*ctx))
#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__)

48
lib/tsocket/tsocket_bsd.c
View File

@ -44,11 +44,11 @@ struct tsocket_address_bsd {
bool broadcast;
union {
struct sockaddr sa;
struct sockaddr_in sin;
struct sockaddr_in in;
#ifdef HAVE_IPV6
struct sockaddr_in6 sin6;
struct sockaddr_in6 in6;
#endif
struct sockaddr_un sun;
struct sockaddr_un un;
struct sockaddr_storage ss;
} u;
};
@ -204,14 +204,14 @@ char *tsocket_address_inet_addr_string(const struct tsocket_address *addr,
switch (bsda->u.sa.sa_family) {
case AF_INET:
str = inet_ntop(bsda->u.sin.sin_family,
&bsda->u.sin.sin_addr,
str = inet_ntop(bsda->u.in.sin_family,
&bsda->u.in.sin_addr,
addr_str, sizeof(addr_str));
break;
#ifdef HAVE_IPV6
case AF_INET6:
str = inet_ntop(bsda->u.sin6.sin6_family,
&bsda->u.sin6.sin6_addr,
str = inet_ntop(bsda->u.in6.sin6_family,
&bsda->u.in6.sin6_addr,
addr_str, sizeof(addr_str));
break;
#endif
@ -240,11 +240,11 @@ uint16_t tsocket_address_inet_port(const struct tsocket_address *addr)
switch (bsda->u.sa.sa_family) {
case AF_INET:
port = ntohs(bsda->u.sin.sin_port);
port = ntohs(bsda->u.in.sin_port);
break;
#ifdef HAVE_IPV6
case AF_INET6:
port = ntohs(bsda->u.sin6.sin6_port);
port = ntohs(bsda->u.in6.sin6_port);
break;
#endif
default:
@ -268,11 +268,11 @@ int tsocket_address_inet_set_port(struct tsocket_address *addr,
switch (bsda->u.sa.sa_family) {
case AF_INET:
bsda->u.sin.sin_port = htons(port);
bsda->u.in.sin_port = htons(port);
break;
#ifdef HAVE_IPV6
case AF_INET6:
bsda->u.sin6.sin6_port = htons(port);
bsda->u.in6.sin6_port = htons(port);
break;
#endif
default:
@ -301,21 +301,21 @@ int _tsocket_address_unix_from_path(TALLOC_CTX *mem_ctx,
struct tsocket_address **_addr,
const char *location)
{
struct sockaddr_un sun;
void *p = &sun;
struct sockaddr_un un;
void *p = &un;
int ret;
if (!path) {
path = "";
}
ZERO_STRUCT(sun);
sun.sun_family = AF_UNIX;
strncpy(sun.sun_path, path, sizeof(sun.sun_path));
ZERO_STRUCT(un);
un.sun_family = AF_UNIX;
strncpy(un.sun_path, path, sizeof(un.sun_path));
ret = _tsocket_address_bsd_from_sockaddr(mem_ctx,
(struct sockaddr *)p,
sizeof(sun),
sizeof(un),
_addr,
location);
@ -336,7 +336,7 @@ char *tsocket_address_unix_path(const struct tsocket_address *addr,
switch (bsda->u.sa.sa_family) {
case AF_UNIX:
str = bsda->u.sun.sun_path;
str = bsda->u.un.sun_path;
break;
default:
errno = EINVAL;
@ -359,7 +359,7 @@ static char *tsocket_address_bsd_string(const struct tsocket_address *addr,
switch (bsda->u.sa.sa_family) {
case AF_UNIX:
return talloc_asprintf(mem_ctx, "unix:%s",
bsda->u.sun.sun_path);
bsda->u.un.sun_path);
case AF_INET:
prefix = "ipv4";
break;
@ -469,27 +469,27 @@ static int tsocket_address_bsd_create_socket(const struct tsocket_address *addr,
errno = EINVAL;
return -1;
}
if (bsda->u.sun.sun_path[0] != 0) {
if (bsda->u.un.sun_path[0] != 0) {
do_bind = true;
}
break;
case AF_INET:
if (bsda->u.sin.sin_port != 0) {
if (bsda->u.in.sin_port != 0) {
do_reuseaddr = true;
do_bind = true;
}
if (bsda->u.sin.sin_addr.s_addr == INADDR_ANY) {
if (bsda->u.in.sin_addr.s_addr == INADDR_ANY) {
do_bind = true;
}
break;
#ifdef HAVE_IPV6
case AF_INET6:
if (bsda->u.sin6.sin6_port != 0) {
if (bsda->u.in6.sin6_port != 0) {
do_reuseaddr = true;
do_bind = true;
}
if (memcmp(&in6addr_any,
&bsda->u.sin6.sin6_addr,
&bsda->u.in6.sin6_addr,
sizeof(in6addr_any)) != 0) {
do_bind = true;
}

2
lib/util/fault.m4
View File

@ -9,6 +9,8 @@ if test x"$ac_cv_header_execinfo_h" = x"yes" -a x"$ac_cv_func_ext_backtrace" = x
EXECINFO_CPPFLAGS="$CPPFLAGS"
EXECINFO_LDFLAGS="$LDFLAGS"
LIB_REMOVE_USR_LIB(EXECINFO_LDFLAGS)
CFLAGS_REMOVE_USR_INCLUDE(EXECINFO_CFLAGS)
CFLAGS_REMOVE_USR_INCLUDE(EXECINFO_CPPFLAGS)
else
SMB_ENABLE(EXECINFO,NO)
fi

10
lib/util/tevent_ntstatus.c
View File

@ -49,3 +49,13 @@ bool tevent_req_is_nterror(struct tevent_req *req, NTSTATUS *status)
}
return true;
}
NTSTATUS tevent_req_simple_recv_ntstatus(struct tevent_req *req)
{
NTSTATUS status;
if (tevent_req_is_nterror(req, &status)) {
return status;
}
return NT_STATUS_OK;
}

1
lib/util/tevent_ntstatus.h
View File

@ -28,5 +28,6 @@
bool tevent_req_nterror(struct tevent_req *req, NTSTATUS status);
bool tevent_req_is_nterror(struct tevent_req *req, NTSTATUS *pstatus);
NTSTATUS tevent_req_simple_recv_ntstatus(struct tevent_req *req);
#endif

2
libcli/security/config.mk
View File

@ -2,4 +2,4 @@
PRIVATE_DEPENDENCIES = TALLOC
LIBSECURITY_COMMON_OBJ_FILES = $(addprefix $(libclicommonsrcdir)/security/, \
dom_sid.o)
dom_sid.o display_sec.o secace.o secacl.o)

91
source3/lib/display_sec.c → libcli/security/display_sec.c
View File

@ -19,12 +19,16 @@
*/
#include "includes.h"
#include "librpc/gen_ndr/security.h"
#include "libcli/security/secace.h"
#include "libcli/security/dom_sid.h"
#include "librpc/ndr/libndr.h"
/****************************************************************************
convert a security permissions into a string
****************************************************************************/
char *get_sec_mask_str(TALLOC_CTX *ctx, uint32 type)
char *get_sec_mask_str(TALLOC_CTX *ctx, uint32_t type)
{
char *typestr = talloc_strdup(ctx, "");
@ -32,77 +36,77 @@ char *get_sec_mask_str(TALLOC_CTX *ctx, uint32 type)
return NULL;
}
if (type & GENERIC_ALL_ACCESS) {
if (type & SEC_GENERIC_ALL) {
typestr = talloc_asprintf_append(typestr,
"Generic all access ");
if (!typestr) {
return NULL;
}
}
if (type & GENERIC_EXECUTE_ACCESS) {
if (type & SEC_GENERIC_EXECUTE) {
typestr = talloc_asprintf_append(typestr,
"Generic execute access");
if (!typestr) {
return NULL;
}
}
if (type & GENERIC_WRITE_ACCESS) {
if (type & SEC_GENERIC_WRITE) {
typestr = talloc_asprintf_append(typestr,
"Generic write access ");
if (!typestr) {
return NULL;
}
}
if (type & GENERIC_READ_ACCESS) {
if (type & SEC_GENERIC_READ) {
typestr = talloc_asprintf_append(typestr,
"Generic read access ");
if (!typestr) {
return NULL;
}
}
if (type & MAXIMUM_ALLOWED_ACCESS) {
if (type & SEC_FLAG_MAXIMUM_ALLOWED) {
typestr = talloc_asprintf_append(typestr,
"MAXIMUM_ALLOWED_ACCESS ");
if (!typestr) {
return NULL;
}
}
if (type & SYSTEM_SECURITY_ACCESS) {
if (type & SEC_FLAG_SYSTEM_SECURITY) {
typestr = talloc_asprintf_append(typestr,
"SYSTEM_SECURITY_ACCESS ");
if (!typestr) {
return NULL;
}
}
if (type & SYNCHRONIZE_ACCESS) {
if (type & SEC_STD_SYNCHRONIZE) {
typestr = talloc_asprintf_append(typestr,
"SYNCHRONIZE_ACCESS ");
if (!typestr) {
return NULL;
}
}
if (type & WRITE_OWNER_ACCESS) {
if (type & SEC_STD_WRITE_OWNER) {
typestr = talloc_asprintf_append(typestr,
"WRITE_OWNER_ACCESS ");
if (!typestr) {
return NULL;
}
}
if (type & WRITE_DAC_ACCESS) {
if (type & SEC_STD_WRITE_DAC) {
typestr = talloc_asprintf_append(typestr,
"WRITE_DAC_ACCESS ");
if (!typestr) {
return NULL;
}
}
if (type & READ_CONTROL_ACCESS) {
if (type & SEC_STD_READ_CONTROL) {
typestr = talloc_asprintf_append(typestr,
"READ_CONTROL_ACCESS ");
if (!typestr) {
return NULL;
}
}
if (type & DELETE_ACCESS) {
if (type & SEC_STD_DELETE) {
typestr = talloc_asprintf_append(typestr,
"DELETE_ACCESS ");
if (!typestr) {
@ -110,7 +114,7 @@ char *get_sec_mask_str(TALLOC_CTX *ctx, uint32 type)
}
}
printf("\t\tSpecific bits: 0x%lx\n", (unsigned long)type&SPECIFIC_RIGHTS_MASK);
printf("\t\tSpecific bits: 0x%lx\n", (unsigned long)type&SEC_MASK_SPECIFIC);
return typestr;
}
@ -122,7 +126,7 @@ void display_sec_access(uint32_t *info)
{
char *mask_str = get_sec_mask_str(NULL, *info);
printf("\t\tPermissions: 0x%x: %s\n", *info, mask_str ? mask_str : "");
TALLOC_FREE(mask_str);
talloc_free(mask_str);
}
/****************************************************************************
@ -170,9 +174,9 @@ static void disp_sec_ace_object(struct security_ace_object *object)
/****************************************************************************
display sec_ace structure
****************************************************************************/
void display_sec_ace(SEC_ACE *ace)
void display_sec_ace(struct security_ace *ace)
{
fstring sid_str;
char *sid_str;
printf("\tACE\n\t\ttype: ");
switch (ace->type) {
@ -211,8 +215,9 @@ void display_sec_ace(SEC_ACE *ace)
printf(" (%d) flags: 0x%02x ", ace->type, ace->flags);
display_sec_ace_flags(ace->flags);
display_sec_access(&ace->access_mask);
sid_to_fstring(sid_str, &ace->trustee);
sid_str = dom_sid_string(NULL, &ace->trustee);
printf("\t\tSID: %s\n\n", sid_str);
talloc_free(sid_str);
if (sec_ace_object(ace->type)) {
disp_sec_ace_object(&ace->object.object);
@ -223,7 +228,7 @@ void display_sec_ace(SEC_ACE *ace)
/****************************************************************************
display sec_acl structure
****************************************************************************/
void display_sec_acl(SEC_ACL *sec_acl)
void display_sec_acl(struct security_acl *sec_acl)
{
int i;
@ -238,54 +243,52 @@ void display_sec_acl(SEC_ACL *sec_acl)
}
}
void display_acl_type(uint16 type)
void display_acl_type(uint16_t type)
{
fstring typestr="";
typestr[0] = 0;
printf("type: 0x%04x: ", type);
if (type & SEC_DESC_OWNER_DEFAULTED) /* 0x0001 */
fstrcat(typestr, "SEC_DESC_OWNER_DEFAULTED ");
printf("SEC_DESC_OWNER_DEFAULTED ");
if (type & SEC_DESC_GROUP_DEFAULTED) /* 0x0002 */
fstrcat(typestr, "SEC_DESC_GROUP_DEFAULTED ");
printf("SEC_DESC_GROUP_DEFAULTED ");
if (type & SEC_DESC_DACL_PRESENT) /* 0x0004 */
fstrcat(typestr, "SEC_DESC_DACL_PRESENT ");
printf("SEC_DESC_DACL_PRESENT ");
if (type & SEC_DESC_DACL_DEFAULTED) /* 0x0008 */
fstrcat(typestr, "SEC_DESC_DACL_DEFAULTED ");
printf("SEC_DESC_DACL_DEFAULTED ");
if (type & SEC_DESC_SACL_PRESENT) /* 0x0010 */
fstrcat(typestr, "SEC_DESC_SACL_PRESENT ");
printf("SEC_DESC_SACL_PRESENT ");
if (type & SEC_DESC_SACL_DEFAULTED) /* 0x0020 */
fstrcat(typestr, "SEC_DESC_SACL_DEFAULTED ");
printf("SEC_DESC_SACL_DEFAULTED ");
if (type & SEC_DESC_DACL_TRUSTED) /* 0x0040 */
fstrcat(typestr, "SEC_DESC_DACL_TRUSTED ");
printf("SEC_DESC_DACL_TRUSTED ");
if (type & SEC_DESC_SERVER_SECURITY) /* 0x0080 */
fstrcat(typestr, "SEC_DESC_SERVER_SECURITY ");
printf("SEC_DESC_SERVER_SECURITY ");
if (type & SEC_DESC_DACL_AUTO_INHERIT_REQ) /* 0x0100 */
fstrcat(typestr, "SEC_DESC_DACL_AUTO_INHERIT_REQ ");
printf("SEC_DESC_DACL_AUTO_INHERIT_REQ ");
if (type & SEC_DESC_SACL_AUTO_INHERIT_REQ) /* 0x0200 */
fstrcat(typestr, "SEC_DESC_SACL_AUTO_INHERIT_REQ ");
printf("SEC_DESC_SACL_AUTO_INHERIT_REQ ");
if (type & SEC_DESC_DACL_AUTO_INHERITED) /* 0x0400 */
fstrcat(typestr, "SEC_DESC_DACL_AUTO_INHERITED ");
printf("SEC_DESC_DACL_AUTO_INHERITED ");
if (type & SEC_DESC_SACL_AUTO_INHERITED) /* 0x0800 */
fstrcat(typestr, "SEC_DESC_SACL_AUTO_INHERITED ");
printf("SEC_DESC_SACL_AUTO_INHERITED ");
if (type & SEC_DESC_DACL_PROTECTED) /* 0x1000 */
fstrcat(typestr, "SEC_DESC_DACL_PROTECTED ");
printf("SEC_DESC_DACL_PROTECTED ");
if (type & SEC_DESC_SACL_PROTECTED) /* 0x2000 */
fstrcat(typestr, "SEC_DESC_SACL_PROTECTED ");
printf("SEC_DESC_SACL_PROTECTED ");
if (type & SEC_DESC_RM_CONTROL_VALID) /* 0x4000 */
fstrcat(typestr, "SEC_DESC_RM_CONTROL_VALID ");
printf("SEC_DESC_RM_CONTROL_VALID ");
if (type & SEC_DESC_SELF_RELATIVE) /* 0x8000 */
fstrcat(typestr, "SEC_DESC_SELF_RELATIVE ");
printf("SEC_DESC_SELF_RELATIVE ");
printf("type: 0x%04x: %s\n", type, typestr);
printf("\n");
}
/****************************************************************************
display sec_desc structure
****************************************************************************/
void display_sec_desc(SEC_DESC *sec)
void display_sec_desc(struct security_descriptor *sec)
{
fstring sid_str;
char *sid_str;
if (!sec) {
printf("NULL\n");
@ -306,12 +309,14 @@ void display_sec_desc(SEC_DESC *sec)
}
if (sec->owner_sid) {
sid_to_fstring(sid_str, sec->owner_sid);
sid_str = dom_sid_string(NULL, sec->owner_sid);
printf("\tOwner SID:\t%s\n", sid_str);
talloc_free(sid_str);
}
if (sec->group_sid) {
sid_to_fstring(sid_str, sec->group_sid);
sid_str = dom_sid_string(NULL, sec->group_sid);
printf("\tGroup SID:\t%s\n", sid_str);
talloc_free(sid_str);
}
}

1
libcli/util/doserr.c
View File

@ -124,6 +124,7 @@ static const struct werror_code_struct dos_errs[] =
{ "WERR_DS_DRA_DB_ERROR", WERR_DS_DRA_DB_ERROR },
{ "WERR_DS_DRA_NO_REPLICA", WERR_DS_DRA_NO_REPLICA },
{ "WERR_DS_DRA_ACCESS_DENIED", WERR_DS_DRA_ACCESS_DENIED },
{ "WERR_DS_DRA_SOURCE_DISABLED", WERR_DS_DRA_SOURCE_DISABLED },
{ "WERR_DS_DNS_LOOKUP_FAILURE", WERR_DS_DNS_LOOKUP_FAILURE },
{ "WERR_DS_WRONG_LINKED_ATTRIBUTE_SYNTAX", WERR_DS_WRONG_LINKED_ATTRIBUTE_SYNTAX },
{ "WERR_DS_NO_MSDS_INTID", WERR_DS_NO_MSDS_INTID },

1
libcli/util/werror.h
View File

@ -248,6 +248,7 @@ typedef uint32_t WERROR;
#define WERR_DS_DRA_DB_ERROR W_ERROR(0x00002103)
#define WERR_DS_DRA_NO_REPLICA W_ERROR(0x00002104)
#define WERR_DS_DRA_ACCESS_DENIED W_ERROR(0x00002105)
#define WERR_DS_DRA_SOURCE_DISABLED W_ERROR(0x00002108)
#define WERR_DS_DNS_LOOKUP_FAILURE W_ERROR(0x0000214c)
#define WERR_DS_WRONG_LINKED_ATTRIBUTE_SYNTAX W_ERROR(0x00002150)
#define WERR_DS_NO_MSDS_INTID W_ERROR(0x00002194)

343
librpc/gen_ndr/dcerpc.h Normal file
View File

@ -0,0 +1,343 @@
/* header auto-generated by pidl */
#include <stdint.h>
#include "libcli/util/ntstatus.h"
#include "librpc/gen_ndr/misc.h"
#ifndef _HEADER_dcerpc
#define _HEADER_dcerpc
#define DCERPC_REQUEST_LENGTH ( 24 )
#define DCERPC_BIND_REASON_ASYNTAX ( 1 )
#define DCERPC_BIND_PROVIDER_REJECT ( 2 )
#define DECRPC_BIND_PROTOCOL_VERSION_NOT_SUPPORTED ( 4 )
#define DCERPC_BIND_REASON_INVALID_AUTH_TYPE ( 8 )
#define DCERPC_RESPONSE_LENGTH ( 24 )
#define DCERPC_FAULT_OP_RNG_ERROR ( 0x1c010002 )
#define DCERPC_FAULT_UNK_IF ( 0x1c010003 )
#define DCERPC_FAULT_NDR ( 0x000006f7 )
#define DCERPC_FAULT_INVALID_TAG ( 0x1c000006 )
#define DCERPC_FAULT_CONTEXT_MISMATCH ( 0x1c00001a )
#define DCERPC_FAULT_OTHER ( 0x00000001 )
#define DCERPC_FAULT_ACCESS_DENIED ( 0x00000005 )
#define DCERPC_FAULT_CANT_PERFORM ( 0x000006d8 )
#define DCERPC_FAULT_TODO ( 0x00000042 )
#define DCERPC_AUTH_LEVEL_DEFAULT ( DCERPC_AUTH_LEVEL_CONNECT )
#define DCERPC_AUTH_TRAILER_LENGTH ( 8 )
#define DCERPC_PFC_FLAG_FIRST ( 0x01 )
#define DCERPC_PFC_FLAG_LAST ( 0x02 )
#define DCERPC_PFC_FLAG_PENDING_CANCEL ( 0x04 )
#define DCERPC_PFC_FLAG_SUPPORT_HEADER_SIGN ( DCERPC_PFC_FLAG_PENDING_CANCEL )
#define DCERPC_PFC_FLAG_CONC_MPX ( 0x10 )
#define DCERPC_PFC_FLAG_DID_NOT_EXECUTE ( 0x20 )
#define DCERPC_PFC_FLAG_MAYBE ( 0x40 )
#define DCERPC_PFC_FLAG_OBJECT_UUID ( 0x80 )
#define DCERPC_PFC_OFFSET ( 3 )
#define DCERPC_DREP_OFFSET ( 4 )
#define DCERPC_FRAG_LEN_OFFSET ( 8 )
#define DCERPC_AUTH_LEN_OFFSET ( 10 )
#define DCERPC_DREP_LE ( 0x10 )
struct dcerpc_ctx_list {
uint16_t context_id;
uint8_t num_transfer_syntaxes;
struct ndr_syntax_id abstract_syntax;
struct ndr_syntax_id *transfer_syntaxes;
};
struct dcerpc_bind {
uint16_t max_xmit_frag;
uint16_t max_recv_frag;
uint32_t assoc_group_id;
uint8_t num_contexts;
struct dcerpc_ctx_list *ctx_list;
DATA_BLOB _pad;/* [flag(LIBNDR_FLAG_ALIGN4)] */
DATA_BLOB auth_info;/* [flag(LIBNDR_FLAG_REMAINING)] */
};
struct dcerpc_empty {
char _empty_;
};
union dcerpc_object {
struct dcerpc_empty empty;/* [default] */
struct GUID object;/* [case(LIBNDR_FLAG_OBJECT_PRESENT)] */
}/* [nodiscriminant] */;
struct dcerpc_request {
uint32_t alloc_hint;
uint16_t context_id;
uint16_t opnum;
union dcerpc_object object;/* [switch_is(ndr->flags&LIBNDR_FLAG_OBJECT_PRESENT)] */
DATA_BLOB _pad;/* [flag(LIBNDR_FLAG_ALIGN8)] */
DATA_BLOB stub_and_verifier;/* [flag(LIBNDR_FLAG_REMAINING)] */
};
struct dcerpc_ack_ctx {
uint16_t result;
uint16_t reason;
struct ndr_syntax_id syntax;
};
struct dcerpc_bind_ack {
uint16_t max_xmit_frag;
uint16_t max_recv_frag;
uint32_t assoc_group_id;
uint16_t secondary_address_size;/* [value(strlen(secondary_address)+1)] */
const char *secondary_address;/* [charset(DOS)] */
DATA_BLOB _pad1;/* [flag(LIBNDR_FLAG_ALIGN4)] */
uint8_t num_results;
struct dcerpc_ack_ctx *ctx_list;
DATA_BLOB auth_info;/* [flag(LIBNDR_FLAG_REMAINING)] */
};
struct dcerpc_bind_nak_versions {
uint32_t num_versions;
uint32_t *versions;
};
union dcerpc_bind_nak_versions_ctr {
struct dcerpc_bind_nak_versions v;/* [case(DECRPC_BIND_PROTOCOL_VERSION_NOT_SUPPORTED)] */
}/* [nodiscriminant] */;
struct dcerpc_bind_nak {
uint16_t reject_reason;
union dcerpc_bind_nak_versions_ctr versions;/* [switch_is(reject_reason)] */
};
struct dcerpc_response {
uint32_t alloc_hint;
uint16_t context_id;
uint8_t cancel_count;
DATA_BLOB _pad;/* [flag(LIBNDR_FLAG_ALIGN8)] */
DATA_BLOB stub_and_verifier;/* [flag(LIBNDR_FLAG_REMAINING)] */
};
struct dcerpc_fault {
uint32_t alloc_hint;
uint16_t context_id;
uint8_t cancel_count;
uint32_t status;
DATA_BLOB _pad;/* [flag(LIBNDR_FLAG_REMAINING)] */
};
enum dcerpc_AuthType
#ifndef USE_UINT_ENUMS
{
DCERPC_AUTH_TYPE_NONE=0,
DCERPC_AUTH_TYPE_KRB5_1=1,
DCERPC_AUTH_TYPE_SPNEGO=9,
DCERPC_AUTH_TYPE_NTLMSSP=10,
DCERPC_AUTH_TYPE_KRB5=16,
DCERPC_AUTH_TYPE_DPA=17,
DCERPC_AUTH_TYPE_MSN=18,
DCERPC_AUTH_TYPE_DIGEST=21,
DCERPC_AUTH_TYPE_SCHANNEL=68,
DCERPC_AUTH_TYPE_MSMQ=100
}
#else
{ __donnot_use_enum_dcerpc_AuthType=0x7FFFFFFF}
#define DCERPC_AUTH_TYPE_NONE ( 0 )
#define DCERPC_AUTH_TYPE_KRB5_1 ( 1 )
#define DCERPC_AUTH_TYPE_SPNEGO ( 9 )
#define DCERPC_AUTH_TYPE_NTLMSSP ( 10 )
#define DCERPC_AUTH_TYPE_KRB5 ( 16 )
#define DCERPC_AUTH_TYPE_DPA ( 17 )
#define DCERPC_AUTH_TYPE_MSN ( 18 )
#define DCERPC_AUTH_TYPE_DIGEST ( 21 )
#define DCERPC_AUTH_TYPE_SCHANNEL ( 68 )
#define DCERPC_AUTH_TYPE_MSMQ ( 100 )
#endif
;
enum dcerpc_AuthLevel
#ifndef USE_UINT_ENUMS
{
DCERPC_AUTH_LEVEL_NONE=1,
DCERPC_AUTH_LEVEL_CONNECT=2,
DCERPC_AUTH_LEVEL_CALL=3,
DCERPC_AUTH_LEVEL_PACKET=4,
DCERPC_AUTH_LEVEL_INTEGRITY=5,
DCERPC_AUTH_LEVEL_PRIVACY=6
}
#else
{ __donnot_use_enum_dcerpc_AuthLevel=0x7FFFFFFF}
#define DCERPC_AUTH_LEVEL_NONE ( 1 )
#define DCERPC_AUTH_LEVEL_CONNECT ( 2 )
#define DCERPC_AUTH_LEVEL_CALL ( 3 )
#define DCERPC_AUTH_LEVEL_PACKET ( 4 )
#define DCERPC_AUTH_LEVEL_INTEGRITY ( 5 )
#define DCERPC_AUTH_LEVEL_PRIVACY ( 6 )
#endif
;
struct dcerpc_auth {
enum dcerpc_AuthType auth_type;
enum dcerpc_AuthLevel auth_level;
uint8_t auth_pad_length;
uint8_t auth_reserved;
uint32_t auth_context_id;
DATA_BLOB credentials;/* [flag(LIBNDR_FLAG_REMAINING)] */
}/* [public] */;
struct dcerpc_auth3 {
uint32_t _pad;
DATA_BLOB auth_info;/* [flag(LIBNDR_FLAG_REMAINING)] */
}/* [public] */;
struct dcerpc_orphaned {
uint32_t _pad;
DATA_BLOB auth_info;/* [flag(LIBNDR_FLAG_REMAINING)] */
}/* [public] */;
struct dcerpc_co_cancel {
uint32_t _pad;
DATA_BLOB auth_info;/* [flag(LIBNDR_FLAG_REMAINING)] */
}/* [public] */;
struct dcerpc_cl_cancel {
uint32_t version;
uint32_t id;
}/* [public] */;
struct dcerpc_cancel_ack {
uint32_t version;
uint32_t id;
uint32_t server_is_accepting;
}/* [public] */;
struct dcerpc_fack {
uint32_t version;
uint8_t _pad1;
uint16_t window_size;
uint32_t max_tdsu;
uint32_t max_frag_size;
uint16_t serial_no;
uint16_t selack_size;
uint32_t *selack;
}/* [public] */;
struct dcerpc_ack {
char _empty_;
}/* [public] */;
struct dcerpc_ping {
char _empty_;
}/* [public] */;
struct dcerpc_shutdown {
char _empty_;
}/* [public] */;
struct dcerpc_working {
char _empty_;
}/* [public] */;
enum dcerpc_pkt_type
#ifndef USE_UINT_ENUMS
{
DCERPC_PKT_REQUEST=0,
DCERPC_PKT_PING=1,
DCERPC_PKT_RESPONSE=2,
DCERPC_PKT_FAULT=3,
DCERPC_PKT_WORKING=4,
DCERPC_PKT_NOCALL=5,
DCERPC_PKT_REJECT=6,
DCERPC_PKT_ACK=7,
DCERPC_PKT_CL_CANCEL=8,
DCERPC_PKT_FACK=9,
DCERPC_PKT_CANCEL_ACK=10,
DCERPC_PKT_BIND=11,
DCERPC_PKT_BIND_ACK=12,
DCERPC_PKT_BIND_NAK=13,
DCERPC_PKT_ALTER=14,
DCERPC_PKT_ALTER_RESP=15,
DCERPC_PKT_AUTH3=16,
DCERPC_PKT_SHUTDOWN=17,
DCERPC_PKT_CO_CANCEL=18,
DCERPC_PKT_ORPHANED=19
}
#else
{ __donnot_use_enum_dcerpc_pkt_type=0x7FFFFFFF}
#define DCERPC_PKT_REQUEST ( 0 )
#define DCERPC_PKT_PING ( 1 )
#define DCERPC_PKT_RESPONSE ( 2 )
#define DCERPC_PKT_FAULT ( 3 )
#define DCERPC_PKT_WORKING ( 4 )
#define DCERPC_PKT_NOCALL ( 5 )
#define DCERPC_PKT_REJECT ( 6 )
#define DCERPC_PKT_ACK ( 7 )
#define DCERPC_PKT_CL_CANCEL ( 8 )
#define DCERPC_PKT_FACK ( 9 )
#define DCERPC_PKT_CANCEL_ACK ( 10 )
#define DCERPC_PKT_BIND ( 11 )
#define DCERPC_PKT_BIND_ACK ( 12 )
#define DCERPC_PKT_BIND_NAK ( 13 )
#define DCERPC_PKT_ALTER ( 14 )
#define DCERPC_PKT_ALTER_RESP ( 15 )
#define DCERPC_PKT_AUTH3 ( 16 )
#define DCERPC_PKT_SHUTDOWN ( 17 )
#define DCERPC_PKT_CO_CANCEL ( 18 )
#define DCERPC_PKT_ORPHANED ( 19 )
#endif
;
union dcerpc_payload {
struct dcerpc_request request;/* [case(DCERPC_PKT_REQUEST)] */
struct dcerpc_ping ping;/* [case(DCERPC_PKT_PING)] */
struct dcerpc_response response;/* [case(DCERPC_PKT_RESPONSE)] */
struct dcerpc_fault fault;/* [case(DCERPC_PKT_FAULT)] */
struct dcerpc_working working;/* [case(DCERPC_PKT_WORKING)] */
struct dcerpc_fack nocall;/* [case(DCERPC_PKT_NOCALL)] */
struct dcerpc_fault reject;/* [case(DCERPC_PKT_REJECT)] */
struct dcerpc_ack ack;/* [case(DCERPC_PKT_ACK)] */
struct dcerpc_cl_cancel cl_cancel;/* [case(DCERPC_PKT_CL_CANCEL)] */
struct dcerpc_fack fack;/* [case(DCERPC_PKT_FACK)] */
struct dcerpc_cancel_ack cancel_ack;/* [case(DCERPC_PKT_CANCEL_ACK)] */
struct dcerpc_bind bind;/* [case(DCERPC_PKT_BIND)] */
struct dcerpc_bind_ack bind_ack;/* [case(DCERPC_PKT_BIND_ACK)] */
struct dcerpc_bind_nak bind_nak;/* [case(DCERPC_PKT_BIND_NAK)] */
struct dcerpc_bind alter;/* [case(DCERPC_PKT_ALTER)] */
struct dcerpc_bind_ack alter_resp;/* [case(DCERPC_PKT_ALTER_RESP)] */
struct dcerpc_shutdown shutdown;/* [case(DCERPC_PKT_SHUTDOWN)] */
struct dcerpc_co_cancel co_cancel;/* [case(DCERPC_PKT_CO_CANCEL)] */
struct dcerpc_orphaned orphaned;/* [case(DCERPC_PKT_ORPHANED)] */
struct dcerpc_auth3 auth3;/* [case(DCERPC_PKT_AUTH3)] */
}/* [nodiscriminant] */;
struct ncacn_packet {
uint8_t rpc_vers;
uint8_t rpc_vers_minor;
enum dcerpc_pkt_type ptype;
uint8_t pfc_flags;
uint8_t drep[4];
uint16_t frag_length;
uint16_t auth_length;
uint32_t call_id;
union dcerpc_payload u;/* [switch_is(ptype)] */
}/* [public] */;
struct ncadg_packet {
uint8_t rpc_vers;
uint8_t ptype;
uint8_t pfc_flags;
uint8_t ncadg_flags;
uint8_t drep[3];
uint8_t serial_high;
struct GUID object;
struct GUID iface;
struct GUID activity;
uint32_t server_boot;
uint32_t iface_version;
uint32_t seq_num;
uint16_t opnum;
uint16_t ihint;
uint16_t ahint;
uint16_t len;
uint16_t fragnum;
uint8_t auth_proto;
uint8_t serial_low;
union dcerpc_payload u;/* [switch_is(ptype)] */
}/* [public] */;
#endif /* _HEADER_dcerpc */

1834
librpc/gen_ndr/ndr_dcerpc.c Normal file
View File

File diff suppressed because it is too large Load Diff

65
librpc/gen_ndr/ndr_dcerpc.h Normal file
View File

@ -0,0 +1,65 @@
/* header auto-generated by pidl */
#include "librpc/ndr/libndr.h"
#include "../librpc/gen_ndr/dcerpc.h"
#ifndef _HEADER_NDR_dcerpc
#define _HEADER_NDR_dcerpc
#define NDR_DCERPC_CALL_COUNT (0)
void ndr_print_dcerpc_ctx_list(struct ndr_print *ndr, const char *name, const struct dcerpc_ctx_list *r);
void ndr_print_dcerpc_bind(struct ndr_print *ndr, const char *name, const struct dcerpc_bind *r);
void ndr_print_dcerpc_empty(struct ndr_print *ndr, const char *name, const struct dcerpc_empty *r);
void ndr_print_dcerpc_object(struct ndr_print *ndr, const char *name, const union dcerpc_object *r);
void ndr_print_dcerpc_request(struct ndr_print *ndr, const char *name, const struct dcerpc_request *r);
void ndr_print_dcerpc_ack_ctx(struct ndr_print *ndr, const char *name, const struct dcerpc_ack_ctx *r);
void ndr_print_dcerpc_bind_ack(struct ndr_print *ndr, const char *name, const struct dcerpc_bind_ack *r);
void ndr_print_dcerpc_bind_nak_versions(struct ndr_print *ndr, const char *name, const struct dcerpc_bind_nak_versions *r);
void ndr_print_dcerpc_bind_nak_versions_ctr(struct ndr_print *ndr, const char *name, const union dcerpc_bind_nak_versions_ctr *r);
void ndr_print_dcerpc_bind_nak(struct ndr_print *ndr, const char *name, const struct dcerpc_bind_nak *r);
void ndr_print_dcerpc_response(struct ndr_print *ndr, const char *name, const struct dcerpc_response *r);
void ndr_print_dcerpc_fault(struct ndr_print *ndr, const char *name, const struct dcerpc_fault *r);
void ndr_print_dcerpc_AuthType(struct ndr_print *ndr, const char *name, enum dcerpc_AuthType r);
void ndr_print_dcerpc_AuthLevel(struct ndr_print *ndr, const char *name, enum dcerpc_AuthLevel r);
enum ndr_err_code ndr_push_dcerpc_auth(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_auth *r);
enum ndr_err_code ndr_pull_dcerpc_auth(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_auth *r);
void ndr_print_dcerpc_auth(struct ndr_print *ndr, const char *name, const struct dcerpc_auth *r);
enum ndr_err_code ndr_push_dcerpc_auth3(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_auth3 *r);
enum ndr_err_code ndr_pull_dcerpc_auth3(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_auth3 *r);
void ndr_print_dcerpc_auth3(struct ndr_print *ndr, const char *name, const struct dcerpc_auth3 *r);
enum ndr_err_code ndr_push_dcerpc_orphaned(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_orphaned *r);
enum ndr_err_code ndr_pull_dcerpc_orphaned(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_orphaned *r);
void ndr_print_dcerpc_orphaned(struct ndr_print *ndr, const char *name, const struct dcerpc_orphaned *r);
enum ndr_err_code ndr_push_dcerpc_co_cancel(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_co_cancel *r);
enum ndr_err_code ndr_pull_dcerpc_co_cancel(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_co_cancel *r);
void ndr_print_dcerpc_co_cancel(struct ndr_print *ndr, const char *name, const struct dcerpc_co_cancel *r);
enum ndr_err_code ndr_push_dcerpc_cl_cancel(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_cl_cancel *r);
enum ndr_err_code ndr_pull_dcerpc_cl_cancel(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_cl_cancel *r);
void ndr_print_dcerpc_cl_cancel(struct ndr_print *ndr, const char *name, const struct dcerpc_cl_cancel *r);
enum ndr_err_code ndr_push_dcerpc_cancel_ack(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_cancel_ack *r);
enum ndr_err_code ndr_pull_dcerpc_cancel_ack(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_cancel_ack *r);
void ndr_print_dcerpc_cancel_ack(struct ndr_print *ndr, const char *name, const struct dcerpc_cancel_ack *r);
enum ndr_err_code ndr_push_dcerpc_fack(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_fack *r);
enum ndr_err_code ndr_pull_dcerpc_fack(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_fack *r);
void ndr_print_dcerpc_fack(struct ndr_print *ndr, const char *name, const struct dcerpc_fack *r);
enum ndr_err_code ndr_push_dcerpc_ack(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_ack *r);
enum ndr_err_code ndr_pull_dcerpc_ack(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_ack *r);
void ndr_print_dcerpc_ack(struct ndr_print *ndr, const char *name, const struct dcerpc_ack *r);
enum ndr_err_code ndr_push_dcerpc_ping(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_ping *r);
enum ndr_err_code ndr_pull_dcerpc_ping(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_ping *r);
void ndr_print_dcerpc_ping(struct ndr_print *ndr, const char *name, const struct dcerpc_ping *r);
enum ndr_err_code ndr_push_dcerpc_shutdown(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_shutdown *r);
enum ndr_err_code ndr_pull_dcerpc_shutdown(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_shutdown *r);
void ndr_print_dcerpc_shutdown(struct ndr_print *ndr, const char *name, const struct dcerpc_shutdown *r);
enum ndr_err_code ndr_push_dcerpc_working(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_working *r);
enum ndr_err_code ndr_pull_dcerpc_working(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_working *r);
void ndr_print_dcerpc_working(struct ndr_print *ndr, const char *name, const struct dcerpc_working *r);
void ndr_print_dcerpc_pkt_type(struct ndr_print *ndr, const char *name, enum dcerpc_pkt_type r);
void ndr_print_dcerpc_payload(struct ndr_print *ndr, const char *name, const union dcerpc_payload *r);
enum ndr_err_code ndr_push_ncacn_packet(struct ndr_push *ndr, int ndr_flags, const struct ncacn_packet *r);
enum ndr_err_code ndr_pull_ncacn_packet(struct ndr_pull *ndr, int ndr_flags, struct ncacn_packet *r);
void ndr_print_ncacn_packet(struct ndr_print *ndr, const char *name, const struct ncacn_packet *r);
enum ndr_err_code ndr_push_ncadg_packet(struct ndr_push *ndr, int ndr_flags, const struct ncadg_packet *r);
enum ndr_err_code ndr_pull_ncadg_packet(struct ndr_pull *ndr, int ndr_flags, struct ncadg_packet *r);
void ndr_print_ncadg_packet(struct ndr_print *ndr, const char *name, const struct ncadg_packet *r);
#endif /* _HEADER_NDR_dcerpc */

10
source4/librpc/idl/dcerpc.idl → librpc/idl/dcerpc.idl
View File

@ -33,7 +33,7 @@ interface dcerpc
typedef struct {
} dcerpc_empty;
typedef [nodiscriminant] union {
[default] dcerpc_empty empty;
[case(LIBNDR_FLAG_OBJECT_PRESENT)] GUID object;
@ -75,7 +75,7 @@ interface dcerpc
uint32 num_versions;
uint32 versions[num_versions];
} dcerpc_bind_nak_versions;
typedef [nodiscriminant] union {
[case(DECRPC_BIND_PROTOCOL_VERSION_NOT_SUPPORTED)] dcerpc_bind_nak_versions v;
[default] ;
@ -145,7 +145,7 @@ interface dcerpc
const uint8 DCERPC_AUTH_LEVEL_DEFAULT = DCERPC_AUTH_LEVEL_CONNECT;
typedef [public] struct {
dcerpc_AuthType auth_type;
dcerpc_AuthType auth_type;
dcerpc_AuthLevel auth_level;
uint8 auth_pad_length;
uint8 auth_reserved;
@ -176,7 +176,7 @@ interface dcerpc
} dcerpc_cl_cancel;
typedef [public] struct {
uint32 version;
uint32 version;
uint32 id;
boolean32 server_is_accepting;
} dcerpc_cancel_ack;
@ -200,7 +200,7 @@ interface dcerpc
typedef [public] struct {
} dcerpc_shutdown;
typedef [public] struct {
} dcerpc_working;

16
selftest/SocketWrapper.pm
View File

@ -1,7 +1,21 @@
#!/usr/bin/perl
# Bootstrap Samba and run a number of tests against it.
# Copyright (C) 2005-2007 Jelmer Vernooij <jelmer@samba.org>
# Published under the GNU GPL, v3 or later.
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
package SocketWrapper;

16
selftest/Subunit.pm
View File

@ -1,3 +1,19 @@
# Simple Perl module for parsing the Subunit protocol
# Copyright (C) 2008 Jelmer Vernooij <jelmer@samba.org>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
package Subunit;
require Exporter;

15
selftest/output/buildfarm.pm
View File

@ -1,4 +1,19 @@
#!/usr/bin/perl
# Buildfarm output for selftest
# Copyright (C) 2008 Jelmer Vernooij <jelmer@samba.org>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
package output::buildfarm;

14
selftest/output/html.pm
View File

@ -1,5 +1,19 @@
#!/usr/bin/perl
# HTML output for selftest
# Copyright (C) 2008 Jelmer Vernooij <jelmer@samba.org>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
package output::html;
use Exporter;
@ISA = qw(Exporter);

14
selftest/output/plain.pm
View File

@ -1,5 +1,19 @@
#!/usr/bin/perl
# Plain text output for selftest
# Copyright (C) 2008 Jelmer Vernooij <jelmer@samba.org>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
package output::plain;
use Exporter;
@ISA = qw(Exporter);

14
selftest/selftest.pl
View File

@ -2,7 +2,19 @@
# Bootstrap Samba and run a number of tests against it.
# Copyright (C) 2005-2008 Jelmer Vernooij <jelmer@samba.org>
# Copyright (C) 2007-2009 Stefan Metzmacher <metze@samba.org>
# Published under the GNU GPL, v3 or later.
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
=pod

38
selftest/target/Samba3.pm
View File

@ -41,6 +41,9 @@ sub teardown_env($$)
$self->stop_sig_term($smbdpid);
$self->stop_sig_term($nmbdpid);
$self->stop_sig_term($winbinddpid);
sleep(2);
$self->stop_sig_kill($smbdpid);
$self->stop_sig_kill($nmbdpid);
$self->stop_sig_kill($winbinddpid);
@ -123,9 +126,8 @@ sub setup_dc($$)
$dc_options);
$self->check_or_start($vars,
($ENV{NMBD_MAXTIME} or 2700),
($ENV{WINBINDD_MAXTIME} or 2700),
($ENV{SMBD_MAXTIME} or 2700));
($ENV{SMBD_MAXTIME} or 2700),
"yes", "yes", "yes");
$self->wait_for_start($vars);
@ -142,6 +144,7 @@ sub setup_member($$$)
my $member_options = "
security = domain
server signing = on
";
my $ret = $self->provision($prefix,
"LOCALMEMBER3",
@ -160,9 +163,8 @@ sub setup_member($$$)
system($cmd) == 0 or die("Join failed\n$cmd");
$self->check_or_start($ret,
($ENV{NMBD_MAXTIME} or 2700),
($ENV{WINBINDD_MAXTIME} or 2700),
($ENV{SMBD_MAXTIME} or 2700));
($ENV{SMBD_MAXTIME} or 2700),
"yes", "yes", "yes");
$self->wait_for_start($ret);
@ -187,7 +189,7 @@ sub stop_sig_term($$) {
sub stop_sig_kill($$) {
my ($self, $pid) = @_;
kill("KILL", $pid) or warn("Unable to kill $pid: $!");
kill("ALRM", $pid) or warn("Unable to kill $pid: $!");
}
sub write_pid($$$)
@ -209,8 +211,8 @@ sub read_pid($$)
return $pid;
}
sub check_or_start($$$$) {
my ($self, $env_vars, $nmbd_maxtime, $winbindd_maxtime, $smbd_maxtime) = @_;
sub check_or_start($$$$$) {
my ($self, $env_vars, $maxtime, $nmbd, $winbindd, $smbd) = @_;
unlink($env_vars->{NMBD_TEST_LOG});
print "STARTING NMBD...";
@ -226,13 +228,13 @@ sub check_or_start($$$$) {
$ENV{NSS_WRAPPER_PASSWD} = $env_vars->{NSS_WRAPPER_PASSWD};
$ENV{NSS_WRAPPER_GROUP} = $env_vars->{NSS_WRAPPER_GROUP};
if ($nmbd_maxtime eq "skip") {
if ($nmbd ne "yes") {
$SIG{USR1} = $SIG{ALRM} = $SIG{INT} = $SIG{QUIT} = $SIG{TERM} = sub {
my $signame = shift;
print("Skip nmbd received signal $signame");
exit 0;
};
sleep(999999);
sleep($maxtime);
exit 0;
}
@ -243,7 +245,7 @@ sub check_or_start($$$$) {
$ENV{MAKE_TEST_BINARY} = $self->binpath("nmbd");
my @preargs = ($self->binpath("timelimit"), $nmbd_maxtime);
my @preargs = ($self->binpath("timelimit"), $maxtime);
if(defined($ENV{NMBD_VALGRIND})) {
@preargs = split(/ /, $ENV{NMBD_VALGRIND});
}
@ -267,13 +269,13 @@ sub check_or_start($$$$) {
$ENV{NSS_WRAPPER_PASSWD} = $env_vars->{NSS_WRAPPER_PASSWD};
$ENV{NSS_WRAPPER_GROUP} = $env_vars->{NSS_WRAPPER_GROUP};
if ($winbindd_maxtime eq "skip") {
if ($winbindd ne "yes") {
$SIG{USR1} = $SIG{ALRM} = $SIG{INT} = $SIG{QUIT} = $SIG{TERM} = sub {
my $signame = shift;
print("Skip winbindd received signal $signame");
exit 0;
};
sleep(999999);
sleep($maxtime);
exit 0;
}
@ -284,7 +286,7 @@ sub check_or_start($$$$) {
$ENV{MAKE_TEST_BINARY} = $self->binpath("winbindd");
my @preargs = ($self->binpath("timelimit"), $winbindd_maxtime);
my @preargs = ($self->binpath("timelimit"), $maxtime);
if(defined($ENV{WINBINDD_VALGRIND})) {
@preargs = split(/ /, $ENV{WINBINDD_VALGRIND});
}
@ -308,13 +310,13 @@ sub check_or_start($$$$) {
$ENV{NSS_WRAPPER_PASSWD} = $env_vars->{NSS_WRAPPER_PASSWD};
$ENV{NSS_WRAPPER_GROUP} = $env_vars->{NSS_WRAPPER_GROUP};
if ($smbd_maxtime eq "skip") {
if ($smbd ne "yes") {
$SIG{USR1} = $SIG{ALRM} = $SIG{INT} = $SIG{QUIT} = $SIG{TERM} = sub {
my $signame = shift;
print("Skip smbd received signal $signame");
exit 0;
};
sleep(999999);
sleep($maxtime);
exit 0;
}
@ -323,7 +325,7 @@ sub check_or_start($$$$) {
if (defined($ENV{SMBD_OPTIONS})) {
@optargs = split(/ /, $ENV{SMBD_OPTIONS});
}
my @preargs = ($self->binpath("timelimit"), $smbd_maxtime);
my @preargs = ($self->binpath("timelimit"), $maxtime);
if(defined($ENV{SMBD_VALGRIND})) {
@preargs = split(/ /,$ENV{SMBD_VALGRIND});
}

8
selftest/target/Samba4.pm
View File

@ -103,8 +103,8 @@ sub check_or_start($$$)
SocketWrapper::set_default_iface($env_vars->{SOCKET_WRAPPER_DEFAULT_IFACE});
my $valgrind = "";
if (defined($ENV{SMBD_VALGRIND})) {
$valgrind = $ENV{SMBD_VALGRIND};
if (defined($ENV{SAMBA_VALGRIND})) {
$valgrind = $ENV{SAMBA_VALGRIND};
}
$ENV{KRB5_CONFIG} = $env_vars->{KRB5_CONFIG};
@ -122,8 +122,8 @@ sub check_or_start($$$)
if (defined($max_time)) {
$optarg = "--maximum-runtime=$max_time ";
}
if (defined($ENV{SMBD_OPTIONS})) {
$optarg.= " $ENV{SMBD_OPTIONS}";
if (defined($ENV{SAMBA_OPTIONS})) {
$optarg.= " $ENV{SAMBA_OPTIONS}";
}
my $samba = $self->bindir_path("samba");
my $ret = system("$valgrind $samba $optarg $env_vars->{CONFIGURATION} -M single -i --leak-report-full");

63
source3/Makefile.in
View File

@ -73,6 +73,7 @@ WINBIND_NSS_EXTRA_LIBS=@WINBIND_NSS_EXTRA_LIBS@
WINBIND_NSS_PTHREAD=@WINBIND_NSS_PTHREAD@
PAM_WINBIND_EXTRA_LIBS=@PAM_WINBIND_EXTRA_LIBS@
DNSSD_LIBS=@DNSSD_LIBS@
AVAHI_LIBS=@AVAHI_LIBS@
POPT_LIBS=@POPTLIBS@
LIBTALLOC_LIBS=@LIBTALLOC_LIBS@
LIBTDB_LIBS=@LIBTDB_LIBS@
@ -158,7 +159,7 @@ CODEPAGEDIR = @codepagedir@
# the directory where pid files go
PIDDIR = @piddir@
FLAGS = -I. -I$(srcdir) @FLAGS1@ @SAMBA_CPPFLAGS@ $(CPPFLAGS) -I$(CTDBDIR)/include $(ISA) -I$(srcdir)/lib -I.. -D_SAMBA_BUILD_=3 -I../source4
FLAGS = -I. -I$(srcdir) @FLAGS1@ @SAMBA_CPPFLAGS@ $(CPPFLAGS) $(ISA) -I$(srcdir)/lib -I.. -D_SAMBA_BUILD_=3 -I../source4
PATH_FLAGS = -DSMB_PASSWD_FILE=\"$(SMB_PASSWD_FILE)\" \
-DPRIVATE_DIR=\"$(PRIVATE_DIR)\" \
@ -173,7 +174,6 @@ PATH_FLAGS = -DSMB_PASSWD_FILE=\"$(SMB_PASSWD_FILE)\" \
-DMODULESDIR=\"$(MODULESDIR)\" \
-DLOGFILEBASE=\"$(LOGFILEBASE)\" \
-DSHLIBEXT=\"@SHLIBEXT@\" \
-DCTDBDIR=\"$(CTDBDIR)\" \
-DNCALRPCDIR=\"$(NCALRPCDIR)\" \
-DCONFIGDIR=\"$(CONFIGDIR)\" \
-DCODEPAGEDIR=\"$(CODEPAGEDIR)\" \
@ -255,6 +255,8 @@ AFS_OBJ = lib/afs.o
AFS_SETTOKEN_OBJ = lib/afs_settoken.o
AVAHI_OBJ = @AVAHI_OBJ@
SERVER_MUTEX_OBJ = lib/server_mutex.o
PASSCHANGE_OBJ = libsmb/passchange.o
@ -282,7 +284,8 @@ LIBNDR_OBJ = ../librpc/ndr/ndr_basic.o \
../librpc/ndr/ndr_sec_helper.o \
librpc/ndr/ndr_string.o \
../librpc/ndr/uuid.o \
librpc/ndr/util.o
librpc/ndr/util.o \
../librpc/gen_ndr/ndr_dcerpc.o
RPCCLIENT_NDR_OBJ = rpc_client/ndr.o
@ -316,7 +319,7 @@ RPC_PARSE_OBJ0 = rpc_parse/parse_prs.o rpc_parse/parse_misc.o
# this includes only the low level parse code, not stuff
# that requires knowledge of security contexts
RPC_PARSE_OBJ1 = $(RPC_PARSE_OBJ0) rpc_parse/parse_sec.o
RPC_PARSE_OBJ1 = $(RPC_PARSE_OBJ0)
RPC_PARSE_OBJ2 = rpc_parse/parse_rpc.o \
rpc_client/init_netlogon.o \
@ -364,7 +367,8 @@ LIB_OBJ = $(LIBSAMBAUTIL_OBJ) $(UTIL_OBJ) $(CRYPTO_OBJ) \
lib/util.o lib/util_sock.o lib/sock_exec.o lib/util_sec.o \
lib/substitute.o lib/dbwrap_util.o \
lib/ms_fnmatch.o lib/select.o lib/errmap_unix.o \
lib/tallocmsg.o lib/dmallocmsg.o libsmb/smb_signing.o \
lib/tallocmsg.o lib/dmallocmsg.o \
libsmb/clisigning.o libsmb/smb_signing.o \
lib/iconv.o lib/pam_errors.o intl/lang_tdb.o \
lib/conn_tdb.o lib/adt_tree.o lib/gencache.o \
lib/module.o lib/events.o @LIBTEVENT_OBJ0@ \
@ -687,6 +691,7 @@ VFS_ONEFS_OBJ = modules/vfs_onefs.o modules/onefs_acl.o modules/onefs_system.o \
VFS_ONEFS_SHADOW_COPY_OBJ = modules/vfs_onefs_shadow_copy.o modules/onefs_shadow_copy.o
PERFCOUNT_ONEFS_OBJ = modules/perfcount_onefs.o
PERFCOUNT_TEST_OBJ = modules/perfcount_test.o
VFS_DIRSORT_OBJ = modules/vfs_dirsort.o
PLAINTEXT_AUTH_OBJ = auth/pampass.o auth/pass_check.o
@ -731,7 +736,7 @@ SMBD_OBJ_SRV = smbd/files.o smbd/chgpasswd.o smbd/connection.o \
smbd/change_trust_pw.o smbd/fake_file.o \
smbd/quotas.o smbd/ntquotas.o $(AFS_OBJ) smbd/msdfs.o \
$(AFS_SETTOKEN_OBJ) smbd/aio.o smbd/statvfs.o \
smbd/dmapi.o \
smbd/dmapi.o smbd/signing.o \
smbd/file_access.o \
smbd/dnsregister.o smbd/globals.o \
$(MANGLE_OBJ) @VFS_STATIC@
@ -741,7 +746,7 @@ SMBD_OBJ_BASE = $(PARAM_WITHOUT_REG_OBJ) $(SMBD_OBJ_SRV) $(LIBSMB_OBJ) \
$(LOCKING_OBJ) $(PASSDB_OBJ) $(PRINTING_OBJ) $(PROFILE_OBJ) \
$(LIB_OBJ) $(PRINTBACKEND_OBJ) $(OPLOCK_OBJ) \
$(NOTIFY_OBJ) $(GROUPDB_OBJ) $(AUTH_OBJ) \
$(LIBMSRPC_OBJ) $(LIBMSRPC_GEN_OBJ) \
$(LIBMSRPC_OBJ) $(LIBMSRPC_GEN_OBJ) $(AVAHI_OBJ) \
$(LIBADS_OBJ) $(KRBCLIENT_OBJ) $(LIBADS_SERVER_OBJ) \
$(REG_FULL_OBJ) $(POPT_LIB_OBJ) $(BUILDOPT_OBJ) \
$(SMBLDAP_OBJ) $(LDB_OBJ) $(LIBNET_OBJ) @LIBWBCLIENT_STATIC@ \
@ -826,7 +831,7 @@ PDBEDIT_OBJ = utils/pdbedit.o $(PASSWD_UTIL_OBJ) $(PARAM_OBJ) $(PASSDB_OBJ) @LIB
SMBGET_OBJ = utils/smbget.o $(POPT_LIB_OBJ) $(LIBSMBCLIENT_OBJ1) @LIBWBCLIENT_STATIC@
DISPLAY_SEC_OBJ= lib/display_sec.o
DISPLAY_SEC_OBJ= ../libcli/security/display_sec.o
RPCCLIENT_OBJ1 = rpcclient/rpcclient.o rpcclient/cmd_lsarpc.o \
rpcclient/cmd_samr.o rpcclient/cmd_spoolss.o \
@ -1277,6 +1282,10 @@ everything:: all libtalloc libsmbclient libnetapi debug2html smbfilter talloctor
.SUFFIXES:
.SUFFIXES: .c .o .lo
.PHONY: showflags SHOWFLAGS
showflags: SHOWFLAGS
SHOWFLAGS::
@echo "Using CFLAGS = $(CFLAGS)"
@echo " PICFLAG = $(PICFLAG)"
@ -1385,7 +1394,7 @@ bin/smbd@EXEEXT@: $(BINARY_PREREQS) $(SMBD_OBJ) @LIBTALLOC_SHARED@ @LIBTDB_SHARE
@echo Linking $@
@$(CC) -o $@ $(SMBD_OBJ) $(LDFLAGS) $(LDAP_LIBS) \
$(KRB5LIBS) $(DYNEXP) $(PRINT_LIBS) $(AUTH_LIBS) \
$(ACL_LIBS) $(PASSDB_LIBS) $(LIBS) $(DNSSD_LIBS) \
$(ACL_LIBS) $(PASSDB_LIBS) $(LIBS) $(DNSSD_LIBS) $(AVAHI_LIBS) \
$(POPT_LIBS) @SMBD_LIBS@ $(LIBTALLOC_LIBS) $(LIBTDB_LIBS) \
$(WINBIND_LIBS) $(ZLIB_LIBS)
@ -1433,19 +1442,19 @@ bin/smbspool@EXEEXT@: $(BINARY_PREREQS) $(CUPS_OBJ) @BUILD_POPT@ @LIBTALLOC_SHAR
@$(CC) -o $@ $(CUPS_OBJ) $(DYNEXP) $(LDFLAGS) $(LIBS) \
$(KRB5LIBS) $(LDAP_LIBS) $(POPT_LIBS) $(LIBTALLOC_LIBS) $(LIBTDB_LIBS) $(ZLIB_LIBS)
bin/mount.cifs@EXEEXT@: $(BINARY_PREREQS) $(CIFS_MOUNT_OBJ) @BUILD_POPT@
bin/mount.cifs@EXEEXT@: $(BINARY_PREREQS) $(CIFS_MOUNT_OBJ)
@echo Linking $@
@$(CC) -o $@ $(CIFS_MOUNT_OBJ) $(DYNEXP) $(LDFLAGS) $(POPT_LIBS)
@$(CC) -o $@ $(CIFS_MOUNT_OBJ) $(DYNEXP) $(LDFLAGS)
bin/umount.cifs@EXEEXT@: $(BINARY_PREREQS) $(CIFS_UMOUNT_OBJ) @BUILD_POPT@
bin/umount.cifs@EXEEXT@: $(BINARY_PREREQS) $(CIFS_UMOUNT_OBJ)
@echo Linking $@
@$(CC) -o $@ $(CIFS_UMOUNT_OBJ) $(DYNEXP) $(LDFLAGS) $(POPT_LIBS)
@$(CC) -o $@ $(CIFS_UMOUNT_OBJ) $(DYNEXP) $(LDFLAGS)
bin/cifs.upcall@EXEEXT@: $(BINARY_PREREQS) $(CIFS_UPCALL_OBJ) $(LIBSMBCLIENT_OBJ1) @BUILD_POPT@ @LIBTALLOC_SHARED@ @LIBTDB_SHARED@ @LIBWBCLIENT_SHARED@
bin/cifs.upcall@EXEEXT@: $(BINARY_PREREQS) $(CIFS_UPCALL_OBJ) $(LIBSMBCLIENT_OBJ1) @LIBTALLOC_SHARED@ @LIBTDB_SHARED@ @LIBWBCLIENT_SHARED@
@echo Linking $@
@$(CC) -o $@ $(CIFS_UPCALL_OBJ) $(DYNEXP) $(LDFLAGS) \
-lkeyutils $(LIBS) $(LIBSMBCLIENT_OBJ1) $(KRB5LIBS) \
$(LDAP_LIBS) $(POPT_LIBS) $(LIBTALLOC_LIBS) $(WINBIND_LIBS) \
$(LDAP_LIBS) $(LIBTALLOC_LIBS) $(WINBIND_LIBS) \
$(LIBTDB_LIBS) $(NSCD_LIBS)
bin/testparm@EXEEXT@: $(BINARY_PREREQS) $(TESTPARM_OBJ) @BUILD_POPT@ @LIBTALLOC_SHARED@ @LIBTDB_SHARED@
@ -1571,7 +1580,7 @@ bin/pdbtest@EXEEXT@: $(BINARY_PREREQS) $(PDBTEST_OBJ) @BUILD_POPT@ @LIBTALLOC_SH
bin/vfstest@EXEEXT@: $(BINARY_PREREQS) $(VFSTEST_OBJ) @BUILD_POPT@ @LIBTALLOC_SHARED@ @LIBTDB_SHARED@ @LIBWBCLIENT_SHARED@
@echo Linking $@
@$(CC) -o $@ $(VFSTEST_OBJ) $(LDFLAGS) $(TERMLDFLAGS) \
@$(CC) -o $@ $(VFSTEST_OBJ) $(LDFLAGS) $(TERMLDFLAGS) $(AVAHI_LIBS) \
$(TERMLIBS) $(DYNEXP) $(PRINT_LIBS) $(AUTH_LIBS) $(DNSSD_LIBS) \
$(ACL_LIBS) $(LIBS) $(POPT_LIBS) $(KRB5LIBS) $(LDAP_LIBS) \
@SMBD_LIBS@ $(NSCD_LIBS) $(LIBTALLOC_LIBS) $(LIBTDB_LIBS) \
@ -1609,37 +1618,37 @@ bin/ldbedit: $(BINARY_PREREQS) $(LDBEDIT_OBJ) @BUILD_POPT@ @LIBTALLOC_SHARED@ @L
@echo Linking $@
@$(CC) -o $@ $(LDBEDIT_OBJ) $(DYNEXP) $(LDFLAGS) \
$(LIBS) $(POPT_LIBS) $(LDAP_LIBS) \
$(LIBTALLOC_LIBS) $(LIBTDB_LIBS) $(WINBIND_LIBS)
$(LIBTALLOC_LIBS) $(LIBTDB_LIBS)
bin/ldbsearch: $(BINARY_PREREQS) $(LDBSEARCH_OBJ) @BUILD_POPT@ @LIBTALLOC_SHARED@ @LIBTDB_SHARED@ @LIBWBCLIENT_SHARED@
@echo Linking $@
@$(CC) -o $@ $(LDBSEARCH_OBJ) $(DYNEXP) $(LDFLAGS) \
$(LIBS) $(POPT_LIBS) $(LDAP_LIBS) \
$(LIBTALLOC_LIBS) $(LIBTDB_LIBS) $(WINBIND_LIBS)
$(LIBTALLOC_LIBS) $(LIBTDB_LIBS)
bin/ldbadd: $(BINARY_PREREQS) $(LDBADD_OBJ) @BUILD_POPT@ @LIBTALLOC_SHARED@ @LIBTDB_SHARED@ @LIBWBCLIENT_SHARED@
@echo Linking $@
@$(CC) -o $@ $(LDBADD_OBJ) $(DYNEXP) $(LDFLAGS) \
$(LIBS) $(POPT_LIBS) $(LDAP_LIBS) \
$(LIBTALLOC_LIBS) $(LIBTDB_LIBS) $(WINBIND_LIBS)
$(LIBTALLOC_LIBS) $(LIBTDB_LIBS)
bin/ldbmodify: $(BINARY_PREREQS) $(LDBMODIFY_OBJ) @BUILD_POPT@ @LIBTALLOC_SHARED@ @LIBTDB_SHARED@ @LIBWBCLIENT_SHARED@
@echo Linking $@
@$(CC) -o $@ $(LDBMODIFY_OBJ) $(DYNEXP) $(LDFLAGS) \
$(LIBS) $(POPT_LIBS) $(LDAP_LIBS) \
$(LIBTALLOC_LIBS) $(LIBTDB_LIBS) $(WINBIND_LIBS)
$(LIBTALLOC_LIBS) $(LIBTDB_LIBS)
bin/ldbdel: $(BINARY_PREREQS) $(LDBDEL_OBJ) @BUILD_POPT@ @LIBTALLOC_SHARED@ @LIBTDB_SHARED@ @LIBWBCLIENT_SHARED@
@echo Linking $@
@$(CC) -o $@ $(LDBDEL_OBJ) $(DYNEXP) $(LDFLAGS) \
$(LIBS) $(POPT_LIBS) $(LDAP_LIBS) \
$(LIBTALLOC_LIBS) $(LIBTDB_LIBS) $(WINBIND_LIBS)
$(LIBTALLOC_LIBS) $(LIBTDB_LIBS)
bin/ldbrename: $(BINARY_PREREQS) $(LDBRENAME_OBJ) @BUILD_POPT@ @LIBTALLOC_SHARED@ @LIBTDB_SHARED@ @LIBWBCLIENT_SHARED@
@echo Linking $@
@$(CC) $(FLAGS) -o $@ $(LDBRENAME_OBJ) $(DYNEXP) $(LDFLAGS) \
$(LIBS) $(POPT_LIBS) $(LDAP_LIBS) \
$(LIBTALLOC_LIBS) $(LIBTDB_LIBS) $(WINBIND_LIBS)
$(LIBTALLOC_LIBS) $(LIBTDB_LIBS)
bin/versiontest: $(BINARY_PREREQS) lib/version_test.o $(VERSION_OBJ)
@echo Linking $@
@ -2625,6 +2634,10 @@ bin/security.@SHLIBEXT@: $(BINARY_PREREQS) libgpo/gpext/security.o
@echo "Building plugin $@"
@$(SHLD_MODULE) libgpo/gpext/security.o
bin/dirsort.@SHLIBEXT@: $(BINARY_PREREQS) $(VFS_DIRSORT_OBJ)
@echo "Building plugin $@"
@$(SHLD_MODULE) $(VFS_DIRSORT_OBJ)
#########################################################
## IdMap NSS plugins
@ -2648,7 +2661,7 @@ bin/ntlm_auth@EXEEXT@: $(BINARY_PREREQS) $(NTLM_AUTH_OBJ) $(PARAM_OBJ) \
bin/pam_smbpass.@SHLIBEXT@: $(BINARY_PREREQS) $(PAM_SMBPASS_OBJ) @LIBTALLOC_SHARED@ @LIBWBCLIENT_SHARED@ @LIBTDB_SHARED@
@echo "Linking shared library $@"
@$(SHLD) $(LDSHFLAGS) -o $@ $(PAM_SMBPASS_OBJ) -lpam $(DYNEXP) \
$(LIBS) $(LDAP_LIBS) $(KRB5LIBS) $(NSCD_LIBS) \
$(LIBS) $(LDAP_LIBS) $(NSCD_LIBS) \
$(LIBTALLOC_LIBS) $(LIBTDB_LIBS) $(WINBIND_LIBS)
bin/tdbbackup@EXEEXT@: $(BINARY_PREREQS) $(TDBBACKUP_OBJ) @LIBTALLOC_SHARED@ @LIBTDB_SHARED@
@ -2893,10 +2906,10 @@ include/build_env.h: script/build_env.sh
proto::
etags::
find $(srcdir)/.. -name "*.[ch]" | xargs -n 100 etags --append
find $(srcdir)/.. -name "*.[ch]" | xargs -n 100 etags --append $(ETAGS_OPTIONS)
ctags::
ctags `find $(srcdir)/.. -name "*.[ch]" | grep -v include/proto\.h`
ctags $(CTAGS_OPTIONS) `find $(srcdir)/.. -name "*.[ch]" | grep -v include/proto\.h`
realclean:: clean
-rm -f config.log bin/.dummy script/findsmb script/gen-8bit-gap.sh

51
source3/configure.in
View File

@ -152,13 +152,11 @@ AC_SUBST(NSCD_LIBS)
# do this here since AC_CACHE_CHECK apparently sets the CFLAGS to "-g -O2"
# if it has no value. This prevent *very* large debug binaries from occurring
# by default.
if test "x$CFLAGS" = x; then
CFLAGS="-O"
fi
if test "x$debug" = "xyes" ; then
CFLAGS="${CFLAGS} -g"
else
CFLAGS="${CFLAGS} -O"
fi
if test "x$CFLAGS" = x; then
CFLAGS="-O"
fi
m4_include(../lib/socket_wrapper/config.m4)
@ -879,7 +877,7 @@ fi
AC_CHECK_FUNCS(dirfd)
if test x"$ac_cv_func_dirfd" = x"yes"; then
default_shared_modules="$default_shared_modules vfs_syncops"
default_shared_modules="$default_shared_modules vfs_syncops vfs_dirsort"
fi
AC_CACHE_CHECK([for struct sigevent type],samba_cv_struct_sigevent, [
@ -5975,10 +5973,10 @@ AC_SUBST(FLAGS1)
# Check if user wants DNS service discovery support
AC_ARG_ENABLE(dnssd,
[AS_HELP_STRING([--enable-dnssd], [Enable DNS service discovery support (default=auto)])])
[AS_HELP_STRING([--enable-dnssd], [Enable DNS service discovery support (default=no)])])
AC_SUBST(DNSSD_LIBS)
if test x"$enable_dnssd" != x"no"; then
if test x"$enable_dnssd" == x"yes"; then
have_dnssd_support=yes
AC_CHECK_HEADERS(dns_sd.h)
@ -6006,6 +6004,42 @@ if test x"$enable_dnssd" != x"no"; then
fi
#################################################
# Check if user wants avahi support
AC_ARG_ENABLE(avahi,
[AS_HELP_STRING([--enable-avahi], [Enable Avahi support (default=auto)])])
AC_SUBST(AVAHI_LIBS)
if test x"$enable_avahi" != x"no"; then
have_avahi_support=yes
AC_CHECK_HEADERS(avahi-common/watch.h)
if test x"$ac_cv_header_avahi_common_watch_h" != x"yes"; then
have_avahi_support=no
fi
AC_CHECK_HEADERS(avahi-client/client.h)
if test x"$ac_cv_header_avahi_common_watch_h" != x"yes"; then
have_avahi_support=no
fi
AC_CHECK_LIB_EXT(avahi-client, AVAHI_LIBS, avahi_client_new)
if test x"$ac_cv_lib_ext_avahi_client_avahi_client_new" != x"yes"; then
have_avahi_support=no
fi
if test x"$have_avahi_support" = x"yes"; then
AC_DEFINE(WITH_AVAHI_SUPPORT, 1,
[Whether to enable avahi support])
AC_SUBST(AVAHI_OBJ, "lib/avahi.o smbd/avahi_register.o")
else
if test x"$enable_avahi" = x"yes"; then
AC_MSG_ERROR(avahi support not available)
fi
fi
fi
#################################################
# Check to see if we should use the included iniparser
@ -6213,6 +6247,7 @@ SMB_MODULE(vfs_acl_tdb, \$(VFS_ACL_TDB_OBJ), "bin/acl_tdb.$SHLIBEXT", VFS)
SMB_MODULE(vfs_smb_traffic_analyzer, \$(VFS_SMB_TRAFFIC_ANALYZER_OBJ), "bin/smb_traffic_analyzer.$SHLIBEXT", VFS)
SMB_MODULE(vfs_onefs, \$(VFS_ONEFS), "bin/onefs.$SHLIBEXT", VFS)
SMB_MODULE(vfs_onefs_shadow_copy, \$(VFS_ONEFS_SHADOW_COPY), "bin/onefs_shadow_copy.$SHLIBEXT", VFS)
SMB_MODULE(vfs_dirsort, \$(VFS_DIRSORT_OBJ), "bin/dirsort.$SHLIBEXT", VFS)
SMB_SUBSYSTEM(VFS,smbd/vfs.o)

2
source3/include/async_smb.h
View File

@ -63,6 +63,8 @@ struct cli_request {
*/
uint16_t mid;
uint32_t seqnum;
/**
* The bytes we have to ship to the server
*/

52
source3/include/client.h
View File

@ -71,26 +71,26 @@ struct rpc_cli_transport {
/**
* Trigger an async read from the server. May return a short read.
*/
struct async_req *(*read_send)(TALLOC_CTX *mem_ctx,
struct event_context *ev,
uint8_t *data, size_t size,
void *priv);
/**
* Get the result from the read_send operation.
*/
NTSTATUS (*read_recv)(struct async_req *req, ssize_t *preceived);
/**
* Trigger an async write to the server. May return a short write.
*/
struct async_req *(*write_send)(TALLOC_CTX *mem_ctx,
struct tevent_req *(*read_send)(TALLOC_CTX *mem_ctx,
struct event_context *ev,
const uint8_t *data, size_t size,
uint8_t *data, size_t size,
void *priv);
/**
* Get the result from the read_send operation.
*/
NTSTATUS (*write_recv)(struct async_req *req, ssize_t *psent);
NTSTATUS (*read_recv)(struct tevent_req *req, ssize_t *preceived);
/**
* Trigger an async write to the server. May return a short write.
*/
struct tevent_req *(*write_send)(TALLOC_CTX *mem_ctx,
struct event_context *ev,
const uint8_t *data, size_t size,
void *priv);
/**
* Get the result from the read_send operation.
*/
NTSTATUS (*write_recv)(struct tevent_req *req, ssize_t *psent);
/**
* This is an optimization for the SMB transport. It models the
@ -98,15 +98,15 @@ struct rpc_cli_transport {
* trip. The transport implementation is free to set this to NULL,
* cli_pipe.c will fall back to the explicit write/read routines.
*/
struct async_req *(*trans_send)(TALLOC_CTX *mem_ctx,
struct event_context *ev,
uint8_t *data, size_t data_len,
uint32_t max_rdata_len,
void *priv);
struct tevent_req *(*trans_send)(TALLOC_CTX *mem_ctx,
struct event_context *ev,
uint8_t *data, size_t data_len,
uint32_t max_rdata_len,
void *priv);
/**
* Get the result from the trans_send operation.
*/
NTSTATUS (*trans_recv)(struct async_req *req, TALLOC_CTX *mem_ctx,
NTSTATUS (*trans_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx,
uint8_t **prdata, uint32_t *prdata_len);
void *priv;
};
@ -166,6 +166,13 @@ struct smb_trans_enc_state {
} s;
};
struct cli_state_seqnum {
struct cli_state_seqnum *prev, *next;
uint16_t mid;
uint32_t seqnum;
bool persistent;
};
struct cli_state {
/**
* A list of subsidiary connections for DFS.
@ -217,6 +224,7 @@ struct cli_state {
size_t max_xmit;
size_t max_mux;
char *outbuf;
struct cli_state_seqnum *seqnum;
char *inbuf;
unsigned int bufsize;
int initialised;
@ -231,7 +239,7 @@ struct cli_state {
TALLOC_CTX *call_mem_ctx;
#endif
smb_sign_info sign_info;
struct smb_signing_state *signing_state;
struct smb_trans_enc_state *trans_enc_state; /* Setup if we're encrypting SMB's. */

2
source3/include/dbwrap.h
View File

@ -54,6 +54,8 @@ struct db_context {
bool persistent;
};
bool db_is_local(const char *name);
struct db_context *db_open(TALLOC_CTX *mem_ctx,
const char *name,
int hash_size, int tdb_flags,

1
source3/include/includes.h
View File

@ -598,6 +598,7 @@ struct smb_iconv_convenience *lp_iconv_convenience(void *lp_ctx);
#include "messages.h"
#include "locking.h"
#include "smb_perfcount.h"
#include "smb_signing.h"
#include "smb.h"
#include "nameserv.h"
#include "secrets.h"

111
source3/include/proto.h
View File

@ -150,6 +150,10 @@ bool is_trusted_domain(const char* dom_name);
NTSTATUS auth_winbind_init(void);
/* The following definitions come from auth/auth_wbc.c */
NTSTATUS auth_wbc_init(void);
/* The following definitions come from auth/pampass.c */
bool smb_pam_claim_session(char *user, char *tty, char *rhost);
@ -2410,6 +2414,10 @@ bool receive_getdc_response(TALLOC_CTX *mem_ctx,
int cli_set_message(char *buf,int num_words,int num_bytes,bool zero);
unsigned int cli_set_timeout(struct cli_state *cli, unsigned int timeout);
void cli_set_port(struct cli_state *cli, int port);
bool cli_state_seqnum_persistent(struct cli_state *cli,
uint16_t mid);
bool cli_state_seqnum_remove(struct cli_state *cli,
uint16_t mid);
bool cli_receive_smb(struct cli_state *cli);
ssize_t cli_receive_smb_data(struct cli_state *cli, char *buffer, size_t len);
bool cli_receive_smb_readX_header(struct cli_state *cli);
@ -3181,29 +3189,34 @@ void cli_free_enc_buffer(struct cli_state *cli, char *buf);
NTSTATUS cli_decrypt_message(struct cli_state *cli);
NTSTATUS cli_encrypt_message(struct cli_state *cli, char *buf, char **buf_out);
/* The following definitions come from libsmb/smb_signing.c */
/* The following definitions come from libsmb/clisigning.c */
bool cli_simple_set_signing(struct cli_state *cli,
const DATA_BLOB user_session_key,
const DATA_BLOB response);
bool cli_null_set_signing(struct cli_state *cli);
bool cli_temp_set_signing(struct cli_state *cli);
void cli_free_signing_context(struct cli_state *cli);
void cli_calculate_sign_mac(struct cli_state *cli, char *buf);
bool cli_check_sign_mac(struct cli_state *cli, char *buf);
bool client_set_trans_sign_state_on(struct cli_state *cli, uint16 mid);
bool client_set_trans_sign_state_off(struct cli_state *cli, uint16 mid);
void cli_calculate_sign_mac(struct cli_state *cli, char *buf, uint32_t *seqnum);
bool cli_check_sign_mac(struct cli_state *cli, const char *buf, uint32_t seqnum);
bool client_is_signing_on(struct cli_state *cli);
bool srv_oplock_set_signing(bool onoff);
bool srv_check_sign_mac(const char *inbuf, bool must_be_ok);
void srv_calculate_sign_mac(char *outbuf);
void srv_defer_sign_response(uint16 mid);
void srv_cancel_sign_response(uint16 mid, bool cancel);
void srv_set_signing_negotiated(void);
bool srv_is_signing_active(void);
bool srv_is_signing_negotiated(void);
bool srv_signing_started(void);
void srv_set_signing(const DATA_BLOB user_session_key, const DATA_BLOB response);
bool client_is_signing_allowed(struct cli_state *cli);
bool client_is_signing_mandatory(struct cli_state *cli);
void cli_set_signing_negotiated(struct cli_state *cli);
/* The following definitions come from smbd/signing.c */
struct smbd_server_connection;
bool srv_check_sign_mac(struct smbd_server_connection *conn,
const char *inbuf, uint32_t *seqnum);
void srv_calculate_sign_mac(struct smbd_server_connection *conn,
char *outbuf, uint32_t seqnum);
void srv_cancel_sign_response(struct smbd_server_connection *conn);
bool srv_init_signing(struct smbd_server_connection *conn);
void srv_set_signing_negotiated(struct smbd_server_connection *conn);
bool srv_is_signing_active(struct smbd_server_connection *conn);
bool srv_is_signing_negotiated(struct smbd_server_connection *conn);
void srv_set_signing(struct smbd_server_connection *conn,
const DATA_BLOB user_session_key,
const DATA_BLOB response);
/* The following definitions come from libsmb/smbdes.c */
@ -3779,6 +3792,8 @@ bool send_mailslot(bool unique, const char *mailslot,char *buf, size_t len,
/* The following definitions come from nmbd/nmbd_processlogon.c */
bool initialize_nmbd_proxy_logon(void);
void process_logon_packet(struct packet_struct *p, char *buf,int len,
const char *mailslot);
@ -4345,7 +4360,7 @@ const char *lp_printcapname(void);
bool lp_disable_spoolss( void );
void lp_set_spoolss_state( uint32 state );
uint32 lp_get_spoolss_state( void );
bool lp_use_sendfile(int snum);
bool lp_use_sendfile(int snum, struct smb_signing_state *signing_state);
void set_use_sendfile(int snum, bool val);
void set_store_dos_attributes(int snum, bool val);
void lp_set_mangling_method(const char *new_method);
@ -4828,7 +4843,7 @@ WERROR add_printer_data( NT_PRINTER_INFO_LEVEL_2 *p2, const char *key, const cha
REGISTRY_VALUE* get_printer_data( NT_PRINTER_INFO_LEVEL_2 *p2, const char *key, const char *value );
WERROR mod_a_printer(NT_PRINTER_INFO_LEVEL *printer, uint32 level);
bool set_driver_init(NT_PRINTER_INFO_LEVEL *printer, uint32 level);
bool del_driver_init(char *drivername);
bool del_driver_init(const char *drivername);
WERROR save_driver_init(NT_PRINTER_INFO_LEVEL *printer, uint32 level, uint8 *data, uint32 data_len);
WERROR get_a_printer( Printer_entry *print_hnd,
NT_PRINTER_INFO_LEVEL **pp_printer,
@ -4840,8 +4855,8 @@ WERROR get_a_printer_search( Printer_entry *print_hnd,
const char *sharename);
uint32 free_a_printer(NT_PRINTER_INFO_LEVEL **pp_printer, uint32 level);
uint32 add_a_printer_driver(NT_PRINTER_DRIVER_INFO_LEVEL driver, uint32 level);
WERROR get_a_printer_driver(NT_PRINTER_DRIVER_INFO_LEVEL *driver, uint32 level,
fstring drivername, const char *architecture, uint32 version);
WERROR get_a_printer_driver(NT_PRINTER_DRIVER_INFO_LEVEL *driver, uint32_t level,
const char *drivername, const char *architecture, uint32_t version);
uint32 free_a_printer_driver(NT_PRINTER_DRIVER_INFO_LEVEL driver, uint32 level);
bool printer_driver_in_use ( NT_PRINTER_DRIVER_INFO_LEVEL_3 *info_3 );
bool printer_driver_files_in_use ( NT_PRINTER_DRIVER_INFO_LEVEL_3 *info );
@ -5241,22 +5256,22 @@ NTSTATUS rpccli_netlogon_set_trust_password(struct rpc_pipe_client *cli,
/* The following definitions come from rpc_client/cli_pipe.c */
struct async_req *rpc_api_pipe_req_send(TALLOC_CTX *mem_ctx,
struct event_context *ev,
struct rpc_pipe_client *cli,
uint8_t op_num,
prs_struct *req_data);
NTSTATUS rpc_api_pipe_req_recv(struct async_req *req, TALLOC_CTX *mem_ctx,
struct tevent_req *rpc_api_pipe_req_send(TALLOC_CTX *mem_ctx,
struct event_context *ev,
struct rpc_pipe_client *cli,
uint8_t op_num,
prs_struct *req_data);
NTSTATUS rpc_api_pipe_req_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
prs_struct *reply_pdu);
NTSTATUS rpc_api_pipe_req(TALLOC_CTX *mem_ctx, struct rpc_pipe_client *cli,
uint8 op_num,
prs_struct *in_data,
prs_struct *out_data);
struct async_req *rpc_pipe_bind_send(TALLOC_CTX *mem_ctx,
struct event_context *ev,
struct rpc_pipe_client *cli,
struct cli_pipe_auth_data *auth);
NTSTATUS rpc_pipe_bind_recv(struct async_req *req);
struct tevent_req *rpc_pipe_bind_send(TALLOC_CTX *mem_ctx,
struct event_context *ev,
struct rpc_pipe_client *cli,
struct cli_pipe_auth_data *auth);
NTSTATUS rpc_pipe_bind_recv(struct tevent_req *req);
NTSTATUS rpc_pipe_bind(struct rpc_pipe_client *cli,
struct cli_pipe_auth_data *auth);
unsigned int rpccli_set_timeout(struct rpc_pipe_client *cli,
@ -5678,10 +5693,8 @@ NTSTATUS cli_do_rpc_ndr(struct rpc_pipe_client *cli,
bool smb_io_time(const char *desc, NTTIME *nttime, prs_struct *ps, int depth);
bool smb_io_system_time(const char *desc, prs_struct *ps, int depth, SYSTEMTIME *systime);
bool make_systemtime(SYSTEMTIME *systime, struct tm *unixtime);
bool smb_io_dom_sid(const char *desc, DOM_SID *sid, prs_struct *ps, int depth);
bool smb_io_uuid(const char *desc, struct GUID *uuid,
prs_struct *ps, int depth);
void init_unistr(UNISTR *str, const char *buf);
void init_unistr2(UNISTR2 *str, const char *buf, enum unistr2_term_codes flags);
/* The following definitions come from rpc_parse/parse_prs.c */
@ -5803,11 +5816,6 @@ bool smb_io_rpc_auth_schannel_chk(const char *desc, int auth_len,
RPC_AUTH_SCHANNEL_CHK * chk,
prs_struct *ps, int depth);
/* The following definitions come from rpc_parse/parse_sec.c */
bool sec_io_desc(const char *desc, SEC_DESC **ppsd, prs_struct *ps, int depth);
bool sec_io_desc_buf(const char *desc, SEC_DESC_BUF **ppsdb, prs_struct *ps, int depth);
/* The following definitions come from rpc_server/srv_eventlog_lib.c */
TDB_CONTEXT *elog_init_tdb( char *tdbfilename );
@ -5898,6 +5906,8 @@ NTSTATUS np_read_recv(struct tevent_req *req, ssize_t *nread,
/* The following definitions come from rpc_server/srv_samr_util.c */
void copy_id18_to_sam_passwd(struct samu *to,
struct samr_UserInfo18 *from);
void copy_id20_to_sam_passwd(struct samu *to,
struct samr_UserInfo20 *from);
void copy_id21_to_sam_passwd(const char *log_prefix,
@ -5905,8 +5915,12 @@ void copy_id21_to_sam_passwd(const char *log_prefix,
struct samr_UserInfo21 *from);
void copy_id23_to_sam_passwd(struct samu *to,
struct samr_UserInfo23 *from);
void copy_id24_to_sam_passwd(struct samu *to,
struct samr_UserInfo24 *from);
void copy_id25_to_sam_passwd(struct samu *to,
struct samr_UserInfo25 *from);
void copy_id26_to_sam_passwd(struct samu *to,
struct samr_UserInfo26 *from);
/* The following definitions come from rpc_server/srv_spoolss_nt.c */
@ -5925,8 +5939,9 @@ void reset_all_printerdata(struct messaging_context *msg,
bool convert_devicemode(const char *printername,
const struct spoolss_DeviceMode *devmode,
NT_DEVICEMODE **pp_nt_devmode);
WERROR set_printer_dataex( NT_PRINTER_INFO_LEVEL *printer, const char *key, const char *value,
uint32 type, uint8 *data, int real_len );
WERROR set_printer_dataex(NT_PRINTER_INFO_LEVEL *printer,
const char *key, const char *value,
uint32_t type, uint8_t *data, int real_len);
void spoolss_notify_server_name(int snum,
struct spoolss_Notify *data,
print_queue_struct *queue,
@ -6713,7 +6728,9 @@ SEC_DESC *get_nt_acl_no_snum( TALLOC_CTX *ctx, const char *fname);
void smbd_setup_sig_term_handler(void);
void smbd_setup_sig_hup_handler(void);
bool srv_send_smb(int fd, char *buffer, bool do_encrypt,
bool srv_send_smb(int fd, char *buffer,
bool no_signing, uint32_t seqnum,
bool do_encrypt,
struct smb_perfcount_data *pcd);
int srv_set_message(char *buf,
int num_words,
@ -7210,6 +7227,16 @@ NTSTATUS idmap_sid_to_gid(const char *domname, DOM_SID *sid, gid_t *gid);
NTSTATUS nss_info_template_init( void );
/* The following definitions come from lib/avahi.c */
struct AvahiPoll *tevent_avahi_poll(TALLOC_CTX *mem_ctx,
struct tevent_context *ev);
/* The following definitions come from smbd/avahi_register.c */
void *avahi_start_register(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
uint16_t port);
/* Misc protos */
#endif /* _PROTO_H_ */

10
source3/include/rpc_dce.h
View File

@ -81,16 +81,6 @@ enum RPC_PKT_TYPE {
#define RPC_PIPE_AUTH_SEAL_LEVEL 0x6
#endif
#define DCERPC_FAULT_OP_RNG_ERROR 0x1c010002
#define DCERPC_FAULT_UNK_IF 0x1c010003
#define DCERPC_FAULT_INVALID_TAG 0x1c000006
#define DCERPC_FAULT_CONTEXT_MISMATCH 0x1c00001a
#define DCERPC_FAULT_OTHER 0x00000001
#define DCERPC_FAULT_ACCESS_DENIED 0x00000005
#define DCERPC_FAULT_CANT_PERFORM 0x000006d8
#define DCERPC_FAULT_NDR 0x000006f7
/* Netlogon schannel auth type and level */
#define SCHANNEL_SIGN_SIGNATURE { 0x77, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00 }
#define SCHANNEL_SEAL_SIGNATURE { 0x77, 0x00, 0x7a, 0x00, 0xff, 0xff, 0x00, 0x00 }

19
source3/include/smb.h
View File

@ -252,6 +252,8 @@ struct id_map {
#include "librpc/gen_ndr/drsuapi.h"
#include "librpc/gen_ndr/drsblobs.h"
#include "librpc/gen_ndr/spoolss.h"
#include "librpc/gen_ndr/dcerpc.h"
#include "librpc/gen_ndr/ndr_dcerpc.h"
struct lsa_dom_info {
bool valid;
@ -621,6 +623,7 @@ struct smb_request {
uint16 flags2;
uint16 smbpid;
uint16 mid;
uint32_t seqnum;
uint16 vuid;
uint16 tid;
uint8 wct;
@ -722,6 +725,7 @@ struct pending_message_list {
struct timeval request_time; /* When was this first issued? */
struct timed_event *te;
struct smb_perfcount_data pcd;
uint32_t seqnum;
bool encrypted;
DATA_BLOB buf;
DATA_BLOB private_data;
@ -1847,21 +1851,6 @@ struct ip_service {
/* Special name type used to cause a _kerberos DNS lookup. */
#define KDC_NAME_TYPE 0xDCDC
/* Used by the SMB signing functions. */
typedef struct smb_sign_info {
void (*sign_outgoing_message)(char *outbuf, struct smb_sign_info *si);
bool (*check_incoming_message)(const char *inbuf, struct smb_sign_info *si, bool must_be_ok);
void (*free_signing_context)(struct smb_sign_info *si);
void *signing_context;
bool negotiated_smb_signing;
bool allow_smb_signing;
bool doing_signing;
bool mandatory_signing;
bool seen_valid; /* Have I ever seen a validly signed packet? */
} smb_sign_info;
struct ea_struct {
uint8 flags;
char *name;

8
source3/include/smb_perfcount.h
View File

@ -37,8 +37,6 @@ struct smb_perfcount_handlers {
uint64_t in_bytes);
void (*perfcount_set_msglen_out) (struct smb_perfcount_data *pcd,
uint64_t out_bytes);
void (*perfcount_set_client) (struct smb_perfcount_data *pcd, uid_t uid,
const char *user, const char *domain);
void (*perfcount_copy_context) (struct smb_perfcount_data *pcd,
struct smb_perfcount_data *new_pcd);
void (*perfcount_defer_op) (struct smb_perfcount_data *pcd,
@ -88,12 +86,6 @@ void smb_init_perfcount_data(struct smb_perfcount_data *pcd);
(_pcd_)->handlers->perfcount_set_msglen_out((_pcd_), (_out_));\
} while (0)
#define SMB_PERFCOUNT_SET_CLIENT(_pcd_,_uid_, _user_, _domain_) \
do {if((_pcd_) && (_pcd_)->handlers) \
(_pcd_)->handlers->perfcount_set_client((_pcd_), (_uid_), \
(_user_), (_domain_)); \
} while (0)
#define SMB_PERFCOUNT_COPY_CONTEXT(_pcd_, _new_pcd_) \
do {if((_pcd_) && (_pcd_)->handlers) \
(_pcd_)->handlers->perfcount_copy_context((_pcd_), (_new_pcd_)); \

46
source3/include/smb_signing.h Normal file
View File

@ -0,0 +1,46 @@
/*
Unix SMB/CIFS implementation.
SMB Signing Code
Copyright (C) Jeremy Allison 2003.
Copyright (C) Andrew Bartlett <abartlet@samba.org> 2002-2003
Copyright (C) Stefan Metzmacher 2009
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef _SMB_SIGNING_H_
#define _SMB_SIGNING_H_
struct smb_signing_state;
struct smb_signing_state *smb_signing_init(TALLOC_CTX *mem_ctx,
bool allowed,
bool mandatory);
uint32_t smb_signing_next_seqnum(struct smb_signing_state *si, bool oneway);
void smb_signing_cancel_reply(struct smb_signing_state *si, bool oneway);
void smb_signing_sign_pdu(struct smb_signing_state *si,
uint8_t *outbuf, uint32_t seqnum);
bool smb_signing_check_pdu(struct smb_signing_state *si,
const uint8_t *inbuf, uint32_t seqnum);
bool smb_signing_set_bsrspyl(struct smb_signing_state *si);
bool smb_signing_activate(struct smb_signing_state *si,
const DATA_BLOB user_session_key,
const DATA_BLOB response);
bool smb_signing_is_active(struct smb_signing_state *si);
bool smb_signing_is_allowed(struct smb_signing_state *si);
bool smb_signing_is_mandatory(struct smb_signing_state *si);
bool smb_signing_set_negotiated(struct smb_signing_state *si);
bool smb_signing_is_negotiated(struct smb_signing_state *si);
#endif /* _SMB_SIGNING_H_ */

275
source3/lib/avahi.c Normal file
View File

@ -0,0 +1,275 @@
/*
Unix SMB/CIFS implementation.
Connect avahi to lib/tevents
Copyright (C) Volker Lendecke 2009
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "includes.h"
#include <avahi-common/watch.h>
struct avahi_poll_context {
struct tevent_context *ev;
AvahiWatch **watches;
AvahiTimeout **timeouts;
};
struct AvahiWatch {
struct avahi_poll_context *ctx;
struct tevent_fd *fde;
int fd;
AvahiWatchEvent latest_event;
AvahiWatchCallback callback;
void *userdata;
};
struct AvahiTimeout {
struct avahi_poll_context *ctx;
struct tevent_timer *te;
AvahiTimeoutCallback callback;
void *userdata;
};
static uint16_t avahi_flags_map_to_tevent(AvahiWatchEvent event)
{
return ((event & AVAHI_WATCH_IN) ? TEVENT_FD_READ : 0)
| ((event & AVAHI_WATCH_OUT) ? TEVENT_FD_WRITE : 0);
}
static void avahi_fd_handler(struct tevent_context *ev,
struct tevent_fd *fde, uint16_t flags,
void *private_data);
static AvahiWatch *avahi_watch_new(const AvahiPoll *api, int fd,
AvahiWatchEvent event,
AvahiWatchCallback callback,
void *userdata)
{
struct avahi_poll_context *ctx = talloc_get_type_abort(
api->userdata, struct avahi_poll_context);
int num_watches = talloc_array_length(ctx->watches);
AvahiWatch **tmp, *watch_ctx;
tmp = talloc_realloc(ctx, ctx->watches, AvahiWatch *, num_watches + 1);
if (tmp == NULL) {
return NULL;
}
ctx->watches = tmp;
watch_ctx = talloc(tmp, AvahiWatch);
if (watch_ctx == NULL) {
goto fail;
}
ctx->watches[num_watches] = watch_ctx;
watch_ctx->ctx = ctx;
watch_ctx->fde = tevent_add_fd(ctx->ev, watch_ctx, fd,
avahi_flags_map_to_tevent(event),
avahi_fd_handler, watch_ctx);
if (watch_ctx->fde == NULL) {
goto fail;
}
watch_ctx->callback = callback;
watch_ctx->userdata = userdata;
return watch_ctx;
fail:
TALLOC_FREE(watch_ctx);
ctx->watches = talloc_realloc(ctx, ctx->watches, AvahiWatch *,
num_watches);
return NULL;
}
static void avahi_fd_handler(struct tevent_context *ev,
struct tevent_fd *fde, uint16_t flags,
void *private_data)
{
AvahiWatch *watch_ctx = talloc_get_type_abort(private_data, AvahiWatch);
watch_ctx->latest_event =
((flags & TEVENT_FD_READ) ? AVAHI_WATCH_IN : 0)
| ((flags & TEVENT_FD_WRITE) ? AVAHI_WATCH_OUT : 0);
watch_ctx->callback(watch_ctx, watch_ctx->fd, watch_ctx->latest_event,
watch_ctx->userdata);
}
static void avahi_watch_update(AvahiWatch *w, AvahiWatchEvent event)
{
tevent_fd_set_flags(w->fde, avahi_flags_map_to_tevent(event));
}
static AvahiWatchEvent avahi_watch_get_events(AvahiWatch *w)
{
return w->latest_event;
}
static void avahi_watch_free(AvahiWatch *w)
{
int i, num_watches;
AvahiWatch **watches = w->ctx->watches;
struct avahi_poll_context *ctx;
num_watches = talloc_array_length(watches);
for (i=0; i<num_watches; i++) {
if (w == watches[i]) {
break;
}
}
if (i == num_watches) {
return;
}
ctx = w->ctx;
TALLOC_FREE(w);
memmove(&watches[i], &watches[i+1],
sizeof(*watches) * (num_watches - i - 1));
ctx->watches = talloc_realloc(ctx, watches, AvahiWatch *,
num_watches - 1);
}
static void avahi_timeout_handler(struct tevent_context *ev,
struct tevent_timer *te,
struct timeval current_time,
void *private_data);
static AvahiTimeout *avahi_timeout_new(const AvahiPoll *api,
const struct timeval *tv,
AvahiTimeoutCallback callback,
void *userdata)
{
struct avahi_poll_context *ctx = talloc_get_type_abort(
api->userdata, struct avahi_poll_context);
int num_timeouts = talloc_array_length(ctx->timeouts);
AvahiTimeout **tmp, *timeout_ctx;
tmp = talloc_realloc(ctx, ctx->timeouts, AvahiTimeout *,
num_timeouts + 1);
if (tmp == NULL) {
return NULL;
}
ctx->timeouts = tmp;
timeout_ctx = talloc(tmp, AvahiTimeout);
if (timeout_ctx == NULL) {
goto fail;
}
ctx->timeouts[num_timeouts] = timeout_ctx;
timeout_ctx->ctx = ctx;
if (tv == NULL) {
timeout_ctx->te = NULL;
} else {
timeout_ctx->te = tevent_add_timer(ctx->ev, timeout_ctx,
*tv, avahi_timeout_handler,
timeout_ctx);
if (timeout_ctx->te == NULL) {
goto fail;
}
}
timeout_ctx->callback = callback;
timeout_ctx->userdata = userdata;
return timeout_ctx;
fail:
TALLOC_FREE(timeout_ctx);
ctx->timeouts = talloc_realloc(ctx, ctx->timeouts, AvahiTimeout *,
num_timeouts);
return NULL;
}
static void avahi_timeout_handler(struct tevent_context *ev,
struct tevent_timer *te,
struct timeval current_time,
void *private_data)
{
AvahiTimeout *timeout_ctx = talloc_get_type_abort(
private_data, AvahiTimeout);
TALLOC_FREE(timeout_ctx->te);
timeout_ctx->callback(timeout_ctx, timeout_ctx->userdata);
}
static void avahi_timeout_update(AvahiTimeout *t, const struct timeval *tv)
{
TALLOC_FREE(t->te);
if (tv == NULL) {
/*
* Disable this timer
*/
return;
}
t->te = tevent_add_timer(t->ctx->ev, t, *tv, avahi_timeout_handler, t);
/*
* No failure mode defined here
*/
SMB_ASSERT(t->te != NULL);
}
static void avahi_timeout_free(AvahiTimeout *t)
{
int i, num_timeouts;
AvahiTimeout **timeouts = t->ctx->timeouts;
struct avahi_poll_context *ctx;
num_timeouts = talloc_array_length(timeouts);
for (i=0; i<num_timeouts; i++) {
if (t == timeouts[i]) {
break;
}
}
if (i == num_timeouts) {
return;
}
ctx = t->ctx;
TALLOC_FREE(t);
memmove(&timeouts[i], &timeouts[i+1],
sizeof(*timeouts) * (num_timeouts - i - 1));
ctx->timeouts = talloc_realloc(ctx, timeouts, AvahiTimeout *,
num_timeouts - 1);
}
struct AvahiPoll *tevent_avahi_poll(TALLOC_CTX *mem_ctx,
struct tevent_context *ev)
{
struct AvahiPoll *result;
struct avahi_poll_context *ctx;
result = talloc(mem_ctx, struct AvahiPoll);
if (result == NULL) {
return result;
}
ctx = talloc_zero(result, struct avahi_poll_context);
if (ctx == NULL) {
TALLOC_FREE(result);
return NULL;
}
ctx->ev = ev;
result->watch_new = avahi_watch_new;
result->watch_update = avahi_watch_update;
result->watch_get_events = avahi_watch_get_events;
result->watch_free = avahi_watch_free;
result->timeout_new = avahi_timeout_new;
result->timeout_update = avahi_timeout_update;
result->timeout_free = avahi_timeout_free;
result->userdata = ctx;
return result;
}

27
source3/lib/dbwrap.c
View File

@ -65,6 +65,33 @@ static int dbwrap_fallback_parse_record(struct db_context *db, TDB_DATA key,
return res;
}
bool db_is_local(const char *name)
{
#ifdef CLUSTER_SUPPORT
const char *sockname = lp_ctdbd_socket();
if(!sockname || !*sockname) {
sockname = CTDB_PATH;
}
if (lp_clustering() && socket_exist(sockname)) {
const char *partname;
/* ctdb only wants the file part of the name */
partname = strrchr(name, '/');
if (partname) {
partname++;
} else {
partname = name;
}
/* allow ctdb for individual databases to be disabled */
if (lp_parm_bool(-1, "ctdb", partname, True)) {
return false;
}
}
#endif
return true;
}
/**
* open a database
*/

5
source3/lib/netapi/cm.c
View File

@ -57,6 +57,11 @@ static WERROR libnetapi_open_ipc_connection(struct libnetapi_ctx *ctx,
false, false,
PROTOCOL_NT1,
0, 0x20);
if (cli_ipc) {
cli_set_username(cli_ipc, ctx->username);
cli_set_password(cli_ipc, ctx->password);
cli_set_domain(cli_ipc, ctx->workgroup);
}
TALLOC_FREE(auth_info);
if (!cli_ipc) {

10
source3/lib/netapi/group.c
View File

@ -1276,6 +1276,7 @@ WERROR NetGroupGetUsers_r(struct libnetapi_ctx *ctx,
*r->out.buffer = NULL;
*r->out.entries_read = 0;
*r->out.total_entries = 0;
switch (r->in.level) {
case 0:
@ -1364,13 +1365,8 @@ WERROR NetGroupGetUsers_r(struct libnetapi_ctx *ctx,
}
}
if (r->out.entries_read) {
*r->out.entries_read = entries_read;
}
if (r->out.total_entries) {
*r->out.total_entries = entries_read;
}
*r->out.entries_read = entries_read;
*r->out.total_entries = entries_read;
werr = WERR_OK;

36
source3/lib/netapi/user.c
View File

@ -1497,6 +1497,9 @@ WERROR NetQueryDisplayInformation_r(struct libnetapi_ctx *ctx,
NTSTATUS status = NT_STATUS_OK;
WERROR werr;
WERROR werr_tmp;
*r->out.entries_read = 0;
ZERO_STRUCT(connect_handle);
ZERO_STRUCT(domain_handle);
@ -1540,15 +1543,18 @@ WERROR NetQueryDisplayInformation_r(struct libnetapi_ctx *ctx,
&total_size,
&returned_size,
&info);
if (!NT_STATUS_IS_OK(status)) {
werr = ntstatus_to_werror(status);
werr = ntstatus_to_werror(status);
if (NT_STATUS_IS_ERR(status)) {
goto done;
}
werr = convert_samr_dispinfo_to_NET_DISPLAY(ctx, &info,
r->in.level,
r->out.entries_read,
r->out.buffer);
werr_tmp = convert_samr_dispinfo_to_NET_DISPLAY(ctx, &info,
r->in.level,
r->out.entries_read,
r->out.buffer);
if (!W_ERROR_IS_OK(werr_tmp)) {
werr = werr_tmp;
}
done:
/* if last query */
if (NT_STATUS_IS_OK(status) ||
@ -2806,6 +2812,7 @@ WERROR NetUserGetGroups_r(struct libnetapi_ctx *ctx,
*r->out.buffer = NULL;
*r->out.entries_read = 0;
*r->out.total_entries = 0;
switch (r->in.level) {
case 0:
@ -2899,12 +2906,8 @@ WERROR NetUserGetGroups_r(struct libnetapi_ctx *ctx,
}
}
if (r->out.entries_read) {
*r->out.entries_read = entries_read;
}
if (r->out.total_entries) {
*r->out.total_entries = entries_read;
}
*r->out.entries_read = entries_read;
*r->out.total_entries = entries_read;
done:
if (ctx->disable_policy_handle_cache) {
@ -3242,6 +3245,7 @@ WERROR NetUserGetLocalGroups_r(struct libnetapi_ctx *ctx,
*r->out.buffer = NULL;
*r->out.entries_read = 0;
*r->out.total_entries = 0;
switch (r->in.level) {
case 0:
@ -3402,12 +3406,8 @@ WERROR NetUserGetLocalGroups_r(struct libnetapi_ctx *ctx,
}
}
if (r->out.entries_read) {
*r->out.entries_read = entries_read;
}
if (r->out.total_entries) {
*r->out.total_entries = entries_read;
}
*r->out.entries_read = entries_read;
*r->out.total_entries = entries_read;
done:
if (ctx->disable_policy_handle_cache) {

2
source3/lib/util_file.c
View File

@ -39,7 +39,7 @@ static char *file_pload(const char *syscmd, size_t *size)
total = 0;
while ((n = read(fd, buf, sizeof(buf))) > 0) {
p = (char *)SMB_REALLOC(p, total + n + 1);
p = talloc_realloc(NULL, p, char, total + n + 1);
if (!p) {
DEBUG(0,("file_pload: failed to expand buffer!\n"));
close(fd);

12
source3/lib/wbclient.c
View File

@ -449,8 +449,8 @@ static void wb_open_pipe_connect_nonpriv_done(struct tevent_req *subreq)
ZERO_STRUCT(state->wb_req);
state->wb_req.cmd = WINBINDD_INTERFACE_VERSION;
subreq = wb_int_trans_send(state, state->ev, NULL, state->wb_ctx->fd,
&state->wb_req);
subreq = wb_int_trans_send(state, state->ev, state->wb_ctx->queue,
state->wb_ctx->fd, &state->wb_req);
if (tevent_req_nomem(subreq, req)) {
return;
}
@ -480,8 +480,8 @@ static void wb_open_pipe_ping_done(struct tevent_req *subreq)
state->wb_req.cmd = WINBINDD_PRIV_PIPE_DIR;
subreq = wb_int_trans_send(state, state->ev, NULL, state->wb_ctx->fd,
&state->wb_req);
subreq = wb_int_trans_send(state, state->ev, state->wb_ctx->queue,
state->wb_ctx->fd, &state->wb_req);
if (tevent_req_nomem(subreq, req)) {
return;
}
@ -673,8 +673,8 @@ static void wb_trans_connect_done(struct tevent_req *subreq)
return;
}
subreq = wb_int_trans_send(state, state->ev, NULL, state->wb_ctx->fd,
state->wb_req);
subreq = wb_int_trans_send(state, state->ev, state->wb_ctx->queue,
state->wb_ctx->fd, state->wb_req);
if (tevent_req_nomem(subreq, req)) {
return;
}

12
source3/libads/kerberos.c
View File

@ -511,13 +511,13 @@ char *kerberos_get_default_realm_from_ccache( void )
out:
if (princ) {
krb5_free_principal(ctx, princ);
}
if (cc) {
krb5_cc_close(ctx, cc);
}
if (ctx) {
if (princ) {
krb5_free_principal(ctx, princ);
}
if (cc) {
krb5_cc_close(ctx, cc);
}
krb5_free_context(ctx);
}

3
source3/libnet/libnet_samsync.c
View File

@ -422,9 +422,6 @@ static NTSTATUS libnet_samsync_delta(TALLOC_CTX *mem_ctx,
TALLOC_FREE(delta_enum_array);
/* Increment sync_context */
sync_context += 1;
} while (NT_STATUS_EQUAL(result, STATUS_MORE_ENTRIES));
out:

52
source3/libsmb/async_smb.c
View File

@ -550,7 +550,7 @@ void cli_chain_uncork(struct cli_state *cli)
_smb_setlen_large(((char *)req->outbuf), smblen);
}
cli_calculate_sign_mac(cli, (char *)req->outbuf);
cli_calculate_sign_mac(cli, (char *)req->outbuf, &req->seqnum);
if (cli_encryption_on(cli)) {
NTSTATUS status;
@ -811,9 +811,16 @@ NTSTATUS cli_pull_reply(struct async_req *req,
*/
static NTSTATUS validate_smb_crypto(struct cli_state *cli, char *pdu)
static NTSTATUS validate_smb_crypto(struct cli_state *cli, char *pdu,
struct cli_request **_req,
uint16_t *_mid)
{
NTSTATUS status;
struct cli_request *req = NULL;
uint16_t mid;
*_req = NULL;
*_mid = 0;
if ((IVAL(pdu, 4) != 0x424d53ff) /* 0xFF"SMB" */
&& (SVAL(pdu, 4) != 0x45ff)) /* 0xFF"E" */ {
@ -846,11 +853,27 @@ static NTSTATUS validate_smb_crypto(struct cli_state *cli, char *pdu)
}
}
if (!cli_check_sign_mac(cli, pdu)) {
mid = SVAL(pdu, smb_mid);
for (req = cli->outstanding_requests; req; req = req->next) {
if (req->mid == mid) {
break;
}
}
if (!req) {
/* oplock breaks are not signed */
goto done;
}
if (!cli_check_sign_mac(cli, pdu, req->seqnum+1)) {
DEBUG(10, ("cli_check_sign_mac failed\n"));
return NT_STATUS_ACCESS_DENIED;
}
done:
*_req = req;
*_mid = mid;
return NT_STATUS_OK;
}
@ -861,9 +884,9 @@ static NTSTATUS validate_smb_crypto(struct cli_state *cli, char *pdu)
static void handle_incoming_pdu(struct cli_state *cli)
{
struct cli_request *req;
struct cli_request *req, *next;
uint16_t mid;
size_t raw_pdu_len, buf_len, pdu_len, rest_len;
size_t raw_pdu_len, buf_len, rest_len;
char *pdu;
int i;
NTSTATUS status;
@ -923,23 +946,13 @@ static void handle_incoming_pdu(struct cli_state *cli)
}
}
status = validate_smb_crypto(cli, pdu);
status = validate_smb_crypto(cli, pdu, &req, &mid);
if (!NT_STATUS_IS_OK(status)) {
goto invalidate_requests;
}
mid = SVAL(pdu, smb_mid);
DEBUG(10, ("handle_incoming_pdu: got mid %d\n", mid));
for (req = cli->outstanding_requests; req; req = req->next) {
if (req->mid == mid) {
break;
}
}
pdu_len = smb_len(pdu) + 4;
if (req == NULL) {
DEBUG(3, ("Request for mid %d not found, dumping PDU\n", mid));
@ -978,8 +991,11 @@ static void handle_incoming_pdu(struct cli_state *cli)
DEBUG(10, ("handle_incoming_pdu: Aborting with %s\n",
nt_errstr(status)));
for (req = cli->outstanding_requests; req; req = req->next) {
async_req_nterror(req->async[0], status);
for (req = cli->outstanding_requests; req; req = next) {
next = req->next;
if (req->num_async) {
async_req_nterror(req->async[0], status);
}
}
return;
}

46
source3/libsmb/cliconnect.c
View File

@ -505,11 +505,7 @@ static NTSTATUS cli_session_setup_nt1(struct cli_state *cli, const char *user,
ok = cli_simple_set_signing(cli, session_key, nt_response);
#endif
if (ok) {
/* 'resign' the last message, so we get the right sequence numbers
for checking the first reply from the server */
cli_calculate_sign_mac(cli, cli->outbuf);
if (!cli_check_sign_mac(cli, cli->inbuf)) {
if (!cli_check_sign_mac(cli, cli->inbuf, 1)) {
result = NT_STATUS_ACCESS_DENIED;
goto end;
}
@ -747,11 +743,7 @@ static ADS_STATUS cli_session_setup_kerberos(struct cli_state *cli, const char *
if (cli_simple_set_signing(
cli, session_key_krb5, data_blob_null)) {
/* 'resign' the last message, so we get the right sequence numbers
for checking the first reply from the server */
cli_calculate_sign_mac(cli, cli->outbuf);
if (!cli_check_sign_mac(cli, cli->inbuf)) {
if (!cli_check_sign_mac(cli, cli->inbuf, 1)) {
nt_status = NT_STATUS_ACCESS_DENIED;
goto nt_error;
}
@ -873,11 +865,7 @@ static NTSTATUS cli_session_setup_ntlmssp(struct cli_state *cli, const char *use
if (cli_simple_set_signing(
cli, ntlmssp_state->session_key, data_blob_null)) {
/* 'resign' the last message, so we get the right sequence numbers
for checking the first reply from the server */
cli_calculate_sign_mac(cli, cli->outbuf);
if (!cli_check_sign_mac(cli, cli->inbuf)) {
if (!cli_check_sign_mac(cli, cli->inbuf, 1)) {
nt_status = NT_STATUS_ACCESS_DENIED;
}
}
@ -1540,13 +1528,16 @@ NTSTATUS cli_negprot_recv(struct async_req *req)
cli->protocol = prots[protnum].prot;
if ((cli->protocol < PROTOCOL_NT1) && cli->sign_info.mandatory_signing) {
if ((cli->protocol < PROTOCOL_NT1) &&
client_is_signing_mandatory(cli)) {
DEBUG(0,("cli_negprot: SMB signing is mandatory and the selected protocol level doesn't support it.\n"));
return NT_STATUS_ACCESS_DENIED;
}
if (cli->protocol >= PROTOCOL_NT1) {
struct timespec ts;
bool negotiated_smb_signing = false;
/* NT protocol */
cli->sec_mode = CVAL(vwv + 1, 0);
cli->max_mux = SVAL(vwv + 1, 1);
@ -1579,22 +1570,24 @@ NTSTATUS cli_negprot_recv(struct async_req *req)
if (cli->sec_mode & NEGOTIATE_SECURITY_SIGNATURES_REQUIRED) {
/* Fail if server says signing is mandatory and we don't want to support it. */
if (!cli->sign_info.allow_smb_signing) {
if (!client_is_signing_allowed(cli)) {
DEBUG(0,("cli_negprot: SMB signing is mandatory and we have disabled it.\n"));
return NT_STATUS_ACCESS_DENIED;
}
cli->sign_info.negotiated_smb_signing = True;
cli->sign_info.mandatory_signing = True;
} else if (cli->sign_info.mandatory_signing && cli->sign_info.allow_smb_signing) {
negotiated_smb_signing = true;
} else if (client_is_signing_mandatory(cli) && client_is_signing_allowed(cli)) {
/* Fail if client says signing is mandatory and the server doesn't support it. */
if (!(cli->sec_mode & NEGOTIATE_SECURITY_SIGNATURES_ENABLED)) {
DEBUG(1,("cli_negprot: SMB signing is mandatory and the server doesn't support it.\n"));
return NT_STATUS_ACCESS_DENIED;
}
cli->sign_info.negotiated_smb_signing = True;
cli->sign_info.mandatory_signing = True;
negotiated_smb_signing = true;
} else if (cli->sec_mode & NEGOTIATE_SECURITY_SIGNATURES_ENABLED) {
cli->sign_info.negotiated_smb_signing = True;
negotiated_smb_signing = true;
}
if (negotiated_smb_signing) {
cli_set_signing_negotiated(cli);
}
if (cli->capabilities & (CAP_LARGE_READX|CAP_LARGE_WRITEX)) {
@ -1841,10 +1834,9 @@ static NTSTATUS open_smb_socket(const struct sockaddr_storage *pss,
tevent_req_set_callback(r445, smb_sock_connected, fd445);
tevent_req_set_callback(r139, smb_sock_connected, fd139);
while ((fd139->fd == -1)
&& tevent_req_is_in_progress(r139)
&& (fd445->fd == -1)
&& tevent_req_is_in_progress(r445)) {
while ((fd445->fd == -1) && (fd139->fd == -1)
&& (tevent_req_is_in_progress(r139)
|| tevent_req_is_in_progress(r445))) {
event_loop_once(ev);
}

104
source3/libsmb/clientgen.c
View File

@ -135,6 +135,79 @@ static ssize_t client_receive_smb(struct cli_state *cli, size_t maxlen)
return len;
}
static bool cli_state_set_seqnum(struct cli_state *cli, uint16_t mid, uint32_t seqnum)
{
struct cli_state_seqnum *c;
for (c = cli->seqnum; c; c = c->next) {
if (c->mid == mid) {
c->seqnum = seqnum;
return true;
}
}
c = talloc_zero(cli, struct cli_state_seqnum);
if (!c) {
return false;
}
c->mid = mid;
c->seqnum = seqnum;
c->persistent = false;
DLIST_ADD_END(cli->seqnum, c, struct cli_state_seqnum *);
return true;
}
bool cli_state_seqnum_persistent(struct cli_state *cli,
uint16_t mid)
{
struct cli_state_seqnum *c;
for (c = cli->seqnum; c; c = c->next) {
if (c->mid == mid) {
c->persistent = true;
return true;
}
}
return false;
}
bool cli_state_seqnum_remove(struct cli_state *cli,
uint16_t mid)
{
struct cli_state_seqnum *c;
for (c = cli->seqnum; c; c = c->next) {
if (c->mid == mid) {
DLIST_REMOVE(cli->seqnum, c);
TALLOC_FREE(c);
return true;
}
}
return false;
}
static uint32_t cli_state_get_seqnum(struct cli_state *cli, uint16_t mid)
{
struct cli_state_seqnum *c;
for (c = cli->seqnum; c; c = c->next) {
if (c->mid == mid) {
uint32_t seqnum = c->seqnum;
if (!c->persistent) {
DLIST_REMOVE(cli->seqnum, c);
TALLOC_FREE(c);
}
return seqnum;
}
}
return 0;
}
/****************************************************************************
Recv an smb.
****************************************************************************/
@ -142,6 +215,8 @@ static ssize_t client_receive_smb(struct cli_state *cli, size_t maxlen)
bool cli_receive_smb(struct cli_state *cli)
{
ssize_t len;
uint16_t mid;
uint32_t seqnum;
/* fd == -1 causes segfaults -- Tom (tom@ninja.nl) */
if (cli->fd == -1)
@ -177,7 +252,10 @@ bool cli_receive_smb(struct cli_state *cli)
return false;
}
if (!cli_check_sign_mac(cli, cli->inbuf)) {
mid = SVAL(cli->inbuf,smb_mid);
seqnum = cli_state_get_seqnum(cli, mid);
if (!cli_check_sign_mac(cli, cli->inbuf, seqnum+1)) {
/*
* If we get a signature failure in sessionsetup, then
* the server sometimes just reflects the sent signature
@ -264,12 +342,20 @@ bool cli_send_smb(struct cli_state *cli)
ssize_t ret;
char *buf_out = cli->outbuf;
bool enc_on = cli_encryption_on(cli);
uint32_t seqnum;
/* fd == -1 causes segfaults -- Tom (tom@ninja.nl) */
if (cli->fd == -1)
return false;
cli_calculate_sign_mac(cli, cli->outbuf);
cli_calculate_sign_mac(cli, cli->outbuf, &seqnum);
if (!cli_state_set_seqnum(cli, cli->mid, seqnum)) {
DEBUG(0,("Failed to store mid[%u]/seqnum[%u]\n",
(unsigned int)cli->mid,
(unsigned int)seqnum));
return false;
}
if (enc_on) {
NTSTATUS status = cli_encrypt_message(cli, cli->outbuf,
@ -506,6 +592,7 @@ struct cli_state *cli_initialise_ex(int signing_state)
cli->bufsize = CLI_BUFFER_SIZE+4;
cli->max_xmit = cli->bufsize;
cli->outbuf = (char *)SMB_MALLOC(cli->bufsize+SAFETY_MARGIN);
cli->seqnum = 0;
cli->inbuf = (char *)SMB_MALLOC(cli->bufsize+SAFETY_MARGIN);
cli->oplock_handler = cli_oplock_ack;
cli->case_sensitive = false;
@ -556,9 +643,12 @@ struct cli_state *cli_initialise_ex(int signing_state)
#endif
/* initialise signing */
cli->sign_info.allow_smb_signing = allow_smb_signing;
cli->sign_info.mandatory_signing = mandatory_signing;
cli_null_set_signing(cli);
cli->signing_state = smb_signing_init(cli,
allow_smb_signing,
mandatory_signing);
if (!cli->signing_state) {
goto error;
}
cli->initialised = 1;
@ -641,7 +731,6 @@ void cli_shutdown(struct cli_state *cli)
SAFE_FREE(cli->outbuf);
SAFE_FREE(cli->inbuf);
cli_free_signing_context(cli);
data_blob_free(&cli->secblob);
data_blob_free(&cli->user_session_key);
@ -740,7 +829,6 @@ static void cli_echo_recv_helper(struct async_req *req)
cli_req->data.echo.num_echos -= 1;
if (cli_req->data.echo.num_echos == 0) {
client_set_trans_sign_state_off(cli_req->cli, cli_req->mid);
async_req_done(req);
return;
}
@ -782,8 +870,6 @@ struct async_req *cli_echo_send(TALLOC_CTX *mem_ctx, struct event_context *ev,
}
req = talloc_get_type_abort(result->private_data, struct cli_request);
client_set_trans_sign_state_on(cli, req->mid);
req->data.echo.num_echos = num_echos;
req->data.echo.data.data = talloc_move(req, &data_copy);
req->data.echo.data.length = data.length;

34
source3/libsmb/clikrb5.c
View File

@ -878,24 +878,30 @@ failed:
bool get_krb5_smb_session_key(krb5_context context, krb5_auth_context auth_context, DATA_BLOB *session_key, bool remote)
{
krb5_keyblock *skey;
krb5_error_code err;
bool ret = False;
krb5_keyblock *skey = NULL;
krb5_error_code err = 0;
bool ret = false;
if (remote)
if (remote) {
err = krb5_auth_con_getremotesubkey(context, auth_context, &skey);
else
err = krb5_auth_con_getlocalsubkey(context, auth_context, &skey);
if (err == 0 && skey != NULL) {
DEBUG(10, ("Got KRB5 session key of length %d\n", (int)KRB5_KEY_LENGTH(skey)));
*session_key = data_blob(KRB5_KEY_DATA(skey), KRB5_KEY_LENGTH(skey));
dump_data_pw("KRB5 Session Key:\n", session_key->data, session_key->length);
ret = True;
krb5_free_keyblock(context, skey);
} else {
err = krb5_auth_con_getlocalsubkey(context, auth_context, &skey);
}
if (err || skey == NULL) {
DEBUG(10, ("KRB5 error getting session key %d\n", err));
goto done;
}
DEBUG(10, ("Got KRB5 session key of length %d\n", (int)KRB5_KEY_LENGTH(skey)));
*session_key = data_blob(KRB5_KEY_DATA(skey), KRB5_KEY_LENGTH(skey));
dump_data_pw("KRB5 Session Key:\n", session_key->data, session_key->length);
ret = true;
done:
if (skey) {
krb5_free_keyblock(context, skey);
}
return ret;

87
source3/libsmb/clisigning.c Normal file
View File

@ -0,0 +1,87 @@
/*
Unix SMB/CIFS implementation.
SMB Signing Code
Copyright (C) Jeremy Allison 2003.
Copyright (C) Andrew Bartlett <abartlet@samba.org> 2002-2003
Copyright (C) Stefan Metzmacher 2009
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "includes.h"
bool cli_simple_set_signing(struct cli_state *cli,
const DATA_BLOB user_session_key,
const DATA_BLOB response)
{
bool ok;
ok = smb_signing_activate(cli->signing_state,
user_session_key,
response);
if (!ok) {
return false;
}
cli->readbraw_supported = false;
cli->writebraw_supported = false;
return true;
}
bool cli_temp_set_signing(struct cli_state *cli)
{
return smb_signing_set_bsrspyl(cli->signing_state);
}
void cli_calculate_sign_mac(struct cli_state *cli, char *buf, uint32_t *seqnum)
{
*seqnum = smb_signing_next_seqnum(cli->signing_state, false);
smb_signing_sign_pdu(cli->signing_state, (uint8_t *)buf, *seqnum);
}
bool cli_check_sign_mac(struct cli_state *cli, const char *buf, uint32_t seqnum)
{
bool ok;
ok = smb_signing_check_pdu(cli->signing_state,
(const uint8_t *)buf,
seqnum);
if (!ok) {
return false;
}
return true;
}
void cli_set_signing_negotiated(struct cli_state *cli)
{
smb_signing_set_negotiated(cli->signing_state);
}
bool client_is_signing_on(struct cli_state *cli)
{
return smb_signing_is_active(cli->signing_state);
}
bool client_is_signing_allowed(struct cli_state *cli)
{
return smb_signing_is_allowed(cli->signing_state);
}
bool client_is_signing_mandatory(struct cli_state *cli)
{
return smb_signing_is_mandatory(cli->signing_state);
}

54
source3/libsmb/clitrans.c
View File

@ -94,14 +94,12 @@ bool cli_send_trans(struct cli_state *cli, int trans,
return False;
}
/* Note we're in a trans state. Save the sequence
* numbers for replies. */
client_set_trans_sign_state_on(cli, mid);
cli_state_seqnum_persistent(cli, mid);
if (this_ldata < ldata || this_lparam < lparam) {
/* receive interim response */
if (!cli_receive_smb(cli) || cli_is_error(cli)) {
client_set_trans_sign_state_off(cli, mid);
cli_state_seqnum_remove(cli, mid);
return(False);
}
@ -137,12 +135,11 @@ bool cli_send_trans(struct cli_state *cli, int trans,
show_msg(cli->outbuf);
client_set_trans_sign_state_off(cli, mid);
cli->mid = mid;
if (!cli_send_smb(cli)) {
cli_state_seqnum_remove(cli, mid);
return False;
}
client_set_trans_sign_state_on(cli, mid);
tot_data += this_ldata;
tot_param += this_lparam;
@ -165,10 +162,14 @@ bool cli_receive_trans(struct cli_state *cli,int trans,
unsigned int this_data,this_param;
NTSTATUS status;
bool ret = False;
uint16_t mid;
*data_len = *param_len = 0;
mid = SVAL(cli->inbuf,smb_mid);
if (!cli_receive_smb(cli)) {
cli_state_seqnum_remove(cli, mid);
return False;
}
@ -179,6 +180,7 @@ bool cli_receive_trans(struct cli_state *cli,int trans,
DEBUG(0,("Expected %s response, got command 0x%02x\n",
trans==SMBtrans?"SMBtrans":"SMBtrans2",
CVAL(cli->inbuf,smb_com)));
cli_state_seqnum_remove(cli, mid);
return False;
}
@ -331,6 +333,8 @@ bool cli_receive_trans(struct cli_state *cli,int trans,
out:
cli_state_seqnum_remove(cli, mid);
if (ret) {
/* Ensure the last 2 bytes of param and data are 2 null
* bytes. These are malloc'ed, but not included in any
@ -344,7 +348,6 @@ bool cli_receive_trans(struct cli_state *cli,int trans,
}
}
client_set_trans_sign_state_off(cli, SVAL(cli->inbuf,smb_mid));
return ret;
}
@ -412,14 +415,12 @@ bool cli_send_nt_trans(struct cli_state *cli,
return False;
}
/* Note we're in a trans state. Save the sequence
* numbers for replies. */
client_set_trans_sign_state_on(cli, mid);
cli_state_seqnum_persistent(cli, mid);
if (this_ldata < ldata || this_lparam < lparam) {
/* receive interim response */
if (!cli_receive_smb(cli) || cli_is_error(cli)) {
client_set_trans_sign_state_off(cli, mid);
cli_state_seqnum_remove(cli, mid);
return(False);
}
@ -454,12 +455,11 @@ bool cli_send_nt_trans(struct cli_state *cli,
show_msg(cli->outbuf);
client_set_trans_sign_state_off(cli, mid);
cli->mid = mid;
if (!cli_send_smb(cli)) {
cli_state_seqnum_remove(cli, mid);
return False;
}
client_set_trans_sign_state_on(cli, mid);
tot_data += this_ldata;
tot_param += this_lparam;
@ -483,10 +483,14 @@ bool cli_receive_nt_trans(struct cli_state *cli,
uint8 eclass;
uint32 ecode;
bool ret = False;
uint16_t mid;
*data_len = *param_len = 0;
mid = SVAL(cli->inbuf,smb_mid);
if (!cli_receive_smb(cli)) {
cli_state_seqnum_remove(cli, mid);
return False;
}
@ -496,6 +500,7 @@ bool cli_receive_nt_trans(struct cli_state *cli,
if (CVAL(cli->inbuf,smb_com) != SMBnttrans) {
DEBUG(0,("Expected SMBnttrans response, got command 0x%02x\n",
CVAL(cli->inbuf,smb_com)));
cli_state_seqnum_remove(cli, mid);
return(False);
}
@ -669,6 +674,8 @@ bool cli_receive_nt_trans(struct cli_state *cli,
out:
cli_state_seqnum_remove(cli, mid);
if (ret) {
/* Ensure the last 2 bytes of param and data are 2 null
* bytes. These are malloc'ed, but not included in any
@ -682,7 +689,6 @@ bool cli_receive_nt_trans(struct cli_state *cli,
}
}
client_set_trans_sign_state_off(cli, SVAL(cli->inbuf,smb_mid));
return ret;
}
@ -696,6 +702,7 @@ struct cli_trans_state {
struct event_context *ev;
uint8_t cmd;
uint16_t mid;
uint32_t seqnum;
const char *pipe_name;
uint16_t fid;
uint16_t function;
@ -919,6 +926,7 @@ static struct async_req *cli_ship_trans(TALLOC_CTX *mem_ctx,
cli_req = talloc_get_type_abort(result->private_data,
struct cli_request);
state->mid = cli_req->mid;
state->seqnum = cli_req->seqnum;
} else {
uint16_t num_bytes = talloc_get_size(bytes);
/*
@ -939,12 +947,10 @@ static struct async_req *cli_ship_trans(TALLOC_CTX *mem_ctx,
cli_req->recv_helper.fn = cli_trans_recv_helper;
cli_req->recv_helper.priv = state;
cli_req->mid = state->mid;
client_set_trans_sign_state_off(state->cli, state->mid);
cli_chain_uncork(state->cli);
state->seqnum = cli_req->seqnum;
}
client_set_trans_sign_state_on(state->cli, state->mid);
fail:
TALLOC_FREE(frame);
return result;
@ -953,6 +959,8 @@ static struct async_req *cli_ship_trans(TALLOC_CTX *mem_ctx,
static void cli_trans_ship_rest(struct async_req *req,
struct cli_trans_state *state)
{
struct cli_request *cli_req;
state->secondary_request_ctx = talloc_new(state);
if (state->secondary_request_ctx == NULL) {
async_req_nterror(req, NT_STATUS_NO_MEMORY);
@ -961,14 +969,19 @@ static void cli_trans_ship_rest(struct async_req *req,
while ((state->param_sent < state->num_param)
|| (state->data_sent < state->num_data)) {
struct async_req *cli_req;
struct async_req *subreq;
cli_req = cli_ship_trans(state->secondary_request_ctx, state);
if (cli_req == NULL) {
subreq = cli_ship_trans(state->secondary_request_ctx, state);
if (subreq == NULL) {
async_req_nterror(req, NT_STATUS_NO_MEMORY);
return;
}
}
cli_req = talloc_get_type_abort(req->private_data,
struct cli_request);
cli_req->seqnum = state->seqnum;
}
static NTSTATUS cli_pull_trans(struct async_req *req,
@ -1174,7 +1187,6 @@ static void cli_trans_recv_helper(struct async_req *req)
if ((state->rparam.total == state->rparam.received)
&& (state->rdata.total == state->rdata.received)) {
client_set_trans_sign_state_off(state->cli, state->mid);
async_req_done(req);
}
}

2
source3/libsmb/dsgetdcname.c
View File

@ -311,7 +311,7 @@ static uint32_t get_cldap_reply_server_flags(struct netlogon_samlogon_response *
/****************************************************************
****************************************************************/
#define RETURN_ON_FALSE(x) if (!x) return false;
#define RETURN_ON_FALSE(x) if (!(x)) return false;
static bool check_cldap_reply_required_flags(uint32_t ret_flags,
uint32_t req_flags)

8
source3/libsmb/libsmb_dir.c
View File

@ -1171,7 +1171,8 @@ SMBC_mkdir_ctx(SMBCCTX *context,
srv->cli, path,
&targetcli, &targetpath)) {
d_printf("Could not resolve %s\n", path);
TALLOC_FREE(frame);
errno = ENOENT;
TALLOC_FREE(frame);
return -1;
}
/*d_printf(">>>mkdir: resolved path as %s\n", targetpath);*/
@ -1278,6 +1279,7 @@ SMBC_rmdir_ctx(SMBCCTX *context,
srv->cli, path,
&targetcli, &targetpath)) {
d_printf("Could not resolve %s\n", path);
errno = ENOENT;
TALLOC_FREE(frame);
return -1;
}
@ -1561,6 +1563,7 @@ SMBC_chmod_ctx(SMBCCTX *context,
srv->cli, path,
&targetcli, &targetpath)) {
d_printf("Could not resolve %s\n", path);
errno = ENOENT;
TALLOC_FREE(frame);
return -1;
}
@ -1753,6 +1756,7 @@ SMBC_unlink_ctx(SMBCCTX *context,
srv->cli, path,
&targetcli, &targetpath)) {
d_printf("Could not resolve %s\n", path);
errno = ENOENT;
TALLOC_FREE(frame);
return -1;
}
@ -1927,6 +1931,7 @@ SMBC_rename_ctx(SMBCCTX *ocontext,
path1,
&targetcli1, &targetpath1)) {
d_printf("Could not resolve %s\n", path1);
errno = ENOENT;
TALLOC_FREE(frame);
return -1;
}
@ -1944,6 +1949,7 @@ SMBC_rename_ctx(SMBCCTX *ocontext,
path2,
&targetcli2, &targetpath2)) {
d_printf("Could not resolve %s\n", path2);
errno = ENOENT;
TALLOC_FREE(frame);
return -1;
}

7
source3/libsmb/libsmb_file.c
View File

@ -119,6 +119,7 @@ SMBC_open_ctx(SMBCCTX *context,
srv->cli, path,
&targetcli, &targetpath)) {
d_printf("Could not resolve %s\n", path);
errno = ENOENT;
SAFE_FREE(file);
TALLOC_FREE(frame);
return NULL;
@ -300,6 +301,7 @@ SMBC_read_ctx(SMBCCTX *context,
file->srv->cli, path,
&targetcli, &targetpath)) {
d_printf("Could not resolve %s\n", path);
errno = ENOENT;
TALLOC_FREE(frame);
return -1;
}
@ -390,6 +392,7 @@ SMBC_write_ctx(SMBCCTX *context,
file->srv->cli, path,
&targetcli, &targetpath)) {
d_printf("Could not resolve %s\n", path);
errno = ENOENT;
TALLOC_FREE(frame);
return -1;
}
@ -466,6 +469,7 @@ SMBC_close_ctx(SMBCCTX *context,
file->srv->cli, path,
&targetcli, &targetpath)) {
d_printf("Could not resolve %s\n", path);
errno = ENOENT;
TALLOC_FREE(frame);
return -1;
}
@ -549,6 +553,7 @@ SMBC_getatr(SMBCCTX * context,
srv->cli, fixedpath,
&targetcli, &targetpath)) {
d_printf("Couldn't resolve %s\n", path);
errno = ENOENT;
TALLOC_FREE(frame);
return False;
}
@ -762,6 +767,7 @@ SMBC_lseek_ctx(SMBCCTX *context,
file->srv->cli, path,
&targetcli, &targetpath)) {
d_printf("Could not resolve %s\n", path);
errno = ENOENT;
TALLOC_FREE(frame);
return -1;
}
@ -854,6 +860,7 @@ SMBC_ftruncate_ctx(SMBCCTX *context,
file->srv->cli, path,
&targetcli, &targetpath)) {
d_printf("Could not resolve %s\n", path);
errno = ENOENT;
TALLOC_FREE(frame);
return -1;
}

1
source3/libsmb/libsmb_stat.c
View File

@ -261,6 +261,7 @@ SMBC_fstat_ctx(SMBCCTX *context,
file->srv->cli, path,
&targetcli, &targetpath)) {
d_printf("Could not resolve %s\n", path);
errno = ENOENT;
TALLOC_FREE(frame);
return -1;
}

3
source3/libsmb/smb_seal.c
View File

@ -136,7 +136,7 @@ NTSTATUS common_ntlm_encrypt_buffer(NTLMSSP_STATE *ntlmssp_state,
smb_set_enclen(buf_out, smb_len(buf) + NTLMSSP_SIG_SIZE, enc_ctx_num);
sig = data_blob(NULL, NTLMSSP_SIG_SIZE);
ZERO_STRUCT(sig);
status = ntlmssp_seal_packet(ntlmssp_state,
(unsigned char *)buf_out + 8 + NTLMSSP_SIG_SIZE, /* 4 byte len + 0xFF 'S' <enc> <ctx> */
@ -153,6 +153,7 @@ NTSTATUS common_ntlm_encrypt_buffer(NTLMSSP_STATE *ntlmssp_state,
/* First 16 data bytes are signature for SSPI compatibility. */
memcpy(buf_out + 8, sig.data, NTLMSSP_SIG_SIZE);
data_blob_free(&sig);
*ppbuf_out = buf_out;
return NT_STATUS_OK;
}

1054
source3/libsmb/smb_signing.c
View File

File diff suppressed because it is too large Load Diff

2
source3/libsmb/unexpected.c
View File

@ -162,6 +162,8 @@ static int traverse_match(TDB_CONTEXT *ttdb, TDB_DATA kbuf, TDB_DATA dbuf,
state->match_type,
ip,
port);
if (!p)
return 0;
if ((state->match_type == NMB_PACKET &&
p->packet.nmb.header.name_trn_id == state->match_id) ||

3
source3/locking/locking.c
View File

@ -887,7 +887,8 @@ struct share_mode_lock *fetch_share_mode_unlocked(TALLOC_CTX *mem_ctx,
}
if (!fill_share_mode_lock(lck, id, servicepath, fname, data, NULL)) {
DEBUG(3, ("fill_share_mode_lock failed\n"));
DEBUG(10, ("fetch_share_mode_unlocked: no share_mode record "
"around (file not open)\n"));
TALLOC_FREE(lck);
return NULL;
}

2
source3/modules/nfs4_acls.c
View File

@ -315,7 +315,7 @@ static NTSTATUS smb_get_nt_acl_nfs4_common(const SMB_STRUCT_STAT *sbuf,
}
DEBUG(10, ("smb_get_nt_acl_nfs4_common successfully exited with sd_size %d\n",
ndr_size_security_descriptor(*ppdesc, 0)));
ndr_size_security_descriptor(*ppdesc, NULL, 0)));
return NT_STATUS_OK;
}

10
source3/modules/onefs_acl.c
View File

@ -825,7 +825,7 @@ NTSTATUS onefs_samba_sd_to_sd(uint32 security_info_sent, SEC_DESC *psd,
/* Setup owner */
if (security_info_sent & OWNER_SECURITY_INFORMATION) {
if (!onefs_og_to_identity(psd->owner_sid, &owner, false, snum))
return NT_STATUS_UNSUCCESSFUL;
return NT_STATUS_ACCESS_DENIED;
SMB_ASSERT(owner.id.uid >= 0);
@ -835,7 +835,7 @@ NTSTATUS onefs_samba_sd_to_sd(uint32 security_info_sent, SEC_DESC *psd,
/* Setup group */
if (security_info_sent & GROUP_SECURITY_INFORMATION) {
if (!onefs_og_to_identity(psd->group_sid, &group, true, snum))
return NT_STATUS_UNSUCCESSFUL;
return NT_STATUS_ACCESS_DENIED;
SMB_ASSERT(group.id.gid >= 0);
@ -846,7 +846,7 @@ NTSTATUS onefs_samba_sd_to_sd(uint32 security_info_sent, SEC_DESC *psd,
if ((security_info_sent & DACL_SECURITY_INFORMATION) && (psd->dacl)) {
if (!onefs_samba_acl_to_acl(psd->dacl, &daclp, &ignore_aces,
snum))
return NT_STATUS_UNSUCCESSFUL;
return NT_STATUS_ACCESS_DENIED;
if (ignore_aces == true)
security_info_sent &= ~DACL_SECURITY_INFORMATION;
@ -863,7 +863,7 @@ NTSTATUS onefs_samba_sd_to_sd(uint32 security_info_sent, SEC_DESC *psd,
if (psd->sacl) {
if (!onefs_samba_acl_to_acl(psd->sacl,
&saclp, &ignore_aces, snum))
return NT_STATUS_UNSUCCESSFUL;
return NT_STATUS_ACCESS_DENIED;
if (ignore_aces == true) {
security_info_sent &=
@ -877,7 +877,7 @@ NTSTATUS onefs_samba_sd_to_sd(uint32 security_info_sent, SEC_DESC *psd,
DEBUG(5,("Setting up SD\n"));
if (aclu_initialize_sd(sd, psd->type, ownerp, groupp,
(daclp ? &daclp : NULL), (saclp ? &saclp : NULL), false))
return NT_STATUS_UNSUCCESSFUL;
return NT_STATUS_ACCESS_DENIED;
return NT_STATUS_OK;
}

13
source3/modules/onefs_open.c
View File

@ -208,14 +208,14 @@ static NTSTATUS onefs_open_file(files_struct *fsp,
if ((oplock_request & ~SAMBA_PRIVATE_OPLOCK_MASK) !=
NO_OPLOCK) {
DEBUG(0,("Oplock(%d) being requested on a stream! "
"Ignoring oplock request: base=%s, stream=%s",
"Ignoring oplock request: base=%s, stream=%s\n",
oplock_request & ~SAMBA_PRIVATE_OPLOCK_MASK,
base, stream));
/* Recover by requesting NO_OPLOCK instead. */
oplock_request &= SAMBA_PRIVATE_OPLOCK_MASK;
}
DEBUG(10,("Opening a stream: base=%s(%d), stream=%s",
DEBUG(10,("Opening a stream: base=%s(%d), stream=%s\n",
base, fsp->base_fsp->fh->fd, stream));
base_fd = fsp->base_fsp->fh->fd;
@ -386,15 +386,6 @@ static void defer_open(struct share_mode_lock *lck,
exit_server("push_deferred_smb_message failed");
}
add_deferred_open(lck, req->mid, request_time, state->id);
/*
* Push the MID of this packet on the signing queue.
* We only do this once, the first time we push the packet
* onto the deferred open queue, as this has a side effect
* of incrementing the response sequence number.
*/
srv_defer_sign_response(req->mid);
}
static void schedule_defer_open(struct share_mode_lock *lck,

52
source3/modules/perfcount_onefs.c
View File

@ -20,8 +20,11 @@
#include "includes.h"
#include <sys/isi_stats_protocol.h>
#include <sys/isi_stats_client.h>
#include <sys/isi_stats_cifs.h>
extern struct current_user current_user;
struct onefs_op_counter {
struct isp_op_delta iod;
struct onefs_op_counter *next;
@ -282,42 +285,64 @@ static void onefs_smb_statistics_defer_op(struct smb_perfcount_data *pcd,
pcd->context = NULL;
}
static void onefs_smb_statistics_set_client(struct smb_perfcount_data *pcd,
uid_t uid, const char *user,
const char *domain)
{
// not implemented...
return;
}
static void onefs_smb_statistics_end(struct smb_perfcount_data *pcd)
{
struct onefs_stats_context *ctxt = pcd->context;
struct onefs_op_counter *tmp;
uint64_t uid;
static in_addr_t rem_addr = 0;
static in_addr_t loc_addr = 0;
/* not enabled */
if (pcd->context == NULL)
return;
uid = current_user.ut.uid ? current_user.ut.uid : ISC_UNKNOWN_CLIENT_ID;
/* get address info once, doesn't change for process */
if (rem_addr == 0) {
struct sockaddr_storage sa;
socklen_t sa_len;
int fd = smbd_server_fd();
sa_len = sizeof sa;
if (getpeername(fd, (struct sockaddr *)&sa, &sa_len) == 0 &&
sa.ss_family == AF_INET)
rem_addr = ((struct sockaddr_in *)&sa)->sin_addr.s_addr;
else
rem_addr = ISC_MASKED_ADDR;
sa_len = sizeof sa;
if (getsockname(fd, (struct sockaddr *)&sa, &sa_len) == 0 &&
sa.ss_family == AF_INET)
loc_addr = ((struct sockaddr_in *)&sa)->sin_addr.s_addr;
else
loc_addr = ISC_MASKED_ADDR;
}
/*
* bug here - we aren't getting the outlens right,
* when dealing w/ chained requests.
*/
for (tmp = ctxt->ops_chain; tmp; tmp = tmp->next) {
tmp->iod.out_bytes = ctxt->iod.out_bytes;
isc_cookie_init(&tmp->iod.cookie, rem_addr, loc_addr, uid);
ISP_OP_END(&tmp->iod);
#ifdef ONEFS_PERF_DEBUG
DEBUG(0,("******** Finalized CHAIN op %s in:%llu, out:%llu\n",
onefs_stat_debug(&tmp->iod),
DEBUG(0,("******** Finalized CHAIN op %s uid %llu in:%llu"
", out:%llu\n",
onefs_stat_debug(&tmp->iod), uid,
tmp->iod.in_bytes, tmp->iod.out_bytes));
#endif
SAFE_FREE(tmp->prev);
}
ISP_OP_END(&ctxt->iod);
isc_cookie_init(&ctxt->iod.cookie, rem_addr, loc_addr, uid);
ISP_OP_END(&ctxt->iod);
#ifdef ONEFS_PERF_DEBUG
DEBUG(0,("******** Finalized op %s in:%llu, out:%llu\n",
onefs_stat_debug(&ctxt->iod),
DEBUG(0,("******** Finalized op %s uid %llu in:%llu, out:%llu\n",
onefs_stat_debug(&ctxt->iod), uid,
ctxt->iod.in_bytes, ctxt->iod.out_bytes));
#endif
@ -338,7 +363,6 @@ static struct smb_perfcount_handlers onefs_pc_handlers = {
onefs_smb_statistics_set_ioctl,
onefs_smb_statistics_set_msglen_in,
onefs_smb_statistics_set_msglen_out,
onefs_smb_statistics_set_client,
onefs_smb_statistics_copy_context,
onefs_smb_statistics_defer_op,
onefs_smb_statistics_end

9
source3/modules/perfcount_test.c
View File

@ -351,14 +351,6 @@ static void perfcount_test_defer_op(struct smb_perfcount_data *pcd,
return;
}
static void perfcount_test_set_client(struct smb_perfcount_data *pcd,
uid_t uid, const char *user,
const char *domain)
{
/* WIP */
return;
}
static void perfcount_test_end(struct smb_perfcount_data *pcd)
{
struct perfcount_test_context *ctxt =
@ -382,7 +374,6 @@ static struct smb_perfcount_handlers perfcount_test_handlers = {
perfcount_test_set_ioctl,
perfcount_test_set_msglen_in,
perfcount_test_set_msglen_out,
perfcount_test_set_client,
perfcount_test_copy_context,
perfcount_test_defer_op,
perfcount_test_end

194
source3/modules/vfs_dirsort.c Normal file
View File

@ -0,0 +1,194 @@
/*
* VFS module to provide a sorted directory list.
*
* Copyright (C) Andy Kelk (andy@mopoke.co.uk), 2009
*
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see <http://www.gnu.org/licenses/>.
*/
#include "includes.h"
static int compare_dirent (const void *a, const void *b) {
const SMB_STRUCT_DIRENT *da = (const SMB_STRUCT_DIRENT *) a;
const SMB_STRUCT_DIRENT *db = (const SMB_STRUCT_DIRENT *) b;
return StrCaseCmp(da->d_name, db->d_name);
}
struct dirsort_privates {
long pos;
SMB_STRUCT_DIRENT *directory_list;
long number_of_entries;
time_t mtime;
SMB_STRUCT_DIR *source_directory;
int fd;
};
static void free_dirsort_privates(void **datap) {
struct dirsort_privates *data = (struct dirsort_privates *) *datap;
SAFE_FREE(data->directory_list);
SAFE_FREE(data);
*datap = NULL;
return;
}
static void open_and_sort_dir (vfs_handle_struct *handle)
{
SMB_STRUCT_DIRENT *dp;
struct stat dir_stat;
long current_pos;
struct dirsort_privates *data = NULL;
SMB_VFS_HANDLE_GET_DATA(handle, data, struct dirsort_privates, return);
data->number_of_entries = 0;
if (fstat(data->fd, &dir_stat) == 0) {
data->mtime = dir_stat.st_mtime;
}
while (SMB_VFS_NEXT_READDIR(handle, data->source_directory, NULL)
!= NULL) {
data->number_of_entries++;
}
/* Open the underlying directory and count the number of entries
Skip back to the beginning as we'll read it again */
SMB_VFS_NEXT_REWINDDIR(handle, data->source_directory);
/* Set up an array and read the directory entries into it */
SAFE_FREE(data->directory_list); /* destroy previous cache if needed */
data->directory_list = (SMB_STRUCT_DIRENT *)SMB_MALLOC(
data->number_of_entries * sizeof(SMB_STRUCT_DIRENT));
current_pos = data->pos;
data->pos = 0;
while ((dp = SMB_VFS_NEXT_READDIR(handle, data->source_directory,
NULL)) != NULL) {
data->directory_list[data->pos++] = *dp;
}
/* Sort the directory entries by name */
data->pos = current_pos;
qsort(data->directory_list, data->number_of_entries,
sizeof(SMB_STRUCT_DIRENT), compare_dirent);
}
static SMB_STRUCT_DIR *dirsort_opendir(vfs_handle_struct *handle,
const char *fname, const char *mask,
uint32 attr)
{
struct dirsort_privates *data = NULL;
/* set up our private data about this directory */
data = (struct dirsort_privates *)SMB_MALLOC(
sizeof(struct dirsort_privates));
data->directory_list = NULL;
data->pos = 0;
/* Open the underlying directory and count the number of entries */
data->source_directory = SMB_VFS_NEXT_OPENDIR(handle, fname, mask,
attr);
data->fd = dirfd(data->source_directory);
SMB_VFS_HANDLE_SET_DATA(handle, data, free_dirsort_privates,
struct dirsort_privates, return NULL);
open_and_sort_dir(handle);
return data->source_directory;
}
static SMB_STRUCT_DIRENT *dirsort_readdir(vfs_handle_struct *handle,
SMB_STRUCT_DIR *dirp)
{
struct dirsort_privates *data = NULL;
time_t current_mtime;
struct stat dir_stat;
SMB_VFS_HANDLE_GET_DATA(handle, data, struct dirsort_privates,
return NULL);
if (fstat(data->fd, &dir_stat) == -1) {
return NULL;
}
current_mtime = dir_stat.st_mtime;
/* throw away cache and re-read the directory if we've changed */
if (current_mtime > data->mtime) {
open_and_sort_dir(handle);
}
if (data->pos >= data->number_of_entries) {
return NULL;
}
return &data->directory_list[data->pos++];
}
static void dirsort_seekdir(vfs_handle_struct *handle, SMB_STRUCT_DIR *dirp,
long offset)
{
struct dirsort_privates *data = NULL;
SMB_VFS_HANDLE_GET_DATA(handle, data, struct dirsort_privates, return);
data->pos = offset;
}
static long dirsort_telldir(vfs_handle_struct *handle, SMB_STRUCT_DIR *dirp)
{
struct dirsort_privates *data = NULL;
SMB_VFS_HANDLE_GET_DATA(handle, data, struct dirsort_privates,
return -1);
return data->pos;
}
static void dirsort_rewinddir(vfs_handle_struct *handle, SMB_STRUCT_DIR *dirp)
{
struct dirsort_privates *data = NULL;
SMB_VFS_HANDLE_GET_DATA(handle, data, struct dirsort_privates, return);
data->pos = 0;
}
/* VFS operations structure */
static vfs_op_tuple dirsort_op_tuples[] = {
/* Directory operations */
{SMB_VFS_OP(dirsort_opendir), SMB_VFS_OP_OPENDIR,
SMB_VFS_LAYER_TRANSPARENT},
{SMB_VFS_OP(dirsort_readdir), SMB_VFS_OP_READDIR,
SMB_VFS_LAYER_TRANSPARENT},
{SMB_VFS_OP(dirsort_seekdir), SMB_VFS_OP_SEEKDIR,
SMB_VFS_LAYER_TRANSPARENT},
{SMB_VFS_OP(dirsort_telldir), SMB_VFS_OP_TELLDIR,
SMB_VFS_LAYER_TRANSPARENT},
{SMB_VFS_OP(dirsort_rewinddir), SMB_VFS_OP_REWINDDIR,
SMB_VFS_LAYER_TRANSPARENT},
{NULL, SMB_VFS_OP_NOOP,
SMB_VFS_LAYER_NOOP}
};
NTSTATUS vfs_dirsort_init(void)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "dirsort",
dirsort_op_tuples);
}

4
source3/modules/vfs_streams_depot.c
View File

@ -78,7 +78,7 @@ static bool file_is_valid(vfs_handle_struct *handle, const char *path,
DEBUG(10, ("file_is_valid (%s) called\n", path));
if (SMB_VFS_NEXT_GETXATTR(handle, path, SAMBA_XATTR_MARKER,
if (SMB_VFS_GETXATTR(handle->conn, path, SAMBA_XATTR_MARKER,
&buf, sizeof(buf)) != sizeof(buf)) {
DEBUG(10, ("GETXATTR failed: %s\n", strerror(errno)));
return false;
@ -104,7 +104,7 @@ static bool mark_file_valid(vfs_handle_struct *handle, const char *path,
DEBUG(10, ("marking file %s as valid\n", path));
ret = SMB_VFS_NEXT_SETXATTR(handle, path, SAMBA_XATTR_MARKER,
ret = SMB_VFS_SETXATTR(handle->conn, path, SAMBA_XATTR_MARKER,
&buf, sizeof(buf), 0);
if (ret == -1) {

6
source3/nmbd/nmbd.c
View File

@ -988,6 +988,12 @@ static bool open_sockets(bool isdaemon, int port)
exit(1);
}
if (!initialize_nmbd_proxy_logon()) {
DEBUG(0,("ERROR: Failed setup nmbd_proxy_logon.\n"));
kill_async_dns_child();
exit(1);
}
TALLOC_FREE(frame);
process();

3
source3/nmbd/nmbd_elections.c
View File

@ -130,9 +130,6 @@ void check_master_browser_exists(time_t t)
struct subnet_record *subrec;
const char *workgroup_name = lp_workgroup();
if (!lastrun)
lastrun = t;
if (t < (lastrun + (CHECK_TIME_MST_BROWSE * 60)))
return;

238
source3/nmbd/nmbd_processlogon.c
View File

@ -24,6 +24,9 @@
*/
#include "includes.h"
#include "../libcli/netlogon.h"
#include "../libcli/cldap/cldap.h"
#include "../lib/tsocket/tsocket.h"
struct sam_database_info {
uint32 index;
@ -65,6 +68,235 @@ static void delayed_init_logon_handler(struct event_context *event_ctx,
TALLOC_FREE(te);
}
struct nmbd_proxy_logon_context {
struct cldap_socket *cldap_sock;
};
static struct nmbd_proxy_logon_context *global_nmbd_proxy_logon;
bool initialize_nmbd_proxy_logon(void)
{
const char *cldap_server = lp_parm_const_string(-1, "nmbd_proxy_logon",
"cldap_server", NULL);
struct nmbd_proxy_logon_context *ctx;
NTSTATUS status;
struct in_addr addr;
char addrstr[INET_ADDRSTRLEN];
const char *server_str;
int ret;
struct tsocket_address *server_addr;
if (!cldap_server) {
return true;
}
addr = interpret_addr2(cldap_server);
server_str = inet_ntop(AF_INET, &addr,
addrstr, sizeof(addrstr));
if (!server_str || strcmp("0.0.0.0", server_str) == 0) {
DEBUG(0,("Failed to resolve[%s] for nmbd_proxy_logon\n",
cldap_server));
return false;
}
ctx = talloc_zero(nmbd_event_context(),
struct nmbd_proxy_logon_context);
if (!ctx) {
return false;
}
ret = tsocket_address_inet_from_strings(ctx, "ipv4",
server_str, LDAP_PORT,
&server_addr);
if (ret != 0) {
TALLOC_FREE(ctx);
status = map_nt_error_from_unix(errno);
DEBUG(0,("Failed to create cldap tsocket_address for %s - %s\n",
server_str, nt_errstr(status)));
return false;
}
/* we create a connected udp socket */
status = cldap_socket_init(ctx, nmbd_event_context(), NULL,
server_addr, &ctx->cldap_sock);
TALLOC_FREE(server_addr);
if (!NT_STATUS_IS_OK(status)) {
TALLOC_FREE(ctx);
DEBUG(0,("failed to create cldap socket for %s: %s\n",
server_str, nt_errstr(status)));
return false;
}
global_nmbd_proxy_logon = ctx;
return true;
}
struct nmbd_proxy_logon_state {
struct in_addr local_ip;
struct packet_struct *p;
const char *remote_name;
uint8_t remote_name_type;
const char *remote_mailslot;
struct nbt_netlogon_packet req;
struct nbt_netlogon_response resp;
struct cldap_netlogon io;
};
static int nmbd_proxy_logon_state_destructor(struct nmbd_proxy_logon_state *s)
{
s->p->locked = false;
free_packet(s->p);
return 0;
}
static void nmbd_proxy_logon_done(struct tevent_req *subreq);
static void nmbd_proxy_logon(struct nmbd_proxy_logon_context *ctx,
struct in_addr local_ip,
struct packet_struct *p,
uint8_t *buf,
uint32_t len)
{
struct nmbd_proxy_logon_state *state;
enum ndr_err_code ndr_err;
DATA_BLOB blob = data_blob_const(buf, len);
const char *computer_name = NULL;
const char *mailslot_name = NULL;
const char *user_name = NULL;
const char *domain_sid = NULL;
uint32_t acct_control = 0;
uint32_t nt_version = 0;
struct tevent_req *subreq;
fstring source_name;
struct dgram_packet *dgram = &p->packet.dgram;
state = TALLOC_ZERO_P(ctx, struct nmbd_proxy_logon_state);
if (!state) {
DEBUG(0,("failed to allocate nmbd_proxy_logon_state\n"));
return;
}
pull_ascii_nstring(source_name, sizeof(source_name), dgram->source_name.name);
state->remote_name = talloc_strdup(state, source_name);
state->remote_name_type = dgram->source_name.name_type,
state->local_ip = local_ip;
state->p = p;
ndr_err = ndr_pull_struct_blob(
&blob, state, NULL, &state->req,
(ndr_pull_flags_fn_t)ndr_pull_nbt_netlogon_packet);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
DEBUG(0,("failed parse nbt_letlogon_packet: %s\n",
nt_errstr(status)));
TALLOC_FREE(state);
return;
}
if (DEBUGLEVEL >= 10) {
DEBUG(10, ("nmbd_proxy_logon:\n"));
NDR_PRINT_DEBUG(nbt_netlogon_packet, &state->req);
}
switch (state->req.command) {
case LOGON_SAM_LOGON_REQUEST:
computer_name = state->req.req.logon.computer_name;
user_name = state->req.req.logon.user_name;
mailslot_name = state->req.req.logon.mailslot_name;
acct_control = state->req.req.logon.acct_control;
if (state->req.req.logon.sid_size > 0) {
domain_sid = dom_sid_string(state,
&state->req.req.logon.sid);
if (!domain_sid) {
DEBUG(0,("failed to get a string for sid\n"));
TALLOC_FREE(state);
return;
}
}
nt_version = state->req.req.logon.nt_version;
break;
default:
/* this can't happen as the caller already checks the command */
break;
}
state->remote_mailslot = mailslot_name;
if (user_name && strlen(user_name) == 0) {
user_name = NULL;
}
if (computer_name && strlen(computer_name) == 0) {
computer_name = NULL;
}
/*
* as the socket is connected,
* we don't need to specify the destination
*/
state->io.in.dest_address = NULL;
state->io.in.dest_port = 0;
state->io.in.realm = NULL;
state->io.in.host = computer_name;
state->io.in.user = user_name;
state->io.in.domain_guid = NULL;
state->io.in.domain_sid = domain_sid;
state->io.in.acct_control = acct_control;
state->io.in.version = nt_version;
state->io.in.map_response = false;
subreq = cldap_netlogon_send(state,
ctx->cldap_sock,
&state->io);
if (!subreq) {
DEBUG(0,("failed to send cldap netlogon call\n"));
TALLOC_FREE(state);
return;
}
tevent_req_set_callback(subreq, nmbd_proxy_logon_done, state);
/* we reply async */
state->p->locked = true;
talloc_set_destructor(state, nmbd_proxy_logon_state_destructor);
}
static void nmbd_proxy_logon_done(struct tevent_req *subreq)
{
struct nmbd_proxy_logon_state *state =
tevent_req_callback_data(subreq,
struct nmbd_proxy_logon_state);
NTSTATUS status;
DATA_BLOB response;
status = cldap_netlogon_recv(subreq, NULL, state, &state->io);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("failed to recv cldap netlogon call: %s\n",
nt_errstr(status)));
TALLOC_FREE(state);
return;
}
status = push_netlogon_samlogon_response(&response, state, NULL,
&state->io.out.netlogon);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("failed to push netlogon_samlogon_response: %s\n",
nt_errstr(status)));
TALLOC_FREE(state);
return;
}
send_mailslot(true, state->remote_mailslot,
(char *)response.data, response.length,
global_myname(), 0x0,
state->remote_name,
state->remote_name_type,
state->p->ip,
state->local_ip,
state->p->port);
TALLOC_FREE(state);
}
/****************************************************************************
Process a domain logon packet
**************************************************************************/
@ -318,6 +550,12 @@ reporting %s domain %s 0x%x ntversion=%x lm_nt token=%x lm_20 token=%x\n",
char *q = buf + 2;
fstring asccomp;
if (global_nmbd_proxy_logon) {
nmbd_proxy_logon(global_nmbd_proxy_logon,
ip, p, (uint8_t *)buf, len);
return;
}
q += 2;
if (PTR_DIFF(q, buf) >= len) {

15
source3/param/loadparm.c
View File

@ -9542,10 +9542,6 @@ const char *lp_printcapname(void)
return PRINTCAP_NAME;
}
/*******************************************************************
Ensure we don't use sendfile if server smb signing is active.
********************************************************************/
static uint32 spoolss_state;
bool lp_disable_spoolss( void )
@ -9572,15 +9568,20 @@ uint32 lp_get_spoolss_state( void )
Ensure we don't use sendfile if server smb signing is active.
********************************************************************/
bool lp_use_sendfile(int snum)
bool lp_use_sendfile(int snum, struct smb_signing_state *signing_state)
{
bool sign_active = false;
/* Using sendfile blows the brains out of any DOS or Win9x TCP stack... JRA. */
if (Protocol < PROTOCOL_NT1) {
return False;
return false;
}
if (signing_state) {
sign_active = smb_signing_is_active(signing_state);
}
return (_lp_use_sendfile(snum) &&
(get_remote_arch() != RA_WIN95) &&
!srv_is_signing_active());
!sign_active);
}
/*******************************************************************

2
source3/passdb/lookup_sid.c
View File

@ -804,7 +804,7 @@ NTSTATUS lookup_sids(TALLOC_CTX *mem_ctx, int num_sids,
} else {
/* This is a normal SID with rid component */
if (!sid_split_rid(&sid, &rid)) {
result = NT_STATUS_INVALID_PARAMETER;
result = NT_STATUS_INVALID_SID;
goto fail;
}
}

51
source3/passdb/pdb_tdb.c
View File

@ -4,7 +4,7 @@
* Copyright (C) Andrew Tridgell 1992-1998
* Copyright (C) Simo Sorce 2000-2003
* Copyright (C) Gerald Carter 2000-2006
* Copyright (C) Jeremy Allison 2001
* Copyright (C) Jeremy Allison 2001-2009
* Copyright (C) Andrew Bartlett 2002
* Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2005
*
@ -38,7 +38,9 @@ static int tdbsam_debug_level = DBGC_ALL;
#endif
#define TDBSAM_VERSION 4 /* Most recent TDBSAM version */
#define TDBSAM_MINOR_VERSION 0 /* Most recent TDBSAM minor version */
#define TDBSAM_VERSION_STRING "INFO/version"
#define TDBSAM_MINOR_VERSION_STRING "INFO/minor_version"
#define PASSDB_FILE_NAME "passdb.tdb"
#define USERPREFIX "USER_"
#define USERPREFIX_LEN 5
@ -322,7 +324,8 @@ static bool tdbsam_convert(struct db_context **pp_db, const char *name, int32 fr
struct db_context *db = NULL;
int ret;
if (!tdbsam_convert_backup(name, pp_db)) {
/* We only need the update backup for local db's. */
if (db_is_local(name) && !tdbsam_convert_backup(name, pp_db)) {
DEBUG(0, ("tdbsam_convert: Could not backup %s\n", name));
return false;
}
@ -358,6 +361,12 @@ static bool tdbsam_convert(struct db_context **pp_db, const char *name, int32 fr
goto cancel;
}
if (dbwrap_store_int32(db, TDBSAM_MINOR_VERSION_STRING,
TDBSAM_MINOR_VERSION) != 0) {
DEBUG(0, ("tdbsam_convert: Could not store tdbsam minor version\n"));
goto cancel;
}
if (db->transaction_commit(db) != 0) {
DEBUG(0, ("tdbsam_convert: Could not commit transaction\n"));
return false;
@ -381,6 +390,7 @@ static bool tdbsam_convert(struct db_context **pp_db, const char *name, int32 fr
static bool tdbsam_open( const char *name )
{
int32 version;
int32 minor_version;
/* check if we are already open */
@ -403,6 +413,12 @@ static bool tdbsam_open( const char *name )
version = 0; /* Version not found, assume version 0 */
}
/* Get the minor version */
minor_version = dbwrap_fetch_int32(db_sam, TDBSAM_MINOR_VERSION_STRING);
if (minor_version == -1) {
minor_version = 0; /* Minor version not found, assume 0 */
}
/* Compare the version */
if (version > TDBSAM_VERSION) {
/* Version more recent than the latest known */
@ -411,7 +427,9 @@ static bool tdbsam_open( const char *name )
return false;
}
if ( version < TDBSAM_VERSION ) {
if ( version < TDBSAM_VERSION ||
(version == TDBSAM_VERSION &&
minor_version < TDBSAM_MINOR_VERSION) ) {
/*
* Ok - we think we're going to have to convert.
* Due to the backup process we now must do to
@ -436,6 +454,12 @@ static bool tdbsam_open( const char *name )
version = 0; /* Version not found, assume version 0 */
}
/* Re-check the minor version */
minor_version = dbwrap_fetch_int32(db_sam, TDBSAM_MINOR_VERSION_STRING);
if (minor_version == -1) {
minor_version = 0; /* Minor version not found, assume 0 */
}
/* Compare the version */
if (version > TDBSAM_VERSION) {
/* Version more recent than the latest known */
@ -445,9 +469,24 @@ static bool tdbsam_open( const char *name )
return false;
}
if ( version < TDBSAM_VERSION ) {
DEBUG(1, ("tdbsam_open: Converting version %d database to "
"version %d.\n", version, TDBSAM_VERSION));
if ( version < TDBSAM_VERSION ||
(version == TDBSAM_VERSION &&
minor_version < TDBSAM_MINOR_VERSION) ) {
/*
* Note that minor versions we read that are greater
* than the current minor version we have hard coded
* are assumed to be compatible if they have the same
* major version. That allows previous versions of the
* passdb code that don't know about minor versions to
* still use this database. JRA.
*/
DEBUG(1, ("tdbsam_open: Converting version %d.%d database to "
"version %d.%d.\n",
version,
minor_version,
TDBSAM_VERSION,
TDBSAM_MINOR_VERSION));
if ( !tdbsam_convert(&db_sam, name, version) ) {
DEBUG(0, ("tdbsam_open: Error when trying to convert "

11
source3/printing/nt_printing.c
View File

@ -2275,7 +2275,9 @@ static WERROR get_a_printer_driver_3_default(NT_PRINTER_DRIVER_INFO_LEVEL_3 **in
/****************************************************************************
****************************************************************************/
static WERROR get_a_printer_driver_3(NT_PRINTER_DRIVER_INFO_LEVEL_3 **info_ptr, fstring drivername, const char *arch, uint32 version)
static WERROR get_a_printer_driver_3(NT_PRINTER_DRIVER_INFO_LEVEL_3 **info_ptr,
const char *drivername, const char *arch,
uint32_t version)
{
NT_PRINTER_DRIVER_INFO_LEVEL_3 driver;
TDB_DATA dbuf;
@ -4448,7 +4450,7 @@ bool set_driver_init(NT_PRINTER_INFO_LEVEL *printer, uint32 level)
Delete driver init data stored for a specified driver
****************************************************************************/
bool del_driver_init(char *drivername)
bool del_driver_init(const char *drivername)
{
char *key;
bool ret;
@ -4837,8 +4839,9 @@ uint32 add_a_printer_driver(NT_PRINTER_DRIVER_INFO_LEVEL driver, uint32 level)
/****************************************************************************
****************************************************************************/
WERROR get_a_printer_driver(NT_PRINTER_DRIVER_INFO_LEVEL *driver, uint32 level,
fstring drivername, const char *architecture, uint32 version)
WERROR get_a_printer_driver(NT_PRINTER_DRIVER_INFO_LEVEL *driver, uint32_t level,
const char *drivername, const char *architecture,
uint32_t version)
{
WERROR result;

26
source3/registry/regfio.c
View File

@ -712,8 +712,30 @@ static bool hbin_prs_sk_rec( const char *desc, REGF_HBIN *hbin, int depth, REGF_
if ( !prs_uint32( "size", ps, depth, &sk->size))
return False;
if ( !sec_io_desc( "sec_desc", &sk->sec_desc, ps, depth ))
return False;
{
NTSTATUS status;
TALLOC_CTX *mem_ctx = prs_get_mem_context(&hbin->ps);
DATA_BLOB blob;
if (MARSHALLING(&hbin->ps)) {
status = marshall_sec_desc(mem_ctx,
sk->sec_desc,
&blob.data, &blob.length);
if (!NT_STATUS_IS_OK(status))
return False;
if (!prs_copy_data_in(&hbin->ps, (const char *)blob.data, blob.length))
return False;
} else {
blob = data_blob_const(prs_data_p(&hbin->ps),
prs_data_size(&hbin->ps));
status = unmarshall_sec_desc(mem_ctx,
blob.data, blob.length,
&sk->sec_desc);
if (!NT_STATUS_IS_OK(status))
return False;
prs_set_offset(&hbin->ps, blob.length);
}
}
end_off = prs_offset( &hbin->ps );

580
source3/rpc_client/cli_pipe.c
View File

File diff suppressed because it is too large Load Diff

127
source3/rpc_client/rpc_transport_np.c
View File

@ -51,18 +51,19 @@ struct rpc_np_write_state {
static void rpc_np_write_done(struct async_req *subreq);
static struct async_req *rpc_np_write_send(TALLOC_CTX *mem_ctx,
struct event_context *ev,
const uint8_t *data, size_t size,
void *priv)
static struct tevent_req *rpc_np_write_send(TALLOC_CTX *mem_ctx,
struct event_context *ev,
const uint8_t *data, size_t size,
void *priv)
{
struct rpc_transport_np_state *np_transport = talloc_get_type_abort(
priv, struct rpc_transport_np_state);
struct async_req *result, *subreq;
struct tevent_req *req;
struct async_req *subreq;
struct rpc_np_write_state *state;
if (!async_req_setup(mem_ctx, &result, &state,
struct rpc_np_write_state)) {
req = tevent_req_create(mem_ctx, &state, struct rpc_np_write_state);
if (req == NULL) {
return NULL;
}
state->size = size;
@ -75,37 +76,37 @@ static struct async_req *rpc_np_write_send(TALLOC_CTX *mem_ctx,
goto fail;
}
subreq->async.fn = rpc_np_write_done;
subreq->async.priv = result;
return result;
subreq->async.priv = req;
return req;
fail:
TALLOC_FREE(result);
TALLOC_FREE(req);
return NULL;
}
static void rpc_np_write_done(struct async_req *subreq)
{
struct async_req *req = talloc_get_type_abort(
subreq->async.priv, struct async_req);
struct rpc_np_write_state *state = talloc_get_type_abort(
req->private_data, struct rpc_np_write_state);
struct tevent_req *req = talloc_get_type_abort(
subreq->async.priv, struct tevent_req);
struct rpc_np_write_state *state = tevent_req_data(
req, struct rpc_np_write_state);
NTSTATUS status;
status = cli_write_andx_recv(subreq, &state->written);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
async_req_nterror(req, status);
tevent_req_nterror(req, status);
return;
}
async_req_done(req);
tevent_req_done(req);
}
static NTSTATUS rpc_np_write_recv(struct async_req *req, ssize_t *pwritten)
static NTSTATUS rpc_np_write_recv(struct tevent_req *req, ssize_t *pwritten)
{
struct rpc_np_write_state *state = talloc_get_type_abort(
req->private_data, struct rpc_np_write_state);
struct rpc_np_write_state *state = tevent_req_data(
req, struct rpc_np_write_state);
NTSTATUS status;
if (async_req_is_nterror(req, &status)) {
if (tevent_req_is_nterror(req, &status)) {
return status;
}
*pwritten = state->written;
@ -120,18 +121,19 @@ struct rpc_np_read_state {
static void rpc_np_read_done(struct async_req *subreq);
static struct async_req *rpc_np_read_send(TALLOC_CTX *mem_ctx,
struct event_context *ev,
uint8_t *data, size_t size,
void *priv)
static struct tevent_req *rpc_np_read_send(TALLOC_CTX *mem_ctx,
struct event_context *ev,
uint8_t *data, size_t size,
void *priv)
{
struct rpc_transport_np_state *np_transport = talloc_get_type_abort(
priv, struct rpc_transport_np_state);
struct async_req *result, *subreq;
struct tevent_req *req;
struct async_req *subreq;
struct rpc_np_read_state *state;
if (!async_req_setup(mem_ctx, &result, &state,
struct rpc_np_read_state)) {
req = tevent_req_create(mem_ctx, &state, struct rpc_np_read_state);
if (req == NULL) {
return NULL;
}
state->data = data;
@ -143,19 +145,19 @@ static struct async_req *rpc_np_read_send(TALLOC_CTX *mem_ctx,
goto fail;
}
subreq->async.fn = rpc_np_read_done;
subreq->async.priv = result;
return result;
subreq->async.priv = req;
return req;
fail:
TALLOC_FREE(result);
TALLOC_FREE(req);
return NULL;
}
static void rpc_np_read_done(struct async_req *subreq)
{
struct async_req *req = talloc_get_type_abort(
subreq->async.priv, struct async_req);
struct rpc_np_read_state *state = talloc_get_type_abort(
req->private_data, struct rpc_np_read_state);
struct tevent_req *req = talloc_get_type_abort(
subreq->async.priv, struct tevent_req);
struct rpc_np_read_state *state = tevent_req_data(
req, struct rpc_np_read_state);
NTSTATUS status;
uint8_t *rcvbuf;
@ -169,27 +171,27 @@ static void rpc_np_read_done(struct async_req *subreq)
}
if (!NT_STATUS_IS_OK(status)) {
TALLOC_FREE(subreq);
async_req_nterror(req, status);
tevent_req_nterror(req, status);
return;
}
if (state->received > state->size) {
TALLOC_FREE(subreq);
async_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
return;
}
memcpy(state->data, rcvbuf, state->received);
async_req_done(req);
tevent_req_done(req);
}
static NTSTATUS rpc_np_read_recv(struct async_req *req, ssize_t *preceived)
static NTSTATUS rpc_np_read_recv(struct tevent_req *req, ssize_t *preceived)
{
struct rpc_np_read_state *state = talloc_get_type_abort(
req->private_data, struct rpc_np_read_state);
struct rpc_np_read_state *state = tevent_req_data(
req, struct rpc_np_read_state);
NTSTATUS status;
if (async_req_is_nterror(req, &status)) {
if (tevent_req_is_nterror(req, &status)) {
return status;
}
*preceived = state->received;
@ -204,19 +206,20 @@ struct rpc_np_trans_state {
static void rpc_np_trans_done(struct async_req *subreq);
static struct async_req *rpc_np_trans_send(TALLOC_CTX *mem_ctx,
struct event_context *ev,
uint8_t *data, size_t data_len,
uint32_t max_rdata_len,
void *priv)
static struct tevent_req *rpc_np_trans_send(TALLOC_CTX *mem_ctx,
struct event_context *ev,
uint8_t *data, size_t data_len,
uint32_t max_rdata_len,
void *priv)
{
struct rpc_transport_np_state *np_transport = talloc_get_type_abort(
priv, struct rpc_transport_np_state);
struct async_req *result, *subreq;
struct tevent_req *req;
struct async_req *subreq;
struct rpc_np_trans_state *state;
if (!async_req_setup(mem_ctx, &result, &state,
struct rpc_np_trans_state)) {
req = tevent_req_create(mem_ctx, &state, struct rpc_np_trans_state);
if (req == NULL) {
return NULL;
}
@ -231,40 +234,40 @@ static struct async_req *rpc_np_trans_send(TALLOC_CTX *mem_ctx,
goto fail;
}
subreq->async.fn = rpc_np_trans_done;
subreq->async.priv = result;
return result;
subreq->async.priv = req;
return req;
fail:
TALLOC_FREE(result);
TALLOC_FREE(req);
return NULL;
}
static void rpc_np_trans_done(struct async_req *subreq)
{
struct async_req *req = talloc_get_type_abort(
subreq->async.priv, struct async_req);
struct rpc_np_trans_state *state = talloc_get_type_abort(
req->private_data, struct rpc_np_trans_state);
struct tevent_req *req = talloc_get_type_abort(
subreq->async.priv, struct tevent_req);
struct rpc_np_trans_state *state = tevent_req_data(
req, struct rpc_np_trans_state);
NTSTATUS status;
status = cli_trans_recv(subreq, state, NULL, NULL, NULL, NULL,
&state->rdata, &state->rdata_len);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
async_req_nterror(req, status);
tevent_req_nterror(req, status);
return;
}
async_req_done(req);
tevent_req_done(req);
}
static NTSTATUS rpc_np_trans_recv(struct async_req *req, TALLOC_CTX *mem_ctx,
static NTSTATUS rpc_np_trans_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
uint8_t **prdata, uint32_t *prdata_len)
{
struct rpc_np_trans_state *state = talloc_get_type_abort(
req->private_data, struct rpc_np_trans_state);
struct rpc_np_trans_state *state = tevent_req_data(
req, struct rpc_np_trans_state);
NTSTATUS status;
if (async_req_is_nterror(req, &status)) {
if (tevent_req_is_nterror(req, &status)) {
return status;
}
*prdata = talloc_move(mem_ctx, &state->rdata);

93
source3/rpc_client/rpc_transport_smbd.c
View File

@ -432,20 +432,20 @@ struct rpc_smbd_write_state {
ssize_t written;
};
static void rpc_smbd_write_done(struct async_req *subreq);
static void rpc_smbd_write_done(struct tevent_req *subreq);
static struct async_req *rpc_smbd_write_send(TALLOC_CTX *mem_ctx,
struct event_context *ev,
const uint8_t *data, size_t size,
void *priv)
static struct tevent_req *rpc_smbd_write_send(TALLOC_CTX *mem_ctx,
struct event_context *ev,
const uint8_t *data, size_t size,
void *priv)
{
struct rpc_transport_smbd_state *transp = talloc_get_type_abort(
priv, struct rpc_transport_smbd_state);
struct async_req *result, *subreq;
struct tevent_req *req, *subreq;
struct rpc_smbd_write_state *state;
if (!async_req_setup(mem_ctx, &result, &state,
struct rpc_smbd_write_state)) {
req = tevent_req_create(mem_ctx, &state, struct rpc_smbd_write_state);
if (req == NULL) {
return NULL;
}
state->sub_transp = transp->sub_transp;
@ -460,40 +460,38 @@ static struct async_req *rpc_smbd_write_send(TALLOC_CTX *mem_ctx,
rpc_cli_smbd_stdout_reader, transp->conn) == NULL) {
goto fail;
}
subreq->async.fn = rpc_smbd_write_done;
subreq->async.priv = result;
return result;
tevent_req_set_callback(subreq, rpc_smbd_write_done, req);
return req;
fail:
TALLOC_FREE(result);
TALLOC_FREE(req);
return NULL;
}
static void rpc_smbd_write_done(struct async_req *subreq)
static void rpc_smbd_write_done(struct tevent_req *subreq)
{
struct async_req *req = talloc_get_type_abort(
subreq->async.priv, struct async_req);
struct rpc_smbd_write_state *state = talloc_get_type_abort(
req->private_data, struct rpc_smbd_write_state);
struct tevent_req *req = tevent_req_callback_data(
subreq, struct tevent_req);
struct rpc_smbd_write_state *state = tevent_req_data(
req, struct rpc_smbd_write_state);
NTSTATUS status;
status = state->sub_transp->write_recv(subreq, &state->written);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
async_req_nterror(req, status);
tevent_req_nterror(req, status);
return;
}
async_req_done(req);
tevent_req_done(req);
}
static NTSTATUS rpc_smbd_write_recv(struct async_req *req, ssize_t *pwritten)
static NTSTATUS rpc_smbd_write_recv(struct tevent_req *req, ssize_t *pwritten)
{
struct rpc_smbd_write_state *state = talloc_get_type_abort(
req->private_data, struct rpc_smbd_write_state);
struct rpc_smbd_write_state *state = tevent_req_data(
req, struct rpc_smbd_write_state);
NTSTATUS status;
if (async_req_is_nterror(req, &status)) {
if (tevent_req_is_nterror(req, &status)) {
return status;
}
*pwritten = state->written;
@ -505,20 +503,20 @@ struct rpc_smbd_read_state {
ssize_t received;
};
static void rpc_smbd_read_done(struct async_req *subreq);
static void rpc_smbd_read_done(struct tevent_req *subreq);
static struct async_req *rpc_smbd_read_send(TALLOC_CTX *mem_ctx,
struct event_context *ev,
uint8_t *data, size_t size,
void *priv)
static struct tevent_req *rpc_smbd_read_send(TALLOC_CTX *mem_ctx,
struct event_context *ev,
uint8_t *data, size_t size,
void *priv)
{
struct rpc_transport_smbd_state *transp = talloc_get_type_abort(
priv, struct rpc_transport_smbd_state);
struct async_req *result, *subreq;
struct tevent_req *req, *subreq;
struct rpc_smbd_read_state *state;
if (!async_req_setup(mem_ctx, &result, &state,
struct rpc_smbd_read_state)) {
req = tevent_req_create(mem_ctx, &state, struct rpc_smbd_read_state);
if (req == NULL) {
return NULL;
}
state->sub_transp = transp->sub_transp;
@ -533,40 +531,37 @@ static struct async_req *rpc_smbd_read_send(TALLOC_CTX *mem_ctx,
rpc_cli_smbd_stdout_reader, transp->conn) == NULL) {
goto fail;
}
subreq->async.fn = rpc_smbd_read_done;
subreq->async.priv = result;
return result;
tevent_req_set_callback(subreq, rpc_smbd_read_done, req);
return req;
fail:
TALLOC_FREE(result);
TALLOC_FREE(req);
return NULL;
}
static void rpc_smbd_read_done(struct async_req *subreq)
static void rpc_smbd_read_done(struct tevent_req *subreq)
{
struct async_req *req = talloc_get_type_abort(
subreq->async.priv, struct async_req);
struct rpc_smbd_read_state *state = talloc_get_type_abort(
req->private_data, struct rpc_smbd_read_state);
struct tevent_req *req = tevent_req_callback_data(
subreq, struct tevent_req);
struct rpc_smbd_read_state *state = tevent_req_data(
req, struct rpc_smbd_read_state);
NTSTATUS status;
status = state->sub_transp->read_recv(subreq, &state->received);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
async_req_nterror(req, status);
tevent_req_nterror(req, status);
return;
}
async_req_done(req);
tevent_req_done(req);
}
static NTSTATUS rpc_smbd_read_recv(struct async_req *req, ssize_t *preceived)
static NTSTATUS rpc_smbd_read_recv(struct tevent_req *req, ssize_t *preceived)
{
struct rpc_smbd_read_state *state = talloc_get_type_abort(
req->private_data, struct rpc_smbd_read_state);
struct rpc_smbd_read_state *state = tevent_req_data(
req, struct rpc_smbd_read_state);
NTSTATUS status;
if (async_req_is_nterror(req, &status)) {
if (tevent_req_is_nterror(req, &status)) {
return status;
}
*preceived = state->received;

82
source3/rpc_client/rpc_transport_sock.c
View File

@ -41,19 +41,18 @@ struct rpc_sock_read_state {
static void rpc_sock_read_done(struct tevent_req *subreq);
static struct async_req *rpc_sock_read_send(TALLOC_CTX *mem_ctx,
struct event_context *ev,
uint8_t *data, size_t size,
void *priv)
static struct tevent_req *rpc_sock_read_send(TALLOC_CTX *mem_ctx,
struct event_context *ev,
uint8_t *data, size_t size,
void *priv)
{
struct rpc_transport_sock_state *sock_transp = talloc_get_type_abort(
priv, struct rpc_transport_sock_state);
struct async_req *result;
struct tevent_req *subreq;
struct tevent_req *req, *subreq;
struct rpc_sock_read_state *state;
if (!async_req_setup(mem_ctx, &result, &state,
struct rpc_sock_read_state)) {
req = tevent_req_create(mem_ctx, &state, struct rpc_sock_read_state);
if (req == NULL) {
return NULL;
}
@ -61,36 +60,36 @@ static struct async_req *rpc_sock_read_send(TALLOC_CTX *mem_ctx,
if (subreq == NULL) {
goto fail;
}
tevent_req_set_callback(subreq, rpc_sock_read_done, result);
return result;
tevent_req_set_callback(subreq, rpc_sock_read_done, req);
return req;
fail:
TALLOC_FREE(result);
TALLOC_FREE(req);
return NULL;
}
static void rpc_sock_read_done(struct tevent_req *subreq)
{
struct async_req *req =
tevent_req_callback_data(subreq, struct async_req);
struct rpc_sock_read_state *state = talloc_get_type_abort(
req->private_data, struct rpc_sock_read_state);
struct tevent_req *req = tevent_req_callback_data(
subreq, struct tevent_req);
struct rpc_sock_read_state *state = tevent_req_data(
req, struct rpc_sock_read_state);
int err;
state->received = async_recv_recv(subreq, &err);
if (state->received == -1) {
async_req_nterror(req, map_nt_error_from_unix(err));
tevent_req_nterror(req, map_nt_error_from_unix(err));
return;
}
async_req_done(req);
tevent_req_done(req);
}
static NTSTATUS rpc_sock_read_recv(struct async_req *req, ssize_t *preceived)
static NTSTATUS rpc_sock_read_recv(struct tevent_req *req, ssize_t *preceived)
{
struct rpc_sock_read_state *state = talloc_get_type_abort(
req->private_data, struct rpc_sock_read_state);
struct rpc_sock_read_state *state = tevent_req_data(
req, struct rpc_sock_read_state);
NTSTATUS status;
if (async_req_is_nterror(req, &status)) {
if (tevent_req_is_nterror(req, &status)) {
return status;
}
*preceived = state->received;
@ -103,55 +102,54 @@ struct rpc_sock_write_state {
static void rpc_sock_write_done(struct tevent_req *subreq);
static struct async_req *rpc_sock_write_send(TALLOC_CTX *mem_ctx,
struct event_context *ev,
const uint8_t *data, size_t size,
void *priv)
static struct tevent_req *rpc_sock_write_send(TALLOC_CTX *mem_ctx,
struct event_context *ev,
const uint8_t *data, size_t size,
void *priv)
{
struct rpc_transport_sock_state *sock_transp = talloc_get_type_abort(
priv, struct rpc_transport_sock_state);
struct async_req *result;
struct tevent_req *subreq;
struct tevent_req *req, *subreq;
struct rpc_sock_write_state *state;
if (!async_req_setup(mem_ctx, &result, &state,
struct rpc_sock_write_state)) {
req = tevent_req_create(mem_ctx, &state, struct rpc_sock_write_state);
if (req == NULL) {
return NULL;
}
subreq = async_send_send(state, ev, sock_transp->fd, data, size, 0);
if (subreq == NULL) {
goto fail;
}
tevent_req_set_callback(subreq, rpc_sock_write_done, result);
return result;
tevent_req_set_callback(subreq, rpc_sock_write_done, req);
return req;
fail:
TALLOC_FREE(result);
TALLOC_FREE(req);
return NULL;
}
static void rpc_sock_write_done(struct tevent_req *subreq)
{
struct async_req *req =
tevent_req_callback_data(subreq, struct async_req);
struct rpc_sock_write_state *state = talloc_get_type_abort(
req->private_data, struct rpc_sock_write_state);
struct tevent_req *req = tevent_req_callback_data(
subreq, struct tevent_req);
struct rpc_sock_write_state *state = tevent_req_data(
req, struct rpc_sock_write_state);
int err;
state->sent = async_send_recv(subreq, &err);
if (state->sent == -1) {
async_req_nterror(req, map_nt_error_from_unix(err));
tevent_req_nterror(req, map_nt_error_from_unix(err));
return;
}
async_req_done(req);
tevent_req_done(req);
}
static NTSTATUS rpc_sock_write_recv(struct async_req *req, ssize_t *psent)
static NTSTATUS rpc_sock_write_recv(struct tevent_req *req, ssize_t *psent)
{
struct rpc_sock_write_state *state = talloc_get_type_abort(
req->private_data, struct rpc_sock_write_state);
struct rpc_sock_write_state *state = tevent_req_data(
req, struct rpc_sock_write_state);
NTSTATUS status;
if (async_req_is_nterror(req, &status)) {
if (tevent_req_is_nterror(req, &status)) {
return status;
}
*psent = state->sent;

57
source3/rpc_parse/parse_misc.c
View File

@ -100,44 +100,6 @@ bool make_systemtime(SYSTEMTIME *systime, struct tm *unixtime)
return True;
}
/*******************************************************************
Reads or writes a DOM_SID structure.
********************************************************************/
bool smb_io_dom_sid(const char *desc, DOM_SID *sid, prs_struct *ps, int depth)
{
int i;
if (sid == NULL)
return False;
prs_debug(ps, depth, desc, "smb_io_dom_sid");
depth++;
if(!prs_uint8 ("sid_rev_num", ps, depth, &sid->sid_rev_num))
return False;
if(!prs_uint8 ("num_auths ", ps, depth, (uint8 *)&sid->num_auths))
return False;
for (i = 0; i < 6; i++)
{
fstring tmp;
slprintf(tmp, sizeof(tmp) - 1, "id_auth[%d] ", i);
if(!prs_uint8 (tmp, ps, depth, &sid->id_auth[i]))
return False;
}
/* oops! XXXX should really issue a warning here... */
if (sid->num_auths > MAXSUBAUTHS)
sid->num_auths = MAXSUBAUTHS;
if(!prs_uint32s(False, "sub_auths ", ps, depth, sid->sub_auths, sid->num_auths))
return False;
return True;
}
/*******************************************************************
Reads or writes a struct GUID
********************************************************************/
@ -166,25 +128,6 @@ bool smb_io_uuid(const char *desc, struct GUID *uuid,
return True;
}
/*******************************************************************
Inits a UNISTR structure.
********************************************************************/
void init_unistr(UNISTR *str, const char *buf)
{
size_t len;
if (buf == NULL) {
str->buffer = NULL;
return;
}
len = rpcstr_push_talloc(talloc_tos(), &str->buffer, buf);
if (len == (size_t)-1) {
str->buffer = NULL;
}
}
/*******************************************************************
Inits a UNISTR2 structure.
********************************************************************/

436
source3/rpc_parse/parse_sec.c
View File

@ -1,436 +0,0 @@
/*
* Unix SMB/Netbios implementation.
* Version 1.9.
* RPC Pipe client / server routines
* Copyright (C) Andrew Tridgell 1992-1998,
* Copyright (C) Jeremy R. Allison 1995-2005.
* Copyright (C) Luke Kenneth Casson Leighton 1996-1998,
* Copyright (C) Paul Ashton 1997-1998.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see <http://www.gnu.org/licenses/>.
*/
#include "includes.h"
#undef DBGC_CLASS
#define DBGC_CLASS DBGC_RPC_PARSE
/*******************************************************************
Reads or writes a SEC_ACE structure.
********************************************************************/
static bool sec_io_ace(const char *desc, SEC_ACE *psa, prs_struct *ps,
int depth)
{
uint32 old_offset;
uint32 offset_ace_size;
uint8 type;
if (psa == NULL)
return False;
prs_debug(ps, depth, desc, "sec_io_ace");
depth++;
old_offset = prs_offset(ps);
if (MARSHALLING(ps)) {
type = (uint8)psa->type;
}
if(!prs_uint8("type ", ps, depth, &type))
return False;
if (UNMARSHALLING(ps)) {
psa->type = (enum security_ace_type)type;
}
if(!prs_uint8("flags", ps, depth, &psa->flags))
return False;
if(!prs_uint16_pre("size ", ps, depth, &psa->size, &offset_ace_size))
return False;
if(!prs_uint32("access_mask", ps, depth, &psa->access_mask))
return False;
/* check whether object access is present */
if (!sec_ace_object(psa->type)) {
if (!smb_io_dom_sid("trustee ", &psa->trustee , ps, depth))
return False;
} else {
if (!prs_uint32("obj_flags", ps, depth, &psa->object.object.flags))
return False;
if (psa->object.object.flags & SEC_ACE_OBJECT_TYPE_PRESENT)
if (!smb_io_uuid("obj_guid", &psa->object.object.type.type, ps,depth))
return False;
if (psa->object.object.flags & SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT)
if (!smb_io_uuid("inh_guid", &psa->object.object.inherited_type.inherited_type, ps,depth))
return False;
if(!smb_io_dom_sid("trustee ", &psa->trustee , ps, depth))
return False;
}
/* Theorectically an ACE can have a size greater than the
sum of its components. When marshalling, pad with extra null bytes up to the
correct size. */
if (MARSHALLING(ps) && (psa->size > prs_offset(ps) - old_offset)) {
uint32 extra_len = psa->size - (prs_offset(ps) - old_offset);
uint32 i;
uint8 c = 0;
for (i = 0; i < extra_len; i++) {
if (!prs_uint8("ace extra space", ps, depth, &c))
return False;
}
}
if(!prs_uint16_post("size ", ps, depth, &psa->size, offset_ace_size, old_offset))
return False;
return True;
}
/*******************************************************************
Reads or writes a SEC_ACL structure.
First of the xx_io_xx functions that allocates its data structures
for you as it reads them.
********************************************************************/
static bool sec_io_acl(const char *desc, SEC_ACL **ppsa, prs_struct *ps,
int depth)
{
unsigned int i;
uint32 old_offset;
uint32 offset_acl_size;
SEC_ACL *psa;
uint16 revision;
/*
* Note that the size is always a multiple of 4 bytes due to the
* nature of the data structure. Therefore the prs_align() calls
* have been removed as they through us off when doing two-layer
* marshalling such as in the printing code (RPC_BUFFER). --jerry
*/
if (ppsa == NULL)
return False;
psa = *ppsa;
if(UNMARSHALLING(ps) && psa == NULL) {
/*
* This is a read and we must allocate the stuct to read into.
*/
if((psa = PRS_ALLOC_MEM(ps, SEC_ACL, 1)) == NULL)
return False;
*ppsa = psa;
}
prs_debug(ps, depth, desc, "sec_io_acl");
depth++;
old_offset = prs_offset(ps);
if (MARSHALLING(ps)) {
revision = (uint16)psa->revision;
}
if(!prs_uint16("revision", ps, depth, &revision))
return False;
if (UNMARSHALLING(ps)) {
psa->revision = (enum security_acl_revision)revision;
}
if(!prs_uint16_pre("size ", ps, depth, &psa->size, &offset_acl_size))
return False;
if(!prs_uint32("num_aces ", ps, depth, &psa->num_aces))
return False;
if (UNMARSHALLING(ps)) {
if (psa->num_aces) {
if((psa->aces = PRS_ALLOC_MEM(ps, SEC_ACE, psa->num_aces)) == NULL)
return False;
} else {
psa->aces = NULL;
}
}
for (i = 0; i < psa->num_aces; i++) {
fstring tmp;
slprintf(tmp, sizeof(tmp)-1, "ace_list[%02d]: ", i);
if(!sec_io_ace(tmp, &psa->aces[i], ps, depth))
return False;
}
/* Theorectically an ACL can have a size greater than the
sum of its components. When marshalling, pad with extra null bytes up to the
correct size. */
if (MARSHALLING(ps) && (psa->size > prs_offset(ps) - old_offset)) {
uint32 extra_len = psa->size - (prs_offset(ps) - old_offset);
uint8 c = 0;
for (i = 0; i < extra_len; i++) {
if (!prs_uint8("acl extra space", ps, depth, &c))
return False;
}
}
if(!prs_uint16_post("size ", ps, depth, &psa->size, offset_acl_size, old_offset))
return False;
return True;
}
/*******************************************************************
Reads or writes a SEC_DESC structure.
If reading and the *ppsd = NULL, allocates the structure.
********************************************************************/
bool sec_io_desc(const char *desc, SEC_DESC **ppsd, prs_struct *ps, int depth)
{
uint32 old_offset;
uint32 max_offset = 0; /* after we're done, move offset to end */
uint32 tmp_offset = 0;
uint32 off_sacl, off_dacl, off_owner_sid, off_grp_sid;
uint16 revision;
SEC_DESC *psd;
if (ppsd == NULL)
return False;
psd = *ppsd;
if (psd == NULL) {
if(UNMARSHALLING(ps)) {
if((psd = PRS_ALLOC_MEM(ps,SEC_DESC,1)) == NULL)
return False;
*ppsd = psd;
} else {
/* Marshalling - just ignore. */
return True;
}
}
prs_debug(ps, depth, desc, "sec_io_desc");
depth++;
/* start of security descriptor stored for back-calc offset purposes */
old_offset = prs_offset(ps);
if (MARSHALLING(ps)) {
revision = (uint16)psd->revision;
}
if(!prs_uint16("revision", ps, depth, &revision))
return False;
if (UNMARSHALLING(ps)) {
psd->revision = (enum security_descriptor_revision)revision;
}
if(!prs_uint16("type ", ps, depth, &psd->type))
return False;
if (MARSHALLING(ps)) {
uint32 offset = SEC_DESC_HEADER_SIZE;
/*
* Work out the offsets here, as we write it out.
*/
if (psd->sacl != NULL) {
off_sacl = offset;
offset += psd->sacl->size;
} else {
off_sacl = 0;
}
if (psd->dacl != NULL) {
off_dacl = offset;
offset += psd->dacl->size;
} else {
off_dacl = 0;
}
if (psd->owner_sid != NULL) {
off_owner_sid = offset;
offset += ndr_size_dom_sid(psd->owner_sid, NULL, 0);
} else {
off_owner_sid = 0;
}
if (psd->group_sid != NULL) {
off_grp_sid = offset;
offset += ndr_size_dom_sid(psd->group_sid, NULL, 0);
} else {
off_grp_sid = 0;
}
}
if(!prs_uint32("off_owner_sid", ps, depth, &off_owner_sid))
return False;
if(!prs_uint32("off_grp_sid ", ps, depth, &off_grp_sid))
return False;
if(!prs_uint32("off_sacl ", ps, depth, &off_sacl))
return False;
if(!prs_uint32("off_dacl ", ps, depth, &off_dacl))
return False;
max_offset = MAX(max_offset, prs_offset(ps));
if (off_owner_sid != 0) {
tmp_offset = prs_offset(ps);
if(!prs_set_offset(ps, old_offset + off_owner_sid))
return False;
if (UNMARSHALLING(ps)) {
/* reading */
if((psd->owner_sid = PRS_ALLOC_MEM(ps,DOM_SID,1)) == NULL)
return False;
}
if(!smb_io_dom_sid("owner_sid ", psd->owner_sid , ps, depth))
return False;
max_offset = MAX(max_offset, prs_offset(ps));
if (!prs_set_offset(ps,tmp_offset))
return False;
}
if (psd->group_sid != 0) {
tmp_offset = prs_offset(ps);
if(!prs_set_offset(ps, old_offset + off_grp_sid))
return False;
if (UNMARSHALLING(ps)) {
/* reading */
if((psd->group_sid = PRS_ALLOC_MEM(ps,DOM_SID,1)) == NULL)
return False;
}
if(!smb_io_dom_sid("grp_sid", psd->group_sid, ps, depth))
return False;
max_offset = MAX(max_offset, prs_offset(ps));
if (!prs_set_offset(ps,tmp_offset))
return False;
}
if ((psd->type & SEC_DESC_SACL_PRESENT) && off_sacl) {
tmp_offset = prs_offset(ps);
if(!prs_set_offset(ps, old_offset + off_sacl))
return False;
if(!sec_io_acl("sacl", &psd->sacl, ps, depth))
return False;
max_offset = MAX(max_offset, prs_offset(ps));
if (!prs_set_offset(ps,tmp_offset))
return False;
}
if ((psd->type & SEC_DESC_DACL_PRESENT) && off_dacl != 0) {
tmp_offset = prs_offset(ps);
if(!prs_set_offset(ps, old_offset + off_dacl))
return False;
if(!sec_io_acl("dacl", &psd->dacl, ps, depth))
return False;
max_offset = MAX(max_offset, prs_offset(ps));
if (!prs_set_offset(ps,tmp_offset))
return False;
}
if(!prs_set_offset(ps, max_offset))
return False;
return True;
}
/*******************************************************************
Reads or writes a SEC_DESC_BUF structure.
********************************************************************/
bool sec_io_desc_buf(const char *desc, SEC_DESC_BUF **ppsdb, prs_struct *ps, int depth)
{
uint32 off_len;
uint32 off_max_len;
uint32 old_offset;
uint32 size;
uint32 len;
SEC_DESC_BUF *psdb;
uint32 ptr;
if (ppsdb == NULL)
return False;
psdb = *ppsdb;
if (UNMARSHALLING(ps) && psdb == NULL) {
if((psdb = PRS_ALLOC_MEM(ps,SEC_DESC_BUF,1)) == NULL)
return False;
*ppsdb = psdb;
}
prs_debug(ps, depth, desc, "sec_io_desc_buf");
depth++;
if(!prs_align(ps))
return False;
if(!prs_uint32_pre("max_len", ps, depth, &psdb->sd_size, &off_max_len))
return False;
ptr = 1;
if(!prs_uint32 ("ptr ", ps, depth, &ptr))
return False;
len = ndr_size_security_descriptor(psdb->sd, NULL, 0);
if(!prs_uint32_pre("len ", ps, depth, &len, &off_len))
return False;
old_offset = prs_offset(ps);
/* reading, length is non-zero; writing, descriptor is non-NULL */
if ((UNMARSHALLING(ps) && psdb->sd_size != 0) || (MARSHALLING(ps) && psdb->sd != NULL)) {
if(!sec_io_desc("sec ", &psdb->sd, ps, depth))
return False;
}
if(!prs_align(ps))
return False;
size = prs_offset(ps) - old_offset;
if(!prs_uint32_post("max_len", ps, depth, &psdb->sd_size, off_max_len, size == 0 ? psdb->sd_size : size))
return False;
if(!prs_uint32_post("len ", ps, depth, &len, off_len, size))
return False;
return True;
}

4
source3/rpc_server/srv_lsa_nt.c
View File

@ -827,6 +827,10 @@ NTSTATUS _lsa_LookupSids(pipes_struct *p,
&names,
&mapped_count);
if (NT_STATUS_IS_ERR(status)) {
return status;
}
/* Convert from lsa_TranslatedName2 to lsa_TranslatedName */
names_out = TALLOC_ARRAY(p->mem_ctx, struct lsa_TranslatedName,
num_sids);

2
source3/rpc_server/srv_pipe_hnd.c
View File

@ -1383,7 +1383,7 @@ struct tevent_req *np_read_send(TALLOC_CTX *mem_ctx, struct event_context *ev,
static void np_read_trigger(struct tevent_req *req, void *private_data)
{
struct np_read_state *state = tevent_req_callback_data(
struct np_read_state *state = tevent_req_data(
req, struct np_read_state);
struct tevent_req *subreq;

122
source3/rpc_server/srv_samr_nt.c
View File

@ -3636,12 +3636,7 @@ static NTSTATUS set_user_info_18(struct samr_UserInfo18 *id18,
pdb_set_pass_last_set_time(pwd, time(NULL), PDB_CHANGED);
}
if (id18->password_expired) {
pdb_set_pass_last_set_time(pwd, 0, PDB_CHANGED);
} else {
/* FIXME */
pdb_set_pass_last_set_time(pwd, time(NULL), PDB_CHANGED);
}
copy_id18_to_sam_passwd(pwd, id18);
return pdb_update_sam_account(pwd);
}
@ -3848,23 +3843,16 @@ static NTSTATUS set_user_info_23(TALLOC_CTX *mem_ctx,
set_user_info_pw
********************************************************************/
static bool set_user_info_pw(uint8 *pass, struct samu *pwd,
int level)
static bool set_user_info_pw(uint8 *pass, struct samu *pwd)
{
uint32 len = 0;
char *plaintext_buf = NULL;
uint32 acct_ctrl;
time_t last_set_time;
enum pdb_value_state last_set_state;
DEBUG(5, ("Attempting administrator password change for user %s\n",
pdb_get_username(pwd)));
acct_ctrl = pdb_get_acct_ctrl(pwd);
/* we need to know if it's expired, because this is an admin change, not a
user change, so it's still expired when we're done */
last_set_state = pdb_get_init_flags(pwd, PDB_PASSLASTSET);
last_set_time = pdb_get_pass_last_set_time(pwd);
if (!decode_pw_buffer(talloc_tos(),
pass,
@ -3907,29 +3895,38 @@ static bool set_user_info_pw(uint8 *pass, struct samu *pwd,
memset(plaintext_buf, '\0', strlen(plaintext_buf));
/*
* A level 25 change does reset the pwdlastset field, a level 24
* change does not. I know this is probably not the full story, but
* it is needed to make XP join LDAP correctly, without it the later
* auth2 check can fail with PWD_MUST_CHANGE.
*/
if (level != 25) {
/*
* restore last set time as this is an admin change, not a
* user pw change
*/
pdb_set_pass_last_set_time (pwd, last_set_time,
last_set_state);
}
DEBUG(5,("set_user_info_pw: pdb_update_pwd()\n"));
/* update the SAMBA password */
if(!NT_STATUS_IS_OK(pdb_update_sam_account(pwd))) {
return False;
return True;
}
/*******************************************************************
set_user_info_24
********************************************************************/
static NTSTATUS set_user_info_24(TALLOC_CTX *mem_ctx,
struct samr_UserInfo24 *id24,
struct samu *pwd)
{
NTSTATUS status;
if (id24 == NULL) {
DEBUG(5, ("set_user_info_24: NULL id24\n"));
return NT_STATUS_INVALID_PARAMETER;
}
if (!set_user_info_pw(id24->password.data, pwd)) {
return NT_STATUS_WRONG_PASSWORD;
}
copy_id24_to_sam_passwd(pwd, id24);
status = pdb_update_sam_account(pwd);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
return True;
return NT_STATUS_OK;
}
/*******************************************************************
@ -3955,6 +3952,14 @@ static NTSTATUS set_user_info_25(TALLOC_CTX *mem_ctx,
return NT_STATUS_ACCESS_DENIED;
}
if ((id25->info.fields_present & SAMR_FIELD_NT_PASSWORD_PRESENT) ||
(id25->info.fields_present & SAMR_FIELD_LM_PASSWORD_PRESENT)) {
if (!set_user_info_pw(id25->password.data, pwd)) {
return NT_STATUS_WRONG_PASSWORD;
}
}
copy_id25_to_sam_passwd(pwd, id25);
/* write the change out */
@ -3980,6 +3985,36 @@ static NTSTATUS set_user_info_25(TALLOC_CTX *mem_ctx,
return NT_STATUS_OK;
}
/*******************************************************************
set_user_info_26
********************************************************************/
static NTSTATUS set_user_info_26(TALLOC_CTX *mem_ctx,
struct samr_UserInfo26 *id26,
struct samu *pwd)
{
NTSTATUS status;
if (id26 == NULL) {
DEBUG(5, ("set_user_info_26: NULL id26\n"));
return NT_STATUS_INVALID_PARAMETER;
}
if (!set_user_info_pw(id26->password.data, pwd)) {
return NT_STATUS_WRONG_PASSWORD;
}
copy_id26_to_sam_passwd(pwd, id26);
status = pdb_update_sam_account(pwd);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
return NT_STATUS_OK;
}
/*******************************************************************
samr_SetUserInfo
********************************************************************/
@ -4139,10 +4174,8 @@ NTSTATUS _samr_SetUserInfo(pipes_struct *p,
dump_data(100, info->info24.password.data, 516);
if (!set_user_info_pw(info->info24.password.data, pwd,
switch_value)) {
status = NT_STATUS_WRONG_PASSWORD;
}
status = set_user_info_24(p->mem_ctx,
&info->info24, pwd);
break;
case 25:
@ -4157,13 +4190,6 @@ NTSTATUS _samr_SetUserInfo(pipes_struct *p,
status = set_user_info_25(p->mem_ctx,
&info->info25, pwd);
if (!NT_STATUS_IS_OK(status)) {
goto done;
}
if (!set_user_info_pw(info->info25.password.data, pwd,
switch_value)) {
status = NT_STATUS_WRONG_PASSWORD;
}
break;
case 26:
@ -4176,18 +4202,14 @@ NTSTATUS _samr_SetUserInfo(pipes_struct *p,
dump_data(100, info->info26.password.data, 516);
if (!set_user_info_pw(info->info26.password.data, pwd,
switch_value)) {
status = NT_STATUS_WRONG_PASSWORD;
}
status = set_user_info_26(p->mem_ctx,
&info->info26, pwd);
break;
default:
status = NT_STATUS_INVALID_INFO_CLASS;
}
done:
TALLOC_FREE(pwd);
if (has_enough_rights) {

87
source3/rpc_server/srv_samr_util.c
View File

@ -35,6 +35,27 @@
(!(s1) && (s2)) ||\
((s1) && (s2) && (strcmp((s1), (s2)) != 0))
/*************************************************************
Copies a struct samr_UserInfo18 to a struct samu
**************************************************************/
void copy_id18_to_sam_passwd(struct samu *to,
struct samr_UserInfo18 *from)
{
struct samr_UserInfo21 i;
if (from == NULL || to == NULL) {
return;
}
ZERO_STRUCT(i);
i.fields_present = SAMR_FIELD_EXPIRED_FLAG;
i.password_expired = from->password_expired;
copy_id21_to_sam_passwd("INFO_18", to, &i);
}
/*************************************************************
Copies a struct samr_UserInfo20 to a struct samu
**************************************************************/
@ -336,7 +357,7 @@ void copy_id21_to_sam_passwd(const char *log_prefix,
if (from->fields_present & SAMR_FIELD_EXPIRED_FLAG) {
DEBUG(10,("%s SAMR_FIELD_EXPIRED_FLAG: %02X\n", l,
from->password_expired));
if (from->password_expired == PASS_MUST_CHANGE_AT_NEXT_LOGON) {
if (from->password_expired != 0) {
pdb_set_pass_last_set_time(to, 0, PDB_CHANGED);
} else {
/* A subtlety here: some windows commands will
@ -345,9 +366,27 @@ void copy_id21_to_sam_passwd(const char *log_prefix,
in these caess. "net user /dom <user> /active:y"
for example, to clear an autolocked acct.
We must check to see if it's expired first. jmcd */
uint32_t pwd_max_age = 0;
time_t now = time(NULL);
pdb_get_account_policy(AP_MAX_PASSWORD_AGE, &pwd_max_age);
if (pwd_max_age == (uint32_t)-1 || pwd_max_age == 0) {
pwd_max_age = get_time_t_max();
}
stored_time = pdb_get_pass_last_set_time(to);
if (stored_time == 0)
pdb_set_pass_last_set_time(to, time(NULL),PDB_CHANGED);
/* we will only *set* a pwdlastset date when
a) the last pwdlastset time was 0 (user was forced to
change password).
b) the users password has not expired. gd. */
if ((stored_time == 0) ||
((now - stored_time) > pwd_max_age)) {
pdb_set_pass_last_set_time(to, now, PDB_CHANGED);
}
}
}
}
@ -367,6 +406,27 @@ void copy_id23_to_sam_passwd(struct samu *to,
copy_id21_to_sam_passwd("INFO 23", to, &from->info);
}
/*************************************************************
Copies a struct samr_UserInfo24 to a struct samu
**************************************************************/
void copy_id24_to_sam_passwd(struct samu *to,
struct samr_UserInfo24 *from)
{
struct samr_UserInfo21 i;
if (from == NULL || to == NULL) {
return;
}
ZERO_STRUCT(i);
i.fields_present = SAMR_FIELD_EXPIRED_FLAG;
i.password_expired = from->password_expired;
copy_id21_to_sam_passwd("INFO_24", to, &i);
}
/*************************************************************
Copies a struct samr_UserInfo25 to a struct samu
**************************************************************/
@ -380,3 +440,24 @@ void copy_id25_to_sam_passwd(struct samu *to,
copy_id21_to_sam_passwd("INFO_25", to, &from->info);
}
/*************************************************************
Copies a struct samr_UserInfo26 to a struct samu
**************************************************************/
void copy_id26_to_sam_passwd(struct samu *to,
struct samr_UserInfo26 *from)
{
struct samr_UserInfo21 i;
if (from == NULL || to == NULL) {
return;
}
ZERO_STRUCT(i);
i.fields_present = SAMR_FIELD_EXPIRED_FLAG;
i.password_expired = from->password_expired;
copy_id21_to_sam_passwd("INFO_26", to, &i);
}

530
source3/rpc_server/srv_spoolss_nt.c
View File

File diff suppressed because it is too large Load Diff

45
source3/rpcclient/cmd_spoolss.c
View File

@ -257,9 +257,10 @@ static WERROR cmd_spoolss_enum_printers(struct rpc_pipe_client *cli,
union spoolss_PrinterInfo *info;
uint32_t i, count;
const char *name;
uint32_t flags = PRINTER_ENUM_LOCAL;
if (argc > 3) {
printf("Usage: %s [level] [name]\n", argv[0]);
if (argc > 4) {
printf("Usage: %s [level] [name] [flags]\n", argv[0]);
return WERR_OK;
}
@ -267,14 +268,18 @@ static WERROR cmd_spoolss_enum_printers(struct rpc_pipe_client *cli,
level = atoi(argv[1]);
}
if (argc == 3) {
if (argc >= 3) {
name = argv[2];
} else {
name = cli->srv_name_slash;
}
if (argc == 4) {
flags = atoi(argv[3]);
}
result = rpccli_spoolss_enumprinters(cli, mem_ctx,
PRINTER_ENUM_LOCAL,
flags,
name,
level,
0,
@ -417,7 +422,7 @@ static WERROR cmd_spoolss_setprinter(struct rpc_pipe_client *cli,
struct policy_handle pol;
WERROR result;
NTSTATUS status;
uint32 info_level = 2;
uint32_t info_level = 2;
union spoolss_PrinterInfo info;
struct spoolss_SetPrinterInfoCtr info_ctr;
const char *printername, *comment = NULL;
@ -493,7 +498,7 @@ static WERROR cmd_spoolss_setprintername(struct rpc_pipe_client *cli,
struct policy_handle pol;
WERROR result;
NTSTATUS status;
uint32 info_level = 2;
uint32_t info_level = 2;
union spoolss_PrinterInfo info;
const char *printername,
*new_printername = NULL;
@ -644,7 +649,7 @@ static void display_reg_value(REGISTRY_VALUE value)
switch(value.type) {
case REG_DWORD:
printf("%s: REG_DWORD: 0x%08x\n", value.valuename,
*((uint32 *) value.data_p));
*((uint32_t *) value.data_p));
break;
case REG_SZ:
rpcstr_pull_talloc(talloc_tos(),
@ -673,7 +678,7 @@ static void display_reg_value(REGISTRY_VALUE value)
break;
}
case REG_MULTI_SZ: {
uint32 i, num_values;
uint32_t i, num_values;
char **values;
if (!W_ERROR_IS_OK(reg_pull_multi_sz(NULL, value.data_p,
@ -1338,7 +1343,7 @@ static WERROR cmd_spoolss_addprinterdriver(struct rpc_pipe_client *cli,
{
WERROR result;
NTSTATUS status;
uint32 level = 3;
uint32_t level = 3;
struct spoolss_AddDriverInfoCtr info_ctr;
struct spoolss_AddDriverInfo3 info3;
const char *arch;
@ -1467,7 +1472,7 @@ static WERROR cmd_spoolss_setdriver(struct rpc_pipe_client *cli,
struct policy_handle pol;
WERROR result;
NTSTATUS status;
uint32 level = 2;
uint32_t level = 2;
const char *printername;
union spoolss_PrinterInfo info;
struct spoolss_SetPrinterInfoCtr info_ctr;
@ -2051,7 +2056,7 @@ static WERROR cmd_spoolss_enum_forms(struct rpc_pipe_client *cli,
struct policy_handle handle;
WERROR werror;
const char *printername;
uint32 num_forms, level = 1, i;
uint32_t num_forms, level = 1, i;
union spoolss_FormInfo *forms;
/* Parse the command arguments */
@ -2544,7 +2549,7 @@ static WERROR cmd_spoolss_enum_data_ex( struct rpc_pipe_client *cli,
const char **argv)
{
WERROR result;
uint32 i;
uint32_t i;
const char *printername;
struct policy_handle hnd;
uint32_t count;
@ -2764,7 +2769,7 @@ static bool compare_printer( struct rpc_pipe_client *cli1, struct policy_handle
if ( !W_ERROR_IS_OK(werror) ) {
printf("failed (%s)\n", win_errstr(werror));
talloc_destroy(mem_ctx);
return False;
return false;
}
printf("ok\n");
@ -2777,13 +2782,13 @@ static bool compare_printer( struct rpc_pipe_client *cli1, struct policy_handle
if ( !W_ERROR_IS_OK(werror) ) {
printf("failed (%s)\n", win_errstr(werror));
talloc_destroy(mem_ctx);
return False;
return false;
}
printf("ok\n");
talloc_destroy(mem_ctx);
return True;
return true;
}
/****************************************************************************
@ -2796,7 +2801,7 @@ static bool compare_printer_secdesc( struct rpc_pipe_client *cli1, struct policy
WERROR werror;
TALLOC_CTX *mem_ctx = talloc_init("compare_printer_secdesc");
SEC_DESC *sd1, *sd2;
bool result = True;
bool result = true;
printf("Retrieving printer security for %s...", cli1->desthost);
@ -2807,7 +2812,7 @@ static bool compare_printer_secdesc( struct rpc_pipe_client *cli1, struct policy
&info1);
if ( !W_ERROR_IS_OK(werror) ) {
printf("failed (%s)\n", win_errstr(werror));
result = False;
result = false;
goto done;
}
printf("ok\n");
@ -2820,7 +2825,7 @@ static bool compare_printer_secdesc( struct rpc_pipe_client *cli1, struct policy
&info2);
if ( !W_ERROR_IS_OK(werror) ) {
printf("failed (%s)\n", win_errstr(werror));
result = False;
result = false;
goto done;
}
printf("ok\n");
@ -2833,13 +2838,13 @@ static bool compare_printer_secdesc( struct rpc_pipe_client *cli1, struct policy
if ( (sd1 != sd2) && ( !sd1 || !sd2 ) ) {
printf("NULL secdesc!\n");
result = False;
result = false;
goto done;
}
if (!sec_desc_equal( sd1, sd2 ) ) {
printf("Security Descriptors *not* equal!\n");
result = False;
result = false;
goto done;
}

8
source3/samba4.m4
View File

@ -69,14 +69,14 @@ AC_CONFIG_FILES(../source4/librpc/dcerpc_atsvc.pc)
m4_include(../source4/min_versions.m4)
SMB_EXT_LIB_FROM_PKGCONFIG(LIBTALLOC, talloc >= $TALLOC_MIN_VERSION,
SMB_EXT_LIB_FROM_PKGCONFIG(LIBTALLOC, talloc >= TALLOC_MIN_VERSION,
[],
[
SMB_INCLUDE_MK(../lib/talloc/config.mk)
]
)
SMB_EXT_LIB_FROM_PKGCONFIG(LIBTDB, tdb >= $TDB_MIN_VERSION,
SMB_EXT_LIB_FROM_PKGCONFIG(LIBTDB, tdb >= TDB_MIN_VERSION,
[],
[
m4_include(../lib/tdb/libtdb.m4)
@ -86,13 +86,13 @@ SMB_EXT_LIB_FROM_PKGCONFIG(LIBTDB, tdb >= $TDB_MIN_VERSION,
SMB_INCLUDE_MK(../lib/tdb/python.mk)
SMB_EXT_LIB_FROM_PKGCONFIG(LIBTEVENT, tevent = $TEVENT_REQUIRED_VERSION,
SMB_EXT_LIB_FROM_PKGCONFIG(LIBTEVENT, tevent = TEVENT_REQUIRED_VERSION,
[],[m4_include(../lib/tevent/samba.m4)]
)
SMB_INCLUDE_MK(../lib/tevent/python.mk)
SMB_EXT_LIB_FROM_PKGCONFIG(LIBLDB, ldb = $LDB_REQUIRED_VERSION,
SMB_EXT_LIB_FROM_PKGCONFIG(LIBLDB, ldb = LDB_REQUIRED_VERSION,
[
SMB_INCLUDE_MK(lib/ldb/ldb_ildap/config.mk)
SMB_INCLUDE_MK(lib/ldb/tools/config.mk)

12
source3/samba4.mk
View File

@ -225,32 +225,32 @@ test4-%::
valgrindtest4:: valgrindtest-all
valgrindtest4-quick:: all
SMBD_VALGRIND="xterm -n server -e $(selftestdir)/valgrind_run $(LD_LIBPATH_OVERRIDE)" \
SAMBA_VALGRIND="xterm -n server -e $(selftestdir)/valgrind_run $(LD_LIBPATH_OVERRIDE)" \
VALGRIND="valgrind -q --num-callers=30 --log-file=${selftest_prefix}/valgrind.log" \
$(SELFTEST4) $(SELFTEST4_QUICK_OPTS) --immediate --socket-wrapper $(TESTS)
valgrindtest4-all:: everything
SMBD_VALGRIND="xterm -n server -e $(selftestdir)/valgrind_run $(LD_LIBPATH_OVERRIDE)" \
SAMBA_VALGRIND="xterm -n server -e $(selftestdir)/valgrind_run $(LD_LIBPATH_OVERRIDE)" \
VALGRIND="valgrind -q --num-callers=30 --log-file=${selftest_prefix}/valgrind.log" \
$(SELFTEST4) $(SELFTEST4_NOSLOW_OPTS) --immediate --socket-wrapper $(TESTS)
valgrindtest4-env:: everything
SMBD_VALGRIND="xterm -n server -e $(selftestdir)/valgrind_run $(LD_LIBPATH_OVERRIDE)" \
SAMBA_VALGRIND="xterm -n server -e $(selftestdir)/valgrind_run $(LD_LIBPATH_OVERRIDE)" \
VALGRIND="valgrind -q --num-callers=30 --log-file=${selftest_prefix}/valgrind.log" \
$(SELFTEST4) $(SELFTEST4_NOSLOW_OPTS) --socket-wrapper --testenv
gdbtest4:: gdbtest4-all
gdbtest4-quick:: all
SMBD_VALGRIND="xterm -n server -e $(selftestdir)/gdb_run $(LD_LIBPATH_OVERRIDE)" \
SAMBA_VALGRIND="xterm -n server -e $(selftestdir)/gdb_run $(LD_LIBPATH_OVERRIDE)" \
$(SELFTEST4) $(SELFTEST4_QUICK_OPTS) --immediate --socket-wrapper $(TESTS)
gdbtest4-all:: everything
SMBD_VALGRIND="xterm -n server -e $(selftestdir)/gdb_run $(LD_LIBPATH_OVERRIDE)" \
SAMBA_VALGRIND="xterm -n server -e $(selftestdir)/gdb_run $(LD_LIBPATH_OVERRIDE)" \
$(SELFTEST4) $(SELFTEST4_NOSLOW_OPTS) --immediate --socket-wrapper $(TESTS)
gdbtest4-env:: everything
SMBD_VALGRIND="xterm -n server -e $(selftestdir)/gdb_run $(LD_LIBPATH_OVERRIDE)" \
SAMBA_VALGRIND="xterm -n server -e $(selftestdir)/gdb_run $(LD_LIBPATH_OVERRIDE)" \
$(SELFTEST4) $(SELFTEST4_NOSLOW_OPTS) --socket-wrapper --testenv
plugins: $(PLUGINS)

4
source3/selftest/tests.sh
View File

@ -120,6 +120,10 @@ plantest "blackbox.smbclient_s3.plain" dc BINDIR="$BINDIR" script/tests/test_smb
plantest "blackbox.smbclient_s3.plain member creds" member BINDIR="$BINDIR" script/tests/test_smbclient_s3.sh \$SERVER \$SERVER_IP \$SERVER\\\\\$USERNAME \$PASSWORD
plantest "blackbox.smbclient_s3.plain domain creds" member BINDIR="$BINDIR" script/tests/test_smbclient_s3.sh \$SERVER \$SERVER_IP \$DOMAIN\\\\\$DC_USERNAME \$DC_PASSWORD
# sign, only the member server allows signing
plantest "blackbox.smbclient_s3.sign member creds" member BINDIR="$BINDIR" script/tests/test_smbclient_s3.sh \$SERVER \$SERVER_IP \$SERVER\\\\\$USERNAME \$PASSWORD "--signing=required"
plantest "blackbox.smbclient_s3.sign domain creds" member BINDIR="$BINDIR" script/tests/test_smbclient_s3.sh \$SERVER \$SERVER_IP \$DOMAIN\\\\\$DC_USERNAME \$DC_PASSWORD "--signing=required"
# encrypted
plantest "blackbox.smbclient_s3.crypt" dc BINDIR="$BINDIR" script/tests/test_smbclient_s3.sh \$SERVER \$SERVER_IP \$USERNAME \$PASSWORD "-e"

13
source3/smbd/aio.c
View File

@ -197,7 +197,6 @@ bool schedule_aio_read_and_X(connection_struct *conn,
fsp->fsp_name, (double)startpos, (unsigned int)smb_maxcnt,
(unsigned int)aio_ex->req->mid ));
srv_defer_sign_response(aio_ex->req->mid);
outstanding_aio_calls++;
return True;
}
@ -303,6 +302,7 @@ bool schedule_aio_write_and_X(connection_struct *conn,
SSVAL(aio_ex->outbuf,smb_vwv4,(numtowrite>>16)&1);
show_msg(aio_ex->outbuf);
if (!srv_send_smb(smbd_server_fd(),aio_ex->outbuf,
true, aio_ex->req->seqnum+1,
IS_CONN_ENCRYPTED(fsp->conn),
&req->pcd)) {
exit_server_cleanly("handle_aio_write: srv_send_smb "
@ -310,8 +310,6 @@ bool schedule_aio_write_and_X(connection_struct *conn,
}
DEBUG(10,("schedule_aio_write_and_X: scheduled aio_write "
"behind for file %s\n", fsp->fsp_name ));
} else {
srv_defer_sign_response(aio_ex->req->mid);
}
outstanding_aio_calls++;
@ -347,7 +345,6 @@ static int handle_aio_read_complete(struct aio_extra *aio_ex)
/* If errno is ECANCELED then don't return anything to the
* client. */
if (errno == ECANCELED) {
srv_cancel_sign_response(aio_ex->req->mid, false);
return 0;
}
@ -378,6 +375,7 @@ static int handle_aio_read_complete(struct aio_extra *aio_ex)
smb_setlen(outbuf,outsize - 4);
show_msg(outbuf);
if (!srv_send_smb(smbd_server_fd(),outbuf,
true, aio_ex->req->seqnum+1,
IS_CONN_ENCRYPTED(aio_ex->fsp->conn), NULL)) {
exit_server_cleanly("handle_aio_read_complete: srv_send_smb "
"failed.");
@ -441,7 +439,6 @@ static int handle_aio_write_complete(struct aio_extra *aio_ex)
/* If errno is ECANCELED then don't return anything to the
* client. */
if (errno == ECANCELED) {
srv_cancel_sign_response(aio_ex->req->mid, false);
return 0;
}
@ -475,7 +472,9 @@ static int handle_aio_write_complete(struct aio_extra *aio_ex)
}
show_msg(outbuf);
if (!srv_send_smb(smbd_server_fd(),outbuf,IS_CONN_ENCRYPTED(fsp->conn),
if (!srv_send_smb(smbd_server_fd(),outbuf,
true, aio_ex->req->seqnum+1,
IS_CONN_ENCRYPTED(fsp->conn),
NULL)) {
exit_server_cleanly("handle_aio_write: srv_send_smb failed.");
}
@ -534,7 +533,6 @@ void smbd_aio_complete_mid(unsigned int mid)
if (!aio_ex) {
DEBUG(3,("smbd_aio_complete_mid: Can't find record to "
"match mid %u.\n", mid));
srv_cancel_sign_response(mid, false);
return;
}
@ -544,7 +542,6 @@ void smbd_aio_complete_mid(unsigned int mid)
* ignore. */
DEBUG( 3,( "smbd_aio_complete_mid: file closed whilst "
"aio outstanding (mid[%u]).\n", mid));
srv_cancel_sign_response(mid, false);
return;
}

170
source3/smbd/avahi_register.c Normal file
View File

@ -0,0 +1,170 @@
/*
* Unix SMB/CIFS implementation.
* Register _smb._tcp with avahi
*
* Copyright (C) Volker Lendecke 2009
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see <http://www.gnu.org/licenses/>.
*/
#include "includes.h"
#include <avahi-client/client.h>
#include <avahi-client/publish.h>
#include <avahi-common/error.h>
struct avahi_state_struct {
struct AvahiPoll *poll;
AvahiClient *client;
AvahiEntryGroup *entry_group;
uint16_t port;
};
static void avahi_entry_group_callback(AvahiEntryGroup *g,
AvahiEntryGroupState status,
void *userdata)
{
struct avahi_state_struct *state = talloc_get_type_abort(
userdata, struct avahi_state_struct);
int error;
switch (status) {
case AVAHI_ENTRY_GROUP_ESTABLISHED:
DEBUG(10, ("avahi_entry_group_callback: "
"AVAHI_ENTRY_GROUP_ESTABLISHED\n"));
break;
case AVAHI_ENTRY_GROUP_FAILURE:
error = avahi_client_errno(state->client);
DEBUG(10, ("avahi_entry_group_callback: "
"AVAHI_ENTRY_GROUP_FAILURE: %s\n",
avahi_strerror(error)));
break;
case AVAHI_ENTRY_GROUP_COLLISION:
DEBUG(10, ("avahi_entry_group_callback: "
"AVAHI_ENTRY_GROUP_COLLISION\n"));
break;
case AVAHI_ENTRY_GROUP_UNCOMMITED:
DEBUG(10, ("avahi_entry_group_callback: "
"AVAHI_ENTRY_GROUP_UNCOMMITED\n"));
break;
case AVAHI_ENTRY_GROUP_REGISTERING:
DEBUG(10, ("avahi_entry_group_callback: "
"AVAHI_ENTRY_GROUP_REGISTERING\n"));
break;
}
}
static void avahi_client_callback(AvahiClient *c, AvahiClientState status,
void *userdata)
{
struct avahi_state_struct *state = talloc_get_type_abort(
userdata, struct avahi_state_struct);
int error;
switch (status) {
case AVAHI_CLIENT_S_RUNNING:
DEBUG(10, ("avahi_client_callback: AVAHI_CLIENT_S_RUNNING\n"));
state->entry_group = avahi_entry_group_new(
c, avahi_entry_group_callback, state);
if (state->entry_group == NULL) {
error = avahi_client_errno(c);
DEBUG(10, ("avahi_entry_group_new failed: %s\n",
avahi_strerror(error)));
break;
}
if (avahi_entry_group_add_service(
state->entry_group, AVAHI_IF_UNSPEC,
AVAHI_PROTO_UNSPEC, 0, global_myname(),
"_smb._tcp", NULL, NULL, state->port, NULL) < 0) {
error = avahi_client_errno(c);
DEBUG(10, ("avahi_entry_group_add_service failed: "
"%s\n", avahi_strerror(error)));
avahi_entry_group_free(state->entry_group);
state->entry_group = NULL;
break;
}
if (avahi_entry_group_commit(state->entry_group) < 0) {
error = avahi_client_errno(c);
DEBUG(10, ("avahi_entry_group_commit failed: "
"%s\n", avahi_strerror(error)));
avahi_entry_group_free(state->entry_group);
state->entry_group = NULL;
break;
}
break;
case AVAHI_CLIENT_FAILURE:
error = avahi_client_errno(c);
DEBUG(10, ("avahi_client_callback: AVAHI_CLIENT_FAILURE: %s\n",
avahi_strerror(error)));
if (error != AVAHI_ERR_DISCONNECTED) {
break;
}
avahi_client_free(c);
state->client = avahi_client_new(state->poll, AVAHI_CLIENT_NO_FAIL,
avahi_client_callback, state,
&error);
if (state->client == NULL) {
DEBUG(10, ("avahi_client_new failed: %s\n",
avahi_strerror(error)));
break;
}
break;
case AVAHI_CLIENT_S_COLLISION:
DEBUG(10, ("avahi_client_callback: "
"AVAHI_CLIENT_S_COLLISION\n"));
break;
case AVAHI_CLIENT_S_REGISTERING:
DEBUG(10, ("avahi_client_callback: "
"AVAHI_CLIENT_S_REGISTERING\n"));
break;
case AVAHI_CLIENT_CONNECTING:
DEBUG(10, ("avahi_client_callback: "
"AVAHI_CLIENT_CONNECTING\n"));
break;
}
}
void *avahi_start_register(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
uint16_t port)
{
struct avahi_state_struct *state;
int error;
state = talloc(mem_ctx, struct avahi_state_struct);
if (state == NULL) {
return state;
}
state->port = port;
state->poll = tevent_avahi_poll(state, ev);
if (state->poll == NULL) {
goto fail;
}
state->client = avahi_client_new(state->poll, AVAHI_CLIENT_NO_FAIL,
avahi_client_callback, state,
&error);
if (state->client == NULL) {
DEBUG(10, ("avahi_client_new failed: %s\n",
avahi_strerror(error)));
goto fail;
}
return state;
fail:
TALLOC_FREE(state);
return NULL;
}

5
source3/smbd/blocking.c
View File

@ -204,9 +204,6 @@ bool push_blocking_lock_request( struct byte_range_lock *br_lck,
(unsigned int)blr->expire_time.tv_usec, lock_timeout,
blr->fsp->fnum, blr->fsp->fsp_name ));
/* Push the MID of this packet on the signing queue. */
srv_defer_sign_response(blr->req->mid);
return True;
}
@ -260,6 +257,7 @@ static void generic_blocking_lock_error(struct blocking_lock_record *blr, NTSTAT
reply_nterror(blr->req, status);
if (!srv_send_smb(smbd_server_fd(), (char *)blr->req->outbuf,
true, blr->req->seqnum+1,
blr->req->encrypted, NULL)) {
exit_server_cleanly("generic_blocking_lock_error: srv_send_smb failed.");
}
@ -343,6 +341,7 @@ static void blocking_lock_reply_error(struct blocking_lock_record *blr, NTSTATUS
if (!srv_send_smb(smbd_server_fd(),
(char *)blr->req->outbuf,
true, blr->req->seqnum+1,
IS_CONN_ENCRYPTED(blr->fsp->conn),
NULL)) {
exit_server_cleanly("blocking_lock_reply_error: "

1
source3/smbd/globals.h
View File

@ -202,6 +202,7 @@ extern int num_children;
struct smbd_server_connection {
struct fd_event *fde;
uint64_t num_requests;
struct smb_signing_state *signing_state;
};
extern struct smbd_server_connection *smbd_server_conn;

4
source3/smbd/ipc.c
View File

@ -134,6 +134,7 @@ void send_trans_reply(connection_struct *conn,
show_msg((char *)req->outbuf);
if (!srv_send_smb(smbd_server_fd(), (char *)req->outbuf,
true, req->seqnum+1,
IS_CONN_ENCRYPTED(conn), &req->pcd)) {
exit_server_cleanly("send_trans_reply: srv_send_smb failed.");
}
@ -190,6 +191,7 @@ void send_trans_reply(connection_struct *conn,
show_msg((char *)req->outbuf);
if (!srv_send_smb(smbd_server_fd(), (char *)req->outbuf,
true, req->seqnum+1,
IS_CONN_ENCRYPTED(conn), &req->pcd))
exit_server_cleanly("send_trans_reply: srv_send_smb "
"failed.");
@ -296,6 +298,7 @@ static void api_dcerpc_cmd_write_done(struct tevent_req *subreq)
send:
if (!srv_send_smb(
smbd_server_fd(), (char *)req->outbuf,
true, req->seqnum+1,
IS_CONN_ENCRYPTED(req->conn) || req->encrypted,
&req->pcd)) {
exit_server_cleanly("construct_reply: srv_send_smb failed.");
@ -322,6 +325,7 @@ static void api_dcerpc_cmd_read_done(struct tevent_req *subreq)
reply_nterror(req, status);
if (!srv_send_smb(smbd_server_fd(), (char *)req->outbuf,
true, req->seqnum+1,
IS_CONN_ENCRYPTED(req->conn)
||req->encrypted, &req->pcd)) {
exit_server_cleanly("construct_reply: srv_send_smb "

2
source3/smbd/negprot.c
View File

@ -316,7 +316,7 @@ static void reply_nt1(struct smb_request *req, uint16 choice)
capabilities &= ~CAP_RAW_MODE;
if (lp_server_signing() == Required)
secword |=NEGOTIATE_SECURITY_SIGNATURES_REQUIRED;
srv_set_signing_negotiated();
srv_set_signing_negotiated(smbd_server_conn);
} else {
DEBUG(0,("reply_nt1: smb signing is incompatible with share level security !\n"));
if (lp_server_signing() == Required) {

7
source3/smbd/notify.c
View File

@ -143,7 +143,9 @@ static void change_notify_reply_packet(connection_struct *conn,
}
show_msg((char *)req->outbuf);
if (!srv_send_smb(smbd_server_fd(), (char *)req->outbuf,
if (!srv_send_smb(smbd_server_fd(),
(char *)req->outbuf,
true, req->seqnum+1,
req->encrypted, &req->pcd)) {
exit_server_cleanly("change_notify_reply_packet: srv_send_smb "
"failed.");
@ -260,9 +262,6 @@ NTSTATUS change_notify_add_request(struct smb_request *req,
map->mid = request->req->mid;
DLIST_ADD(notify_changes_by_mid, map);
/* Push the MID of this packet on the signing queue. */
srv_defer_sign_response(request->req->mid);
return NT_STATUS_OK;
}

7
source3/smbd/nttrans.c
View File

@ -230,6 +230,7 @@ void send_nt_replies(connection_struct *conn,
show_msg((char *)req->outbuf);
if (!srv_send_smb(smbd_server_fd(),
(char *)req->outbuf,
true, req->seqnum+1,
IS_CONN_ENCRYPTED(conn),
&req->pcd)) {
exit_server_cleanly("send_nt_replies: srv_send_smb failed.");
@ -440,6 +441,8 @@ void reply_ntcreate_and_X(struct smb_request *req)
START_PROFILE(SMBntcreateX);
SET_STAT_INVALID(sbuf);
if (req->wct < 24) {
reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
return;
@ -864,6 +867,8 @@ static void call_nt_transact_create(connection_struct *conn,
uint8_t oplock_granted;
TALLOC_CTX *ctx = talloc_tos();
SET_STAT_INVALID(sbuf);
DEBUG(5,("call_nt_transact_create\n"));
/*
@ -1129,9 +1134,9 @@ void reply_ntcancel(struct smb_request *req)
*/
START_PROFILE(SMBntcancel);
srv_cancel_sign_response(smbd_server_conn);
remove_pending_change_notify_requests_by_mid(req->mid);
remove_pending_lock_requests_by_mid(req->mid);
srv_cancel_sign_response(req->mid, true);
DEBUG(3,("reply_ntcancel: cancel called on mid = %d.\n", req->mid));

Some files were not shown because too many files have changed in this diff Show More