sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2025-10-30 08:23:49 +03:00
Code Activity

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

Browse Source
This commit is contained in:
Andrew Bartlett
2008-03-19 10:18:35 +11:00
parent d88b530522 b7dad8674a
commit 400c16e700
43 changed files with 709 additions and 775 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
source/heimdal_build/config.mk
View File

@@ -443,7 +443,7 @@ PUBLIC_DEPENDENCIES = \
HEIMDAL_ROKEN_GETPROGNAME \
HEIMDAL_ROKEN_CLOSEFROM \
RESOLV \
EXT_SOCKET
LIBREPLACE_NETWORK
# End SUBSYSTEM HEIMDAL_ROKEN
#######################
@@ -503,7 +503,7 @@ OBJ_FILES = \
../heimdal/lib/vers/print_version.ho \
../lib/socket_wrapper/socket_wrapper.ho \
replace.ho
PRIVATE_DEPENDENCIES = HEIMDAL_ASN1_COMPILE_LEX HEIMDAL_ROKEN_GETPROGNAME_H EXT_SOCKET EXT_NSL
PRIVATE_DEPENDENCIES = HEIMDAL_ASN1_COMPILE_LEX HEIMDAL_ROKEN_GETPROGNAME_H LIBREPLACE_NETWORK
# End BINARY asn1_compile
#######################
@@ -530,7 +530,7 @@ OBJ_FILES = ../heimdal/lib/vers/print_version.ho \
../heimdal/lib/roken/setprogname.ho \
../lib/socket_wrapper/socket_wrapper.ho \
replace.ho
PRIVATE_DEPENDENCIES = HEIMDAL_COM_ERR_COMPILE_LEX HEIMDAL_ROKEN_GETPROGNAME_H EXT_SOCKET EXT_NSL
PRIVATE_DEPENDENCIES = HEIMDAL_COM_ERR_COMPILE_LEX HEIMDAL_ROKEN_GETPROGNAME_H LIBREPLACE_NETWORK
# End BINARY compile_et
#######################

2
source/lib/ldb/Makefile.in
View File

@@ -121,7 +121,7 @@ distclean:: clean
rm -f Makefile
realdistclean:: distclean
rm -f configure.in include/config.h.in
rm -f configure include/config.h.in
check:: test @PYTHON_CHECK_TARGET@

2
source/lib/ldb/common/ldb.c
View File

@@ -65,7 +65,7 @@ static struct backends_list_entry {
#ifdef HAVE_LDB_LDAP
#define LDAP_INIT &ldb_ldap_backend_ops, \
&ldb_ildap_backend_ops, \
&ldb_ldapi_backend_ops, \
&ldb_ldaps_backend_ops,
#else
#define LDAP_INIT

10
source/lib/ldb/common/ldb_modules.c
View File

@@ -129,11 +129,11 @@ static struct ops_list_entry {
#ifndef STATIC_LIBLDB_MODULES
#define STATIC_LIBLDB_MODULES \
ldb_operational_module_ops, \
ldb_rdn_name_module_ops, \
ldb_paged_results_module_ops, \
ldb_sort_module_ops, \
ldb_asq_module_ops, \
&ldb_operational_module_ops, \
&ldb_rdn_name_module_ops, \
&ldb_paged_results_module_ops, \
&ldb_server_sort_module_ops, \
&ldb_asq_module_ops, \
NULL
#endif

1
source/lib/ldb/include/ldb_includes.h
View File

@@ -18,7 +18,6 @@
#include "replace.h"
#include "system/filesys.h"
#include "system/network.h"
#include "system/time.h"
#include "talloc.h"
#include "ldb.h"

4
source/lib/ldb/include/ldb_private.h
View File

@@ -185,7 +185,7 @@ extern const struct ldb_module_ops ldb_paged_results_module_ops;
extern const struct ldb_module_ops ldb_rdn_name_module_ops;
extern const struct ldb_module_ops ldb_schema_module_ops;
extern const struct ldb_module_ops ldb_asq_module_ops;
extern const struct ldb_module_ops ldb_sort_module_ops;
extern const struct ldb_module_ops ldb_server_sort_module_ops;
extern const struct ldb_module_ops ldb_ldap_module_ops;
extern const struct ldb_module_ops ldb_ildap_module_ops;
extern const struct ldb_module_ops ldb_tdb_module_ops;
@@ -194,7 +194,7 @@ extern const struct ldb_module_ops ldb_sqlite3_module_ops;
extern const struct ldb_backend_ops ldb_tdb_backend_ops;
extern const struct ldb_backend_ops ldb_sqlite3_backend_ops;
extern const struct ldb_backend_ops ldb_ldap_backend_ops;
extern const struct ldb_backend_ops ldb_ildap_backend_ops;
extern const struct ldb_backend_ops ldb_ldapi_backend_ops;
extern const struct ldb_backend_ops ldb_ldaps_backend_ops;
int ldb_match_msg(struct ldb_context *ldb,

6
source/lib/ldb/ldb_ldap/ldb_ldap.c
View File

@@ -826,17 +826,17 @@ failed:
return -1;
}
_PUBLIC_ struct ldb_backend_ops ldb_ldap_backend_ops = {
const struct ldb_backend_ops ldb_ldap_backend_ops = {
.name = "ldap",
.connect_fn = lldb_connect
};
_PUBLIC_ struct ldb_backend_ops ldb_ldapi_backend_ops = {
const struct ldb_backend_ops ldb_ldapi_backend_ops = {
.name = "ldapi",
.connect_fn = lldb_connect
};
_PUBLIC_ struct ldb_backend_ops ldb_ldaps_backend_ops = {
const struct ldb_backend_ops ldb_ldaps_backend_ops = {
.name = "ldaps",
.connect_fn = lldb_connect
};

2
source/lib/ldb/rules.mk
View File

@@ -7,7 +7,7 @@ ctags:
.SUFFIXES: _wrap.c .i
.i_wrap.c:
[ "$(SWIG)" == "no" ] || $(SWIG) -O -Wall -python -keyword $<
[ "$(SWIG)" = "no" ] || $(SWIG) -O -Wall -python -keyword $<
.SUFFIXES: .1 .1.xml .3 .3.xml .xml .html .c .o

2
source/lib/ldb/tests/sample_module.c
View File

@@ -32,7 +32,7 @@ int sample_add(struct ldb_module *mod, struct ldb_request *req)
return ldb_next_request(mod, req);
}
_PUBLIC_ const struct ldb_module_ops ldb_sample_module_ops = {
const struct ldb_module_ops ldb_sample_module_ops = {
.name = "sample",
.add = sample_add,
};

2
source/lib/ldb/tests/test-soloading.sh
View File

@@ -19,7 +19,7 @@ fi
cat <<EOF | $VALGRIND ldbadd || exit 1
dn: @MODULES
@LIST: sample_module
@LIST: sample
EOF
cat <<EOF | $VALGRIND ldbadd || exit 1

1
source/lib/replace/README
View File

@@ -15,7 +15,6 @@ rename
initgroups
memmove
strdup
inet_ntoa
setlinebuf
vsyslog
timegm

2
source/lib/replace/configure.ac
View File

@@ -21,7 +21,7 @@ if test "$ac_cv_prog_gcc" = yes; then
CFLAGS="$CFLAGS -Wno-format-y2k"
fi
LIBS="$SOCKET_LIBS $NSL_LIBS"
LIBS="${LIBREPLACE_NETWORK_LIBS}"
AC_SUBST(LIBS)
AC_SUBST(LDFLAGS)

4
source/lib/replace/getifaddrs.m4
View File

@@ -34,10 +34,10 @@ fi
##################
# look for a method of finding the list of network interfaces
#
# This tests need LIBS="$NSL_LIBS $SOCKET_LIBS"
# This tests need LIBS="${LIBREPLACE_NETWORK_LIBS}"
#
old_LIBS=$LIBS
LIBS="$NSL_LIBS $SOCKET_LIBS"
LIBS="${LIBREPLACE_NETWORK_LIBS}"
SAVE_CPPFLAGS="$CPPFLAGS"
CPPFLAGS="$CPPFLAGS -I$libreplacedir"
iface=no;

8
source/lib/replace/getpass.c
View File

@@ -185,7 +185,13 @@ char *rep_getpass(const char *prompt)
buf[0] = 0;
if (!gotintr) {
in_fd = fileno(in);
fgets(buf, bufsize, in);
if (fgets(buf, bufsize, in) == NULL) {
buf[0] = 0;
if (in && in != stdin) {
fclose(in);
}
return buf;
}
}
nread = strlen(buf);
if (nread) {

22
source/lib/replace/inet_aton.c
View File

@@ -3,18 +3,22 @@
* replacement functions
* Copyright (C) Michael Adam <obnox@samba.org> 2008
*
* 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.
* ** NOTE! The following LGPL license applies to the replace
* ** library. This does NOT imply that all of Samba is released
* ** under the LGPL
*
* This program is distributed in the hope that it will be useful,
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3 of the License, or (at your option) any later version.
*
* This library 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.
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser 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/>.
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, see <http://www.gnu.org/licenses/>.
*/
#include "replace.h"

39
source/lib/replace/inet_ntoa.c Normal file
View File

@@ -0,0 +1,39 @@
/*
* Unix SMB/CIFS implementation.
* replacement routines for broken systems
* Copyright (C) Andrew Tridgell 2003
* Copyright (C) Michael Adam 2008
*
* ** NOTE! The following LGPL license applies to the replace
* ** library. This does NOT imply that all of Samba is released
* ** under the LGPL
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, see <http://www.gnu.org/licenses/>.
*/
#include "replace.h"
#include "system/network.h"
/**
* NOTE: this is not thread safe, but it can't be, either
* since it returns a pointer to static memory.
*/
char *rep_inet_ntoa(struct in_addr ip)
{
uint8_t *p = (uint8_t *)&ip.s_addr;
static char buf[18];
slprintf(buf, 17, "%d.%d.%d.%d",
(int)p[0], (int)p[1], (int)p[2], (int)p[3]);
return buf;
}

19
source/lib/replace/inet_ntoa.m4 Normal file
View File

@@ -0,0 +1,19 @@
AC_CHECK_FUNCS(inet_ntoa,[],[LIBREPLACEOBJ="${LIBREPLACEOBJ} inet_ntoa.o"])
AC_CACHE_CHECK([for broken inet_ntoa],libreplace_cv_REPLACE_INET_NTOA,[
AC_TRY_RUN([
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <netinet/in.h>
#ifdef HAVE_ARPA_INET_H
#include <arpa/inet.h>
#endif
main() { struct in_addr ip; ip.s_addr = 0x12345678;
if (strcmp(inet_ntoa(ip),"18.52.86.120") &&
strcmp(inet_ntoa(ip),"120.86.52.18")) { exit(0); }
exit(1);}],
libreplace_cv_REPLACE_INET_NTOA=yes,libreplace_cv_REPLACE_INET_NTOA=no,libreplace_cv_REPLACE_INET_NTOA=cross)])
if test x"$libreplace_cv_REPLACE_INET_NTOA" = x"yes"; then
AC_DEFINE(REPLACE_INET_NTOA,1,[Whether inet_ntoa should be replaced])
fi

22
source/lib/replace/libreplace.m4
View File

@@ -120,24 +120,6 @@ if test x"$libreplace_cv_USABLE_NET_IF_H" = x"yes";then
AC_DEFINE(HAVE_NET_IF_H, 1, usability of net/if.h)
fi
AC_CACHE_CHECK([for broken inet_ntoa],libreplace_cv_REPLACE_INET_NTOA,[
AC_TRY_RUN([
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <netinet/in.h>
#ifdef HAVE_ARPA_INET_H
#include <arpa/inet.h>
#endif
main() { struct in_addr ip; ip.s_addr = 0x12345678;
if (strcmp(inet_ntoa(ip),"18.52.86.120") &&
strcmp(inet_ntoa(ip),"120.86.52.18")) { exit(0); }
exit(1);}],
libreplace_cv_REPLACE_INET_NTOA=yes,libreplace_cv_REPLACE_INET_NTOA=no,libreplace_cv_REPLACE_INET_NTOA=cross)])
if test x"$libreplace_cv_REPLACE_INET_NTOA" = x"yes"; then
AC_DEFINE(REPLACE_INET_NTOA,1,[Whether inet_ntoa should be replaced])
fi
AC_HAVE_TYPE([socklen_t],[#include <sys/socket.h>])
AC_HAVE_TYPE([sa_family_t],[#include <sys/socket.h>])
AC_HAVE_TYPE([struct addrinfo], [#include <netdb.h>])
@@ -176,7 +158,7 @@ fi
AC_CHECK_FUNCS(seteuid setresuid setegid setresgid chroot bzero strerror)
AC_CHECK_FUNCS(vsyslog setlinebuf mktime ftruncate chsize rename)
AC_CHECK_FUNCS(waitpid strlcpy strlcat initgroups memmove strdup)
AC_CHECK_FUNCS(pread pwrite strndup strcasestr strtok_r mkdtemp socketpair)
AC_CHECK_FUNCS(pread pwrite strndup strcasestr strtok_r mkdtemp)
AC_CHECK_FUNCS(isatty)
AC_HAVE_DECL(setresuid, [#include <unistd.h>])
AC_HAVE_DECL(setresgid, [#include <unistd.h>])
@@ -348,9 +330,11 @@ m4_include(socket.m4)
m4_include(inet_ntop.m4)
m4_include(inet_pton.m4)
m4_include(inet_aton.m4)
m4_include(inet_ntoa.m4)
m4_include(getaddrinfo.m4)
m4_include(repdir.m4)
m4_include(getifaddrs.m4)
m4_include(socketpair.m4)
AC_CHECK_FUNCS([syslog printf memset memcpy],,[AC_MSG_ERROR([Required function not found])])

37
source/lib/replace/replace.c
View File

@@ -27,7 +27,6 @@
#include "system/time.h"
#include "system/passwd.h"
#include "system/syslog.h"
#include "system/network.h"
#include "system/locale.h"
#include "system/wait.h"
@@ -295,20 +294,6 @@ char *rep_strdup(const char *s)
}
#endif /* HAVE_STRDUP */
#ifndef WITH_PTHREADS
/* REWRITE: not thread safe */
#ifdef REPLACE_INET_NTOA
char *rep_inet_ntoa(struct in_addr ip)
{
uint8_t *p = (uint8_t *)&ip.s_addr;
static char buf[18];
slprintf(buf, 17, "%d.%d.%d.%d",
(int)p[0], (int)p[1], (int)p[2], (int)p[3]);
return buf;
}
#endif /* REPLACE_INET_NTOA */
#endif
#ifndef HAVE_SETLINEBUF
void rep_setlinebuf(FILE *stream)
{
@@ -599,25 +584,3 @@ int rep_unsetenv(const char *name)
return 0;
}
#endif
#ifndef HAVE_SOCKETPAIR
int rep_socketpair(int d, int type, int protocol, int sv[2])
{
if (d != AF_UNIX) {
errno = EAFNOSUPPORT;
return -1;
}
if (protocol != 0) {
errno = EPROTONOSUPPORT;
return -1;
}
if (type != SOCK_STREAM) {
errno = EOPNOTSUPP;
return -1;
}
return pipe(sv);
}
#endif

4
source/lib/replace/replace.h
View File

@@ -212,7 +212,7 @@ int rep_dlclose(void *handle);
#ifndef HAVE_SOCKETPAIR
#define socketpair rep_socketpair
int rep_socketpair(int d, int type, int protocol, int sv[2]);
/* prototype is in system/network.h */
#endif
#ifndef PRINTF_ATTRIBUTE
@@ -325,7 +325,7 @@ ssize_t rep_pread(int __fd, void *__buf, size_t __nbytes, off_t __offset);
ssize_t rep_pwrite(int __fd, const void *__buf, size_t __nbytes, off_t __offset);
#endif
#ifdef REPLACE_INET_NTOA
#if !defined(HAVE_INET_NTOA) || defined(REPLACE_INET_NTOA)
#define inet_ntoa rep_inet_ntoa
/* prototype is in "system/network.h" */
#endif

3
source/lib/replace/samba.m4
View File

@@ -3,6 +3,9 @@ AC_LIBREPLACE_BROKEN_CHECKS
SMB_EXT_LIB(LIBREPLACE_EXT, [${LIBDL}])
SMB_ENABLE(LIBREPLACE_EXT)
SMB_EXT_LIB(LIBREPLACE_NETWORK, [${LIBREPLACE_NETWORK_LIBS}])
SMB_ENABLE(LIBREPLACE_NETWORK)
# remove leading ./
LIBREPLACE_DIR=`echo ${libreplacedir} |sed -e 's/^\.\///g'`

2
source/lib/replace/snprintf.c
View File

@@ -1264,7 +1264,7 @@ static int add_cnk_list_entry(struct pr_chunk_x **list,
VA_COPY(ap2, ap);
ret = vsnprintf(NULL, 0, format, ap2);
va_end(ap2);
if (ret <= 0) return ret;
if (ret < 0) return ret;
(*ptr) = (char *)malloc(ret+1);
if (!*ptr) return -1;

15
source/lib/replace/socket.m4
View File

@@ -7,10 +7,10 @@ dnl only looks in /etc/hosts), so we only look for -lsocket if we need
dnl it.
AC_CHECK_FUNCS(connect)
if test x"$ac_cv_func_connect" = x"no"; then
AC_CHECK_LIB_EXT(nsl_s, SOCKET_LIBS, connect)
AC_CHECK_LIB_EXT(nsl, SOCKET_LIBS, connect)
AC_CHECK_LIB_EXT(socket, SOCKET_LIBS, connect)
AC_CHECK_LIB_EXT(inet, SOCKET_LIBS, connect)
AC_CHECK_LIB_EXT(nsl_s, LIBREPLACE_NETWORK_LIBS, connect)
AC_CHECK_LIB_EXT(nsl, LIBREPLACE_NETWORK_LIBS, connect)
AC_CHECK_LIB_EXT(socket, LIBREPLACE_NETWORK_LIBS, connect)
AC_CHECK_LIB_EXT(inet, LIBREPLACE_NETWORK_LIBS, connect)
dnl We can't just call AC_CHECK_FUNCS(connect) here,
dnl because the value has been cached.
if test x"$ac_cv_lib_ext_nsl_s_connect" = x"yes" ||
@@ -24,9 +24,9 @@ fi
AC_CHECK_FUNCS(gethostbyname)
if test x"$ac_cv_func_gethostbyname" = x"no"; then
AC_CHECK_LIB_EXT(nsl_s, NSL_LIBS, gethostbyname)
AC_CHECK_LIB_EXT(nsl, NSL_LIBS, gethostbyname)
AC_CHECK_LIB_EXT(socket, NSL_LIBS, gethostbyname)
AC_CHECK_LIB_EXT(nsl_s, LIBREPLACE_NETWORK_LIBS, gethostbyname)
AC_CHECK_LIB_EXT(nsl, LIBREPLACE_NETWORK_LIBS, gethostbyname)
AC_CHECK_LIB_EXT(socket, LIBREPLACE_NETWORK_LIBS, gethostbyname)
dnl We can't just call AC_CHECK_FUNCS(gethostbyname) here,
dnl because the value has been cached.
if test x"$ac_cv_lib_ext_nsl_s_gethostbyname" = x"yes" ||
@@ -37,4 +37,3 @@ if test x"$ac_cv_func_gethostbyname" = x"no"; then
[Whether the system has gethostbyname()])
fi
fi

46
source/lib/replace/socketpair.c Normal file
View File

@@ -0,0 +1,46 @@
/*
* Unix SMB/CIFS implementation.
* replacement routines for broken systems
* Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2006
* Copyright (C) Michael Adam <obnox@samba.org> 2008
*
* ** NOTE! The following LGPL license applies to the replace
* ** library. This does NOT imply that all of Samba is released
* ** under the LGPL
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, see <http://www.gnu.org/licenses/>.
*/
#include "replace.h"
#include "system/network.h"
int rep_socketpair(int d, int type, int protocol, int sv[2])
{
if (d != AF_UNIX) {
errno = EAFNOSUPPORT;
return -1;
}
if (protocol != 0) {
errno = EPROTONOSUPPORT;
return -1;
}
if (type != SOCK_STREAM) {
errno = EOPNOTSUPP;
return -1;
}
return pipe(sv);
}

1
source/lib/replace/socketpair.m4 Normal file
View File

@@ -0,0 +1 @@
AC_CHECK_FUNCS(socketpair,[],[LIBREPLACEOBJ="${LIBREPLACEOBJ} socketpair.o"])

9
source/lib/replace/system/network.h
View File

@@ -88,7 +88,7 @@
typedef int socklen_t;
#endif
#ifdef REPLACE_INET_NTOA
#if !defined (HAVE_INET_NTOA) || defined(REPLACE_INET_NTOA)
/* define is in "replace.h" */
char *rep_inet_ntoa(struct in_addr ip);
#endif
@@ -143,6 +143,11 @@ int rep_getifaddrs(struct ifaddrs **);
void rep_freeifaddrs(struct ifaddrs *);
#endif
#ifndef HAVE_SOCKETPAIR
/* define is in "replace.h" */
int rep_socketpair(int d, int type, int protocol, int sv[2]);
#endif
/*
* Some systems have getaddrinfo but not the
* defines needed to use it.
@@ -310,7 +315,7 @@ struct addrinfo {
/* Needed for some systems that don't define it (Solaris). */
#ifndef ifr_netmask
#define ifr_netmask ifr_addrs
#define ifr_netmask ifr_addr
#endif
#ifdef SOCKET_WRAPPER

44
source/lib/socket/config.m4
View File

@@ -11,50 +11,6 @@ if test x"$samba_cv_HAVE_SOCK_SIN_LEN" = x"yes"; then
AC_DEFINE(HAVE_SOCK_SIN_LEN,1,[Whether the sockaddr_in struct has a sin_len property])
fi
# The following test taken from the cvs sources
# If we can't find connect, try looking in -lsocket, -lnsl, and -linet.
# The Irix 5 libc.so has connect and gethostbyname, but Irix 5 also has
# libsocket.so which has a bad implementation of gethostbyname (it
# only looks in /etc/hosts), so we only look for -lsocket if we need
# it.
AC_CHECK_FUNCS(connect)
if test x"$ac_cv_func_connect" = x"no"; then
AC_CHECK_LIB_EXT(nsl_s, SOCKET_LIBS, connect)
AC_CHECK_LIB_EXT(nsl, SOCKET_LIBS, connect)
AC_CHECK_LIB_EXT(socket, SOCKET_LIBS, connect)
AC_CHECK_LIB_EXT(inet, SOCKET_LIBS, connect)
SMB_ENABLE(EXT_SOCKET,YES)
dnl We can't just call AC_CHECK_FUNCS(connect) here, because the value
dnl has been cached.
if test x"$ac_cv_lib_ext_nsl_s_connect" = x"yes" ||
test x"$ac_cv_lib_ext_nsl_connect" = x"yes" ||
test x"$ac_cv_lib_ext_socket_connect" = x"yes" ||
test x"$ac_cv_lib_ext_inet_connect" = x"yes"; then
AC_DEFINE(HAVE_CONNECT,1,[Whether the system has connect()])
else
AC_MSG_ERROR([no connect() function available!])
fi
fi
SMB_EXT_LIB(EXT_SOCKET,[${SOCKET_LIBS}],[${SOCKET_CFLAGS}],[${SOCKET_CPPFLAGS}],[${SOCKET_LDFLAGS}])
AC_CHECK_FUNCS(gethostbyname)
if test x"$ac_cv_func_gethostbyname" = x"no"; then
AC_CHECK_LIB_EXT(nsl_s, NSL_LIBS, gethostbyname)
AC_CHECK_LIB_EXT(nsl, NSL_LIBS, gethostbyname)
AC_CHECK_LIB_EXT(socket, NSL_LIBS, gethostbyname)
SMB_ENABLE(EXT_NSL,YES)
dnl We can't just call AC_CHECK_FUNCS(gethostbyname) here, because the value
dnl has been cached.
if test x"$ac_cv_lib_ext_nsl_s_gethostbyname" != x"yes" &&
test x"$ac_cv_lib_ext_nsl_gethostbyname" != x"yes" &&
test x"$ac_cv_lib_ext_socket_gethostbyname" != x"yes"; then
AC_MSG_ERROR([no gethostbyname() function available!])
fi
fi
SMB_EXT_LIB(EXT_NSL,[${NSL_LIBS}],[],[],[])
############################################
# check for unix domain sockets
AC_CACHE_CHECK([for unix domain sockets],samba_cv_unixsocket, [

6
source/lib/socket/config.mk
View File

@@ -5,7 +5,7 @@ PRIVATE_PROTO_HEADER = netif_proto.h
OBJ_FILES = \
interface.o \
netif.o
PRIVATE_DEPENDENCIES = LIBSAMBA-UTIL EXT_SOCKET EXT_NSL
PRIVATE_DEPENDENCIES = LIBSAMBA-UTIL LIBREPLACE_NETWORK
# End SUBSYSTEM LIBNETIF
##############################
@@ -16,7 +16,7 @@ SUBSYSTEM = samba-socket
OUTPUT_TYPE = MERGED_OBJ
OBJ_FILES = \
socket_ip.o
PRIVATE_DEPENDENCIES = EXT_SOCKET EXT_NSL LIBSAMBA-ERRORS
PRIVATE_DEPENDENCIES = LIBSAMBA-ERRORS LIBREPLACE_NETWORK
# End MODULE socket_ip
################################################
@@ -27,7 +27,7 @@ SUBSYSTEM = samba-socket
OUTPUT_TYPE = MERGED_OBJ
OBJ_FILES = \
socket_unix.o
PRIVATE_DEPENDENCIES = EXT_SOCKET EXT_NSL
PRIVATE_DEPENDENCIES = LIBREPLACE_NETWORK
# End MODULE socket_unix
################################################

2
source/lib/socket_wrapper/config.mk
View File

@@ -2,7 +2,7 @@
# Start SUBSYSTEM SOCKET_WRAPPER
[SUBSYSTEM::SOCKET_WRAPPER]
OBJ_FILES = socket_wrapper.o
PRIVATE_DEPENDENCIES = EXT_SOCKET
PRIVATE_DEPENDENCIES = LIBREPLACE_NETWORK
# End SUBSYSTEM SOCKET_WRAPPER
##############################

2
source/lib/util/config.mk
View File

@@ -21,7 +21,7 @@ OBJ_FILES = xfile.o \
become_daemon.o
PUBLIC_DEPENDENCIES = \
LIBTALLOC LIBCRYPTO \
SOCKET_WRAPPER EXT_NSL \
SOCKET_WRAPPER LIBREPLACE_NETWORK \
CHARSET EXECINFO
PUBLIC_HEADERS += $(addprefix lib/util/, util.h \

2
source/librpc/config.mk
View File

@@ -10,7 +10,7 @@ OBJ_FILES = \
ndr/ndr_basic.o \
ndr/ndr_string.o \
ndr/uuid.o
PUBLIC_DEPENDENCIES = LIBSAMBA-ERRORS LIBTALLOC LIBSAMBA-UTIL CHARSET EXT_NSL \
PUBLIC_DEPENDENCIES = LIBSAMBA-ERRORS LIBTALLOC LIBSAMBA-UTIL CHARSET \
LIBSAMBA-CONFIG
# End SUBSYSTEM LIBNDR
################################################

4
source/script/valgrind_run
View File

@@ -4,4 +4,6 @@ ENV="$1"
shift 1
$ENV valgrind -q --db-attach=yes --num-callers=30 $@
CMD="$ENV valgrind -q --db-attach=yes --num-callers=30 $@"
echo $CMD
eval $CMD

29
source/selftest/Subunit.pm
View File

@@ -15,34 +15,7 @@ sub parse_results($$$$$)
my $unexpected_err = 0;
my $orig_open_len = $#$open_tests;
while(1) {
my $line = "";
my $char = "";
my $eof = 0;
my $error = 0;
while ($char ne "\n") {
my $ret = sysread($fh, $char, 1);
if (not defined($ret)) {
$error = $!;
last;
}
if ($ret == 0) {
$eof = 1;
last;
}
$line .= $char;
if ($char eq "\r") {
$msg_ops->output_msg($line);
$line = "";
}
}
last if ($eof or $error);
$_ = $line;
while(<$fh>) {
if (/^test: (.+)\n/) {
$msg_ops->control_msg($_);
$msg_ops->start_test($open_tests, $1);

4
source/torture/raw/oplock.c
View File

@@ -2539,7 +2539,7 @@ static bool test_raw_oplock_batch22(struct torture_context *tctx, struct smbcli_
int te;
if (torture_setting_bool(tctx, "samba3", false)) {
torture_skip(tctx, "BACHT22 disabled against samba3\n");
torture_skip(tctx, "BATCH22 disabled against samba3\n");
}
if (!torture_setup_dir(cli1, BASEDIR)) {
@@ -2629,7 +2629,7 @@ static bool test_raw_oplock_batch23(struct torture_context *tctx, struct smbcli_
struct smbcli_state *cli3 = NULL;
if (torture_setting_bool(tctx, "samba3", false)) {
torture_skip(tctx, "BACHT23 disabled against samba3\n");
torture_skip(tctx, "BATCH23 disabled against samba3\n");
}
if (!torture_setup_dir(cli1, BASEDIR)) {

2
source/winbind/config.mk
View File

@@ -16,6 +16,8 @@ OBJ_FILES = \
wb_dom_info_trusted.o \
wb_sid2domain.o \
wb_name2domain.o \
wb_sids2xids.o \
wb_xids2sids.o \
wb_gid2sid.o \
wb_sid2uid.o \
wb_sid2gid.o \

738
source/winbind/idmap.c
View File

@@ -1,7 +1,7 @@
/*
Unix SMB/CIFS implementation.
Map SIDs to uids/gids and back
Map SIDs to unixids and back
Copyright (C) Kai Blin 2008
@@ -177,39 +177,46 @@ struct idmap_context *idmap_init(TALLOC_CTX *mem_ctx,
return NULL;
}
idmap_ctx->unix_groups_sid = dom_sid_parse_talloc(mem_ctx, "S-1-22-2");
if (idmap_ctx->unix_groups_sid == NULL) {
return NULL;
}
idmap_ctx->unix_users_sid = dom_sid_parse_talloc(mem_ctx, "S-1-22-1");
if (idmap_ctx->unix_users_sid == NULL) {
return NULL;
}
return idmap_ctx;
}
/**
* Convert a uid to the corresponding SID
* Convert an unixid to the corresponding SID
*
* \param idmap_ctx idmap context to use
* \param mem_ctx talloc context the memory for the struct dom_sid is allocated
* from.
* \param uid Unix uid to map to a SID
* \param sid Pointer that will take the struct dom_sid pointer if the mapping
* \param unixid pointer to a unixid struct to convert
* \param sid pointer that will take the struct dom_sid pointer if the mapping
* succeeds.
* \return NT_STATUS_OK on success, NT_STATUS_NONE_MAPPED if mapping not
* possible or some other NTSTATUS that is more descriptive on failure.
*/
NTSTATUS idmap_uid_to_sid(struct idmap_context *idmap_ctx, TALLOC_CTX *mem_ctx,
const uid_t uid, struct dom_sid **sid)
NTSTATUS idmap_xid_to_sid(struct idmap_context *idmap_ctx, TALLOC_CTX *mem_ctx,
const struct unixid *unixid, struct dom_sid **sid)
{
int ret;
NTSTATUS status = NT_STATUS_NONE_MAPPED;
struct ldb_context *ldb = idmap_ctx->ldb_ctx;
struct ldb_message *msg;
struct ldb_result *res = NULL;
int trans = -1;
uid_t low, high;
char *sid_string, *uid_string;
struct dom_sid *unix_users_sid, *new_sid;
uint32_t low, high;
struct dom_sid *unix_sid, *new_sid;
TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
ret = ldb_search_exp_fmt(ldb, tmp_ctx, &res, NULL, LDB_SCOPE_SUBTREE,
NULL, "(&(objectClass=sidMap)(uidNumber=%u))",
uid);
NULL, "(&(objectClass=sidMap)(xidNumber=%u))",
unixid->id);
if (ret != LDB_SUCCESS) {
DEBUG(1, ("Search failed: %s\n", ldb_errstring(ldb)));
status = NT_STATUS_NONE_MAPPED;
@@ -228,19 +235,13 @@ NTSTATUS idmap_uid_to_sid(struct idmap_context *idmap_ctx, TALLOC_CTX *mem_ctx,
return NT_STATUS_OK;
}
DEBUG(6, ("uid not found in idmap db, trying to allocate SID.\n"));
trans = ldb_transaction_start(ldb);
if (trans != LDB_SUCCESS) {
status = NT_STATUS_NONE_MAPPED;
goto failed;
}
DEBUG(6, ("xid not found in idmap db, trying to allocate SID.\n"));
/* Now redo the search to make sure noone added a mapping for that SID
* while we weren't looking.*/
ret = ldb_search_exp_fmt(ldb, tmp_ctx, &res, NULL, LDB_SCOPE_SUBTREE,
NULL, "(&(objectClass=sidMap)(uidNumber=%u))",
uid);
NULL, "(&(objectClass=sidMap)(xidNumber=%u))",
unixid->id);
if (ret != LDB_SUCCESS) {
DEBUG(1, ("Search failed: %s\n", ldb_errstring(ldb)));
status = NT_STATUS_NONE_MAPPED;
@@ -260,285 +261,58 @@ NTSTATUS idmap_uid_to_sid(struct idmap_context *idmap_ctx, TALLOC_CTX *mem_ctx,
goto failed;
}
if (uid >= low && uid <= high) {
/* An existing user would have been mapped before */
status = NT_STATUS_NO_SUCH_USER;
if (unixid->id >= low && unixid->id <= high) {
/* An existing xid would have been mapped before */
status = NT_STATUS_NONE_MAPPED;
goto failed;
}
/* For local users, we just create a rid = uid +1, so root doesn't end
* up with a 0 rid */
unix_users_sid = dom_sid_parse_talloc(tmp_ctx, "S-1-22-1");
if (unix_users_sid == NULL) {
if (unixid->type == ID_TYPE_UID) {
unix_sid = dom_sid_parse_talloc(tmp_ctx, "S-1-22-1");
} else {
unix_sid = dom_sid_parse_talloc(tmp_ctx, "S-1-22-2");
}
if (unix_sid == NULL) {
status = NT_STATUS_NO_MEMORY;
goto failed;
}
new_sid = dom_sid_add_rid(mem_ctx, unix_users_sid, uid + 1);
new_sid = dom_sid_add_rid(mem_ctx, unix_sid, unixid->id + 1);
if (new_sid == NULL) {
status = NT_STATUS_NO_MEMORY;
goto failed;
}
sid_string = dom_sid_string(tmp_ctx, new_sid);
if (sid_string == NULL) {
status = NT_STATUS_NO_MEMORY;
goto failed;
}
uid_string = talloc_asprintf(tmp_ctx, "%u", uid);
if (uid_string == NULL) {
status = NT_STATUS_NO_MEMORY;
goto failed;
}
msg = ldb_msg_new(tmp_ctx);
if (msg == NULL) {
status = NT_STATUS_NO_MEMORY;
goto failed;
}
msg->dn = ldb_dn_new_fmt(tmp_ctx, ldb, "CN=%s", sid_string);
if (msg->dn == NULL) {
status = NT_STATUS_NO_MEMORY;
goto failed;
}
ret = ldb_msg_add_string(msg, "uidNumber", uid_string);
if (ret != LDB_SUCCESS) {
status = NT_STATUS_NONE_MAPPED;
goto failed;
}
ret = idmap_msg_add_dom_sid(idmap_ctx, tmp_ctx, msg, "objectSid",
new_sid);
if (ret != LDB_SUCCESS) {
status = NT_STATUS_NONE_MAPPED;
goto failed;
}
ret = ldb_msg_add_string(msg, "objectClass", "sidMap");
if (ret != LDB_SUCCESS) {
status = NT_STATUS_NONE_MAPPED;
goto failed;
}
ret = ldb_msg_add_string(msg, "cn", sid_string);
if (ret != LDB_SUCCESS) {
status = NT_STATUS_NONE_MAPPED;
goto failed;
}
ret = ldb_add(ldb, msg);
if (ret != LDB_SUCCESS) {
status = NT_STATUS_NONE_MAPPED;
goto failed;
}
trans = ldb_transaction_commit(ldb);
if (trans != LDB_SUCCESS) {
status = NT_STATUS_NONE_MAPPED;
goto failed;
}
*sid = new_sid;
talloc_free(tmp_ctx);
return NT_STATUS_OK;
failed:
if (trans == LDB_SUCCESS) ldb_transaction_cancel(ldb);
talloc_free(tmp_ctx);
return status;
}
/**
* Map a Unix gid to the corresponding SID
*
* \param idmap_ctx idmap context to use
* \param mem_ctx talloc context the memory for the struct dom_sid is allocated
* from.
* \param gid Unix gid to map to a SID
* \param sid Pointer that will take the struct dom_sid pointer if mapping
* succeeds.
* \return NT_STATUS_OK on success, NT_STATUS_NONE_MAPPED if mapping not
* possible or some other NTSTATUS that is more descriptive on failure.
*/
NTSTATUS idmap_gid_to_sid(struct idmap_context *idmap_ctx, TALLOC_CTX *mem_ctx,
const gid_t gid, struct dom_sid **sid)
{
int ret;
NTSTATUS status = NT_STATUS_NONE_MAPPED;
struct ldb_context *ldb = idmap_ctx->ldb_ctx;
struct ldb_message *msg;
struct ldb_result *res = NULL;
int trans = -1;
gid_t low, high;
char *sid_string, *gid_string;
struct dom_sid *unix_groups_sid, *new_sid;
TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
ret = ldb_search_exp_fmt(ldb, tmp_ctx, &res, NULL, LDB_SCOPE_SUBTREE,
NULL, "(&(objectClass=sidMap)(gidNumber=%u))", gid);
if (ret != LDB_SUCCESS) {
DEBUG(1, ("Search failed: %s\n", ldb_errstring(ldb)));
status = NT_STATUS_NONE_MAPPED;
goto failed;
}
if (res->count == 1) {
*sid = idmap_msg_get_dom_sid(mem_ctx, res->msgs[0],
"objectSid");
if (*sid == NULL) {
DEBUG(1, ("Failed to get sid from db: %u\n", ret));
status = NT_STATUS_NONE_MAPPED;
goto failed;
}
/* No change, so cancel the transaction */
ldb_transaction_cancel(ldb);
talloc_free(tmp_ctx);
return NT_STATUS_OK;
}
DEBUG(6, ("gid not found in idmap db, trying to allocate SID.\n"));
trans = ldb_transaction_start(ldb);
if (trans != LDB_SUCCESS) {
status = NT_STATUS_NONE_MAPPED;
goto failed;
}
/* Now redo the search to make sure noone added a mapping for that SID
* while we weren't looking.*/
ret = ldb_search_exp_fmt(ldb, tmp_ctx, &res, NULL, LDB_SCOPE_SUBTREE,
NULL, "(&(objectClass=sidMap)(gidNumber=%u))",
gid);
if (ret != LDB_SUCCESS) {
DEBUG(1, ("Search failed: %s\n", ldb_errstring(ldb)));
status = NT_STATUS_NONE_MAPPED;
goto failed;
}
if (res->count > 0) {
DEBUG(1, ("sidMap modified while trying to add a mapping.\n"));
status = NT_STATUS_RETRY;
goto failed;
}
ret = idmap_get_bounds(idmap_ctx, &low, &high);
if (ret != LDB_SUCCESS) {
DEBUG(1, ("Failed to get id bounds from db: %u\n", ret));
status = NT_STATUS_NONE_MAPPED;
goto failed;
}
if (gid >= low && gid <= high) {
/* An existing group would have been mapped before */
status = NT_STATUS_NO_SUCH_USER;
goto failed;
}
/* For local groups, we just create a rid = gid +1, so root doesn't end
* up with a 0 rid */
unix_groups_sid = dom_sid_parse_talloc(tmp_ctx, "S-1-22-2");
if (unix_groups_sid == NULL) {
status = NT_STATUS_NO_MEMORY;
goto failed;
}
new_sid = dom_sid_add_rid(mem_ctx, unix_groups_sid, gid + 1);
if (new_sid == NULL) {
status = NT_STATUS_NO_MEMORY;
goto failed;
}
sid_string = dom_sid_string(tmp_ctx, new_sid);
if (sid_string == NULL) {
status = NT_STATUS_NO_MEMORY;
goto failed;
}
gid_string = talloc_asprintf(tmp_ctx, "%u", gid);
if (gid_string == NULL) {
status = NT_STATUS_NO_MEMORY;
goto failed;
}
msg = ldb_msg_new(tmp_ctx);
if (msg == NULL) {
status = NT_STATUS_NO_MEMORY;
goto failed;
}
msg->dn = ldb_dn_new_fmt(tmp_ctx, ldb, "CN=%s", sid_string);
if (msg->dn == NULL) {
status = NT_STATUS_NO_MEMORY;
goto failed;
}
ret = ldb_msg_add_string(msg, "gidNumber", gid_string);
if (ret != LDB_SUCCESS) {
status = NT_STATUS_NONE_MAPPED;
goto failed;
}
ret = idmap_msg_add_dom_sid(idmap_ctx, tmp_ctx, msg, "objectSid",
new_sid);
if (ret != LDB_SUCCESS) {
status = NT_STATUS_NONE_MAPPED;
goto failed;
}
ret = ldb_msg_add_string(msg, "objectClass", "sidMap");
if (ret != LDB_SUCCESS) {
status = NT_STATUS_NONE_MAPPED;
goto failed;
}
ret = ldb_msg_add_string(msg, "cn", sid_string);
if (ret != LDB_SUCCESS) {
status = NT_STATUS_NONE_MAPPED;
goto failed;
}
ret = ldb_add(ldb, msg);
if (ret != LDB_SUCCESS) {
status = NT_STATUS_NONE_MAPPED;
goto failed;
}
trans = ldb_transaction_commit(ldb);
if (trans != LDB_SUCCESS) {
status = NT_STATUS_NONE_MAPPED;
goto failed;
}
*sid = new_sid;
talloc_free(tmp_ctx);
return NT_STATUS_OK;
failed:
if (trans == LDB_SUCCESS) ldb_transaction_cancel(ldb);
talloc_free(tmp_ctx);
return status;
}
/**
* Map a SID to a Unix uid.
* Map a SID to an unixid struct.
*
* If no mapping exists, a new mapping will be created.
*
* \todo Check if SIDs can be resolved if lp_idmap_trusted_only() == true
* \todo Fix backwards compatibility for Samba3
*
* \param idmap_ctx idmap context to use
* \param mem_ctx talloc context to use
* \param sid SID to map to a Unix uid
* \param uid pointer to receive the mapped uid
* \param sid SID to map to an unixid struct
* \param unixid pointer to a unixid struct pointer
* \return NT_STATUS_OK on success, NT_STATUS_INVALID_SID if the sid is not from
* a trusted domain and idmap trusted only = true, NT_STATUS_NONE_MAPPED if the
* mapping failed.
*/
NTSTATUS idmap_sid_to_uid(struct idmap_context *idmap_ctx, TALLOC_CTX *mem_ctx,
const struct dom_sid *sid, uid_t *uid)
NTSTATUS idmap_sid_to_xid(struct idmap_context *idmap_ctx, TALLOC_CTX *mem_ctx,
const struct dom_sid *sid, struct unixid **unixid)
{
int ret;
NTSTATUS status = NT_STATUS_NONE_MAPPED;
@@ -547,8 +321,8 @@ NTSTATUS idmap_sid_to_uid(struct idmap_context *idmap_ctx, TALLOC_CTX *mem_ctx,
struct ldb_message *hwm_msg, *map_msg;
struct ldb_result *res = NULL;
int trans;
uid_t low, high, hwm, new_uid;
char *sid_string, *uid_string, *hwm_string;
uint32_t low, high, hwm, new_xid;
char *sid_string, *unixid_string, *hwm_string;
bool hwm_entry_exists;
TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
@@ -562,20 +336,65 @@ NTSTATUS idmap_sid_to_uid(struct idmap_context *idmap_ctx, TALLOC_CTX *mem_ctx,
}
if (res->count == 1) {
new_uid = ldb_msg_find_attr_as_uint(res->msgs[0], "uidNumber",
new_xid = ldb_msg_find_attr_as_uint(res->msgs[0], "xidNumber",
-1);
if (new_uid == (uid_t) -1) {
DEBUG(1, ("Invalid uid mapping.\n"));
if (new_xid == (uint32_t) -1) {
DEBUG(1, ("Invalid xid mapping.\n"));
status = NT_STATUS_NONE_MAPPED;
goto failed;
}
*uid = new_uid;
*unixid = talloc(mem_ctx, struct unixid);
if (*unixid == NULL) {
status = NT_STATUS_NO_MEMORY;
goto failed;
}
(*unixid)->id = new_xid;
(*unixid)->type = ID_TYPE_BOTH;
talloc_free(tmp_ctx);
return NT_STATUS_OK;
}
DEBUG(6, ("No existing mapping found, attempting to create one.\n"));
if (dom_sid_in_domain(idmap_ctx->unix_users_sid, sid)) {
uint32_t rid;
DEBUG(6, ("This is a local unix uid, just calculate that.\n"));
status = dom_sid_split_rid(tmp_ctx, sid, NULL, &rid);
if (!NT_STATUS_IS_OK(status)) goto failed;
*unixid = talloc(mem_ctx, struct unixid);
if (*unixid == NULL) {
status = NT_STATUS_NO_MEMORY;
goto failed;
}
(*unixid)->id = rid - 1;
(*unixid)->type = ID_TYPE_UID;
talloc_free(tmp_ctx);
return NT_STATUS_OK;
}
if (dom_sid_in_domain(idmap_ctx->unix_groups_sid, sid)) {
uint32_t rid;
DEBUG(6, ("This is a local unix gid, just calculate that.\n"));
status = dom_sid_split_rid(tmp_ctx, sid, NULL, &rid);
if (!NT_STATUS_IS_OK(status)) goto failed;
*unixid = talloc(mem_ctx, struct unixid);
if (*unixid == NULL) {
status = NT_STATUS_NO_MEMORY;
goto failed;
}
(*unixid)->id = rid - 1;
(*unixid)->type = ID_TYPE_GID;
talloc_free(tmp_ctx);
return NT_STATUS_OK;
}
trans = ldb_transaction_start(ldb);
if (trans != LDB_SUCCESS) {
status = NT_STATUS_NONE_MAPPED;
@@ -629,8 +448,8 @@ NTSTATUS idmap_sid_to_uid(struct idmap_context *idmap_ctx, TALLOC_CTX *mem_ctx,
goto failed;
}
hwm = ldb_msg_find_attr_as_uint(res->msgs[0], "uidNumber", -1);
if (hwm == (uid_t)-1) {
hwm = ldb_msg_find_attr_as_uint(res->msgs[0], "xidNumber", -1);
if (hwm == (uint32_t)-1) {
hwm = low;
hwm_entry_exists = false;
} else {
@@ -638,7 +457,7 @@ NTSTATUS idmap_sid_to_uid(struct idmap_context *idmap_ctx, TALLOC_CTX *mem_ctx,
}
if (hwm > high) {
DEBUG(1, ("Out of uids to allocate.\n"));
DEBUG(1, ("Out of xids to allocate.\n"));
status = NT_STATUS_NONE_MAPPED;
goto failed;
}
@@ -652,7 +471,7 @@ NTSTATUS idmap_sid_to_uid(struct idmap_context *idmap_ctx, TALLOC_CTX *mem_ctx,
hwm_msg->dn = dn;
new_uid = hwm;
new_xid = hwm;
hwm++;
hwm_string = talloc_asprintf(tmp_ctx, "%u", hwm);
@@ -667,8 +486,8 @@ NTSTATUS idmap_sid_to_uid(struct idmap_context *idmap_ctx, TALLOC_CTX *mem_ctx,
goto failed;
}
uid_string = talloc_asprintf(tmp_ctx, "%u", new_uid);
if (uid_string == NULL) {
unixid_string = talloc_asprintf(tmp_ctx, "%u", new_xid);
if (unixid_string == NULL) {
status = NT_STATUS_NO_MEMORY;
goto failed;
}
@@ -696,7 +515,7 @@ NTSTATUS idmap_sid_to_uid(struct idmap_context *idmap_ctx, TALLOC_CTX *mem_ctx,
els[0].num_values = 1;
els[0].values = &vals[0];
els[0].flags = LDB_FLAG_MOD_DELETE;
els[0].name = talloc_strdup(tmp_ctx, "uidNumber");
els[0].name = talloc_strdup(tmp_ctx, "xidNumber");
if (els[0].name == NULL) {
status = NT_STATUS_NO_MEMORY;
goto failed;
@@ -707,19 +526,19 @@ NTSTATUS idmap_sid_to_uid(struct idmap_context *idmap_ctx, TALLOC_CTX *mem_ctx,
els[1].flags = LDB_FLAG_MOD_ADD;
els[1].name = els[0].name;
vals[0].data = (uint8_t *)uid_string;
vals[0].length = strlen(uid_string);
vals[0].data = (uint8_t *)unixid_string;
vals[0].length = strlen(unixid_string);
vals[1].data = (uint8_t *)hwm_string;
vals[1].length = strlen(hwm_string);
} else {
ret = ldb_msg_add_empty(hwm_msg, "uidNumber", LDB_FLAG_MOD_ADD,
ret = ldb_msg_add_empty(hwm_msg, "xidNumber", LDB_FLAG_MOD_ADD,
NULL);
if (ret != LDB_SUCCESS) {
status = NT_STATUS_NONE_MAPPED;
goto failed;
}
ret = ldb_msg_add_string(hwm_msg, "uidNumber", hwm_string);
ret = ldb_msg_add_string(hwm_msg, "xidNumber", hwm_string);
if (ret != LDB_SUCCESS)
{
status = NT_STATUS_NONE_MAPPED;
@@ -729,7 +548,7 @@ NTSTATUS idmap_sid_to_uid(struct idmap_context *idmap_ctx, TALLOC_CTX *mem_ctx,
ret = ldb_modify(ldb, hwm_msg);
if (ret != LDB_SUCCESS) {
DEBUG(1, ("Updating the uid high water mark failed: %s\n",
DEBUG(1, ("Updating the xid high water mark failed: %s\n",
ldb_errstring(ldb)));
status = NT_STATUS_NONE_MAPPED;
goto failed;
@@ -747,7 +566,7 @@ NTSTATUS idmap_sid_to_uid(struct idmap_context *idmap_ctx, TALLOC_CTX *mem_ctx,
goto failed;
}
ret = ldb_msg_add_string(map_msg, "uidNumber", uid_string);
ret = ldb_msg_add_string(map_msg, "xidNumber", unixid_string);
if (ret != LDB_SUCCESS) {
status = NT_STATUS_NONE_MAPPED;
goto failed;
@@ -786,7 +605,14 @@ NTSTATUS idmap_sid_to_uid(struct idmap_context *idmap_ctx, TALLOC_CTX *mem_ctx,
goto failed;
}
*uid = new_uid;
*unixid = talloc(mem_ctx, struct unixid);
if (*unixid == NULL) {
status = NT_STATUS_NO_MEMORY;
goto failed;
}
(*unixid)->id = new_xid;
(*unixid)->type = ID_TYPE_BOTH;
talloc_free(tmp_ctx);
return NT_STATUS_OK;
@@ -797,276 +623,92 @@ failed:
}
/**
* Map a SID to a Unix gid.
*
* If no mapping exist, a new mapping will be created.
*
* \todo Check if SID resolve when lp_idmap_trusted_only() == true
* Convert an array of unixids to the corresponding array of SIDs
*
* \param idmap_ctx idmap context to use
* \param mem_ctx talloc context to use
* \param sid SID to map to a Unix gid
* \param gid pointer to receive the mapped gid
* \return NT_STATUS_OK on success, NT_STATUS_INVALID_SID if the sid is not from
* a trusted domain and idmap trusted only = true, NT_STATUS_NONE_MAPPED if the
* mapping failed.
* \param mem_ctx talloc context the memory for the dom_sids is allocated
* from.
* \param count length of id_mapping array.
* \param id array of id_mappings.
* \return NT_STATUS_OK on success, NT_STATUS_NONE_MAPPED if mapping is not
* possible at all, NT_STATUS_SOME_UNMAPPED if some mappings worked and some
* did not.
*/
NTSTATUS idmap_sid_to_gid(struct idmap_context *idmap_ctx, TALLOC_CTX *mem_ctx,
const struct dom_sid *sid, gid_t *gid)
{
int ret;
NTSTATUS status = NT_STATUS_NONE_MAPPED;
struct ldb_context *ldb = idmap_ctx->ldb_ctx;
struct ldb_dn *dn;
struct ldb_message *hwm_msg, *map_msg;
struct ldb_result *res = NULL;
int trans = -1;
gid_t low, high, hwm, new_gid;
char *sid_string, *gid_string, *hwm_string;
bool hwm_entry_exists;
TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
ret = ldb_search_exp_fmt(ldb, tmp_ctx, &res, NULL, LDB_SCOPE_SUBTREE,
NULL, "(&(objectClass=sidMap)(objectSid=%s))",
ldap_encode_ndr_dom_sid(tmp_ctx, sid));
if (ret != LDB_SUCCESS) {
DEBUG(1, ("Search failed: %s\n", ldb_errstring(ldb)));
status = NT_STATUS_NONE_MAPPED;
goto failed;
NTSTATUS idmap_xids_to_sids(struct idmap_context *idmap_ctx,
TALLOC_CTX *mem_ctx, int count,
struct id_mapping *id)
{
int i;
int error_count = 0;
for (i = 0; i < count; ++i) {
id[i].status = idmap_xid_to_sid(idmap_ctx, mem_ctx,
id[i].unixid, &id[i].sid);
if (NT_STATUS_EQUAL(id[i].status, NT_STATUS_RETRY)) {
id[i].status = idmap_xid_to_sid(idmap_ctx, mem_ctx,
id[i].unixid,
&id[i].sid);
}
if (!NT_STATUS_IS_OK(id[i].status)) {
DEBUG(1, ("idmapping failed for id[%d]\n", i));
error_count++;
}
}
if (res->count == 1) {
new_gid = ldb_msg_find_attr_as_uint(res->msgs[0], "gidNumber",
-1);
if (new_gid == (gid_t) -1) {
DEBUG(1, ("Invalid gid mapping.\n"));
status = NT_STATUS_NONE_MAPPED;
goto failed;
}
*gid = new_gid;
talloc_free(tmp_ctx);
if (error_count == count) {
/* Mapping did not work at all. */
return NT_STATUS_NONE_MAPPED;
} else if (error_count > 0) {
/* Some mappings worked, some did not. */
return STATUS_SOME_UNMAPPED;
} else {
return NT_STATUS_OK;
}
}
/**
* Convert an array of SIDs to the corresponding array of unixids
*
* \param idmap_ctx idmap context to use
* \param mem_ctx talloc context the memory for the unixids is allocated
* from.
* \param count length of id_mapping array.
* \param id array of id_mappings.
* \return NT_STATUS_OK on success, NT_STATUS_NONE_MAPPED if mapping is not
* possible at all, NT_STATUS_SOME_UNMAPPED if some mappings worked and some
* did not.
*/
NTSTATUS idmap_sids_to_xids(struct idmap_context *idmap_ctx,
TALLOC_CTX *mem_ctx, int count,
struct id_mapping *id)
{
int i;
int error_count = 0;
for (i = 0; i < count; ++i) {
id[i].status = idmap_sid_to_xid(idmap_ctx, mem_ctx,
id[i].sid, &id[i].unixid);
if (NT_STATUS_EQUAL(id[i].status, NT_STATUS_RETRY)) {
id[i].status = idmap_sid_to_xid(idmap_ctx, mem_ctx,
id[i].sid,
&id[i].unixid);
}
if (!NT_STATUS_IS_OK(id[i].status)) {
DEBUG(1, ("idmapping failed for id[%d]\n", i));
error_count++;
}
}
if (error_count == count) {
/* Mapping did not work at all. */
return NT_STATUS_NONE_MAPPED;
} else if (error_count > 0) {
/* Some mappings worked, some did not. */
return STATUS_SOME_UNMAPPED;
} else {
return NT_STATUS_OK;
}
DEBUG(6, ("No existing mapping found, attempting to create one.\n"));
trans = ldb_transaction_start(ldb);
if (trans != LDB_SUCCESS) {
status = NT_STATUS_NONE_MAPPED;
goto failed;
}
/* Redo the search to make sure noone changed the mapping while we
* weren't looking */
ret = ldb_search_exp_fmt(ldb, tmp_ctx, &res, NULL, LDB_SCOPE_SUBTREE,
NULL, "(&(objectClass=sidMap)(objectSid=%s))",
ldap_encode_ndr_dom_sid(tmp_ctx, sid));
if (ret != LDB_SUCCESS) {
DEBUG(1, ("Search failed: %s\n", ldb_errstring(ldb)));
status = NT_STATUS_NONE_MAPPED;
goto failed;
}
if (res->count > 0) {
DEBUG(1, ("Database changed while trying to add a sidmap.\n"));
status = NT_STATUS_RETRY;
goto failed;
}
/*FIXME: if lp_idmap_trusted_only() == true, check if SID can be
* resolved here. */
ret = idmap_get_bounds(idmap_ctx, &low, &high);
if (ret != LDB_SUCCESS) {
status = NT_STATUS_NONE_MAPPED;
goto failed;
}
dn = ldb_dn_new(tmp_ctx, ldb, "CN=CONFIG");
if (dn == NULL) {
status = NT_STATUS_NO_MEMORY;
goto failed;
}
ret = ldb_search(ldb, dn, LDB_SCOPE_BASE, NULL, NULL, &res);
if (ret != LDB_SUCCESS) {
DEBUG(1, ("Search failed: %s\n", ldb_errstring(ldb)));
status = NT_STATUS_NONE_MAPPED;
goto failed;
}
talloc_steal(tmp_ctx, res);
if (res->count != 1) {
DEBUG(1, ("No CN=CONFIG record, idmap database is broken.\n"));
status = NT_STATUS_NONE_MAPPED;
goto failed;
}
hwm = ldb_msg_find_attr_as_uint(res->msgs[0], "gidNumber", -1);
if (hwm == (gid_t)-1) {
hwm = low;
hwm_entry_exists = false;
} else {
hwm_entry_exists = true;
}
if (hwm > high) {
DEBUG(1, ("Out of gids to allocate.\n"));
status = NT_STATUS_NONE_MAPPED;
goto failed;
}
hwm_msg = ldb_msg_new(tmp_ctx);
if (hwm_msg == NULL) {
DEBUG(1, ("Out of memory when creating ldb_message\n"));
status = NT_STATUS_NO_MEMORY;
goto failed;
}
hwm_msg->dn = dn;
new_gid = hwm;
hwm++;
hwm_string = talloc_asprintf(tmp_ctx, "%u", hwm);
if (hwm_string == NULL) {
status = NT_STATUS_NO_MEMORY;
goto failed;
}
sid_string = dom_sid_string(tmp_ctx, sid);
if (sid_string == NULL) {
status = NT_STATUS_NO_MEMORY;
goto failed;
}
gid_string = talloc_asprintf(tmp_ctx, "%u", new_gid);
if (gid_string == NULL) {
status = NT_STATUS_NO_MEMORY;
goto failed;
}
if (hwm_entry_exists) {
struct ldb_message_element *els;
struct ldb_val *vals;
/* We're modifying the entry, not just adding a new one. */
els = talloc_array(tmp_ctx, struct ldb_message_element, 2);
if (els == NULL) {
status = NT_STATUS_NO_MEMORY;
goto failed;
}
vals = talloc_array(tmp_ctx, struct ldb_val, 2);
if (els == NULL) {
status = NT_STATUS_NO_MEMORY;
goto failed;
}
hwm_msg->num_elements = 2;
hwm_msg->elements = els;
els[0].num_values = 1;
els[0].values = &vals[0];
els[0].flags = LDB_FLAG_MOD_DELETE;
els[0].name = talloc_strdup(tmp_ctx, "gidNumber");
if (els[0].name == NULL) {
status = NT_STATUS_NO_MEMORY;
goto failed;
}
els[1].num_values = 1;
els[1].values = &vals[1];
els[1].flags = LDB_FLAG_MOD_ADD;
els[1].name = els[0].name;
vals[0].data = (uint8_t *)gid_string;
vals[0].length = strlen(gid_string);
vals[1].data = (uint8_t *)hwm_string;
vals[1].length = strlen(hwm_string);
} else {
ret = ldb_msg_add_empty(hwm_msg, "gidNumber", LDB_FLAG_MOD_ADD,
NULL);
if (ret != LDB_SUCCESS) {
status = NT_STATUS_NONE_MAPPED;
goto failed;
}
ret = ldb_msg_add_string(hwm_msg, "gidNumber", hwm_string);
if (ret != LDB_SUCCESS)
{
status = NT_STATUS_NONE_MAPPED;
goto failed;
}
}
ret = ldb_modify(ldb, hwm_msg);
if (ret != LDB_SUCCESS) {
DEBUG(1, ("Updating the gid high water mark failed: %s\n",
ldb_errstring(ldb)));
status = NT_STATUS_NONE_MAPPED;
goto failed;
}
map_msg = ldb_msg_new(tmp_ctx);
if (map_msg == NULL) {
status = NT_STATUS_NO_MEMORY;
goto failed;
}
map_msg->dn = ldb_dn_new_fmt(tmp_ctx, ldb, "CN=%s", sid_string);
if (map_msg->dn == NULL) {
status = NT_STATUS_NO_MEMORY;
goto failed;
}
ret = ldb_msg_add_string(map_msg, "gidNumber", gid_string);
if (ret != LDB_SUCCESS) {
status = NT_STATUS_NONE_MAPPED;
goto failed;
}
ret = idmap_msg_add_dom_sid(idmap_ctx, tmp_ctx, map_msg, "objectSid",
sid);
if (ret != LDB_SUCCESS) {
status = NT_STATUS_NONE_MAPPED;
goto failed;
}
ret = ldb_msg_add_string(map_msg, "objectClass", "sidMap");
if (ret != LDB_SUCCESS) {
status = NT_STATUS_NONE_MAPPED;
goto failed;
}
ret = ldb_msg_add_string(map_msg, "cn", sid_string);
if (ret != LDB_SUCCESS) {
status = NT_STATUS_NONE_MAPPED;
goto failed;
}
ret = ldb_add(ldb, map_msg);
if (ret != LDB_SUCCESS) {
DEBUG(1, ("Adding a sidmap failed: %s\n", ldb_errstring(ldb)));
status = NT_STATUS_NONE_MAPPED;
goto failed;
}
trans = ldb_transaction_commit(ldb);
if (trans != LDB_SUCCESS) {
DEBUG(1, ("Transaction failed: %s\n", ldb_errstring(ldb)));
status = NT_STATUS_NONE_MAPPED;
goto failed;
}
*gid = new_gid;
talloc_free(tmp_ctx);
return NT_STATUS_OK;
failed:
if (trans == LDB_SUCCESS) ldb_transaction_cancel(ldb);
talloc_free(tmp_ctx);
return status;
}

20
source/winbind/idmap.h
View File

@@ -25,6 +25,26 @@
struct idmap_context {
struct loadparm_context *lp_ctx;
struct ldb_context *ldb_ctx;
struct dom_sid *unix_groups_sid;
struct dom_sid *unix_users_sid;
};
enum id_type {
ID_TYPE_NOT_SPECIFIED = 0,
ID_TYPE_UID,
ID_TYPE_GID,
ID_TYPE_BOTH
};
struct unixid {
uint32_t id;
enum id_type type;
};
struct id_mapping {
struct unixid *unixid;
struct dom_sid *sid;
NTSTATUS status;
};
#include "winbind/idmap_proto.h"

49
source/winbind/wb_gid2sid.c
View File

@@ -3,7 +3,7 @@
Command backend for wbinfo -G
Copyright (C) Kai Blin 2007
Copyright (C) 2007-2008 Kai Blin
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
@@ -33,37 +33,62 @@ struct gid2sid_state {
struct dom_sid *sid;
};
static void gid2sid_recv_sid(struct composite_context *ctx);
struct composite_context *wb_gid2sid_send(TALLOC_CTX *mem_ctx,
struct wbsrv_service *service, gid_t gid)
{
struct composite_context *result;
struct composite_context *result, *ctx;
struct gid2sid_state *state;
struct unixid *unixid;
struct id_mapping *ids;
DEBUG(5, ("wb_gid2sid_send called\n"));
result = composite_create(mem_ctx, service->task->event_ctx);
if (!result) return NULL;
state = talloc(mem_ctx, struct gid2sid_state);
state = talloc(result, struct gid2sid_state);
if (composite_nomem(state, result)) return result;
state->ctx = result;
result->private_data = state;
state->service = service;
state->ctx->status = idmap_gid_to_sid(service->idmap_ctx, mem_ctx, gid,
&state->sid);
if (NT_STATUS_EQUAL(state->ctx->status, NT_STATUS_RETRY)) {
state->ctx->status = idmap_gid_to_sid(service->idmap_ctx,
mem_ctx, gid,
&state->sid);
}
if (!composite_is_ok(state->ctx)) return result;
unixid = talloc(result, struct unixid);
if (composite_nomem(unixid, result)) return result;
unixid->id = gid;
unixid->type = ID_TYPE_GID;
composite_done(state->ctx);
ids = talloc(result, struct id_mapping);
if (composite_nomem(ids, result)) return result;
ids->unixid = unixid;
ids->sid = NULL;
ctx = wb_xids2sids_send(result, service, 1, ids);
if (composite_nomem(ctx, result)) return result;
composite_continue(result, ctx, gid2sid_recv_sid, state);
return result;
}
static void gid2sid_recv_sid(struct composite_context *ctx)
{
struct gid2sid_state *state = talloc_get_type(ctx->async.private_data,
struct gid2sid_state);
struct id_mapping *ids = NULL;
state->ctx->status = wb_xids2sids_recv(ctx, &ids);
if (!composite_is_ok(state->ctx)) return;
if (!NT_STATUS_IS_OK(ids->status)) {
composite_error(state->ctx, ids->status);
return;
}
state->sid = ids->sid;
composite_done(state->ctx);
}
NTSTATUS wb_gid2sid_recv(struct composite_context *ctx, TALLOC_CTX *mem_ctx,
struct dom_sid **sid)
{

48
source/winbind/wb_sid2gid.c
View File

@@ -3,7 +3,7 @@
Map a SID to a gid
Copyright (C) Kai Blin 2007
Copyright (C) 2007-2008 Kai Blin
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
@@ -33,11 +33,14 @@ struct sid2gid_state {
gid_t gid;
};
static void sid2gid_recv_gid(struct composite_context *ctx);
struct composite_context *wb_sid2gid_send(TALLOC_CTX *mem_ctx,
struct wbsrv_service *service, const struct dom_sid *sid)
{
struct composite_context *result;
struct composite_context *result, *ctx;
struct sid2gid_state *state;
struct id_mapping *ids;
DEBUG(5, ("wb_sid2gid_send called\n"));
@@ -51,18 +54,43 @@ struct composite_context *wb_sid2gid_send(TALLOC_CTX *mem_ctx,
result->private_data = state;
state->service = service;
state->ctx->status = idmap_sid_to_gid(service->idmap_ctx, state, sid,
&state->gid);
if (NT_STATUS_EQUAL(state->ctx->status, NT_STATUS_RETRY)) {
state->ctx->status = idmap_sid_to_gid(service->idmap_ctx, state,
sid, &state->gid);
}
if (!composite_is_ok(state->ctx)) return result;
ids = talloc(result, struct id_mapping);
if (composite_nomem(ids, result)) return result;
composite_done(state->ctx);
ids->sid = dom_sid_dup(result, sid);
if (composite_nomem(ids->sid, result)) return result;
ctx = wb_sids2xids_send(result, service, 1, ids);
if (composite_nomem(ctx, result)) return result;
composite_continue(result, ctx, sid2gid_recv_gid, state);
return result;
}
static void sid2gid_recv_gid(struct composite_context *ctx)
{
struct sid2gid_state *state = talloc_get_type(ctx->async.private_data,
struct sid2gid_state);
struct id_mapping *ids = NULL;
state->ctx->status = wb_sids2xids_recv(ctx, &ids);
if (!composite_is_ok(state->ctx)) return;
if (!NT_STATUS_IS_OK(ids->status)) {
composite_error(state->ctx, ids->status);
return;
}
if (ids->unixid->type == ID_TYPE_BOTH ||
ids->unixid->type == ID_TYPE_GID) {
state->gid = ids->unixid->id;
composite_done(state->ctx);
} else {
composite_error(state->ctx, NT_STATUS_INVALID_SID);
}
}
NTSTATUS wb_sid2gid_recv(struct composite_context *ctx, gid_t *gid)
{
NTSTATUS status = composite_wait(ctx);

50
source/winbind/wb_sid2uid.c
View File

@@ -3,7 +3,7 @@
Map a SID to a uid
Copyright (C) Kai Blin 2007-2008
Copyright (C) 2007-2008 Kai Blin
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
@@ -33,11 +33,14 @@ struct sid2uid_state {
uid_t uid;
};
static void sid2uid_recv_uid(struct composite_context *ctx);
struct composite_context *wb_sid2uid_send(TALLOC_CTX *mem_ctx,
struct wbsrv_service *service, const struct dom_sid *sid)
{
struct composite_context *result;
struct composite_context *result, *ctx;
struct sid2uid_state *state;
struct id_mapping *ids;
DEBUG(5, ("wb_sid2uid_send called\n"));
@@ -45,24 +48,49 @@ struct composite_context *wb_sid2uid_send(TALLOC_CTX *mem_ctx,
if (!result) return NULL;
state = talloc(result, struct sid2uid_state);
if(composite_nomem(state, result)) return result;
if (composite_nomem(state, result)) return result;
state->ctx = result;
result->private_data = state;
state->service = service;
state->ctx->status = idmap_sid_to_uid(service->idmap_ctx, state, sid,
&state->uid);
if (NT_STATUS_EQUAL(state->ctx->status, NT_STATUS_RETRY)) {
state->ctx->status = idmap_sid_to_uid(service->idmap_ctx, state,
sid, &state->uid);
}
if (!composite_is_ok(state->ctx)) return result;
ids = talloc(result, struct id_mapping);
if (composite_nomem(ids, result)) return result;
composite_done(state->ctx);
ids->sid = dom_sid_dup(result, sid);
if (composite_nomem(ids->sid, result)) return result;
ctx = wb_sids2xids_send(result, service, 1, ids);
if (composite_nomem(ctx, result)) return result;
composite_continue(result, ctx, sid2uid_recv_uid, state);
return result;
}
static void sid2uid_recv_uid(struct composite_context *ctx)
{
struct sid2uid_state *state = talloc_get_type(ctx->async.private_data,
struct sid2uid_state);
struct id_mapping *ids = NULL;
state->ctx->status = wb_sids2xids_recv(ctx, &ids);
if (!composite_is_ok(state->ctx)) return;
if (!NT_STATUS_IS_OK(ids->status)) {
composite_error(state->ctx, ids->status);
return;
}
if (ids->unixid->type == ID_TYPE_BOTH ||
ids->unixid->type == ID_TYPE_UID) {
state->uid = ids->unixid->id;
composite_done(state->ctx);
} else {
composite_error(state->ctx, NT_STATUS_INVALID_SID);
}
}
NTSTATUS wb_sid2uid_recv(struct composite_context *ctx, uid_t *uid)
{
NTSTATUS status = composite_wait(ctx);

82
source/winbind/wb_sids2xids.c Normal file
View File

@@ -0,0 +1,82 @@
/*
Unix SMB/CIFS implementation.
Map SIDs to unixids.
Copyright (C) 2008 Kai Blin
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 "libcli/composite/composite.h"
#include "winbind/wb_server.h"
#include "smbd/service_task.h"
#include "winbind/wb_helper.h"
#include "libcli/security/proto.h"
#include "winbind/idmap.h"
struct sids2xids_state {
struct composite_context *ctx;
struct wbsrv_service *service;
struct id_mapping *ids;
int count;
};
struct composite_context *wb_sids2xids_send(TALLOC_CTX *mem_ctx,
struct wbsrv_service *service,
int count, struct id_mapping *ids)
{
struct composite_context *result;
struct sids2xids_state *state;
DEBUG(5, ("wb_sids2xids_send called\n"));
result = composite_create(mem_ctx, service->task->event_ctx);
if (!result) return NULL;
state = talloc(result, struct sids2xids_state);
if (composite_nomem(state, result)) return result;
state->ctx = result;
result->private_data = state;
state->service = service;
state->count = count;
state->ids = ids;
state->ctx->status = idmap_sids_to_xids(service->idmap_ctx, mem_ctx,
count, state->ids);
if (!composite_is_ok(state->ctx)) return result;
composite_done(state->ctx);
return result;
}
NTSTATUS wb_sids2xids_recv(struct composite_context *ctx,
struct id_mapping **ids)
{
NTSTATUS status = composite_wait(ctx);
DEBUG(5, ("wb_sids2xids_recv called\n"));
if (NT_STATUS_IS_OK(status)) {
struct sids2xids_state *state =
talloc_get_type(ctx->private_data,
struct sids2xids_state);
*ids = state->ids;
}
talloc_free(ctx);
return status;
}

49
source/winbind/wb_uid2sid.c
View File

@@ -3,7 +3,7 @@
Command backend for wbinfo -U
Copyright (C) Kai Blin 2007-2008
Copyright (C) 2007-2008 Kai Blin
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
@@ -33,35 +33,62 @@ struct uid2sid_state {
struct dom_sid *sid;
};
static void uid2sid_recv_sid(struct composite_context *ctx);
struct composite_context *wb_uid2sid_send(TALLOC_CTX *mem_ctx,
struct wbsrv_service *service, uid_t uid)
{
struct composite_context *result;
struct composite_context *result, *ctx;
struct uid2sid_state *state;
struct unixid *unixid;
struct id_mapping *ids;
DEBUG(5, ("wb_uid2sid_send called\n"));
result = composite_create(mem_ctx, service->task->event_ctx);
if (!result) return NULL;
state = talloc(mem_ctx, struct uid2sid_state);
state = talloc(result, struct uid2sid_state);
if (composite_nomem(state, result)) return result;
state->ctx = result;
result->private_data = state;
state->service = service;
state->ctx->status = idmap_uid_to_sid(service->idmap_ctx, mem_ctx, uid,
&state->sid);
if (NT_STATUS_EQUAL(state->ctx->status, NT_STATUS_RETRY)) {
state->ctx->status = idmap_uid_to_sid(service->idmap_ctx,
mem_ctx, uid,
&state->sid);
unixid = talloc(result, struct unixid);
if (composite_nomem(unixid, result)) return result;
unixid->id = uid;
unixid->type = ID_TYPE_UID;
ids = talloc(result, struct id_mapping);
if (composite_nomem(ids, result)) return result;
ids->unixid = unixid;
ids->sid = NULL;
ctx = wb_xids2sids_send(result, service, 1, ids);
if (composite_nomem(ctx, result)) return result;
composite_continue(result, ctx, uid2sid_recv_sid, state);
return result;
}
static void uid2sid_recv_sid(struct composite_context *ctx)
{
struct uid2sid_state *state = talloc_get_type(ctx->async.private_data,
struct uid2sid_state);
struct id_mapping *ids = NULL;
state->ctx->status = wb_xids2sids_recv(ctx, &ids);
if (!composite_is_ok(state->ctx)) return;
if (!NT_STATUS_IS_OK(ids->status)) {
composite_error(state->ctx, ids->status);
return;
}
if (!composite_is_ok(state->ctx)) return result;
state->sid = ids->sid;
composite_done(state->ctx);
return result;
}
NTSTATUS wb_uid2sid_recv(struct composite_context *ctx, TALLOC_CTX *mem_ctx,

82
source/winbind/wb_xids2sids.c Normal file
View File

@@ -0,0 +1,82 @@
/*
Unix SMB/CIFS implementation.
Convet an unixid struct to a SID
Copyright (C) 2008 Kai Blin
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 "libcli/composite/composite.h"
#include "winbind/wb_server.h"
#include "smbd/service_task.h"
#include "winbind/wb_helper.h"
#include "libcli/security/proto.h"
#include "winbind/idmap.h"
struct xids2sids_state {
struct composite_context *ctx;
struct wbsrv_service *service;
struct id_mapping *ids;
int count;
};
struct composite_context *wb_xids2sids_send(TALLOC_CTX *mem_ctx,
struct wbsrv_service *service,
int count, struct id_mapping *ids)
{
struct composite_context *result;
struct xids2sids_state *state;
DEBUG(0, ("wb_xids2sids_send called\n"));
result = composite_create(mem_ctx, service->task->event_ctx);
if (!result) return NULL;
state = talloc(mem_ctx, struct xids2sids_state);
if (composite_nomem(state, result)) return result;
state->ctx = result;
result->private_data = state;
state->service = service;
state->count = count;
state->ids = ids;
state->ctx->status = idmap_xids_to_sids(service->idmap_ctx, mem_ctx,
count, state->ids);
if (!composite_is_ok(state->ctx)) return result;
composite_done(state->ctx);
return result;
}
NTSTATUS wb_xids2sids_recv(struct composite_context *ctx,
struct id_mapping **ids)
{
NTSTATUS status = composite_wait(ctx);
DEBUG(0, ("wb_xids2sids_recv called.\n"));
if (NT_STATUS_IS_OK(status)) {
struct xids2sids_state *state =
talloc_get_type(ctx->private_data,
struct xids2sids_state);
*ids = state->ids;
}
talloc_free(ctx);
return status;
}