source4/param/secrets_proto.h
source4/param/share_proto.h
source4/passdb/proto.h
-source4/pidl/blib
-source4/pidl/cover_db
-source4/pidl/Makefile
-source4/pidl/pm_to_blib
+pidl/blib
+pidl/cover_db
+pidl/Makefile
+pidl/pm_to_blib
source4/rpc_server/common/proto.h
source4/rpc_server/dcerpc_server_proto.h
source4/rpc_server/lsa/proto.h
-##
-## Coding conventions in the Samba 3 tree
-##
+Coding conventions in the Samba tree
+------------------------------------
+
+.. contents::
===========
Quick Start
described here are hopefully easy enough to follow as they are very
common and supported by tools and editors.
-The basic style, also mentioned in the SAMBA_4_0/prog_guide.txt is the
-Linux kernel coding style (See Documentation/CodingStyle in the kernel
-source tree). The closely matches what most Samba developers use already
-anyways.
+The basic style, also mentioned in prog_guide4.txt, is the Linux kernel coding
+style (See Documentation/CodingStyle in the kernel source tree). This closely
+matches what most Samba developers use already anyways.
But to save you the trouble of reading the Linux kernel style guide, here
are the highlights.
-
* Maximum Line Width is 80 Characters
The reason is not for people with low-res screens but rather sticking
to 80 columns prevents you from easily nesting more than one level of
--
(Thanks to SATOH Fumiyasu <fumiyas@osstech.jp> for these hints):
-For the basic vi editor including with all variants of *nix, add the
+For the basic vi editor including with all variants of \*nix, add the
following to $HOME/.exrc:
set tabstop=8
set shiftwidth=8
For Vim, the following settings in $HOME/.vimrc will also deal with
-displaying trailing whitespace:
+displaying trailing whitespace::
if has("syntax") && (&t_Co > 2 || has("gui_running"))
syntax on
Comments
--------
-Comments should always use the standard C syntax. I.e. /* ... */. C++
+Comments should always use the standard C syntax. C++
style comments are not currently allowed.
another language keyword such as else or the closing while in a do..while
loop.
-Good examples:
+Good examples::
if (x == 1) {
printf("good\n");
printf("also good\n");
} while (1);
-Bad examples:
+Bad examples::
while (1)
{
as the single exit point from a function. But in no Samba world what so ever
is a goto outside of a function or block of code a good idea.
-Good Examples:
-
-int function foo(int y)
-{
- int *z = NULL;
- int ret = 0;
+Good Examples::
- if ( y < 10 ) {
- z = malloc(sizeof(int)*y);
- if (!z) {
- ret = 1;
- goto done;
+ int function foo(int y)
+ {
+ int *z = NULL;
+ int ret = 0;
+
+ if ( y < 10 ) {
+ z = malloc(sizeof(int)*y);
+ if (!z) {
+ ret = 1;
+ goto done;
+ }
}
- }
- print("Allocated %d elements.\n", y);
+ print("Allocated %d elements.\n", y);
- done:
- if (z)
- free(z);
+ done:
+ if (z)
+ free(z);
- return ret;
-}
+ return ret;
+ }
Checking Pointer Values
When invoking functions that return pointer values, either of the following
are acceptable. Use you best judgement and choose the more readable option.
-Remember that many other people will review it.
+Remember that many other people will review it.::
if ((x = malloc(sizeof(short)*10)) == NULL ) {
fprintf(stderr, "Unable to alloc memory!\n");
}
-or
+or::
x = malloc(sizeof(short)*10);
if (!x) {
--- /dev/null
+<?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="idmap_adex.8">
+
+<refmeta>
+ <refentrytitle>idmap_adex</refentrytitle>
+ <manvolnum>8</manvolnum>
+ <refmiscinfo class="source">Samba</refmiscinfo>
+ <refmiscinfo class="manual">System Administration tools</refmiscinfo>
+ <refmiscinfo class="version">3.2</refmiscinfo>
+</refmeta>
+
+
+<refnamediv>
+ <refname>idmap_adex</refname>
+ <refpurpose>Samba's idmap_adex Backend for Winbind</refpurpose>
+</refnamediv>
+
+<refsynopsisdiv>
+ <title>DESCRIPTION</title>
+ <para>
+ The idmap_adex plugin provides a way for Winbind to read
+ id mappings from an AD server that uses RFC2307 schema
+ extensions. This module implements both the idmap and nss_info
+ APIs and supports domain trustes as well as two-way cross
+ forest trusts. It is a read-only plugin requiring that the
+ administrator provide mappings in advance by adding the
+ POSIX attribute information to the users and groups objects
+ in AD. The most common means of doing this is using "Identity
+ Services for Unix" support on Windows 2003 R2 and later.
+ </para>
+
+ <para>
+ Note that you must add the uidNumber, gidNumber, and uid
+ attributes to the partial attribute set of the forest global
+ catalog servers. This can be done using the Active Directory Schema
+ Management MMC plugin (schmmgmt.dll).
+ </para>
+</refsynopsisdiv>
+
+<refsynopsisdiv>
+ <title>NSS_INFO</title>
+ <para>
+ The nss_info plugin supports reading the unixHomeDirectory,
+ gidNumber, loginShell, and uidNumber attributes from the user
+ object and the gidNumber attribute from the group object to
+ fill in information required by the libc getpwnam() and
+ getgrnam() family of functions. Group membership is filled in
+ according to the Windows group membership and not the
+ msSFU30PosixMember attribute.
+ </para>
+
+ <para>
+ Username aliases are implement by setting the uid attribute
+ on the user object. While group name aliases are implemented
+ by reading the displayname attribute from the group object.
+ </para>
+</refsynopsisdiv>
+
+<refsect1>
+ <title>EXAMPLES</title>
+ <para>
+ The following example shows how to retrieve idmappings and NSS data
+ from our principal and trusted AD domains.
+ </para>
+
+ <programlisting>
+ [global]
+ idmap backend = adex
+ idmap uid = 1000-4000000000
+ idmap gid = 1000-4000000000
+
+ winbind nss info = adex
+ winbind normalize names = yes
+ </programlisting>
+</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>
--- /dev/null
+<?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="idmap_hash.8">
+
+<refmeta>
+ <refentrytitle>idmap_hash</refentrytitle>
+ <manvolnum>8</manvolnum>
+ <refmiscinfo class="source">Samba</refmiscinfo>
+ <refmiscinfo class="manual">System Administration tools</refmiscinfo>
+ <refmiscinfo class="version">3.2</refmiscinfo>
+</refmeta>
+
+
+<refnamediv>
+ <refname>idmap_hash</refname>
+ <refpurpose>Samba's idmap_hash Backend for Winbind</refpurpose>
+</refnamediv>
+
+<refsynopsisdiv>
+ <title>DESCRIPTION</title>
+ <para>The idmap_hash plugin implements a hashing algorithm used
+ map SIDs for domain users and groups to a 31-bit uid and gid.
+ This plugin also implements the nss_info API and can be used
+ to support a local name mapping files if enabled via the
+ "winbind normlaize names" and "winbind nss info"
+ parameters in smb.conf.
+ </para>
+</refsynopsisdiv>
+
+<refsect1>
+ <title>IDMAP OPTIONS</title>
+
+ <variablelist>
+ <varlistentry>
+ <term>name_map</term>
+ <listitem><para>
+ Specifies the absolute path to the name mapping
+ file used by the nss_info API. Entries in the file
+ are of the form "<replaceable>unix name</replaceable>
+ = <replaceable>qualified domain name</replaceable>"e;.
+ Mapping of both user and group names is supported.
+ </para></listitem>
+ </varlistentry>
+ </variablelist>
+</refsect1>
+
+<refsect1>
+ <title>EXAMPLES</title>
+ <para>The following example utilizes the idmap_hash plugin for
+ the idmap and nss_info information.
+ </para>
+
+ <programlisting>
+ [global]
+ idmap backend = hash
+ idmap uid = 1000-4000000000
+ idmap gid = 1000-4000000000
+
+ winbind nss info = hash
+ winbind normalize names = yes
+ idmap_hash:name_map = /etc/samba/name_map.cfg
+ </programlisting>
+</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>
</para></listitem>
</varlistentry>
+ <varlistentry>
+ <term>mkhomedir</term>
+ <listitem><para>
+ Create homedirectory for a user on-the-fly, option is valid in
+ PAM session block.
+ </para></listitem>
+ </varlistentry>
+
</variablelist>
--- /dev/null
+<?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_smb_traffic_analyzer.8">
+
+<refmeta>
+ <refentrytitle>smb_traffic_analyzer</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_smb_traffic_analyzer</refname>
+ <refpurpose>log Samba VFS read and write operations through a socket
+ to a helper application</refpurpose>
+</refnamediv>
+
+<refsynopsisdiv>
+ <cmdsynopsis>
+ <command>vfs objects = smb_traffic_analyzer</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_smb_traffic_analyzer</command> VFS module logs
+ client write and read operations on a Samba server and sends this data
+ over a socket to a helper program, which feeds a SQL database. More
+ information on the helper programs can be obtained from the
+ homepage of the project at:
+ http://holger123.wordpress.com/smb-traffic-analyzer/
+ </para>
+ <para><command>vfs_smb_traffic_analyzer</command> currently is aware
+ of the following VFS operations:</para>
+
+ <simplelist>
+ <member>write</member>
+ <member>pwrite</member>
+ <member>read</member>
+ <member>pread</member>
+ </simplelist>
+
+ <para><command>vfs_smb_traffic_analyzer</command> sends the following data
+ in a fixed format seperated by a comma through either an internet or a
+ unix domain socket:</para>
+ <programlisting>
+ BYTES|USER|DOMAIN|READ/WRITE|SHARE|FILENAME|TIMESTAMP
+ </programlisting>
+
+ <para>Description of the records:
+
+ <itemizedlist>
+ <listitem><para><command>BYTES</command> - the length in bytes of the VFS operation</para></listitem>
+ <listitem><para><command>USER</command> - the user who initiated the operation</para></listitem>
+ <listitem><para><command>DOMAIN</command> - the domain of the user</para></listitem>
+ <listitem><para><command>READ/WRITE</command> - either "W" for a write operation or "R" for read</para></listitem>
+ <listitem><para><command>SHARE</command> - the name of the share on which the VFS operation occured</para></listitem>
+ <listitem><para><command>FILENAME</command> - the name of the file that was used by the VFS operation</para></listitem>
+ <listitem><para><command>TIMESTAMP</command> - a timestamp, formatted as "yyyy-mm-dd hh-mm-ss.ms" indicating when the VFS operation occured</para></listitem>
+ </itemizedlist>
+
+ </para>
+
+ <para>This module is stackable.</para>
+
+</refsect1>
+
+
+<refsect1>
+ <title>OPTIONS</title>
+
+ <variablelist>
+
+ <varlistentry>
+ <term>smb_traffic_analyzer:mode = STRING</term>
+ <listitem>
+ <para>If STRING matches to "unix_domain_socket", the module will
+ use a unix domain socket located at /var/tmp/stadsocket, if
+ STRING contains an different string or is not defined, the module will
+ use an internet domain socket for data transfer.</para>
+
+ </listitem>
+ </varlistentry>
+
+
+ <varlistentry>
+ <term>smb_traffic_analyzer:host = STRING</term>
+ <listitem>
+ <para>The module will send the data to the system named with
+ the hostname STRING.</para>
+
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>smb_traffic_analyzer:port = STRING</term>
+ <listitem>
+ <para>The module will send the data using the TCP port given
+ in STRING
+ </para>
+
+ </listitem>
+ </varlistentry>
+
+
+ </variablelist>
+</refsect1>
+
+<refsect1>
+ <title>EXAMPLES</title>
+
+ <para>The module running on share "example_share", using a unix domain socket</para>
+ <programlisting>
+ <smbconfsection name="[example_share]"/>
+ <smbconfoption name="path">/data/example</smbconfoption>
+ <smbconfoption name="vfs objects">smb_traffic_analyzer</smbconfoption>
+ <smbconfoption name="smb_traffic_analyzer:mode">unix_domain_socket</smbconfoption>
+ </programlisting>
+
+ <para>The module running on share "example_share", using an internet domain socket,
+ connecting to host "examplehost" on port 3491.</para>
+ <programlisting>
+ <smbconfsection name="[example_share]"/>
+ <smbconfoption name="path">/data/example</smbconfoption>
+ <smbconfoption name="vfs objects">smb_traffic_analyzer</smbconfoption>
+ <smbconfoption name="smb_traffic_analyzer:host">examplehost</smbconfoption>
+ <smbconfoption name="smb_traffic_analyzer:port">3490</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>
+
+ <para>The original version of the VFS module and the
+ helper tools were created by Holger Hetterich.</para>
+</refsect1>
+
+</refentry>
--- /dev/null
+<samba:parameter name="cups connection timeout"
+ context="G"
+ type="integer"
+ print="1"
+ xmlns:samba="http://www.samba.org/samba/DTD/samba-doc">
+<description>
+ <para>
+ This parameter is only applicable if <smbconfoption name="printing"/> is set to <constant>cups</constant>.
+ </para>
+
+ <para>
+ If set, this option specifies the number of seconds that smbd will wait
+ whilst trying to contact to the CUPS server. The connection will fail
+ if it takes longer than this number of seconds.
+ </para>
+</description>
+
+<value type="default">30</value>
+<value type="example">60</value>
+</samba:parameter>
xmlns:samba="http://www.samba.org/samba/DTD/samba-doc">
<description>
<para>This parameter controls whether winbindd will replace
- whitespace in user and group names with an underscore (_) character.
- For example, whether the name "Space Kadet" should be
- replaced with the string "space_kadet".
- Frequently Unix shell scripts will have difficulty with usernames
- contains whitespace due to the default field separator in the shell.
- Do not enable this option if the underscore character is used in
- account names within your domain
- </para>
+ whitespace in user and group names with an underscore (_) character.
+ For example, whether the name "Space Kadet" should be
+ replaced with the string "space_kadet".
+ Frequently Unix shell scripts will have difficulty with usernames
+ contains whitespace due to the default field separator in the shell.
+ If your domain possesses names containing the underscore character,
+ this option may cause problems unless the name aliasing feature
+ is supported by your nss_info plugin.
+ </para>
+
+ <para>This feature also enables the name aliasing API which can
+ be used to make domain user and group names to a non-qlaified
+ version. Please refer to the manpage for the configured
+ idmap and nss_info plugin for the specifics on how to configure
+ name aliasing for a specific configuration. Name aliasing takes
+ precendence (and is mutually exclusive) over the whitespace
+ replacement mechanism discussed previsouly.
+ </para>
+
</description>
<value type="default">no</value>
}
static NTSTATUS skel_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp,
- uint32 security_info_sent, SEC_DESC *psd)
+ uint32 security_info_sent, const SEC_DESC *psd)
{
errno = ENOSYS;
return NT_STATUS_NOT_IMPLEMENTED;
}
static NTSTATUS skel_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp,
- uint32 security_info_sent, SEC_DESC *psd)
+ uint32 security_info_sent, const SEC_DESC *psd)
{
return SMB_VFS_NEXT_FSET_NT_ACL(handle, fsp, security_info_sent, psd);
}
# omit pam conversations
;silent = no
+
+# create homedirectory on the fly
+;mkhomedir = no
*/
#include "includes.h"
-#include "lib/crypto/crypto.h"
+#include "../lib/crypto/arcfour.h"
/* initialise the arcfour sbox with key */
_PUBLIC_ void arcfour_init(struct arcfour_state *state, const DATA_BLOB *key)
--- /dev/null
+#ifndef ARCFOUR_HEADER_H
+#define ARCFOUR_HEADER_H
+
+struct arcfour_state {
+ uint8_t sbox[256];
+ uint8_t index_i;
+ uint8_t index_j;
+};
+
+void arcfour_init(struct arcfour_state *state, const DATA_BLOB *key);
+void arcfour_crypt_sbox(struct arcfour_state *state, uint8_t *data, int len);
+void arcfour_crypt_blob(uint8_t *data, int len, const DATA_BLOB *key);
+void arcfour_crypt(uint8_t *data, const uint8_t keystr[16], int len);
+
+#endif /* ARCFOUR_HEADER_H */
/*
Unix SMB/CIFS implementation.
- Manually parsed structures found in the DRS protocol
-
- Copyright (C) Andrew Bartlett <abartlet@samba.org> 2008
+ Copyright (C) Andrew Tridgell 2004
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
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
-#ifndef __LIBCLI_DRSBLOBS_H__
-#define __LIBCLI_DRSBLOBS_H__
+#include "../lib/crypto/crc32.h"
+#include "../lib/crypto/md4.h"
+#include "../lib/crypto/md5.h"
+#include "../lib/crypto/hmacmd5.h"
+#include "../lib/crypto/sha256.h"
+#include "../lib/crypto/hmacsha256.h"
+#include "../lib/crypto/arcfour.h"
-#include "librpc/gen_ndr/ndr_drsblobs.h"
-#include "libcli/drsblobs_proto.h"
-#endif /* __CLDAP_SERVER_PROTO_H__ */
*/
#include "includes.h"
-#include "lib/crypto/crypto.h"
+#include "../lib/crypto/hmacmd5.h"
/***********************************************************************
the rfc 2104 version of hmac_md5 initialisation.
*/
#ifndef _HMAC_MD5_H
+#define _HMAC_MD5_H
+
+#include "../lib/crypto/md5.h"
typedef struct
{
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "includes.h"
-#include "lib/crypto/crypto.h"
+#include "../lib/crypto/crypto.h"
struct torture_context;
*/
#include "includes.h"
-#include "lib/crypto/crypto.h"
+#include "../lib/crypto/crypto.h"
/***********************************************************************
the rfc 2104/2202 version of hmac_sha256 initialisation.
*/
#include "includes.h"
-#include "lib/crypto/crypto.h"
+#include "../lib/crypto/crypto.h"
struct torture_context;
*/
#include "includes.h"
-#include "lib/crypto/crypto.h"
+#include "../lib/crypto/crypto.h"
struct torture_context;
VPATH = @libreplacedir@
srcdir = @srcdir@
builddir = @builddir@
-INSTALL = @INSTALL@
+sharedbuilddir = @sharedbuilddir@
+INSTALLCMD = @INSTALL@
LIBS = @LIBS@
.PHONY: test all showflags install installcheck clean distclean realdistclean
@echo ' LIBS = $(LIBS)'
install: all
- mkdir -p $(libdir)
- $(INSTALL) libreplace.a $(libdir)
+ ${INSTALLCMD} -d $(libdir)
+ ${INSTALLCMD} -m 644 libreplace.a $(libdir)
+
+shared-build: all
+ ${INSTALLCMD} -d $(sharedbuilddir)/include
+ ${INSTALLCMD} -m 644 replace.h $(sharedbuilddir)/include
+ ${INSTALLCMD} -d $(sharedbuilddir)/lib
+ ${INSTALLCMD} -m 644 libreplace.a $(sharedbuilddir)/lib
libreplace.a: $(OBJS)
ar -rcsv $@ $(OBJS)
installcheck: install test
-TEST_OBJS = test/testsuite.o test/os2_delete.o test/strptime.o test/getifaddrs.o
+TEST_OBJS = test/main.o test/testsuite.o test/os2_delete.o test/strptime.o test/getifaddrs.o
testsuite: libreplace.a $(TEST_OBJS)
$(CC) -o testsuite $(TEST_OBJS) -L. -lreplace $(LDFLAGS) $(LIBS)
--- /dev/null
+AC_DEFUN(BUILD_WITH_SHARED_BUILD_DIR,
+ [ AC_ARG_WITH([shared-build-dir],
+ [AC_HELP_STRING([--with-shared-build-dir=DIR],
+ [temporary build directory where libraries are installed [$srcdir/sharedbuild]])])
+
+ sharedbuilddir="$srcdir/sharedbuild"
+ if test x"$with_shared_build_dir" != x; then
+ sharedbuilddir=$with_shared_build_dir
+ CFLAGS="$CFLAGS -I$with_shared_build_dir/include"
+ LDFLAGS="$LDFLAGS -L$with_shared_build_dir/lib"
+ fi
+ AC_SUBST(sharedbuilddir)
+ ])
+
CFLAGS="$CFLAGS -Wno-format-y2k"
fi
+m4_include(build_macros.m4)
+BUILD_WITH_SHARED_BUILD_DIR
+
LIBS="${LIBREPLACE_NETWORK_LIBS}"
AC_SUBST(LIBS)
dnl find the libreplace sources. This is meant to work both for
dnl libreplace standalone builds, and builds of packages using libreplace
libreplacedir=""
-libreplacepaths="$srcdir $srcdir/lib/replace $srcdir/libreplace $srcdir/../libreplace $srcdir/../replace $srcdir/../lib/replace"
+libreplacepaths="$srcdir $srcdir/lib/replace $srcdir/libreplace $srcdir/../libreplace $srcdir/../replace $srcdir/../lib/replace $srcdir/../../../lib/replace"
for d in $libreplacepaths; do
if test -f "$d/replace.c"; then
libreplacedir="$d"
dnl find the libreplace sources. This is meant to work both for
dnl libreplace standalone builds, and builds of packages using libreplace
libreplacedir=""
-libreplacepaths="$srcdir $srcdir/lib/replace $srcdir/libreplace $srcdir/../libreplace $srcdir/../replace $srcdir/../lib/replace"
+libreplacepaths="$srcdir $srcdir/lib/replace $srcdir/libreplace $srcdir/../libreplace $srcdir/../replace $srcdir/../lib/replace $srcdir/../../../lib/replace"
for d in $libreplacepaths; do
if test -f "$d/replace.c"; then
libreplacedir="$d"
--- /dev/null
+/*
+ Unix SMB/CIFS implementation.
+
+ libreplace tests
+
+ Copyright (C) Jelmer Vernooij 2006
+
+ ** NOTE! The following LGPL license applies to the talloc
+ ** 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"
+
+struct torture_context;
+bool torture_local_replace(struct torture_context *ctx);
+
+int main(void)
+{
+ bool ret = torture_local_replace(NULL);
+ if (ret)
+ return 0;
+ return -1;
+}
return ret;
}
-
-#if _SAMBA_BUILD_<4
-int main(void)
-{
- bool ret = torture_local_replace(NULL);
- if (ret)
- return 0;
- return -1;
-}
-#endif
int socket_type,
const unsigned char *payload,
size_t payload_len,
- unsigned long tcp_seq,
+ unsigned long tcp_seqno,
unsigned long tcp_ack,
unsigned char tcp_ctl,
int unreachable,
case SOCK_STREAM:
packet->ip.p.tcp.source_port = src_port;
packet->ip.p.tcp.dest_port = dest_port;
- packet->ip.p.tcp.seq_num = htonl(tcp_seq);
+ packet->ip.p.tcp.seq_num = htonl(tcp_seqno);
packet->ip.p.tcp.ack_num = htonl(tcp_ack);
packet->ip.p.tcp.hdr_length = 0x50; /* 5 * 32 bit words */
packet->ip.p.tcp.control = tcp_ctl;
{
const struct sockaddr_in *src_addr;
const struct sockaddr_in *dest_addr;
- unsigned long tcp_seq = 0;
+ unsigned long tcp_seqno = 0;
unsigned long tcp_ack = 0;
unsigned char tcp_ctl = 0;
int unreachable = 0;
src_addr = (const struct sockaddr_in *)si->myname;
dest_addr = (const struct sockaddr_in *)addr;
- tcp_seq = si->io.pck_snd;
+ tcp_seqno = si->io.pck_snd;
tcp_ack = si->io.pck_rcv;
tcp_ctl = 0x02; /* SYN */
dest_addr = (const struct sockaddr_in *)si->myname;
src_addr = (const struct sockaddr_in *)addr;
- tcp_seq = si->io.pck_rcv;
+ tcp_seqno = si->io.pck_rcv;
tcp_ack = si->io.pck_snd;
tcp_ctl = 0x12; /** SYN,ACK */
src_addr = (const struct sockaddr_in *)addr;
/* Unreachable: resend the data of SWRAP_CONNECT_SEND */
- tcp_seq = si->io.pck_snd - 1;
+ tcp_seqno = si->io.pck_snd - 1;
tcp_ack = si->io.pck_rcv;
tcp_ctl = 0x02; /* SYN */
unreachable = 1;
src_addr = (const struct sockaddr_in *)si->myname;
dest_addr = (const struct sockaddr_in *)addr;
- tcp_seq = si->io.pck_snd;
+ tcp_seqno = si->io.pck_snd;
tcp_ack = si->io.pck_rcv;
tcp_ctl = 0x10; /* ACK */
dest_addr = (const struct sockaddr_in *)si->myname;
src_addr = (const struct sockaddr_in *)addr;
- tcp_seq = si->io.pck_rcv;
+ tcp_seqno = si->io.pck_rcv;
tcp_ack = si->io.pck_snd;
tcp_ctl = 0x02; /* SYN */
src_addr = (const struct sockaddr_in *)si->myname;
dest_addr = (const struct sockaddr_in *)addr;
- tcp_seq = si->io.pck_snd;
+ tcp_seqno = si->io.pck_snd;
tcp_ack = si->io.pck_rcv;
tcp_ctl = 0x12; /* SYN,ACK */
dest_addr = (const struct sockaddr_in *)si->myname;
src_addr = (const struct sockaddr_in *)addr;
- tcp_seq = si->io.pck_rcv;
+ tcp_seqno = si->io.pck_rcv;
tcp_ack = si->io.pck_snd;
tcp_ctl = 0x10; /* ACK */
src_addr = (const struct sockaddr_in *)si->myname;
dest_addr = (const struct sockaddr_in *)si->peername;
- tcp_seq = si->io.pck_snd;
+ tcp_seqno = si->io.pck_snd;
tcp_ack = si->io.pck_rcv;
tcp_ctl = 0x18; /* PSH,ACK */
buf, len, packet_len);
}
- tcp_seq = si->io.pck_rcv;
+ tcp_seqno = si->io.pck_rcv;
tcp_ack = si->io.pck_snd;
tcp_ctl = 0x14; /** RST,ACK */
return NULL;
}
- tcp_seq = si->io.pck_rcv;
+ tcp_seqno = si->io.pck_rcv;
tcp_ack = si->io.pck_snd;
tcp_ctl = 0x14; /* RST,ACK */
dest_addr = (const struct sockaddr_in *)si->myname;
src_addr = (const struct sockaddr_in *)si->peername;
- tcp_seq = si->io.pck_rcv;
+ tcp_seqno = si->io.pck_rcv;
tcp_ack = si->io.pck_snd;
tcp_ctl = 0x18; /* PSH,ACK */
return NULL;
}
- tcp_seq = si->io.pck_rcv;
+ tcp_seqno = si->io.pck_rcv;
tcp_ack = si->io.pck_snd;
tcp_ctl = 0x14; /* RST,ACK */
src_addr = (const struct sockaddr_in *)si->myname;
dest_addr = (const struct sockaddr_in *)si->peername;
- tcp_seq = si->io.pck_snd;
+ tcp_seqno = si->io.pck_snd;
tcp_ack = si->io.pck_rcv;
tcp_ctl = 0x11; /* FIN, ACK */
dest_addr = (const struct sockaddr_in *)si->myname;
src_addr = (const struct sockaddr_in *)si->peername;
- tcp_seq = si->io.pck_rcv;
+ tcp_seqno = si->io.pck_rcv;
tcp_ack = si->io.pck_snd;
tcp_ctl = 0x11; /* FIN,ACK */
src_addr = (const struct sockaddr_in *)si->myname;
dest_addr = (const struct sockaddr_in *)si->peername;
- tcp_seq = si->io.pck_snd;
+ tcp_seqno = si->io.pck_snd;
tcp_ack = si->io.pck_rcv;
tcp_ctl = 0x10; /* ACK */
return swrap_packet_init(&tv, src_addr, dest_addr, si->type,
(const unsigned char *)buf, len,
- tcp_seq, tcp_ack, tcp_ctl, unreachable,
+ tcp_seqno, tcp_ack, tcp_ctl, unreachable,
packet_len);
}
#!/usr/bin/perl
+# Simple script that converts Perl test harness output to
+# Subunit
+# Copyright (C) 2008 Jelmer Vernooij <jelmer@samba.org>
+# Published under the GNU GPL, v3 or later
my $firstline = 1;
my $error = 0;
--- /dev/null
+# Copyright (c) 2004 Canonical Limited
+# Author: Robert Collins <robert.collins@canonical.com>
+#
+# 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 2 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, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+
+import sys
+import logging
+import unittest
+
+
+class LogCollector(logging.Handler):
+ def __init__(self):
+ logging.Handler.__init__(self)
+ self.records=[]
+ def emit(self, record):
+ self.records.append(record.getMessage())
+
+
+def makeCollectingLogger():
+ """I make a logger instance that collects its logs for programmatic analysis
+ -> (logger, collector)"""
+ logger=logging.Logger("collector")
+ handler=LogCollector()
+ handler.setFormatter(logging.Formatter("%(levelname)s: %(message)s"))
+ logger.addHandler(handler)
+ return logger, handler
+
+
+def visitTests(suite, visitor):
+ """A foreign method for visiting the tests in a test suite."""
+ for test in suite._tests:
+ #Abusing types to avoid monkey patching unittest.TestCase.
+ # Maybe that would be better?
+ try:
+ test.visit(visitor)
+ except AttributeError:
+ if isinstance(test, unittest.TestCase):
+ visitor.visitCase(test)
+ elif isinstance(test, unittest.TestSuite):
+ visitor.visitSuite(test)
+ visitTests(test, visitor)
+ else:
+ print "unvisitable non-unittest.TestCase element %r (%r)" % (test, test.__class__)
+
+
+class TestSuite(unittest.TestSuite):
+ """I am an extended TestSuite with a visitor interface.
+ This is primarily to allow filtering of tests - and suites or
+ more in the future. An iterator of just tests wouldn't scale..."""
+
+ def visit(self, visitor):
+ """visit the composite. Visiting is depth-first.
+ current callbacks are visitSuite and visitCase."""
+ visitor.visitSuite(self)
+ visitTests(self, visitor)
+
+
+class TestLoader(unittest.TestLoader):
+ """Custome TestLoader to set the right TestSuite class."""
+ suiteClass = TestSuite
+
+class TestVisitor(object):
+ """A visitor for Tests"""
+ def visitSuite(self, aTestSuite):
+ pass
+ def visitCase(self, aTestCase):
+ pass
--- /dev/null
+#
+# subunit: extensions to python unittest to get test results from subprocesses.
+# Copyright (C) 2005 Robert Collins <robertc@robertcollins.net>
+#
+# 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 2 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, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+
+from subunit.tests import TestUtil, test_test_protocol
+
+def test_suite():
+ result = TestUtil.TestSuite()
+ result.addTest(test_test_protocol.test_suite())
+ return result
--- /dev/null
+#!/usr/bin/env python
+import sys
+print "test old mcdonald"
+print "success old mcdonald"
+print "test bing crosby"
+print "failure bing crosby ["
+print "foo.c:53:ERROR invalid state"
+print "]"
+print "test an error"
+print "error an error"
+sys.exit(0)
--- /dev/null
+#!/usr/bin/env python
+import sys
+print "test old mcdonald"
+print "success old mcdonald"
+print "test bing crosby"
+print "success bing crosby"
+sys.exit(0)
--- /dev/null
+#
+# subunit: extensions to python unittest to get test results from subprocesses.
+# Copyright (C) 2005 Robert Collins <robertc@robertcollins.net>
+#
+# 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 2 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, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+
+import unittest
+from StringIO import StringIO
+import os
+import subunit
+import sys
+
+try:
+ class MockTestProtocolServerClient(object):
+ """A mock protocol server client to test callbacks."""
+
+ def __init__(self):
+ self.end_calls = []
+ self.error_calls = []
+ self.failure_calls = []
+ self.start_calls = []
+ self.success_calls = []
+ super(MockTestProtocolServerClient, self).__init__()
+
+ def addError(self, test, error):
+ self.error_calls.append((test, error))
+
+ def addFailure(self, test, error):
+ self.failure_calls.append((test, error))
+
+ def addSuccess(self, test):
+ self.success_calls.append(test)
+
+ def stopTest(self, test):
+ self.end_calls.append(test)
+
+ def startTest(self, test):
+ self.start_calls.append(test)
+
+except AttributeError:
+ MockTestProtocolServer = None
+
+
+class TestMockTestProtocolServer(unittest.TestCase):
+
+ def test_start_test(self):
+ protocol = MockTestProtocolServerClient()
+ protocol.startTest(subunit.RemotedTestCase("test old mcdonald"))
+ self.assertEqual(protocol.start_calls,
+ [subunit.RemotedTestCase("test old mcdonald")])
+ self.assertEqual(protocol.end_calls, [])
+ self.assertEqual(protocol.error_calls, [])
+ self.assertEqual(protocol.failure_calls, [])
+ self.assertEqual(protocol.success_calls, [])
+
+ def test_add_error(self):
+ protocol = MockTestProtocolServerClient()
+ protocol.addError(subunit.RemotedTestCase("old mcdonald"),
+ subunit.RemoteError("omg it works"))
+ self.assertEqual(protocol.start_calls, [])
+ self.assertEqual(protocol.end_calls, [])
+ self.assertEqual(protocol.error_calls, [(
+ subunit.RemotedTestCase("old mcdonald"),
+ subunit.RemoteError("omg it works"))])
+ self.assertEqual(protocol.failure_calls, [])
+ self.assertEqual(protocol.success_calls, [])
+
+ def test_add_failure(self):
+ protocol = MockTestProtocolServerClient()
+ protocol.addFailure(subunit.RemotedTestCase("old mcdonald"),
+ subunit.RemoteError("omg it works"))
+ self.assertEqual(protocol.start_calls, [])
+ self.assertEqual(protocol.end_calls, [])
+ self.assertEqual(protocol.error_calls, [])
+ self.assertEqual(protocol.failure_calls, [
+ (subunit.RemotedTestCase("old mcdonald"),
+ subunit.RemoteError("omg it works"))])
+ self.assertEqual(protocol.success_calls, [])
+
+ def test_add_success(self):
+ protocol = MockTestProtocolServerClient()
+ protocol.addSuccess(subunit.RemotedTestCase("test old mcdonald"))
+ self.assertEqual(protocol.start_calls, [])
+ self.assertEqual(protocol.end_calls, [])
+ self.assertEqual(protocol.error_calls, [])
+ self.assertEqual(protocol.failure_calls, [])
+ self.assertEqual(protocol.success_calls,
+ [subunit.RemotedTestCase("test old mcdonald")])
+
+ def test_end_test(self):
+ protocol = MockTestProtocolServerClient()
+ protocol.stopTest(subunit.RemotedTestCase("test old mcdonald"))
+ self.assertEqual(protocol.end_calls,
+ [subunit.RemotedTestCase("test old mcdonald")])
+ self.assertEqual(protocol.error_calls, [])
+ self.assertEqual(protocol.failure_calls, [])
+ self.assertEqual(protocol.success_calls, [])
+ self.assertEqual(protocol.start_calls, [])
+
+
+class TestTestImports(unittest.TestCase):
+
+ def test_imports(self):
+ from subunit import TestProtocolServer
+ from subunit import RemotedTestCase
+ from subunit import RemoteError
+ from subunit import ExecTestCase
+ from subunit import IsolatedTestCase
+ from subunit import TestProtocolClient
+
+
+class TestTestProtocolServerPipe(unittest.TestCase):
+
+ def test_story(self):
+ client = unittest.TestResult()
+ protocol = subunit.TestProtocolServer(client)
+ pipe = StringIO("test old mcdonald\n"
+ "success old mcdonald\n"
+ "test bing crosby\n"
+ "failure bing crosby [\n"
+ "foo.c:53:ERROR invalid state\n"
+ "]\n"
+ "test an error\n"
+ "error an error\n")
+ protocol.readFrom(pipe)
+ mcdonald = subunit.RemotedTestCase("old mcdonald")
+ bing = subunit.RemotedTestCase("bing crosby")
+ an_error = subunit.RemotedTestCase("an error")
+ self.assertEqual(client.errors,
+ [(an_error, 'RemoteException: \n\n')])
+ self.assertEqual(
+ client.failures,
+ [(bing, "RemoteException: foo.c:53:ERROR invalid state\n\n")])
+ self.assertEqual(client.testsRun, 3)
+
+
+class TestTestProtocolServerStartTest(unittest.TestCase):
+
+ def setUp(self):
+ self.client = MockTestProtocolServerClient()
+ self.protocol = subunit.TestProtocolServer(self.client)
+
+ def test_start_test(self):
+ self.protocol.lineReceived("test old mcdonald\n")
+ self.assertEqual(self.client.start_calls,
+ [subunit.RemotedTestCase("old mcdonald")])
+
+ def test_start_testing(self):
+ self.protocol.lineReceived("testing old mcdonald\n")
+ self.assertEqual(self.client.start_calls,
+ [subunit.RemotedTestCase("old mcdonald")])
+
+ def test_start_test_colon(self):
+ self.protocol.lineReceived("test: old mcdonald\n")
+ self.assertEqual(self.client.start_calls,
+ [subunit.RemotedTestCase("old mcdonald")])
+
+ def test_start_testing_colon(self):
+ self.protocol.lineReceived("testing: old mcdonald\n")
+ self.assertEqual(self.client.start_calls,
+ [subunit.RemotedTestCase("old mcdonald")])
+
+
+class TestTestProtocolServerPassThrough(unittest.TestCase):
+
+ def setUp(self):
+ from StringIO import StringIO
+ self.stdout = StringIO()
+ self.test = subunit.RemotedTestCase("old mcdonald")
+ self.client = MockTestProtocolServerClient()
+ self.protocol = subunit.TestProtocolServer(self.client, self.stdout)
+
+ def keywords_before_test(self):
+ self.protocol.lineReceived("failure a\n")
+ self.protocol.lineReceived("failure: a\n")
+ self.protocol.lineReceived("error a\n")
+ self.protocol.lineReceived("error: a\n")
+ self.protocol.lineReceived("success a\n")
+ self.protocol.lineReceived("success: a\n")
+ self.protocol.lineReceived("successful a\n")
+ self.protocol.lineReceived("successful: a\n")
+ self.protocol.lineReceived("]\n")
+ self.assertEqual(self.stdout.getvalue(), "failure a\n"
+ "failure: a\n"
+ "error a\n"
+ "error: a\n"
+ "success a\n"
+ "success: a\n"
+ "successful a\n"
+ "successful: a\n"
+ "]\n")
+
+ def test_keywords_before_test(self):
+ self.keywords_before_test()
+ self.assertEqual(self.client.start_calls, [])
+ self.assertEqual(self.client.error_calls, [])
+ self.assertEqual(self.client.failure_calls, [])
+ self.assertEqual(self.client.success_calls, [])
+
+ def test_keywords_after_error(self):
+ self.protocol.lineReceived("test old mcdonald\n")
+ self.protocol.lineReceived("error old mcdonald\n")
+ self.keywords_before_test()
+ self.assertEqual(self.client.start_calls, [self.test])
+ self.assertEqual(self.client.end_calls, [self.test])
+ self.assertEqual(self.client.error_calls,
+ [(self.test, subunit.RemoteError(""))])
+ self.assertEqual(self.client.failure_calls, [])
+ self.assertEqual(self.client.success_calls, [])
+
+ def test_keywords_after_failure(self):
+ self.protocol.lineReceived("test old mcdonald\n")
+ self.protocol.lineReceived("failure old mcdonald\n")
+ self.keywords_before_test()
+ self.assertEqual(self.client.start_calls, [self.test])
+ self.assertEqual(self.client.end_calls, [self.test])
+ self.assertEqual(self.client.error_calls, [])
+ self.assertEqual(self.client.failure_calls,
+ [(self.test, subunit.RemoteError())])
+ self.assertEqual(self.client.success_calls, [])
+
+ def test_keywords_after_success(self):
+ self.protocol.lineReceived("test old mcdonald\n")
+ self.protocol.lineReceived("success old mcdonald\n")
+ self.keywords_before_test()
+ self.assertEqual(self.client.start_calls, [self.test])
+ self.assertEqual(self.client.end_calls, [self.test])
+ self.assertEqual(self.client.error_calls, [])
+ self.assertEqual(self.client.failure_calls, [])
+ self.assertEqual(self.client.success_calls, [self.test])
+
+ def test_keywords_after_test(self):
+ self.protocol.lineReceived("test old mcdonald\n")
+ self.protocol.lineReceived("test old mcdonald\n")
+ self.protocol.lineReceived("failure a\n")
+ self.protocol.lineReceived("failure: a\n")
+ self.protocol.lineReceived("error a\n")
+ self.protocol.lineReceived("error: a\n")
+ self.protocol.lineReceived("success a\n")
+ self.protocol.lineReceived("success: a\n")
+ self.protocol.lineReceived("successful a\n")
+ self.protocol.lineReceived("successful: a\n")
+ self.protocol.lineReceived("]\n")
+ self.protocol.lineReceived("failure old mcdonald\n")
+ self.assertEqual(self.stdout.getvalue(), "test old mcdonald\n"
+ "failure a\n"
+ "failure: a\n"
+ "error a\n"
+ "error: a\n"
+ "success a\n"
+ "success: a\n"
+ "successful a\n"
+ "successful: a\n"
+ "]\n")
+ self.assertEqual(self.client.start_calls, [self.test])
+ self.assertEqual(self.client.end_calls, [self.test])
+ self.assertEqual(self.client.failure_calls,
+ [(self.test, subunit.RemoteError())])
+ self.assertEqual(self.client.error_calls, [])
+ self.assertEqual(self.client.success_calls, [])
+
+ def test_keywords_during_failure(self):
+ self.protocol.lineReceived("test old mcdonald\n")
+ self.protocol.lineReceived("failure: old mcdonald [\n")
+ self.protocol.lineReceived("test old mcdonald\n")
+ self.protocol.lineReceived("failure a\n")
+ self.protocol.lineReceived("failure: a\n")
+ self.protocol.lineReceived("error a\n")
+ self.protocol.lineReceived("error: a\n")
+ self.protocol.lineReceived("success a\n")
+ self.protocol.lineReceived("success: a\n")
+ self.protocol.lineReceived("successful a\n")
+ self.protocol.lineReceived("successful: a\n")
+ self.protocol.lineReceived(" ]\n")
+ self.protocol.lineReceived("]\n")
+ self.assertEqual(self.stdout.getvalue(), "")
+ self.assertEqual(self.client.start_calls, [self.test])
+ self.assertEqual(self.client.failure_calls,
+ [(self.test, subunit.RemoteError("test old mcdonald\n"
+ "failure a\n"
+ "failure: a\n"
+ "error a\n"
+ "error: a\n"
+ "success a\n"
+ "success: a\n"
+ "successful a\n"
+ "successful: a\n"
+ "]\n"))])
+ self.assertEqual(self.client.end_calls, [self.test])
+ self.assertEqual(self.client.error_calls, [])
+ self.assertEqual(self.client.success_calls, [])
+
+ def test_stdout_passthrough(self):
+ """Lines received which cannot be interpreted as any protocol action
+ should be passed through to sys.stdout.
+ """
+ bytes = "randombytes\n"
+ self.protocol.lineReceived(bytes)
+ self.assertEqual(self.stdout.getvalue(), bytes)
+
+
+class TestTestProtocolServerLostConnection(unittest.TestCase):
+
+ def setUp(self):
+ self.client = MockTestProtocolServerClient()
+ self.protocol = subunit.TestProtocolServer(self.client)
+ self.test = subunit.RemotedTestCase("old mcdonald")
+
+ def test_lost_connection_no_input(self):
+ self.protocol.lostConnection()
+ self.assertEqual(self.client.start_calls, [])
+ self.assertEqual(self.client.error_calls, [])
+ self.assertEqual(self.client.failure_calls, [])
+ self.assertEqual(self.client.success_calls, [])
+
+ def test_lost_connection_after_start(self):
+ self.protocol.lineReceived("test old mcdonald\n")
+ self.protocol.lostConnection()
+ self.assertEqual(self.client.start_calls, [self.test])
+ self.assertEqual(self.client.end_calls, [self.test])
+ self.assertEqual(self.client.error_calls, [
+ (self.test, subunit.RemoteError("lost connection during "
+ "test 'old mcdonald'"))])
+ self.assertEqual(self.client.failure_calls, [])
+ self.assertEqual(self.client.success_calls, [])
+
+ def test_lost_connected_after_error(self):
+ self.protocol.lineReceived("test old mcdonald\n")
+ self.protocol.lineReceived("error old mcdonald\n")
+ self.protocol.lostConnection()
+ self.assertEqual(self.client.start_calls, [self.test])
+ self.assertEqual(self.client.failure_calls, [])
+ self.assertEqual(self.client.end_calls, [self.test])
+ self.assertEqual(self.client.error_calls, [
+ (self.test, subunit.RemoteError(""))])
+ self.assertEqual(self.client.success_calls, [])
+
+ def test_lost_connection_during_error(self):
+ self.protocol.lineReceived("test old mcdonald\n")
+ self.protocol.lineReceived("error old mcdonald [\n")
+ self.protocol.lostConnection()
+ self.assertEqual(self.client.start_calls, [self.test])
+ self.assertEqual(self.client.end_calls, [self.test])
+ self.assertEqual(self.client.error_calls, [
+ (self.test, subunit.RemoteError("lost connection during error "
+ "report of test 'old mcdonald'"))])
+ self.assertEqual(self.client.failure_calls, [])
+ self.assertEqual(self.client.success_calls, [])
+
+ def test_lost_connected_after_failure(self):
+ self.protocol.lineReceived("test old mcdonald\n")
+ self.protocol.lineReceived("failure old mcdonald\n")
+ self.protocol.lostConnection()
+ test = subunit.RemotedTestCase("old mcdonald")
+ self.assertEqual(self.client.start_calls, [self.test])
+ self.assertEqual(self.client.end_calls, [self.test])
+ self.assertEqual(self.client.error_calls, [])
+ self.assertEqual(self.client.failure_calls,
+ [(self.test, subunit.RemoteError())])
+ self.assertEqual(self.client.success_calls, [])
+
+ def test_lost_connection_during_failure(self):
+ self.protocol.lineReceived("test old mcdonald\n")
+ self.protocol.lineReceived("failure old mcdonald [\n")
+ self.protocol.lostConnection()
+ self.assertEqual(self.client.start_calls, [self.test])
+ self.assertEqual(self.client.end_calls, [self.test])
+ self.assertEqual(self.client.error_calls,
+ [(self.test,
+ subunit.RemoteError("lost connection during "
+ "failure report"
+ " of test 'old mcdonald'"))])
+ self.assertEqual(self.client.failure_calls, [])
+ self.assertEqual(self.client.success_calls, [])
+
+ def test_lost_connection_after_success(self):
+ self.protocol.lineReceived("test old mcdonald\n")
+ self.protocol.lineReceived("success old mcdonald\n")
+ self.protocol.lostConnection()
+ self.assertEqual(self.client.start_calls, [self.test])
+ self.assertEqual(self.client.end_calls, [self.test])
+ self.assertEqual(self.client.error_calls, [])
+ self.assertEqual(self.client.failure_calls, [])
+ self.assertEqual(self.client.success_calls, [self.test])
+
+
+class TestTestProtocolServerAddError(unittest.TestCase):
+
+ def setUp(self):
+ self.client = MockTestProtocolServerClient()
+ self.protocol = subunit.TestProtocolServer(self.client)
+ self.protocol.lineReceived("test mcdonalds farm\n")
+ self.test = subunit.RemotedTestCase("mcdonalds farm")
+
+ def simple_error_keyword(self, keyword):
+ self.protocol.lineReceived("%s mcdonalds farm\n" % keyword)
+ self.assertEqual(self.client.start_calls, [self.test])
+ self.assertEqual(self.client.end_calls, [self.test])
+ self.assertEqual(self.client.error_calls, [
+ (self.test, subunit.RemoteError(""))])
+ self.assertEqual(self.client.failure_calls, [])
+
+ def test_simple_error(self):
+ self.simple_error_keyword("error")
+
+ def test_simple_error_colon(self):
+ self.simple_error_keyword("error:")
+
+ def test_error_empty_message(self):
+ self.protocol.lineReceived("error mcdonalds farm [\n")
+ self.protocol.lineReceived("]\n")
+ self.assertEqual(self.client.start_calls, [self.test])
+ self.assertEqual(self.client.end_calls, [self.test])
+ self.assertEqual(self.client.error_calls, [
+ (self.test, subunit.RemoteError(""))])
+ self.assertEqual(self.client.failure_calls, [])
+
+ def error_quoted_bracket(self, keyword):
+ self.protocol.lineReceived("%s mcdonalds farm [\n" % keyword)
+ self.protocol.lineReceived(" ]\n")
+ self.protocol.lineReceived("]\n")
+ self.assertEqual(self.client.start_calls, [self.test])
+ self.assertEqual(self.client.end_calls, [self.test])
+ self.assertEqual(self.client.error_calls, [
+ (self.test, subunit.RemoteError("]\n"))])
+ self.assertEqual(self.client.failure_calls, [])
+
+ def test_error_quoted_bracket(self):
+ self.error_quoted_bracket("error")
+
+ def test_error_colon_quoted_bracket(self):
+ self.error_quoted_bracket("error:")
+
+
+class TestTestProtocolServerAddFailure(unittest.TestCase):
+
+ def setUp(self):
+ self.client = MockTestProtocolServerClient()
+ self.protocol = subunit.TestProtocolServer(self.client)
+ self.protocol.lineReceived("test mcdonalds farm\n")
+ self.test = subunit.RemotedTestCase("mcdonalds farm")
+
+ def simple_failure_keyword(self, keyword):
+ self.protocol.lineReceived("%s mcdonalds farm\n" % keyword)
+ self.assertEqual(self.client.start_calls, [self.test])
+ self.assertEqual(self.client.end_calls, [self.test])
+ self.assertEqual(self.client.error_calls, [])
+ self.assertEqual(self.client.failure_calls,
+ [(self.test, subunit.RemoteError())])
+
+ def test_simple_failure(self):
+ self.simple_failure_keyword("failure")
+
+ def test_simple_failure_colon(self):
+ self.simple_failure_keyword("failure:")
+
+ def test_failure_empty_message(self):
+ self.protocol.lineReceived("failure mcdonalds farm [\n")
+ self.protocol.lineReceived("]\n")
+ self.assertEqual(self.client.start_calls, [self.test])
+ self.assertEqual(self.client.end_calls, [self.test])
+ self.assertEqual(self.client.error_calls, [])
+ self.assertEqual(self.client.failure_calls,
+ [(self.test, subunit.RemoteError())])
+
+ def failure_quoted_bracket(self, keyword):
+ self.protocol.lineReceived("%s mcdonalds farm [\n" % keyword)
+ self.protocol.lineReceived(" ]\n")
+ self.protocol.lineReceived("]\n")
+ self.assertEqual(self.client.start_calls, [self.test])
+ self.assertEqual(self.client.end_calls, [self.test])
+ self.assertEqual(self.client.error_calls, [])
+ self.assertEqual(self.client.failure_calls,
+ [(self.test, subunit.RemoteError("]\n"))])
+
+ def test_failure_quoted_bracket(self):
+ self.failure_quoted_bracket("failure")
+
+ def test_failure_colon_quoted_bracket(self):
+ self.failure_quoted_bracket("failure:")
+
+
+class TestTestProtocolServerAddSuccess(unittest.TestCase):
+
+ def setUp(self):
+ self.client = MockTestProtocolServerClient()
+ self.protocol = subunit.TestProtocolServer(self.client)
+ self.protocol.lineReceived("test mcdonalds farm\n")
+ self.test = subunit.RemotedTestCase("mcdonalds farm")
+
+ def simple_success_keyword(self, keyword):
+ self.protocol.lineReceived("%s mcdonalds farm\n" % keyword)
+ self.assertEqual(self.client.start_calls, [self.test])
+ self.assertEqual(self.client.end_calls, [self.test])
+ self.assertEqual(self.client.error_calls, [])
+ self.assertEqual(self.client.success_calls, [self.test])
+
+ def test_simple_success(self):
+ self.simple_success_keyword("failure")
+
+ def test_simple_success_colon(self):
+ self.simple_success_keyword("failure:")
+
+ def test_simple_success(self):
+ self.simple_success_keyword("successful")
+
+ def test_simple_success_colon(self):
+ self.simple_success_keyword("successful:")
+
+
+class TestRemotedTestCase(unittest.TestCase):
+
+ def test_simple(self):
+ test = subunit.RemotedTestCase("A test description")
+ self.assertRaises(NotImplementedError, test.setUp)
+ self.assertRaises(NotImplementedError, test.tearDown)
+ self.assertEqual("A test description",
+ test.shortDescription())
+ self.assertEqual("subunit.RemotedTestCase.A test description",
+ test.id())
+ self.assertEqual("A test description (subunit.RemotedTestCase)", "%s" % test)
+ self.assertEqual("<subunit.RemotedTestCase description="
+ "'A test description'>", "%r" % test)
+ result = unittest.TestResult()
+ test.run(result)
+ self.assertEqual([(test, "RemoteException: "
+ "Cannot run RemotedTestCases.\n\n")],
+ result.errors)
+ self.assertEqual(1, result.testsRun)
+ another_test = subunit.RemotedTestCase("A test description")
+ self.assertEqual(test, another_test)
+ different_test = subunit.RemotedTestCase("ofo")
+ self.assertNotEqual(test, different_test)
+ self.assertNotEqual(another_test, different_test)
+
+
+class TestRemoteError(unittest.TestCase):
+
+ def test_eq(self):
+ error = subunit.RemoteError("Something went wrong")
+ another_error = subunit.RemoteError("Something went wrong")
+ different_error = subunit.RemoteError("boo!")
+ self.assertEqual(error, another_error)
+ self.assertNotEqual(error, different_error)
+ self.assertNotEqual(different_error, another_error)
+
+ def test_empty_constructor(self):
+ self.assertEqual(subunit.RemoteError(), subunit.RemoteError(""))
+
+
+class TestExecTestCase(unittest.TestCase):
+
+ class SampleExecTestCase(subunit.ExecTestCase):
+
+ def test_sample_method(self):
+ """sample-script.py"""
+ # the sample script runs three tests, one each
+ # that fails, errors and succeeds
+
+
+ def test_construct(self):
+ test = self.SampleExecTestCase("test_sample_method")
+ self.assertEqual(test.script,
+ subunit.join_dir(__file__, 'sample-script.py'))
+
+ def test_run(self):
+ runner = MockTestProtocolServerClient()
+ test = self.SampleExecTestCase("test_sample_method")
+ test.run(runner)
+ mcdonald = subunit.RemotedTestCase("old mcdonald")
+ bing = subunit.RemotedTestCase("bing crosby")
+ an_error = subunit.RemotedTestCase("an error")
+ self.assertEqual(runner.error_calls,
+ [(an_error, subunit.RemoteError())])
+ self.assertEqual(runner.failure_calls,
+ [(bing,
+ subunit.RemoteError(
+ "foo.c:53:ERROR invalid state\n"))])
+ self.assertEqual(runner.start_calls, [mcdonald, bing, an_error])
+ self.assertEqual(runner.end_calls, [mcdonald, bing, an_error])
+
+ def test_debug(self):
+ test = self.SampleExecTestCase("test_sample_method")
+ test.debug()
+
+ def test_count_test_cases(self):
+ """TODO run the child process and count responses to determine the count."""
+
+ def test_join_dir(self):
+ sibling = subunit.join_dir(__file__, 'foo')
+ expected = '%s/foo' % (os.path.split(__file__)[0],)
+ self.assertEqual(sibling, expected)
+
+
+class DoExecTestCase(subunit.ExecTestCase):
+
+ def test_working_script(self):
+ """sample-two-script.py"""
+
+
+class TestIsolatedTestCase(unittest.TestCase):
+
+ class SampleIsolatedTestCase(subunit.IsolatedTestCase):
+
+ SETUP = False
+ TEARDOWN = False
+ TEST = False
+
+ def setUp(self):
+ TestIsolatedTestCase.SampleIsolatedTestCase.SETUP = True
+
+ def tearDown(self):
+ TestIsolatedTestCase.SampleIsolatedTestCase.TEARDOWN = True
+
+ def test_sets_global_state(self):
+ TestIsolatedTestCase.SampleIsolatedTestCase.TEST = True
+
+
+ def test_construct(self):
+ test = self.SampleIsolatedTestCase("test_sets_global_state")
+
+ def test_run(self):
+ result = unittest.TestResult()
+ test = self.SampleIsolatedTestCase("test_sets_global_state")
+ test.run(result)
+ self.assertEqual(result.testsRun, 1)
+ self.assertEqual(self.SampleIsolatedTestCase.SETUP, False)
+ self.assertEqual(self.SampleIsolatedTestCase.TEARDOWN, False)
+ self.assertEqual(self.SampleIsolatedTestCase.TEST, False)
+
+ def test_debug(self):
+ pass
+ #test = self.SampleExecTestCase("test_sample_method")
+ #test.debug()
+
+
+class TestIsolatedTestSuite(unittest.TestCase):
+
+ class SampleTestToIsolate(unittest.TestCase):
+
+ SETUP = False
+ TEARDOWN = False
+ TEST = False
+
+ def setUp(self):
+ TestIsolatedTestSuite.SampleTestToIsolate.SETUP = True
+
+ def tearDown(self):
+ TestIsolatedTestSuite.SampleTestToIsolate.TEARDOWN = True
+
+ def test_sets_global_state(self):
+ TestIsolatedTestSuite.SampleTestToIsolate.TEST = True
+
+
+ def test_construct(self):
+ suite = subunit.IsolatedTestSuite()
+
+ def test_run(self):
+ result = unittest.TestResult()
+ suite = subunit.IsolatedTestSuite()
+ sub_suite = unittest.TestSuite()
+ sub_suite.addTest(self.SampleTestToIsolate("test_sets_global_state"))
+ sub_suite.addTest(self.SampleTestToIsolate("test_sets_global_state"))
+ suite.addTest(sub_suite)
+ suite.addTest(self.SampleTestToIsolate("test_sets_global_state"))
+ suite.run(result)
+ self.assertEqual(result.testsRun, 3)
+ self.assertEqual(self.SampleTestToIsolate.SETUP, False)
+ self.assertEqual(self.SampleTestToIsolate.TEARDOWN, False)
+ self.assertEqual(self.SampleTestToIsolate.TEST, False)
+
+
+class TestTestProtocolClient(unittest.TestCase):
+
+ def setUp(self):
+ self.io = StringIO()
+ self.protocol = subunit.TestProtocolClient(self.io)
+ self.test = TestTestProtocolClient("test_start_test")
+
+
+ def test_start_test(self):
+ """Test startTest on a TestProtocolClient."""
+ self.protocol.startTest(self.test)
+ self.assertEqual(self.io.getvalue(), "test: %s\n" % self.test.id())
+
+ def test_stop_test(self):
+ """Test stopTest on a TestProtocolClient."""
+ self.protocol.stopTest(self.test)
+ self.assertEqual(self.io.getvalue(), "")
+
+ def test_add_success(self):
+ """Test addSuccess on a TestProtocolClient."""
+ self.protocol.addSuccess(self.test)
+ self.assertEqual(
+ self.io.getvalue(), "successful: %s\n" % self.test.id())
+
+ def test_add_failure(self):
+ """Test addFailure on a TestProtocolClient."""
+ self.protocol.addFailure(self.test, subunit.RemoteError("boo"))
+ self.assertEqual(
+ self.io.getvalue(),
+ 'failure: %s [\nRemoteException: boo\n]\n' % self.test.id())
+
+ def test_add_error(self):
+ """Test stopTest on a TestProtocolClient."""
+ self.protocol.addError(self.test, subunit.RemoteError("phwoar"))
+ self.assertEqual(
+ self.io.getvalue(),
+ 'error: %s [\n'
+ "RemoteException: phwoar\n"
+ "]\n" % self.test.id())
+
+
+def test_suite():
+ loader = subunit.tests.TestUtil.TestLoader()
+ result = loader.loadTestsFromName(__name__)
+ return result
VPATH = @srcdir@:@libreplacedir@
srcdir = @srcdir@
builddir = @builddir@
+sharedbuilddir = @sharedbuilddir@
XSLTPROC = @XSLTPROC@
INSTALLCMD = @INSTALL@
CC = @CC@
$(TALLOC_SOLIB): $(LIBOBJ)
$(SHLD) $(SHLD_FLAGS) -o $@ $(LIBOBJ) @SONAMEFLAG@$(TALLOC_SONAME)
+shared-build: all
+ ${INSTALLCMD} -d $(sharedbuilddir)/lib
+ ${INSTALLCMD} -m 644 libtalloc.a $(sharedbuilddir)/lib
+ ${INSTALLCMD} -m 755 $(TALLOC_SOLIB) $(sharedbuilddir)/lib
+ ln -sf $(TALLOC_SOLIB) $(sharedbuilddir)/lib/$(TALLOC_SONAME)
+ ln -sf $(TALLOC_SOLIB) $(sharedbuilddir)/lib/libtalloc.so
+ ${INSTALLCMD} -d $(sharedbuilddir)/include
+ ${INSTALLCMD} -m 644 $(srcdir)/talloc.h $(sharedbuilddir)/include
+
check: test
installcheck:: test install
--- /dev/null
+AC_DEFUN(BUILD_WITH_SHARED_BUILD_DIR,
+ [ AC_ARG_WITH([shared-build-dir],
+ [AC_HELP_STRING([--with-shared-build-dir=DIR],
+ [temporary build directory where libraries are installed [$srcdir/sharedbuild]])])
+
+ sharedbuilddir="$srcdir/sharedbuild"
+ if test x"$with_shared_build_dir" != x; then
+ sharedbuilddir=$with_shared_build_dir
+ CFLAGS="$CFLAGS -I$with_shared_build_dir/include"
+ LDFLAGS="$LDFLAGS -L$with_shared_build_dir/lib"
+ fi
+ AC_SUBST(sharedbuilddir)
+ ])
+
AC_LIBREPLACE_SHLD
AC_LIBREPLACE_SHLD_FLAGS
+m4_include(build_macros.m4)
+BUILD_WITH_SHARED_BUILD_DIR
+
AC_OUTPUT(Makefile talloc.pc)
all:: libtalloc.a $(TALLOC_SOLIB) testsuite
-testsuite:: $(LIBOBJ) testsuite.o
- $(CC) $(CFLAGS) -o testsuite testsuite.o $(LIBOBJ) $(LIBS)
+testsuite:: $(LIBOBJ) testsuite.o testsuite_main.o
+ $(CC) $(CFLAGS) -o testsuite testsuite.o testsuite_main.o $(LIBOBJ) $(LIBS)
libtalloc.a: $(LIBOBJ)
ar -rv $@ $(LIBOBJ)
${INSTALLCMD} -m 644 talloc.pc $(DESTDIR)$(libdir)/pkgconfig
if [ -f talloc.3 ];then ${INSTALLCMD} -d $(DESTDIR)$(mandir)/man3; fi
if [ -f talloc.3 ];then ${INSTALLCMD} -m 644 talloc.3 $(DESTDIR)$(mandir)/man3; fi
- which swig >/dev/null 2>&1 && ${INSTALLCMD} -d $(DESTDIR)`swig -swiglib` || true
- which swig >/dev/null 2>&1 && ${INSTALLCMD} -m 644 talloc.i $(DESTDIR)`swig -swiglib` || true
+ which swig >/dev/null 2>&1 && ${INSTALLCMD} -d $(DESTDIR)$(prefix)`swig -swiglib` || true
+ which swig >/dev/null 2>&1 && ${INSTALLCMD} -m 644 talloc.i $(DESTDIR)$(prefix)`swig -swiglib` || true
doc:: talloc.3 talloc.3.html
clean::
- rm -f *~ $(LIBOBJ) $(TALLOC_SOLIB) libtalloc.a testsuite testsuite.o *.gc?? talloc.3 talloc.3.html
+ rm -f *~ $(LIBOBJ) $(TALLOC_SOLIB) libtalloc.a testsuite testsuite.o testsuite_main.o *.gc?? talloc.3 talloc.3.html
test:: testsuite
./testsuite
Using talloc in Samba4
-----------------------
+======================
+
+.. contents::
Andrew Tridgell
September 2004
Perhaps the biggest change from Samba3 is that there is no distinction
between a "talloc context" and a "talloc pointer". Any pointer
returned from talloc() is itself a valid talloc context. This means
-you can do this:
+you can do this::
struct foo *X = talloc(mem_ctx, struct foo);
X->name = talloc_strdup(X, "foo");
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
void *talloc_named_const(const void *context, size_t size, const char *name);
-This is equivalent to:
+This is equivalent to::
ptr = talloc_size(context, size);
talloc_set_name_const(ptr, name);
void *talloc_init(const char *fmt, ...);
This function creates a zero length named talloc context as a top
-level context. It is equivalent to:
+level context. It is equivalent to::
talloc_named(NULL, 0, fmt, ...);
pointer. The "count" argument is the number of elements of type "type"
that you want the resulting pointer to hold.
-talloc_realloc() has the following equivalences:
+talloc_realloc() has the following equivalences::
talloc_realloc(context, NULL, type, 1) ==> talloc(context, type);
talloc_realloc(context, NULL, type, N) ==> talloc_array(context, type, N);
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
(type *)talloc_zero(const void *ctx, type);
-The talloc_zero() macro is equivalent to:
+The talloc_zero() macro is equivalent to::
ptr = talloc(ctx, type);
if (ptr) memset(ptr, 0, sizeof(type));
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
void *talloc_memdup(const void *ctx, const void *p, size_t size);
-The talloc_memdup() function is equivalent to:
+The talloc_memdup() function is equivalent to::
ptr = talloc_size(ctx, size);
if (ptr) memcpy(ptr, p, size);
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
char *talloc_strdup(const void *ctx, const char *p);
-The talloc_strdup() function is equivalent to:
+The talloc_strdup() function is equivalent to::
ptr = talloc_size(ctx, strlen(p)+1);
if (ptr) memcpy(ptr, p, strlen(p)+1);
This functions sets the name of the new pointer to the passed
-string. This is equivalent to:
+string. This is equivalent to::
+
talloc_set_name_const(ptr, ptr)
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
string to the given string.
This function sets the name of the new pointer to the new
-string. This is equivalent to:
+string. This is equivalent to::
+
talloc_set_name_const(ptr, ptr)
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
library function vasprintf()
This functions sets the name of the new pointer to the new
-string. This is equivalent to:
+string. This is equivalent to::
+
talloc_set_name_const(ptr, ptr)
library function asprintf()
This functions sets the name of the new pointer to the new
-string. This is equivalent to:
+string. This is equivalent to::
+
talloc_set_name_const(ptr, ptr)
have been truncated in length.
This functions sets the name of the new pointer to the new
-string. This is equivalent to:
+string. This is equivalent to::
+
talloc_set_name_const(ptr, ptr)
not been changed.
This functions sets the name of the new pointer to the new
-string. This is equivalent to:
+string. This is equivalent to::
+
talloc_set_name_const(ptr, ptr)
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
((type *)talloc_array(const void *ctx, type, uint_t count);
-The talloc_array() macro is equivalent to:
+The talloc_array() macro is equivalent to::
(type *)talloc_size(ctx, sizeof(type) * count);
This macro allows you to do type checking on talloc pointers. It is
particularly useful for void* private pointers. It is equivalent to
-this:
+this::
(type *)talloc_check_name(ptr, #type)
particular type. This can be used in conjunction with
talloc_get_type() to do type checking on void* pointers.
-It is equivalent to this:
+It is equivalent to this::
+
talloc_set_name_const(ptr, #type)
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
return ret;
}
-
-#if _SAMBA_BUILD_ < 4
-int main(void)
-{
- bool ret = torture_local_talloc(NULL);
- if (!ret)
- return -1;
- return 0;
-}
-#endif
--- /dev/null
+/*
+ Unix SMB/CIFS implementation.
+
+ local testing of talloc routines.
+
+ Copyright (C) Andrew Tridgell 2004
+
+ ** NOTE! The following LGPL license applies to the talloc
+ ** 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"
+
+struct torture_context;
+bool torture_local_talloc(struct torture_context *tctx);
+
+int main(void)
+{
+ bool ret = torture_local_talloc(NULL);
+ if (!ret)
+ return -1;
+ return 0;
+}
VPATH = @srcdir@:@libreplacedir@
srcdir = @srcdir@
builddir = @builddir@
+sharedbuilddir = @sharedbuilddir@
+INSTALLCMD = @INSTALL@
CPPFLAGS = @CPPFLAGS@ -I$(srcdir)/include -Iinclude
CFLAGS = $(CPPFLAGS) @CFLAGS@
LDFLAGS = @LDFLAGS@
$(TDB_SOLIB): $(TDB_OBJ)
$(SHLD) $(SHLD_FLAGS) -o $@ $(TDB_OBJ) @SONAMEFLAG@$(TDB_SONAME)
+shared-build: all
+ ${INSTALLCMD} -d $(sharedbuilddir)/lib
+ ${INSTALLCMD} -m 644 libtdb.a $(sharedbuilddir)/lib
+ ${INSTALLCMD} -m 755 $(TDB_SOLIB) $(sharedbuilddir)/lib
+ ln -sf $(TDB_SOLIB) $(sharedbuilddir)/lib/$(TDB_SONAME)
+ ln -sf $(TDB_SOLIB) $(sharedbuilddir)/lib/libtdb.so
+ ${INSTALLCMD} -d $(sharedbuilddir)/include
+ ${INSTALLCMD} -m 644 $(srcdir)/include/tdb.h $(sharedbuilddir)/include
+
check: test
test:: $(PYTHON_CHECK_TARGET)
--- /dev/null
+AC_DEFUN(BUILD_WITH_SHARED_BUILD_DIR,
+ [ AC_ARG_WITH([shared-build-dir],
+ [AC_HELP_STRING([--with-shared-build-dir=DIR],
+ [temporary build directory where libraries are installed [$srcdir/sharedbuild]])])
+
+ sharedbuilddir="$srcdir/sharedbuild"
+ if test x"$with_shared_build_dir" != x; then
+ sharedbuilddir=$with_shared_build_dir
+ CFLAGS="$CFLAGS -I$with_shared_build_dir/include"
+ LDFLAGS="$LDFLAGS -L$with_shared_build_dir/lib"
+ fi
+ AC_SUBST(sharedbuilddir)
+ ])
+
AC_DEFUN([SMB_MODULE_DEFAULT], [echo -n ""])
AC_DEFUN([SMB_LIBRARY_ENABLE], [echo -n ""])
AC_DEFUN([SMB_ENABLE], [echo -n ""])
-AC_INIT(tdb, 1.1.2)
+AC_INIT(tdb, 1.1.3)
AC_CONFIG_SRCDIR([common/tdb.c])
AC_CONFIG_HEADER(include/config.h)
AC_LIBREPLACE_ALL_CHECKS
PYTHON_INSTALL_TARGET=""
PYTHON_CHECK_TARGET=""
fi
+
+m4_include(build_macros.m4)
+BUILD_WITH_SHARED_BUILD_DIR
+
AC_OUTPUT(Makefile tdb.pc)
extern "C" {
#endif
+#include "signal.h"
/* flags to tdb_store() */
#define TDB_REPLACE 1 /* Unused */
# TODO: any other missing methods for container types
}
} tdb;
+
+%pythoncode {
+__docformat__ = 'restructuredText'
+open = Tdb
+}
# This file was automatically generated by SWIG (http://www.swig.org).
-# Version 1.3.35
+# Version 1.3.36
#
# Don't modify this file, modify the SWIG interface instead.
Tdb_swigregister = _tdb.Tdb_swigregister
Tdb_swigregister(Tdb)
+__docformat__ = 'restructuredText'
+open = Tdb
+
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
- * Version 1.3.35
+ * Version 1.3.36
*
* This file is not intended to be easily readable and contains a number of
* coding conventions designed to improve portability and efficiency. Do not make
# endif
#endif
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+# pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
# define SWIGUNUSEDPARM(p)
#define SWIG_name "_tdb"
-#define SWIGVERSION 0x010335
+#define SWIGVERSION 0x010336
#define SWIG_VERSION SWIGVERSION
int arg3 ;
int arg4 ;
mode_t arg5 ;
- tdb *result = 0 ;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
char * kwnames[] = {
(char *) "name",(char *) "hash_size",(char *) "tdb_flags",(char *) "flags",(char *) "mode", NULL
};
+ tdb *result = 0 ;
arg2 = 0;
arg3 = TDB_DEFAULT;
SWIGINTERN PyObject *_wrap_Tdb_error(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
tdb *arg1 = (tdb *) 0 ;
- enum TDB_ERROR result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
+ enum TDB_ERROR result;
if (!args) SWIG_fail;
swig_obj[0] = args;
}
arg1 = (tdb *)(argp1);
delete_tdb(arg1);
-
resultobj = SWIG_Py_Void();
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_Tdb_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
tdb *arg1 = (tdb *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
+ int result;
if (!args) SWIG_fail;
swig_obj[0] = args;
tdb *arg1 = (tdb *) 0 ;
TDB_DATA arg2 ;
TDB_DATA arg3 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char * kwnames[] = {
(char *) "self",(char *) "key",(char *) "new_dbuf", NULL
};
+ int result;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Tdb_append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_tdb_context, 0 | 0 );
SWIGINTERN PyObject *_wrap_Tdb_errorstr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
tdb *arg1 = (tdb *) 0 ;
- char *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
+ char *result = 0 ;
if (!args) SWIG_fail;
swig_obj[0] = args;
PyObject *resultobj = 0;
tdb *arg1 = (tdb *) 0 ;
TDB_DATA arg2 ;
- TDB_DATA result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char * kwnames[] = {
(char *) "self",(char *) "key", NULL
};
+ TDB_DATA result;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Tdb_get",kwnames,&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_tdb_context, 0 | 0 );
PyObject *resultobj = 0;
tdb *arg1 = (tdb *) 0 ;
TDB_DATA arg2 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char * kwnames[] = {
(char *) "self",(char *) "key", NULL
};
+ int result;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Tdb_delete",kwnames,&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_tdb_context, 0 | 0 );
TDB_DATA arg2 ;
TDB_DATA arg3 ;
int arg4 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
int val4 ;
char * kwnames[] = {
(char *) "self",(char *) "key",(char *) "dbuf",(char *) "flag", NULL
};
+ int result;
arg4 = TDB_REPLACE;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Tdb_store",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
PyObject *resultobj = 0;
tdb *arg1 = (tdb *) 0 ;
TDB_DATA arg2 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char * kwnames[] = {
(char *) "self",(char *) "key", NULL
};
+ int result;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Tdb_exists",kwnames,&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_tdb_context, 0 | 0 );
SWIGINTERN PyObject *_wrap_Tdb_firstkey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
tdb *arg1 = (tdb *) 0 ;
- TDB_DATA result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
+ TDB_DATA result;
if (!args) SWIG_fail;
swig_obj[0] = args;
PyObject *resultobj = 0;
tdb *arg1 = (tdb *) 0 ;
TDB_DATA arg2 ;
- TDB_DATA result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char * kwnames[] = {
(char *) "self",(char *) "key", NULL
};
+ TDB_DATA result;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Tdb_nextkey",kwnames,&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_tdb_context, 0 | 0 );
SWIGINTERN PyObject *_wrap_Tdb_lock_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
tdb *arg1 = (tdb *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
+ int result;
if (!args) SWIG_fail;
swig_obj[0] = args;
SWIGINTERN PyObject *_wrap_Tdb_unlock_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
tdb *arg1 = (tdb *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
+ int result;
if (!args) SWIG_fail;
swig_obj[0] = args;
SWIGINTERN PyObject *_wrap_Tdb_read_lock_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
tdb *arg1 = (tdb *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
+ int result;
if (!args) SWIG_fail;
swig_obj[0] = args;
SWIGINTERN PyObject *_wrap_Tdb_read_unlock_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
tdb *arg1 = (tdb *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
+ int result;
if (!args) SWIG_fail;
swig_obj[0] = args;
SWIGINTERN PyObject *_wrap_Tdb_reopen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
tdb *arg1 = (tdb *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
+ int result;
if (!args) SWIG_fail;
swig_obj[0] = args;
SWIGINTERN PyObject *_wrap_Tdb_transaction_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
tdb *arg1 = (tdb *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
+ int result;
if (!args) SWIG_fail;
swig_obj[0] = args;
SWIGINTERN PyObject *_wrap_Tdb_transaction_commit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
tdb *arg1 = (tdb *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
+ int result;
if (!args) SWIG_fail;
swig_obj[0] = args;
SWIGINTERN PyObject *_wrap_Tdb_transaction_cancel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
tdb *arg1 = (tdb *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
+ int result;
if (!args) SWIG_fail;
swig_obj[0] = args;
SWIGINTERN PyObject *_wrap_Tdb_transaction_recover(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
tdb *arg1 = (tdb *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
+ int result;
if (!args) SWIG_fail;
swig_obj[0] = args;
SWIGINTERN PyObject *_wrap_Tdb_hash_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
tdb *arg1 = (tdb *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
+ int result;
if (!args) SWIG_fail;
swig_obj[0] = args;
SWIGINTERN PyObject *_wrap_Tdb_map_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
tdb *arg1 = (tdb *) 0 ;
- size_t result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
+ size_t result;
if (!args) SWIG_fail;
swig_obj[0] = args;
SWIGINTERN PyObject *_wrap_Tdb_get_flags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
tdb *arg1 = (tdb *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
+ int result;
if (!args) SWIG_fail;
swig_obj[0] = args;
SWIGINTERN PyObject *_wrap_Tdb_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
tdb *arg1 = (tdb *) 0 ;
- char *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
+ char *result = 0 ;
if (!args) SWIG_fail;
swig_obj[0] = args;
/* information on what to do on completion */
struct {
void (*fn)(struct nbt_name_request *);
- void *_private;
+ void *private_data;
} async;
};
struct nbt_name_socket {
struct socket_context *sock;
struct event_context *event_ctx;
-/*
struct smb_iconv_convenience *iconv_convenience;
-*/
+
/* a queue of requests pending to be sent */
struct nbt_name_request *send_queue;
struct {
void (*handler)(struct nbt_name_socket *, struct nbt_name_packet *,
struct socket_address *);
- void *_private;
+ void *private_data;
} incoming;
/* what to do with unexpected replies */
struct {
void (*handler)(struct nbt_name_socket *, struct nbt_name_packet *,
struct socket_address *);
- void *_private;
+ void *private_data;
} unexpected;
};
};
struct nbt_name_socket *nbt_name_socket_init(TALLOC_CTX *mem_ctx,
- struct event_context *event_ctx);
- /*,
- struct smb_iconv_convenience *iconv_convenience);*/
+ struct event_context *event_ctx,
+ struct smb_iconv_convenience *iconv_convenience);
struct nbt_name_request *nbt_name_query_send(struct nbt_name_socket *nbtsock,
struct nbt_name_query *io);
NTSTATUS nbt_name_query_recv(struct nbt_name_request *req,
TALLOC_CTX *mem_ctx, struct nbt_name_status *io);
NTSTATUS nbt_name_dup(TALLOC_CTX *mem_ctx, struct nbt_name *name, struct nbt_name *newname);
-NTSTATUS nbt_name_to_blob(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, struct nbt_name *name);
+NTSTATUS nbt_name_to_blob(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, DATA_BLOB *blob, struct nbt_name *name);
NTSTATUS nbt_name_from_blob(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob, struct nbt_name *name);
void nbt_choose_called_name(TALLOC_CTX *mem_ctx, struct nbt_name *n, const char *name, int type);
char *nbt_name_string(TALLOC_CTX *mem_ctx, const struct nbt_name *name);
NTSTATUS nbt_set_incoming_handler(struct nbt_name_socket *nbtsock,
void (*handler)(struct nbt_name_socket *, struct nbt_name_packet *,
struct socket_address *),
- void *_private);
+ void *private_data);
NTSTATUS nbt_name_reply_send(struct nbt_name_socket *nbtsock,
struct socket_address *dest,
struct nbt_name_packet *request);
-/*
+/*
Unix SMB/CIFS implementation.
make nbt name query requests
Copyright (C) Andrew Tridgell 2005
-
+
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/nbt/libnbt.h"
-#include "libcli/nbt/nbt_proto.h"
+#include "../libcli/nbt/libnbt.h"
+#include "../libcli/nbt/nbt_proto.h"
#include "lib/socket/socket.h"
#include "param/param.h"
failed:
talloc_free(packet);
- return NULL;
+ return NULL;
}
/**
wait for a name query reply
*/
-_PUBLIC_ NTSTATUS nbt_name_query_recv(struct nbt_name_request *req,
+_PUBLIC_ NTSTATUS nbt_name_query_recv(struct nbt_name_request *req,
TALLOC_CTX *mem_ctx, struct nbt_name_query *io)
{
NTSTATUS status;
talloc_free(req);
return status;
}
-
+
packet = req->replies[0].packet;
io->out.reply_from = talloc_steal(mem_ctx, req->replies[0].dest->addr);
talloc_free(req);
return NT_STATUS_NO_MEMORY;
}
-
+
for (i=0;i<io->out.num_addrs;i++) {
- io->out.reply_addrs[i] = talloc_steal(io->out.reply_addrs,
+ io->out.reply_addrs[i] = talloc_steal(io->out.reply_addrs,
packet->answers[0].rdata.netbios.addresses[i].ipaddr);
}
io->out.reply_addrs[i] = NULL;
talloc_steal(mem_ctx, io->out.name.name);
talloc_steal(mem_ctx, io->out.name.scope);
-
+
talloc_free(req);
return NT_STATUS_OK;
/**
wait for a name query reply
*/
-_PUBLIC_ NTSTATUS nbt_name_query(struct nbt_name_socket *nbtsock,
+_PUBLIC_ NTSTATUS nbt_name_query(struct nbt_name_socket *nbtsock,
TALLOC_CTX *mem_ctx, struct nbt_name_query *io)
{
struct nbt_name_request *req = nbt_name_query_send(nbtsock, io);
failed:
talloc_free(packet);
- return NULL;
+ return NULL;
}
/**
wait for a name status reply
*/
-_PUBLIC_ NTSTATUS nbt_name_status_recv(struct nbt_name_request *req,
+_PUBLIC_ NTSTATUS nbt_name_status_recv(struct nbt_name_request *req,
TALLOC_CTX *mem_ctx, struct nbt_name_status *io)
{
NTSTATUS status;
talloc_free(req);
return status;
}
-
+
packet = req->replies[0].packet;
io->out.reply_from = talloc_steal(mem_ctx, req->replies[0].dest->addr);
talloc_steal(io->out.status.names, io->out.status.names[i].name);
}
-
+
talloc_free(req);
return NT_STATUS_OK;
/**
wait for a name status reply
*/
-_PUBLIC_ NTSTATUS nbt_name_status(struct nbt_name_socket *nbtsock,
+_PUBLIC_ NTSTATUS nbt_name_status(struct nbt_name_socket *nbtsock,
TALLOC_CTX *mem_ctx, struct nbt_name_status *io)
{
struct nbt_name_request *req = nbt_name_status_send(nbtsock, io);
-/*
+/*
Unix SMB/CIFS implementation.
send out a name refresh request
Copyright (C) Andrew Tridgell 2005
-
+
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/nbt/libnbt.h"
-#include "libcli/nbt/nbt_proto.h"
+#include "../libcli/nbt/libnbt.h"
+#include "../libcli/nbt/nbt_proto.h"
#include "libcli/composite/composite.h"
#include "lib/socket/socket.h"
#include "param/param.h"
struct nbt_rdata_address, 1);
if (packet->additional[0].rdata.netbios.addresses == NULL) goto failed;
packet->additional[0].rdata.netbios.addresses[0].nb_flags = io->in.nb_flags;
- packet->additional[0].rdata.netbios.addresses[0].ipaddr =
+ packet->additional[0].rdata.netbios.addresses[0].ipaddr =
talloc_strdup(packet->additional, io->in.address);
- dest = socket_address_from_strings(nbtsock,
- nbtsock->sock->backend_name,
+ dest = socket_address_from_strings(nbtsock,
+ nbtsock->sock->backend_name,
io->in.dest_addr, io->in.dest_port);
if (dest == NULL) goto failed;
req = nbt_name_request_send(nbtsock, dest, packet,
failed:
talloc_free(packet);
- return NULL;
+ return NULL;
}
/*
wait for a refresh reply
*/
-_PUBLIC_ NTSTATUS nbt_name_refresh_recv(struct nbt_name_request *req,
+_PUBLIC_ NTSTATUS nbt_name_refresh_recv(struct nbt_name_request *req,
TALLOC_CTX *mem_ctx, struct nbt_name_refresh *io)
{
NTSTATUS status;
talloc_free(req);
return status;
}
-
+
packet = req->replies[0].packet;
io->out.reply_from = talloc_steal(mem_ctx, req->replies[0].dest->addr);
talloc_free(req);
return NT_STATUS_INVALID_NETWORK_RESPONSE;
}
- io->out.reply_addr = talloc_steal(mem_ctx,
+ io->out.reply_addr = talloc_steal(mem_ctx,
packet->answers[0].rdata.netbios.addresses[0].ipaddr);
talloc_steal(mem_ctx, io->out.name.name);
talloc_steal(mem_ctx, io->out.name.scope);
/*
synchronous name refresh request
*/
-_PUBLIC_ NTSTATUS nbt_name_refresh(struct nbt_name_socket *nbtsock,
+_PUBLIC_ NTSTATUS nbt_name_refresh(struct nbt_name_socket *nbtsock,
TALLOC_CTX *mem_ctx, struct nbt_name_refresh *io)
{
struct nbt_name_request *req = nbt_name_refresh_send(nbtsock, io);
*/
static void name_refresh_wins_handler(struct nbt_name_request *req)
{
- struct composite_context *c = talloc_get_type(req->async.private,
+ struct composite_context *c = talloc_get_type(req->async.private_data,
struct composite_context);
- struct refresh_wins_state *state = talloc_get_type(c->private_data,
+ struct refresh_wins_state *state = talloc_get_type(c->private_data,
struct refresh_wins_state);
NTSTATUS status;
c->status = NT_STATUS_NO_MEMORY;
} else {
state->req->async.fn = name_refresh_wins_handler;
- state->req->async.private = c;
+ state->req->async.private_data = c;
}
} else if (!NT_STATUS_IS_OK(status)) {
c->state = COMPOSITE_STATE_ERROR;
c->status = NT_STATUS_NO_MEMORY;
} else {
state->req->async.fn = name_refresh_wins_handler;
- state->req->async.private = c;
+ state->req->async.private_data = c;
}
} else {
c->state = COMPOSITE_STATE_DONE;
state->wins_port = io->in.wins_port;
state->wins_servers = str_list_copy(state, io->in.wins_servers);
- if (state->wins_servers == NULL ||
+ if (state->wins_servers == NULL ||
state->wins_servers[0] == NULL) goto failed;
state->addresses = str_list_copy(state, io->in.addresses);
- if (state->addresses == NULL ||
+ if (state->addresses == NULL ||
state->addresses[0] == NULL) goto failed;
state->io->in.name = io->in.name;
if (state->req == NULL) goto failed;
state->req->async.fn = name_refresh_wins_handler;
- state->req->async.private = c;
+ state->req->async.private_data = c;
c->private_data = state;
c->state = COMPOSITE_STATE_IN_PROGRESS;
NTSTATUS status;
status = composite_wait(c);
if (NT_STATUS_IS_OK(status)) {
- struct refresh_wins_state *state =
+ struct refresh_wins_state *state =
talloc_get_type(c->private_data, struct refresh_wins_state);
io->out.wins_server = talloc_steal(mem_ctx, state->wins_servers[0]);
io->out.rcode = state->io->out.rcode;
-/*
+/*
Unix SMB/CIFS implementation.
send out a name registration request
Copyright (C) Andrew Tridgell 2005
-
+
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/nbt/libnbt.h"
-#include "libcli/nbt/nbt_proto.h"
+#include "../libcli/nbt/libnbt.h"
+#include "../libcli/nbt/nbt_proto.h"
#include "libcli/composite/composite.h"
#include "lib/socket/socket.h"
#include "librpc/gen_ndr/ndr_nbt.h"
struct nbt_rdata_address, 1);
if (packet->additional[0].rdata.netbios.addresses == NULL) goto failed;
packet->additional[0].rdata.netbios.addresses[0].nb_flags = io->in.nb_flags;
- packet->additional[0].rdata.netbios.addresses[0].ipaddr =
+ packet->additional[0].rdata.netbios.addresses[0].ipaddr =
talloc_strdup(packet->additional, io->in.address);
if (packet->additional[0].rdata.netbios.addresses[0].ipaddr == NULL) goto failed;
- dest = socket_address_from_strings(packet, nbtsock->sock->backend_name,
+ dest = socket_address_from_strings(packet, nbtsock->sock->backend_name,
io->in.dest_addr, io->in.dest_port);
if (dest == NULL) goto failed;
req = nbt_name_request_send(nbtsock, dest, packet,
failed:
talloc_free(packet);
- return NULL;
+ return NULL;
}
/*
wait for a registration reply
*/
-_PUBLIC_ NTSTATUS nbt_name_register_recv(struct nbt_name_request *req,
+_PUBLIC_ NTSTATUS nbt_name_register_recv(struct nbt_name_request *req,
TALLOC_CTX *mem_ctx, struct nbt_name_register *io)
{
NTSTATUS status;
talloc_free(req);
return status;
}
-
+
packet = req->replies[0].packet;
io->out.reply_from = talloc_steal(mem_ctx, req->replies[0].dest->addr);
talloc_free(req);
return NT_STATUS_INVALID_NETWORK_RESPONSE;
}
- io->out.reply_addr = talloc_steal(mem_ctx,
+ io->out.reply_addr = talloc_steal(mem_ctx,
packet->answers[0].rdata.netbios.addresses[0].ipaddr);
talloc_steal(mem_ctx, io->out.name.name);
talloc_steal(mem_ctx, io->out.name.scope);
-
+
talloc_free(req);
return NT_STATUS_OK;
/*
synchronous name registration request
*/
-_PUBLIC_ NTSTATUS nbt_name_register(struct nbt_name_socket *nbtsock,
+_PUBLIC_ NTSTATUS nbt_name_register(struct nbt_name_socket *nbtsock,
TALLOC_CTX *mem_ctx, struct nbt_name_register *io)
{
struct nbt_name_request *req = nbt_name_register_send(nbtsock, io);
*/
static void name_register_bcast_handler(struct nbt_name_request *req)
{
- struct composite_context *c = talloc_get_type(req->async.private, struct composite_context);
+ struct composite_context *c = talloc_get_type(req->async.private_data, struct composite_context);
struct register_bcast_state *state = talloc_get_type(c->private_data, struct register_bcast_state);
NTSTATUS status;
c->status = NT_STATUS_NO_MEMORY;
} else {
state->req->async.fn = name_register_bcast_handler;
- state->req->async.private = c;
+ state->req->async.private_data = c;
}
} else if (!NT_STATUS_IS_OK(status)) {
c->state = COMPOSITE_STATE_ERROR;
c->state = COMPOSITE_STATE_ERROR;
c->status = NT_STATUS_CONFLICTING_ADDRESSES;
DEBUG(3,("Name registration conflict from %s for %s with ip %s - rcode %d\n",
- state->io->out.reply_from,
+ state->io->out.reply_from,
nbt_name_string(state, &state->io->out.name),
state->io->out.reply_addr,
state->io->out.rcode));
if (state->req == NULL) goto failed;
state->req->async.fn = name_register_bcast_handler;
- state->req->async.private = c;
+ state->req->async.private_data = c;
c->private_data = state;
c->state = COMPOSITE_STATE_IN_PROGRESS;
*/
static void name_register_wins_handler(struct nbt_name_request *req)
{
- struct composite_context *c = talloc_get_type(req->async.private,
+ struct composite_context *c = talloc_get_type(req->async.private_data,
struct composite_context);
- struct register_wins_state *state = talloc_get_type(c->private_data,
+ struct register_wins_state *state = talloc_get_type(c->private_data,
struct register_wins_state);
NTSTATUS status;
c->status = NT_STATUS_NO_MEMORY;
} else {
state->req->async.fn = name_register_wins_handler;
- state->req->async.private = c;
+ state->req->async.private_data = c;
}
} else if (!NT_STATUS_IS_OK(status)) {
c->state = COMPOSITE_STATE_ERROR;
c->status = NT_STATUS_NO_MEMORY;
} else {
state->req->async.fn = name_register_wins_handler;
- state->req->async.private = c;
+ state->req->async.private_data = c;
}
} else {
c->state = COMPOSITE_STATE_DONE;
state->wins_port = io->in.wins_port;
state->wins_servers = str_list_copy(state, io->in.wins_servers);
- if (state->wins_servers == NULL ||
+ if (state->wins_servers == NULL ||
state->wins_servers[0] == NULL) goto failed;
state->addresses = str_list_copy(state, io->in.addresses);
- if (state->addresses == NULL ||
+ if (state->addresses == NULL ||
state->addresses[0] == NULL) goto failed;
state->io->in.name = io->in.name;
if (state->req == NULL) goto failed;
state->req->async.fn = name_register_wins_handler;
- state->req->async.private = c;
+ state->req->async.private_data = c;
c->private_data = state;
c->state = COMPOSITE_STATE_IN_PROGRESS;
NTSTATUS status;
status = composite_wait(c);
if (NT_STATUS_IS_OK(status)) {
- struct register_wins_state *state =
+ struct register_wins_state *state =
talloc_get_type(c->private_data, struct register_wins_state);
io->out.wins_server = talloc_steal(mem_ctx, state->wins_servers[0]);
io->out.rcode = state->io->out.rcode;
-/*
+/*
Unix SMB/CIFS implementation.
send out a name release request
Copyright (C) Andrew Tridgell 2005
-
+
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/nbt/libnbt.h"
-#include "libcli/nbt/nbt_proto.h"
+#include "../libcli/nbt/libnbt.h"
+#include "../libcli/nbt/nbt_proto.h"
#include "lib/socket/socket.h"
#include "param/param.h"
struct nbt_rdata_address, 1);
if (packet->additional[0].rdata.netbios.addresses == NULL) goto failed;
packet->additional[0].rdata.netbios.addresses[0].nb_flags = io->in.nb_flags;
- packet->additional[0].rdata.netbios.addresses[0].ipaddr =
+ packet->additional[0].rdata.netbios.addresses[0].ipaddr =
talloc_strdup(packet->additional, io->in.address);
- dest = socket_address_from_strings(packet, nbtsock->sock->backend_name,
+ dest = socket_address_from_strings(packet, nbtsock->sock->backend_name,
io->in.dest_addr, io->in.dest_port);
if (dest == NULL) goto failed;
req = nbt_name_request_send(nbtsock, dest, packet,
failed:
talloc_free(packet);
- return NULL;
+ return NULL;
}
/*
wait for a release reply
*/
-_PUBLIC_ NTSTATUS nbt_name_release_recv(struct nbt_name_request *req,
+_PUBLIC_ NTSTATUS nbt_name_release_recv(struct nbt_name_request *req,
TALLOC_CTX *mem_ctx, struct nbt_name_release *io)
{
NTSTATUS status;
talloc_free(req);
return status;
}
-
+
packet = req->replies[0].packet;
io->out.reply_from = talloc_steal(mem_ctx, req->replies[0].dest->addr);
talloc_free(req);
return NT_STATUS_INVALID_NETWORK_RESPONSE;
}
- io->out.reply_addr = talloc_steal(mem_ctx,
+ io->out.reply_addr = talloc_steal(mem_ctx,
packet->answers[0].rdata.netbios.addresses[0].ipaddr);
talloc_steal(mem_ctx, io->out.name.name);
talloc_steal(mem_ctx, io->out.name.scope);
/*
synchronous name release request
*/
-_PUBLIC_ NTSTATUS nbt_name_release(struct nbt_name_socket *nbtsock,
+_PUBLIC_ NTSTATUS nbt_name_release(struct nbt_name_socket *nbtsock,
TALLOC_CTX *mem_ctx, struct nbt_name_release *io)
{
struct nbt_name_request *req = nbt_name_release_send(nbtsock, io);
--- /dev/null
+#ifndef _____LIBCLI_NBT_NBT_PROTO_H__
+#define _____LIBCLI_NBT_NBT_PROTO_H__
+
+#undef _PRINTF_ATTRIBUTE
+#define _PRINTF_ATTRIBUTE(a1, a2) PRINTF_ATTRIBUTE(a1, a2)
+/* This file was automatically generated by mkproto.pl. DO NOT EDIT */
+
+/* this file contains prototypes for functions that are private
+ * to this subsystem or library. These functions should not be
+ * used outside this particular subsystem! */
+
+
+/* The following definitions come from ../libcli/nbt/nbtsocket.c */
+
+struct nbt_name_request *nbt_name_request_send(struct nbt_name_socket *nbtsock,
+ struct socket_address *dest,
+ struct nbt_name_packet *request,
+ int timeout, int retries,
+ bool allow_multiple_replies);
+NTSTATUS nbt_name_request_recv(struct nbt_name_request *req);
+
+/* The following definitions come from ../libcli/nbt/namequery.c */
+
+
+/* The following definitions come from ../libcli/nbt/nameregister.c */
+
+struct nbt_name_request *nbt_name_register_send(struct nbt_name_socket *nbtsock,
+ struct nbt_name_register *io);
+NTSTATUS nbt_name_register_bcast(struct nbt_name_socket *nbtsock,
+ struct nbt_name_register_bcast *io);
+
+/* The following definitions come from ../libcli/nbt/namerefresh.c */
+
+struct nbt_name_request *nbt_name_refresh_send(struct nbt_name_socket *nbtsock,
+ struct nbt_name_refresh *io);
+
+/* The following definitions come from ../libcli/nbt/namerelease.c */
+
+#undef _PRINTF_ATTRIBUTE
+#define _PRINTF_ATTRIBUTE(a1, a2)
+
+#endif /* _____LIBCLI_NBT_NBT_PROTO_H__ */
+
-/*
+/*
Unix SMB/CIFS implementation.
manipulate nbt name structures
Copyright (C) Andrew Tridgell 2005
-
+
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 "librpc/gen_ndr/ndr_nbt.h"
#include "librpc/gen_ndr/ndr_misc.h"
#include "system/locale.h"
-#include "param/param.h"
/* don't allow an unlimited number of name components */
#define MAX_COMPONENTS 10
/* break up name into a list of components */
for (num_components=0;num_components<MAX_COMPONENTS;num_components++) {
- uint8_t *component;
+ uint8_t *component = NULL;
NDR_CHECK(ndr_pull_component(ndr, &component, &offset, &max_offset));
if (component == NULL) break;
if (name) {
ndr_err = ndr_token_retrieve_cmp_fn(&ndr->nbt_string_list, s, &offset, (comparison_fn_t)strcmp, false);
if (NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
uint8_t b[2];
-
+
if (offset > 0x3FFF) {
return ndr_push_error(ndr, NDR_ERR_STRING,
"offset for nbt string label pointer %u[%08X] > 0x00003FFF",
c2 < 'A' || c2 > 'P') {
return false;
}
- name[i] = ((c1-'A')<<4) | (c2-'A');
+ name[i] = ((c1-'A')<<4) | (c2-'A');
}
name[i] = 0;
if (i == 16) {
for (;i>0 && name[i-1]==' ';i--) {
name[i-1] = 0;
}
-
+
return true;
}
/*
compress a name component
*/
-static uint8_t *compress_name(TALLOC_CTX *mem_ctx,
+static uint8_t *compress_name(TALLOC_CTX *mem_ctx,
const uint8_t *name, enum nbt_name_type type)
{
uint8_t *cname;
} else {
fullname = cname;
}
-
+
ndr_err = ndr_push_nbt_string(ndr, ndr_flags, (const char *)fullname);
return ndr_err;
n->scope = NULL;
n->type = type;
- if (is_ipaddress(name) || name == NULL) {
+ if ((name == NULL) || is_ipaddress(name)) {
n->name = "*SMBSERVER";
return;
}
return;
}
s = talloc_strndup(mem_ctx, name, PTR_DIFF(p, name));
- n->name = strupper_talloc(mem_ctx, s);
+ n->name = talloc_strdup_upper(mem_ctx, s);
return;
}
- n->name = strupper_talloc(mem_ctx, name);
+ n->name = talloc_strdup_upper(mem_ctx, name);
}
{
TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
char *ret;
- if (name->scope) {
+ if (name->scope) {
ret = talloc_asprintf(mem_ctx, "%s<%02x>-%s",
nbt_hex_encode(tmp_ctx, name->name),
- name->type,
+ name->type,
nbt_hex_encode(tmp_ctx, name->scope));
} else {
- ret = talloc_asprintf(mem_ctx, "%s<%02x>",
- nbt_hex_encode(tmp_ctx, name->name),
+ ret = talloc_asprintf(mem_ctx, "%s<%02x>",
+ nbt_hex_encode(tmp_ctx, name->name),
name->type);
}
talloc_free(tmp_ctx);
NDR_PULL_ALLOC_N(ndr, namebuf, namebuf_len);
NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, namebuf, namebuf_len));
- NDR_PULL_ALLOC(ndr, r);
+ NDR_PULL_ALLOC(ndr, r);
/* oh wow, what a nasty bug in windows ... */
if (namebuf[0] == 0x1b && namebuf_len >= 16) {
{
uint8_t *namebuf;
uint32_t namebuf_len;
- uint32_t name_len;
+ uint32_t _name_len;
uint32_t scope_len = 0;
if (r == NULL) {
return NDR_ERR_SUCCESS;
}
- name_len = strlen(r->name);
- if (name_len > 15) {
+ _name_len = strlen(r->name);
+ if (_name_len > 15) {
return ndr_push_error(ndr, NDR_ERR_STRING,
"wrepl_nbt_name longer as 15 chars: %s",
r->name);
-/*
+/*
Unix SMB/CIFS implementation.
low level socket handling for nbt requests
Copyright (C) Andrew Tridgell 2005
-
+
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 "lib/events/events.h"
#include "lib/util/dlinklist.h"
-#include "libcli/nbt/libnbt.h"
+#include "../libcli/nbt/libnbt.h"
#include "lib/socket/socket.h"
#include "librpc/gen_ndr/ndr_nbt.h"
#include "param/param.h"
destroy a pending request
*/
static int nbt_name_request_destructor(struct nbt_name_request *req)
-{
+{
if (req->state == NBT_REQUEST_SEND) {
DLIST_REMOVE(req->nbtsock->send_queue, req);
}
if (req->nbtsock->send_queue == NULL) {
EVENT_FD_NOT_WRITEABLE(req->nbtsock->fde);
}
- if (req->nbtsock->num_pending == 0 &&
+ if (req->nbtsock->num_pending == 0 &&
req->nbtsock->incoming.handler == NULL) {
EVENT_FD_NOT_READABLE(req->nbtsock->fde);
}
while ((req = nbtsock->send_queue)) {
size_t len;
-
+
len = req->encoded.length;
- status = socket_sendto(nbtsock->sock, &req->encoded, &len,
+ status = socket_sendto(nbtsock->sock, &req->encoded, &len,
req->dest);
- if (NT_STATUS_IS_ERR(status)) goto failed;
+ if (NT_STATUS_IS_ERR(status)) goto failed;
if (!NT_STATUS_IS_OK(status)) {
talloc_free(tmp_ctx);
static void nbt_name_socket_timeout(struct event_context *ev, struct timed_event *te,
struct timeval t, void *private)
{
- struct nbt_name_request *req = talloc_get_type(private,
+ struct nbt_name_request *req = talloc_get_type(private,
struct nbt_name_request);
if (req->num_retries != 0) {
req->num_retries--;
- req->te = event_add_timed(req->nbtsock->event_ctx, req,
+ req->te = event_add_timed(req->nbtsock->event_ctx, req,
timeval_add(&t, req->timeout, 0),
nbt_name_socket_timeout, req);
if (req->state != NBT_REQUEST_SEND) {
req->state = NBT_REQUEST_SEND;
- DLIST_ADD_END(req->nbtsock->send_queue, req,
+ DLIST_ADD_END(req->nbtsock->send_queue, req,
struct nbt_name_request *);
}
EVENT_FD_WRITEABLE(req->nbtsock->fde);
}
if (DEBUGLVL(10)) {
- DEBUG(10,("Received nbt packet of length %d from %s:%d\n",
+ DEBUG(10,("Received nbt packet of length %d from %s:%d\n",
(int)blob.length, src->addr, src->port));
NDR_PRINT_DEBUG(nbt_name_packet, packet);
}
}
/* find the matching request */
- req = (struct nbt_name_request *)idr_find(nbtsock->idr,
+ req = (struct nbt_name_request *)idr_find(nbtsock->idr,
packet->name_trn_id);
if (req == NULL) {
if (nbtsock->unexpected.handler) {
req->num_retries = 0;
req->received_wack = true;
/* although there can be a timeout in the packet, w2k3 screws it up,
- so better to set it ourselves */
+ so better to set it ourselves */
req->timeout = lp_parm_int(global_loadparm, NULL, "nbt", "wack_timeout", 30);
- req->te = event_add_timed(req->nbtsock->event_ctx, req,
+ req->te = event_add_timed(req->nbtsock->event_ctx, req,
timeval_current_ofs(req->timeout, 0),
nbt_name_socket_timeout, req);
talloc_free(tmp_ctx);
return;
}
-
+
req->replies = talloc_realloc(req, req->replies, struct nbt_name_reply, req->num_replies+1);
if (req->replies == NULL) {
static void nbt_name_socket_handler(struct event_context *ev, struct fd_event *fde,
uint16_t flags, void *private)
{
- struct nbt_name_socket *nbtsock = talloc_get_type(private,
+ struct nbt_name_socket *nbtsock = talloc_get_type(private,
struct nbt_name_socket);
if (flags & EVENT_FD_WRITE) {
nbt_name_socket_send(nbtsock);
- }
+ }
if (flags & EVENT_FD_READ) {
nbt_name_socket_recv(nbtsock);
}
initialise a nbt_name_socket. The event_ctx is optional, if provided
then operations will use that event context
*/
-_PUBLIC_ struct nbt_name_socket *nbt_name_socket_init(TALLOC_CTX *mem_ctx,
+_PUBLIC_ struct nbt_name_socket *nbt_name_socket_init(TALLOC_CTX *mem_ctx,
struct event_context *event_ctx,
struct smb_iconv_convenience *iconv_convenience)
{
nbtsock->unexpected.handler = NULL;
nbtsock->iconv_convenience = iconv_convenience;
- nbtsock->fde = event_add_fd(nbtsock->event_ctx, nbtsock,
+ nbtsock->fde = event_add_fd(nbtsock->event_ctx, nbtsock,
socket_get_fd(nbtsock->sock), 0,
nbt_name_socket_handler, nbtsock);
-
+
return nbtsock;
failed:
/*
send off a nbt name request
*/
-struct nbt_name_request *nbt_name_request_send(struct nbt_name_socket *nbtsock,
+struct nbt_name_request *nbt_name_request_send(struct nbt_name_socket *nbtsock,
struct socket_address *dest,
struct nbt_name_packet *request,
int timeout, int retries,
id = idr_get_new_random(req->nbtsock->idr, req, UINT16_MAX);
} else {
if (idr_find(req->nbtsock->idr, request->name_trn_id)) goto failed;
- id = idr_get_new_above(req->nbtsock->idr, req, request->name_trn_id,
+ id = idr_get_new_above(req->nbtsock->idr, req, request->name_trn_id,
UINT16_MAX);
}
if (id == -1) goto failed;
request->name_trn_id = id;
req->name_trn_id = id;
- req->te = event_add_timed(nbtsock->event_ctx, req,
+ req->te = event_add_timed(nbtsock->event_ctx, req,
timeval_current_ofs(req->timeout, 0),
nbt_name_socket_timeout, req);
-
- talloc_set_destructor(req, nbt_name_request_destructor);
- ndr_err = ndr_push_struct_blob(&req->encoded, req,
+ talloc_set_destructor(req, nbt_name_request_destructor);
+
+ ndr_err = ndr_push_struct_blob(&req->encoded, req,
req->nbtsock->iconv_convenience,
request,
(ndr_push_flags_fn_t)ndr_push_nbt_name_packet);
DLIST_ADD_END(nbtsock->send_queue, req, struct nbt_name_request *);
if (DEBUGLVL(10)) {
- DEBUG(10,("Queueing nbt packet to %s:%d\n",
+ DEBUG(10,("Queueing nbt packet to %s:%d\n",
req->dest->addr, req->dest->port));
NDR_PRINT_DEBUG(nbt_name_packet, request);
}
/*
send off a nbt name reply
*/
-_PUBLIC_ NTSTATUS nbt_name_reply_send(struct nbt_name_socket *nbtsock,
+_PUBLIC_ NTSTATUS nbt_name_reply_send(struct nbt_name_socket *nbtsock,
struct socket_address *dest,
struct nbt_name_packet *request)
{
req->state = NBT_REQUEST_SEND;
req->is_reply = true;
- talloc_set_destructor(req, nbt_name_request_destructor);
+ talloc_set_destructor(req, nbt_name_request_destructor);
if (DEBUGLVL(10)) {
- NDR_PRINT_DEBUG(nbt_name_packet, request);
+ NDR_PRINT_DEBUG(nbt_name_packet, request);
}
- ndr_err = ndr_push_struct_blob(&req->encoded, req,
+ ndr_err = ndr_push_struct_blob(&req->encoded, req,
req->nbtsock->iconv_convenience,
request,
(ndr_push_flags_fn_t)ndr_push_nbt_name_packet);
setup a handler for incoming requests
*/
_PUBLIC_ NTSTATUS nbt_set_incoming_handler(struct nbt_name_socket *nbtsock,
- void (*handler)(struct nbt_name_socket *, struct nbt_name_packet *,
+ void (*handler)(struct nbt_name_socket *, struct nbt_name_packet *,
struct socket_address *),
void *private)
{
nbtsock->incoming.handler = handler;
- nbtsock->incoming.private = private;
+ nbtsock->incoming.private_data = private;
EVENT_FD_READABLE(nbtsock->fde);
return NT_STATUS_OK;
}
-/*
+/*
Unix SMB/CIFS implementation.
Samba utility functions
Copyright © Jelmer Vernooij <jelmer@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.
-
+
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 <Python.h>
#include "libcli/util/pyerrors.h"
-#include "libcli/nbt/libnbt.h"
+#include "../libcli/nbt/libnbt.h"
#include "lib/events/events.h"
#include "param/param.h"
return NULL;
ev = s4_event_context_init(ret->mem_ctx);
- ret->socket = nbt_name_socket_init(ret->mem_ctx, ev, lp_iconv_convenience(global_loadparm));
+ ret->socket = nbt_name_socket_init(ret->mem_ctx, ev, lp_iconv_convenience(global_loadparm));
return (PyObject *)ret;
}
*dest_addr = PyString_AsString(obj);
*dest_port = NBT_NAME_SERVICE_PORT;
return true;
- }
+ }
if (PyTuple_Check(obj)) {
if (PyTuple_Size(obj) < 1) {
PyErr_SetString(PyExc_TypeError, "Destination tuple size invalid");
return false;
}
-
+
if (!PyString_Check(PyTuple_GetItem(obj, 0))) {
PyErr_SetString(PyExc_TypeError, "Destination tuple first element not string");
return false;
return false;
}
-static PyObject *PyObject_FromNBTName(struct nbt_name_socket *socket, struct smb_iconv_convenience *ic,
+static PyObject *PyObject_FromNBTName(struct nbt_name_socket *socket, struct smb_iconv_convenience *ic,
struct nbt_name *name)
{
if (name->scope) {
io.in.timeout = 0;
io.in.retries = 3;
- if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|bbii:query_name",
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|bbii:query_name",
discard_const_p(char *, kwnames),
- &py_name, &py_dest,
- &io.in.broadcast, &io.in.wins_lookup,
+ &py_name, &py_dest,
+ &io.in.broadcast, &io.in.wins_lookup,
&io.in.timeout, &io.in.retries)) {
return NULL;
}
Py_DECREF(ret);
return NULL;
}
-
+
for (i = 0; i < io.out.num_addrs; i++) {
PyList_SetItem(reply_addrs, i, PyString_FromString(io.out.reply_addrs[i]));
}
io.in.timeout = 0;
io.in.retries = 0;
- if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|ii:name_status",
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|ii:name_status",
discard_const_p(char *, kwnames),
- &py_name, &py_dest,
+ &py_name, &py_dest,
&io.in.timeout, &io.in.retries)) {
return NULL;
}
py_names = PyList_New(io.out.status.num_names);
for (i = 0; i < io.out.status.num_names; i++) {
- PyList_SetItem(py_names, i, Py_BuildValue("(sii)",
+ PyList_SetItem(py_names, i, Py_BuildValue("(sii)",
io.out.status.names[i].name,
- io.out.status.names[i].nb_flags,
+ io.out.status.names[i].nb_flags,
io.out.status.names[i].type));
}
struct nbt_name_register io;
NTSTATUS status;
- const char *kwnames[] = { "name", "address", "dest", "register_demand", "broadcast",
+ const char *kwnames[] = { "name", "address", "dest", "register_demand", "broadcast",
"multi_homed", "ttl", "timeout", "retries", NULL };
io.in.broadcast = true;
io.in.timeout = 0;
io.in.retries = 0;
- if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OsO|bbbiii:query_name",
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OsO|bbbiii:query_name",
discard_const_p(char *, kwnames),
- &py_name, &io.in.address, &py_dest,
- &io.in.register_demand,
- &io.in.broadcast, &io.in.multi_homed,
+ &py_name, &io.in.address, &py_dest,
+ &io.in.register_demand,
+ &io.in.broadcast, &io.in.multi_homed,
&io.in.ttl, &io.in.timeout, &io.in.retries)) {
return NULL;
}
struct nbt_name_refresh io;
NTSTATUS status;
- const char *kwnames[] = { "name", "address", "dest", "nb_flags", "broadcast",
+ const char *kwnames[] = { "name", "address", "dest", "nb_flags", "broadcast",
"ttl", "timeout", "retries", NULL };
io.in.broadcast = true;
io.in.timeout = 0;
io.in.retries = 0;
- if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OsO|ibiii:query_name",
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OsO|ibiii:query_name",
discard_const_p(char *, kwnames),
- &py_name, &io.in.address, &py_dest,
- &io.in.nb_flags,
- &io.in.broadcast,
+ &py_name, &io.in.address, &py_dest,
+ &io.in.nb_flags,
+ &io.in.broadcast,
&io.in.ttl, &io.in.timeout, &io.in.retries)) {
return NULL;
}
}
static PyMethodDef py_nbt_methods[] = {
- { "query_name", (PyCFunction)py_nbt_name_query, METH_VARARGS|METH_KEYWORDS,
+ { "query_name", (PyCFunction)py_nbt_name_query, METH_VARARGS|METH_KEYWORDS,
"S.query_name(name, dest, broadcast=True, wins=False, timeout=0, retries=3) -> (reply_from, name, reply_addr)\n"
"Query for a NetBIOS name" },
{ "register_name", (PyCFunction)py_nbt_name_register, METH_VARARGS|METH_KEYWORDS,
-/*
+/*
Unix SMB/CIFS implementation.
CLDAP server structures
Copyright (C) Andrew Bartlett <abartlet@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.
-
+
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/>.
*/
/* parser auto-generated by pidl, then hand-modified by abartlet */
#include "includes.h"
-#include "libcli/netlogon.h"
+#include "../libcli/netlogon.h"
+
/* Manually modified to handle the dom_sid being optional based on if it is present or all zero */
enum ndr_err_code ndr_push_NETLOGON_SAM_LOGON_REQUEST(struct ndr_push *ndr, int ndr_flags, const struct NETLOGON_SAM_LOGON_REQUEST *r)
{
--- /dev/null
+#ifndef _____LIBCLI_NDR_NETLOGON_PROTO_H__
+#define _____LIBCLI_NDR_NETLOGON_PROTO_H__
+
+#undef _PRINTF_ATTRIBUTE
+#define _PRINTF_ATTRIBUTE(a1, a2) PRINTF_ATTRIBUTE(a1, a2)
+/* This file was automatically generated by mkproto.pl. DO NOT EDIT */
+
+/* this file contains prototypes for functions that are private
+ * to this subsystem or library. These functions should not be
+ * used outside this particular subsystem! */
+
+
+/* The following definitions come from ../libcli/ndr_netlogon.c */
+
+enum ndr_err_code ndr_push_NETLOGON_SAM_LOGON_REQUEST(struct ndr_push *ndr, int ndr_flags, const struct NETLOGON_SAM_LOGON_REQUEST *r);
+enum ndr_err_code ndr_pull_NETLOGON_SAM_LOGON_REQUEST(struct ndr_pull *ndr, int ndr_flags, struct NETLOGON_SAM_LOGON_REQUEST *r);
+enum ndr_err_code ndr_push_NETLOGON_SAM_LOGON_RESPONSE_EX_with_flags(struct ndr_push *ndr, int ndr_flags, const struct NETLOGON_SAM_LOGON_RESPONSE_EX *r);
+enum ndr_err_code ndr_pull_NETLOGON_SAM_LOGON_RESPONSE_EX_with_flags(struct ndr_pull *ndr, int ndr_flags, struct NETLOGON_SAM_LOGON_RESPONSE_EX *r,
+ uint32_t nt_version_flags);
+#undef _PRINTF_ATTRIBUTE
+#define _PRINTF_ATTRIBUTE(a1, a2)
+
+#endif /* _____LIBCLI_NDR_NETLOGON_PROTO_H__ */
+
-/*
+/*
Unix SMB/CIFS implementation.
CLDAP server structures
Copyright (C) Andrew Bartlett <abartlet@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.
-
+
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/netlogon.h"
+#include "../libcli/netlogon.h"
+
+#undef DEBUG
+#define DEBUG(x, y)
+#undef DEBUGLVL
+#define DEBUGLVL(x) false
+#undef DEBUGLEVEL
+#define DEBUGLEVEL 0
-NTSTATUS push_netlogon_samlogon_response(DATA_BLOB *data, TALLOC_CTX *mem_ctx,
+NTSTATUS push_netlogon_samlogon_response(DATA_BLOB *data, TALLOC_CTX *mem_ctx,
struct smb_iconv_convenience *iconv_convenience,
- struct netlogon_samlogon_response *response)
+ struct netlogon_samlogon_response *response)
{
enum ndr_err_code ndr_err;
if (response->ntver == NETLOGON_NT_VERSION_1) {
- ndr_err = ndr_push_struct_blob(data, mem_ctx,
+ ndr_err = ndr_push_struct_blob(data, mem_ctx,
iconv_convenience,
- &response->nt4,
+ &response->data.nt4,
(ndr_push_flags_fn_t)ndr_push_NETLOGON_SAM_LOGON_RESPONSE_NT40);
} else if (response->ntver & NETLOGON_NT_VERSION_5EX) {
- ndr_err = ndr_push_struct_blob(data, mem_ctx,
+ ndr_err = ndr_push_struct_blob(data, mem_ctx,
iconv_convenience,
- &response->nt5_ex,
+ &response->data.nt5_ex,
(ndr_push_flags_fn_t)ndr_push_NETLOGON_SAM_LOGON_RESPONSE_EX_with_flags);
} else if (response->ntver & NETLOGON_NT_VERSION_5) {
- ndr_err = ndr_push_struct_blob(data, mem_ctx,
+ ndr_err = ndr_push_struct_blob(data, mem_ctx,
iconv_convenience,
- &response->nt5,
+ &response->data.nt5,
(ndr_push_flags_fn_t)ndr_push_NETLOGON_SAM_LOGON_RESPONSE);
} else {
DEBUG(0, ("Asked to push unknown netlogon response type 0x%02x\n", response->ntver));
return NT_STATUS_OK;
}
-NTSTATUS pull_netlogon_samlogon_response(DATA_BLOB *data, TALLOC_CTX *mem_ctx,
+NTSTATUS pull_netlogon_samlogon_response(DATA_BLOB *data, TALLOC_CTX *mem_ctx,
struct smb_iconv_convenience *iconv_convenience,
struct netlogon_samlogon_response *response)
{
}
ntver = IVAL(data->data, data->length - 8);
-
+
if (ntver == NETLOGON_NT_VERSION_1) {
- ndr_err = ndr_pull_struct_blob_all(data, mem_ctx,
+ ndr_err = ndr_pull_struct_blob_all(data, mem_ctx,
iconv_convenience,
- &response->nt4,
+ &response->data.nt4,
(ndr_pull_flags_fn_t)ndr_pull_NETLOGON_SAM_LOGON_RESPONSE_NT40);
response->ntver = NETLOGON_NT_VERSION_1;
+ if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && DEBUGLEVEL >= 10) {
+ NDR_PRINT_DEBUG(NETLOGON_SAM_LOGON_RESPONSE_NT40,
+ &response->data.nt4);
+ }
+
} else if (ntver & NETLOGON_NT_VERSION_5EX) {
struct ndr_pull *ndr;
ndr = ndr_pull_init_blob(data, mem_ctx, iconv_convenience);
if (!ndr) {
return NT_STATUS_NO_MEMORY;
}
- ndr_err = ndr_pull_NETLOGON_SAM_LOGON_RESPONSE_EX_with_flags(ndr, NDR_SCALARS|NDR_BUFFERS, &response->nt5_ex, ntver);
+ ndr_err = ndr_pull_NETLOGON_SAM_LOGON_RESPONSE_EX_with_flags(
+ ndr, NDR_SCALARS|NDR_BUFFERS, &response->data.nt5_ex,
+ ntver);
if (ndr->offset < ndr->data_size) {
ndr_err = ndr_pull_error(ndr, NDR_ERR_UNREAD_BYTES,
"not all bytes consumed ofs[%u] size[%u]",
ndr->offset, ndr->data_size);
}
response->ntver = NETLOGON_NT_VERSION_5EX;
+ if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && DEBUGLEVEL >= 10) {
+ NDR_PRINT_DEBUG(NETLOGON_SAM_LOGON_RESPONSE_EX,
+ &response->data.nt5_ex);
+ }
} else if (ntver & NETLOGON_NT_VERSION_5) {
- ndr_err = ndr_pull_struct_blob_all(data, mem_ctx,
+ ndr_err = ndr_pull_struct_blob_all(data, mem_ctx,
iconv_convenience,
- &response->nt5,
+ &response->data.nt5,
(ndr_pull_flags_fn_t)ndr_pull_NETLOGON_SAM_LOGON_RESPONSE);
response->ntver = NETLOGON_NT_VERSION_5;
+ if (NDR_ERR_CODE_IS_SUCCESS(ndr_err) && DEBUGLEVEL >= 10) {
+ NDR_PRINT_DEBUG(NETLOGON_SAM_LOGON_RESPONSE,
+ &response->data.nt5);
+ }
} else {
DEBUG(2,("failed to parse netlogon response of type 0x%02x - unknown response type\n",
ntver));
dump_data(10, data->data, data->length);
return ndr_map_error2ntstatus(ndr_err);
}
+
return NT_STATUS_OK;
}
break;
case NETLOGON_NT_VERSION_5:
ZERO_STRUCT(response_5_ex);
- response_5_ex.command = response->nt5.command;
- response_5_ex.pdc_name = response->nt5.pdc_name;
- response_5_ex.user_name = response->nt5.user_name;
- response_5_ex.domain = response->nt5.domain_name;
- response_5_ex.domain_uuid = response->nt5.domain_uuid;
- response_5_ex.forest = response->nt5.forest;
- response_5_ex.dns_domain = response->nt5.dns_domain;
- response_5_ex.pdc_dns_name = response->nt5.pdc_dns_name;
- response_5_ex.sockaddr.pdc_ip = response->nt5.pdc_ip;
- response_5_ex.server_type = response->nt5.server_type;
- response_5_ex.nt_version = response->nt5.nt_version;
- response_5_ex.lmnt_token = response->nt5.lmnt_token;
- response_5_ex.lm20_token = response->nt5.lm20_token;
+ response_5_ex.command = response->data.nt5.command;
+ response_5_ex.pdc_name = response->data.nt5.pdc_name;
+ response_5_ex.user_name = response->data.nt5.user_name;
+ response_5_ex.domain = response->data.nt5.domain_name;
+ response_5_ex.domain_uuid = response->data.nt5.domain_uuid;
+ response_5_ex.forest = response->data.nt5.forest;
+ response_5_ex.dns_domain = response->data.nt5.dns_domain;
+ response_5_ex.pdc_dns_name = response->data.nt5.pdc_dns_name;
+ response_5_ex.sockaddr.pdc_ip = response->data.nt5.pdc_ip;
+ response_5_ex.server_type = response->data.nt5.server_type;
+ response_5_ex.nt_version = response->data.nt5.nt_version;
+ response_5_ex.lmnt_token = response->data.nt5.lmnt_token;
+ response_5_ex.lm20_token = response->data.nt5.lm20_token;
response->ntver = NETLOGON_NT_VERSION_5EX;
- response->nt5_ex = response_5_ex;
+ response->data.nt5_ex = response_5_ex;
break;
-
+
case NETLOGON_NT_VERSION_1:
ZERO_STRUCT(response_5_ex);
- response_5_ex.command = response->nt4.command;
- response_5_ex.pdc_name = response->nt4.server;
- response_5_ex.user_name = response->nt4.user_name;
- response_5_ex.domain = response->nt4.domain;
- response_5_ex.nt_version = response->nt4.nt_version;
- response_5_ex.lmnt_token = response->nt4.lmnt_token;
- response_5_ex.lm20_token = response->nt4.lm20_token;
+ response_5_ex.command = response->data.nt4.command;
+ response_5_ex.pdc_name = response->data.nt4.server;
+ response_5_ex.user_name = response->data.nt4.user_name;
+ response_5_ex.domain = response->data.nt4.domain;
+ response_5_ex.nt_version = response->data.nt4.nt_version;
+ response_5_ex.lmnt_token = response->data.nt4.lmnt_token;
+ response_5_ex.lm20_token = response->data.nt4.lm20_token;
response->ntver = NETLOGON_NT_VERSION_5EX;
- response->nt5_ex = response_5_ex;
+ response->data.nt5_ex = response_5_ex;
break;
}
return;
}
-NTSTATUS push_nbt_netlogon_response(DATA_BLOB *data, TALLOC_CTX *mem_ctx,
+NTSTATUS push_nbt_netlogon_response(DATA_BLOB *data, TALLOC_CTX *mem_ctx,
struct smb_iconv_convenience *iconv_convenience,
- struct nbt_netlogon_response *response)
+ struct nbt_netlogon_response *response)
{
NTSTATUS status = NT_STATUS_INVALID_NETWORK_RESPONSE;
enum ndr_err_code ndr_err;
switch (response->response_type) {
case NETLOGON_GET_PDC:
- ndr_err = ndr_push_struct_blob(data, mem_ctx, iconv_convenience, &response->get_pdc,
+ ndr_err = ndr_push_struct_blob(data, mem_ctx,
+ iconv_convenience,
+ &response->data.get_pdc,
(ndr_push_flags_fn_t)ndr_push_nbt_netlogon_response_from_pdc);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
status = ndr_map_error2ntstatus(ndr_err);
status = NT_STATUS_OK;
break;
case NETLOGON_SAMLOGON:
- status = push_netlogon_samlogon_response(data, mem_ctx, iconv_convenience, &response->samlogon);
+ status = push_netlogon_samlogon_response(
+ data, mem_ctx, iconv_convenience,
+ &response->data.samlogon);
break;
}
return status;
}
-NTSTATUS pull_nbt_netlogon_response(DATA_BLOB *data, TALLOC_CTX *mem_ctx,
+NTSTATUS pull_nbt_netlogon_response(DATA_BLOB *data, TALLOC_CTX *mem_ctx,
struct smb_iconv_convenience *iconv_convenience,
- struct nbt_netlogon_response *response)
+ struct nbt_netlogon_response *response)
{
NTSTATUS status = NT_STATUS_INVALID_NETWORK_RESPONSE;
enum netlogon_command command;
switch (command) {
case NETLOGON_RESPONSE_FROM_PDC:
- ndr_err = ndr_pull_struct_blob_all(data, mem_ctx, iconv_convenience, &response->get_pdc,
+ ndr_err = ndr_pull_struct_blob_all(data, mem_ctx,
+ iconv_convenience,
+ &response->data.get_pdc,
(ndr_pull_flags_fn_t)ndr_pull_nbt_netlogon_response_from_pdc);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
status = ndr_map_error2ntstatus(ndr_err);
case LOGON_SAM_LOGON_RESPONSE_EX:
case LOGON_SAM_LOGON_PAUSE_RESPONSE_EX:
case LOGON_SAM_LOGON_USER_UNKNOWN_EX:
- status = pull_netlogon_samlogon_response(data, mem_ctx, iconv_convenience, &response->samlogon);
+ status = pull_netlogon_samlogon_response(
+ data, mem_ctx, iconv_convenience,
+ &response->data.samlogon);
response->response_type = NETLOGON_SAMLOGON;
break;
-
+
/* These levels are queries, not responses */
case LOGON_PRIMARY_QUERY:
case NETLOGON_ANNOUNCE_UAS:
-/*
+/*
Unix SMB/CIFS implementation.
CLDAP server structures
Copyright (C) Andrew Bartlett <abartlet@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.
-
+
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/>.
*/
struct NETLOGON_SAM_LOGON_RESPONSE_NT40 nt4;
struct NETLOGON_SAM_LOGON_RESPONSE nt5;
struct NETLOGON_SAM_LOGON_RESPONSE_EX nt5_ex;
- };
+ } data;
};
union {
struct nbt_netlogon_response_from_pdc get_pdc;
struct netlogon_samlogon_response samlogon;
- };
+ } data;
};
-#include "libcli/netlogon_proto.h"
-#include "libcli/ndr_netlogon_proto.h"
+#include "../libcli/netlogon_proto.h"
+#include "../libcli/ndr_netlogon_proto.h"
#endif /* __CLDAP_SERVER_PROTO_H__ */
--- /dev/null
+#ifndef _____LIBCLI_NETLOGON_PROTO_H__
+#define _____LIBCLI_NETLOGON_PROTO_H__
+
+#undef _PRINTF_ATTRIBUTE
+#define _PRINTF_ATTRIBUTE(a1, a2) PRINTF_ATTRIBUTE(a1, a2)
+/* This file was automatically generated by mkproto.pl. DO NOT EDIT */
+
+/* this file contains prototypes for functions that are private
+ * to this subsystem or library. These functions should not be
+ * used outside this particular subsystem! */
+
+
+/* The following definitions come from ../libcli/netlogon.c */
+
+NTSTATUS push_netlogon_samlogon_response(DATA_BLOB *data, TALLOC_CTX *mem_ctx,
+ struct smb_iconv_convenience *iconv_convenience,
+ struct netlogon_samlogon_response *response);
+NTSTATUS pull_netlogon_samlogon_response(DATA_BLOB *data, TALLOC_CTX *mem_ctx,
+ struct smb_iconv_convenience *iconv_convenience,
+ struct netlogon_samlogon_response *response);
+void map_netlogon_samlogon_response(struct netlogon_samlogon_response *response);
+NTSTATUS push_nbt_netlogon_response(DATA_BLOB *data, TALLOC_CTX *mem_ctx,
+ struct smb_iconv_convenience *iconv_convenience,
+ struct nbt_netlogon_response *response);
+NTSTATUS pull_nbt_netlogon_response(DATA_BLOB *data, TALLOC_CTX *mem_ctx,
+ struct smb_iconv_convenience *iconv_convenience,
+ struct nbt_netlogon_response *response);
+#undef _PRINTF_ATTRIBUTE
+#define _PRINTF_ATTRIBUTE(a1, a2)
+
+#endif /* _____LIBCLI_NETLOGON_PROTO_H__ */
+
- warn when union instances don't have a discriminant
-- EJS output backend shouldn't use the NDR levels stuff but instead
- as the "C levels" and NDR levels don't necessarily match.
-
- true multiple dimension array / strings in arrays support
- compatibility mode for generating MIDL-readable data:
PIDL = $(PERL) $(pidldir)/pidl
$(pidldir)/Makefile: $(pidldir)/Makefile.PL
- cd $(pidldir) && $(PERL) Makefile.PL PREFIX=$(prefix)
+ @cd $(pidldir) && $(PERL) Makefile.PL PREFIX=$(prefix)
pidl-testcov: $(pidldir)/Makefile
cd $(pidldir) && cover -test
installpidl:: $(pidldir)/Makefile
- $(MAKE) -C $(pidldir) install_vendor VENDORPREFIX=$(prefix) \
+ @$(MAKE) -C $(pidldir) install_vendor VENDORPREFIX=$(prefix) \
INSTALLVENDORLIB=$(datarootdir)/perl5 \
INSTALLVENDORBIN=$(bindir) \
INSTALLVENDORSCRIPT=$(bindir) \
if ($x->{TYPE} eq "IMPORT") {
foreach my $idl_file (@{$x->{PATHS}}) {
$idl_file = unmake_str($idl_file);
+ unless (-f "$basedir/$idl_file") {
+ error($x, "Unable to open include file `$idl_file'");
+ next;
+ }
my $podl = Parse::Pidl::IDL::parse_file("$basedir/$idl_file", $opt_incdirs);
if (defined(@$podl)) {
require Parse::Pidl::Typelist;
pidl "\treturn false;";
pidl "}";
pidl "";
- pidl "pull = ndr_pull_init_blob(&blob, r);";
+ pidl "pull = ndr_pull_init_blob(&blob, r, NULL);";
pidl "if (pull == NULL) {";
pidl "\ttalloc_free(r);";
pidl "\treturn false;";
$self->pidl("{");
$self->indent;
$self->pidl("PyObject *m;");
+ $self->pidl("NTSTATUS status;");
$self->pidl("");
foreach (@{$self->{ready_types}}) {
$self->pidl("PyModule_AddObject(m, \"$object_name\", $c_name);");
}
+ $self->pidl("");
+ $self->pidl("status = dcerpc_init();");
+ $self->pidl("if (!NT_STATUS_IS_OK(status)) {");
+ $self->indent;
+ $self->pidl("PyErr_SetNTSTATUS(status);");
+ $self->pidl("return;");
+ $self->deindent;
+ $self->pidl("}");
+
$self->deindent;
$self->pidl("}");
return ($self->{res_hdr}, $self->{res});
pidl --help
-pidl [--outputdir[=OUTNAME]] [--includedir DIR...] [--parse-idl-tree] [--dump-idl-tree] [--dump-ndr-tree] [--header[=OUTPUT]] [--ejs[=OUTPUT]] [--python[=OUTPUT]] [--swig[=OUTPUT]] [--ndr-parser[=OUTPUT]] [--client] [--server] [--warn-compat] [--quiet] [--verbose] [--template] [--ws-parser[=OUTPUT]] [--diff] [--dump-idl] [--tdr-parser[=OUTPUT]] [--samba3-ndr-client[=OUTPUT]] [--samba3-ndr-server[=OUTPUT]] [--typelib=[OUTPUT]] [<idlfile>.idl]...
+pidl [--outputdir[=OUTNAME]] [--includedir DIR...] [--parse-idl-tree] [--dump-idl-tree] [--dump-ndr-tree] [--header[=OUTPUT]] [--python[=OUTPUT]] [--swig[=OUTPUT]] [--ndr-parser[=OUTPUT]] [--client] [--server] [--warn-compat] [--quiet] [--verbose] [--template] [--ws-parser[=OUTPUT]] [--diff] [--dump-idl] [--tdr-parser[=OUTPUT]] [--samba3-ndr-client[=OUTPUT]] [--samba3-ndr-server[=OUTPUT]] [--typelib=[OUTPUT]] [<idlfile>.idl]...
=head1 DESCRIPTION
my($opt_tdr_parser);
my($opt_ws_parser);
my($opt_swig);
-my($opt_ejs);
my($opt_python);
my($opt_quiet) = 0;
my($opt_outputdir) = '.';
--ndr-parser[=OUTFILE] create a C NDR parser [ndr_BASENAME.c]
--client[=OUTFILE] create a C NDR client [ndr_BASENAME_c.c]
--tdr-parser[=OUTFILE] create a C TDR parser [tdr_BASENAME.c]
- --ejs[=OUTFILE] create ejs wrapper file [BASENAME_ejs.c]
--python[=OUTFILE] create python wrapper file [py_BASENAME.c]
--swig[=OUTFILE] create swig wrapper file [BASENAME.i]
--server[=OUTFILE] create server boilerplate [ndr_BASENAME_s.c]
'ndr-parser:s' => \$opt_ndr_parser,
'client:s' => \$opt_client,
'ws-parser:s' => \$opt_ws_parser,
- 'ejs' => \$opt_ejs,
'python' => \$opt_python,
'diff' => \$opt_diff,
'swig:s' => \$opt_swig,
defined($opt_server) or
defined($opt_header) or
defined($opt_ndr_parser) or
- defined($opt_ejs) or
defined($opt_python) or
defined($opt_dump_ndr_tree) or
defined($opt_samba3_header) or
FileSave($filename, $code);
}
- if (defined($opt_ejs)) {
- require Parse::Pidl::Samba4::EJS;
- my $generator = new Parse::Pidl::Samba4::EJS();
- my ($hdr,$prsr) = $generator->Parse($ndr, $h_filename);
- FileSave("$outputdir/ndr_$basename\_ejs.c", $prsr);
- FileSave("$outputdir/ndr_$basename\_ejs.h", $hdr);
- }
-
if (defined($opt_python)) {
require Parse::Pidl::Samba4::Python;
my $generator = new Parse::Pidl::Samba4::Python();
Samba4 Programming Guide
-------------------------
+========================
+
+.. contents::
The internals of Samba4 are quite different from previous versions of
Samba, so even if you are an experienced Samba developer please take
Static data is evil as it has the following consequences:
- it makes code much less likely to be thread-safe
- it makes code much less likely to be recursion-safe
-- it leads to subtle side effects when the same code is called from
- multiple places
+- it leads to subtle side effects when the same code is called from multiple places
- doesn't play well with shared libraries or plugins
Static data is particularly evil in library code (such as our internal
The same rule applies to strings. In many places in the SMB and MSRPC
protocols complex strings are used on the wire, with complex rules
about padding, format, alighment, termination etc. None of that
-information is useful to a high level calling routine or to a backend
-- its all just so much wire fluff. So, in Samba4 these strings are
-just "char *" and are always in our internal multi-byte format (which
+information is useful to a high level calling routine or to a backend - its
+all just so much wire fluff. So, in Samba4 these strings are
+just "char \*" and are always in our internal multi-byte format (which
is usually UTF8). It is up to the parse functions to worry about
translating the format and getting the padding right.
The various handles that are used in the RPC servers should be created and
fetch using the dcesrv_handle_* functions.
-Use dcesrv_handle_new(struct dcesrv_connection *, uint8 handle_type) to obtain
+Use dcesrv_handle_new(struct dcesrv_connection \*, uint8 handle_type) to obtain
a new handle of the specified type. Handle types are unique within each
pipe.
-The handle can later be fetched again using
-struct dcesrv_handle *dcesrv_handle_fetch(struct dcesrv_connection *dce_conn, struct policy_handle *p, uint8 handle_type)
-and destroyed by dcesrv_handle_destroy(struct dcesrv_handle *).
+The handle can later be fetched again using::
+
+ struct dcesrv_handle *dcesrv_handle_fetch(struct dcesrv_connection *dce_conn, struct policy_handle *p, uint8 handle_type)
+
+and destroyed by::
+
+ dcesrv_handle_destroy(struct dcesrv_handle *).
User data should be stored in the 'data' member of the dcesrv_handle struct.
no 137 resolution not possible
should not fallback to anon when pass supplied
should check pass-thu cap bit, and skip lots of tests
- possibly allow the test suite to say "allow oversized replies" for
- trans2 and other calls
+ possibly allow the test suite to say "allow oversized replies" for trans2 and other calls
handle servers that don't have the setattre call in torture
add max file coponent length test and max path len test
- check for alloc failure in all core reply.c and trans2.c code where
- allocation size depends on client parameter
+ check for alloc failure in all core reply.c and trans2.c code where allocation size depends on client parameter
case-insenstive idea:
all filenames on disk lowercase
OPT_KEYID=""
TOPDIR="`dirname $0`/.."
-VER_H="${TOPDIR}/source/include/version.h"
+VER_H="${TOPDIR}/source3/include/version.h"
function exitOnError
{
}
##
-## Parse the command line options
+## Parse the command line options
##
function parseOptions
rsync -av "${OPT_DOCSDIR}"/ docs/
exitOnError $? "Failed top copy docs from ${OPT_DOCSDIR}"
-
+
return 0
fi
##
## Main driver
##
-function main
+function main
{
parseOptions "$@"
exitOnError $? "Failed to parse options"
-
+
cd $TOPDIR
git-checkout ${OPT_BRANCH}
exitOnError $? "Invalid branch name \"${OPT_BRANCH}\""
- (cd source && ./script/mkversion.sh)
+ (cd source3 && ./script/mkversion.sh)
if [ ! -f $VER_H ]; then
exitOnError 1 "Failed to find ${VER_H}!"
fi
- version=`grep SAMBA_VERSION_OFFICIAL_STRING $VER_H | awk '{print $3}'`
- vendor_version=`grep SAMBA_VERSION_VENDOR_SUFFIX $VER_H | awk '{print $3}'`
+ version=`grep "define SAMBA_VERSION_OFFICIAL_STRING" $VER_H | awk '{print $3}'`
+ vendor_version=`grep "define SAMBA_VERSION_VENDOR_SUFFIX" $VER_H | awk '{print $3}'`
if [ -n "$vendor_version" ]; then
version="$version-$vendor_version"
fi
buildDocs
exitOnError $? "Failed to build documentation"
- ( cd source && ./autogen.sh )
+ ( cd source3 && ./autogen.sh )
cd ..
tar cf samba-${version}.tar --exclude=.git* --exclude=CVS --exclude=.svn samba-${version}
if ($self->{immediate}) {
print "$out\n";
} else {
- require Term::ReadKey;
- my ($wchar, $hchar, $wpixels, $hpixels) = Term::ReadKey::GetTerminalSize();
- foreach (1..$wchar) { $out.= " "; }
- print "\r".substr($out, 0, $wchar);
+ print "$out: ";
}
}
$out .= $self->{test_output}->{$name};
}
+ if (not $self->{immediate}) {
+ if (not $unexpected) {
+ $out .= " ok\n";
+ } else {
+ $out .= " " . uc($result) . "\n";
+ }
+ }
print $out;
}
unless ($unexpected) {
$self->{test_output}->{$self->{NAME}} = "";
+ if (not $self->{immediate}) {
+ if ($result eq "failure") { print "f"; }
+ elsif ($result eq "skip") { print "s"; }
+ elsif ($result eq "success") { print "."; }
+ else { print "?($result)"; }
+ }
return;
}
print $self->{test_output}->{$self->{NAME}};
$self->{test_output}->{$self->{NAME}} = "";
}
+
+ if (not $self->{immediate}) {
+ if ($result eq "error") { print "E"; }
+ elsif ($result eq "failure") { print "F"; }
+ elsif ($result eq "success") { print "S"; }
+ else { print "?"; }
+ }
}
sub summary($)
--expected-failures=FILE specify list of tests that is guaranteed to fail
Samba4 Specific:
- --ldap=openldap|fedora-ds back smbd onto specified ldap server
+ --ldap=openldap|fedora-ds back samba onto specified ldap server
Samba3 Specific:
--bindir=PATH path to binaries
}
}
prefix_pathvar("PKG_CONFIG_PATH", "$old_pwd/source4/bin/pkgconfig");
-# Required for smbscript:
-prefix_pathvar("PATH", "$old_pwd/source4/bin");
prefix_pathvar("PYTHONPATH", "$old_pwd/source4/bin/python");
if ($opt_socket_wrapper_keep_pcap) {
}
print CF "
private dir = $prefix_abs/client/private
- js include = $srcdir_abs/scripting/libjs
name resolve order = bcast
panic action = $srcdir_abs/script/gdb_backtrace \%PID\% \%PROG\%
max xmit = 32K
Welcome to the Samba4 Test environment '$testenv_name'
This matches the client environment used in make test
-smbd is pid `cat \$PIDDIR/smbd.pid`
+server is pid `cat \$PIDDIR/samba.pid`
Some useful environment variables:
TORTURE_OPTIONS=\$TORTURE_OPTIONS
if (defined($ENV{SMBD_OPTIONS})) {
$optarg.= " $ENV{SMBD_OPTIONS}";
}
- my $ret = system("$valgrind $self->{bindir}/smbd $optarg $env_vars->{CONFIGURATION} -M single -i --leak-report-full");
+ my $ret = system("$valgrind $self->{bindir}/samba $optarg $env_vars->{CONFIGURATION} -M single -i --leak-report-full");
if ($? == -1) {
- print "Unable to start smbd: $ret: $!\n";
+ print "Unable to start samba: $ret: $!\n";
exit 1;
}
unlink($env_vars->{SMBD_TEST_FIFO});
my $exit = $? >> 8;
if ( $ret == 0 ) {
- print "smbd exits with status $exit\n";
+ print "samba exits with status $exit\n";
} elsif ( $ret & 127 ) {
- print "smbd got signal ".($ret & 127)." and exits with $exit!\n";
+ print "samba got signal ".($ret & 127)." and exits with $exit!\n";
} else {
$ret = $? >> 8;
- print "smbd failed with status $exit!\n";
+ print "samba failed with status $exit!\n";
}
exit $exit;
}
{
my ($self, $prefix, $server_role, $netbiosname, $netbiosalias, $swiface, $password) = @_;
- my $smbd_loglevel = 1;
+ my $server_loglevel = 1;
my $username = "administrator";
my $domain = "SAMBADOMAIN";
my $realm = "SAMBA.EXAMPLE.COM";
lock dir = $lockdir
setup directory = $self->{setupdir}
modules dir = $self->{bindir}/modules
- js include = $srcdir/scripting/libjs
winbindd socket directory = $winbindd_socket_dir
winbindd privileged socket directory = $winbindd_privileged_socket_dir
ntp signd socket directory = $ntp_signd_socket_dir
ldb:nosync = true
#We don't want to pass our self-tests if the PAC code is wrong
gensec:require_pac = true
- log level = $smbd_loglevel
+ log level = $server_loglevel
[tmp]
path = $tmpdir
cifs:server = $netbiosname
cifs:share = tmp
#There is no username specified here, instead the client is expected
-#to log in with kerberos, and smbd will used delegated credentials.
+#to log in with kerberos, and the serverwill use delegated credentials.
[simple]
path = $tmpdir
$self->add_wins_config("$prefix/private") or
die("Unable to add wins configuration");
- $ret->{SMBD_TEST_FIFO} = "$prefix/smbd_test.fifo";
- $ret->{SMBD_TEST_LOG} = "$prefix/smbd_test.log";
+ $ret->{SMBD_TEST_FIFO} = "$prefix/server_test.fifo";
+ $ret->{SMBD_TEST_LOG} = "$prefix/server_test.log";
$ret->{SMBD_TEST_LOG_POS} = 0;
return $ret;
}
close(DATA);
- if (-f "$envvars->{PIDDIR}/smbd.pid" ) {
- open(IN, "<$envvars->{PIDDIR}/smbd.pid") or die("unable to open smbd pid file");
+ if (-f "$envvars->{PIDDIR}/samba.pid" ) {
+ open(IN, "<$envvars->{PIDDIR}/samba.pid") or die("unable to open server pid file");
$pid = <IN>;
close(IN);
# If it is still around, kill it
if ($count > 20) {
- print "smbd process $pid took more than $count seconds to exit, killing\n";
+ print "server process $pid took more than $count seconds to exit, killing\n";
kill 9, $pid;
}
}
CONFIGFILE = $(CONFIGDIR)/smb.conf
LMHOSTSFILE = $(CONFIGDIR)/lmhosts
CTDBDIR = @ctdbdir@
+NCALRPCDIR = @ncalrpcdir@
# This is where smbpasswd et al go
PRIVATEDIR = @privatedir@
-DLOGFILEBASE=\"$(LOGFILEBASE)\" \
-DSHLIBEXT=\"@SHLIBEXT@\" \
-DCTDBDIR=\"$(CTDBDIR)\" \
+ -DNCALRPCDIR=\"$(NCALRPCDIR)\" \
-DCONFIGDIR=\"$(CONFIGDIR)\" \
-DCODEPAGEDIR=\"$(CODEPAGEDIR)\" \
-DCACHEDIR=\"$(CACHEDIR)\" \
lib/async_sock.o \
$(TDB_LIB_OBJ) \
$(VERSION_OBJ) lib/charcnv.o lib/debug.o lib/fault.o \
- lib/interface.o lib/md4.o \
+ lib/interface.o ../lib/crypto/md4.o \
lib/pidfile.o \
lib/signal.o lib/system.o lib/sendfile.o lib/recvfile.o lib/time.o \
lib/ufc.o lib/genrand.o lib/username.o \
lib/util_pw.o lib/access.o lib/smbrun.o \
- lib/bitmap.o lib/crc32.o lib/dprintf.o \
+ lib/bitmap.o ../lib/crypto/crc32.o lib/dprintf.o \
lib/xfile.o lib/wins_srv.o $(UTIL_REG_OBJ) \
lib/util_str.o lib/clobber.o lib/util_sid.o lib/util_uuid.o \
lib/util_unistr.o lib/util_file.o lib/data_blob.o \
lib/substitute.o lib/fsusage.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/md5.o lib/hmacmd5.o lib/arc4.o lib/iconv.o \
+ ../lib/crypto/md5.o ../lib/crypto/hmacmd5.o lib/arc4.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 lib/ldap_escape.o @CHARSET_STATIC@ \
SECRETS_OBJ = passdb/secrets.o passdb/machine_sid.o
-LIBNBT_OBJ = libcli/nbt/nbtname.o \
+LIBNBT_OBJ = ../libcli/nbt/nbtname.o \
+ ../libcli/netlogon.o \
+ ../libcli/ndr_netlogon.o \
librpc/gen_ndr/ndr_nbt.o \
librpc/gen_ndr/ndr_svcctl.o
VFS_AIO_FORK_OBJ = modules/vfs_aio_fork.o
VFS_SYNCOPS_OBJ = modules/vfs_syncops.o
VFS_ACL_XATTR_OBJ = modules/vfs_acl_xattr.o
+VFS_SMB_TRAFFIC_ANALYZER_OBJ = modules/vfs_smb_traffic_analyzer.o
PLAINTEXT_AUTH_OBJ = auth/pampass.o auth/pass_check.o
AUTH_UNIX_OBJ = auth/auth_unix.o
AUTH_WINBIND_OBJ = auth/auth_winbind.o
AUTH_SCRIPT_OBJ = auth/auth_script.o
+AUTH_NETLOGOND_OBJ = auth/auth_netlogond.o
AUTH_OBJ = auth/auth.o @AUTH_STATIC@ auth/auth_util.o auth/token_util.o \
auth/auth_compat.o auth/auth_ntlmssp.o \
$(PARAM_OBJ) $(LIB_NONSMBD_OBJ) $(POPT_LIB_OBJ) \
$(LIBSAMBA_OBJ)
+TEST_LP_LOAD_OBJ = param/test_lp_load.o \
+ $(PARAM_OBJ) $(LIB_NONSMBD_OBJ) \
+ $(POPT_LIB_OBJ) $(LIBSAMBA_OBJ)
+
PASSWD_UTIL_OBJ = utils/passwd_util.o
SMBPASSWD_OBJ = utils/smbpasswd.o $(PASSWD_UTIL_OBJ) $(PASSCHANGE_OBJ) \
$(LIBSAMBA_OBJ) \
$(POPT_LIB_OBJ)
-TALLOCTORT_OBJ = @tallocdir@/testsuite.o $(PARAM_OBJ) $(LIB_NONSMBD_OBJ) \
- $(LIBSAMBA_OBJ)
+TALLOCTORT_OBJ = @tallocdir@/testsuite.o @tallocdir@/testsuite_main.o \
+ $(PARAM_OBJ) $(LIB_NONSMBD_OBJ) $(LIBSAMBA_OBJ)
REPLACETORT_OBJ = @libreplacedir@/test/testsuite.o \
@libreplacedir@/test/getifaddrs.o \
@libreplacedir@/test/os2_delete.o \
@libreplacedir@/test/strptime.o \
+ @libreplacedir@/test/main.o \
$(LIBREPLACE_OBJ)
NDRDUMP_OBJ = librpc/tools/ndrdump.o \
winbindd/idmap_hash/idmap_hash.o \
winbindd/idmap_hash/mapfile.o
+IDMAP_ADEX_OBJ = \
+ winbindd/idmap_adex/idmap_adex.o \
+ winbindd/idmap_adex/cell_util.o \
+ winbindd/idmap_adex/likewise_cell.o \
+ winbindd/idmap_adex/provider_unified.o \
+ winbindd/idmap_adex/gc_util.o \
+ winbindd/idmap_adex/domain_util.o
+
WINBINDD_OBJ1 = \
winbindd/winbindd.o \
winbindd/winbindd_user.o \
LDBMODIFY_OBJ = $(LDB_CMDLINE_OBJ) lib/ldb/tools/ldbmodify.o
WINBIND_KRB5_LOCATOR_OBJ1 = nsswitch/winbind_krb5_locator.o
-WINBIND_KRB5_LOCATOR_OBJ = $(WINBIND_KRB5_LOCATOR_OBJ1) $(WBCOMMON_OBJ) $(LIBREPLACE_OBJ)
+WINBIND_KRB5_LOCATOR_OBJ = $(WINBIND_KRB5_LOCATOR_OBJ1) $(LIBREPLACE_OBJ)
POPT_OBJ=../lib/popt/findme.o ../lib/popt/popt.o ../lib/popt/poptconfig.o \
../lib/popt/popthelp.o ../lib/popt/poptparse.o
pam_winbind: SHOWFLAGS bin/pam_winbind.@SHLIBEXT@
+gpext_modules:: $(GPEXT_MODULES)
+
torture:: SHOWFLAGS $(TORTURE_PROGS)
smbtorture : SHOWFLAGS bin/smbtorture@EXEEXT@
nsswitch/libwbclient/wbc_pwd.o \
nsswitch/libwbclient/wbc_idmap.o \
nsswitch/libwbclient/wbc_sid.o \
+ nsswitch/libwbclient/wbc_guid.o \
nsswitch/libwbclient/wbc_pam.o
LIBWBCLIENT_OBJ = $(LIBWBCLIENT_OBJ0) \
$(WBCOMMON_OBJ) \
$(LDAP_LIBS) $(KRB5LIBS) $(LIBS) $(LIBTALLOC_LIBS) $(LIBTDB_LIBS) \
@SONAMEFLAG@`basename $@`@NSSSONAMEVERSIONSUFFIX@
-bin/winbind_krb5_locator.@SHLIBEXT@: $(BINARY_PREREQS) $(WINBIND_KRB5_LOCATOR_OBJ)
+bin/winbind_krb5_locator.@SHLIBEXT@: $(BINARY_PREREQS) $(WINBIND_KRB5_LOCATOR_OBJ) @LIBWBCLIENT_SHARED@
@echo "Linking $@"
- @$(SHLD) $(LDSHFLAGS) -o $@ $(WINBIND_KRB5_LOCATOR_OBJ) \
+ @$(SHLD) $(LDSHFLAGS) -o $@ $(WINBIND_KRB5_LOCATOR_OBJ) $(WINBIND_LIBS) \
@SONAMEFLAG@`basename $@`
-bin/pam_winbind.@SHLIBEXT@: $(BINARY_PREREQS) $(PAM_WINBIND_OBJ)
+bin/pam_winbind.@SHLIBEXT@: $(BINARY_PREREQS) $(PAM_WINBIND_OBJ) @LIBTALLOC_SHARED@ @LIBWBCLIENT_SHARED@
@echo "Linking shared library $@"
@$(SHLD) $(LDSHFLAGS) -o $@ $(PAM_WINBIND_OBJ) -lpam @INIPARSERLIBS@ \
- $(PAM_WINBIND_EXTRA_LIBS) @SONAMEFLAG@`basename $@`
+ $(PAM_WINBIND_EXTRA_LIBS) $(LIBTALLOC_LIBS) $(WINBIND_LIBS) @SONAMEFLAG@`basename $@`
bin/builtin.@SHLIBEXT@: $(BINARY_PREREQS) $(AUTH_BUILTIN_OBJ)
@echo "Building plugin $@"
@echo "Building plugin $@"
@$(SHLD_MODULE) $(AUTH_SCRIPT_OBJ)
+bin/netlogond.@SHLIBEXT@: $(BINARY_PREREQS) $(AUTH_NETLOGOND_OBJ)
+ @echo "Building plugin $@"
+ @$(SHLD_MODULE) $(AUTH_NETLOGOND_OBJ)
+
bin/smbserver.@SHLIBEXT@: $(BINARY_PREREQS) $(AUTH_SERVER_OBJ)
@echo "Building plugin $@"
@$(SHLD_MODULE) $(AUTH_SERVER_OBJ)
@echo "Building plugin $@"
@$(SHLD_MODULE) $(IDMAP_HASH_OBJ)
+bin/adex.@SHLIBEXT@: $(BINARY_PREREQS) $(IDMAP_ADEX_OBJ)
+ @echo "Building plugin $@"
+ @$(SHLD_MODULE) $(IDMAP_ADEX_OBJ)
+
bin/tdb2.@SHLIBEXT@: $(BINARY_PREREQS) winbindd/idmap_tdb2.o
@echo "Building plugin $@"
@$(SHLD_MODULE) winbindd/idmap_tdb2.o
@echo "Building plugin $@"
@$(SHLD_MODULE) $(VFS_ACL_XATTR_OBJ)
+bin/smb_traffic_analyzer.@SHLIBEXT@: $(BINARY_PREREQS) $(VFS_SMB_TRAFFIC_ANALYZER_OBJ)
+ @echo "Building plugin $@"
+ @$(SHLD_MODULE) $(VFS_SMB_TRAFFIC_ANALYZER_OBJ)
+
bin/registry.@SHLIBEXT@: $(BINARY_PREREQS) libgpo/gpext/registry.o
@echo "Building plugin $@"
@$(SHLD_MODULE) libgpo/gpext/registry.o
@echo "Building plugin $@"
@$(SHLD_MODULE) libgpo/gpext/scripts.o
+bin/security.@SHLIBEXT@: $(BINARY_PREREQS) libgpo/gpext/security.o
+ @echo "Building plugin $@"
+ @$(SHLD_MODULE) libgpo/gpext/security.o
+
#########################################################
## IdMap NSS plugins
$(LIBS) $(LIBTALLOC_LIBS) @LIBTDB_SHARED@ $(WINBIND_LIBS) \
$(LDAP_LIBS) $(KRB5LIBS) $(NSCD_LIBS)
+bin/test_lp_load@EXEEXT@: $(BINARY_PREREQS) $(TEST_LP_LOAD_OBJ) @BUILD_POPT@ @LIBTALLOC_SHARED@ @LIBTDB_SHARED@
+ @echo "Linking $@"
+ @$(CC) $(FLAGS) -o $@ $(TEST_LP_LOAD_OBJ) \
+ $(LDFLAGS) $(DYNEEXP) $(LIBS) \
+ $(LDAP_LIBS) \
+ $(POPT_LIBS) $(LIBTALLOC_LIBS) $(LIBTDB_LIBS)
+
install:: installservers installbin @INSTALL_CIFSMOUNT@ @INSTALL_CIFSUPCALL@ installman \
installscripts installdat installmodules @SWAT_INSTALL_TARGETS@ \
@INSTALL_PAM_MODULES@ installlibs
@$(SHELL) $(srcdir)/script/linkmodules.sh $(DESTDIR)$(AUTHLIBDIR) domain.@SHLIBEXT@ trustdomain.@SHLIBEXT@ ntdomain.@SHLIBEXT@
@$(SHELL) $(srcdir)/script/linkmodules.sh $(DESTDIR)$(AUTHLIBDIR) builtin.@SHLIBEXT@ guest.@SHLIBEXT@ fixed_challenge.@SHLIBEXT@ name_to_ntstatus.@SHLIBEXT@
@$(SHELL) $(srcdir)/script/linkmodules.sh $(DESTDIR)$(NSSINFOLIBDIR) ../idmap/ad.@SHLIBEXT@ rfc2307.@SHLIBEXT@ sfu.@SHLIBEXT@ sfu20.@SHLIBEXT@
+ @$(SHELL) $(srcdir)/script/linkmodules.sh $(DESTDIR)$(NSSINFOLIBDIR) ../idmap/adex.@SHLIBEXT@ adex.@SHLIBEXT@
+ @$(SHELL) $(srcdir)/script/linkmodules.sh $(DESTDIR)$(NSSINFOLIBDIR) ../idmap/hash.@SHLIBEXT@ hash.@SHLIBEXT@
installscripts:: installdirs
@$(SHELL) $(srcdir)/script/installscripts.sh $(INSTALLPERMS_BIN) $(DESTDIR)$(BINDIR) $(SCRIPTS)
# Toplevel clean files
TOPFILES=dynconfig.o
+cleanlibs::
+ -rm -f ../lib/*/*.o ../lib/*/*/*.o \
+ ../libcli/*.o ../libcli/*/*.o
+
clean:: cleanlibs
-rm -f include/build_env.h
-rm -f smbd/build_options.c
proto::
etags::
- etags `find $(srcdir) -name "*.[ch]"`
+ etags `find $(srcdir)/.. -name "*.[ch]"`
ctags::
- ctags `find $(srcdir) -name "*.[ch]"`
+ ctags `find $(srcdir)/.. -name "*.[ch]"`
realclean:: clean
-rm -f config.log bin/.dummy script/findsmb script/gen-8bit-gap.sh
VALGRIND="valgrind -q --num-callers=30 --log-file=${selftest_prefix}/valgrind.log" \
PERL="$(PERL)" $(srcdir)/script/tests/selftest.sh ${selftest_prefix} all "${smbtorture4_path}"
+# Check for Winbind struct 32/64bit padding
+test_wbpad:
+ @echo "Testing winbind request/response structure for 32/64bit padding"
+ @./script/tests/wb_pad.sh || exit 1;
##
## Examples:
extern bool global_machine_password_needs_changing;
static struct named_mutex *mutex;
+/*
+ * Change machine password (called from main loop
+ * idle timeout. Must be done as root.
+ */
+
+void attempt_machine_password_change(void)
+{
+ unsigned char trust_passwd_hash[16];
+ time_t lct;
+ void *lock;
+
+ if (!global_machine_password_needs_changing) {
+ return;
+ }
+
+ if (lp_security() != SEC_DOMAIN) {
+ return;
+ }
+
+ /*
+ * We're in domain level security, and the code that
+ * read the machine password flagged that the machine
+ * password needs changing.
+ */
+
+ /*
+ * First, open the machine password file with an exclusive lock.
+ */
+
+ lock = secrets_get_trust_account_lock(NULL, lp_workgroup());
+
+ if (lock == NULL) {
+ DEBUG(0,("attempt_machine_password_change: unable to lock "
+ "the machine account password for machine %s in "
+ "domain %s.\n",
+ global_myname(), lp_workgroup() ));
+ return;
+ }
+
+ if(!secrets_fetch_trust_account_password(lp_workgroup(),
+ trust_passwd_hash, &lct, NULL)) {
+ DEBUG(0,("attempt_machine_password_change: unable to read the "
+ "machine account password for %s in domain %s.\n",
+ global_myname(), lp_workgroup()));
+ TALLOC_FREE(lock);
+ return;
+ }
+
+ /*
+ * Make sure someone else hasn't already done this.
+ */
+
+ if(time(NULL) < lct + lp_machine_password_timeout()) {
+ global_machine_password_needs_changing = false;
+ TALLOC_FREE(lock);
+ return;
+ }
+
+ /* always just contact the PDC here */
+
+ change_trust_account_password( lp_workgroup(), NULL);
+ global_machine_password_needs_changing = false;
+ TALLOC_FREE(lock);
+}
+
/**
* Connect to a remote server for (inter)domain security authenticaion.
*
--- /dev/null
+/*
+ Unix SMB/CIFS implementation.
+ Authenticate against a netlogon pipe listening on a unix domain socket
+ Copyright (C) Volker Lendecke 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.
+
+ 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_AUTH
+
+static NTSTATUS netlogond_validate(TALLOC_CTX *mem_ctx,
+ const struct auth_context *auth_context,
+ const char *ncalrpc_sockname,
+ uint8_t schannel_key[16],
+ const auth_usersupplied_info *user_info,
+ struct netr_SamInfo3 **pinfo3,
+ NTSTATUS *schannel_bind_result)
+{
+ struct rpc_pipe_client *p;
+ struct cli_pipe_auth_data *auth;
+ struct netr_SamInfo3 *info3 = NULL;
+ NTSTATUS status;
+
+ *schannel_bind_result = NT_STATUS_OK;
+
+ status = rpc_pipe_open_ncalrpc(talloc_tos(), ncalrpc_sockname,
+ &ndr_table_netlogon.syntax_id, &p);
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(10, ("rpc_pipe_open_ncalrpc failed: %s\n",
+ nt_errstr(status)));
+ return status;
+ }
+
+ status = rpccli_schannel_bind_data(p, lp_workgroup(),
+ PIPE_AUTH_LEVEL_PRIVACY,
+ schannel_key, &auth);
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(10, ("rpccli_schannel_bind_data failed: %s\n",
+ nt_errstr(status)));
+ TALLOC_FREE(p);
+ return status;
+ }
+
+ status = rpc_pipe_bind(p, auth);
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(10, ("rpc_pipe_bind failed: %s\n", nt_errstr(status)));
+ TALLOC_FREE(p);
+ *schannel_bind_result = status;
+ return status;
+ }
+
+ /*
+ * We have to fake a struct dcinfo, so that
+ * rpccli_netlogon_sam_network_logon_ex can decrypt the session keys.
+ */
+
+ p->dc = talloc(p, struct dcinfo);
+ if (p->dc == NULL) {
+ DEBUG(0, ("talloc failed\n"));
+ TALLOC_FREE(p);
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ memcpy(p->dc->sess_key, schannel_key, 16);
+
+ status = rpccli_netlogon_sam_network_logon_ex(
+ p, p,
+ user_info->logon_parameters,/* flags such as 'allow
+ * workstation logon' */
+ global_myname(), /* server name */
+ user_info->smb_name, /* user name logging on. */
+ user_info->client_domain, /* domain name */
+ user_info->wksta_name, /* workstation name */
+ (uchar *)auth_context->challenge.data, /* 8 byte challenge. */
+ user_info->lm_resp, /* lanman 24 byte response */
+ user_info->nt_resp, /* nt 24 byte response */
+ &info3); /* info3 out */
+
+ DEBUG(10, ("rpccli_netlogon_sam_network_logon_ex returned %s\n",
+ nt_errstr(status)));
+
+ if (!NT_STATUS_IS_OK(status)) {
+ TALLOC_FREE(p);
+ return status;
+ }
+
+ *pinfo3 = talloc_move(mem_ctx, &info3);
+
+ TALLOC_FREE(p);
+ return NT_STATUS_OK;
+}
+
+static char *mymachinepw(TALLOC_CTX *mem_ctx)
+{
+ fstring pwd;
+ const char *script;
+ char *to_free = NULL;
+ ssize_t nread;
+ int ret, fd;
+
+ script = lp_parm_const_string(
+ GLOBAL_SECTION_SNUM, "auth_netlogond", "machinepwscript",
+ NULL);
+
+ if (script == NULL) {
+ to_free = talloc_asprintf(talloc_tos(), "%s/%s",
+ get_dyn_SBINDIR(), "mymachinepw");
+ script = to_free;
+ }
+ if (script == NULL) {
+ return NULL;
+ }
+
+ ret = smbrun(script, &fd);
+ DEBUG(ret ? 0 : 3, ("mymachinepw: Running the command `%s' gave %d\n",
+ script, ret));
+ TALLOC_FREE(to_free);
+
+ if (ret != 0) {
+ return NULL;
+ }
+
+ pwd[sizeof(pwd)-1] = '\0';
+
+ nread = read(fd, pwd, sizeof(pwd)-1);
+ close(fd);
+
+ if (nread <= 0) {
+ DEBUG(3, ("mymachinepwd: Could not read password\n"));
+ return NULL;
+ }
+
+ DEBUG(0, ("pwd: %d [%s]\n", (int)nread, pwd));
+
+ if (pwd[nread-1] == '\n') {
+ pwd[nread-1] = '\0';
+ }
+
+ return talloc_strdup(mem_ctx, pwd);
+}
+
+static NTSTATUS check_netlogond_security(const struct auth_context *auth_context,
+ void *my_private_data,
+ TALLOC_CTX *mem_ctx,
+ const auth_usersupplied_info *user_info,
+ auth_serversupplied_info **server_info)
+{
+ TALLOC_CTX *frame = talloc_stackframe();
+ struct netr_SamInfo3 *info3 = NULL;
+ struct rpc_pipe_client *p;
+ struct cli_pipe_auth_data *auth;
+ uint32_t neg_flags = NETLOGON_NEG_AUTH2_ADS_FLAGS;
+ char *plaintext_machinepw;
+ uint8_t machine_password[16];
+ uint8_t schannel_key[16];
+ NTSTATUS schannel_bind_result, status;
+ struct named_mutex *mutex;
+ const char *ncalrpcsock;
+
+ ncalrpcsock = lp_parm_const_string(
+ GLOBAL_SECTION_SNUM, "auth_netlogond", "socket", NULL);
+
+ if (ncalrpcsock == NULL) {
+ ncalrpcsock = talloc_asprintf(talloc_tos(), "%s/%s",
+ get_dyn_NCALRPCDIR(), "DEFAULT");
+ }
+
+ if (ncalrpcsock == NULL) {
+ status = NT_STATUS_NO_MEMORY;
+ goto done;
+ }
+
+ if (!secrets_fetch_local_schannel_key(schannel_key)) {
+ goto new_key;
+ }
+
+ status = netlogond_validate(talloc_tos(), auth_context, ncalrpcsock,
+ schannel_key, user_info, &info3,
+ &schannel_bind_result);
+
+ DEBUG(10, ("netlogond_validate returned %s\n", nt_errstr(status)));
+
+ if (NT_STATUS_IS_OK(status)) {
+ goto okay;
+ }
+
+ if (NT_STATUS_IS_OK(schannel_bind_result)) {
+ /*
+ * This is a real failure from the DC
+ */
+ goto done;
+ }
+
+ new_key:
+
+ mutex = grab_named_mutex(talloc_tos(), "LOCAL_SCHANNEL_KEY", 60);
+ if (mutex == NULL) {
+ DEBUG(10, ("Could not get mutex LOCAL_SCHANNEL_KEY\n"));
+ status = NT_STATUS_ACCESS_DENIED;
+ goto done;
+ }
+
+ DEBUG(10, ("schannel bind failed, setting up new key\n"));
+
+ status = rpc_pipe_open_ncalrpc(talloc_tos(), ncalrpcsock,
+ &ndr_table_netlogon.syntax_id, &p);
+
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(10, ("rpc_pipe_open_ncalrpc failed: %s\n",
+ nt_errstr(status)));
+ goto done;
+ }
+
+ status = rpccli_anon_bind_data(p, &auth);
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(10, ("rpccli_anon_bind_data failed: %s\n",
+ nt_errstr(status)));
+ goto done;
+ }
+
+ status = rpc_pipe_bind(p, auth);
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(10, ("rpc_pipe_bind failed: %s\n", nt_errstr(status)));
+ goto done;
+ }
+
+ TALLOC_FREE(auth);
+
+ plaintext_machinepw = mymachinepw(talloc_tos());
+ if (plaintext_machinepw == NULL) {
+ status = NT_STATUS_NO_MEMORY;
+ goto done;
+ }
+
+ E_md4hash(plaintext_machinepw, machine_password);
+
+ TALLOC_FREE(plaintext_machinepw);
+
+ status = rpccli_netlogon_setup_creds(
+ p, global_myname(), lp_workgroup(), global_myname(),
+ global_myname(), machine_password, SEC_CHAN_BDC, &neg_flags);
+
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(10, ("rpccli_netlogon_setup_creds failed: %s\n",
+ nt_errstr(status)));
+ goto done;
+ }
+
+ memcpy(schannel_key, p->dc->sess_key, 16);
+ secrets_store_local_schannel_key(schannel_key);
+
+ TALLOC_FREE(p);
+
+ /*
+ * Retry the authentication with the mutex held. This way nobody else
+ * can step on our toes.
+ */
+
+ status = netlogond_validate(talloc_tos(), auth_context, ncalrpcsock,
+ schannel_key, user_info, &info3,
+ &schannel_bind_result);
+
+ DEBUG(10, ("netlogond_validate returned %s\n", nt_errstr(status)));
+
+ if (!NT_STATUS_IS_OK(status)) {
+ goto done;
+ }
+
+ okay:
+
+ status = make_server_info_info3(mem_ctx, user_info->smb_name,
+ user_info->domain, server_info,
+ info3);
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(10, ("make_server_info_info3 failed: %s\n",
+ nt_errstr(status)));
+ TALLOC_FREE(frame);
+ return status;
+ }
+
+ status = NT_STATUS_OK;
+
+ done:
+ TALLOC_FREE(frame);
+ return status;
+}
+
+/* module initialisation */
+static NTSTATUS auth_init_netlogond(struct auth_context *auth_context,
+ const char *param,
+ auth_methods **auth_method)
+{
+ if (!make_auth_methods(auth_context, auth_method)) {
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ (*auth_method)->name = "netlogond";
+ (*auth_method)->auth = check_netlogond_security;
+ return NT_STATUS_OK;
+}
+
+NTSTATUS auth_netlogond_init(void)
+{
+ smb_register_auth(AUTH_INTERFACE_VERSION, "netlogond",
+ auth_init_netlogond);
+ return NT_STATUS_OK;
+}
# Run this script to build samba from GIT.
+while true; do
+ case $1 in
+ (--version-file)
+ VERSION_FILE=$2
+ shift 2
+ ;;
+ (*)
+ break
+ ;;
+ esac
+done
+
## insert all possible names (only works with
## autoconf 2.x)
TESTAUTOHEADER="autoheader autoheader-2.53 autoheader2.50 autoheader259 autoheader253"
fi
echo "$0: running script/mkversion.sh"
-./script/mkversion.sh || exit 1
+./script/mkversion.sh $VERSION_FILE || exit 1
rm -rf autom4te*.cache
rm -f configure include/config.h*
}
}
+static bool finished;
+
/****************************************************************************
Make sure we swallow keepalives during idle time.
****************************************************************************/
DEBUG(0, ("Read from server failed, maybe it closed "
"the connection\n"));
+ finished = true;
+ smb_readline_done();
if (NT_STATUS_EQUAL(status, NT_STATUS_END_OF_FILE)) {
set_smb_read_error(&cli->smb_rw_error,
SMB_READ_EOF);
/* Ping the server to keep the connection alive using SMBecho. */
{
+ NTSTATUS status;
unsigned char garbage[16];
memset(garbage, 0xf0, sizeof(garbage));
- cli_echo(cli, 1, data_blob_const(garbage, sizeof(garbage)));
+ status = cli_echo(cli, 1, data_blob_const(garbage, sizeof(garbage)));
+
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(0, ("SMBecho failed. Maybe server has closed "
+ "the connection\n"));
+ finished = true;
+ smb_readline_done();
+ }
}
}
{
int rc = 0;
- while (1) {
+ while (!finished) {
TALLOC_CTX *frame = talloc_stackframe();
char *tok = NULL;
char *the_prompt = NULL;
#endif /* _SAMBA_BUILD_ */
#endif /* MOUNT_CIFS_VENDOR_SUFFIX */
+#ifdef _SAMBA_BUILD_
+#include "include/config.h"
+#endif
+
#ifndef MS_MOVE
#define MS_MOVE 8192
#endif
#define MOUNT_PASSWD_SIZE 64
#define DOMAIN_SIZE 64
+/* exit status - bits below are ORed */
+#define EX_USAGE 1 /* incorrect invocation or permission */
+#define EX_SYSERR 2 /* out of memory, cannot fork, ... */
+#define EX_SOFTWARE 4 /* internal mount bug or wrong version */
+#define EX_USER 8 /* user interrupt */
+#define EX_FILEIO 16 /* problems writing, locking, ... mtab/fstab */
+#define EX_FAIL 32 /* mount failure */
+#define EX_SOMEOK 64 /* some mount succeeded */
+
const char *thisprogram;
int verboseflag = 0;
static int got_password = 0;
/* like strncpy but does not 0 fill the buffer and always null
* terminates. bufsize is the size of the destination buffer */
+
+#ifndef HAVE_STRLCPY
static size_t strlcpy(char *d, const char *s, size_t bufsize)
{
size_t len = strlen(s);
d[len] = 0;
return ret;
}
+#endif
/* like strncat but does not 0 fill the buffer and always null
* terminates. bufsize is the length of the buffer, which should
* be one more than the maximum resulting string length */
+
+#ifndef HAVE_STRLCAT
static size_t strlcat(char *d, const char *s, size_t bufsize)
{
size_t len1 = strlen(d);
}
return ret;
}
+#endif
/* BB finish BB
printf("\n\t%s -V\n",thisprogram);
SAFE_FREE(mountpassword);
- exit(1);
+ exit(EX_USAGE);
}
/* caller frees username if necessary */
if(length > 4086) {
printf("mount.cifs failed due to malformed username in credentials file");
memset(line_buf,0,4096);
- exit(1);
+ exit(EX_USAGE);
} else {
got_user = 1;
user_name = (char *)calloc(1 + length,1);
if(length > MOUNT_PASSWD_SIZE) {
printf("mount.cifs failed: password in credentials file too long\n");
memset(line_buf,0, 4096);
- exit(1);
+ exit(EX_USAGE);
} else {
if(mountpassword == NULL) {
mountpassword = (char *)calloc(MOUNT_PASSWD_SIZE+1,1);
}
if(length > DOMAIN_SIZE) {
printf("mount.cifs failed: domain in credentials file too long\n");
- exit(1);
+ exit(EX_USAGE);
} else {
if(domain_name == NULL) {
domain_name = (char *)calloc(DOMAIN_SIZE+1,1);
if (mountpassword == NULL) {
printf("malloc failed\n");
- exit(1);
+ exit(EX_SYSERR);
}
if(filename != NULL) {
if(file_descript < 0) {
printf("mount.cifs failed. %s attempting to open password file %s\n",
strerror(errno),filename);
- exit(1);
+ exit(EX_SYSERR);
}
}
/* else file already open and fd provided */
printf("mount.cifs failed. Error %s reading password file\n",strerror(errno));
if(filename != NULL)
close(file_descript);
- exit(1);
+ exit(EX_SYSERR);
} else if(rc == 0) {
if(mountpassword[0] == 0) {
if(verboseflag)
if (!(pw = getpwnam(value))) {
printf("bad user name \"%s\"\n", value);
- exit(1);
+ exit(EX_USAGE);
}
snprintf(user, sizeof(user), "%u", pw->pw_uid);
} else {
if (!(gr = getgrnam(value))) {
printf("bad group name \"%s\"\n", value);
- exit(1);
+ exit(EX_USAGE);
}
snprintf(group, sizeof(group), "%u", gr->gr_gid);
} else {
out = (char *)realloc(out, out_len + word_len + 2);
if (out == NULL) {
perror("malloc");
- exit(1);
+ exit(EX_SYSERR);
}
if (out_len) {
out = (char *)realloc(out, out_len + word_len + 6);
if (out == NULL) {
perror("malloc");
- exit(1);
+ exit(EX_SYSERR);
}
if (out_len) {
out = (char *)realloc(out, out_len + 1 + word_len + 6);
if (out == NULL) {
perror("malloc");
- exit(1);
+ exit(EX_SYSERR);
}
if (out_len) {
};
/* convert a string to uppercase. return false if the string
- * wasn't ASCII or was a NULL ptr */
+ * wasn't ASCII. Return success on a NULL ptr */
static int
uppercase_string(char *string)
{
if (!string)
- return 0;
+ return 1;
while (*string) {
/* check for unicode */
thisprogram = argv[0];
} else {
mount_cifs_usage();
- exit(1);
+ exit(EX_USAGE);
}
if(thisprogram == NULL)
share_name = strndup(argv[1], MAX_UNC_LEN);
if (share_name == NULL) {
fprintf(stderr, "%s: %s", argv[0], strerror(ENOMEM));
- exit(1);
+ exit(EX_SYSERR);
}
mountpoint = argv[2];
} else {
mount_cifs_usage();
- exit(1);
+ exit(EX_USAGE);
}
/* add sharename in opts string as unc= parm */
case '?':
case 'h': /* help */
mount_cifs_usage ();
- exit(1);
+ exit(EX_USAGE);
case 'n':
++nomtab;
break;
uid = strtoul(optarg, &ep, 10);
if (*ep) {
printf("bad uid value \"%s\"\n", optarg);
- exit(1);
+ exit(EX_USAGE);
}
} else {
struct passwd *pw;
if (!(pw = getpwnam(optarg))) {
printf("bad user name \"%s\"\n", optarg);
- exit(1);
+ exit(EX_USAGE);
}
uid = pw->pw_uid;
endpwent();
gid = strtoul(optarg, &ep, 10);
if (*ep) {
printf("bad gid value \"%s\"\n", optarg);
- exit(1);
+ exit(EX_USAGE);
}
} else {
struct group *gr;
if (!(gr = getgrnam(optarg))) {
printf("bad user name \"%s\"\n", optarg);
- exit(1);
+ exit(EX_USAGE);
}
gid = gr->gr_gid;
endpwent();
default:
printf("unknown mount option %c\n",c);
mount_cifs_usage();
- exit(1);
+ exit(EX_USAGE);
}
}
if((argc < 3) || (dev_name == NULL) || (mountpoint == NULL)) {
mount_cifs_usage();
- exit(1);
+ exit(EX_USAGE);
}
if (getenv("PASSWD")) {
}
if (orgoptions && parse_options(&orgoptions, &flags)) {
- rc = -1;
+ rc = EX_USAGE;
goto mount_exit;
}
ipaddr = parse_server(&share_name);
if((ipaddr == NULL) && (got_ip == 0)) {
printf("No ip address specified and hostname not found\n");
- rc = -1;
+ rc = EX_USAGE;
goto mount_exit;
}
}
if(chdir(mountpoint)) {
printf("mount error: can not change directory into mount target %s\n",mountpoint);
- rc = -1;
+ rc = EX_USAGE;
goto mount_exit;
}
if(stat (".", &statbuf)) {
printf("mount error: mount point %s does not exist\n",mountpoint);
- rc = -1;
+ rc = EX_USAGE;
goto mount_exit;
}
if (S_ISDIR(statbuf.st_mode) == 0) {
printf("mount error: mount point %s is not a directory\n",mountpoint);
- rc = -1;
+ rc = EX_USAGE;
goto mount_exit;
}
#endif
} else {
printf("mount error: permission denied or not superuser and mount.cifs not installed SUID\n");
- return -1;
+ exit(EX_USAGE);
}
}
mountpassword = (char *)calloc(MOUNT_PASSWD_SIZE+1,1);
if (!tmp_pass || !mountpassword) {
printf("Password not entered, exiting\n");
- return -1;
+ exit(EX_USAGE);
}
strlcpy(mountpassword, tmp_pass, MOUNT_PASSWD_SIZE+1);
got_password = 1;
else {
printf("No server share name specified\n");
printf("\nMounting the DFS root for server not implemented yet\n");
- exit(1);
+ exit(EX_USAGE);
}
if(user_name)
optlen += strlen(user_name) + 6;
if(options == NULL) {
printf("Could not allocate memory for mount options\n");
- return -1;
+ exit(EX_SYSERR);
}
options[0] = 0;
printf("mount error %d = %s\n",errno,strerror(errno));
}
printf("Refer to the mount.cifs(8) manual page (e.g.man mount.cifs)\n");
- rc = -1;
- goto mount_exit;
+ rc = EX_FAIL;
} else {
pmntfile = setmntent(MOUNTED, "a+");
if(pmntfile) {
rc = addmntent(pmntfile,&mountent);
endmntent(pmntfile);
SAFE_FREE(mountent.mnt_opts);
+ if (rc)
+ rc = EX_FILEIO;
} else {
- printf("could not update mount table\n");
+ printf("could not update mount table\n");
+ rc = EX_FILEIO;
}
}
- rc = 0;
mount_exit:
if(mountpassword) {
int len = strlen(mountpassword);
SAFE_FREE(orgoptions);
SAFE_FREE(resolved_path);
SAFE_FREE(share_name);
- return rc;
+ exit(rc);
}
if test "x$debug" = "xyes" ; then
CFLAGS="${CFLAGS} -g"
else
- CFLAGS="-O"
+ CFLAGS="${CFLAGS} -O"
fi
m4_include(../lib/socket_wrapper/config.m4)
dnl Add modules that have to be built by default here
dnl These have to be built static:
-default_static_modules="pdb_smbpasswd pdb_tdbsam rpc_lsarpc rpc_samr rpc_winreg rpc_initshutdown rpc_dssetup rpc_wkssvc rpc_svcctl2 rpc_ntsvcs2 rpc_netlogon rpc_netdfs rpc_srvsvc rpc_spoolss rpc_eventlog2 auth_sam auth_unix auth_winbind auth_server auth_domain auth_builtin vfs_default nss_info_template"
+default_static_modules="pdb_smbpasswd pdb_tdbsam rpc_lsarpc rpc_samr rpc_winreg rpc_initshutdown rpc_dssetup rpc_wkssvc rpc_svcctl2 rpc_ntsvcs2 rpc_netlogon rpc_netdfs rpc_srvsvc rpc_spoolss rpc_eventlog2 auth_sam auth_unix auth_winbind auth_server auth_domain auth_builtin auth_netlogond vfs_default nss_info_template"
dnl These are preferably build shared, and static if dlopen() is not available
-default_shared_modules="vfs_recycle vfs_audit vfs_extd_audit vfs_full_audit vfs_netatalk vfs_fake_perms vfs_default_quota vfs_readonly vfs_cap vfs_expand_msdfs vfs_shadow_copy vfs_shadow_copy2 charset_CP850 charset_CP437 auth_script vfs_readahead vfs_xattr_tdb vfs_streams_xattr vfs_acl_xattr"
+default_shared_modules="vfs_recycle vfs_audit vfs_extd_audit vfs_full_audit vfs_netatalk vfs_fake_perms vfs_default_quota vfs_readonly vfs_cap vfs_expand_msdfs vfs_shadow_copy vfs_shadow_copy2 charset_CP850 charset_CP437 auth_script vfs_readahead vfs_xattr_tdb vfs_streams_xattr vfs_acl_xattr vfs_smb_traffic_analyzer"
if test "x$developer" = xyes; then
default_static_modules="$default_static_modules rpc_rpcecho"
SMB_MODULE(idmap_rid, winbindd/idmap_rid.o, "bin/rid.$SHLIBEXT", IDMAP)
SMB_MODULE(idmap_ad, winbindd/idmap_ad.o, "bin/ad.$SHLIBEXT", IDMAP)
SMB_MODULE(idmap_hash, \$(IDMAP_HASH_OBJ), "bin/hash.$SHLIBEXT", IDMAP)
+SMB_MODULE(idmap_adex, \$(IDMAP_ADEX_OBJ), "bin/adex.$SHLIBEXT", IDMAP)
SMB_SUBSYSTEM(IDMAP, winbindd/idmap.o)
SMB_MODULE(nss_info_template, winbindd/nss_info_template.o, "bin/template.$SHLIBEXT", NSS_INFO)
SMB_MODULE(auth_domain, \$(AUTH_DOMAIN_OBJ), "bin/domain.$SHLIBEXT", AUTH)
SMB_MODULE(auth_builtin, \$(AUTH_BUILTIN_OBJ), "bin/builtin.$SHLIBEXT", AUTH)
SMB_MODULE(auth_script, \$(AUTH_SCRIPT_OBJ), "bin/script.$SHLIBEXT", AUTH)
+SMB_MODULE(auth_netlogond, \$(AUTH_NETLOGOND_OBJ), "bin/netlogond.$SHLIBEXT", AUTH)
SMB_SUBSYSTEM(AUTH,auth/auth.o)
SMB_MODULE(vfs_default, \$(VFS_DEFAULT_OBJ), "bin/default.$SHLIBEXT", VFS)
SMB_MODULE(vfs_zfsacl, \$(VFS_ZFSACL_OBJ), "bin/zfsacl.$SHLIBEXT", VFS)
SMB_MODULE(vfs_notify_fam, \$(VFS_NOTIFY_FAM_OBJ), "bin/notify_fam.$SHLIBEXT", VFS)
SMB_MODULE(vfs_acl_xattr, \$(VFS_ACL_XATTR_OBJ), "bin/acl_xattr.$SHLIBEXT", VFS)
-
+SMB_MODULE(vfs_smb_traffic_analyzer, \$(VFS_SMB_TRAFFIC_ANALYZER_OBJ), "bin/smb_traffic_analyzer.$SHLIBEXT", VFS)
SMB_SUBSYSTEM(VFS,smbd/vfs.o)
SMB_MODULE(gpext_registry, libgpo/gpext/registry.o, "bin/registry.$SHLIBEXT", GPEXT)
SMB_MODULE(gpext_scripts, libgpo/gpext/scripts.o, "bin/scripts.$SHLIBEXT", GPEXT)
+SMB_MODULE(gpext_security, libgpo/gpext/security.o, "bin/security.$SHLIBEXT", GPEXT)
SMB_SUBSYSTEM(GPEXT, libgpo/gpext/gpext.o)
AC_DEFINE_UNQUOTED(STRING_STATIC_MODULES, "$string_static_modules", [String list of builtin modules])
SMBD_LIBS="$samba_dmapi_libs"
AC_SUBST(SMBD_LIBS)
+CFLAGS="${CFLAGS} \$(FLAGS)"
+
if test x$MERGED_BUILD != x1; then
- CFLAGS="${CFLAGS} \$(FLAGS) -D_SAMBA_BUILD_=3"
+ CFLAGS="${CFLAGS} -D_SAMBA_BUILD_=3"
+else
+ if test x"$BLDSHARED" = x"true" ; then
+ LDFLAGS="$LDFLAGS -L./bin"
+ fi
fi
AC_OUTPUT(Makefile
DEFINE_DYN_CONFIG_PARAM(SHLIBEXT)
DEFINE_DYN_CONFIG_PARAM(LOCKDIR)
DEFINE_DYN_CONFIG_PARAM(PIDDIR)
+DEFINE_DYN_CONFIG_PARAM(NCALRPCDIR)
DEFINE_DYN_CONFIG_PARAM(SMB_PASSWD_FILE)
DEFINE_DYN_CONFIG_PARAM(PRIVATE_DIR)
if (num == 0) {
status = dbwrap_delete_bystring(db, key);
- TALLOC_FREE(sids);
- goto cancel;
+ goto commit;
}
member_string = talloc_strdup(sids, "");
status = dbwrap_store_bystring(
db, key, string_term_tdb_data(member_string), 0);
-
+ commit:
TALLOC_FREE(sids);
if (!NT_STATUS_IS_OK(status)) {
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
+struct smb_iconv_convenience;
+
/* this defines the charset types used in samba */
typedef enum {CH_UTF16LE=0, CH_UTF16=0, CH_UNIX=1, CH_DISPLAY=2, CH_DOS=3, CH_UTF8=4, CH_UTF16BE=5} charset_t;
const char *set_dyn_PIDDIR(const char *newpath);
bool is_default_dyn_PIDDIR(void);
+const char *get_dyn_NCALRPCDIR(void);
+const char *set_dyn_NCALRPCDIR(const char *newpath);
+bool is_default_dyn_NCALRPCDIR(void);
+
const char *get_dyn_SMB_PASSWD_FILE(void);
const char *set_dyn_SMB_PASSWD_FILE(const char *newpath);
bool is_default_dyn_SMB_PASSWD_FILE(void);
+++ /dev/null
-/*
- Unix SMB/CIFS implementation.
- Interface header: Scheduler service
- Copyright (C) Luke Kenneth Casson Leighton 1996-1999
- Copyright (C) Andrew Tridgell 1992-1999
-
- 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 _HMAC_MD5_H
-
-typedef struct {
- struct MD5Context ctx;
- unsigned char k_ipad[65];
- unsigned char k_opad[65];
-} HMACMD5Context;
-
-#endif /* _HMAC_MD5_H */
Updated to 3 for enum types by JRA. */
/* Updated to 4, completely new interface, SSS */
+/* Updated to 5, simplified interface by Volker */
-#define SMB_IDMAP_INTERFACE_VERSION 4
+#define SMB_IDMAP_INTERFACE_VERSION 5
struct idmap_domain {
const char *name;
#include "authdata.h"
#include "msdfs.h"
#include "rap.h"
-#include "md5.h"
-#include "hmacmd5.h"
+#include "../lib/crypto/md5.h"
+#include "../lib/crypto/crc32.h"
+#include "../lib/crypto/hmacmd5.h"
#include "ntlmssp.h"
#include "auth.h"
#include "ntdomain.h"
#include "librpc/gen_ndr/notify.h"
#include "librpc/gen_ndr/xattr.h"
#include "librpc/gen_ndr/messaging.h"
+#include "librpc/gen_ndr/ndr_nbt.h"
#include "librpc/rpc/dcerpc.h"
#include "nt_printing.h"
#include "idmap.h"
+++ /dev/null
-/*
- * Unix SMB/CIFS implementation.
- * MS-RPC client library API definitions/prototypes
- *
- * Copyright (C) Chris Nicholls 2005.
- *
- * 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 LIBMSRPC_H
-#define LIBMSRPC_H
-
-
-#include "includes.h"
-#include "libsmbclient.h"
-#include "libsmb_internal.h"
-
-/*server capability levels*/
-#define SRV_WIN_NT4 1
-#define SRV_WIN_2K 2
-#define SRV_WIN_2K_SP3 3
-#define SRV_WIN_2K3 4
-
-/**@defgroup handle Server Handle*/
-/**@defgroup Library_Functions Library/Utility Functions*/
-/**@defgroup lsa_defs LSA Definitions*/
-/**@defgroup LSA_Functions LSA Functions*/
-/**@defgroup reg_defs Registry Definitions*/
-/**@defgroup Reg_Functions Registry Functions*/
-/**@defgroup sam_defs SAM Definitions*/
-/**@defgroup SAM_Functions SAM Functions*/
-/**@defgroup svc_defs Service Control Definitions*/
-/**@defgroup SCM_Functions Service Control Functions*/
-
-/**Operation was unsuccessful*/
-#define CAC_FAILURE 0
-/**Operation was successful*/
-#define CAC_SUCCESS 1
-/**Operation was only partially successful
- * an example of this is if you try to lookup a list of accounts to SIDs and not all accounts can be resolved*/
-#define CAC_PARTIAL_SUCCESS 2
-
-/**@ingroup CAC_errors Use this to see if the last operation failed - useful for enumeration functions that use multiple calls*/
-#define CAC_OP_FAILED(status) !NT_STATUS_IS_OK(status) && \
- NT_STATUS_V(status) != NT_STATUS_V(STATUS_SOME_UNMAPPED) && \
- NT_STATUS_V(status) != NT_STATUS_V(STATUS_NO_MORE_FILES) && \
- NT_STATUS_V(status) != NT_STATUS_V(NT_STATUS_NO_MORE_ENTRIES) && \
- NT_STATUS_V(status) != NT_STATUS_V(NT_STATUS_NONE_MAPPED) && \
- NT_STATUS_V(status) != NT_STATUS_V(NT_STATUS_GUIDS_EXHAUSTED)
-
-
-/**Privilege string constants*/
-#define CAC_SE_CREATE_TOKEN "SeCreateTokenPrivilege"
-#define CAC_SE_ASSIGN_PRIMARY_TOKEN "SeAssignPrimaryTokenPrivilege"
-#define CAC_SE_LOCK_MEMORY "SeLockMemoryPrivilege"
-#define CAC_SE_INCREASE_QUOTA "SeIncreaseQuotaPrivilege"
-#define CAC_SE_MACHINE_ACCOUNT "SeMachineAccountPrivilege"
-#define CAC_SE_TCB "SeTcbPrivilege"
-#define CAC_SE_SECURITY "SeSecurityPrivilege"
-#define CAC_SE_TAKE_OWNERSHIP "SeTakeOwnershipPrivilege"
-#define CAC_SE_LOAD_DRIVER "SeLoadDriverPrivilege"
-#define CAC_SE_SYSTEM_PROFILE "SeSystemProfilePrivilege"
-#define CAC_SE_SYSTEM_TIME "SeSystemtimePrivilege"
-#define CAC_SE_PROFILE_SINGLE_PROC "SeProfileSingleProcessPrivilege"
-#define CAC_SE_INCREASE_BASE_PRIORITY "SeIncreaseBasePriorityPrivilege"
-#define CAC_SE_CREATE_PAGEFILE "SeCreatePagefilePrivilege"
-#define CAC_SE_CREATE_PERMANENT "SeCreatePermanentPrivilege"
-#define CAC_SE_BACKUP "SeBackupPrivilege"
-#define CAC_SE_RESTORE "SeRestorePrivilege"
-#define CAC_SE_SHUTDOWN "SeShutdownPrivilege"
-#define CAC_SE_DEBUG "SeDebugPrivilege"
-#define CAC_SE_AUDIT "SeAuditPrivilege"
-#define CAC_SE_SYSTEM_ENV "SeSystemEnvironmentPrivilege"
-#define CAC_SE_CHANGE_NOTIFY "SeChangeNotifyPrivilege"
-#define CAC_SE_REMOTE_SHUTDOWN "SeRemoteShutdownPrivilege"
-#define CAC_SE_UNDOCK "SeUndockPrivilege"
-#define CAC_SE_SYNC_AGENT "SeSyncAgentPrivilege"
-#define CAC_SE_ENABLE_DELEGATION "SeEnableDelegationPrivilege"
-#define CAC_SE_MANAGE_VOLUME "SeManageVolumePrivilege"
-#define CAC_SE_IMPERSONATE "SeImpersonatePrivilege"
-#define CAC_SE_CREATE_GLOBAL "SeCreateGlobalPrivilege"
-#define CAC_SE_PRINT_OPERATOR "SePrintOperatorPrivilege"
-#define CAC_SE_NETWORK_LOGON "SeNetworkLogonRight"
-#define CAC_SE_INTERACTIVE_LOGON "SeInteractiveLogonRight"
-#define CAC_SE_BATCH_LOGON "SeBatchLogonRight"
-#define CAC_SE_SERVICE_LOGON "SeServiceLogonRight"
-#define CAC_SE_ADD_USERS "SeAddUsersPrivilege"
-#define CAC_SE_DISK_OPERATOR "SeDiskOperatorPrivilege"
-
-/**
- * @addtogroup lsa_defs
- * @{
- */
-/**used to specify what data to retrieve using cac_LsaQueryTrustedDomainInformation*/
-#define CAC_INFO_TRUSTED_DOMAIN_NAME 0x1
-#define CAC_INFO_TRUSTED_DOMAIN_POSIX_OFFSET 0x3
-#define CAC_INFO_TRUSTED_DOMAIN_PASSWORD 0x4
-
-/**Used when requesting machine domain information*/
-#define CAC_DOMAIN_INFO 0x0003
-
-/**Used when requesting machine local information*/
-#define CAC_LOCAL_INFO 0x0005
-
-/**Stores information about a SID*/
-typedef struct _CACSIDINFO {
- /**The actual SID*/
- DOM_SID sid;
-
- /**The name of the object which maps to this SID*/
- char *name;
-
- /**The domain the SID belongs to*/
- char *domain;
-} CacSidInfo;
-/* @} */
-
-/**
- * @addtogroup reg_defs
- * @{
- */
-/**Null terminated string*/
-typedef char* REG_SZ_DATA;
-
-/**Null terminated string with windows environment variables that should be expanded*/
-typedef char* REG_EXPAND_SZ_DATA;
-
-/**Binary data of some kind*/
-typedef struct _REGBINARYDATA {
- uint32 data_length;
- uint8 * data;
-} REG_BINARY_DATA;
-
-/**32-bit (little endian) number*/
-typedef uint32 REG_DWORD_DATA;
-
-/**32-bit big endian number*/
-typedef uint32 REG_DWORD_BE_DATA;
-
-/**array of strings*/
-typedef struct _REGMULTISZDATA {
- uint32 num_strings;
-
- char **strings;
-} REG_MULTI_SZ_DATA;
-
-typedef union _REGVALUEDATA {
- REG_SZ_DATA reg_sz;
- REG_EXPAND_SZ_DATA reg_expand_sz;
- REG_BINARY_DATA reg_binary;
- REG_DWORD_DATA reg_dword;
- REG_DWORD_BE_DATA reg_dword_be;
- REG_MULTI_SZ_DATA reg_multi_sz;
-} REG_VALUE_DATA;
-/**@}*/
-
-/**
- * @addtogroup sam_defs
- * @{
- */
-
-#define CAC_USER_RID 0x1
-#define CAC_GROUP_RID 0x2
-
-typedef struct _CACLOOKUPRIDSRECORD {
- char *name;
- uint32 rid;
-
- /**If found, this will be one of:
- * - CAC_USER_RID
- * - CAC_GROUP_RID
- */
- uint32 type;
-
- /*if the name or RID was looked up, then found = True*/
- bool found;
-} CacLookupRidsRecord;
-
-typedef struct _CACUSERINFO {
- /**Last logon time*/
- time_t logon_time;
-
- /**Last logoff time*/
- time_t logoff_time;
-
- /**Last kickoff time*/
- time_t kickoff_time;
-
- /**Last password set time*/
- time_t pass_last_set_time;
-
- /**Time password can change*/
- time_t pass_can_change_time;
-
- /**Time password must change*/
- time_t pass_must_change_time;
-
- /**LM user password*/
- uint8 lm_password[8];
-
- /**NT user password*/
- uint8 nt_password[8];
-
- /**User's RID*/
- uint32 rid;
-
- /**RID of primary group*/
- uint32 group_rid;
-
- /**User's ACB mask*/
- uint32 acb_mask;
-
- /**Bad password count*/
- uint16 bad_passwd_count;
-
- /**Number of logons*/
- uint16 logon_count;
-
- /**Change password at next logon?*/
- bool pass_must_change;
-
- /**Username*/
- char *username;
-
- /**User's full name*/
- char *full_name;
-
- /**User's home directory*/
- char *home_dir;
-
- /**Home directory drive*/
- char *home_drive;
-
- /**Logon script*/
- char *logon_script;
-
- /**Path to profile*/
- char *profile_path;
-
- /**Account description*/
- char *description;
-
- /**Login from workstations*/
- char *workstations;
-
- char *dial;
-
- /**Possible logon hours*/
- LOGON_HRS *logon_hours;
-
-} CacUserInfo;
-
-typedef struct _CACGROUPINFO {
- /**Group name*/
- char *name;
-
- /**Description*/
- char *description;
-
- /**Number of members*/
- uint32 num_members;
-} CacGroupInfo, CacAliasInfo;
-
-/**Represents a period (duration) of time*/
-typedef struct _CACTIME {
- /**Number of days*/
- uint32 days;
-
- /**Number of hours*/
- uint32 hours;
-
- /**Number of minutes*/
- uint32 minutes;
-
- /**number of seconds*/
- uint32 seconds;
-} CacTime;
-
-
-typedef struct _CACDOMINFO {
- /**The server role. Should be one of:
- * ROLE_STANDALONE
- * ROLE_DOMAIN_MEMBER
- * ROLE_DOMAIN_BDC
- * ROLE_DOMAIN_PDC
- * see include/smb.h
- */
- uint32 server_role;
-
- /**Number of domain users*/
- uint32 num_users;
-
- /**Number of domain groups*/
- uint32 num_domain_groups;
-
- /**Number of local groups*/
- uint32 num_local_groups;
-
- /**Comment*/
- char *comment;
-
- /**Domain name*/
- char *domain_name;
-
- /**Server name*/
- char *server_name;
-
- /**Minimum password length*/
- uint16 min_pass_length;
-
- /**How many previous passwords to remember - ie, password cannot be the same as N previous passwords*/
- uint16 pass_history;
-
- /**How long (from now) before passwords expire*/
- CacTime expire;
-
- /**How long (from now) before passwords can be changed*/
- CacTime min_pass_age;
-
- /**How long users are locked out for too many bad password attempts*/
- CacTime lockout_duration;
-
- /**How long before lockouts are reset*/
- CacTime lockout_reset;
-
- /**How many bad password attempts before lockout occurs*/
- uint16 num_bad_attempts;
-} CacDomainInfo;
-
-/**@}*/ /*sam_defs*/
-
-/**@addtogroup svc_defs
- * @{
- */
-typedef struct _CACSERVICE {
- /**The service name*/
- char *service_name;
-
- /**The display name of the service*/
- char *display_name;
-
- /**Current status of the service - see include/rpc_svcctl.h for SERVICE_STATUS definition*/
- SERVICE_STATUS status;
-} CacService;
-
-typedef struct __CACSERVICECONFIG {
- /**The service type*/
- uint32 type;
-
- /**The start type. Should be one of:
- * - SVCCTL_BOOT_START
- * - SVCCTL_SYSTEM_START
- * - SVCCTL_AUTO_START
- * - SVCCTL_DEMAND_START
- */
- uint32 start_type;
-
- uint32 error_control;
-
- /**Path to executable*/
- char *exe_path;
-
- /***/
- char *load_order_group;
-
- uint32 tag_id;
-
- /**Any dependencies for the service*/
- char *dependencies;
-
- /**Run as...*/
- char *start_name;
-
- /**Service display name*/
- char *display_name;
-
-} CacServiceConfig;
-/**@}*/ /*svc_defs*/
-
-#include "libmsrpc_internal.h"
-
-/**
- * @addtogroup handle
- * @{
- */
-
-/**
- * Server handle used to keep track of client/server/pipe information. Use cac_NewServerHandle() to allocate.
- * Initiliaze as many values as possible before calling cac_Connect().
- *
- * @note When allocating memory for the fields, use SMB_MALLOC() (or equivalent) instead of talloc() (or equivalent) -
- * If memory is not allocated for a field, cac_Connect will allocate sizeof(fstring) bytes for it.
- *
- * @note It may be wise to allocate large buffers for these fields and strcpy data into them.
- *
- * @see cac_NewServerHandle()
- * @see cac_FreeHandle()
- */
-typedef struct _CACSERVERHANDLE {
- /** debug level
- */
- int debug;
-
- /** netbios name used to make connections
- */
- char *netbios_name;
-
- /** domain name used to make connections
- */
- char *domain;
-
- /** username used to make connections
- */
- char *username;
-
- /** user's password plain text string
- */
- char *password;
-
- /** name or IP address of server we are currently working with
- */
- char *server;
-
- /**stores the latest NTSTATUS code
- */
- NTSTATUS status;
-
- /** internal. do not modify!
- */
- struct CacServerHandleInternal _internal;
-
-} CacServerHandle;
-
-/*@}*/
-
-/**internal function. do not call this function*/
-SMBCSRV *cac_GetServer(CacServerHandle *hnd);
-
-
-/** @addtogroup Library_Functions
- * @{
- */
-/**
- * Initializes the library - do not need to call this function. Open's smb.conf as well as initializes logging.
- * @param debug Debug level for library to use
- */
-
-void cac_Init(int debug);
-
-/**
- * Creates an un-initialized CacServerHandle
- * @param allocate_fields If True, the function will allocate sizeof(fstring) bytes for all char * fields in the handle
- * @return - un-initialized server handle
- * - NULL if no memory could be allocated
- */
-CacServerHandle * cac_NewServerHandle(bool allocate_fields);
-
-/**
- * Specifies the smbc_get_auth_data_fn to use if you do not want to use the default.
- * @param hnd non-NULL server handle
- * @param auth_fn auth_data_fn to set in server handle
- */
-
-void cac_SetAuthDataFn(CacServerHandle *hnd, smbc_get_auth_data_fn auth_fn);
-
-/** Use your own libsmbclient context - not necessary.
- * @note You must still call cac_Connect() after specifying your own libsmbclient context
- * @param hnd Initialized, but not connected CacServerHandle
- * @param ctx The libsmbclient context you would like to use.
- */
-void cac_SetSmbcContext(CacServerHandle *hnd, SMBCCTX *ctx);
-
-/** Connects to a specified server. If there is already a connection to a different server,
- * it will be cleaned up before connecting to the new server.
- * @param hnd Pre-initialized CacServerHandle
- * @param srv (Optional) Name or IP of the server to connect to. If NULL, server from the CacServerHandle will be used.
- *
- * @return CAC_FAILURE if the operation could not be completed successfully (hnd->status will also be set with a NTSTATUS code)
- * @return CAC_SUCCESS if the operation succeeded
- */
-int cac_Connect(CacServerHandle *hnd, const char *srv);
-
-
-/**
- * Cleans up any data used by the CacServerHandle. If the libsmbclient context was set using cac_SetSmbcContext(), it will not be free'd.
- * @param hnd the CacServerHandle to destroy
- */
-void cac_FreeHandle(CacServerHandle * hnd);
-
-/**
- * Initializes a CacTime structure based on an NTTIME structure
- * If the function fails, then the CacTime structure will be zero'd out
- */
-void cac_InitCacTime(CacTime *cactime, NTTIME nttime);
-
-/**
- * Called by cac_NewServerHandle() if allocate_fields = True. You can call this if you want to, allocates sizeof(fstring) char's for every char * field
- * @param hnd Uninitialized server handle
- * @return CAC_FAILURE Memory could not be allocated
- * @return CAC_SUCCESS Memory was allocated
- */
-int cac_InitHandleMem(CacServerHandle *hnd);
-
-/**
- * Default smbc_get_auth_data_fn for libmsrpc. This function is called when libmsrpc needs to get more information about the
- * client (username/password, workgroup).
- * This function provides simple prompts to the user to enter the information. This description his here so you know how to re-define this function.
- * @see cac_SetAuthDataFn()
- * @param pServer Name/IP of the server to connect to.
- * @param pShare Share name to connect to
- * @param pWorkgroup libmsrpc passes in the workgroup/domain name from hnd->domain. It can be modified in the function.
- * @param maxLenWorkgroup The maximum length of a string pWogroup can hold.
- * @param pUsername libmsrpc passes in the username from hnd->username. It can be modified in the function.
- * @param maxLenUsername The maximum length of a string pUsername can hold.
- * @param pPassword libmsrpc pass in the password from hnd->password. It can be modified in the function.
- * @param maxLenPassword The maximum length of a string pPassword can hold.
- */
-void cac_GetAuthDataFn(const char * pServer,
- const char * pShare,
- char * pWorkgroup,
- int maxLenWorkgroup,
- char * pUsername,
- int maxLenUsername,
- char * pPassword,
- int maxLenPassword);
-
-
-/**@}*/
-
-/*****************
- * LSA Functions *
- *****************/
-
-/** @addtogroup LSA_Functions
- * @{
- */
-
-struct LsaOpenPolicy {
- /**Inputs*/
- struct {
- /**Access Mask. Refer to Security Access Masks in include/rpc_secdes.h*/
- uint32 access;
-
- /**Use security quality of service? (True/False)*/
- bool security_qos;
- } in;
-
- /**Outputs*/
- struct {
- /**Handle to the open policy (needed for all other operations)*/
- POLICY_HND *pol;
- } out;
-};
-
-/**
- * Opens a policy handle on a remote machine.
- * @param hnd fully initialized CacServerHandle for remote machine
- * @param mem_ctx Talloc context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE if the policy could not be opened. hnd->status set with appropriate NTSTATUS
- * @return CAC_SUCCESS if the policy could be opened, the policy handle can be found
- */
-int cac_LsaOpenPolicy(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct LsaOpenPolicy *op);
-
-
-/**
- * Closes an LSA policy handle (Retrieved using cac_LsaOpenPolicy).
- * If successful, the handle will be closed on the server, and memory for pol will be freed
- * @param hnd - An initialized and connected server handle
- * @param mem_ctx Talloc context for memory allocation
- * @param pol - the policy handle to close
- * @return CAC_FAILURE could not close the policy handle, hnd->status is set to the appropriate NTSTATUS error code
- * @return CAC_SUCCESS the policy handle was closed
- */
-int cac_LsaClosePolicy(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, POLICY_HND *pol);
-
-
-struct LsaGetNamesFromSids {
- struct {
- /**handle to and open LSA policy*/
- POLICY_HND *pol;
-
- /**the number of SIDs to lookup*/
- uint32 num_sids;
-
- /**array of SIDs to lookup*/
- DOM_SID *sids;
- } in;
-
- struct {
- /**The number of names returned (in case of CAC_PARTIAL_SUCCESS)*/
- uint32 num_found;
-
- /**array of SID info each index is one sid */
- CacSidInfo *sids;
-
- /**in case of partial success, an array of SIDs that could not be looked up (NULL if all sids were looked up)*/
- DOM_SID *unknown;
- } out;
-};
-
-/**
- * Looks up the names for a list of SIDS
- * @param hnd initialized and connected server handle
- * @param mem_ctx Talloc context for memory allocation
- * @param op input and output parameters
- * @return CAC_FAILURE none of the SIDs could be looked up hnd->status is set with appropriate NTSTATUS error code
- * @return CAC_SUCCESS all of the SIDs were translated and a list of names has been output
- * @return CAC_PARTIAL_SUCCESS not all of the SIDs were translated, as a result the number of returned names is less than the original list of SIDs
- */
-int cac_LsaGetNamesFromSids(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct LsaGetNamesFromSids *op);
-
-struct LsaGetSidsFromNames {
- struct {
- /**handle to an open LSA policy*/
- POLICY_HND *pol;
-
- /**number of SIDs to lookup*/
- uint32 num_names;
-
- /**array of strings listing the names*/
- char **names;
- } in;
-
- struct {
- /**The number of SIDs returned (in case of partial success*/
- uint32 num_found;
-
- /**array of SID info for the looked up names*/
- CacSidInfo *sids;
-
- /**in case of partial success, the names that were not looked up*/
- char **unknown;
- } out;
-};
-
-/**
- * Looks up the SIDs for a list of names
- * @param hnd initialized and connected server handle
- * @param mem_ctx Talloc context for memory allocation
- * @param op input and output parameters
- * @return CAC_FAILURE none of the SIDs could be looked up hnd->status is set with appropriate NTSTATUS error code
- * @return CAC_SUCCESS all of the SIDs were translated and a list of names has been output
- * @return CAC_PARTIAL_SUCCESS not all of the SIDs were translated, as a result the number of returned names is less than the original list of SIDs
- */
-int cac_LsaGetSidsFromNames(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct LsaGetSidsFromNames *op);
-
-struct LsaFetchSid {
- struct {
- /**handle to an open LSA policy*/
- POLICY_HND *pol;
-
- /**can be CAC_LOCAL_INFO, CAC_DOMAIN_INFO, or (CAC_LOCAL_INFO | CAC_DOMAIN_INFO)*/
- uint16 info_class;
- } in;
-
- struct {
- /**the machine's local SID and domain name (NULL if not asked for)*/
- CacSidInfo *local_sid;
-
- /**the machine's domain SID and name (NULL if not asked for)*/
- CacSidInfo *domain_sid;
-
- } out;
-};
-
-/**
- * Looks up the domain or local sid of a machine with an open LSA policy handle
- * @param hnd initialized and connected server handle
- * @param mem_ctx Talloc context for memory allocation
- * @param op input and output parameters
- * @return CAC_FAILURE if the SID could not be fetched
- * @return CAC_SUCCESS if the SID was fetched
- * @return CAC_PARTIAL_SUCCESS if you asked for both local and domain sids but only one was returned
- */
-int cac_LsaFetchSid(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct LsaFetchSid *op);
-
-struct LsaQueryInfoPolicy {
- struct {
- /**Open LSA policy handle on remote server*/
- POLICY_HND *pol;
- } in;
-
- struct {
- /**remote server's domain name*/
- char *domain_name;
-
- /**remote server's dns name*/
- char *dns_name;
-
- /**remote server's forest name*/
- char *forest_name;
-
- /**remote server's domain guid*/
- struct GUID *domain_guid;
-
- /**remote server's domain SID*/
- DOM_SID *domain_sid;
- } out;
-};
-
-/**
- * Retrieves information about the LSA machine/domain
- * @param hnd initialized and connected server handle
- * @param mem_ctx Talloc context for memory allocation
- * @param op input and output parameters
- * Note: for pre-Windows 2000 machines, only op->out.SID and op->out.domain will be set. @see cac_LsaFetchSid
- * @return - CAC_FAILURE if the operation was not successful. hnd->status will be set with an accurate NT_STATUS code
- * @return CAC_SUCCESS the operation was successful.
- */
-int cac_LsaQueryInfoPolicy(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct LsaQueryInfoPolicy *op);
-
-struct LsaEnumSids {
- struct {
- /**Open LSA Policy handle*/
- POLICY_HND *pol;
-
- /**The prefered maximum number of SIDs returned per call*/
- uint32 pref_max_sids;
- } in;
-
- struct {
- /**used to keep track of how many sids have been retrieved over multiple calls
- * should be set to zero via ZERO_STRUCT() befrore the first call. Use the same struct LsaEnumSids for multiple calls*/
- uint32 resume_idx;
-
- /**The number of sids returned this call*/
- uint32 num_sids;
-
- /**Array of sids returned*/
- DOM_SID *sids;
-
- } out;
-};
-
-/**
- * Enumerates the SIDs in the LSA. Can be enumerated in blocks by calling the function multiple times.
- * Example: while(cac_LsaEnumSids(hnd, mem_ctx, op) { ... }
- * @param hnd - An initialized and connected server handle
- * @param mem_ctx Talloc context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE there was an error during operations OR there are no more results
- * @return CAC_SUCCESS the operation completed and results were returned
- */
-int cac_LsaEnumSids(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct LsaEnumSids *op);
-
-struct LsaEnumAccountRights {
- struct {
- /**Open LSA Policy handle*/
- POLICY_HND *pol;
-
- /**(Optional) SID of the account - must supply either sid or name*/
- DOM_SID *sid;
-
- /**(Optional) name of the account - must supply either sid or name*/
- char *name;
- } in;
-
- struct {
- /**Count of rights for this account*/
- uint32 num_privs;
-
- /**array of privilege names*/
- char **priv_names;
- } out;
-};
-
-/**
- * Enumerates rights assigned to a given account. Takes a SID instead of account handle as input
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized Parameters
- * @return CAC_FAILURE the rights could not be retrieved. hnd->status is set with NT_STATUS code
- * @return CAC_SUCCESS the operation was successful.
- */
-
-int cac_LsaEnumAccountRights(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct LsaEnumAccountRights *op);
-
-struct LsaEnumTrustedDomains {
- struct {
- /**Open LSA policy handle*/
- POLICY_HND *pol;
- } in;
-
- struct {
- /**used to keep track of how many domains have been retrieved over multiple calls
- * should be set to zero via ZERO_STRUCT() before the first call. Use the same struct LsaEnumSids for multiple calls*/
- uint32 resume_idx;
-
- /**The number of domains returned by the remote server this call*/
- uint32 num_domains;
-
- /**array of trusted domain names returned by the remote server*/
- char **domain_names;
-
- /**array of trusted domain sids returned by the remote server*/
- DOM_SID *domain_sids;
- } out;
-};
-
-/**
- * Enumerates the trusted domains in the LSA.
- * @param hnd - An initialized and connected server handle
- * @param mem_ctx Talloc context for memory allocation
- * @param op - initialized parameters
- * @return CAC_FAILURE there was an error during operations OR there are no more results
- * @return CAC_SUCCESS the operation completed and results were returned
- */
-int cac_LsaEnumTrustedDomains(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct LsaEnumTrustedDomains *op);
-
-struct LsaOpenTrustedDomain {
- struct {
- /**an open LSA policy handle*/
- POLICY_HND *pol;
-
- /**SID of the trusted domain to open*/
- DOM_SID *domain_sid;
-
- /**Desired access on the open domain*/
- uint32 access;
- } in;
-
- struct {
- /**A handle to the policy that is opened*/
- POLICY_HND *domain_pol;
- } out;
-};
-
-/**
- * Opens a trusted domain by SID.
- * @param hnd An initialized and connected server handle
- * @param mem_ctx Talloc context for memory allocation
- * @param op initialized I/O parameters
- * @return CAC_FAILURE a handle to the domain could not be opened. hnd->status is set with approriate NT_STATUS code
- * @return CAC_SUCCESS the domain was opened successfully
- */
-int cac_LsaOpenTrustedDomain(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct LsaOpenTrustedDomain *op);
-
-struct LsaQueryTrustedDomainInfo {
- struct {
- /**Open LSA policy handle*/
- POLICY_HND *pol;
-
- /**Info class of returned data*/
- uint16 info_class;
-
- /**(Optional)SID of trusted domain to query (must specify either SID or name of trusted domain)*/
- DOM_SID *domain_sid;
-
- /**(Optional)Name of trusted domain to query (must specify either SID or name of trusted domain)*/
- char *domain_name;
- } in;
-
- struct {
- /**information about the trusted domain*/
- LSA_TRUSTED_DOMAIN_INFO *info;
- } out;
-};
-
-/**
- * Retrieves information a trusted domain.
- * @param hnd An initialized and connected server handle
- * @param mem_ctx Talloc context for memory allocation
- * @param op initialized I/O parameters
- * @return CAC_FAILURE a handle to the domain could not be opened. hnd->status is set with approriate NT_STATUS code
- * @return CAC_SUCCESS the domain was opened successfully
- */
-
-int cac_LsaQueryTrustedDomainInfo(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct LsaQueryTrustedDomainInfo *op);
-
-struct LsaEnumPrivileges {
- struct {
- /**An open LSA policy handle*/
- POLICY_HND *pol;
-
- /**The _preferred_ maxinum number of privileges returned per call*/
- uint32 pref_max_privs;
- } in;
-
- struct {
- /**Used to keep track of how many privileges have been retrieved over multiple calls. Do not modify this value between calls*/
- uint32 resume_idx;
-
- /**The number of privileges returned this call*/
- uint32 num_privs;
-
- /**Array of privilege names*/
- char **priv_names;
-
- /**Array of high bits for privilege LUID*/
- uint32 *high_bits;
-
- /**Array of low bits for privilege LUID*/
- uint32 *low_bits;
- } out;
-};
-
-/**
- * Enumerates the Privileges supported by the LSA. Can be enumerated in blocks by calling the function multiple times.
- * Example: while(cac_LsaEnumPrivileges(hnd, mem_ctx, op) { ... }
- * @param hnd An initialized and connected server handle
- * @param mem_ctx Talloc context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE there was an error during operations OR there are no more results
- * @return CAC_SUCCESS the operation completed and results were returned
- * @see CAC_OP_FAILED()
- */
-int cac_LsaEnumPrivileges(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct LsaEnumPrivileges *op);
-
-struct LsaOpenAccount {
- struct {
- /**An open LSA policy handle*/
- POLICY_HND *pol;
-
- /**(Optional) account SID - must supply either sid or name*/
- DOM_SID *sid;
-
- /**(Optional) account name - must supply either sid or name*/
- char *name;
-
- /**desired access for the handle*/
- uint32 access;
- } in;
-
- struct {
- /**A handle to the opened user*/
- POLICY_HND *user;
- } out;
-};
-
-/**
- * Opens a handle to an account in the LSA
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized Parameters
- * @return CAC_FAILURE the account could not be opened. hnd->status has appropriate NT_STATUS code
- * @return CAC_SUCCESS the account was opened
- */
-int cac_LsaOpenAccount(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct LsaOpenAccount *op);
-
-struct LsaAddPrivileges {
- struct {
- /**An open LSA policy handle*/
- POLICY_HND *pol;
-
- /**(Optional) The user's SID (must specify at least sid or name)*/
- DOM_SID *sid;
-
- /**(Optional) The user's name (must specify at least sid or name)*/
- char *name;
-
- /**The privilege names of the privileges to add for the account*/
- char **priv_names;
-
- /**The number of privileges in the priv_names array*/
- uint32 num_privs;
-
- } in;
-};
-
-/**
- * Adds Privileges an account.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized Parameters
- * @return CAC_FAILURE the privileges could not be set. hnd->status has appropriate NT_STATUS code
- * @return CAC_SUCCESS the privileges were set.
- */
-int cac_LsaAddPrivileges(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct LsaAddPrivileges *op);
-
-struct LsaRemovePrivileges {
- struct {
- /**An open handle to the LSA*/
- POLICY_HND *pol;
-
- /**(Optional) The account SID (must specify at least sid or name)*/
- DOM_SID *sid;
-
- /**(Optional) The account name (must specify at least sid or name)*/
- char *name;
-
- /**The privilege names of the privileges to remove from the account*/
- char **priv_names;
-
- /**The number of privileges in the priv_names array*/
- uint32 num_privs;
-
- } in;
-
-};
-
-/**
- * Removes a _specific_ set of privileges from an account
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized Parameters
- * @return CAC_FAILURE the privileges could not be removed. hnd->status is set with NT_STATUS code
- * @return CAC_SUCCESS the privileges were removed
- */
-int cac_LsaRemovePrivileges(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct LsaRemovePrivileges *op);
-
-struct LsaClearPrivileges {
- struct {
- /**An open handle to the LSA*/
- POLICY_HND *pol;
-
- /**(Optional) The user's SID (must specify at least sid or name)*/
- DOM_SID *sid;
-
- /**(Optional) The user's name (must specify at least sid or name)*/
- char *name;
- } in;
-
-};
-
-/**
- * Removes ALL privileges from an account
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized Parameters
- * @return CAC_FAILURE the operation was not successful, hnd->status set with NT_STATUS code
- * @return CAC_SUCCESS the opeartion was successful.
- */
-int cac_LsaClearPrivileges(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct LsaClearPrivileges *op);
-
-/**
- * Sets an accounts priviliges. Removes all privileges and then adds specified privileges.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized Parameters
- * @return CAC_FAILURE The operation could not complete successfully
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_LsaSetPrivileges(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct LsaAddPrivileges *op);
-
-struct LsaGetSecurityObject {
- struct {
- /**Open LSA policy handle*/
- POLICY_HND *pol;
- } in;
-
- struct {
- /**Returned security descriptor information*/
- SEC_DESC_BUF *sec;
- } out;
-};
-
-/**
- * Retrieves Security Descriptor information about the LSA
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized Parameters
- * @return CAC_FAILURE The operation could not complete successfully
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_LsaGetSecurityObject(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct LsaGetSecurityObject *op);
-
-
-/**@}*/ /*LSA_Functions*/
-
-/**********************
- * Registry Functions *
- *********************/
-
-/**@addtogroup Reg_Functions
- * @{
- */
-
-struct RegConnect {
- struct {
- /** must be one of :
- * HKEY_CLASSES_ROOT,
- * HKEY_LOCAL_MACHINE,
- * HKEY_USERS,
- * HKEY_PERFORMANCE_DATA,
- */
- int root;
-
- /**desired access on the root key
- * combination of:
- * REG_KEY_READ,
- * REG_KEY_WRITE,
- * REG_KEY_EXECUTE,
- * REG_KEY_ALL,
- * found in include/rpc_secdes.h*/
- uint32 access;
- } in;
-
- struct {
- POLICY_HND *key;
- } out;
-};
-
-/**
- * Opens a handle to the registry on the server
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized Parameters
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_RegConnect(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegConnect *op);
-
-/**
- * Closes an open registry handle
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param key The Key/Handle to close
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_RegClose(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, POLICY_HND *key);
-
-struct RegOpenKey {
- struct {
- /**(Optional)parent key.
- * If this is NULL, then cac_RegOpenKey() will attempt to connect to the registry, name MUST start with something like:<br>
- * HKEY_LOCAL_MACHINE\ or an abbreviation like HKCR\
- *
- * supported root names:
- * - HKEY_LOCAL_MACHINE\ or HKLM\
- * - HKEY_CLASSES_ROOT\ or HKCR\
- * - HKEY_USERS\ or HKU\
- * - HKEY_PERFORMANCE_DATA or HKPD\
- */
- POLICY_HND *parent_key;
-
- /**name/path of key*/
- char *name;
-
- /**desired access on this key*/
- uint32 access;
- } in;
-
- struct {
- POLICY_HND *key;
- } out;
-};
-
-/**
- * Opens a registry key
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-
-int cac_RegOpenKey(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegOpenKey *op);
-
-struct RegEnumKeys {
- struct {
- /**enumerate subkeys of this key*/
- POLICY_HND *key;
-
- /**maximum number of keys to enumerate each call*/
- uint32 max_keys;
- } in;
-
- struct {
- /**keeps track of the index to resume enumerating*/
- uint32 resume_idx;
-
- /**the number of keys returned this call*/
- uint32 num_keys;
-
- /**array of key names*/
- char **key_names;
-
- /**class names of the keys*/
- char **class_names;
-
- /**last modification time of the key*/
- time_t *mod_times;
- } out;
-};
-
-/**
- * Enumerates Subkeys of a given key. Can be run in a loop. Example: while(cac_RegEnumKeys(hnd, mem_ctx, op)) { ... }
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized Parameters
- * @see CAC_OP_FAILED()
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_RegEnumKeys(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegEnumKeys *op);
-
-
-struct RegCreateKey {
- struct {
- /**create a subkey of parent_key*/
- POLICY_HND *parent_key;
-
- /**name of the key to create*/
- char *key_name;
-
- /**class of the key*/
- char *class_name;
-
- /**Access mask to open the key with. See REG_KEY_* in include/rpc_secdes.h*/
- uint32 access;
- } in;
-
- struct {
- /**Open handle to the key*/
- POLICY_HND *key;
- } out;
-};
-
-/**
- * Creates a registry key, if the key already exists, it will be opened __Creating keys is not currently working__.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized Parmeters
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_RegCreateKey(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegCreateKey *op);
-
-struct RegDeleteKey {
- struct {
- /**handle to open registry key*/
- POLICY_HND *parent_key;
-
- /**name of the key to delete*/
- char *name;
-
- /**delete recursively. WARNING: this might not always work as planned*/
- bool recursive;
- } in;
-
-};
-
-/**
- * Deletes a subkey of an open key. Note: if you run this with op->in.recursive == True, and the operation fails, it may leave the key in an inconsistent state.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-
-int cac_RegDeleteKey(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegDeleteKey *op);
-
-struct RegDeleteValue {
- struct {
- /**handle to open registry key*/
- POLICY_HND *parent_key;
-
- /**name of the value to delete*/
- char *name;
- } in;
-};
-
-/**
- * Deletes a registry value.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized Parameters
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_RegDeleteValue(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegDeleteValue *op);
-
-struct RegQueryKeyInfo {
- struct {
- /**Open handle to the key to query*/
- POLICY_HND *key;
- } in;
-
- struct {
- /**name of the key class*/
- char *class_name;
-
- /**number of subkeys of the key*/
- uint32 num_subkeys;
-
- /**length (in characters) of the longest subkey name*/
- uint32 longest_subkey;
-
- /**length (in characters) of the longest class name*/
- uint32 longest_class;
-
- /**number of values in this key*/
- uint32 num_values;
-
- /**length (in characters) of the longest value name*/
- uint32 longest_value_name;
-
- /**length (in bytes) of the biggest value data*/
- uint32 longest_value_data;
-
- /**size (in bytes) of the security descriptor*/
- uint32 security_desc_size;
-
- /**time of the last write*/
- time_t last_write_time;
- } out;
-};
-
-/**
- * Retrieves information about an open key
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-
-int cac_RegQueryKeyInfo(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegQueryKeyInfo *op);
-
-struct RegSaveKey {
- struct {
- /**Open key to be saved*/
- POLICY_HND *key;
-
- /**The path (on the remote computer) to save the file to*/
- char *filename;
- } in;
-};
-
-/**
- * Saves a key to a file on the remote machine __Not currently working__.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-
-int cac_RegSaveKey(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegSaveKey *op);
-
-struct RegQueryValue {
- struct {
- /**handle to open registry key*/
- POLICY_HND *key;
-
- /**name of the value to query*/
- char *val_name;
- } in;
-
- struct {
- /**Value type.
- * One of:
- * - REG_DWORD (equivalent to REG_DWORD_LE)
- * - REG_DWORD_BE
- * - REG_SZ
- * - REG_EXPAND_SZ
- * - REG_MULTI_SZ
- * - REG_BINARY
- */
- uint32 type;
-
- /**The value*/
- REG_VALUE_DATA *data;
- } out;
-};
-
-/**
- * Retrieves a value (type and data) _not currently working_.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-
-int cac_RegQueryValue(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegQueryValue *op);
-
-struct RegEnumValues {
- struct {
- /**handle to open key*/
- POLICY_HND *key;
-
- /**max number of values returned per call*/
- uint32 max_values;
-
- } in;
-
- struct {
- /**keeps track of the index to resume from - used over multiple calls*/
- uint32 resume_idx;
-
- /**the number of values that were returned this call*/
- uint32 num_values;
-
- /**Array of value types. A type can be one of:
- * - REG_DWORD (equivalent to REG_DWORD_LE)
- * - REG_DWORD_BE
- * - REG_SZ
- * - REG_EXPAND_SZ
- * - REG_MULTI_SZ
- * - REG_BINARY
- */
- uint32 *types;
-
- /**array of strings storing the names of the values*/
- char **value_names;
-
- /**array of pointers to the value data returned*/
- REG_VALUE_DATA **values;
- } out;
-};
-
-/**
- * Enumerates a number of Registry values in an open registry key.
- * Can be run in a loop. Example: while(cac_RegEnumValues(hnd, mem_ctx, op)) { ... }
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized Parameters
- * @see CAC_OP_FAILED()
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_RegEnumValues(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegEnumValues *op);
-
-struct RegSetValue {
- struct {
- /**Handle to open registry key*/
- POLICY_HND *key;
-
- /**Name of the value*/
- char *val_name;
-
- /**Value type.
- * One of:
- * - REG_DWORD (equivalent to REG_DWORD_LE)
- * - REG_DWORD_BE
- * - REG_SZ
- * - REG_EXPAND_SZ
- * - REG_MULTI_SZ
- * - REG_BINARY
- */
- uint32 type;
-
- /**the value*/
- REG_VALUE_DATA value;
- } in;
-};
-
-/**
- * Sets or creates value (type and data).
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_RegSetValue(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegSetValue *op);
-
-struct RegGetVersion {
- struct {
- /**open registry key*/
- POLICY_HND *key;
- } in;
-
- struct {
- /**version number*/
- uint32 version;
- } out;
-};
-
-/**
- * Retrieves the registry version number
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_RegGetVersion(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegGetVersion *op);
-
-struct RegGetKeySecurity {
- struct {
- /**Handle to key to query*/
- POLICY_HND *key;
-
- /**Info that you want. Should be a combination of (1 or more or'd):
- * - OWNER_SECURITY_INFORMATION
- * - GROUP_SECURITY_INFORMATION
- * - DACL_SECURITY_INFORMATION
- * - SACL_SECURITY_INFORMATION
- * - UNPROTECTED_SACL_SECURITY_INFORMATION
- * - UNPROTECTED_DACL_SECURITY_INFORMATION
- * - PROTECTED_SACL_SECURITY_INFORMATION
- * - PROTECTED_DACL_SECURITY_INFORMATION
- *
- * or use:
- * - ALL_SECURITY_INFORMATION
- *
- * all definitions from include/rpc_secdes.h
- */
- uint32 info_type;
- } in;
-
- struct {
- /**size of the data returned*/
- uint32 size;
-
- /**Security descriptor*/
- SEC_DESC *descriptor;
- } out;
-};
-
-/**
- * Retrieves a key security descriptor.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-
-int cac_RegGetKeySecurity(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegGetKeySecurity *op);
-
-struct RegSetKeySecurity {
- struct {
- /**Handle to key to query*/
- POLICY_HND *key;
-
- /**Info that you want. Should be a combination of (1 or more or'd):
- * - OWNER_SECURITY_INFORMATION
- * - GROUP_SECURITY_INFORMATION
- * - DACL_SECURITY_INFORMATION
- * - SACL_SECURITY_INFORMATION
- * - UNPROTECTED_SACL_SECURITY_INFORMATION
- * - UNPROTECTED_DACL_SECURITY_INFORMATION
- * - PROTECTED_SACL_SECURITY_INFORMATION
- * - PROTECTED_DACL_SECURITY_INFORMATION
- *
- * or use:
- * - ALL_SECURITY_INFORMATION
- *
- * all definitions from include/rpc_secdes.h
- */
- uint32 info_type;
-
- /**size of the descriptor*/
- size_t size;
-
- /**Security descriptor*/
- SEC_DESC *descriptor;
- } in;
-};
-
-/**
- * Sets the key security descriptor.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_RegSetKeySecurity(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct RegSetKeySecurity *op);
-
-/**@}*/ /*Reg_Functions*/
-
-struct Shutdown {
- struct {
- /**the message to display (can be NULL)*/
- char *message;
-
- /**timeout in seconds*/
- uint32 timeout;
-
- /**False = shutdown, True = reboot*/
- bool reboot;
-
- /**force the*/
- bool force;
-
- /*FIXME: make this useful*/
- uint32 reason;
- } in;
-};
-
-
-/**
- * Shutdown the server _not currently working_.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_Shutdown(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct Shutdown *op);
-
-/**
- * Attempt to abort initiated shutdown on the server _not currently working_.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_AbortShutdown(CacServerHandle *hnd, TALLOC_CTX *mem_ctx);
-
-/*****************
- * SAM Functions *
- *****************/
-
-/**@addtogroup SAM_Functions
- * @{
- */
-struct SamConnect {
- struct {
- /**Access mask to open with
- * see generic access masks in include/smb.h*/
- uint32 access;
- } in;
-
- struct {
- POLICY_HND *sam;
- } out;
-};
-
-/**
- * Connects to the SAM. This can be skipped by just calling cac_SamOpenDomain()
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-
-int cac_SamConnect(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamConnect *op);
-
-
-/**
- * Closes any (SAM, domain, user, group, etc.) SAM handle.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param sam Handle to close
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-
-int cac_SamClose(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, POLICY_HND *sam);
-
-struct SamOpenDomain {
- struct {
- /**The desired access. See generic access masks - include/smb.h*/
- uint32 access;
-
- /**(Optional) An open handle to the SAM. If it is NULL, the function will connect to the SAM with the access mask above*/
- POLICY_HND *sam;
-
- /**(Optional) The SID of the domain to open.
- * If this this is NULL, the function will attempt to open the domain specified in hnd->domain */
- DOM_SID *sid;
- } in;
-
- struct {
- /**handle to the open domain*/
- POLICY_HND *dom_hnd;
-
- /**Handle to the open SAM*/
- POLICY_HND *sam;
- } out;
-};
-
-/**
- * Opens a handle to a domain. This must be called before any other SAM functions
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_SamOpenDomain(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamOpenDomain *op);
-
-struct SamCreateUser {
- struct {
- /**Open domain handle*/
- POLICY_HND *dom_hnd;
-
- /**Username*/
- char *name;
-
- /**See Allowable account control bits in include/smb.h*/
- uint32 acb_mask;
- } in;
-
- struct {
- /**handle to the user*/
- POLICY_HND *user_hnd;
-
- /**rid of the user*/
- uint32 rid;
- } out;
-};
-
-/**
- * Creates a new domain user, if the account already exists it will _not_ be opened and hnd->status will be NT_STATUS_USER_EXISTS
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-
-int cac_SamCreateUser(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamCreateUser *op);
-
-struct SamOpenUser {
- struct {
- /**Handle to open SAM connection*/
- POLICY_HND *dom_hnd;
-
- /**desired access - see generic access masks in include/smb.h*/
- uint32 access;
-
- /**RID of the user*/
- uint32 rid;
-
- /**(Optional) name of the user - must supply either RID or user name*/
- char *name;
- } in;
-
- struct {
- /**Handle to the user*/
- POLICY_HND *user_hnd;
- } out;
-};
-
-/**
- * Opens a domain user.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_SamOpenUser(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamOpenUser *op);
-
-/**
- * Deletes a domain user.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param user_hnd Open handle to the user
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_SamDeleteUser(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, POLICY_HND *user_hnd);
-
-
-struct SamEnumUsers {
- struct {
- /**Open handle to a domain*/
- POLICY_HND *dom_hnd;
-
- /**Enumerate users with specific ACB. If 0, all users will be enumerated*/
- uint32 acb_mask;
- } in;
-
- struct {
- /**where to resume from. Used over multiple calls*/
- uint32 resume_idx;
-
- /**the number of users returned this call*/
- uint32 num_users;
-
- /**Array storing the rids of the returned users*/
- uint32 *rids;
-
- /**Array storing the names of all the users returned*/
- char **names;
-
- bool done;
- } out;
-};
-
-/**
- * Enumerates domain users. Can be used as a loop condition. Example: while(cac_SamEnumUsers(hnd, mem_ctx, op)) { ... }
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_SamEnumUsers(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamEnumUsers *op);
-
-struct SamGetNamesFromRids {
- struct {
- /**An open handle to the domain SAM from cac_SamOpenDomain()*/
- POLICY_HND *dom_hnd;
-
- /**Number of RIDs to resolve*/
- uint32 num_rids;
-
- /**Array of RIDs to resolve*/
- uint32 *rids;
- } in;
-
- struct {
- /**the number of names returned - if this is 0, the map is NULL*/
- uint32 num_names;
-
- /**array contiaing the Names and RIDs*/
- CacLookupRidsRecord *map;
- } out;
-};
-
-/**
- * Returns a list of names which map to a list of RIDs.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_SamGetNamesFromRids(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamGetNamesFromRids *op);
-
-struct SamGetRidsFromNames {
- struct {
- /**An open handle to the domain SAM from cac_SamOpenDomain()*/
- POLICY_HND *dom_hnd;
-
- /**Number of names to resolve*/
- uint32 num_names;
-
- /**Array of names to resolve*/
- char **names;
- } in;
-
- struct {
- /**the number of names returned - if this is 0, then map is NULL*/
- uint32 num_rids;
-
- /**array contiaing the Names and RIDs*/
- CacLookupRidsRecord *map;
- } out;
-};
-
-/**
- * Returns a list of RIDs which map to a list of names.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_SamGetRidsFromNames(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamGetRidsFromNames *op);
-
-struct SamGetGroupsForUser {
- struct {
- /**An open handle to the user*/
- POLICY_HND *user_hnd;
- } in;
-
- struct {
- /**The number of groups the user is a member of*/
- uint32 num_groups;
-
- /**The RIDs of the groups*/
- uint32 *rids;
-
- /**The attributes of the groups*/
- uint32 *attributes;
- } out;
-};
-/**
- * Retrieves a list of groups that a user is a member of.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_SamGetGroupsForUser(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamGetGroupsForUser *op);
-
-struct SamOpenGroup {
- struct {
- /**Open handle to the domain SAM*/
- POLICY_HND *dom_hnd;
-
- /**Desired access to open the group with. See Generic access masks in include/smb.h*/
- uint32 access;
-
- /**rid of the group*/
- uint32 rid;
- } in;
-
- struct {
- /**Handle to the group*/
- POLICY_HND *group_hnd;
- } out;
-};
-
-/**
- * Opens a domain group.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_SamOpenGroup(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamOpenGroup *op);
-
-struct SamCreateGroup {
- struct {
- /**Open handle to the domain SAM*/
- POLICY_HND *dom_hnd;
-
- /**Desired access to open the group with. See Generic access masks in include/smb.h*/
- uint32 access;
-
- /**The name of the group*/
- char *name;
- } in;
-
- struct {
- /**Handle to the group*/
- POLICY_HND *group_hnd;
- } out;
-};
-
-/**
- * Creates a group. If the group already exists it will not be opened.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_SamCreateGroup(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamCreateGroup *op);
-
-/**
- * Deletes a domain group.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param group_hnd Open handle to the group.
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_SamDeleteGroup(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, POLICY_HND *group_hnd);
-
-struct SamGetGroupMembers {
- struct {
- /**Open handle to a group*/
- POLICY_HND *group_hnd;
- } in;
-
- struct {
- /**The number of members in the group*/
- uint32 num_members;
-
- /**An array storing the RIDs of the users*/
- uint32 *rids;
-
- /**The attributes*/
- uint32 *attributes;
- } out;
-};
-
-/**
- * Retrives a list of users in a group.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_SamGetGroupMembers(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamGetGroupMembers *op);
-
-struct SamAddGroupMember {
- struct {
- /**Open handle to a group*/
- POLICY_HND *group_hnd;
-
- /**RID of new member*/
- uint32 rid;
- } in;
-};
-
-/**
- * Adds a user to a group.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_SamAddGroupMember(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamAddGroupMember *op);
-
-struct SamRemoveGroupMember {
- struct {
- /**Open handle to a group*/
- POLICY_HND *group_hnd;
-
- /**RID of member to remove*/
- uint32 rid;
- } in;
-};
-
-/**
- * Removes a user from a group.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_SamRemoveGroupMember(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamRemoveGroupMember *op);
-
-/**
- * Removes all the members of a group - warning: if this function fails is is possible that some but not all members were removed
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param group_hnd Open handle to the group to clear
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_SamClearGroupMembers(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, POLICY_HND *group_hnd);
-
-struct SamSetGroupMembers {
- struct {
- /**Open handle to the group*/
- POLICY_HND *group_hnd;
-
- /**Number of members in the group - if this is 0, all members of the group will be removed*/
- uint32 num_members;
-
- /**The RIDs of the users to add*/
- uint32 *rids;
- } in;
-};
-
-/**
- * Clears the members of a group and adds a list of members to the group
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_SamSetGroupMembers(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamSetGroupMembers *op);
-
-struct SamEnumGroups {
- struct {
- /**Open handle to a domain*/
- POLICY_HND *dom_hnd;
- } in;
-
- struct {
- /**Where to resume from _do not_ modify this value. Used over multiple calls.*/
- uint32 resume_idx;
-
- /**the number of users returned this call*/
- uint32 num_groups;
-
- /**Array storing the rids of the returned groups*/
- uint32 *rids;
-
- /**Array storing the names of all the groups returned*/
- char **names;
-
- /**Array storing the descriptions of all the groups returned*/
- char **descriptions;
-
- bool done;
- } out;
-};
-
-/**
- * Enumerates domain groups. Can be used as a loop condition. Example: while(cac_SamEnumGroups(hnd, mem_ctx, op)) { ... }
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_SamEnumGroups(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamEnumGroups *op);
-
-struct SamEnumAliases {
- struct {
- /**Open handle to a domain*/
- POLICY_HND *dom_hnd;
- } in;
-
- struct {
- /**where to resume from. Used over multiple calls*/
- uint32 resume_idx;
-
- /**the number of users returned this call*/
- uint32 num_aliases;
-
- /**Array storing the rids of the returned groups*/
- uint32 *rids;
-
- /**Array storing the names of all the groups returned*/
- char **names;
-
- /**Array storing the descriptions of all the groups returned*/
- char **descriptions;
-
- bool done;
- } out;
-};
-
-/**
- * Enumerates domain aliases. Can be used as a loop condition. Example: while(cac_SamEnumAliases(hnd, mem_ctx, op)) { ... }
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_SamEnumAliases(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamEnumAliases *op);
-
-struct SamCreateAlias {
- struct {
- /**Open handle to the domain SAM*/
- POLICY_HND *dom_hnd;
-
- /**The name of the alias*/
- char *name;
- } in;
-
- struct {
- /**Handle to the group*/
- POLICY_HND *alias_hnd;
- } out;
-};
-
-/**
- * Creates an alias. If the alias already exists it will not be opened.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-
-int cac_SamCreateAlias(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamCreateAlias *op);
-
-struct SamOpenAlias {
- struct {
- /**Open handle to the domain SAM*/
- POLICY_HND *dom_hnd;
-
- /**Desired access to open the group with. See Generic access masks in include/smb.h*/
- uint32 access;
-
- /**rid of the alias*/
- uint32 rid;
- } in;
-
- struct {
- /**Handle to the alias*/
- POLICY_HND *alias_hnd;
- } out;
-};
-
-/**
- * Opens a handle to an alias.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_SamOpenAlias(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamOpenAlias *op);
-
-/**
- * Deletes an alias.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param alias_hnd Open handle to the alias
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_SamDeleteAlias(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, POLICY_HND *alias_hnd);
-
-struct SamAddAliasMember {
- struct {
- /**Open handle to a alias*/
- POLICY_HND *alias_hnd;
-
- /**SID of new member*/
- DOM_SID *sid;
- } in;
-};
-
-/**
- * Adds an account to an alias.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_SamAddAliasMember(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamAddAliasMember *op);
-
-struct SamRemoveAliasMember {
- struct {
- /**Open handle to the alias*/
- POLICY_HND *alias_hnd;
-
- /**The SID of the member*/
- DOM_SID *sid;
- } in;
-};
-
-/**
- * Removes an account from an alias.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_SamRemoveAliasMember(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamRemoveAliasMember *op);
-
-struct SamGetAliasMembers {
- struct {
- /**Open handle to the alias*/
- POLICY_HND *alias_hnd;
- } in;
-
- struct {
- /**The number of members*/
- uint32 num_members;
-
- /**An array storing the SIDs of the accounts*/
- DOM_SID *sids;
- } out;
-};
-
-/**
- * Retrieves a list of all accounts in an alias.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_SamGetAliasMembers(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamGetAliasMembers *op);
-
-/**
- * Removes all the members of an alias - warning: if this function fails is is possible that some but not all members were removed
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param alias_hnd Handle to the alias to clear
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-
-int cac_SamClearAliasMembers(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, POLICY_HND *alias_hnd);
-
-struct SamSetAliasMembers {
- struct {
- /**Open handle to the group*/
- POLICY_HND *alias_hnd;
-
- /**Number of members in the group - if this is 0, all members of the group will be removed*/
- uint32 num_members;
-
- /**The SIDs of the accounts to add*/
- DOM_SID *sids;
- } in;
-};
-
-/**
- * Clears the members of an alias and adds a list of members to the alias
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_SamSetAliasMembers(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamSetAliasMembers *op);
-
-
-struct SamUserChangePasswd {
- struct {
- /**The username*/
- char *username;
-
- /**The current password*/
- char *password;
-
- /**The new password*/
- char *new_password;
- } in;
-};
-/**Used by a user to change their password*/
-int cac_SamUserChangePasswd(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamUserChangePasswd *op);
-
-/**
- * Enables a user
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param user_hnd Open handle to the user to enable
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_SamEnableUser(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, POLICY_HND *user_hnd);
-
-/**
- * Disables a user
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param user_hnd Open handle to the user to disables
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_SamDisableUser(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, POLICY_HND *user_hnd);
-
-struct SamSetPassword {
- struct {
- /**Open handle to a user*/
- POLICY_HND *user_hnd;
-
- /**The new password*/
- char *password;
- } in;
-};
-
-/**
- * Sets a user's password
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-
-int cac_SamSetPassword(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamSetPassword *op);
-
-struct SamGetUserInfo {
- struct {
- /**Open Handle to a user*/
- POLICY_HND *user_hnd;
- } in;
-
- struct {
- CacUserInfo *info;
- } out;
-};
-
-/**
- * Retrieves user information using a CacUserInfo structure. If you would like to use a SAM_USERINFO_CTR directly, use cac_SamGetUserInfoCtr()
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @see cac_SamGetUserInfoCtr()
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_SamGetUserInfo(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamGetUserInfo *op);
-
-struct SamSetUserInfo {
- struct {
- /**Open handle to a user*/
- POLICY_HND *user_hnd;
-
- /**Structure containing the data you would like to set*/
- CacUserInfo *info;
- } in;
-};
-
-/**
- * Sets the user info using a CacUserInfo structure. If you would like to use a SAM_USERINFO_CTR directly use cac_SamSetUserInfoCtr().
- * @note All fields in the CacUserInfo structure will be set. Best to call cac_GetUserInfo() modify fields that you want, and then call cac_SetUserInfo().
- * @note When calling this, you _must_ set the user's password.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @see cac_SamSetUserInfoCtr()
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_SamSetUserInfo(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamSetUserInfo *op);
-
-struct SamGetUserInfoCtr {
- struct {
- /**Open handle to a user*/
- POLICY_HND *user_hnd;
-
- /**What USER_INFO structure you want. See include/rpc_samr.h*/
- uint16 info_class;
- } in;
-
- struct {
- /**returned user info*/
- SAM_USERINFO_CTR *ctr;
- } out;
-};
-
-/**
- * Retrieves user information using a SAM_USERINFO_CTR structure. If you don't want to use this structure, user SamGetUserInfo()
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @see cac_SamGetUserInfo()
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_SamGetUserInfoCtr(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamGetUserInfoCtr *op);
-
-struct SamSetUserInfoCtr {
- struct {
- /**Open handle to a user*/
- POLICY_HND *user_hnd;
-
- /**user info - make sure ctr->switch_value is set properly*/
- SAM_USERINFO_CTR *ctr;
- } in;
-};
-
-/**
- * Sets the user info using a SAM_USERINFO_CTR structure. If you don't want to use this structure, use cac_SamSetUserInfo()
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @see cac_SamSetUserInfo()
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-
-int cac_SamSetUserInfoCtr(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamSetUserInfoCtr *op);
-
-struct SamRenameUser {
- struct {
- /**Open handle to user*/
- POLICY_HND *user_hnd;
-
- /**New user name*/
- char *new_name;
- } in;
-};
-
-/**
- * Changes the name of a user.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_SamRenameUser(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamRenameUser *op);
-
-struct SamGetGroupInfo {
- struct {
- /**Open handle to a group*/
- POLICY_HND *group_hnd;
- } in;
-
- struct {
- /**Returned info about the group*/
- CacGroupInfo *info;
- } out;
-};
-
-/**
- * Retrieves information about a group.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_SamGetGroupInfo(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamGetGroupInfo *op);
-
-struct SamSetGroupInfo {
- struct {
- /**Open handle to a group*/
- POLICY_HND *group_hnd;
-
- /**group info*/
- CacGroupInfo *info;
- } in;
-};
-
-/**
- * Sets information about a group.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_SamSetGroupInfo(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamSetGroupInfo *op);
-
-struct SamRenameGroup {
- struct {
- /**Open handle to a group*/
- POLICY_HND *group_hnd;
-
- /**New name*/
- char *new_name;
- } in;
-};
-
-/**
- * Changes the name of a group
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-
-int cac_SamRenameGroup(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamRenameGroup *op);
-
-struct SamGetAliasInfo {
- struct {
- /**Open handle to an alias*/
- POLICY_HND *alias_hnd;
- } in;
-
- struct {
- /**Returned alias info*/
- CacAliasInfo *info;
- } out;
-};
-
-/**
- * Retrieves information about an alias.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_SamGetAliasInfo(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamGetAliasInfo *op);
-
-struct SamSetAliasInfo {
- struct {
- /**Open handle to an alias*/
- POLICY_HND *alias_hnd;
-
- /**Returned alias info*/
- CacAliasInfo *info;
- } in;
-};
-
-/**
- * Sets information about an alias.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE The operation could not complete successfully. hnd->status is set with appropriate NTSTATUS code
- * @return CAC_SUCCESS The operation completed successfully
- */
-int cac_SamSetAliasInfo(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamSetAliasInfo *op);
-
-struct SamGetDomainInfo {
- struct {
- /**Open handle to the domain SAM*/
- POLICY_HND *dom_hnd;
- } in;
-
- struct {
- /**Returned domain info*/
- CacDomainInfo *info;
- } out;
-};
-
-/**
- * Gets domain information in the form of a CacDomainInfo structure.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @see SamGetDomainInfoCtr()
- * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
- * @return CAC_SUCCESS - the operation was successful
- * @return CAC_PARTIAL_SUCCESS - This function makes 3 rpc calls, if one or two fail and the rest succeed,
- * not all fields in the CacDomainInfo structure will be filled
- */
-int cac_SamGetDomainInfo(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamGetDomainInfo *op);
-
-struct SamGetDomainInfoCtr {
- struct {
- /**Open handle to domain*/
- POLICY_HND *dom_hnd;
-
- /**What info level you want*/
- uint16 info_class;
- } in;
-
- struct {
- SAM_UNK_CTR *info;
- } out;
-};
-
-/**
- * Gets domain information in the form of a SAM_UNK_CTR structure.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @see SamGetDomainInfo()
- * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
- * @return CAC_SUCCESS - the operation was successful
- */
-int cac_SamGetDomainInfoCtr(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamGetDomainInfoCtr *op);
-
-struct SamGetDisplayInfo {
- struct {
- /**Open handle to domain*/
- POLICY_HND *dom_hnd;
-
- /**What type of data*/
- uint16 info_class;
-
- /**(Optional)If 0, max_entries and max_size will be filled in by the function*/
- uint32 max_entries;
-
- /**(Optional)If 0, max_entries and max_size will be filled in by the function*/
- uint32 max_size;
- } in;
-
- struct {
- /**Do not modify this value, use the same value between multiple calls (ie in while loop)*/
- uint32 resume_idx;
-
- /**Number of entries returned*/
- uint32 num_entries;
-
- /**Returned display info*/
- SAM_DISPINFO_CTR ctr;
-
- /**Internal value. Do not modify.*/
- uint32 loop_count;
-
- bool done;
- } out;
-};
-
-/**
- * Gets dislpay information using a SAM_DISPINFO_CTR.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
- * @return CAC_SUCCESS - the operation was successful
- */
-int cac_SamGetDisplayInfo(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamGetDisplayInfo *op);
-
-struct SamLookupDomain {
- struct {
- /**Open handle to the sam (opened with cac_SamConnect() or cac_SamOpenDomain()*/
- POLICY_HND *sam;
-
- /**Name of the domain to lookup*/
- char *name;
- } in;
-
- struct {
- /**SID of the domain*/
- DOM_SID *sid;
- } out;
-};
-
-/**
- * Looks up a Domain SID given it's name.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
- * @return CAC_SUCCESS - the operation was successful
- */
-int cac_SamLookupDomain(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamLookupDomain *op);
-
-struct SamGetSecurityObject {
- struct {
- /**An open handle (SAM, domain or user)*/
- POLICY_HND *pol;
- } in;
-
- struct {
- SEC_DESC_BUF *sec;
- } out;
-};
-
-/**
- * Retrievies Security descriptor information for a SAM/Domain/user
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
- * @return CAC_SUCCESS - the operation was successful
- */
-int cac_SamGetSecurityObject(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamGetSecurityObject *op);
-
-struct SamFlush {
- struct {
- /**Open handle to the domain SAM*/
- POLICY_HND *dom_hnd;
-
- /**(Optional)Domain SID. If NULL, the domain in hnd->domain will be opened*/
- DOM_SID *sid;
-
- /**(Optional)Desired access to re-open the domain with. If 0, MAXIMUM_ALLOWED_ACCESS is used.*/
- uint32 access;
- } in;
-};
-
-/**
- * Closes the domain handle, then re-opens it - effectively flushing any changes made.
- * WARNING: if this fails you will no longer have an open handle to the domain SAM.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized Parameters
- * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
- * @return CAC_SUCCESS - the operation was successful
- */
-int cac_SamFlush(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SamFlush *op);
-
-/**@}*/ /*SAM_Functions*/
-
-/**@addtogroup SCM_Functions
- * @{
- */
-
-struct SvcOpenScm {
- struct {
- /**Desired access to open the Handle with. See SC_RIGHT_MGR_* or SC_MANAGER_* in include/rpc_secdes.h*/
- uint32 access;
- } in;
-
- struct {
- /**Handle to the SCM*/
- POLICY_HND *scm_hnd;
- } out;
-};
-
-/**
- * Opens a handle to the SCM on the remote machine.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
- * @return CAC_SUCCESS - the operation was successful
- */
-int cac_SvcOpenScm(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SvcOpenScm *op);
-
-/**
- * Closes an Svc handle (SCM or Service)
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param scm_hnd The handle to close
- * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
- * @return CAC_SUCCESS - the operation was successful
- */
-int cac_SvcClose(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, POLICY_HND *scm_hnd);
-
-struct SvcEnumServices {
- struct {
- /**Open handle to the SCM*/
- POLICY_HND *scm_hnd;
-
- /**(Optional)Type of service to enumerate. Possible values:
- * - SVCCTL_TYPE_WIN32
- * - SVCCTL_TYPE_DRIVER
- * If this is 0, (SVCCTL_TYPE_DRIVER | SVCCTL_TYPE_WIN32) is assumed.
- */
- uint32 type;
-
- /**(Optional)State of service to enumerate. Possible values:
- * - SVCCTL_STATE_ACTIVE
- * - SVCCTL_STATE_INACTIVE
- * - SVCCTL_STATE_ALL
- * If this is 0, SVCCTL_STATE_ALL is assumed.
- */
- uint32 state;
- } in;
-
- struct {
- /**Number of services returned*/
- uint32 num_services;
-
- /**Array of service structures*/
- CacService *services;
- } out;
-};
-
-/**
- * Enumerates services on the remote machine.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized parameters
- * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
- * @return CAC_SUCCESS - the operation was successful
- */
-int cac_SvcEnumServices(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SvcEnumServices *op);
-
-struct SvcOpenService {
- struct {
- /**Handle to the Service Control Manager*/
- POLICY_HND *scm_hnd;
-
- /**Access mask to open service with see SERVICE_* or SC_RIGHT_SVC_* in include/rpc_secdes.h*/
- uint32 access;
-
- /**The name of the service. _not_ the display name*/
- char *name;
- } in;
-
- struct {
- /**Handle to the open service*/
- POLICY_HND *svc_hnd;
- } out;
-};
-
-/**
- * Opens a handle to a service.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized Parameters
- * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
- * @return CAC_SUCCESS - the operation was successful
- */
-
-int cac_SvcOpenService(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SvcOpenService *op);
-
-struct SvcGetStatus {
- struct {
- /**Open handle to the service to query*/
- POLICY_HND *svc_hnd;
- } in;
-
- struct {
- /**The status of the service. See include/rpc_svcctl.h for SERVICE_STATUS definition.*/
- SERVICE_STATUS status;
- } out;
-};
-
-/**
- * Retrieves the status of a service.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized Parameters
- * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
- * @return CAC_SUCCESS - the operation was successful
- */
-int cac_SvcGetStatus(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SvcGetStatus *op);
-
-struct SvcStartService {
- struct {
- /**open handle to the service*/
- POLICY_HND *svc_hnd;
-
- /**Array of parameters to start the service with. Can be NULL if num_parms is 0*/
- char **parms;
-
- /**Number of parameters in the parms array*/
- uint32 num_parms;
-
- /**Number of seconds to wait for the service to actually start. If this is 0, then the status will not be checked after the initial call*/
- uint32 timeout;
- } in;
-};
-
-/**
- * Attempts to start a service.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized Parameters
- * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
- * @return CAC_SUCCESS - the operation was successful
- */
-
-int cac_SvcStartService(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SvcStartService *op);
-
-struct SvcControlService {
- struct {
- /**Open handle to the service to control*/
- POLICY_HND *svc_hnd;
-
- /**The control operation to perform. Possible values (from include/rpc_svcctl.h):
- * - SVCCTL_CONTROL_STOP
- * - SVCCTL_CONTROL_PAUSE
- * - SVCCTL_CONTROL_CONTINUE
- * - SVCCTL_CONTROL_SHUTDOWN
- */
- uint32 control;
- } in;
-
- struct {
- /**The returned status of the service, _immediately_ after the call*/
- SERVICE_STATUS *status;
- } out;
-};
-
-/**
- * Performs a control operation on a service and _immediately_ returns.
- * @see cac_SvcStopService()
- * @see cac_SvcPauseService()
- * @see cac_SvcContinueService()
- * @see cac_SvcShutdownService()
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized Parameters
- * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
- * @return CAC_SUCCESS - the operation was successful
- */
-int cac_SvcControlService(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SvcControlService *op);
-
-struct SvcStopService {
- struct {
- /**Open handle to the service*/
- POLICY_HND *svc_hnd;
-
- /**Number of seconds to wait for the service to actually start.
- * If this is 0, then the status will not be checked after the initial call and CAC_SUCCESS might be returned if the status isn't actually started
- */
- uint32 timeout;
- } in;
-
- struct {
- /**Status of the service after the operation*/
- SERVICE_STATUS status;
- } out;
-};
-
-/**
- * Attempts to stop a service.
- * @see cacSvcControlService()
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized Parameters
- * @return CAC_FAILURE - the operation was not successful. If hnd->status is NT_STATUS_OK, then a timeout occured.
- * @return CAC_SUCCESS - the operation was successful
- */
-int cac_SvcStopService(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SvcStopService *op);
-
-struct SvcPauseService {
- struct {
- /**Open handle to the service*/
- POLICY_HND *svc_hnd;
-
- /**Number of seconds to wait for the service to actually start.
- * If this is 0, then the status will not be checked after the initial call and CAC_SUCCESS might be returned if the status isn't actually started
- */
- uint32 timeout;
- } in;
-
- struct {
- /**Status of the service after the operation*/
- SERVICE_STATUS status;
- } out;
-};
-
-/**
- * Attempts to pause a service.
- * @see cacSvcControlService()
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized Parameters
- * @return CAC_FAILURE - the operation was not successful. If hnd->status is NT_STATUS_OK, then a timeout occured.
- * @return CAC_SUCCESS - the operation was successful
- */
-int cac_SvcPauseService(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SvcPauseService *op);
-
-struct SvcContinueService {
- struct {
- /**Open handle to the service*/
- POLICY_HND *svc_hnd;
-
- /**Number of seconds to wait for the service to actually start.
- * If this is 0, then the status will not be checked after the initial call and CAC_SUCCESS might be returned if the status isn't actually started
- */
- uint32 timeout;
- } in;
-
- struct {
- /**Status of the service after the operation*/
- SERVICE_STATUS status;
- } out;
-};
-
-/**
- * Attempts to continue a paused service.
- * @see cacSvcControlService()
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized Parameters
- * @return CAC_FAILURE - the operation was not successful. If hnd->status is NT_STATUS_OK, then a timeout occured.
- * @return CAC_SUCCESS - the operation was successful
- */
-int cac_SvcContinueService(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SvcContinueService *op);
-
-struct SvcGetDisplayName {
- struct {
- /**Open handle to the service*/
- POLICY_HND *svc_hnd;
- } in;
-
- struct {
- /**The returned display name of the service*/
- char *display_name;
- } out;
-};
-
-/**
- * Retrieves the display name of a service _not currently working_
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized Parameters
- * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
- * @return CAC_SUCCESS - the operation was successful
- */
-int cac_SvcGetDisplayName(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SvcGetDisplayName *op);
-
-struct SvcGetServiceConfig {
- struct {
- /**Open handle to the service*/
- POLICY_HND *svc_hnd;
- } in;
-
- struct {
- /**Returned Configuration information*/
- CacServiceConfig config;
- } out;
-};
-
-/**
- * Retrieves configuration information about a service.
- * @param hnd Initialized and connected server handle
- * @param mem_ctx Context for memory allocation
- * @param op Initialized Parameters
- * @return CAC_FAILURE - the operation was not successful hnd->status is set appropriately
- * @return CAC_SUCCESS - the operation was successful
- */
-int cac_SvcGetServiceConfig(CacServerHandle *hnd, TALLOC_CTX *mem_ctx, struct SvcGetServiceConfig *op);
-
-/**@}*/ /*SCM_Functions*/
-
-struct rpc_pipe_client *cac_GetPipe(CacServerHandle *hnd, int pi_idx);
-
-#endif /* LIBMSRPC_H */
-
-
+++ /dev/null
-/*
- * Unix SMB/CIFS implementation.
- * MS-RPC client internal definitions
- * Copyright (C) Chris Nicholls 2005.
- *
- * 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 LIBMSRPC_INTERNAL_H
-#define LIBMSRPC_INTERNAL_H
-
-#include "libmsrpc.h"
-
-/*definitions*/
-
-struct CacServerHandleInternal {
- /*stores the os type of the server*/
- uint16 srv_level;
-
- /*stores the initialized/active pipes*/
- bool pipes[PI_MAX_PIPES];
-
- /*underlying smbc context*/
- SMBCCTX *ctx;
-
- /*did the user supply this SMBCCTX?*/
- bool user_supplied_ctx;
-};
-
-/*used to get a struct rpc_pipe_client* to be passed into rpccli* calls*/
-
-/*nessecary prototypes*/
-bool rid_in_list(uint32 rid, uint32 *list, uint32 list_len);
-
-int cac_ParseRegPath(char *path, uint32 *reg_type, char **key_name);
-
-REG_VALUE_DATA *cac_MakeRegValueData(TALLOC_CTX *mem_ctx, uint32 data_type, REGVAL_BUFFER buf);
-
-RPC_DATA_BLOB *cac_MakeRpcDataBlob(TALLOC_CTX *mem_ctx, uint32 data_type, REG_VALUE_DATA data);
-
-SAM_USERINFO_CTR *cac_MakeUserInfoCtr(TALLOC_CTX *mem_ctx, CacUserInfo *info);
-
-CacUserInfo *cac_MakeUserInfo(TALLOC_CTX *mem_ctx, SAM_USERINFO_CTR *ctr);
-CacGroupInfo *cac_MakeGroupInfo(TALLOC_CTX *mem_ctx, GROUP_INFO_CTR *ctr);
-GROUP_INFO_CTR *cac_MakeGroupInfoCtr(TALLOC_CTX *mem_ctx, CacGroupInfo *info);
-CacAliasInfo *cac_MakeAliasInfo(TALLOC_CTX *mem_ctx, ALIAS_INFO_CTR ctr);
-ALIAS_INFO_CTR *cac_MakeAliasInfoCtr(TALLOC_CTX *mem_ctx, CacAliasInfo *info);
-CacDomainInfo *cac_MakeDomainInfo(TALLOC_CTX *mem_ctx, SAM_UNK_INFO_1 *info1, SAM_UNK_INFO_2 *info2, SAM_UNK_INFO_12 *info12);
-CacService *cac_MakeServiceArray(TALLOC_CTX *mem_ctx, ENUM_SERVICES_STATUS *svc, uint32 num_services);
-int cac_InitCacServiceConfig(TALLOC_CTX *mem_ctx, SERVICE_CONFIG *src, CacServiceConfig *dest);
-
-/*moved to libmsrpc.h*/
-/*struct rpc_pipe_client *cac_GetPipe(CacServerHandle *hnd, int pi_idx);*/
-
-SMBCSRV *smbc_attr_server(SMBCCTX *context,
- const char *server, const char *share,
- fstring workgroup,
- fstring username, fstring password,
- POLICY_HND *pol);
-
-
-#endif /* LIBMSRPC_INTERNAL_H */
+++ /dev/null
-#ifndef MD5_H
-#define MD5_H
-#ifndef HEADER_MD5_H
-/* Try to avoid clashes with OpenSSL */
-#define HEADER_MD5_H
-#endif
-
-struct MD5Context {
- uint32 buf[4];
- uint32 bits[2];
- unsigned char in[64];
-};
-
-void MD5Init(struct MD5Context *context);
-void MD5Update(struct MD5Context *context, unsigned char const *buf,
- unsigned len);
-void MD5Final(unsigned char digest[16], struct MD5Context *context);
-
-#endif /* !MD5_H */
} packet;
};
-/* NETLOGON opcodes */
-
-#define QUERYFORPDC 7 /* Query for PDC. */
-#define SAM_UAS_CHANGE 10 /* Announce change to UAS or SAM. */
-#define QUERYFORPDC_R 12 /* Response to Query for PDC. */
-#define SAMLOGON 18
-#define SAMLOGON_R 19
-#define SAMLOGON_UNK_R 21
-#define SAMLOGON_AD_UNK_R 23
-#define SAMLOGON_AD_R 25
-
/* Ids for netbios packet types. */
#define ANN_HostAnnouncement 1
#define NEXT_JOBID(j) ((j+1) % PRINT_MAX_JOBID > 0 ? (j+1) % PRINT_MAX_JOBID : 1)
#define MAX_CACHE_VALID_TIME 3600
+#define CUPS_DEFAULT_CONNECTION_TIMEOUT 30
#ifndef PRINT_SPOOL_PREFIX
#define PRINT_SPOOL_PREFIX "smbprn."
/* The following definitions come from auth/auth_domain.c */
-NTSTATUS auth_domain_init(void) ;
+void attempt_machine_password_change(void);
+NTSTATUS auth_domain_init(void);
+
+NTSTATUS auth_netlogond_init(void);
/* The following definitions come from auth/auth_ntlmssp.c */
void *private_data);
bool connections_init(bool rw);
-/* The following definitions come from lib/crc32.c */
-
-uint32 crc32_calc_buffer(const char *buf, size_t size);
-
/* The following definitions come from lib/data_blob.c */
DATA_BLOB data_blob(const void *p, size_t length);
/* The following definitions come from lib/display_sec.c */
char *get_sec_mask_str(TALLOC_CTX *ctx, uint32 type);
-void display_sec_access(SEC_ACCESS *info);
+void display_sec_access(uint32_t *info);
void display_sec_ace_flags(uint8_t flags);
void display_sec_ace(SEC_ACE *ace);
void display_sec_acl(SEC_ACL *sec_acl);
/* The following definitions come from lib/errmap_unix.c */
NTSTATUS map_nt_error_from_unix(int unix_error);
+int map_errno_from_nt_status(NTSTATUS status);
/* The following definitions come from lib/events.c */
void generate_random_buffer( unsigned char *out, int len);
char *generate_random_str(size_t len);
-/* The following definitions come from lib/hmacmd5.c */
-
-void hmac_md5_init_rfc2104(const unsigned char *key, int key_len, HMACMD5Context *ctx);
-void hmac_md5_init_limK_to_64(const unsigned char* key, int key_len,
- HMACMD5Context *ctx);
-void hmac_md5_update(const unsigned char *text, int text_len, HMACMD5Context *ctx);
-void hmac_md5_final(unsigned char *digest, HMACMD5Context *ctx);
-void hmac_md5( unsigned char key[16], const unsigned char *data, int data_len,
- unsigned char *digest);
-
/* The following definitions come from lib/iconv.c */
NTSTATUS smb_register_charset(struct charset_functions *funcs) ;
void mdfour(unsigned char *out, const unsigned char *in, int n);
-/* The following definitions come from lib/md5.c */
-
-void MD5Init(struct MD5Context *ctx);
-void MD5Update(struct MD5Context *ctx, unsigned char const *buf, unsigned len);
-void MD5Final(unsigned char digest[16], struct MD5Context *ctx);
-
/* The following definitions come from lib/module.c */
NTSTATUS smb_load_module(const char *module_name);
/* The following definitions come from lib/readline.c */
+void smb_readline_done(void);
char *smb_readline(const char *prompt, void (*callback)(void),
char **(completion_fn)(const char *text, int start, int end));
const char *smb_readline_get_line_buffer(void);
NTSTATUS sec_desc_del_sid(TALLOC_CTX *ctx, SEC_DESC **psd, DOM_SID *sid, size_t *sd_size);
SEC_DESC_BUF *se_create_child_secdesc(TALLOC_CTX *ctx, SEC_DESC *parent_ctr,
bool child_container);
-void init_sec_access(uint32 *t, uint32 mask);
/* The following definitions come from lib/select.c */
/* The following definitions come from lib/util_seaccess.c */
void se_map_generic(uint32 *access_mask, const struct generic_mapping *mapping);
+void security_acl_map_generic(struct security_acl *sa, const struct generic_mapping *mapping);
void se_map_standard(uint32 *access_mask, struct standard_mapping *mapping);
bool se_access_check(const SEC_DESC *sd, const NT_USER_TOKEN *token,
uint32 acc_desired, uint32 *acc_granted,
struct netr_SamInfo3 **info3);
/* The following definitions come from libads/cldap.c */
-
bool ads_cldap_netlogon(TALLOC_CTX *mem_ctx,
const char *server,
const char *realm,
- uint32_t *nt_version,
- union nbt_cldap_netlogon **reply);
+ uint32_t nt_version,
+ struct netlogon_samlogon_response **reply);
bool ads_cldap_netlogon_5(TALLOC_CTX *mem_ctx,
const char *server,
const char *realm,
- struct nbt_cldap_netlogon_5 *reply5);
-bool pull_mailslot_cldap_reply(TALLOC_CTX *mem_ctx,
- const DATA_BLOB *blob,
- union nbt_cldap_netlogon *r,
- uint32_t *nt_version);
+ struct NETLOGON_SAM_LOGON_RESPONSE_EX *reply5);
/* The following definitions come from libads/disp_sec.c */
ADS_STATUS ads_guess_service_principal(ADS_STRUCT *ads,
char **returned_principal);
-/* The following definitions come from libcli/nbt/nbtname.c */
-
-_PUBLIC_ void ndr_print_nbt_string(struct ndr_print *ndr, const char *name, const char *s);
-_PUBLIC_ enum ndr_err_code ndr_pull_nbt_string(struct ndr_pull *ndr, int ndr_flags, const char **s);
-_PUBLIC_ enum ndr_err_code ndr_push_nbt_string(struct ndr_push *ndr, int ndr_flags, const char *s);
-_PUBLIC_ enum ndr_err_code ndr_pull_nbt_name(struct ndr_pull *ndr, int ndr_flags, struct nbt_name *r);
-_PUBLIC_ enum ndr_err_code ndr_push_nbt_name(struct ndr_push *ndr, int ndr_flags, const struct nbt_name *r);
-_PUBLIC_ NTSTATUS nbt_name_dup(TALLOC_CTX *mem_ctx, struct nbt_name *name, struct nbt_name *newname);
-_PUBLIC_ NTSTATUS nbt_name_to_blob(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, struct nbt_name *name);
-_PUBLIC_ NTSTATUS nbt_name_from_blob(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob, struct nbt_name *name);
-_PUBLIC_ void nbt_choose_called_name(TALLOC_CTX *mem_ctx,
- struct nbt_name *n, const char *name, int type);
-_PUBLIC_ char *nbt_name_string(TALLOC_CTX *mem_ctx, const struct nbt_name *name);
-_PUBLIC_ enum ndr_err_code ndr_pull_wrepl_nbt_name(struct ndr_pull *ndr, int ndr_flags, const struct nbt_name **_r);
-_PUBLIC_ enum ndr_err_code ndr_push_wrepl_nbt_name(struct ndr_push *ndr, int ndr_flags, const struct nbt_name *r);
-_PUBLIC_ void ndr_print_wrepl_nbt_name(struct ndr_print *ndr, const char *name, const struct nbt_name *r);
-
/* The following definitions come from libgpo/gpext/gpext.c */
struct gp_extension *get_gp_extension_list(void);
_PUBLIC_ enum ndr_err_code ndr_pull_samr_RejectReason(struct ndr_pull *ndr, int ndr_flags, enum samr_RejectReason *r);
_PUBLIC_ void ndr_print_samr_RejectReason(struct ndr_print *ndr, const char *name, enum samr_RejectReason r);
-/* The following definitions come from librpc/gen_ndr/ndr_nbt.c */
-
-_PUBLIC_ void ndr_print_nbt_operation(struct ndr_print *ndr, const char *name, uint16_t r);
-_PUBLIC_ void ndr_print_nbt_name_type(struct ndr_print *ndr, const char *name, enum nbt_name_type r);
-_PUBLIC_ void ndr_print_nbt_name(struct ndr_print *ndr, const char *name, const struct nbt_name *r);
-_PUBLIC_ void ndr_print_nbt_qclass(struct ndr_print *ndr, const char *name, enum nbt_qclass r);
-_PUBLIC_ void ndr_print_nbt_qtype(struct ndr_print *ndr, const char *name, enum nbt_qtype r);
-_PUBLIC_ void ndr_print_nbt_name_question(struct ndr_print *ndr, const char *name, const struct nbt_name_question *r);
-_PUBLIC_ void ndr_print_nb_flags(struct ndr_print *ndr, const char *name, uint16_t r);
-_PUBLIC_ void ndr_print_nbt_rdata_address(struct ndr_print *ndr, const char *name, const struct nbt_rdata_address *r);
-_PUBLIC_ void ndr_print_nbt_rdata_netbios(struct ndr_print *ndr, const char *name, const struct nbt_rdata_netbios *r);
-_PUBLIC_ void ndr_print_nbt_statistics(struct ndr_print *ndr, const char *name, const struct nbt_statistics *r);
-_PUBLIC_ void ndr_print_nbt_status_name(struct ndr_print *ndr, const char *name, const struct nbt_status_name *r);
-_PUBLIC_ void ndr_print_nbt_rdata_status(struct ndr_print *ndr, const char *name, const struct nbt_rdata_status *r);
-_PUBLIC_ void ndr_print_nbt_rdata_data(struct ndr_print *ndr, const char *name, const struct nbt_rdata_data *r);
-_PUBLIC_ void ndr_print_nbt_rdata(struct ndr_print *ndr, const char *name, const union nbt_rdata *r);
-_PUBLIC_ void ndr_print_nbt_res_rec(struct ndr_print *ndr, const char *name, const struct nbt_res_rec *r);
-_PUBLIC_ enum ndr_err_code ndr_push_nbt_name_packet(struct ndr_push *ndr, int ndr_flags, const struct nbt_name_packet *r);
-_PUBLIC_ enum ndr_err_code ndr_pull_nbt_name_packet(struct ndr_pull *ndr, int ndr_flags, struct nbt_name_packet *r);
-_PUBLIC_ void ndr_print_nbt_name_packet(struct ndr_print *ndr, const char *name, const struct nbt_name_packet *r);
-_PUBLIC_ void ndr_print_dgram_msg_type(struct ndr_print *ndr, const char *name, enum dgram_msg_type r);
-_PUBLIC_ void ndr_print_dgram_flags(struct ndr_print *ndr, const char *name, uint8_t r);
-_PUBLIC_ void ndr_print_smb_command(struct ndr_print *ndr, const char *name, enum smb_command r);
-_PUBLIC_ void ndr_print_smb_trans_body(struct ndr_print *ndr, const char *name, const struct smb_trans_body *r);
-_PUBLIC_ void ndr_print_smb_body(struct ndr_print *ndr, const char *name, const union smb_body *r);
-_PUBLIC_ enum ndr_err_code ndr_push_dgram_smb_packet(struct ndr_push *ndr, int ndr_flags, const struct dgram_smb_packet *r);
-_PUBLIC_ enum ndr_err_code ndr_pull_dgram_smb_packet(struct ndr_pull *ndr, int ndr_flags, struct dgram_smb_packet *r);
-_PUBLIC_ void ndr_print_dgram_smb_packet(struct ndr_print *ndr, const char *name, const struct dgram_smb_packet *r);
-_PUBLIC_ void ndr_print_dgram_message_body(struct ndr_print *ndr, const char *name, const union dgram_message_body *r);
-_PUBLIC_ void ndr_print_dgram_message(struct ndr_print *ndr, const char *name, const struct dgram_message *r);
-_PUBLIC_ void ndr_print_dgram_err_code(struct ndr_print *ndr, const char *name, enum dgram_err_code r);
-_PUBLIC_ void ndr_print_dgram_data(struct ndr_print *ndr, const char *name, const union dgram_data *r);
-_PUBLIC_ enum ndr_err_code ndr_push_nbt_dgram_packet(struct ndr_push *ndr, int ndr_flags, const struct nbt_dgram_packet *r);
-_PUBLIC_ enum ndr_err_code ndr_pull_nbt_dgram_packet(struct ndr_pull *ndr, int ndr_flags, struct nbt_dgram_packet *r);
-_PUBLIC_ void ndr_print_nbt_dgram_packet(struct ndr_print *ndr, const char *name, const struct nbt_dgram_packet *r);
-_PUBLIC_ void ndr_print_nbt_netlogon_command(struct ndr_print *ndr, const char *name, enum nbt_netlogon_command r);
-_PUBLIC_ void ndr_print_nbt_netlogon_version(struct ndr_print *ndr, const char *name, uint32_t r);
-_PUBLIC_ void ndr_print_nbt_netlogon_query_for_pdc(struct ndr_print *ndr, const char *name, const struct nbt_netlogon_query_for_pdc *r);
-_PUBLIC_ void ndr_print_nbt_netlogon_query_for_pdc2(struct ndr_print *ndr, const char *name, const struct nbt_netlogon_query_for_pdc2 *r);
-_PUBLIC_ void ndr_print_nbt_netlogon_response_from_pdc(struct ndr_print *ndr, const char *name, const struct nbt_netlogon_response_from_pdc *r);
-_PUBLIC_ void ndr_print_nbt_server_type(struct ndr_print *ndr, const char *name, uint32_t r);
-_PUBLIC_ void ndr_print_nbt_dc_sock_addr(struct ndr_print *ndr, const char *name, const struct nbt_dc_sock_addr *r);
-_PUBLIC_ void ndr_print_nbt_netlogon_response_from_pdc2(struct ndr_print *ndr, const char *name, const struct nbt_netlogon_response_from_pdc2 *r);
-_PUBLIC_ void ndr_print_nbt_db_change(struct ndr_print *ndr, const char *name, const struct nbt_db_change *r);
-_PUBLIC_ void ndr_print_nbt_netlogon_announce_uas(struct ndr_print *ndr, const char *name, const struct nbt_netlogon_announce_uas *r);
-_PUBLIC_ void ndr_print_nbt_netlogon_request(struct ndr_print *ndr, const char *name, const union nbt_netlogon_request *r);
-_PUBLIC_ enum ndr_err_code ndr_push_nbt_netlogon_packet(struct ndr_push *ndr, int ndr_flags, const struct nbt_netlogon_packet *r);
-_PUBLIC_ enum ndr_err_code ndr_pull_nbt_netlogon_packet(struct ndr_pull *ndr, int ndr_flags, struct nbt_netlogon_packet *r);
-_PUBLIC_ void ndr_print_nbt_netlogon_packet(struct ndr_print *ndr, const char *name, const struct nbt_netlogon_packet *r);
-_PUBLIC_ void ndr_print_nbt_cldap_netlogon_1(struct ndr_print *ndr, const char *name, const struct nbt_cldap_netlogon_1 *r);
-_PUBLIC_ void ndr_print_nbt_cldap_netlogon_3(struct ndr_print *ndr, const char *name, const struct nbt_cldap_netlogon_3 *r);
-_PUBLIC_ enum ndr_err_code ndr_push_nbt_cldap_netlogon_5(struct ndr_push *ndr, int ndr_flags, const struct nbt_cldap_netlogon_5 *r);
-_PUBLIC_ enum ndr_err_code ndr_pull_nbt_cldap_netlogon_5(struct ndr_pull *ndr, int ndr_flags, struct nbt_cldap_netlogon_5 *r);
-_PUBLIC_ void ndr_print_nbt_cldap_netlogon_5(struct ndr_print *ndr, const char *name, const struct nbt_cldap_netlogon_5 *r);
-_PUBLIC_ void ndr_print_nbt_cldap_netlogon_13(struct ndr_print *ndr, const char *name, const struct nbt_cldap_netlogon_13 *r);
-_PUBLIC_ enum ndr_err_code ndr_push_nbt_cldap_netlogon_15(struct ndr_push *ndr, int ndr_flags, const struct nbt_cldap_netlogon_15 *r);
-_PUBLIC_ enum ndr_err_code ndr_pull_nbt_cldap_netlogon_15(struct ndr_pull *ndr, int ndr_flags, struct nbt_cldap_netlogon_15 *r);
-_PUBLIC_ void ndr_print_nbt_cldap_netlogon_15(struct ndr_print *ndr, const char *name, const struct nbt_cldap_netlogon_15 *r);
-_PUBLIC_ enum ndr_err_code ndr_push_nbt_cldap_netlogon_29(struct ndr_push *ndr, int ndr_flags, const struct nbt_cldap_netlogon_29 *r);
-_PUBLIC_ enum ndr_err_code ndr_pull_nbt_cldap_netlogon_29(struct ndr_pull *ndr, int ndr_flags, struct nbt_cldap_netlogon_29 *r);
-_PUBLIC_ void ndr_print_nbt_cldap_netlogon_29(struct ndr_print *ndr, const char *name, const struct nbt_cldap_netlogon_29 *r);
-_PUBLIC_ enum ndr_err_code ndr_push_nbt_cldap_netlogon(struct ndr_push *ndr, int ndr_flags, const union nbt_cldap_netlogon *r);
-_PUBLIC_ enum ndr_err_code ndr_pull_nbt_cldap_netlogon(struct ndr_pull *ndr, int ndr_flags, union nbt_cldap_netlogon *r);
-_PUBLIC_ void ndr_print_nbt_cldap_netlogon(struct ndr_print *ndr, const char *name, const union nbt_cldap_netlogon *r);
-_PUBLIC_ void ndr_print_nbt_ntlogon_command(struct ndr_print *ndr, const char *name, enum nbt_ntlogon_command r);
-_PUBLIC_ void ndr_print_nbt_ntlogon_sam_logon(struct ndr_print *ndr, const char *name, const struct nbt_ntlogon_sam_logon *r);
-_PUBLIC_ void ndr_print_nbt_ntlogon_sam_logon_reply(struct ndr_print *ndr, const char *name, const struct nbt_ntlogon_sam_logon_reply *r);
-_PUBLIC_ void ndr_print_nbt_ntlogon_request(struct ndr_print *ndr, const char *name, const union nbt_ntlogon_request *r);
-_PUBLIC_ enum ndr_err_code ndr_push_nbt_ntlogon_packet(struct ndr_push *ndr, int ndr_flags, const struct nbt_ntlogon_packet *r);
-_PUBLIC_ enum ndr_err_code ndr_pull_nbt_ntlogon_packet(struct ndr_pull *ndr, int ndr_flags, struct nbt_ntlogon_packet *r);
-_PUBLIC_ void ndr_print_nbt_ntlogon_packet(struct ndr_print *ndr, const char *name, const struct nbt_ntlogon_packet *r);
-_PUBLIC_ void ndr_print_nbt_browse_opcode(struct ndr_print *ndr, const char *name, enum nbt_browse_opcode r);
-_PUBLIC_ void ndr_print_nbt_browse_host_announcement(struct ndr_print *ndr, const char *name, const struct nbt_browse_host_announcement *r);
-_PUBLIC_ void ndr_print_nbt_browse_announcement_request(struct ndr_print *ndr, const char *name, const struct nbt_browse_announcement_request *r);
-_PUBLIC_ void ndr_print_nbt_browse_election_request(struct ndr_print *ndr, const char *name, const struct nbt_browse_election_request *r);
-_PUBLIC_ void ndr_print_nbt_browse_backup_list_request(struct ndr_print *ndr, const char *name, const struct nbt_browse_backup_list_request *r);
-_PUBLIC_ void ndr_print_nbt_browse_backup_list_response(struct ndr_print *ndr, const char *name, const struct nbt_browse_backup_list_response *r);
-_PUBLIC_ void ndr_print_nbt_browse_become_backup(struct ndr_print *ndr, const char *name, const struct nbt_browse_become_backup *r);
-_PUBLIC_ void ndr_print_nbt_browse_domain_announcement(struct ndr_print *ndr, const char *name, const struct nbt_browse_domain_announcement *r);
-_PUBLIC_ void ndr_print_nbt_browse_master_announcement(struct ndr_print *ndr, const char *name, const struct nbt_browse_master_announcement *r);
-_PUBLIC_ void ndr_print_nbt_browse_reset_state(struct ndr_print *ndr, const char *name, const struct nbt_browse_reset_state *r);
-_PUBLIC_ void ndr_print_nbt_browse_local_master_announcement(struct ndr_print *ndr, const char *name, const struct nbt_browse_local_master_announcement *r);
-_PUBLIC_ void ndr_print_nbt_browse_payload(struct ndr_print *ndr, const char *name, const union nbt_browse_payload *r);
-_PUBLIC_ enum ndr_err_code ndr_push_nbt_browse_packet(struct ndr_push *ndr, int ndr_flags, const struct nbt_browse_packet *r);
-_PUBLIC_ enum ndr_err_code ndr_pull_nbt_browse_packet(struct ndr_pull *ndr, int ndr_flags, struct nbt_browse_packet *r);
-_PUBLIC_ void ndr_print_nbt_browse_packet(struct ndr_print *ndr, const char *name, const struct nbt_browse_packet *r);
-
/* The following definitions come from librpc/gen_ndr/ndr_netlogon.c */
_PUBLIC_ void ndr_print_netr_UasInfo(struct ndr_print *ndr, const char *name, const struct netr_UasInfo *r);
/* The following definitions come from librpc/ndr/ndr.c */
_PUBLIC_ size_t ndr_align_size(uint32_t offset, size_t n);
-_PUBLIC_ struct ndr_pull *ndr_pull_init_blob(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx);
+_PUBLIC_ struct ndr_pull *ndr_pull_init_blob(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience);
_PUBLIC_ enum ndr_err_code ndr_pull_advance(struct ndr_pull *ndr, uint32_t size);
_PUBLIC_ void ndr_pull_save(struct ndr_pull *ndr, struct ndr_pull_save *save);
_PUBLIC_ void ndr_pull_restore(struct ndr_pull *ndr, struct ndr_pull_save *save);
_PUBLIC_ uint32_t ndr_push_get_switch_value(struct ndr_push *ndr, const void *p);
_PUBLIC_ uint32_t ndr_pull_get_switch_value(struct ndr_pull *ndr, const void *p);
_PUBLIC_ uint32_t ndr_print_get_switch_value(struct ndr_print *ndr, const void *p);
-_PUBLIC_ enum ndr_err_code ndr_pull_struct_blob(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx, void *p,
- ndr_pull_flags_fn_t fn);
-_PUBLIC_ enum ndr_err_code ndr_pull_struct_blob_all(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx, void *p,
- ndr_pull_flags_fn_t fn);
+_PUBLIC_ enum ndr_err_code ndr_pull_struct_blob(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, void *p, ndr_pull_flags_fn_t fn);
+_PUBLIC_ enum ndr_err_code ndr_pull_struct_blob_all(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx,
+ struct smb_iconv_convenience *iconv_convenience,
+ void *p, ndr_pull_flags_fn_t fn);
_PUBLIC_ enum ndr_err_code ndr_pull_union_blob(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx, void *p,
uint32_t level, ndr_pull_flags_fn_t fn);
_PUBLIC_ enum ndr_err_code ndr_pull_union_blob_all(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx, void *p,
uint32_t level, ndr_pull_flags_fn_t fn);
-_PUBLIC_ enum ndr_err_code ndr_push_struct_blob(DATA_BLOB *blob, TALLOC_CTX *mem_ctx, const void *p,
- ndr_push_flags_fn_t fn);
+_PUBLIC_ enum ndr_err_code ndr_push_struct_blob(DATA_BLOB *blob, TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, const void *p, ndr_push_flags_fn_t fn);
_PUBLIC_ enum ndr_err_code ndr_push_union_blob(DATA_BLOB *blob, TALLOC_CTX *mem_ctx, void *p,
uint32_t level, ndr_push_flags_fn_t fn);
_PUBLIC_ size_t ndr_size_struct(const void *p, int flags, ndr_push_flags_fn_t push);
const char *domain_name,
uint32_t *nt_version,
const char **dc_name,
- union nbt_cldap_netlogon **reply);
+ struct netlogon_samlogon_response **reply);
/* The following definitions come from libsmb/clientgen.c */
char *lp_cups_options(int );
char *lp_cups_server(void);
char *lp_iprint_server(void);
+int lp_cups_connection_timeout(void);
const char *lp_ctdbd_socket(void);
const char **lp_cluster_addresses(void);
bool lp_clustering(void);
struct parm_struct *lp_get_parameter(const char *param_name);
struct parm_struct *lp_next_parameter(int snum, int *i, int allparameters);
bool lp_snum_ok(int iService);
-void lp_add_one_printer(char *name, char *comment);
+void lp_add_one_printer(const char *name, const char *comment, void *pdata);
bool lp_loaded(void);
void lp_killunused(bool (*snumused) (int));
void lp_kill_all_services(void);
struct dcinfo **ppdc);
bool secrets_store_generic(const char *owner, const char *key, const char *secret);
char *secrets_fetch_generic(const char *owner, const char *key);
+bool secrets_store_local_schannel_key(uint8_t schannel_key[16]);
+bool secrets_fetch_local_schannel_key(uint8_t schannel_key[16]);
/* The following definitions come from passdb/util_builtin.c */
/* The following definitions come from printing/pcap.c */
+bool pcap_cache_add_specific(struct pcap_cache **ppcache, const char *name, const char *comment);
+void pcap_cache_destroy_specific(struct pcap_cache **ppcache);
bool pcap_cache_add(const char *name, const char *comment);
bool pcap_cache_loaded(void);
+void pcap_cache_replace(const struct pcap_cache *cache);
void pcap_cache_reload(void);
bool pcap_printername_ok(const char *printername);
-void pcap_printer_fn(void (*fn)(char *, char *));
+void pcap_printer_fn_specific(const struct pcap_cache *, void (*fn)(const char *, const char *, void *), void *);
+void pcap_printer_fn(void (*fn)(const char *, const char *, void *), void *);
/* The following definitions come from printing/print_aix.c */
DATA_BLOB lm_response,
DATA_BLOB nt_response,
struct netr_SamInfo3 **info3);
+NTSTATUS rpccli_netlogon_set_trust_password(struct rpc_pipe_client *cli,
+ TALLOC_CTX *mem_ctx,
+ const unsigned char orig_trust_passwd_hash[16],
+ const char *new_trust_pwd_cleartext,
+ const unsigned char new_trust_passwd_hash[16],
+ uint32_t sec_channel_type);
/* The following definitions come from rpc_client/cli_pipe.c */
const char *workstation,
struct samr_Password lmpassword,
struct samr_Password ntpassword);
+void init_netr_CryptPassword(const char *pwd,
+ unsigned char session_key[16],
+ struct netr_CryptPassword *pwd_buf);
/* The following definitions come from rpc_client/init_samr.c */
const char *fname,
uint32 access_mask,
files_struct **result);
-void destroy_fake_file_handle(struct fake_file_handle **fh);
NTSTATUS close_fake_file(files_struct *fsp);
/* The following definitions come from smbd/file_access.c */
/* The following definitions come from smbd/posix_acls.c */
-NTSTATUS unpack_nt_owners(int snum, uid_t *puser, gid_t *pgrp, uint32 security_info_sent, SEC_DESC *psd);
+NTSTATUS unpack_nt_owners(int snum, uid_t *puser, gid_t *pgrp, uint32 security_info_sent, const SEC_DESC *psd);
SMB_ACL_T free_empty_sys_acl(connection_struct *conn, SMB_ACL_T the_acl);
NTSTATUS posix_fget_nt_acl(struct files_struct *fsp, uint32_t security_info,
SEC_DESC **ppdesc);
NTSTATUS posix_get_nt_acl(struct connection_struct *conn, const char *name,
uint32_t security_info, SEC_DESC **ppdesc);
int try_chown(connection_struct *conn, const char *fname, uid_t uid, gid_t gid);
-NTSTATUS set_nt_acl(files_struct *fsp, uint32 security_info_sent, SEC_DESC *psd);
+NTSTATUS append_parent_acl(files_struct *fsp,
+ const SEC_DESC *pcsd,
+ SEC_DESC **pp_new_sd);
+NTSTATUS set_nt_acl(files_struct *fsp, uint32 security_info_sent, const SEC_DESC *psd);
int get_acl_group_bits( connection_struct *conn, const char *fname, mode_t *mode );
int chmod_acl(connection_struct *conn, const char *name, mode_t mode);
int inherit_access_posix_acl(connection_struct *conn, const char *inherit_from_dir,
PROTECTED_SACL_SECURITY_INFORMATION|\
PROTECTED_DACL_SECURITY_INFORMATION)
-/* SEC_ACCESS */
-typedef uint32 SEC_ACCESS;
-
/* SEC_ACE */
typedef struct security_ace SEC_ACE;
#define SEC_ACE_HEADER_SIZE (2 * sizeof(uint8) + sizeof(uint16) + sizeof(uint32))
#define SECRETS_LDAP_BIND_PW "SECRETS/LDAP_BIND_PW"
+#define SECRETS_LOCAL_SCHANNEL_KEY "SECRETS/LOCAL_SCHANNEL_KEY"
+
/* Authenticated user info is stored in secrets.tdb under these keys */
#define SECRETS_AUTH_USER "SECRETS/AUTH_USER"
struct share_mode_entry;
struct uuid;
struct named_mutex;
+struct pcap_cache;
struct vfs_fsp_data {
struct vfs_fsp_data *next;
return ERROR_NT(NT_STATUS_INVALID_HANDLE); \
} while(0)
-/* you must add the following extern declaration to files using this macro
- * (do not add it to the macro as that causes nested extern declaration warnings)
- * extern struct current_user current_user;
- */
-#define CHECK_FSP(fsp,conn) do {\
- if (!(fsp) || !(conn)) \
- return ERROR_NT(NT_STATUS_INVALID_HANDLE); \
- else if (((conn) != (fsp)->conn) || current_user.vuid != (fsp)->vuid) \
- return ERROR_NT(NT_STATUS_INVALID_HANDLE); \
- else if ((fsp)->is_directory) \
- return ERROR_NT(NT_STATUS_INVALID_DEVICE_REQUEST); \
- else if ((fsp)->fh->fd == -1) \
- return ERROR_NT(NT_STATUS_ACCESS_DENIED); \
- (fsp)->num_smb_operations++;\
- } while(0)
-
#define CHECK_READ(fsp,inbuf) (((fsp)->fh->fd != -1) && ((fsp)->can_read || \
((SVAL((inbuf),smb_flg2) & FLAGS2_READ_PERMIT_EXECUTE) && \
(fsp->access_mask & FILE_EXECUTE))))
/* Leave at 22 - not yet released. Remove parameter fd from close_fn. - obnox */
/* Changed to version 23 - remove set_nt_acl call. This can only be done via an
open handle. JRA. */
+/* Changed to version 24 - make security descriptor const in fset_nt_acl. JRA. */
-#define SMB_VFS_INTERFACE_VERSION 23
+#define SMB_VFS_INTERFACE_VERSION 24
/* to bug old modules which are trying to compile with the old functions */
NTSTATUS (*fset_nt_acl)(struct vfs_handle_struct *handle,
struct files_struct *fsp,
uint32 security_info_sent,
- struct security_descriptor *psd);
+ const struct security_descriptor *psd);
/* POSIX ACL operations. */
state->fde = event_add_fd(ev, state, fd,
EVENT_FD_READ | EVENT_FD_WRITE,
- async_connect_callback, state);
+ async_connect_callback, result);
if (state->fde == NULL) {
sys_fcntl_long(fd, F_SETFL, p->old_sockflags);
TALLOC_FREE(result);
return NULL;
}
+ result->private_data = state;
state->param.param_connect.fd = fd;
state->param.param_connect.address = address;
+++ /dev/null
-/*-
- * COPYRIGHT (C) 1986 Gary S. Brown. You may use this program, or
- * code or tables extracted from it, as desired without restriction.
- *
- * First, the polynomial itself and its table of feedback terms. The
- * polynomial is
- * X^32+X^26+X^23+X^22+X^16+X^12+X^11+X^10+X^8+X^7+X^5+X^4+X^2+X^1+X^0
- *
- * Note that we take it "backwards" and put the highest-order term in
- * the lowest-order bit. The X^32 term is "implied"; the LSB is the
- * X^31 term, etc. The X^0 term (usually shown as "+1") results in
- * the MSB being 1
- *
- * Note that the usual hardware shift register implementation, which
- * is what we're using (we're merely optimizing it by doing eight-bit
- * chunks at a time) shifts bits into the lowest-order term. In our
- * implementation, that means shifting towards the right. Why do we
- * do it this way? Because the calculated CRC must be transmitted in
- * order from highest-order term to lowest-order term. UARTs transmit
- * characters in order from LSB to MSB. By storing the CRC this way
- * we hand it to the UART in the order low-byte to high-byte; the UART
- * sends each low-bit to hight-bit; and the result is transmission bit
- * by bit from highest- to lowest-order term without requiring any bit
- * shuffling on our part. Reception works similarly
- *
- * The feedback terms table consists of 256, 32-bit entries. Notes
- *
- * The table can be generated at runtime if desired; code to do so
- * is shown later. It might not be obvious, but the feedback
- * terms simply represent the results of eight shift/xor opera
- * tions for all combinations of data and CRC register values
- *
- * The values must be right-shifted by eight bits by the "updcrc
- * logic; the shift must be unsigned (bring in zeroes). On some
- * hardware you could probably optimize the shift in assembler by
- * using byte-swap instructions
- * polynomial $edb88320
- *
- *
- * CRC32 code derived from work by Gary S. Brown.
- */
-
-#include "includes.h"
-
-static const uint32 crc32_tab[] = {
- 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
- 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
- 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
- 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
- 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
- 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
- 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
- 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
- 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
- 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
- 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
- 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
- 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
- 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
- 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
- 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
- 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
- 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
- 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
- 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
- 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
- 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
- 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
- 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
- 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
- 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
- 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
- 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
- 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
- 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
- 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
- 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
- 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
- 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
- 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
- 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
- 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
- 0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
- 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
- 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
- 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
- 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
- 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
-};
-
-uint32 crc32_calc_buffer(const char *buf, size_t size)
-{
- const unsigned char *p;
- uint32 crc;
-
- p = (const unsigned char *)buf;
- crc = ~0U;
-
- while (size--)
- crc = crc32_tab[(crc ^ *p++) & 0xFF] ^ (crc >> 8);
-
- return crc ^ ~0U;
-}
blob = data_blob_const(msg->data, msg->datalen);
ndr_err = ndr_pull_struct_blob(
- &blob, result, result,
+ &blob, result, NULL, result,
(ndr_pull_flags_fn_t)ndr_pull_messaging_rec);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
}
ndr_err = ndr_push_struct_blob(
- &blob, mem_ctx, msg,
+ &blob, mem_ctx, NULL, msg,
(ndr_push_flags_fn_t)ndr_push_messaging_rec);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return result;
}
-static int db_ctdb_record_destructor(struct db_record *rec)
+static int db_ctdb_record_destructor(struct db_record **recp)
{
+ struct db_record *rec = talloc_get_type_abort(*recp, struct db_record);
struct db_ctdb_transaction_handle *h = talloc_get_type_abort(
rec->private_data, struct db_ctdb_transaction_handle);
int ret = h->ctx->db->transaction_commit(h->ctx->db);
TDB_DATA key)
{
int res;
- struct db_record *rec;
+ struct db_record *rec, **recp;
res = db_ctdb_transaction_start(ctx->db);
if (res == -1) {
}
/* destroy this transaction when we release the lock */
- talloc_set_destructor((struct db_record *)talloc_new(rec), db_ctdb_record_destructor);
+ recp = talloc(rec, struct db_record *);
+ if (recp == NULL) {
+ ctx->db->transaction_cancel(ctx->db);
+ talloc_free(rec);
+ return NULL;
+ }
+ *recp = rec;
+ talloc_set_destructor(recp, db_ctdb_record_destructor);
return rec;
}
stdout_logging = False;
if (dbf) {
x_fflush(dbf);
- (void) x_fclose(dbf);
+ if (dbf != x_stdout) {
+ (void) x_fclose(dbf);
+ }
}
dbf = NULL;
/****************************************************************************
display sec_access structure
****************************************************************************/
-void display_sec_access(SEC_ACCESS *info)
+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 : "");
{
return NT_STATUS_OK;
}
+
+bool change_to_root_user(void)
+{
+ return false;
+}
+
+struct event_context *smbd_event_context(void)
+{
+ return NULL;
+}
+
+struct messaging_context *smbd_messaging_context(void)
+{
+ return NULL;
+}
/* Default return */
return NT_STATUS_ACCESS_DENIED;
}
+
+/* Return a UNIX errno from a NT status code */
+static const struct {
+ NTSTATUS status;
+ int error;
+} nt_errno_map[] = {
+ {NT_STATUS_ACCESS_VIOLATION, EACCES},
+ {NT_STATUS_INVALID_HANDLE, EBADF},
+ {NT_STATUS_ACCESS_DENIED, EACCES},
+ {NT_STATUS_OBJECT_NAME_NOT_FOUND, ENOENT},
+ {NT_STATUS_OBJECT_PATH_NOT_FOUND, ENOENT},
+ {NT_STATUS_SHARING_VIOLATION, EBUSY},
+ {NT_STATUS_OBJECT_PATH_INVALID, ENOTDIR},
+ {NT_STATUS_OBJECT_NAME_COLLISION, EEXIST},
+ {NT_STATUS_PATH_NOT_COVERED, ENOENT},
+ {NT_STATUS_UNSUCCESSFUL, EINVAL},
+ {NT_STATUS_NOT_IMPLEMENTED, ENOSYS},
+ {NT_STATUS_IN_PAGE_ERROR, EFAULT},
+ {NT_STATUS_BAD_NETWORK_NAME, ENOENT},
+#ifdef EDQUOT
+ {NT_STATUS_PAGEFILE_QUOTA, EDQUOT},
+ {NT_STATUS_QUOTA_EXCEEDED, EDQUOT},
+ {NT_STATUS_REGISTRY_QUOTA_LIMIT, EDQUOT},
+ {NT_STATUS_LICENSE_QUOTA_EXCEEDED, EDQUOT},
+#endif
+#ifdef ETIME
+ {NT_STATUS_TIMER_NOT_CANCELED, ETIME},
+#endif
+ {NT_STATUS_INVALID_PARAMETER, EINVAL},
+ {NT_STATUS_NO_SUCH_DEVICE, ENODEV},
+ {NT_STATUS_NO_SUCH_FILE, ENOENT},
+#ifdef ENODATA
+ {NT_STATUS_END_OF_FILE, ENODATA},
+#endif
+#ifdef ENOMEDIUM
+ {NT_STATUS_NO_MEDIA_IN_DEVICE, ENOMEDIUM},
+ {NT_STATUS_NO_MEDIA, ENOMEDIUM},
+#endif
+ {NT_STATUS_NONEXISTENT_SECTOR, ESPIPE},
+ {NT_STATUS_NO_MEMORY, ENOMEM},
+ {NT_STATUS_CONFLICTING_ADDRESSES, EADDRINUSE},
+ {NT_STATUS_NOT_MAPPED_VIEW, EINVAL},
+ {NT_STATUS_UNABLE_TO_FREE_VM, EADDRINUSE},
+ {NT_STATUS_ACCESS_DENIED, EACCES},
+ {NT_STATUS_BUFFER_TOO_SMALL, ENOBUFS},
+ {NT_STATUS_WRONG_PASSWORD, EACCES},
+ {NT_STATUS_LOGON_FAILURE, EACCES},
+ {NT_STATUS_INVALID_WORKSTATION, EACCES},
+ {NT_STATUS_INVALID_LOGON_HOURS, EACCES},
+ {NT_STATUS_PASSWORD_EXPIRED, EACCES},
+ {NT_STATUS_ACCOUNT_DISABLED, EACCES},
+ {NT_STATUS_DISK_FULL, ENOSPC},
+ {NT_STATUS_INVALID_PIPE_STATE, EPIPE},
+ {NT_STATUS_PIPE_BUSY, EPIPE},
+ {NT_STATUS_PIPE_DISCONNECTED, EPIPE},
+ {NT_STATUS_PIPE_NOT_AVAILABLE, ENOSYS},
+ {NT_STATUS_FILE_IS_A_DIRECTORY, EISDIR},
+ {NT_STATUS_NOT_SUPPORTED, ENOSYS},
+ {NT_STATUS_NOT_A_DIRECTORY, ENOTDIR},
+ {NT_STATUS_DIRECTORY_NOT_EMPTY, ENOTEMPTY},
+ {NT_STATUS_NETWORK_UNREACHABLE, ENETUNREACH},
+ {NT_STATUS_HOST_UNREACHABLE, EHOSTUNREACH},
+ {NT_STATUS_CONNECTION_ABORTED, ECONNABORTED},
+ {NT_STATUS_CONNECTION_REFUSED, ECONNREFUSED},
+ {NT_STATUS_TOO_MANY_LINKS, EMLINK},
+ {NT_STATUS_NETWORK_BUSY, EBUSY},
+ {NT_STATUS_DEVICE_DOES_NOT_EXIST, ENODEV},
+#ifdef ELIBACC
+ {NT_STATUS_DLL_NOT_FOUND, ELIBACC},
+#endif
+ {NT_STATUS_PIPE_BROKEN, EPIPE},
+ {NT_STATUS_REMOTE_NOT_LISTENING, ECONNREFUSED},
+ {NT_STATUS_NETWORK_ACCESS_DENIED, EACCES},
+ {NT_STATUS_TOO_MANY_OPENED_FILES, EMFILE},
+#ifdef EPROTO
+ {NT_STATUS_DEVICE_PROTOCOL_ERROR, EPROTO},
+#endif
+ {NT_STATUS_FLOAT_OVERFLOW, ERANGE},
+ {NT_STATUS_FLOAT_UNDERFLOW, ERANGE},
+ {NT_STATUS_INTEGER_OVERFLOW, ERANGE},
+ {NT_STATUS_MEDIA_WRITE_PROTECTED, EROFS},
+ {NT_STATUS_PIPE_CONNECTED, EISCONN},
+ {NT_STATUS_MEMORY_NOT_ALLOCATED, EFAULT},
+ {NT_STATUS_FLOAT_INEXACT_RESULT, ERANGE},
+ {NT_STATUS_ILL_FORMED_PASSWORD, EACCES},
+ {NT_STATUS_PASSWORD_RESTRICTION, EACCES},
+ {NT_STATUS_ACCOUNT_RESTRICTION, EACCES},
+ {NT_STATUS_PORT_CONNECTION_REFUSED, ECONNREFUSED},
+ {NT_STATUS_NAME_TOO_LONG, ENAMETOOLONG},
+ {NT_STATUS_REMOTE_DISCONNECT, ESHUTDOWN},
+ {NT_STATUS_CONNECTION_DISCONNECTED, ECONNABORTED},
+ {NT_STATUS_CONNECTION_RESET, ENETRESET},
+#ifdef ENOTUNIQ
+ {NT_STATUS_IP_ADDRESS_CONFLICT1, ENOTUNIQ},
+ {NT_STATUS_IP_ADDRESS_CONFLICT2, ENOTUNIQ},
+#endif
+ {NT_STATUS_PORT_MESSAGE_TOO_LONG, EMSGSIZE},
+ {NT_STATUS_PROTOCOL_UNREACHABLE, ENOPROTOOPT},
+ {NT_STATUS_ADDRESS_ALREADY_EXISTS, EADDRINUSE},
+ {NT_STATUS_PORT_UNREACHABLE, EHOSTUNREACH},
+ {NT_STATUS_IO_TIMEOUT, ETIMEDOUT},
+ {NT_STATUS_RETRY, EAGAIN},
+#ifdef ENOTUNIQ
+ {NT_STATUS_DUPLICATE_NAME, ENOTUNIQ},
+#endif
+#ifdef ECOMM
+ {NT_STATUS_NET_WRITE_FAULT, ECOMM},
+#endif
+#ifdef EXDEV
+ {NT_STATUS_NOT_SAME_DEVICE, EXDEV},
+#endif
+ {NT_STATUS(0), 0}
+};
+
+int map_errno_from_nt_status(NTSTATUS status)
+{
+ int i;
+ DEBUG(10,("map_errno_from_nt_status: 32 bit codes: code=%08x\n",
+ NT_STATUS_V(status)));
+
+ /* Status codes without this bit set are not errors */
+
+ if (!(NT_STATUS_V(status) & 0xc0000000)) {
+ return 0;
+ }
+
+ for (i=0;nt_errno_map[i].error;i++) {
+ if (NT_STATUS_V(nt_errno_map[i].status) ==
+ NT_STATUS_V(status)) {
+ return nt_errno_map[i].error;
+ }
+ }
+
+ /* for all other cases - a default code */
+ return EINVAL;
+}
+++ /dev/null
-/*
- Unix SMB/CIFS implementation.
- HMAC MD5 code for use in NTLMv2
- Copyright (C) Luke Kenneth Casson Leighton 1996-2000
- Copyright (C) Andrew Tridgell 1992-2000
-
- 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/>.
-*/
-
-/* taken direct from rfc2104 implementation and modified for suitable use
- * for ntlmv2.
- */
-
-#include "includes.h"
-
-/***********************************************************************
- the rfc 2104 version of hmac_md5 initialisation.
-***********************************************************************/
-
-void hmac_md5_init_rfc2104(const unsigned char *key, int key_len, HMACMD5Context *ctx)
-{
- int i;
- unsigned char tk[16];
-
- /* if key is longer than 64 bytes reset it to key=MD5(key) */
- if (key_len > 64) {
- struct MD5Context tctx;
-
- MD5Init(&tctx);
- MD5Update(&tctx, key, key_len);
- MD5Final(tk, &tctx);
-
- key = tk;
- key_len = 16;
- }
-
- /* start out by storing key in pads */
- ZERO_STRUCT(ctx->k_ipad);
- ZERO_STRUCT(ctx->k_opad);
- memcpy( ctx->k_ipad, key, key_len);
- memcpy( ctx->k_opad, key, key_len);
-
- /* XOR key with ipad and opad values */
- for (i=0; i<64; i++) {
- ctx->k_ipad[i] ^= 0x36;
- ctx->k_opad[i] ^= 0x5c;
- }
-
- MD5Init(&ctx->ctx);
- MD5Update(&ctx->ctx, ctx->k_ipad, 64);
-}
-
-/***********************************************************************
- the microsoft version of hmac_md5 initialisation.
-***********************************************************************/
-
-void hmac_md5_init_limK_to_64(const unsigned char* key, int key_len,
- HMACMD5Context *ctx)
-{
- int i;
-
- /* if key is longer than 64 bytes truncate it */
- if (key_len > 64) {
- key_len = 64;
- }
-
- /* start out by storing key in pads */
- ZERO_STRUCT(ctx->k_ipad);
- ZERO_STRUCT(ctx->k_opad);
- memcpy( ctx->k_ipad, key, key_len);
- memcpy( ctx->k_opad, key, key_len);
-
- /* XOR key with ipad and opad values */
- for (i=0; i<64; i++) {
- ctx->k_ipad[i] ^= 0x36;
- ctx->k_opad[i] ^= 0x5c;
- }
-
- MD5Init(&ctx->ctx);
- MD5Update(&ctx->ctx, ctx->k_ipad, 64);
-}
-
-/***********************************************************************
- update hmac_md5 "inner" buffer
-***********************************************************************/
-
-void hmac_md5_update(const unsigned char *text, int text_len, HMACMD5Context *ctx)
-{
- MD5Update(&ctx->ctx, text, text_len); /* then text of datagram */
-}
-
-/***********************************************************************
- finish off hmac_md5 "inner" buffer and generate outer one.
-***********************************************************************/
-void hmac_md5_final(unsigned char *digest, HMACMD5Context *ctx)
-
-{
- struct MD5Context ctx_o;
-
- MD5Final(digest, &ctx->ctx);
-
- MD5Init(&ctx_o);
- MD5Update(&ctx_o, ctx->k_opad, 64);
- MD5Update(&ctx_o, digest, 16);
- MD5Final(digest, &ctx_o);
-}
-
-/***********************************************************
- single function to calculate an HMAC MD5 digest from data.
- use the microsoft hmacmd5 init method because the key is 16 bytes.
-************************************************************/
-
-void hmac_md5( unsigned char key[16], const unsigned char *data, int data_len,
- unsigned char *digest)
-{
- HMACMD5Context ctx;
- hmac_md5_init_limK_to_64(key, 16, &ctx);
- if (data_len != 0)
- {
- hmac_md5_update(data, data_len, &ctx);
- }
- hmac_md5_final(digest, &ctx);
-}
-
done:
if (ret != LDB_SUCCESS) {
talloc_free(res);
+ res = NULL;
}
*_res = res;
+++ /dev/null
-/*
- Unix SMB/CIFS implementation.
- a implementation of MD4 designed for use in the SMB authentication protocol
- Copyright (C) Andrew Tridgell 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"
-
-/* NOTE: This code makes no attempt to be fast!
-
- It assumes that a int is at least 32 bits long
-*/
-
-#if 0
-static uint32 A, B, C, D;
-#else
-#define A (state[0])
-#define B (state[1])
-#define C (state[2])
-#define D (state[3])
-#endif
-
-static uint32 F(uint32 X, uint32 Y, uint32 Z)
-{
- return (X&Y) | ((~X)&Z);
-}
-
-static uint32 G(uint32 X, uint32 Y, uint32 Z)
-{
- return (X&Y) | (X&Z) | (Y&Z);
-}
-
-static uint32 H(uint32 X, uint32 Y, uint32 Z)
-{
- return X^Y^Z;
-}
-
-static uint32 lshift(uint32 x, int s)
-{
- x &= 0xFFFFFFFF;
- return ((x<<s)&0xFFFFFFFF) | (x>>(32-s));
-}
-
-#define ROUND1(a,b,c,d,k,s) a = lshift(a + F(b,c,d) + X[k], s)
-#define ROUND2(a,b,c,d,k,s) a = lshift(a + G(b,c,d) + X[k] + (uint32)0x5A827999,s)
-#define ROUND3(a,b,c,d,k,s) a = lshift(a + H(b,c,d) + X[k] + (uint32)0x6ED9EBA1,s)
-
-/* this applies md4 to 64 byte chunks */
-static void mdfour64(uint32_t *state, uint32 *M)
-{
- int j;
- uint32 AA, BB, CC, DD;
- uint32 X[16];
-
- for (j=0;j<16;j++)
- X[j] = M[j];
-
- AA = A; BB = B; CC = C; DD = D;
-
- ROUND1(A,B,C,D, 0, 3); ROUND1(D,A,B,C, 1, 7);
- ROUND1(C,D,A,B, 2, 11); ROUND1(B,C,D,A, 3, 19);
- ROUND1(A,B,C,D, 4, 3); ROUND1(D,A,B,C, 5, 7);
- ROUND1(C,D,A,B, 6, 11); ROUND1(B,C,D,A, 7, 19);
- ROUND1(A,B,C,D, 8, 3); ROUND1(D,A,B,C, 9, 7);
- ROUND1(C,D,A,B, 10, 11); ROUND1(B,C,D,A, 11, 19);
- ROUND1(A,B,C,D, 12, 3); ROUND1(D,A,B,C, 13, 7);
- ROUND1(C,D,A,B, 14, 11); ROUND1(B,C,D,A, 15, 19);
-
- ROUND2(A,B,C,D, 0, 3); ROUND2(D,A,B,C, 4, 5);
- ROUND2(C,D,A,B, 8, 9); ROUND2(B,C,D,A, 12, 13);
- ROUND2(A,B,C,D, 1, 3); ROUND2(D,A,B,C, 5, 5);
- ROUND2(C,D,A,B, 9, 9); ROUND2(B,C,D,A, 13, 13);
- ROUND2(A,B,C,D, 2, 3); ROUND2(D,A,B,C, 6, 5);
- ROUND2(C,D,A,B, 10, 9); ROUND2(B,C,D,A, 14, 13);
- ROUND2(A,B,C,D, 3, 3); ROUND2(D,A,B,C, 7, 5);
- ROUND2(C,D,A,B, 11, 9); ROUND2(B,C,D,A, 15, 13);
-
- ROUND3(A,B,C,D, 0, 3); ROUND3(D,A,B,C, 8, 9);
- ROUND3(C,D,A,B, 4, 11); ROUND3(B,C,D,A, 12, 15);
- ROUND3(A,B,C,D, 2, 3); ROUND3(D,A,B,C, 10, 9);
- ROUND3(C,D,A,B, 6, 11); ROUND3(B,C,D,A, 14, 15);
- ROUND3(A,B,C,D, 1, 3); ROUND3(D,A,B,C, 9, 9);
- ROUND3(C,D,A,B, 5, 11); ROUND3(B,C,D,A, 13, 15);
- ROUND3(A,B,C,D, 3, 3); ROUND3(D,A,B,C, 11, 9);
- ROUND3(C,D,A,B, 7, 11); ROUND3(B,C,D,A, 15, 15);
-
- A += AA; B += BB; C += CC; D += DD;
-
- A &= 0xFFFFFFFF; B &= 0xFFFFFFFF;
- C &= 0xFFFFFFFF; D &= 0xFFFFFFFF;
-
- for (j=0;j<16;j++)
- X[j] = 0;
-}
-
-static void copy64(uint32 *M, const unsigned char *in)
-{
- int i;
-
- for (i=0;i<16;i++)
- M[i] = (in[i*4+3]<<24) | (in[i*4+2]<<16) |
- (in[i*4+1]<<8) | (in[i*4+0]<<0);
-}
-
-static void copy4(unsigned char *out, uint32 x)
-{
- out[0] = x&0xFF;
- out[1] = (x>>8)&0xFF;
- out[2] = (x>>16)&0xFF;
- out[3] = (x>>24)&0xFF;
-}
-
-/* produce a md4 message digest from data of length n bytes */
-void mdfour(unsigned char *out, const unsigned char *in, int n)
-{
- unsigned char buf[128];
- uint32 M[16];
- uint32 state[4];
- uint32 b = n * 8;
- int i;
-
- A = 0x67452301;
- B = 0xefcdab89;
- C = 0x98badcfe;
- D = 0x10325476;
-
- while (n > 64) {
- copy64(M, in);
- mdfour64(state, M);
- in += 64;
- n -= 64;
- }
-
- for (i=0;i<128;i++)
- buf[i] = 0;
- memcpy(buf, in, n);
- buf[n] = 0x80;
-
- if (n <= 55) {
- copy4(buf+56, b);
- copy64(M, buf);
- mdfour64(state, M);
- } else {
- copy4(buf+120, b);
- copy64(M, buf);
- mdfour64(state, M);
- copy64(M, buf+64);
- mdfour64(state, M);
- }
-
- for (i=0;i<128;i++)
- buf[i] = 0;
- copy64(M, buf);
-
- copy4(out, A);
- copy4(out+4, B);
- copy4(out+8, C);
- copy4(out+12, D);
-}
-
-
+++ /dev/null
-/*
- * This code implements the MD5 message-digest algorithm.
- * The algorithm is due to Ron Rivest. This code was
- * written by Colin Plumb in 1993, no copyright is claimed.
- * This code is in the public domain; do with it what you wish.
- *
- * Equivalent code is available from RSA Data Security, Inc.
- * This code has been tested against that, and is equivalent,
- * except that you don't need to include two pages of legalese
- * with every copy.
- *
- * To compute the message digest of a chunk of bytes, declare an
- * MD5Context structure, pass it to MD5Init, call MD5Update as
- * needed on buffers full of bytes, and then call MD5Final, which
- * will fill a supplied 16-byte array with the digest.
- */
-
-/* This code slightly modified to fit into Samba by
- abartlet@samba.org Jun 2001 */
-
-#include "includes.h"
-
-#include "md5.h"
-
-static void MD5Transform(uint32 buf[4], uint32 const in[16]);
-
-/*
- * Note: this code is harmless on little-endian machines.
- */
-static void byteReverse(unsigned char *buf, unsigned longs)
-{
- uint32 t;
- do {
- t = (uint32) ((unsigned) buf[3] << 8 | buf[2]) << 16 |
- ((unsigned) buf[1] << 8 | buf[0]);
- *(uint32 *) buf = t;
- buf += 4;
- } while (--longs);
-}
-
-/*
- * Start MD5 accumulation. Set bit count to 0 and buffer to mysterious
- * initialization constants.
- */
-void MD5Init(struct MD5Context *ctx)
-{
- ctx->buf[0] = 0x67452301;
- ctx->buf[1] = 0xefcdab89;
- ctx->buf[2] = 0x98badcfe;
- ctx->buf[3] = 0x10325476;
-
- ctx->bits[0] = 0;
- ctx->bits[1] = 0;
-}
-
-/*
- * Update context to reflect the concatenation of another buffer full
- * of bytes.
- */
-void MD5Update(struct MD5Context *ctx, unsigned char const *buf, unsigned len)
-{
- register uint32 t;
-
- /* Update bitcount */
-
- t = ctx->bits[0];
- if ((ctx->bits[0] = t + ((uint32) len << 3)) < t)
- ctx->bits[1]++; /* Carry from low to high */
- ctx->bits[1] += len >> 29;
-
- t = (t >> 3) & 0x3f; /* Bytes already in shsInfo->data */
-
- /* Handle any leading odd-sized chunks */
-
- if (t) {
- unsigned char *p = (unsigned char *) ctx->in + t;
-
- t = 64 - t;
- if (len < t) {
- memmove(p, buf, len);
- return;
- }
- memmove(p, buf, t);
- byteReverse(ctx->in, 16);
- MD5Transform(ctx->buf, (uint32 *) ctx->in);
- buf += t;
- len -= t;
- }
- /* Process data in 64-byte chunks */
-
- while (len >= 64) {
- memmove(ctx->in, buf, 64);
- byteReverse(ctx->in, 16);
- MD5Transform(ctx->buf, (uint32 *) ctx->in);
- buf += 64;
- len -= 64;
- }
-
- /* Handle any remaining bytes of data. */
-
- memmove(ctx->in, buf, len);
-}
-
-/*
- * Final wrapup - pad to 64-byte boundary with the bit pattern
- * 1 0* (64-bit count of bits processed, MSB-first)
- */
-void MD5Final(unsigned char digest[16], struct MD5Context *ctx)
-{
- unsigned int count;
- unsigned char *p;
-
- /* Compute number of bytes mod 64 */
- count = (ctx->bits[0] >> 3) & 0x3F;
-
- /* Set the first char of padding to 0x80. This is safe since there is
- always at least one byte free */
- p = ctx->in + count;
- *p++ = 0x80;
-
- /* Bytes of padding needed to make 64 bytes */
- count = 64 - 1 - count;
-
- /* Pad out to 56 mod 64 */
- if (count < 8) {
- /* Two lots of padding: Pad the first block to 64 bytes */
- memset(p, 0, count);
- byteReverse(ctx->in, 16);
- MD5Transform(ctx->buf, (uint32 *) ctx->in);
-
- /* Now fill the next block with 56 bytes */
- memset(ctx->in, 0, 56);
- } else {
- /* Pad block to 56 bytes */
- memset(p, 0, count - 8);
- }
- byteReverse(ctx->in, 14);
-
- /* Append length in bits and transform */
- ((uint32 *) ctx->in)[14] = ctx->bits[0];
- ((uint32 *) ctx->in)[15] = ctx->bits[1];
-
- MD5Transform(ctx->buf, (uint32 *) ctx->in);
- byteReverse((unsigned char *) ctx->buf, 4);
- memmove(digest, ctx->buf, 16);
- memset(ctx, 0, sizeof(ctx)); /* In case it's sensitive */
-}
-
-/* The four core functions - F1 is optimized somewhat */
-
-/* #define F1(x, y, z) (x & y | ~x & z) */
-#define F1(x, y, z) (z ^ (x & (y ^ z)))
-#define F2(x, y, z) F1(z, x, y)
-#define F3(x, y, z) (x ^ y ^ z)
-#define F4(x, y, z) (y ^ (x | ~z))
-
-/* This is the central step in the MD5 algorithm. */
-#define MD5STEP(f, w, x, y, z, data, s) \
- ( w += f(x, y, z) + data, w = w<<s | w>>(32-s), w += x )
-
-/*
- * The core of the MD5 algorithm, this alters an existing MD5 hash to
- * reflect the addition of 16 longwords of new data. MD5Update blocks
- * the data and converts bytes into longwords for this routine.
- */
-static void MD5Transform(uint32 buf[4], uint32 const in[16])
-{
- register uint32 a, b, c, d;
-
- a = buf[0];
- b = buf[1];
- c = buf[2];
- d = buf[3];
-
- MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
- MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
- MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
- MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
- MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
- MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
- MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
- MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
- MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
- MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
- MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
- MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
- MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
- MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
- MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
- MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
-
- MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
- MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
- MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
- MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
- MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
- MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
- MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
- MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
- MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
- MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
- MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
- MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
- MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
- MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
- MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
- MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
-
- MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
- MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
- MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
- MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
- MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
- MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
- MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
- MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
- MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
- MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
- MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
- MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
- MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
- MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
- MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
- MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
-
- MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
- MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
- MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
- MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
- MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
- MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
- MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
- MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
- MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
- MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
- MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
- MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
- MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
- MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
- MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
- MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
-
- buf[0] += a;
- buf[1] += b;
- buf[2] += c;
- buf[3] += d;
-}
blob = data_blob_const(data.dptr, data.dsize);
ndr_err = ndr_pull_struct_blob(
- &blob, result, result,
+ &blob, result, NULL, result,
(ndr_pull_flags_fn_t)ndr_pull_messaging_array);
SAFE_FREE(data.dptr);
}
ndr_err = ndr_push_struct_blob(
- &blob, mem_ctx, array,
+ &blob, mem_ctx, NULL, array,
(ndr_push_flags_fn_t)ndr_push_messaging_array);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
case 1:
case 2:
case 3:
+ break;
case 1001:
u1001.usrmod1001_min_passwd_len = 0;
buffer = (uint8_t *)&u1001;
r->in.server_name,
r->in.fileid,
&werr);
- if (!W_ERROR_IS_OK(werr)) {
+ if (!NT_STATUS_IS_OK(status)) {
+ werr = ntstatus_to_werror(status);
goto done;
}
r->in.domain_name,
(const char **)r->out.buffer,
&werr);
+
+ if (!NT_STATUS_IS_OK(status)) {
+ werr = ntstatus_to_werror(status);
+ }
done:
return werr;
r->in.net_name,
r->in.reserved,
&werr);
- if (!W_ERROR_IS_OK(werr)) {
+ if (!NT_STATUS_IS_OK(status)) {
+ werr = ntstatus_to_werror(status);
goto done;
}
CMDLINE_OBJ = common.o
NETAPIBUFFER_OBJ = netapibuffer.o
-NETAPITEST_OBJ = netapitest.o netlocalgroup.o netuser.o netgroup.o netdisplay.o netshare.o $(CMDLINE_OBJ)
+NETAPITEST_OBJ = netapitest.o netlocalgroup.o netuser.o netgroup.o netdisplay.o netshare.o netfile.o $(CMDLINE_OBJ)
bin/netapitest@EXEEXT@: $(BINARY_PREREQS) $(NETAPITEST_OBJ)
@echo Linking $@
const char *hostname);
NET_API_STATUS netapitest_share(struct libnetapi_ctx *ctx,
const char *hostname);
+NET_API_STATUS netapitest_file(struct libnetapi_ctx *ctx,
+ const char *hostname);
#ifndef ARRAY_SIZE
#define ARRAY_SIZE(a) (sizeof(a)/sizeof(a[0]))
goto out;
}
+ status = netapitest_file(ctx, hostname);
+ if (status) {
+ goto out;
+ }
+
out:
if (status != 0) {
printf("testsuite failed with: %s\n",
--- /dev/null
+/*
+ * Unix SMB/CIFS implementation.
+ * NetFile testsuite
+ * Copyright (C) Guenther Deschner 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.
+ *
+ * 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 <sys/types.h>
+#include <inttypes.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <netapi.h>
+
+#include "common.h"
+
+static NET_API_STATUS test_netfileenum(const char *hostname,
+ uint32_t level)
+{
+ NET_API_STATUS status;
+ uint32_t entries_read = 0;
+ uint32_t total_entries = 0;
+ uint32_t resume_handle = 0;
+ uint8_t *buffer = NULL;
+ int i;
+
+ struct FILE_INFO_2 *i2;
+ struct FILE_INFO_3 *i3;
+
+ printf("testing NetFileEnum level %d\n", level);
+
+ do {
+ status = NetFileEnum(hostname,
+ NULL,
+ NULL,
+ level,
+ &buffer,
+ (uint32_t)-1,
+ &entries_read,
+ &total_entries,
+ &resume_handle);
+ if (status == 0 || status == ERROR_MORE_DATA) {
+ switch (level) {
+ case 2:
+ i2 = (struct FILE_INFO_2 *)buffer;
+ break;
+ case 3:
+ i3 = (struct FILE_INFO_3 *)buffer;
+ break;
+ default:
+ return -1;
+ }
+
+ for (i=0; i<entries_read; i++) {
+
+ switch (level) {
+ case 2:
+ case 3:
+ break;
+ default:
+ break;
+ }
+
+ switch (level) {
+ case 2:
+ i2++;
+ break;
+ case 3:
+ i3++;
+ break;
+ }
+ }
+ NetApiBufferFree(buffer);
+ }
+ } while (status == ERROR_MORE_DATA);
+
+ if (status) {
+ return status;
+ }
+
+ return 0;
+}
+
+NET_API_STATUS netapitest_file(struct libnetapi_ctx *ctx,
+ const char *hostname)
+{
+ NET_API_STATUS status = 0;
+ uint8_t *buffer = NULL;
+ uint32_t levels[] = { 2, 3 };
+ uint32_t enum_levels[] = { 2, 3 };
+ int i;
+
+ printf("NetFile tests\n");
+
+ /* test enum */
+
+ for (i=0; i<ARRAY_SIZE(enum_levels); i++) {
+
+ status = test_netfileenum(hostname, enum_levels[i]);
+ if (status) {
+ NETAPI_STATUS(ctx, status, "NetFileEnum");
+ goto out;
+ }
+ }
+
+ /* basic queries */
+#if 0
+ for (i=0; i<ARRAY_SIZE(levels); i++) {
+
+ printf("testing NetFileGetInfo level %d\n", levels[i]);
+
+ status = NetFileGetInfo(hostname, fid, levels[i], &buffer);
+ if (status && status != 124) {
+ NETAPI_STATUS(ctx, status, "NetFileGetInfo");
+ goto out;
+ }
+ }
+#endif
+
+ status = 0;
+
+ printf("NetFile tests succeeded\n");
+ out:
+ if (status != 0) {
+ printf("NetFile testsuite failed with: %s\n",
+ libnetapi_get_error_string(ctx, status));
+ }
+
+ return status;
+}
infoX->usriX_workstations,
infoX->usriX_usr_comment,
&zero_parameters,
- 0,
+ infoX->usriX_user_id,
infoX->usriX_primary_group_id,
infoX->usriX_flags,
fields_present,
zero_logon_hours,
- 0,
- 0,
+ infoX->usriX_bad_pw_count,
+ infoX->usriX_num_logons,
infoX->usriX_country_code,
+ infoX->usriX_code_page,
0,
0,
- 0,
- 0);
+ infoX->usriX_password_expired);
}
/****************************************************************
struct USER_INFO_0 *u0 = NULL;
struct USER_INFO_1 *u1 = NULL;
struct USER_INFO_2 *u2 = NULL;
+ struct USER_INFO_3 *u3 = NULL;
struct USER_INFO_1003 *u1003 = NULL;
struct USER_INFO_1006 *u1006 = NULL;
struct USER_INFO_1007 *u1007 = NULL;
uX->usriX_country_code = u2->usri2_country_code;
uX->usriX_code_page = u2->usri2_code_page;
break;
+ case 3:
+ u3 = (struct USER_INFO_3 *)buffer;
+ uX->usriX_name = u3->usri3_name;
+ uX->usriX_password_age = u3->usri3_password_age;
+ uX->usriX_priv = u3->usri3_priv;
+ uX->usriX_home_dir = u3->usri3_home_dir;
+ uX->usriX_comment = u3->usri3_comment;
+ uX->usriX_flags = u3->usri3_flags;
+ uX->usriX_script_path = u3->usri3_script_path;
+ uX->usriX_auth_flags = u3->usri3_auth_flags;
+ uX->usriX_full_name = u3->usri3_full_name;
+ uX->usriX_usr_comment = u3->usri3_usr_comment;
+ uX->usriX_parms = u3->usri3_parms;
+ uX->usriX_workstations = u3->usri3_workstations;
+ uX->usriX_last_logon = u3->usri3_last_logon;
+ uX->usriX_last_logoff = u3->usri3_last_logoff;
+ uX->usriX_acct_expires = u3->usri3_acct_expires;
+ uX->usriX_max_storage = u3->usri3_max_storage;
+ uX->usriX_units_per_week= u3->usri3_units_per_week;
+ uX->usriX_logon_hours = u3->usri3_logon_hours;
+ uX->usriX_bad_pw_count = u3->usri3_bad_pw_count;
+ uX->usriX_num_logons = u3->usri3_num_logons;
+ uX->usriX_logon_server = u3->usri3_logon_server;
+ uX->usriX_country_code = u3->usri3_country_code;
+ uX->usriX_code_page = u3->usri3_code_page;
+ uX->usriX_user_id = u3->usri3_user_id;
+ uX->usriX_primary_group_id = u3->usri3_primary_group_id;
+ uX->usriX_profile = u3->usri3_profile;
+ uX->usriX_home_dir_drive = u3->usri3_home_dir_drive;
+ uX->usriX_password_expired = u3->usri3_password_expired;
+ break;
case 1003:
u1003 = (struct USER_INFO_1003 *)buffer;
uX->usriX_password = u1003->usri1003_password;
u1053 = (struct USER_INFO_1053 *)buffer;
uX->usriX_home_dir_drive = u1053->usri1053_home_dir_drive;
break;
- case 3:
case 4:
default:
return NT_STATUS_INVALID_INFO_CLASS;
user_mask = SAMR_USER_ACCESS_SET_ATTRIBUTES |
SAMR_USER_ACCESS_GET_GROUPS;
break;
+ case 3:
+ user_mask = STD_RIGHT_READ_CONTROL_ACCESS |
+ STD_RIGHT_WRITE_DAC_ACCESS |
+ SAMR_USER_ACCESS_GET_GROUPS |
+ SAMR_USER_ACCESS_SET_PASSWORD |
+ SAMR_USER_ACCESS_SET_ATTRIBUTES |
+ SAMR_USER_ACCESS_GET_ATTRIBUTES |
+ SAMR_USER_ACCESS_SET_LOC_COM;
+ break;
case 1:
case 2:
- case 3:
case 4:
case 21:
case 22:
# define RL_COMPLETION_CAST
#endif /* HAVE_NEW_LIBREADLINE */
+static bool smb_rl_done;
+
+#if HAVE_LIBREADLINE
+/*
+ * MacOS/X does not have rl_done in readline.h, but
+ * readline.so has it
+ */
+extern int rl_done;
+#endif
+
+void smb_readline_done(void)
+{
+ smb_rl_done = true;
+#if HAVE_LIBREADLINE
+ rl_done = 1;
+#endif
+}
+
/****************************************************************************
Display the prompt and wait for input. Call callback() regularly
****************************************************************************/
return NULL;
}
- while (1) {
+ while (!smb_rl_done) {
timeout.tv_sec = 5;
timeout.tv_usec = 0;
callback();
}
}
+ return NULL;
}
/****************************************************************************
********************************************************************/
void init_sec_ace(SEC_ACE *t, const DOM_SID *sid, enum security_ace_type type,
- uint32 mask, uint8 flag)
+ uint32_t mask, uint8 flag)
{
t->type = type;
t->flags = flag;
enum ndr_err_code ndr_err;
ndr_err = ndr_push_struct_blob(
- &blob, mem_ctx, secdesc,
+ &blob, mem_ctx, NULL, secdesc,
(ndr_push_flags_fn_t)ndr_push_security_descriptor);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
blob = data_blob_const(data, len);
ndr_err = ndr_pull_struct_blob(
- &blob, result, result,
+ &blob, result, NULL, result,
(ndr_pull_flags_fn_t)ndr_pull_security_descriptor);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
if (!inherit)
continue;
- init_sec_access(&new_ace->access_mask, ace->access_mask);
+ new_ace->access_mask = ace->access_mask;
init_sec_ace(new_ace, &ace->trustee, ace->type,
new_ace->access_mask, new_flags);
return sdb;
}
-
-/*******************************************************************
- Sets up a SEC_ACCESS structure.
-********************************************************************/
-
-void init_sec_access(uint32 *t, uint32 mask)
-{
- *t = mask;
-}
-
-
SEC_DESC *get_share_security_default( TALLOC_CTX *ctx, size_t *psize, uint32 def_access)
{
- SEC_ACCESS sa;
+ uint32_t sa;
SEC_ACE ace;
SEC_ACL *psa = NULL;
SEC_DESC *psd = NULL;
se_map_generic(&spec_access, &file_generic_mapping);
- init_sec_access(&sa, def_access | spec_access );
+ sa = (def_access | spec_access );
init_sec_ace(&ace, &global_sid_World, SEC_ACE_TYPE_ACCESS_ALLOWED, sa, 0);
if ((psa = make_sec_acl(ctx, NT4_ACL_REVISION, 1, &ace)) != NULL) {
}
for (i = 0; i < num_aces; i++) {
- SEC_ACCESS sa;
+ uint32_t sa;
uint32 g_access;
uint32 s_access;
DOM_SID sid;
pacl++; /* Go past any ',' */
se_map_generic(&s_access, &file_generic_mapping);
- init_sec_access(&sa, g_access | s_access );
+ sa = (g_access | s_access);
init_sec_ace(&ace_list[i], &sid, type, sa, 0);
}
static uint32 check_ace(SEC_ACE *ace, const NT_USER_TOKEN *token, uint32 acc_desired,
NTSTATUS *status)
{
- uint32 mask = ace->access_mask;
+ uint32_t mask = ace->access_mask;
/*
* Inherit only is ignored.
}
}
+/* Map generic access rights to object specific rights for all the ACE's
+ * in a security_acl.
+ */
+
+void security_acl_map_generic(struct security_acl *sa,
+ const struct generic_mapping *mapping)
+{
+ unsigned int i;
+
+ if (!sa) {
+ return;
+ }
+
+ for (i = 0; i < sa->num_aces; i++) {
+ se_map_generic(&sa->aces[i].access_mask, mapping);
+ }
+}
+
/* Map standard access rights to object specific rights. This technique is
used to give meaning to assigning read, write, execute and all access to
objects. Each type of object has its own mapping of standard to object
DOM_SID act_sid;
SEC_ACE ace[3];
- SEC_ACCESS mask;
SEC_ACL *psa = NULL;
sid_append_rid(&act_sid, BUILTIN_ALIAS_RID_ACCOUNT_OPS);
/*basic access for every one*/
- init_sec_access(&mask, GENERIC_RIGHTS_SAM_EXECUTE | GENERIC_RIGHTS_SAM_READ);
- init_sec_ace(&ace[0], &global_sid_World, SEC_ACE_TYPE_ACCESS_ALLOWED, mask, 0);
+ init_sec_ace(&ace[0], &global_sid_World, SEC_ACE_TYPE_ACCESS_ALLOWED,
+ GENERIC_RIGHTS_SAM_EXECUTE | GENERIC_RIGHTS_SAM_READ, 0);
/*full access for builtin aliases Administrators and Account Operators*/
- init_sec_access(&mask, GENERIC_RIGHTS_SAM_ALL_ACCESS);
- init_sec_ace(&ace[1], &adm_sid, SEC_ACE_TYPE_ACCESS_ALLOWED, mask, 0);
- init_sec_ace(&ace[2], &act_sid, SEC_ACE_TYPE_ACCESS_ALLOWED, mask, 0);
+ init_sec_ace(&ace[1], &adm_sid,
+ SEC_ACE_TYPE_ACCESS_ALLOWED, GENERIC_RIGHTS_SAM_ALL_ACCESS, 0);
+ init_sec_ace(&ace[2], &act_sid,
+ SEC_ACE_TYPE_ACCESS_ALLOWED, GENERIC_RIGHTS_SAM_ALL_ACCESS, 0);
if ((psa = make_sec_acl(ctx, NT4_ACL_REVISION, 3, ace)) == NULL)
return NT_STATUS_NO_MEMORY;
if (!(name = talloc(mem_ctx, struct dns_domain_name))) {
buf->error = ERROR_DNS_NO_MEMORY;
+ return;
}
dns_unmarshall_label(name, 0, buf, &name->pLabelList);
if (!ERR_DNS_IS_OK(err)) return err;
/*
- * The zone must be used at all
+ * Use the same prereq as WinXP -- No CNAME records for this host.
*/
- err = dns_create_rrec(req, domainname, QTYPE_ANY, DNS_CLASS_ANY,
+ err = dns_create_rrec(req, hostname, QTYPE_CNAME, DNS_CLASS_NONE,
0, 0, NULL, &rec);
if (!ERR_DNS_IS_OK(err)) goto error;
}
ndr_err = ndr_pull_struct_blob(pac_data_blob, pac_data,
- pac_data,
+ NULL, pac_data,
(ndr_pull_flags_fn_t)ndr_pull_PAC_DATA);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
status = ndr_map_error2ntstatus(ndr_err);
}
ndr_err = ndr_pull_struct_blob(pac_data_blob, pac_data_raw,
- pac_data_raw,
+ NULL, pac_data_raw,
(ndr_pull_flags_fn_t)ndr_pull_PAC_DATA_RAW);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
status = ndr_map_error2ntstatus(ndr_err);
/* We find the data blobs above, now we parse them to get at the exact portion we should zero */
ndr_err = ndr_pull_struct_blob(kdc_sig_blob, kdc_sig_wipe,
- kdc_sig_wipe,
+ NULL, kdc_sig_wipe,
(ndr_pull_flags_fn_t)ndr_pull_PAC_SIGNATURE_DATA);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
status = ndr_map_error2ntstatus(ndr_err);
}
ndr_err = ndr_pull_struct_blob(srv_sig_blob, srv_sig_wipe,
- srv_sig_wipe,
+ NULL, srv_sig_wipe,
(ndr_pull_flags_fn_t)ndr_pull_PAC_SIGNATURE_DATA);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
status = ndr_map_error2ntstatus(ndr_err);
/* and reencode, back into the same place it came from */
ndr_err = ndr_push_struct_blob(kdc_sig_blob, pac_data_raw,
- kdc_sig_wipe,
+ NULL, kdc_sig_wipe,
(ndr_push_flags_fn_t)ndr_push_PAC_SIGNATURE_DATA);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
status = ndr_map_error2ntstatus(ndr_err);
return status;
}
ndr_err = ndr_push_struct_blob(srv_sig_blob, pac_data_raw,
- srv_sig_wipe,
+ NULL, srv_sig_wipe,
(ndr_push_flags_fn_t)ndr_push_PAC_SIGNATURE_DATA);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
status = ndr_map_error2ntstatus(ndr_err);
/* push out the whole structure, but now with zero'ed signatures */
ndr_err = ndr_push_struct_blob(&modified_pac_blob, pac_data_raw,
- pac_data_raw,
+ NULL, pac_data_raw,
(ndr_push_flags_fn_t)ndr_push_PAC_DATA_RAW);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
status = ndr_map_error2ntstatus(ndr_err);
*/
static int recv_cldap_netlogon(TALLOC_CTX *mem_ctx,
int sock,
- uint32_t *nt_version,
- union nbt_cldap_netlogon **reply)
+ uint32_t nt_version,
+ struct netlogon_samlogon_response **reply)
{
int ret;
ASN1_DATA data;
int i1;
/* half the time of a regular ldap timeout, not less than 3 seconds. */
unsigned int al_secs = MAX(3,lp_ldap_timeout()/2);
- union nbt_cldap_netlogon *r = NULL;
+ struct netlogon_samlogon_response *r = NULL;
+ NTSTATUS status;
blob = data_blob(NULL, 8192);
if (blob.data == NULL) {
return -1;
}
- r = TALLOC_ZERO_P(mem_ctx, union nbt_cldap_netlogon);
+ r = TALLOC_ZERO_P(mem_ctx, struct netlogon_samlogon_response);
if (!r) {
errno = ENOMEM;
data_blob_free(&os1);
return -1;
}
- if (!pull_mailslot_cldap_reply(mem_ctx, &os3, r, nt_version)) {
+ status = pull_netlogon_samlogon_response(&os3, mem_ctx, NULL, r);
+ if (!NT_STATUS_IS_OK(status)) {
data_blob_free(&os1);
data_blob_free(&os2);
data_blob_free(&os3);
return -1;
}
+ map_netlogon_samlogon_response(r);
+
data_blob_free(&os1);
data_blob_free(&os2);
data_blob_free(&os3);
bool ads_cldap_netlogon(TALLOC_CTX *mem_ctx,
const char *server,
const char *realm,
- uint32_t *nt_version,
- union nbt_cldap_netlogon **reply)
+ uint32_t nt_version,
+ struct netlogon_samlogon_response **reply)
{
int sock;
int ret;
return False;
}
- ret = send_cldap_netlogon(sock, realm, global_myname(), *nt_version);
+ ret = send_cldap_netlogon(sock, realm, global_myname(), nt_version);
if (ret != 0) {
close(sock);
return False;
bool ads_cldap_netlogon_5(TALLOC_CTX *mem_ctx,
const char *server,
const char *realm,
- struct nbt_cldap_netlogon_5 *reply5)
+ struct NETLOGON_SAM_LOGON_RESPONSE_EX *reply5)
{
- uint32_t nt_version = NETLOGON_VERSION_5 | NETLOGON_VERSION_5EX;
- union nbt_cldap_netlogon *reply = NULL;
+ uint32_t nt_version = NETLOGON_NT_VERSION_5 | NETLOGON_NT_VERSION_5EX;
+ struct netlogon_samlogon_response *reply = NULL;
bool ret;
- ret = ads_cldap_netlogon(mem_ctx, server, realm, &nt_version, &reply);
+ ret = ads_cldap_netlogon(mem_ctx, server, realm, nt_version, &reply);
if (!ret) {
return false;
}
- if (nt_version != (NETLOGON_VERSION_5 | NETLOGON_VERSION_5EX)) {
+ if (reply->ntver != NETLOGON_NT_VERSION_5EX) {
+ DEBUG(0,("ads_cldap_netlogon_5: nt_version mismatch: 0x%08x\n",
+ reply->ntver));
return false;
}
- *reply5 = reply->logon5;
-
- return true;
-}
-
-/****************************************************************
-****************************************************************/
-
-bool pull_mailslot_cldap_reply(TALLOC_CTX *mem_ctx,
- const DATA_BLOB *blob,
- union nbt_cldap_netlogon *r,
- uint32_t *nt_version)
-{
- enum ndr_err_code ndr_err;
- uint32_t nt_version_query = ((*nt_version) & 0x0000001f);
- uint16_t command = 0;
-
- ndr_err = ndr_pull_struct_blob(blob, mem_ctx, &command,
- (ndr_pull_flags_fn_t)ndr_pull_uint16);
- if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
- return false;
- }
-
- switch (command) {
- case 0x13: /* 19 */
- case 0x15: /* 21 */
- case 0x17: /* 23 */
- case 0x19: /* 25 */
- break;
- default:
- DEBUG(1,("got unexpected command: %d (0x%08x)\n",
- command, command));
- return false;
- }
-
- ndr_err = ndr_pull_union_blob_all(blob, mem_ctx, r, nt_version_query,
- (ndr_pull_flags_fn_t)ndr_pull_nbt_cldap_netlogon);
- if (NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
- goto done;
- }
-
- /* when the caller requested just those nt_version bits that the server
- * was able to reply to, we are fine and all done. otherwise we need to
- * assume downgraded replies which are painfully parsed here - gd */
-
- if (nt_version_query & NETLOGON_VERSION_WITH_CLOSEST_SITE) {
- nt_version_query &= ~NETLOGON_VERSION_WITH_CLOSEST_SITE;
- }
- ndr_err = ndr_pull_union_blob_all(blob, mem_ctx, r, nt_version_query,
- (ndr_pull_flags_fn_t)ndr_pull_nbt_cldap_netlogon);
- if (NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
- goto done;
- }
- if (nt_version_query & NETLOGON_VERSION_5EX_WITH_IP) {
- nt_version_query &= ~NETLOGON_VERSION_5EX_WITH_IP;
- }
- ndr_err = ndr_pull_union_blob_all(blob, mem_ctx, r, nt_version_query,
- (ndr_pull_flags_fn_t)ndr_pull_nbt_cldap_netlogon);
- if (NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
- goto done;
- }
- if (nt_version_query & NETLOGON_VERSION_5EX) {
- nt_version_query &= ~NETLOGON_VERSION_5EX;
- }
- ndr_err = ndr_pull_union_blob_all(blob, mem_ctx, r, nt_version_query,
- (ndr_pull_flags_fn_t)ndr_pull_nbt_cldap_netlogon);
- if (NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
- goto done;
- }
- if (nt_version_query & NETLOGON_VERSION_5) {
- nt_version_query &= ~NETLOGON_VERSION_5;
- }
- ndr_err = ndr_pull_union_blob_all(blob, mem_ctx, r, nt_version_query,
- (ndr_pull_flags_fn_t)ndr_pull_nbt_cldap_netlogon);
- if (NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
- goto done;
- }
-
- return false;
-
- done:
- if (DEBUGLEVEL >= 10) {
- NDR_PRINT_UNION_DEBUG(nbt_cldap_netlogon, nt_version_query, r);
- }
-
- *nt_version = nt_version_query;
+ *reply5 = reply->data.nt5_ex;
return true;
}
static bool ads_try_connect(ADS_STRUCT *ads, const char *server, bool gc)
{
char *srv;
- struct nbt_cldap_netlogon_5 cldap_reply;
+ struct NETLOGON_SAM_LOGON_RESPONSE_EX cldap_reply;
TALLOC_CTX *mem_ctx = NULL;
bool ret = false;
if ( (ads_s = ads_init( ads->server.realm, ads->server.workgroup,
ads->server.ldap_server )) == NULL )
{
+ status = ADS_ERROR_NT(NT_STATUS_NO_MEMORY);
goto done;
}
ads_s->auth.flags = ADS_AUTH_ANON_BIND;
server_realm = SMB_STRDUP(ads->config.realm);
if (!server || !server_realm) {
+ SAFE_FREE(server);
+ SAFE_FREE(server_realm);
return ADS_ERROR(LDAP_NO_MEMORY);
}
+++ /dev/null
-/*
- Unix SMB/CIFS implementation.
-
- manipulate nbt name structures
-
- Copyright (C) Andrew Tridgell 2005
-
- 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/>.
-*/
-
-/*
- see rfc1002 for the detailed format of compressed names
-*/
-
-#include "includes.h"
-#include "librpc/gen_ndr/ndr_nbt.h"
-#include "librpc/gen_ndr/ndr_misc.h"
-
-/* don't allow an unlimited number of name components */
-#define MAX_COMPONENTS 10
-
-/**
- print a nbt string
-*/
-_PUBLIC_ void ndr_print_nbt_string(struct ndr_print *ndr, const char *name, const char *s)
-{
- ndr_print_string(ndr, name, s);
-}
-
-/*
- pull one component of a nbt_string
-*/
-static enum ndr_err_code ndr_pull_component(struct ndr_pull *ndr,
- uint8_t **component,
- uint32_t *offset,
- uint32_t *max_offset)
-{
- uint8_t len;
- uint_t loops = 0;
- while (loops < 5) {
- if (*offset >= ndr->data_size) {
- return ndr_pull_error(ndr, NDR_ERR_STRING,
- "BAD NBT NAME component");
- }
- len = ndr->data[*offset];
- if (len == 0) {
- *offset += 1;
- *max_offset = MAX(*max_offset, *offset);
- *component = NULL;
- return NDR_ERR_SUCCESS;
- }
- if ((len & 0xC0) == 0xC0) {
- /* its a label pointer */
- if (1 + *offset >= ndr->data_size) {
- return ndr_pull_error(ndr, NDR_ERR_STRING,
- "BAD NBT NAME component");
- }
- *max_offset = MAX(*max_offset, *offset + 2);
- *offset = ((len&0x3F)<<8) | ndr->data[1 + *offset];
- *max_offset = MAX(*max_offset, *offset);
- loops++;
- continue;
- }
- if ((len & 0xC0) != 0) {
- /* its a reserved length field */
- return ndr_pull_error(ndr, NDR_ERR_STRING,
- "BAD NBT NAME component");
- }
- if (*offset + len + 2 > ndr->data_size) {
- return ndr_pull_error(ndr, NDR_ERR_STRING,
- "BAD NBT NAME component");
- }
- *component = (uint8_t*)talloc_strndup(ndr, (const char *)&ndr->data[1 + *offset], len);
- NDR_ERR_HAVE_NO_MEMORY(*component);
- *offset += len + 1;
- *max_offset = MAX(*max_offset, *offset);
- return NDR_ERR_SUCCESS;
- }
-
- /* too many pointers */
- return ndr_pull_error(ndr, NDR_ERR_STRING, "BAD NBT NAME component");
-}
-
-/**
- pull a nbt_string from the wire
-*/
-_PUBLIC_ enum ndr_err_code ndr_pull_nbt_string(struct ndr_pull *ndr, int ndr_flags, const char **s)
-{
- uint32_t offset = ndr->offset;
- uint32_t max_offset = offset;
- unsigned num_components;
- char *name;
-
- if (!(ndr_flags & NDR_SCALARS)) {
- return NDR_ERR_SUCCESS;
- }
-
- name = NULL;
-
- /* break up name into a list of components */
- for (num_components=0;num_components<MAX_COMPONENTS;num_components++) {
- uint8_t *component = NULL;
- NDR_CHECK(ndr_pull_component(ndr, &component, &offset, &max_offset));
- if (component == NULL) break;
- if (name) {
- name = talloc_asprintf_append_buffer(name, ".%s", component);
- NDR_ERR_HAVE_NO_MEMORY(name);
- } else {
- name = (char *)component;
- }
- }
- if (num_components == MAX_COMPONENTS) {
- return ndr_pull_error(ndr, NDR_ERR_STRING,
- "BAD NBT NAME too many components");
- }
- if (num_components == 0) {
- name = talloc_strdup(ndr, "");
- NDR_ERR_HAVE_NO_MEMORY(name);
- }
-
- (*s) = name;
- ndr->offset = max_offset;
-
- return NDR_ERR_SUCCESS;
-}
-
-/**
- push a nbt string to the wire
-*/
-_PUBLIC_ enum ndr_err_code ndr_push_nbt_string(struct ndr_push *ndr, int ndr_flags, const char *s)
-{
- if (!(ndr_flags & NDR_SCALARS)) {
- return NDR_ERR_SUCCESS;
- }
-
- while (s && *s) {
- enum ndr_err_code ndr_err;
- char *compname;
- size_t complen;
- uint32_t offset;
-
- /* see if we have pushed the remaing string allready,
- * if so we use a label pointer to this string
- */
- ndr_err = ndr_token_retrieve_cmp_fn(&ndr->nbt_string_list, s, &offset, (comparison_fn_t)strcmp, false);
- if (NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
- uint8_t b[2];
-
- if (offset > 0x3FFF) {
- return ndr_push_error(ndr, NDR_ERR_STRING,
- "offset for nbt string label pointer %u[%08X] > 0x00003FFF",
- offset, offset);
- }
-
- b[0] = 0xC0 | (offset>>8);
- b[1] = (offset & 0xFF);
-
- return ndr_push_bytes(ndr, b, 2);
- }
-
- complen = strcspn(s, ".");
-
- /* we need to make sure the length fits into 6 bytes */
- if (complen >= 0x3F) {
- return ndr_push_error(ndr, NDR_ERR_STRING,
- "component length %u[%08X] > 0x00003F",
- (unsigned)complen, (unsigned)complen);
- }
-
- compname = talloc_asprintf(ndr, "%c%*.*s",
- (unsigned char)complen,
- (unsigned char)complen,
- (unsigned char)complen, s);
- NDR_ERR_HAVE_NO_MEMORY(compname);
-
- /* remember the current componemt + the rest of the string
- * so it can be reused later
- */
- NDR_CHECK(ndr_token_store(ndr, &ndr->nbt_string_list, s, ndr->offset));
-
- /* push just this component into the blob */
- NDR_CHECK(ndr_push_bytes(ndr, (const uint8_t *)compname, complen+1));
- talloc_free(compname);
-
- s += complen;
- if (*s == '.') s++;
- }
-
- /* if we reach the end of the string and have pushed the last component
- * without using a label pointer, we need to terminate the string
- */
- return ndr_push_bytes(ndr, (const uint8_t *)"", 1);
-}
-
-
-/*
- decompress a 'compressed' name component
- */
-static bool decompress_name(char *name, enum nbt_name_type *type)
-{
- int i;
- for (i=0;name[2*i];i++) {
- uint8_t c1 = name[2*i];
- uint8_t c2 = name[1+(2*i)];
- if (c1 < 'A' || c1 > 'P' ||
- c2 < 'A' || c2 > 'P') {
- return false;
- }
- name[i] = ((c1-'A')<<4) | (c2-'A');
- }
- name[i] = 0;
- if (i == 16) {
- *type = (enum nbt_name_type)(name[15]);
- name[15] = 0;
- i--;
- } else {
- *type = NBT_NAME_CLIENT;
- }
-
- /* trim trailing spaces */
- for (;i>0 && name[i-1]==' ';i--) {
- name[i-1] = 0;
- }
-
- return true;
-}
-
-
-/*
- compress a name component
- */
-static uint8_t *compress_name(TALLOC_CTX *mem_ctx,
- const uint8_t *name, enum nbt_name_type type)
-{
- uint8_t *cname;
- int i;
- uint8_t pad_char;
-
- if (strlen((const char *)name) > 15) {
- return NULL;
- }
-
- cname = talloc_array(mem_ctx, uint8_t, 33);
- if (cname == NULL) return NULL;
-
- for (i=0;name[i];i++) {
- cname[2*i] = 'A' + (name[i]>>4);
- cname[1+2*i] = 'A' + (name[i]&0xF);
- }
- if (strcmp((const char *)name, "*") == 0) {
- pad_char = 0;
- } else {
- pad_char = ' ';
- }
- for (;i<15;i++) {
- cname[2*i] = 'A' + (pad_char>>4);
- cname[1+2*i] = 'A' + (pad_char&0xF);
- }
-
- pad_char = type;
- cname[2*i] = 'A' + (pad_char>>4);
- cname[1+2*i] = 'A' + (pad_char&0xF);
-
- cname[32] = 0;
- return cname;
-}
-
-
-/**
- pull a nbt name from the wire
-*/
-_PUBLIC_ enum ndr_err_code ndr_pull_nbt_name(struct ndr_pull *ndr, int ndr_flags, struct nbt_name *r)
-{
- uint8_t *scope;
- char *cname;
- const char *s;
- bool ok;
-
- if (!(ndr_flags & NDR_SCALARS)) {
- return NDR_ERR_SUCCESS;
- }
-
- NDR_CHECK(ndr_pull_nbt_string(ndr, ndr_flags, &s));
-
- scope = (uint8_t *)strchr(s, '.');
- if (scope) {
- *scope = 0;
- r->scope = talloc_strdup(ndr->current_mem_ctx, (const char *)&scope[1]);
- NDR_ERR_HAVE_NO_MEMORY(r->scope);
- } else {
- r->scope = NULL;
- }
-
- cname = discard_const_p(char, s);
-
- /* the first component is limited to 16 bytes in the DOS charset,
- which is 32 in the 'compressed' form */
- if (strlen(cname) > 32) {
- return ndr_pull_error(ndr, NDR_ERR_STRING,
- "NBT NAME cname > 32");
- }
-
- /* decompress the first component */
- ok = decompress_name(cname, &r->type);
- if (!ok) {
- return ndr_pull_error(ndr, NDR_ERR_STRING,
- "NBT NAME failed to decompress");
- }
-
- r->name = talloc_strdup(ndr->current_mem_ctx, cname);
- NDR_ERR_HAVE_NO_MEMORY(r->name);
-
- talloc_free(cname);
-
- return NDR_ERR_SUCCESS;
-}
-
-/**
- push a nbt name to the wire
-*/
-_PUBLIC_ enum ndr_err_code ndr_push_nbt_name(struct ndr_push *ndr, int ndr_flags, const struct nbt_name *r)
-{
- uint8_t *cname, *fullname;
- enum ndr_err_code ndr_err;
-
- if (!(ndr_flags & NDR_SCALARS)) {
- return NDR_ERR_SUCCESS;
- }
-
- if (strlen(r->name) > 15) {
- return ndr_push_error(ndr, NDR_ERR_STRING,
- "nbt_name longer as 15 chars: %s",
- r->name);
- }
-
- cname = compress_name(ndr, (const uint8_t *)r->name, r->type);
- NDR_ERR_HAVE_NO_MEMORY(cname);
-
- if (r->scope) {
- fullname = (uint8_t *)talloc_asprintf(ndr, "%s.%s", cname, r->scope);
- NDR_ERR_HAVE_NO_MEMORY(fullname);
- talloc_free(cname);
- } else {
- fullname = cname;
- }
-
- ndr_err = ndr_push_nbt_string(ndr, ndr_flags, (const char *)fullname);
-
- return ndr_err;
-}
-
-
-/**
- copy a nbt name structure
-*/
-_PUBLIC_ NTSTATUS nbt_name_dup(TALLOC_CTX *mem_ctx, struct nbt_name *name, struct nbt_name *newname)
-{
- *newname = *name;
- newname->name = talloc_strdup(mem_ctx, newname->name);
- NT_STATUS_HAVE_NO_MEMORY(newname->name);
- newname->scope = talloc_strdup(mem_ctx, newname->scope);
- if (name->scope) {
- NT_STATUS_HAVE_NO_MEMORY(newname->scope);
- }
- return NT_STATUS_OK;
-}
-
-/**
- push a nbt name into a blob
-*/
-_PUBLIC_ NTSTATUS nbt_name_to_blob(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, struct nbt_name *name)
-{
- enum ndr_err_code ndr_err;
-
- ndr_err = ndr_push_struct_blob(blob, mem_ctx, name, (ndr_push_flags_fn_t)ndr_push_nbt_name);
- if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
- return ndr_map_error2ntstatus(ndr_err);
- }
-
- return NT_STATUS_OK;
-}
-
-/**
- pull a nbt name from a blob
-*/
-_PUBLIC_ NTSTATUS nbt_name_from_blob(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob, struct nbt_name *name)
-{
- enum ndr_err_code ndr_err;
-
- ndr_err = ndr_pull_struct_blob(blob, mem_ctx, name,
- (ndr_pull_flags_fn_t)ndr_pull_nbt_name);
- if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
- return ndr_map_error2ntstatus(ndr_err);
- }
-
- return NT_STATUS_OK;
-}
-
-
-/**
- choose a name to use when calling a server in a NBT session request.
- we use heuristics to see if the name we have been given is a IP
- address, or a too-long name. If it is then use *SMBSERVER, or a
- truncated name
-*/
-_PUBLIC_ void nbt_choose_called_name(TALLOC_CTX *mem_ctx,
- struct nbt_name *n, const char *name, int type)
-{
- n->scope = NULL;
- n->type = type;
-
- if ((name == NULL) || is_ipaddress(name)) {
- n->name = "*SMBSERVER";
- return;
- }
- if (strlen(name) > 15) {
- const char *p = strchr(name, '.');
- char *s;
- if (p - name > 15) {
- n->name = "*SMBSERVER";
- return;
- }
- s = talloc_strndup(mem_ctx, name, PTR_DIFF(p, name));
- n->name = talloc_strdup_upper(mem_ctx, s);
- return;
- }
-
- n->name = talloc_strdup_upper(mem_ctx, name);
-}
-
-
-/*
- escape a string into a form containing only a small set of characters,
- the rest is hex encoded. This is similar to URL encoding
-*/
-static const char *nbt_hex_encode(TALLOC_CTX *mem_ctx, const char *s)
-{
- int i, len;
- char *ret;
- const char *valid_chars = "_-.$@ ";
-#define NBT_CHAR_ALLOW(c) (isalnum((unsigned char)c) || strchr(valid_chars, c))
-
- for (len=i=0;s[i];i++,len++) {
- if (!NBT_CHAR_ALLOW(s[i])) {
- len += 2;
- }
- }
-
- ret = talloc_array(mem_ctx, char, len+1);
- if (ret == NULL) return NULL;
-
- for (len=i=0;s[i];i++) {
- if (NBT_CHAR_ALLOW(s[i])) {
- ret[len++] = s[i];
- } else {
- snprintf(&ret[len], 4, "%%%02x", (unsigned char)s[i]);
- len += 3;
- }
- }
- ret[len] = 0;
-
- return ret;
-}
-
-
-/**
- form a string for a NBT name
-*/
-_PUBLIC_ char *nbt_name_string(TALLOC_CTX *mem_ctx, const struct nbt_name *name)
-{
- TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
- char *ret;
- if (name->scope) {
- ret = talloc_asprintf(mem_ctx, "%s<%02x>-%s",
- nbt_hex_encode(tmp_ctx, name->name),
- name->type,
- nbt_hex_encode(tmp_ctx, name->scope));
- } else {
- ret = talloc_asprintf(mem_ctx, "%s<%02x>",
- nbt_hex_encode(tmp_ctx, name->name),
- name->type);
- }
- talloc_free(tmp_ctx);
- return ret;
-}
-
-/**
- pull a nbt name, WINS Replication uses another on wire format for nbt name
-*/
-_PUBLIC_ enum ndr_err_code ndr_pull_wrepl_nbt_name(struct ndr_pull *ndr, int ndr_flags, const struct nbt_name **_r)
-{
- struct nbt_name *r;
- uint8_t *namebuf;
- uint32_t namebuf_len;
-
- if (!(ndr_flags & NDR_SCALARS)) {
- return NDR_ERR_SUCCESS;
- }
-
- NDR_CHECK(ndr_pull_align(ndr, 4));
- NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &namebuf_len));
- if (namebuf_len < 1 || namebuf_len > 255) {
- return ndr_pull_error(ndr, NDR_ERR_ALLOC, "value out of range");
- }
- NDR_PULL_ALLOC_N(ndr, namebuf, namebuf_len);
- NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, namebuf, namebuf_len));
-
- NDR_PULL_ALLOC(ndr, r);
-
- /* oh wow, what a nasty bug in windows ... */
- if (namebuf[0] == 0x1b && namebuf_len >= 16) {
- namebuf[0] = namebuf[15];
- namebuf[15] = 0x1b;
- }
-
- if (namebuf_len < 17) {
- r->type = 0x00;
-
- r->name = talloc_strndup(r, (char *)namebuf, namebuf_len);
- if (!r->name) return ndr_pull_error(ndr, NDR_ERR_ALLOC, "out of memory");
-
- r->scope= NULL;
-
- talloc_free(namebuf);
- *_r = r;
- return NDR_ERR_SUCCESS;
- }
-
- r->type = namebuf[15];
-
- namebuf[15] = '\0';
- trim_string((char *)namebuf, NULL, " ");
- r->name = talloc_strdup(r, (char *)namebuf);
- if (!r->name) return ndr_pull_error(ndr, NDR_ERR_ALLOC, "out of memory");
-
- if (namebuf_len > 18) {
- r->scope = talloc_strndup(r, (char *)(namebuf+17), namebuf_len-17);
- if (!r->scope) return ndr_pull_error(ndr, NDR_ERR_ALLOC, "out of memory");
- } else {
- r->scope = NULL;
- }
-
- talloc_free(namebuf);
- *_r = r;
- return NDR_ERR_SUCCESS;
-}
-
-/**
- push a nbt name, WINS Replication uses another on wire format for nbt name
-*/
-_PUBLIC_ enum ndr_err_code ndr_push_wrepl_nbt_name(struct ndr_push *ndr, int ndr_flags, const struct nbt_name *r)
-{
- uint8_t *namebuf;
- uint32_t namebuf_len;
- uint32_t _name_len;
- uint32_t scope_len = 0;
-
- if (r == NULL) {
- return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER,
- "wrepl_nbt_name NULL pointer");
- }
-
- if (!(ndr_flags & NDR_SCALARS)) {
- return NDR_ERR_SUCCESS;
- }
-
- _name_len = strlen(r->name);
- if (_name_len > 15) {
- return ndr_push_error(ndr, NDR_ERR_STRING,
- "wrepl_nbt_name longer as 15 chars: %s",
- r->name);
- }
-
- if (r->scope) {
- scope_len = strlen(r->scope);
- }
- if (scope_len > 238) {
- return ndr_push_error(ndr, NDR_ERR_STRING,
- "wrepl_nbt_name scope longer as 238 chars: %s",
- r->scope);
- }
-
- namebuf = (uint8_t *)talloc_asprintf(ndr, "%-15s%c%s",
- r->name, 'X',
- (r->scope?r->scope:""));
- if (!namebuf) return ndr_push_error(ndr, NDR_ERR_ALLOC, "out of memory");
-
- namebuf_len = strlen((char *)namebuf) + 1;
-
- /*
- * we need to set the type here, and use a place-holder in the talloc_asprintf()
- * as the type can be 0x00, and then the namebuf_len = strlen(namebuf); would give wrong results
- */
- namebuf[15] = r->type;
-
- /* oh wow, what a nasty bug in windows ... */
- if (r->type == 0x1b) {
- namebuf[15] = namebuf[0];
- namebuf[0] = 0x1b;
- }
-
- NDR_CHECK(ndr_push_align(ndr, 4));
- NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, namebuf_len));
- NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, namebuf, namebuf_len));
-
- talloc_free(namebuf);
- return NDR_ERR_SUCCESS;
-}
-
-_PUBLIC_ void ndr_print_wrepl_nbt_name(struct ndr_print *ndr, const char *name, const struct nbt_name *r)
-{
- char *s = nbt_name_string(ndr, r);
- ndr_print_string(ndr, name, s);
- talloc_free(s);
-}
data->type = data_type;
switch (data->type) {
case REG_QWORD:
- data->v.qword = (uint64_t)data_p;
+ data->v.qword = *(uint64_t *)data_p;
break;
case REG_SZ:
data->v.sz.str = talloc_strdup(mem_ctx, (char *)data_p);
--- /dev/null
+/*
+ * Unix SMB/CIFS implementation.
+ * Group Policy Support
+ * Copyright (C) Guenther Deschner 2005-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.
+ *
+ * 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 "libgpo/gpo_ini.h"
+
+#define GP_EXT_NAME "security"
+
+#define GPTTMPL_UNIX_PATH "Microsoft/Windows NT/SecEdit/GptTmpl.inf"
+
+#define GPTTMPL_SECTION_UNICODE "Unicode"
+#define GPTTMPL_SECTION_VERSION "Version"
+
+#define GPTTMPL_SECTION_REGISTRY_VALUES "Registry Values"
+#define GPTTMPL_SECTION_SYSTEM_ACCESS "System Access"
+#define GPTTMPL_SECTION_KERBEROS_POLICY "Kerberos Policy"
+#define GPTTMPL_SECTION_EVENT_AUDIT "Event Audit"
+#define GPTTMPL_SECTION_PRIVILEGE_RIGHTS "Privilege Rights"
+#define GPTTMPL_SECTION_APPLICATION_LOG "Application Log"
+#define GPTTMPL_SECTION_SECURITY_LOG "Security Log"
+#define GPTTMPL_SECTION_SYSTEM_LOG "System Log"
+#define GPTTMPL_SECTION_GROUP_MEMBERSHIP "Group Membership"
+#define GPTTMPL_SECTION_FILE_SECURITY "File Security"
+#define GPTTMPL_SECTION_SERVICE_GENERAL_SETTING "Service General Setting"
+
+static TALLOC_CTX *ctx = NULL;
+
+struct gpttmpl_table {
+ const char *section;
+ const char *parameter;
+ enum winreg_Type type;
+};
+
+/****************************************************************
+ parse the Version section from gpttmpl file
+****************************************************************/
+
+#define GPTTMPL_PARAMETER_REVISION "Revision"
+#define GPTTMPL_PARAMETER_SIGNATURE "signature"
+#define GPTTMPL_VALUE_CHICAGO "$CHICAGO$" /* whatever this is good for... */
+#define GPTTMPL_PARAMETER_UNICODE "Unicode"
+
+static NTSTATUS gpttmpl_parse_header(dictionary *dict,
+ uint32_t *version_out)
+{
+ const char *signature = NULL;
+ uint32_t version;
+
+ if (!dict) {
+ return NT_STATUS_INVALID_PARAMETER;
+ }
+
+ if ((signature = iniparser_getstring(dict, GPTTMPL_SECTION_VERSION
+ ":"GPTTMPL_PARAMETER_SIGNATURE, NULL)) == NULL) {
+ return NT_STATUS_INTERNAL_DB_CORRUPTION;
+ }
+
+ if (!strequal(signature, GPTTMPL_VALUE_CHICAGO)) {
+ return NT_STATUS_INTERNAL_DB_CORRUPTION;
+ }
+
+ if ((version = iniparser_getint(dict, GPTTMPL_SECTION_VERSION
+ ":"GPTTMPL_PARAMETER_REVISION, Undefined)) == Undefined) {
+ return NT_STATUS_INTERNAL_DB_CORRUPTION;
+ }
+
+ if (version_out) {
+ *version_out = version;
+ }
+
+ /* treat that as boolean */
+ if ((!iniparser_getboolean(dict, GPTTMPL_SECTION_UNICODE
+ ":"GPTTMPL_PARAMETER_UNICODE, Undefined)) == Undefined) {
+ return NT_STATUS_INTERNAL_DB_CORRUPTION;
+ }
+
+ return NT_STATUS_OK;
+}
+
+/****************************************************************
+****************************************************************/
+
+static NTSTATUS gpttmpl_init_context(TALLOC_CTX *mem_ctx,
+ uint32_t flags,
+ const char *unix_path,
+ struct gp_inifile_context **ini_ctx)
+{
+ NTSTATUS status;
+ uint32_t version;
+ struct gp_inifile_context *tmp_ctx = NULL;
+
+ status = gp_inifile_init_context(mem_ctx, flags, unix_path,
+ GPTTMPL_UNIX_PATH, &tmp_ctx);
+ NT_STATUS_NOT_OK_RETURN(status);
+
+ status = gpttmpl_parse_header(tmp_ctx->dict, &version);
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(1,("gpttmpl_init_context: failed: %s\n",
+ nt_errstr(status)));
+ TALLOC_FREE(tmp_ctx);
+ return status;
+ }
+
+ *ini_ctx = tmp_ctx;
+
+ return NT_STATUS_OK;
+}
+
+/****************************************************************
+****************************************************************/
+
+static NTSTATUS gpttmpl_process(struct gp_inifile_context *ini_ctx,
+ struct registry_key *root_key,
+ uint32_t flags)
+{
+ return NT_STATUS_OK;
+}
+
+/****************************************************************
+****************************************************************/
+
+static NTSTATUS security_process_group_policy(ADS_STRUCT *ads,
+ TALLOC_CTX *mem_ctx,
+ uint32_t flags,
+ struct registry_key *root_key,
+ const struct nt_user_token *token,
+ struct GROUP_POLICY_OBJECT *gpo,
+ const char *extension_guid,
+ const char *snapin_guid)
+{
+ NTSTATUS status;
+ char *unix_path = NULL;
+ struct gp_inifile_context *ini_ctx = NULL;
+
+ debug_gpext_header(0, "security_process_group_policy", flags, gpo,
+ extension_guid, snapin_guid);
+
+ /* this handler processes the gpttmpl files and merge output to the
+ * registry */
+
+ status = gpo_get_unix_path(mem_ctx, gpo, &unix_path);
+ if (!NT_STATUS_IS_OK(status)) {
+ goto out;
+ }
+
+ status = gpttmpl_init_context(mem_ctx, flags, unix_path, &ini_ctx);
+ if (!NT_STATUS_IS_OK(status)) {
+ goto out;
+ }
+
+ status = gpttmpl_process(ini_ctx, root_key, flags);
+ if (!NT_STATUS_IS_OK(status)) {
+ goto out;
+ }
+
+ out:
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(0,("security_process_group_policy: %s\n",
+ nt_errstr(status)));
+ }
+ TALLOC_FREE(ini_ctx);
+
+ return status;
+}
+
+/****************************************************************
+****************************************************************/
+
+static NTSTATUS security_get_reg_config(TALLOC_CTX *mem_ctx,
+ struct gp_extension_reg_info **reg_info)
+{
+ NTSTATUS status;
+ struct gp_extension_reg_info *info = NULL;
+
+ struct gp_extension_reg_table table[] = {
+ /* FIXME: how can we store the "(Default)" value ??? */
+ /* { "", REG_SZ, "Security" }, */
+ { "ProcessGroupPolicy", REG_SZ, "security_process_group_policy" },
+ { "NoUserPolicy", REG_DWORD, "1" },
+ { "ExtensionDebugLevel", REG_DWORD, "1" },
+ { NULL, REG_NONE, NULL }
+ };
+
+ info = TALLOC_ZERO_P(mem_ctx, struct gp_extension_reg_info);
+ NT_STATUS_HAVE_NO_MEMORY(info);
+
+ status = gp_ext_info_add_entry(mem_ctx, GP_EXT_NAME,
+ GP_EXT_GUID_SECURITY,
+ table, info);
+ NT_STATUS_NOT_OK_RETURN(status);
+
+ *reg_info = info;
+
+ return NT_STATUS_OK;
+}
+
+
+/****************************************************************
+****************************************************************/
+
+static NTSTATUS security_initialize(TALLOC_CTX *mem_ctx)
+{
+ return NT_STATUS_OK;
+}
+
+/****************************************************************
+****************************************************************/
+
+static NTSTATUS security_shutdown(void)
+{
+ NTSTATUS status;
+
+ status = unregister_gp_extension(GP_EXT_NAME);
+ if (NT_STATUS_IS_OK(status)) {
+ return status;
+ }
+
+ TALLOC_FREE(ctx);
+
+ return NT_STATUS_OK;
+}
+
+/****************************************************************
+****************************************************************/
+
+static struct gp_extension_methods security_methods = {
+ .initialize = security_initialize,
+ .process_group_policy = security_process_group_policy,
+ .get_reg_config = security_get_reg_config,
+ .shutdown = security_shutdown
+};
+
+/****************************************************************
+****************************************************************/
+
+static NTSTATUS gpext_security_init(void)
+{
+ NTSTATUS status;
+
+ ctx = talloc_init("gpext_security_init");
+ NT_STATUS_HAVE_NO_MEMORY(ctx);
+
+ status = register_gp_extension(ctx, SMB_GPEXT_INTERFACE_VERSION,
+ GP_EXT_NAME, GP_EXT_GUID_SECURITY,
+ &security_methods);
+ if (!NT_STATUS_IS_OK(status)) {
+ TALLOC_FREE(ctx);
+ }
+
+ return status;
+}
size_t *sd_size)
{
SEC_ACE ace[6];
- SEC_ACCESS mask;
+ uint32_t mask;
SEC_ACL *acl = NULL;
uint8_t inherit_flags;
- init_sec_access(&mask, REG_KEY_ALL);
+ mask = REG_KEY_ALL;
init_sec_ace(&ace[0],
&global_sid_System,
SEC_ACE_TYPE_ACCESS_ALLOWED,
mask, 0);
- init_sec_access(&mask, REG_KEY_ALL);
+ mask = REG_KEY_ALL;
init_sec_ace(&ace[1],
&global_sid_Builtin_Administrators,
SEC_ACE_TYPE_ACCESS_ALLOWED,
mask, 0);
- init_sec_access(&mask, REG_KEY_READ);
+ mask = REG_KEY_READ;
init_sec_ace(&ace[2],
sid ? sid : &global_sid_Authenticated_Users,
SEC_ACE_TYPE_ACCESS_ALLOWED,
SEC_ACE_FLAG_CONTAINER_INHERIT |
SEC_ACE_FLAG_INHERIT_ONLY;
- init_sec_access(&mask, REG_KEY_ALL);
+ mask = REG_KEY_ALL;
init_sec_ace(&ace[3],
&global_sid_System,
SEC_ACE_TYPE_ACCESS_ALLOWED,
mask, inherit_flags);
- init_sec_access(&mask, REG_KEY_ALL);
+ mask = REG_KEY_ALL;
init_sec_ace(&ace[4],
&global_sid_Builtin_Administrators,
SEC_ACE_TYPE_ACCESS_ALLOWED,
mask, inherit_flags);
- init_sec_access(&mask, REG_KEY_READ);
+ mask = REG_KEY_READ;
init_sec_ace(&ace[5],
sid ? sid : &global_sid_Authenticated_Users,
SEC_ACE_TYPE_ACCESS_ALLOWED,
old_utdv = talloc(mem_ctx, struct replUpToDateVectorBlob);
ndr_err = ndr_pull_struct_blob(&entry->password, old_utdv,
- old_utdv,
+ NULL, old_utdv,
(ndr_pull_flags_fn_t)ndr_pull_replUpToDateVectorBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
NDR_PRINT_DEBUG(replUpToDateVectorBlob, new_utdv);
}
- ndr_err = ndr_push_struct_blob(&blob, mem_ctx, new_utdv,
+ ndr_err = ndr_push_struct_blob(&blob, mem_ctx, NULL, new_utdv,
(ndr_push_flags_fn_t)ndr_push_replUpToDateVectorBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
status = ndr_map_error2ntstatus(ndr_err);
bool newer_keys = false;
uint32_t j;
- ndr_err = ndr_pull_struct_blob_all(blob, mem_ctx, &scb,
+ ndr_err = ndr_pull_struct_blob_all(blob, mem_ctx, NULL, &scb,
(ndr_pull_flags_fn_t)ndr_pull_supplementalCredentialsBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
status = ndr_map_error2ntstatus(ndr_err);
status = NT_STATUS_NO_MEMORY;
goto done;
}
- ndr_err = ndr_pull_struct_blob(&scpk_blob, mem_ctx, pkb,
+ ndr_err = ndr_pull_struct_blob(&scpk_blob, mem_ctx, NULL, pkb,
(ndr_pull_flags_fn_t)ndr_pull_package_PrimaryKerberosBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
status = ndr_map_error2ntstatus(ndr_err);
strupper_m(spn);
spn_array[0] = spn;
- if (name_to_fqdn(my_fqdn, r->in.machine_name) &&
- !strequal(my_fqdn, r->in.machine_name)) {
+ if (!name_to_fqdn(my_fqdn, r->in.machine_name)
+ || (strchr(my_fqdn, '.') == NULL)) {
+ fstr_sprintf(my_fqdn, "%s.%s", r->in.machine_name,
+ r->out.dns_domain_name);
+ }
+
+ strlower_m(my_fqdn);
- strlower_m(my_fqdn);
+ if (!strequal(my_fqdn, r->in.machine_name)) {
spn = talloc_asprintf(mem_ctx, "HOST/%s", my_fqdn);
if (!spn) {
return ADS_ERROR_LDAP(LDAP_NO_MEMORY);
struct libnet_keytab_entry *libnet_keytab_search(struct libnet_keytab_context *ctx,
const char *principal, int kvno,
- const const krb5_enctype enctype,
+ const krb5_enctype enctype,
TALLOC_CTX *mem_ctx);
#endif
user->user_private_info.SensitiveData = data.data;
user->user_private_info.DataLength = data.length;
- ndr_err = ndr_pull_struct_blob(&data, mem_ctx, &keys,
+ ndr_err = ndr_pull_struct_blob(&data, mem_ctx, NULL, &keys,
(ndr_pull_flags_fn_t)ndr_pull_netr_USER_KEYS);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
dump_data(10, data.data, data.length);
blob = data_blob_const(r->array, r->length);
- ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, str,
+ ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, NULL, str,
(ndr_pull_flags_fn_t)ndr_pull_netr_AcctLockStr);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
uint32_t usriX_code_page;
const char * usriX_profile;
const char * usriX_home_dir_drive;
+ uint32_t usriX_user_id;
uint32_t usriX_primary_group_id;
+ uint32_t usriX_password_expired;
};
struct GROUP_USERS_INFO_0 {
struct nbt_rdata_netbios netbios;/* [case(NBT_QTYPE_NETBIOS)] */
struct nbt_rdata_status status;/* [case(NBT_QTYPE_STATUS)] */
struct nbt_rdata_data data;/* [default] */
-}/* [nodiscriminant] */;
+}/* [nodiscriminant,public] */;
struct nbt_res_rec {
struct nbt_name name;
enum nbt_qtype rr_type;
enum nbt_qclass rr_class;
uint32_t ttl;
- union nbt_rdata rdata;/* [switch_is(((((rr_type)==NBT_QTYPE_NETBIOS)&&talloc_check_name(ndr,"struct ndr_push")&&((rdata).data.length==2))?0:rr_type))] */
-}/* [flag(LIBNDR_PRINT_ARRAY_HEX)] */;
+ union nbt_rdata rdata;/* [switch_is(rr_type)] */
+}/* [nopush,flag(LIBNDR_PRINT_ARRAY_HEX)] */;
struct nbt_name_packet {
uint16_t name_trn_id;
union dgram_data data;/* [switch_is(msg_type)] */
}/* [public,flag(LIBNDR_FLAG_NOALIGN|LIBNDR_FLAG_BIGENDIAN|LIBNDR_PRINT_ARRAY_HEX)] */;
-enum nbt_netlogon_command
-#ifndef USE_UINT_ENUMS
- {
- NETLOGON_QUERY_FOR_PDC=0x7,
- NETLOGON_ANNOUNCE_UAS=0xa,
- NETLOGON_RESPONSE_FROM_PDC=0xc,
- NETLOGON_QUERY_FOR_PDC2=0x12,
- NETLOGON_RESPONSE_FROM_PDC2=0x17,
- NETLOGON_RESPONSE_FROM_PDC_USER=0x19
-}
-#else
- { __donnot_use_enum_nbt_netlogon_command=0x7FFFFFFF}
-#define NETLOGON_QUERY_FOR_PDC ( 0x7 )
-#define NETLOGON_ANNOUNCE_UAS ( 0xa )
-#define NETLOGON_RESPONSE_FROM_PDC ( 0xc )
-#define NETLOGON_QUERY_FOR_PDC2 ( 0x12 )
-#define NETLOGON_RESPONSE_FROM_PDC2 ( 0x17 )
-#define NETLOGON_RESPONSE_FROM_PDC_USER ( 0x19 )
-#endif
-;
-
-/* bitmap nbt_netlogon_version */
-#define NETLOGON_VERSION_1 ( 0x00000001 )
-#define NETLOGON_VERSION_5 ( 0x00000002 )
-#define NETLOGON_VERSION_5EX ( 0x00000004 )
-#define NETLOGON_VERSION_5EX_WITH_IP ( 0x00000008 )
-#define NETLOGON_VERSION_WITH_CLOSEST_SITE ( 0x00000010 )
-#define NETLOGON_VERSION_AVOID_NT4_EMUL ( 0x01000000 )
-#define NETLOGON_VERSION_PDC ( 0x10000000 )
-#define NETLOGON_VERSION_IP ( 0x20000000 )
-#define NETLOGON_VERSION_LOCAL ( 0x40000000 )
-#define NETLOGON_VERSION_GC ( 0x80000000 )
-
-struct nbt_netlogon_query_for_pdc {
- const char * computer_name;/* [flag(LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM)] */
- const char * mailslot_name;/* [flag(LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM)] */
- DATA_BLOB _pad;/* [flag(LIBNDR_FLAG_ALIGN2)] */
- const char * unicode_name;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */
- uint32_t nt_version;
- uint16_t lmnt_token;
- uint16_t lm20_token;
-};
-
-struct nbt_netlogon_query_for_pdc2 {
- uint16_t request_count;
- const char * computer_name;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */
- const char * user_name;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */
- const char * mailslot_name;/* [flag(LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM)] */
- uint32_t unknown[2];
- uint32_t nt_version;
- uint16_t lmnt_token;
- uint16_t lm20_token;
-};
-
-struct nbt_netlogon_response_from_pdc {
- const char * pdc_name;/* [flag(LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM)] */
- DATA_BLOB _pad;/* [flag(LIBNDR_FLAG_ALIGN2)] */
- const char * unicode_pdc_name;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */
- const char * domain_name;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */
- uint32_t nt_version;
- uint16_t lmnt_token;
- uint16_t lm20_token;
-};
+struct nbt_sockaddr {
+ uint32_t sockaddr_family;
+ const char * pdc_ip;/* [flag(LIBNDR_FLAG_BIGENDIAN)] */
+ DATA_BLOB remaining;/* [flag(LIBNDR_FLAG_REMAINING)] */
+}/* [gensize,public] */;
/* bitmap nbt_server_type */
#define NBT_SERVER_PDC ( 0x00000001 )
#define NBT_SERVER_SELECT_SECRET_DOMAIN_6 ( 0x00000800 )
#define NBT_SERVER_FULL_SECRET_DOMAIN_6 ( 0x00001000 )
-struct nbt_dc_sock_addr {
- uint32_t family;
- const char * pdc_ip;/* [flag(LIBNDR_FLAG_BIGENDIAN)] */
- DATA_BLOB remaining;/* [flag(LIBNDR_FLAG_REMAINING)] */
-};
-
-struct nbt_netlogon_response_from_pdc2 {
- DATA_BLOB _pad;/* [flag(LIBNDR_FLAG_ALIGN4)] */
- uint32_t server_type;
- struct GUID domain_uuid;
- const char * forest;
- const char * dns_domain;
- const char * pdc_dns_name;
- const char * domain;
- const char * pdc_name;
- const char * user_name;
- const char * server_site;
- const char * client_site;
- uint8_t dc_sock_addr_size;
- struct nbt_dc_sock_addr dc_sock_addr;/* [subcontext_size(dc_sock_addr_size),subcontext(0)] */
- uint32_t nt_version;
- uint16_t lmnt_token;
- uint16_t lm20_token;
-};
-
-enum netr_SamDatabaseID;
-
-struct nbt_db_change {
- enum netr_SamDatabaseID db_index;
- uint64_t serial;
- NTTIME timestamp;
-};
+/* bitmap netlogon_nt_version_flags */
+#define NETLOGON_NT_VERSION_1 ( 0x00000001 )
+#define NETLOGON_NT_VERSION_5 ( 0x00000002 )
+#define NETLOGON_NT_VERSION_5EX ( 0x00000004 )
+#define NETLOGON_NT_VERSION_5EX_WITH_IP ( 0x00000008 )
+#define NETLOGON_NT_VERSION_WITH_CLOSEST_SITE ( 0x00000010 )
+#define NETLOGON_NT_VERSION_AVIOD_NT4EMUL ( 0x01000000 )
+#define NETLOGON_NT_VERSION_PDC ( 0x10000000 )
+#define NETLOGON_NT_VERSION_IP ( 0x20000000 )
+#define NETLOGON_NT_VERSION_LOCAL ( 0x40000000 )
+#define NETLOGON_NT_VERSION_GC ( 0x80000000 )
+
+enum netlogon_command
+#ifndef USE_UINT_ENUMS
+ {
+ LOGON_PRIMARY_QUERY=7,
+ NETLOGON_ANNOUNCE_UAS=10,
+ NETLOGON_RESPONSE_FROM_PDC=12,
+ LOGON_SAM_LOGON_REQUEST=18,
+ LOGON_SAM_LOGON_RESPONSE=19,
+ LOGON_SAM_LOGON_PAUSE_RESPONSE=20,
+ LOGON_SAM_LOGON_USER_UNKNOWN=21,
+ LOGON_SAM_LOGON_RESPONSE_EX=23,
+ LOGON_SAM_LOGON_PAUSE_RESPONSE_EX=24,
+ LOGON_SAM_LOGON_USER_UNKNOWN_EX=25
+}
+#else
+ { __donnot_use_enum_netlogon_command=0x7FFFFFFF}
+#define LOGON_PRIMARY_QUERY ( 7 )
+#define NETLOGON_ANNOUNCE_UAS ( 10 )
+#define NETLOGON_RESPONSE_FROM_PDC ( 12 )
+#define LOGON_SAM_LOGON_REQUEST ( 18 )
+#define LOGON_SAM_LOGON_RESPONSE ( 19 )
+#define LOGON_SAM_LOGON_PAUSE_RESPONSE ( 20 )
+#define LOGON_SAM_LOGON_USER_UNKNOWN ( 21 )
+#define LOGON_SAM_LOGON_RESPONSE_EX ( 23 )
+#define LOGON_SAM_LOGON_PAUSE_RESPONSE_EX ( 24 )
+#define LOGON_SAM_LOGON_USER_UNKNOWN_EX ( 25 )
+#endif
+;
-struct nbt_netlogon_announce_uas {
- uint32_t serial_lo;
- time_t timestamp;
- uint32_t pulse;
- uint32_t random;
- const char * pdc_name;/* [flag(LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM)] */
- const char * domain;/* [flag(LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM)] */
- DATA_BLOB _pad;/* [flag(LIBNDR_FLAG_ALIGN2)] */
- const char * unicode_pdc_name;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */
- const char * unicode_domain;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */
- uint32_t db_count;
- struct nbt_db_change *dbchange;
+struct NETLOGON_SAM_LOGON_REQUEST {
+ uint16_t request_count;
+ const char * computer_name;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */
+ const char * user_name;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */
+ const char * mailslot_name;/* [flag(LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM)] */
+ uint32_t acct_control;
uint32_t sid_size;/* [value(ndr_size_dom_sid0(&sid,ndr->flags))] */
+ DATA_BLOB _pad;/* [flag(LIBNDR_FLAG_ALIGN4)] */
struct dom_sid0 sid;/* [subcontext_size(sid_size),subcontext(0)] */
uint32_t nt_version;
uint16_t lmnt_token;
uint16_t lm20_token;
-};
+}/* [nopull,nopush] */;
-union nbt_netlogon_request {
- struct nbt_netlogon_query_for_pdc pdc;/* [case(NETLOGON_QUERY_FOR_PDC)] */
- struct nbt_netlogon_query_for_pdc2 pdc2;/* [case(NETLOGON_QUERY_FOR_PDC2)] */
- struct nbt_netlogon_announce_uas uas;/* [case(NETLOGON_ANNOUNCE_UAS)] */
- struct nbt_netlogon_response_from_pdc response;/* [case(NETLOGON_RESPONSE_FROM_PDC)] */
- struct nbt_netlogon_response_from_pdc2 response2;/* [case(NETLOGON_RESPONSE_FROM_PDC2)] */
-}/* [nodiscriminant] */;
-
-struct nbt_netlogon_packet {
- enum nbt_netlogon_command command;
- union nbt_netlogon_request req;/* [switch_is(command)] */
-}/* [public,flag(LIBNDR_FLAG_NOALIGN)] */;
-
-struct nbt_cldap_netlogon_1 {
- enum nbt_netlogon_command type;
- const char * pdc_name;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */
+struct NETLOGON_SAM_LOGON_RESPONSE_NT40 {
+ enum netlogon_command command;
+ const char * server;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */
const char * user_name;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */
- const char * domain_name;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */
- uint32_t nt_version;/* [value] */
+ const char * domain;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */
+ uint32_t nt_version;
uint16_t lmnt_token;
uint16_t lm20_token;
-};
+}/* [public,flag(LIBNDR_FLAG_NOALIGN)] */;
-struct nbt_cldap_netlogon_3 {
- enum nbt_netlogon_command type;
+struct NETLOGON_SAM_LOGON_RESPONSE {
+ enum netlogon_command command;
const char * pdc_name;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */
const char * user_name;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */
const char * domain_name;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */
struct GUID domain_uuid;
- struct GUID unknown_uuid;
+ struct GUID zero_uuid;
const char * forest;
const char * dns_domain;
const char * pdc_dns_name;
const char * pdc_ip;
uint32_t server_type;
- uint32_t nt_version;/* [value(3)] */
- uint16_t lmnt_token;
- uint16_t lm20_token;
-};
-
-struct nbt_cldap_netlogon_5 {
- enum nbt_netlogon_command type;
- uint16_t sbz;
- uint32_t server_type;
- struct GUID domain_uuid;
- const char * forest;
- const char * dns_domain;
- const char * pdc_dns_name;
- const char * domain;
- const char * pdc_name;
- const char * user_name;
- const char * server_site;
- const char * client_site;
- uint32_t nt_version;/* [value(5)] */
- uint16_t lmnt_token;
- uint16_t lm20_token;
-}/* [public] */;
-
-struct nbt_cldap_netlogon_13 {
- enum nbt_netlogon_command type;
- uint16_t sbz;
- uint32_t server_type;
- struct GUID domain_uuid;
- const char * forest;
- const char * dns_domain;
- const char * pdc_dns_name;
- const char * domain;
- const char * pdc_name;
- const char * user_name;
- const char * server_site;
- const char * client_site;
- uint8_t dc_sock_addr_size;
- struct nbt_dc_sock_addr dc_sock_addr;/* [subcontext_size(dc_sock_addr_size),subcontext(0)] */
- uint32_t nt_version;/* [value(13)] */
- uint16_t lmnt_token;
- uint16_t lm20_token;
-};
-
-struct nbt_cldap_netlogon_15 {
- enum nbt_netlogon_command type;
- uint16_t sbz;
- uint32_t server_type;
- struct GUID domain_uuid;
- const char * forest;
- const char * dns_domain;
- const char * pdc_dns_name;
- const char * domain;
- const char * pdc_name;
- const char * user_name;
- const char * server_site;
- const char * client_site;
- const char * next_closest_site;
- uint32_t nt_version;/* [value(15)] */
+ uint32_t nt_version;
uint16_t lmnt_token;
uint16_t lm20_token;
-}/* [public] */;
+}/* [public,flag(LIBNDR_FLAG_NOALIGN)] */;
-struct nbt_cldap_netlogon_29 {
- enum nbt_netlogon_command type;
+struct NETLOGON_SAM_LOGON_RESPONSE_EX {
+ enum netlogon_command command;
uint16_t sbz;
uint32_t server_type;
struct GUID domain_uuid;
const char * user_name;
const char * server_site;
const char * client_site;
- uint8_t dc_sock_addr_size;
- struct nbt_dc_sock_addr dc_sock_addr;/* [subcontext_size(dc_sock_addr_size),subcontext(0)] */
+ uint8_t sockaddr_size;/* [value(ndr_size_nbt_sockaddr(&sockaddr,ndr->flags))] */
+ struct nbt_sockaddr sockaddr;/* [subcontext_size(sockaddr_size),subcontext(0)] */
const char * next_closest_site;
- uint32_t nt_version;/* [value(29)] */
+ uint32_t nt_version;
uint16_t lmnt_token;
uint16_t lm20_token;
-}/* [public] */;
-
-union nbt_cldap_netlogon {
- struct nbt_cldap_netlogon_1 logon1;/* [case(0)] */
- struct nbt_cldap_netlogon_3 logon3;/* [case(2)] */
- struct nbt_cldap_netlogon_5 logon5;/* [case(4)] */
- struct nbt_cldap_netlogon_13 logon13;/* [case(8)] */
- struct nbt_cldap_netlogon_15 logon15;/* [case(20)] */
- struct nbt_cldap_netlogon_29 logon29;/* [case(29)] */
-}/* [public,nodiscriminant,flag(LIBNDR_FLAG_NOALIGN)] */;
-
-enum nbt_ntlogon_command
-#ifndef USE_UINT_ENUMS
- {
- NTLOGON_SAM_LOGON=0x12,
- NTLOGON_SAM_LOGON_REPLY=0x13,
- NTLOGON_SAM_LOGON_REPLY15=0x15,
- NTLOGON_RESPONSE_FROM_PDC2=0x17
-}
-#else
- { __donnot_use_enum_nbt_ntlogon_command=0x7FFFFFFF}
-#define NTLOGON_SAM_LOGON ( 0x12 )
-#define NTLOGON_SAM_LOGON_REPLY ( 0x13 )
-#define NTLOGON_SAM_LOGON_REPLY15 ( 0x15 )
-#define NTLOGON_RESPONSE_FROM_PDC2 ( 0x17 )
-#endif
-;
+}/* [public,flag(LIBNDR_FLAG_NOALIGN)] */;
-struct nbt_ntlogon_sam_logon {
- uint16_t request_count;
- const char * computer_name;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */
- const char * user_name;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */
+struct nbt_netlogon_query_for_pdc {
+ const char * computer_name;/* [flag(LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM)] */
const char * mailslot_name;/* [flag(LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM)] */
- uint32_t acct_control;
- uint32_t sid_size;/* [value(ndr_size_dom_sid0(&sid,ndr->flags))] */
- struct dom_sid0 sid;/* [subcontext_size(sid_size),subcontext(0)] */
+ DATA_BLOB _pad;/* [flag(LIBNDR_FLAG_ALIGN2)] */
+ const char * unicode_name;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */
uint32_t nt_version;
uint16_t lmnt_token;
uint16_t lm20_token;
};
-struct nbt_ntlogon_sam_logon_reply {
- const char * server;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */
- const char * user_name;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */
- const char * domain;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */
+struct nbt_netlogon_response_from_pdc {
+ enum netlogon_command command;
+ const char * pdc_name;/* [flag(LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM)] */
+ DATA_BLOB _pad;/* [flag(LIBNDR_FLAG_ALIGN2)] */
+ const char * unicode_pdc_name;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */
+ const char * domain_name;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */
uint32_t nt_version;
uint16_t lmnt_token;
uint16_t lm20_token;
+}/* [public,flag(LIBNDR_FLAG_NOALIGN)] */;
+
+enum netr_SamDatabaseID;
+
+struct nbt_db_change_info {
+ enum netr_SamDatabaseID db_index;
+ uint64_t serial;
+ NTTIME timestamp;
+};
+
+struct NETLOGON_DB_CHANGE {
+ uint32_t serial_lo;
+ time_t timestamp;
+ uint32_t pulse;
+ uint32_t random;
+ const char * pdc_name;/* [flag(LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM)] */
+ const char * domain;/* [flag(LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM)] */
+ DATA_BLOB _pad;/* [flag(LIBNDR_FLAG_ALIGN2)] */
+ const char * unicode_pdc_name;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */
+ const char * unicode_domain;/* [flag(LIBNDR_FLAG_STR_NULLTERM)] */
+ uint32_t db_count;
+ struct nbt_db_change_info *dbchange;
+ uint32_t sid_size;/* [value(ndr_size_dom_sid0(&sid,ndr->flags))] */
+ struct dom_sid0 sid;/* [subcontext_size(sid_size),subcontext(0)] */
+ uint32_t message_format_version;
+ uint32_t message_token;
};
-union nbt_ntlogon_request {
- struct nbt_ntlogon_sam_logon logon;/* [case(NTLOGON_SAM_LOGON)] */
- struct nbt_ntlogon_sam_logon_reply reply;/* [case(NTLOGON_SAM_LOGON_REPLY)] */
- struct nbt_netlogon_response_from_pdc2 reply2;/* [case(NTLOGON_RESPONSE_FROM_PDC2)] */
+union nbt_netlogon_request {
+ struct NETLOGON_SAM_LOGON_REQUEST logon;/* [case(LOGON_SAM_LOGON_REQUEST)] */
+ struct nbt_netlogon_query_for_pdc pdc;/* [case(LOGON_PRIMARY_QUERY)] */
+ struct NETLOGON_DB_CHANGE uas;/* [case(NETLOGON_ANNOUNCE_UAS)] */
}/* [nodiscriminant] */;
-struct nbt_ntlogon_packet {
- enum nbt_ntlogon_command command;
- union nbt_ntlogon_request req;/* [switch_is(command)] */
+struct nbt_netlogon_packet {
+ enum netlogon_command command;
+ union nbt_netlogon_request req;/* [switch_is(command)] */
}/* [public,flag(LIBNDR_FLAG_NOALIGN)] */;
enum nbt_browse_opcode
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->usriX_code_page));
NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->usriX_profile));
NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->usriX_home_dir_drive));
+ NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->usriX_user_id));
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->usriX_primary_group_id));
+ NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->usriX_password_expired));
}
if (ndr_flags & NDR_BUFFERS) {
if (r->usriX_logon_hours) {
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->usriX_code_page));
NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->usriX_profile));
NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->usriX_home_dir_drive));
+ NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->usriX_user_id));
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->usriX_primary_group_id));
+ NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->usriX_password_expired));
}
if (ndr_flags & NDR_BUFFERS) {
if (r->usriX_logon_hours) {
ndr_print_uint32(ndr, "usriX_code_page", r->usriX_code_page);
ndr_print_string(ndr, "usriX_profile", r->usriX_profile);
ndr_print_string(ndr, "usriX_home_dir_drive", r->usriX_home_dir_drive);
+ ndr_print_uint32(ndr, "usriX_user_id", r->usriX_user_id);
ndr_print_uint32(ndr, "usriX_primary_group_id", r->usriX_primary_group_id);
+ ndr_print_uint32(ndr, "usriX_password_expired", r->usriX_password_expired);
ndr->depth--;
}
ndr->depth--;
}
-static enum ndr_err_code ndr_push_nbt_qclass(struct ndr_push *ndr, int ndr_flags, enum nbt_qclass r)
+_PUBLIC_ enum ndr_err_code ndr_push_nbt_qclass(struct ndr_push *ndr, int ndr_flags, enum nbt_qclass r)
{
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
return NDR_ERR_SUCCESS;
}
-static enum ndr_err_code ndr_pull_nbt_qclass(struct ndr_pull *ndr, int ndr_flags, enum nbt_qclass *r)
+_PUBLIC_ enum ndr_err_code ndr_pull_nbt_qclass(struct ndr_pull *ndr, int ndr_flags, enum nbt_qclass *r)
{
uint16_t v;
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
ndr_print_enum(ndr, name, "ENUM", val, r);
}
-static enum ndr_err_code ndr_push_nbt_qtype(struct ndr_push *ndr, int ndr_flags, enum nbt_qtype r)
+_PUBLIC_ enum ndr_err_code ndr_push_nbt_qtype(struct ndr_push *ndr, int ndr_flags, enum nbt_qtype r)
{
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
return NDR_ERR_SUCCESS;
}
-static enum ndr_err_code ndr_pull_nbt_qtype(struct ndr_pull *ndr, int ndr_flags, enum nbt_qtype *r)
+_PUBLIC_ enum ndr_err_code ndr_pull_nbt_qtype(struct ndr_pull *ndr, int ndr_flags, enum nbt_qtype *r)
{
uint16_t v;
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
ndr->depth--;
}
-static enum ndr_err_code ndr_push_nbt_rdata(struct ndr_push *ndr, int ndr_flags, const union nbt_rdata *r)
+_PUBLIC_ enum ndr_err_code ndr_push_nbt_rdata(struct ndr_push *ndr, int ndr_flags, const union nbt_rdata *r)
{
if (ndr_flags & NDR_SCALARS) {
int level = ndr_push_get_switch_value(ndr, r);
return NDR_ERR_SUCCESS;
}
-static enum ndr_err_code ndr_pull_nbt_rdata(struct ndr_pull *ndr, int ndr_flags, union nbt_rdata *r)
+_PUBLIC_ enum ndr_err_code ndr_pull_nbt_rdata(struct ndr_pull *ndr, int ndr_flags, union nbt_rdata *r)
{
int level;
level = ndr_pull_get_switch_value(ndr, r);
}
}
-static enum ndr_err_code ndr_push_nbt_res_rec(struct ndr_push *ndr, int ndr_flags, const struct nbt_res_rec *r)
-{
- {
- uint32_t _flags_save_STRUCT = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
- if (ndr_flags & NDR_SCALARS) {
- NDR_CHECK(ndr_push_align(ndr, 4));
- NDR_CHECK(ndr_push_nbt_name(ndr, NDR_SCALARS, &r->name));
- NDR_CHECK(ndr_push_nbt_qtype(ndr, NDR_SCALARS, r->rr_type));
- NDR_CHECK(ndr_push_nbt_qclass(ndr, NDR_SCALARS, r->rr_class));
- NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ttl));
- NDR_CHECK(ndr_push_set_switch_value(ndr, &r->rdata, ((((r->rr_type) == NBT_QTYPE_NETBIOS) && talloc_check_name(ndr, "struct ndr_push") && ((r->rdata).data.length == 2))?0:r->rr_type)));
- NDR_CHECK(ndr_push_nbt_rdata(ndr, NDR_SCALARS, &r->rdata));
- }
- if (ndr_flags & NDR_BUFFERS) {
- }
- ndr->flags = _flags_save_STRUCT;
- }
- return NDR_ERR_SUCCESS;
-}
-
static enum ndr_err_code ndr_pull_nbt_res_rec(struct ndr_pull *ndr, int ndr_flags, struct nbt_res_rec *r)
{
{
NDR_CHECK(ndr_pull_nbt_qtype(ndr, NDR_SCALARS, &r->rr_type));
NDR_CHECK(ndr_pull_nbt_qclass(ndr, NDR_SCALARS, &r->rr_class));
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ttl));
- NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->rdata, ((((r->rr_type) == NBT_QTYPE_NETBIOS) && talloc_check_name(ndr, "struct ndr_push") && ((r->rdata).data.length == 2))?0:r->rr_type)));
+ NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->rdata, r->rr_type));
NDR_CHECK(ndr_pull_nbt_rdata(ndr, NDR_SCALARS, &r->rdata));
}
if (ndr_flags & NDR_BUFFERS) {
ndr_print_nbt_qtype(ndr, "rr_type", r->rr_type);
ndr_print_nbt_qclass(ndr, "rr_class", r->rr_class);
ndr_print_uint32(ndr, "ttl", r->ttl);
- ndr_print_set_switch_value(ndr, &r->rdata, ((((r->rr_type) == NBT_QTYPE_NETBIOS) && talloc_check_name(ndr, "struct ndr_push") && ((r->rdata).data.length == 2))?0:r->rr_type));
+ ndr_print_set_switch_value(ndr, &r->rdata, r->rr_type);
ndr_print_nbt_rdata(ndr, "rdata", &r->rdata);
ndr->depth--;
ndr->flags = _flags_save_STRUCT;
}
}
-static enum ndr_err_code ndr_push_nbt_netlogon_command(struct ndr_push *ndr, int ndr_flags, enum nbt_netlogon_command r)
+_PUBLIC_ enum ndr_err_code ndr_push_nbt_sockaddr(struct ndr_push *ndr, int ndr_flags, const struct nbt_sockaddr *r)
+{
+ if (ndr_flags & NDR_SCALARS) {
+ NDR_CHECK(ndr_push_align(ndr, 4));
+ NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sockaddr_family));
+ {
+ uint32_t _flags_save_ipv4address = ndr->flags;
+ ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
+ NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->pdc_ip));
+ ndr->flags = _flags_save_ipv4address;
+ }
+ {
+ uint32_t _flags_save_DATA_BLOB = ndr->flags;
+ ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
+ NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->remaining));
+ ndr->flags = _flags_save_DATA_BLOB;
+ }
+ }
+ if (ndr_flags & NDR_BUFFERS) {
+ }
+ return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ enum ndr_err_code ndr_pull_nbt_sockaddr(struct ndr_pull *ndr, int ndr_flags, struct nbt_sockaddr *r)
+{
+ if (ndr_flags & NDR_SCALARS) {
+ NDR_CHECK(ndr_pull_align(ndr, 4));
+ NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sockaddr_family));
+ {
+ uint32_t _flags_save_ipv4address = ndr->flags;
+ ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
+ NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->pdc_ip));
+ ndr->flags = _flags_save_ipv4address;
+ }
+ {
+ uint32_t _flags_save_DATA_BLOB = ndr->flags;
+ ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
+ NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->remaining));
+ ndr->flags = _flags_save_DATA_BLOB;
+ }
+ }
+ if (ndr_flags & NDR_BUFFERS) {
+ }
+ return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_nbt_sockaddr(struct ndr_print *ndr, const char *name, const struct nbt_sockaddr *r)
+{
+ ndr_print_struct(ndr, name, "nbt_sockaddr");
+ ndr->depth++;
+ ndr_print_uint32(ndr, "sockaddr_family", r->sockaddr_family);
+ ndr_print_ipv4address(ndr, "pdc_ip", r->pdc_ip);
+ ndr_print_DATA_BLOB(ndr, "remaining", r->remaining);
+ ndr->depth--;
+}
+
+_PUBLIC_ size_t ndr_size_nbt_sockaddr(const struct nbt_sockaddr *r, int flags)
+{
+ return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_nbt_sockaddr);
+}
+
+_PUBLIC_ enum ndr_err_code ndr_push_nbt_server_type(struct ndr_push *ndr, int ndr_flags, uint32_t r)
+{
+ NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
+ return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ enum ndr_err_code ndr_pull_nbt_server_type(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
+{
+ uint32_t v;
+ NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
+ *r = v;
+ return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_nbt_server_type(struct ndr_print *ndr, const char *name, uint32_t r)
+{
+ ndr_print_uint32(ndr, name, r);
+ ndr->depth++;
+ ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_PDC", NBT_SERVER_PDC, r);
+ ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_GC", NBT_SERVER_GC, r);
+ ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_LDAP", NBT_SERVER_LDAP, r);
+ ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_DS", NBT_SERVER_DS, r);
+ ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_KDC", NBT_SERVER_KDC, r);
+ ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_TIMESERV", NBT_SERVER_TIMESERV, r);
+ ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_CLOSEST", NBT_SERVER_CLOSEST, r);
+ ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_WRITABLE", NBT_SERVER_WRITABLE, r);
+ ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_GOOD_TIMESERV", NBT_SERVER_GOOD_TIMESERV, r);
+ ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_NDNC", NBT_SERVER_NDNC, r);
+ ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_SELECT_SECRET_DOMAIN_6", NBT_SERVER_SELECT_SECRET_DOMAIN_6, r);
+ ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_FULL_SECRET_DOMAIN_6", NBT_SERVER_FULL_SECRET_DOMAIN_6, r);
+ ndr->depth--;
+}
+
+_PUBLIC_ enum ndr_err_code ndr_push_netlogon_nt_version_flags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
+{
+ NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
+ return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ enum ndr_err_code ndr_pull_netlogon_nt_version_flags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
+{
+ uint32_t v;
+ NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
+ *r = v;
+ return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_netlogon_nt_version_flags(struct ndr_print *ndr, const char *name, uint32_t r)
+{
+ ndr_print_uint32(ndr, name, r);
+ ndr->depth++;
+ ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NETLOGON_NT_VERSION_1", NETLOGON_NT_VERSION_1, r);
+ ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NETLOGON_NT_VERSION_5", NETLOGON_NT_VERSION_5, r);
+ ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NETLOGON_NT_VERSION_5EX", NETLOGON_NT_VERSION_5EX, r);
+ ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NETLOGON_NT_VERSION_5EX_WITH_IP", NETLOGON_NT_VERSION_5EX_WITH_IP, r);
+ ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NETLOGON_NT_VERSION_WITH_CLOSEST_SITE", NETLOGON_NT_VERSION_WITH_CLOSEST_SITE, r);
+ ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NETLOGON_NT_VERSION_AVIOD_NT4EMUL", NETLOGON_NT_VERSION_AVIOD_NT4EMUL, r);
+ ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NETLOGON_NT_VERSION_PDC", NETLOGON_NT_VERSION_PDC, r);
+ ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NETLOGON_NT_VERSION_IP", NETLOGON_NT_VERSION_IP, r);
+ ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NETLOGON_NT_VERSION_LOCAL", NETLOGON_NT_VERSION_LOCAL, r);
+ ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NETLOGON_NT_VERSION_GC", NETLOGON_NT_VERSION_GC, r);
+ ndr->depth--;
+}
+
+_PUBLIC_ enum ndr_err_code ndr_push_netlogon_command(struct ndr_push *ndr, int ndr_flags, enum netlogon_command r)
{
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
return NDR_ERR_SUCCESS;
}
-static enum ndr_err_code ndr_pull_nbt_netlogon_command(struct ndr_pull *ndr, int ndr_flags, enum nbt_netlogon_command *r)
+_PUBLIC_ enum ndr_err_code ndr_pull_netlogon_command(struct ndr_pull *ndr, int ndr_flags, enum netlogon_command *r)
{
uint16_t v;
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
return NDR_ERR_SUCCESS;
}
-_PUBLIC_ void ndr_print_nbt_netlogon_command(struct ndr_print *ndr, const char *name, enum nbt_netlogon_command r)
+_PUBLIC_ void ndr_print_netlogon_command(struct ndr_print *ndr, const char *name, enum netlogon_command r)
{
const char *val = NULL;
switch (r) {
- case NETLOGON_QUERY_FOR_PDC: val = "NETLOGON_QUERY_FOR_PDC"; break;
+ case LOGON_PRIMARY_QUERY: val = "LOGON_PRIMARY_QUERY"; break;
case NETLOGON_ANNOUNCE_UAS: val = "NETLOGON_ANNOUNCE_UAS"; break;
case NETLOGON_RESPONSE_FROM_PDC: val = "NETLOGON_RESPONSE_FROM_PDC"; break;
- case NETLOGON_QUERY_FOR_PDC2: val = "NETLOGON_QUERY_FOR_PDC2"; break;
- case NETLOGON_RESPONSE_FROM_PDC2: val = "NETLOGON_RESPONSE_FROM_PDC2"; break;
- case NETLOGON_RESPONSE_FROM_PDC_USER: val = "NETLOGON_RESPONSE_FROM_PDC_USER"; break;
+ case LOGON_SAM_LOGON_REQUEST: val = "LOGON_SAM_LOGON_REQUEST"; break;
+ case LOGON_SAM_LOGON_RESPONSE: val = "LOGON_SAM_LOGON_RESPONSE"; break;
+ case LOGON_SAM_LOGON_PAUSE_RESPONSE: val = "LOGON_SAM_LOGON_PAUSE_RESPONSE"; break;
+ case LOGON_SAM_LOGON_USER_UNKNOWN: val = "LOGON_SAM_LOGON_USER_UNKNOWN"; break;
+ case LOGON_SAM_LOGON_RESPONSE_EX: val = "LOGON_SAM_LOGON_RESPONSE_EX"; break;
+ case LOGON_SAM_LOGON_PAUSE_RESPONSE_EX: val = "LOGON_SAM_LOGON_PAUSE_RESPONSE_EX"; break;
+ case LOGON_SAM_LOGON_USER_UNKNOWN_EX: val = "LOGON_SAM_LOGON_USER_UNKNOWN_EX"; break;
}
ndr_print_enum(ndr, name, "ENUM", val, r);
}
-static enum ndr_err_code ndr_push_nbt_netlogon_version(struct ndr_push *ndr, int ndr_flags, uint32_t r)
+_PUBLIC_ void ndr_print_NETLOGON_SAM_LOGON_REQUEST(struct ndr_print *ndr, const char *name, const struct NETLOGON_SAM_LOGON_REQUEST *r)
+{
+ ndr_print_struct(ndr, name, "NETLOGON_SAM_LOGON_REQUEST");
+ ndr->depth++;
+ ndr_print_uint16(ndr, "request_count", r->request_count);
+ ndr_print_string(ndr, "computer_name", r->computer_name);
+ ndr_print_string(ndr, "user_name", r->user_name);
+ ndr_print_string(ndr, "mailslot_name", r->mailslot_name);
+ ndr_print_samr_AcctFlags(ndr, "acct_control", r->acct_control);
+ ndr_print_uint32(ndr, "sid_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_dom_sid0(&r->sid, ndr->flags):r->sid_size);
+ ndr_print_DATA_BLOB(ndr, "_pad", r->_pad);
+ ndr_print_dom_sid0(ndr, "sid", &r->sid);
+ ndr_print_netlogon_nt_version_flags(ndr, "nt_version", r->nt_version);
+ ndr_print_uint16(ndr, "lmnt_token", r->lmnt_token);
+ ndr_print_uint16(ndr, "lm20_token", r->lm20_token);
+ ndr->depth--;
+}
+
+_PUBLIC_ enum ndr_err_code ndr_push_NETLOGON_SAM_LOGON_RESPONSE_NT40(struct ndr_push *ndr, int ndr_flags, const struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *r)
{
{
- uint32_t _flags_save_BITMAP = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_LITTLE_ENDIAN);
- NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
- ndr->flags = _flags_save_BITMAP;
+ uint32_t _flags_save_STRUCT = ndr->flags;
+ ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
+ if (ndr_flags & NDR_SCALARS) {
+ NDR_CHECK(ndr_push_align(ndr, 4));
+ NDR_CHECK(ndr_push_netlogon_command(ndr, NDR_SCALARS, r->command));
+ {
+ uint32_t _flags_save_string = ndr->flags;
+ ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
+ NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server));
+ ndr->flags = _flags_save_string;
+ }
+ {
+ uint32_t _flags_save_string = ndr->flags;
+ ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
+ NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
+ ndr->flags = _flags_save_string;
+ }
+ {
+ uint32_t _flags_save_string = ndr->flags;
+ ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
+ NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->domain));
+ ndr->flags = _flags_save_string;
+ }
+ NDR_CHECK(ndr_push_netlogon_nt_version_flags(ndr, NDR_SCALARS, r->nt_version));
+ NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lmnt_token));
+ NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lm20_token));
+ }
+ if (ndr_flags & NDR_BUFFERS) {
+ }
+ ndr->flags = _flags_save_STRUCT;
}
return NDR_ERR_SUCCESS;
}
-static enum ndr_err_code ndr_pull_nbt_netlogon_version(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
+_PUBLIC_ enum ndr_err_code ndr_pull_NETLOGON_SAM_LOGON_RESPONSE_NT40(struct ndr_pull *ndr, int ndr_flags, struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *r)
+{
+ {
+ uint32_t _flags_save_STRUCT = ndr->flags;
+ ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
+ if (ndr_flags & NDR_SCALARS) {
+ NDR_CHECK(ndr_pull_align(ndr, 4));
+ NDR_CHECK(ndr_pull_netlogon_command(ndr, NDR_SCALARS, &r->command));
+ {
+ uint32_t _flags_save_string = ndr->flags;
+ ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
+ NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server));
+ ndr->flags = _flags_save_string;
+ }
+ {
+ uint32_t _flags_save_string = ndr->flags;
+ ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
+ NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
+ ndr->flags = _flags_save_string;
+ }
+ {
+ uint32_t _flags_save_string = ndr->flags;
+ ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
+ NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->domain));
+ ndr->flags = _flags_save_string;
+ }
+ NDR_CHECK(ndr_pull_netlogon_nt_version_flags(ndr, NDR_SCALARS, &r->nt_version));
+ NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lmnt_token));
+ NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lm20_token));
+ }
+ if (ndr_flags & NDR_BUFFERS) {
+ }
+ ndr->flags = _flags_save_STRUCT;
+ }
+ return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_NETLOGON_SAM_LOGON_RESPONSE_NT40(struct ndr_print *ndr, const char *name, const struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *r)
+{
+ ndr_print_struct(ndr, name, "NETLOGON_SAM_LOGON_RESPONSE_NT40");
+ {
+ uint32_t _flags_save_STRUCT = ndr->flags;
+ ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
+ ndr->depth++;
+ ndr_print_netlogon_command(ndr, "command", r->command);
+ ndr_print_string(ndr, "server", r->server);
+ ndr_print_string(ndr, "user_name", r->user_name);
+ ndr_print_string(ndr, "domain", r->domain);
+ ndr_print_netlogon_nt_version_flags(ndr, "nt_version", r->nt_version);
+ ndr_print_uint16(ndr, "lmnt_token", r->lmnt_token);
+ ndr_print_uint16(ndr, "lm20_token", r->lm20_token);
+ ndr->depth--;
+ ndr->flags = _flags_save_STRUCT;
+ }
+}
+
+_PUBLIC_ enum ndr_err_code ndr_push_NETLOGON_SAM_LOGON_RESPONSE(struct ndr_push *ndr, int ndr_flags, const struct NETLOGON_SAM_LOGON_RESPONSE *r)
+{
+ {
+ uint32_t _flags_save_STRUCT = ndr->flags;
+ ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
+ if (ndr_flags & NDR_SCALARS) {
+ NDR_CHECK(ndr_push_align(ndr, 4));
+ NDR_CHECK(ndr_push_netlogon_command(ndr, NDR_SCALARS, r->command));
+ {
+ uint32_t _flags_save_string = ndr->flags;
+ ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
+ NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->pdc_name));
+ ndr->flags = _flags_save_string;
+ }
+ {
+ uint32_t _flags_save_string = ndr->flags;
+ ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
+ NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
+ ndr->flags = _flags_save_string;
+ }
+ {
+ uint32_t _flags_save_string = ndr->flags;
+ ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
+ NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->domain_name));
+ ndr->flags = _flags_save_string;
+ }
+ NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->domain_uuid));
+ NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->zero_uuid));
+ NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->forest));
+ NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->dns_domain));
+ NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->pdc_dns_name));
+ NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->pdc_ip));
+ NDR_CHECK(ndr_push_nbt_server_type(ndr, NDR_SCALARS, r->server_type));
+ NDR_CHECK(ndr_push_netlogon_nt_version_flags(ndr, NDR_SCALARS, r->nt_version));
+ NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lmnt_token));
+ NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lm20_token));
+ }
+ if (ndr_flags & NDR_BUFFERS) {
+ }
+ ndr->flags = _flags_save_STRUCT;
+ }
+ return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ enum ndr_err_code ndr_pull_NETLOGON_SAM_LOGON_RESPONSE(struct ndr_pull *ndr, int ndr_flags, struct NETLOGON_SAM_LOGON_RESPONSE *r)
+{
+ {
+ uint32_t _flags_save_STRUCT = ndr->flags;
+ ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
+ if (ndr_flags & NDR_SCALARS) {
+ NDR_CHECK(ndr_pull_align(ndr, 4));
+ NDR_CHECK(ndr_pull_netlogon_command(ndr, NDR_SCALARS, &r->command));
+ {
+ uint32_t _flags_save_string = ndr->flags;
+ ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
+ NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->pdc_name));
+ ndr->flags = _flags_save_string;
+ }
+ {
+ uint32_t _flags_save_string = ndr->flags;
+ ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
+ NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
+ ndr->flags = _flags_save_string;
+ }
+ {
+ uint32_t _flags_save_string = ndr->flags;
+ ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
+ NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->domain_name));
+ ndr->flags = _flags_save_string;
+ }
+ NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->domain_uuid));
+ NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->zero_uuid));
+ NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->forest));
+ NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->dns_domain));
+ NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->pdc_dns_name));
+ NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->pdc_ip));
+ NDR_CHECK(ndr_pull_nbt_server_type(ndr, NDR_SCALARS, &r->server_type));
+ NDR_CHECK(ndr_pull_netlogon_nt_version_flags(ndr, NDR_SCALARS, &r->nt_version));
+ NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lmnt_token));
+ NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lm20_token));
+ }
+ if (ndr_flags & NDR_BUFFERS) {
+ }
+ ndr->flags = _flags_save_STRUCT;
+ }
+ return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_NETLOGON_SAM_LOGON_RESPONSE(struct ndr_print *ndr, const char *name, const struct NETLOGON_SAM_LOGON_RESPONSE *r)
+{
+ ndr_print_struct(ndr, name, "NETLOGON_SAM_LOGON_RESPONSE");
+ {
+ uint32_t _flags_save_STRUCT = ndr->flags;
+ ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
+ ndr->depth++;
+ ndr_print_netlogon_command(ndr, "command", r->command);
+ ndr_print_string(ndr, "pdc_name", r->pdc_name);
+ ndr_print_string(ndr, "user_name", r->user_name);
+ ndr_print_string(ndr, "domain_name", r->domain_name);
+ ndr_print_GUID(ndr, "domain_uuid", &r->domain_uuid);
+ ndr_print_GUID(ndr, "zero_uuid", &r->zero_uuid);
+ ndr_print_nbt_string(ndr, "forest", r->forest);
+ ndr_print_nbt_string(ndr, "dns_domain", r->dns_domain);
+ ndr_print_nbt_string(ndr, "pdc_dns_name", r->pdc_dns_name);
+ ndr_print_ipv4address(ndr, "pdc_ip", r->pdc_ip);
+ ndr_print_nbt_server_type(ndr, "server_type", r->server_type);
+ ndr_print_netlogon_nt_version_flags(ndr, "nt_version", r->nt_version);
+ ndr_print_uint16(ndr, "lmnt_token", r->lmnt_token);
+ ndr_print_uint16(ndr, "lm20_token", r->lm20_token);
+ ndr->depth--;
+ ndr->flags = _flags_save_STRUCT;
+ }
+}
+
+_PUBLIC_ enum ndr_err_code ndr_push_NETLOGON_SAM_LOGON_RESPONSE_EX(struct ndr_push *ndr, int ndr_flags, const struct NETLOGON_SAM_LOGON_RESPONSE_EX *r)
+{
+ {
+ uint32_t _flags_save_STRUCT = ndr->flags;
+ ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
+ if (ndr_flags & NDR_SCALARS) {
+ NDR_CHECK(ndr_push_align(ndr, 4));
+ NDR_CHECK(ndr_push_netlogon_command(ndr, NDR_SCALARS, r->command));
+ NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->sbz));
+ NDR_CHECK(ndr_push_nbt_server_type(ndr, NDR_SCALARS, r->server_type));
+ NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->domain_uuid));
+ NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->forest));
+ NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->dns_domain));
+ NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->pdc_dns_name));
+ NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->domain));
+ NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->pdc_name));
+ NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->user_name));
+ NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->server_site));
+ NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->client_site));
+ NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, ndr_size_nbt_sockaddr(&r->sockaddr, ndr->flags)));
+ {
+ struct ndr_push *_ndr_sockaddr;
+ NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_sockaddr, 0, ndr_size_nbt_sockaddr(&r->sockaddr, ndr->flags)));
+ NDR_CHECK(ndr_push_nbt_sockaddr(_ndr_sockaddr, NDR_SCALARS, &r->sockaddr));
+ NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_sockaddr, 0, ndr_size_nbt_sockaddr(&r->sockaddr, ndr->flags)));
+ }
+ NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->next_closest_site));
+ NDR_CHECK(ndr_push_netlogon_nt_version_flags(ndr, NDR_SCALARS, r->nt_version));
+ NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lmnt_token));
+ NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lm20_token));
+ }
+ if (ndr_flags & NDR_BUFFERS) {
+ }
+ ndr->flags = _flags_save_STRUCT;
+ }
+ return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ enum ndr_err_code ndr_pull_NETLOGON_SAM_LOGON_RESPONSE_EX(struct ndr_pull *ndr, int ndr_flags, struct NETLOGON_SAM_LOGON_RESPONSE_EX *r)
{
- uint32_t v;
{
- uint32_t _flags_save_BITMAP = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_LITTLE_ENDIAN);
- NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
- *r = v;
- ndr->flags = _flags_save_BITMAP;
+ uint32_t _flags_save_STRUCT = ndr->flags;
+ ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
+ if (ndr_flags & NDR_SCALARS) {
+ NDR_CHECK(ndr_pull_align(ndr, 4));
+ NDR_CHECK(ndr_pull_netlogon_command(ndr, NDR_SCALARS, &r->command));
+ NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->sbz));
+ NDR_CHECK(ndr_pull_nbt_server_type(ndr, NDR_SCALARS, &r->server_type));
+ NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->domain_uuid));
+ NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->forest));
+ NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->dns_domain));
+ NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->pdc_dns_name));
+ NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->domain));
+ NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->pdc_name));
+ NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->user_name));
+ NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->server_site));
+ NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->client_site));
+ NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->sockaddr_size));
+ {
+ struct ndr_pull *_ndr_sockaddr;
+ NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_sockaddr, 0, r->sockaddr_size));
+ NDR_CHECK(ndr_pull_nbt_sockaddr(_ndr_sockaddr, NDR_SCALARS, &r->sockaddr));
+ NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_sockaddr, 0, r->sockaddr_size));
+ }
+ NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->next_closest_site));
+ NDR_CHECK(ndr_pull_netlogon_nt_version_flags(ndr, NDR_SCALARS, &r->nt_version));
+ NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lmnt_token));
+ NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lm20_token));
+ }
+ if (ndr_flags & NDR_BUFFERS) {
+ }
+ ndr->flags = _flags_save_STRUCT;
}
return NDR_ERR_SUCCESS;
}
-_PUBLIC_ void ndr_print_nbt_netlogon_version(struct ndr_print *ndr, const char *name, uint32_t r)
+_PUBLIC_ void ndr_print_NETLOGON_SAM_LOGON_RESPONSE_EX(struct ndr_print *ndr, const char *name, const struct NETLOGON_SAM_LOGON_RESPONSE_EX *r)
{
+ ndr_print_struct(ndr, name, "NETLOGON_SAM_LOGON_RESPONSE_EX");
{
- uint32_t _flags_save_BITMAP = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_LITTLE_ENDIAN);
- ndr_print_uint32(ndr, name, r);
+ uint32_t _flags_save_STRUCT = ndr->flags;
+ ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
ndr->depth++;
- ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NETLOGON_VERSION_1", NETLOGON_VERSION_1, r);
- ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NETLOGON_VERSION_5", NETLOGON_VERSION_5, r);
- ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NETLOGON_VERSION_5EX", NETLOGON_VERSION_5EX, r);
- ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NETLOGON_VERSION_5EX_WITH_IP", NETLOGON_VERSION_5EX_WITH_IP, r);
- ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NETLOGON_VERSION_WITH_CLOSEST_SITE", NETLOGON_VERSION_WITH_CLOSEST_SITE, r);
- ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NETLOGON_VERSION_AVOID_NT4_EMUL", NETLOGON_VERSION_AVOID_NT4_EMUL, r);
- ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NETLOGON_VERSION_PDC", NETLOGON_VERSION_PDC, r);
- ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NETLOGON_VERSION_IP", NETLOGON_VERSION_IP, r);
- ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NETLOGON_VERSION_LOCAL", NETLOGON_VERSION_LOCAL, r);
- ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NETLOGON_VERSION_GC", NETLOGON_VERSION_GC, r);
+ ndr_print_netlogon_command(ndr, "command", r->command);
+ ndr_print_uint16(ndr, "sbz", r->sbz);
+ ndr_print_nbt_server_type(ndr, "server_type", r->server_type);
+ ndr_print_GUID(ndr, "domain_uuid", &r->domain_uuid);
+ ndr_print_nbt_string(ndr, "forest", r->forest);
+ ndr_print_nbt_string(ndr, "dns_domain", r->dns_domain);
+ ndr_print_nbt_string(ndr, "pdc_dns_name", r->pdc_dns_name);
+ ndr_print_nbt_string(ndr, "domain", r->domain);
+ ndr_print_nbt_string(ndr, "pdc_name", r->pdc_name);
+ ndr_print_nbt_string(ndr, "user_name", r->user_name);
+ ndr_print_nbt_string(ndr, "server_site", r->server_site);
+ ndr_print_nbt_string(ndr, "client_site", r->client_site);
+ ndr_print_uint8(ndr, "sockaddr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_nbt_sockaddr(&r->sockaddr, ndr->flags):r->sockaddr_size);
+ ndr_print_nbt_sockaddr(ndr, "sockaddr", &r->sockaddr);
+ ndr_print_nbt_string(ndr, "next_closest_site", r->next_closest_site);
+ ndr_print_netlogon_nt_version_flags(ndr, "nt_version", r->nt_version);
+ ndr_print_uint16(ndr, "lmnt_token", r->lmnt_token);
+ ndr_print_uint16(ndr, "lm20_token", r->lm20_token);
ndr->depth--;
- ndr->flags = _flags_save_BITMAP;
+ ndr->flags = _flags_save_STRUCT;
}
}
NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->unicode_name));
ndr->flags = _flags_save_string;
}
- NDR_CHECK(ndr_push_nbt_netlogon_version(ndr, NDR_SCALARS, r->nt_version));
+ NDR_CHECK(ndr_push_netlogon_nt_version_flags(ndr, NDR_SCALARS, r->nt_version));
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lmnt_token));
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lm20_token));
}
NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->unicode_name));
ndr->flags = _flags_save_string;
}
- NDR_CHECK(ndr_pull_nbt_netlogon_version(ndr, NDR_SCALARS, &r->nt_version));
+ NDR_CHECK(ndr_pull_netlogon_nt_version_flags(ndr, NDR_SCALARS, &r->nt_version));
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lmnt_token));
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lm20_token));
}
ndr_print_string(ndr, "mailslot_name", r->mailslot_name);
ndr_print_DATA_BLOB(ndr, "_pad", r->_pad);
ndr_print_string(ndr, "unicode_name", r->unicode_name);
- ndr_print_nbt_netlogon_version(ndr, "nt_version", r->nt_version);
+ ndr_print_netlogon_nt_version_flags(ndr, "nt_version", r->nt_version);
ndr_print_uint16(ndr, "lmnt_token", r->lmnt_token);
ndr_print_uint16(ndr, "lm20_token", r->lm20_token);
ndr->depth--;
}
-static enum ndr_err_code ndr_push_nbt_netlogon_query_for_pdc2(struct ndr_push *ndr, int ndr_flags, const struct nbt_netlogon_query_for_pdc2 *r)
-{
- uint32_t cntr_unknown_0;
- if (ndr_flags & NDR_SCALARS) {
- NDR_CHECK(ndr_push_align(ndr, 4));
- NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->request_count));
- {
- uint32_t _flags_save_string = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->computer_name));
- ndr->flags = _flags_save_string;
- }
- {
- uint32_t _flags_save_string = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
- ndr->flags = _flags_save_string;
- }
- {
- uint32_t _flags_save_string = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->mailslot_name));
- ndr->flags = _flags_save_string;
- }
- for (cntr_unknown_0 = 0; cntr_unknown_0 < 2; cntr_unknown_0++) {
- NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown[cntr_unknown_0]));
- }
- NDR_CHECK(ndr_push_nbt_netlogon_version(ndr, NDR_SCALARS, r->nt_version));
- NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lmnt_token));
- NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lm20_token));
- }
- if (ndr_flags & NDR_BUFFERS) {
- }
- return NDR_ERR_SUCCESS;
-}
-
-static enum ndr_err_code ndr_pull_nbt_netlogon_query_for_pdc2(struct ndr_pull *ndr, int ndr_flags, struct nbt_netlogon_query_for_pdc2 *r)
-{
- uint32_t cntr_unknown_0;
- if (ndr_flags & NDR_SCALARS) {
- NDR_CHECK(ndr_pull_align(ndr, 4));
- NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->request_count));
- {
- uint32_t _flags_save_string = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->computer_name));
- ndr->flags = _flags_save_string;
- }
- {
- uint32_t _flags_save_string = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
- ndr->flags = _flags_save_string;
- }
- {
- uint32_t _flags_save_string = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->mailslot_name));
- ndr->flags = _flags_save_string;
- }
- for (cntr_unknown_0 = 0; cntr_unknown_0 < 2; cntr_unknown_0++) {
- NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown[cntr_unknown_0]));
- }
- NDR_CHECK(ndr_pull_nbt_netlogon_version(ndr, NDR_SCALARS, &r->nt_version));
- NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lmnt_token));
- NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lm20_token));
- }
- if (ndr_flags & NDR_BUFFERS) {
- }
- return NDR_ERR_SUCCESS;
-}
-
-_PUBLIC_ void ndr_print_nbt_netlogon_query_for_pdc2(struct ndr_print *ndr, const char *name, const struct nbt_netlogon_query_for_pdc2 *r)
-{
- uint32_t cntr_unknown_0;
- ndr_print_struct(ndr, name, "nbt_netlogon_query_for_pdc2");
- ndr->depth++;
- ndr_print_uint16(ndr, "request_count", r->request_count);
- ndr_print_string(ndr, "computer_name", r->computer_name);
- ndr_print_string(ndr, "user_name", r->user_name);
- ndr_print_string(ndr, "mailslot_name", r->mailslot_name);
- ndr->print(ndr, "%s: ARRAY(%d)", "unknown", (int)2);
- ndr->depth++;
- for (cntr_unknown_0=0;cntr_unknown_0<2;cntr_unknown_0++) {
- char *idx_0=NULL;
- if (asprintf(&idx_0, "[%d]", cntr_unknown_0) != -1) {
- ndr_print_uint32(ndr, "unknown", r->unknown[cntr_unknown_0]);
- free(idx_0);
- }
- }
- ndr->depth--;
- ndr_print_nbt_netlogon_version(ndr, "nt_version", r->nt_version);
- ndr_print_uint16(ndr, "lmnt_token", r->lmnt_token);
- ndr_print_uint16(ndr, "lm20_token", r->lm20_token);
- ndr->depth--;
-}
-
-static enum ndr_err_code ndr_push_nbt_netlogon_response_from_pdc(struct ndr_push *ndr, int ndr_flags, const struct nbt_netlogon_response_from_pdc *r)
-{
- if (ndr_flags & NDR_SCALARS) {
- NDR_CHECK(ndr_push_align(ndr, 4));
- {
- uint32_t _flags_save_string = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->pdc_name));
- ndr->flags = _flags_save_string;
- }
- {
- uint32_t _flags_save_DATA_BLOB = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN2);
- NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_pad));
- ndr->flags = _flags_save_DATA_BLOB;
- }
- {
- uint32_t _flags_save_string = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->unicode_pdc_name));
- ndr->flags = _flags_save_string;
- }
- {
- uint32_t _flags_save_string = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->domain_name));
- ndr->flags = _flags_save_string;
- }
- NDR_CHECK(ndr_push_nbt_netlogon_version(ndr, NDR_SCALARS, r->nt_version));
- NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lmnt_token));
- NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lm20_token));
- }
- if (ndr_flags & NDR_BUFFERS) {
- }
- return NDR_ERR_SUCCESS;
-}
-
-static enum ndr_err_code ndr_pull_nbt_netlogon_response_from_pdc(struct ndr_pull *ndr, int ndr_flags, struct nbt_netlogon_response_from_pdc *r)
-{
- if (ndr_flags & NDR_SCALARS) {
- NDR_CHECK(ndr_pull_align(ndr, 4));
- {
- uint32_t _flags_save_string = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->pdc_name));
- ndr->flags = _flags_save_string;
- }
- {
- uint32_t _flags_save_DATA_BLOB = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN2);
- NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_pad));
- ndr->flags = _flags_save_DATA_BLOB;
- }
- {
- uint32_t _flags_save_string = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->unicode_pdc_name));
- ndr->flags = _flags_save_string;
- }
- {
- uint32_t _flags_save_string = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->domain_name));
- ndr->flags = _flags_save_string;
- }
- NDR_CHECK(ndr_pull_nbt_netlogon_version(ndr, NDR_SCALARS, &r->nt_version));
- NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lmnt_token));
- NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lm20_token));
- }
- if (ndr_flags & NDR_BUFFERS) {
- }
- return NDR_ERR_SUCCESS;
-}
-
-_PUBLIC_ void ndr_print_nbt_netlogon_response_from_pdc(struct ndr_print *ndr, const char *name, const struct nbt_netlogon_response_from_pdc *r)
-{
- ndr_print_struct(ndr, name, "nbt_netlogon_response_from_pdc");
- ndr->depth++;
- ndr_print_string(ndr, "pdc_name", r->pdc_name);
- ndr_print_DATA_BLOB(ndr, "_pad", r->_pad);
- ndr_print_string(ndr, "unicode_pdc_name", r->unicode_pdc_name);
- ndr_print_string(ndr, "domain_name", r->domain_name);
- ndr_print_nbt_netlogon_version(ndr, "nt_version", r->nt_version);
- ndr_print_uint16(ndr, "lmnt_token", r->lmnt_token);
- ndr_print_uint16(ndr, "lm20_token", r->lm20_token);
- ndr->depth--;
-}
-
-static enum ndr_err_code ndr_push_nbt_server_type(struct ndr_push *ndr, int ndr_flags, uint32_t r)
-{
- NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
- return NDR_ERR_SUCCESS;
-}
-
-static enum ndr_err_code ndr_pull_nbt_server_type(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
-{
- uint32_t v;
- NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
- *r = v;
- return NDR_ERR_SUCCESS;
-}
-
-_PUBLIC_ void ndr_print_nbt_server_type(struct ndr_print *ndr, const char *name, uint32_t r)
-{
- ndr_print_uint32(ndr, name, r);
- ndr->depth++;
- ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_PDC", NBT_SERVER_PDC, r);
- ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_GC", NBT_SERVER_GC, r);
- ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_LDAP", NBT_SERVER_LDAP, r);
- ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_DS", NBT_SERVER_DS, r);
- ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_KDC", NBT_SERVER_KDC, r);
- ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_TIMESERV", NBT_SERVER_TIMESERV, r);
- ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_CLOSEST", NBT_SERVER_CLOSEST, r);
- ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_WRITABLE", NBT_SERVER_WRITABLE, r);
- ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_GOOD_TIMESERV", NBT_SERVER_GOOD_TIMESERV, r);
- ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_NDNC", NBT_SERVER_NDNC, r);
- ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_SELECT_SECRET_DOMAIN_6", NBT_SERVER_SELECT_SECRET_DOMAIN_6, r);
- ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "NBT_SERVER_FULL_SECRET_DOMAIN_6", NBT_SERVER_FULL_SECRET_DOMAIN_6, r);
- ndr->depth--;
-}
-
-static enum ndr_err_code ndr_push_nbt_dc_sock_addr(struct ndr_push *ndr, int ndr_flags, const struct nbt_dc_sock_addr *r)
-{
- if (ndr_flags & NDR_SCALARS) {
- NDR_CHECK(ndr_push_align(ndr, 4));
- NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->family));
- {
- uint32_t _flags_save_ipv4address = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
- NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->pdc_ip));
- ndr->flags = _flags_save_ipv4address;
- }
- {
- uint32_t _flags_save_DATA_BLOB = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
- NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->remaining));
- ndr->flags = _flags_save_DATA_BLOB;
- }
- }
- if (ndr_flags & NDR_BUFFERS) {
- }
- return NDR_ERR_SUCCESS;
-}
-
-static enum ndr_err_code ndr_pull_nbt_dc_sock_addr(struct ndr_pull *ndr, int ndr_flags, struct nbt_dc_sock_addr *r)
-{
- if (ndr_flags & NDR_SCALARS) {
- NDR_CHECK(ndr_pull_align(ndr, 4));
- NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->family));
- {
- uint32_t _flags_save_ipv4address = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
- NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->pdc_ip));
- ndr->flags = _flags_save_ipv4address;
- }
- {
- uint32_t _flags_save_DATA_BLOB = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
- NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->remaining));
- ndr->flags = _flags_save_DATA_BLOB;
- }
- }
- if (ndr_flags & NDR_BUFFERS) {
- }
- return NDR_ERR_SUCCESS;
-}
-
-_PUBLIC_ void ndr_print_nbt_dc_sock_addr(struct ndr_print *ndr, const char *name, const struct nbt_dc_sock_addr *r)
-{
- ndr_print_struct(ndr, name, "nbt_dc_sock_addr");
- ndr->depth++;
- ndr_print_uint32(ndr, "family", r->family);
- ndr_print_ipv4address(ndr, "pdc_ip", r->pdc_ip);
- ndr_print_DATA_BLOB(ndr, "remaining", r->remaining);
- ndr->depth--;
-}
-
-static enum ndr_err_code ndr_push_nbt_netlogon_response_from_pdc2(struct ndr_push *ndr, int ndr_flags, const struct nbt_netlogon_response_from_pdc2 *r)
-{
- if (ndr_flags & NDR_SCALARS) {
- NDR_CHECK(ndr_push_align(ndr, 4));
- {
- uint32_t _flags_save_DATA_BLOB = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
- NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_pad));
- ndr->flags = _flags_save_DATA_BLOB;
- }
- NDR_CHECK(ndr_push_nbt_server_type(ndr, NDR_SCALARS, r->server_type));
- NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->domain_uuid));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->forest));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->dns_domain));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->pdc_dns_name));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->domain));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->pdc_name));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->user_name));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->server_site));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->client_site));
- NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->dc_sock_addr_size));
- {
- struct ndr_push *_ndr_dc_sock_addr;
- NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_dc_sock_addr, 0, r->dc_sock_addr_size));
- NDR_CHECK(ndr_push_nbt_dc_sock_addr(_ndr_dc_sock_addr, NDR_SCALARS, &r->dc_sock_addr));
- NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_dc_sock_addr, 0, r->dc_sock_addr_size));
- }
- NDR_CHECK(ndr_push_nbt_netlogon_version(ndr, NDR_SCALARS, r->nt_version));
- NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lmnt_token));
- NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lm20_token));
- }
- if (ndr_flags & NDR_BUFFERS) {
- }
- return NDR_ERR_SUCCESS;
-}
-
-static enum ndr_err_code ndr_pull_nbt_netlogon_response_from_pdc2(struct ndr_pull *ndr, int ndr_flags, struct nbt_netlogon_response_from_pdc2 *r)
-{
- if (ndr_flags & NDR_SCALARS) {
- NDR_CHECK(ndr_pull_align(ndr, 4));
- {
- uint32_t _flags_save_DATA_BLOB = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
- NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_pad));
- ndr->flags = _flags_save_DATA_BLOB;
- }
- NDR_CHECK(ndr_pull_nbt_server_type(ndr, NDR_SCALARS, &r->server_type));
- NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->domain_uuid));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->forest));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->dns_domain));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->pdc_dns_name));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->domain));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->pdc_name));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->user_name));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->server_site));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->client_site));
- NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->dc_sock_addr_size));
- {
- struct ndr_pull *_ndr_dc_sock_addr;
- NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_dc_sock_addr, 0, r->dc_sock_addr_size));
- NDR_CHECK(ndr_pull_nbt_dc_sock_addr(_ndr_dc_sock_addr, NDR_SCALARS, &r->dc_sock_addr));
- NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_dc_sock_addr, 0, r->dc_sock_addr_size));
- }
- NDR_CHECK(ndr_pull_nbt_netlogon_version(ndr, NDR_SCALARS, &r->nt_version));
- NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lmnt_token));
- NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lm20_token));
- }
- if (ndr_flags & NDR_BUFFERS) {
- }
- return NDR_ERR_SUCCESS;
-}
-
-_PUBLIC_ void ndr_print_nbt_netlogon_response_from_pdc2(struct ndr_print *ndr, const char *name, const struct nbt_netlogon_response_from_pdc2 *r)
-{
- ndr_print_struct(ndr, name, "nbt_netlogon_response_from_pdc2");
- ndr->depth++;
- ndr_print_DATA_BLOB(ndr, "_pad", r->_pad);
- ndr_print_nbt_server_type(ndr, "server_type", r->server_type);
- ndr_print_GUID(ndr, "domain_uuid", &r->domain_uuid);
- ndr_print_nbt_string(ndr, "forest", r->forest);
- ndr_print_nbt_string(ndr, "dns_domain", r->dns_domain);
- ndr_print_nbt_string(ndr, "pdc_dns_name", r->pdc_dns_name);
- ndr_print_nbt_string(ndr, "domain", r->domain);
- ndr_print_nbt_string(ndr, "pdc_name", r->pdc_name);
- ndr_print_nbt_string(ndr, "user_name", r->user_name);
- ndr_print_nbt_string(ndr, "server_site", r->server_site);
- ndr_print_nbt_string(ndr, "client_site", r->client_site);
- ndr_print_uint8(ndr, "dc_sock_addr_size", r->dc_sock_addr_size);
- ndr_print_nbt_dc_sock_addr(ndr, "dc_sock_addr", &r->dc_sock_addr);
- ndr_print_nbt_netlogon_version(ndr, "nt_version", r->nt_version);
- ndr_print_uint16(ndr, "lmnt_token", r->lmnt_token);
- ndr_print_uint16(ndr, "lm20_token", r->lm20_token);
- ndr->depth--;
-}
-
-static enum ndr_err_code ndr_push_nbt_db_change(struct ndr_push *ndr, int ndr_flags, const struct nbt_db_change *r)
-{
- if (ndr_flags & NDR_SCALARS) {
- NDR_CHECK(ndr_push_align(ndr, 8));
- NDR_CHECK(ndr_push_netr_SamDatabaseID(ndr, NDR_SCALARS, r->db_index));
- NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->serial));
- NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->timestamp));
- }
- if (ndr_flags & NDR_BUFFERS) {
- }
- return NDR_ERR_SUCCESS;
-}
-
-static enum ndr_err_code ndr_pull_nbt_db_change(struct ndr_pull *ndr, int ndr_flags, struct nbt_db_change *r)
-{
- if (ndr_flags & NDR_SCALARS) {
- NDR_CHECK(ndr_pull_align(ndr, 8));
- NDR_CHECK(ndr_pull_netr_SamDatabaseID(ndr, NDR_SCALARS, &r->db_index));
- NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->serial));
- NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->timestamp));
- }
- if (ndr_flags & NDR_BUFFERS) {
- }
- return NDR_ERR_SUCCESS;
-}
-
-_PUBLIC_ void ndr_print_nbt_db_change(struct ndr_print *ndr, const char *name, const struct nbt_db_change *r)
-{
- ndr_print_struct(ndr, name, "nbt_db_change");
- ndr->depth++;
- ndr_print_netr_SamDatabaseID(ndr, "db_index", r->db_index);
- ndr_print_hyper(ndr, "serial", r->serial);
- ndr_print_NTTIME(ndr, "timestamp", r->timestamp);
- ndr->depth--;
-}
-
-static enum ndr_err_code ndr_push_nbt_netlogon_announce_uas(struct ndr_push *ndr, int ndr_flags, const struct nbt_netlogon_announce_uas *r)
-{
- uint32_t cntr_dbchange_0;
- if (ndr_flags & NDR_SCALARS) {
- NDR_CHECK(ndr_push_align(ndr, 8));
- NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->serial_lo));
- NDR_CHECK(ndr_push_time_t(ndr, NDR_SCALARS, r->timestamp));
- NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pulse));
- NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->random));
- {
- uint32_t _flags_save_string = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->pdc_name));
- ndr->flags = _flags_save_string;
- }
- {
- uint32_t _flags_save_string = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->domain));
- ndr->flags = _flags_save_string;
- }
- {
- uint32_t _flags_save_DATA_BLOB = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN2);
- NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_pad));
- ndr->flags = _flags_save_DATA_BLOB;
- }
- {
- uint32_t _flags_save_string = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->unicode_pdc_name));
- ndr->flags = _flags_save_string;
- }
- {
- uint32_t _flags_save_string = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->unicode_domain));
- ndr->flags = _flags_save_string;
- }
- NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->db_count));
- for (cntr_dbchange_0 = 0; cntr_dbchange_0 < r->db_count; cntr_dbchange_0++) {
- NDR_CHECK(ndr_push_nbt_db_change(ndr, NDR_SCALARS, &r->dbchange[cntr_dbchange_0]));
- }
- NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid0(&r->sid, ndr->flags)));
- {
- struct ndr_push *_ndr_sid;
- NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_sid, 0, ndr_size_dom_sid0(&r->sid, ndr->flags)));
- NDR_CHECK(ndr_push_dom_sid0(_ndr_sid, NDR_SCALARS|NDR_BUFFERS, &r->sid));
- NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_sid, 0, ndr_size_dom_sid0(&r->sid, ndr->flags)));
- }
- NDR_CHECK(ndr_push_nbt_netlogon_version(ndr, NDR_SCALARS, r->nt_version));
- NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lmnt_token));
- NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lm20_token));
- }
- if (ndr_flags & NDR_BUFFERS) {
- }
- return NDR_ERR_SUCCESS;
-}
-
-static enum ndr_err_code ndr_pull_nbt_netlogon_announce_uas(struct ndr_pull *ndr, int ndr_flags, struct nbt_netlogon_announce_uas *r)
-{
- uint32_t cntr_dbchange_0;
- TALLOC_CTX *_mem_save_dbchange_0;
- if (ndr_flags & NDR_SCALARS) {
- NDR_CHECK(ndr_pull_align(ndr, 8));
- NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->serial_lo));
- NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, &r->timestamp));
- NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pulse));
- NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->random));
- {
- uint32_t _flags_save_string = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->pdc_name));
- ndr->flags = _flags_save_string;
- }
- {
- uint32_t _flags_save_string = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->domain));
- ndr->flags = _flags_save_string;
- }
- {
- uint32_t _flags_save_DATA_BLOB = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN2);
- NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_pad));
- ndr->flags = _flags_save_DATA_BLOB;
- }
- {
- uint32_t _flags_save_string = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->unicode_pdc_name));
- ndr->flags = _flags_save_string;
- }
- {
- uint32_t _flags_save_string = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->unicode_domain));
- ndr->flags = _flags_save_string;
- }
- NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->db_count));
- NDR_PULL_ALLOC_N(ndr, r->dbchange, r->db_count);
- _mem_save_dbchange_0 = NDR_PULL_GET_MEM_CTX(ndr);
- NDR_PULL_SET_MEM_CTX(ndr, r->dbchange, 0);
- for (cntr_dbchange_0 = 0; cntr_dbchange_0 < r->db_count; cntr_dbchange_0++) {
- NDR_CHECK(ndr_pull_nbt_db_change(ndr, NDR_SCALARS, &r->dbchange[cntr_dbchange_0]));
- }
- NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dbchange_0, 0);
- NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sid_size));
- {
- struct ndr_pull *_ndr_sid;
- NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_sid, 0, r->sid_size));
- NDR_CHECK(ndr_pull_dom_sid0(_ndr_sid, NDR_SCALARS|NDR_BUFFERS, &r->sid));
- NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_sid, 0, r->sid_size));
- }
- NDR_CHECK(ndr_pull_nbt_netlogon_version(ndr, NDR_SCALARS, &r->nt_version));
- NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lmnt_token));
- NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lm20_token));
- }
- if (ndr_flags & NDR_BUFFERS) {
- }
- return NDR_ERR_SUCCESS;
-}
-
-_PUBLIC_ void ndr_print_nbt_netlogon_announce_uas(struct ndr_print *ndr, const char *name, const struct nbt_netlogon_announce_uas *r)
-{
- uint32_t cntr_dbchange_0;
- ndr_print_struct(ndr, name, "nbt_netlogon_announce_uas");
- ndr->depth++;
- ndr_print_uint32(ndr, "serial_lo", r->serial_lo);
- ndr_print_time_t(ndr, "timestamp", r->timestamp);
- ndr_print_uint32(ndr, "pulse", r->pulse);
- ndr_print_uint32(ndr, "random", r->random);
- ndr_print_string(ndr, "pdc_name", r->pdc_name);
- ndr_print_string(ndr, "domain", r->domain);
- ndr_print_DATA_BLOB(ndr, "_pad", r->_pad);
- ndr_print_string(ndr, "unicode_pdc_name", r->unicode_pdc_name);
- ndr_print_string(ndr, "unicode_domain", r->unicode_domain);
- ndr_print_uint32(ndr, "db_count", r->db_count);
- ndr->print(ndr, "%s: ARRAY(%d)", "dbchange", (int)r->db_count);
- ndr->depth++;
- for (cntr_dbchange_0=0;cntr_dbchange_0<r->db_count;cntr_dbchange_0++) {
- char *idx_0=NULL;
- if (asprintf(&idx_0, "[%d]", cntr_dbchange_0) != -1) {
- ndr_print_nbt_db_change(ndr, "dbchange", &r->dbchange[cntr_dbchange_0]);
- free(idx_0);
- }
- }
- ndr->depth--;
- ndr_print_uint32(ndr, "sid_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_dom_sid0(&r->sid, ndr->flags):r->sid_size);
- ndr_print_dom_sid0(ndr, "sid", &r->sid);
- ndr_print_nbt_netlogon_version(ndr, "nt_version", r->nt_version);
- ndr_print_uint16(ndr, "lmnt_token", r->lmnt_token);
- ndr_print_uint16(ndr, "lm20_token", r->lm20_token);
- ndr->depth--;
-}
-
-static enum ndr_err_code ndr_push_nbt_netlogon_request(struct ndr_push *ndr, int ndr_flags, const union nbt_netlogon_request *r)
-{
- if (ndr_flags & NDR_SCALARS) {
- int level = ndr_push_get_switch_value(ndr, r);
- switch (level) {
- case NETLOGON_QUERY_FOR_PDC: {
- NDR_CHECK(ndr_push_nbt_netlogon_query_for_pdc(ndr, NDR_SCALARS, &r->pdc));
- break; }
-
- case NETLOGON_QUERY_FOR_PDC2: {
- NDR_CHECK(ndr_push_nbt_netlogon_query_for_pdc2(ndr, NDR_SCALARS, &r->pdc2));
- break; }
-
- case NETLOGON_ANNOUNCE_UAS: {
- NDR_CHECK(ndr_push_nbt_netlogon_announce_uas(ndr, NDR_SCALARS, &r->uas));
- break; }
-
- case NETLOGON_RESPONSE_FROM_PDC: {
- NDR_CHECK(ndr_push_nbt_netlogon_response_from_pdc(ndr, NDR_SCALARS, &r->response));
- break; }
-
- case NETLOGON_RESPONSE_FROM_PDC2: {
- NDR_CHECK(ndr_push_nbt_netlogon_response_from_pdc2(ndr, NDR_SCALARS, &r->response2));
- break; }
-
- case NETLOGON_RESPONSE_FROM_PDC_USER: {
- NDR_CHECK(ndr_push_nbt_netlogon_response_from_pdc2(ndr, NDR_SCALARS, &r->response2));
- break; }
-
- default:
- return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
- }
- }
- if (ndr_flags & NDR_BUFFERS) {
- int level = ndr_push_get_switch_value(ndr, r);
- switch (level) {
- case NETLOGON_QUERY_FOR_PDC:
- break;
-
- case NETLOGON_QUERY_FOR_PDC2:
- break;
-
- case NETLOGON_ANNOUNCE_UAS:
- NDR_CHECK(ndr_push_nbt_netlogon_announce_uas(ndr, NDR_BUFFERS, &r->uas));
- break;
-
- case NETLOGON_RESPONSE_FROM_PDC:
- break;
-
- case NETLOGON_RESPONSE_FROM_PDC2:
- break;
-
- case NETLOGON_RESPONSE_FROM_PDC_USER:
- break;
-
- default:
- return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
- }
- }
- return NDR_ERR_SUCCESS;
-}
-
-static enum ndr_err_code ndr_pull_nbt_netlogon_request(struct ndr_pull *ndr, int ndr_flags, union nbt_netlogon_request *r)
-{
- int level;
- level = ndr_pull_get_switch_value(ndr, r);
- if (ndr_flags & NDR_SCALARS) {
- switch (level) {
- case NETLOGON_QUERY_FOR_PDC: {
- NDR_CHECK(ndr_pull_nbt_netlogon_query_for_pdc(ndr, NDR_SCALARS, &r->pdc));
- break; }
-
- case NETLOGON_QUERY_FOR_PDC2: {
- NDR_CHECK(ndr_pull_nbt_netlogon_query_for_pdc2(ndr, NDR_SCALARS, &r->pdc2));
- break; }
-
- case NETLOGON_ANNOUNCE_UAS: {
- NDR_CHECK(ndr_pull_nbt_netlogon_announce_uas(ndr, NDR_SCALARS, &r->uas));
- break; }
-
- case NETLOGON_RESPONSE_FROM_PDC: {
- NDR_CHECK(ndr_pull_nbt_netlogon_response_from_pdc(ndr, NDR_SCALARS, &r->response));
- break; }
-
- case NETLOGON_RESPONSE_FROM_PDC2: {
- NDR_CHECK(ndr_pull_nbt_netlogon_response_from_pdc2(ndr, NDR_SCALARS, &r->response2));
- break; }
-
- case NETLOGON_RESPONSE_FROM_PDC_USER: {
- NDR_CHECK(ndr_pull_nbt_netlogon_response_from_pdc2(ndr, NDR_SCALARS, &r->response2));
- break; }
-
- default:
- return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
- }
- }
- if (ndr_flags & NDR_BUFFERS) {
- switch (level) {
- case NETLOGON_QUERY_FOR_PDC:
- break;
-
- case NETLOGON_QUERY_FOR_PDC2:
- break;
-
- case NETLOGON_ANNOUNCE_UAS:
- NDR_CHECK(ndr_pull_nbt_netlogon_announce_uas(ndr, NDR_BUFFERS, &r->uas));
- break;
-
- case NETLOGON_RESPONSE_FROM_PDC:
- break;
-
- case NETLOGON_RESPONSE_FROM_PDC2:
- break;
-
- case NETLOGON_RESPONSE_FROM_PDC_USER:
- break;
-
- default:
- return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
- }
- }
- return NDR_ERR_SUCCESS;
-}
-
-_PUBLIC_ void ndr_print_nbt_netlogon_request(struct ndr_print *ndr, const char *name, const union nbt_netlogon_request *r)
-{
- int level;
- level = ndr_print_get_switch_value(ndr, r);
- ndr_print_union(ndr, name, level, "nbt_netlogon_request");
- switch (level) {
- case NETLOGON_QUERY_FOR_PDC:
- ndr_print_nbt_netlogon_query_for_pdc(ndr, "pdc", &r->pdc);
- break;
-
- case NETLOGON_QUERY_FOR_PDC2:
- ndr_print_nbt_netlogon_query_for_pdc2(ndr, "pdc2", &r->pdc2);
- break;
-
- case NETLOGON_ANNOUNCE_UAS:
- ndr_print_nbt_netlogon_announce_uas(ndr, "uas", &r->uas);
- break;
-
- case NETLOGON_RESPONSE_FROM_PDC:
- ndr_print_nbt_netlogon_response_from_pdc(ndr, "response", &r->response);
- break;
-
- case NETLOGON_RESPONSE_FROM_PDC2:
- ndr_print_nbt_netlogon_response_from_pdc2(ndr, "response2", &r->response2);
- break;
-
- case NETLOGON_RESPONSE_FROM_PDC_USER:
- ndr_print_nbt_netlogon_response_from_pdc2(ndr, "response2", &r->response2);
- break;
-
- default:
- ndr_print_bad_level(ndr, name, level);
- }
-}
-
-_PUBLIC_ enum ndr_err_code ndr_push_nbt_netlogon_packet(struct ndr_push *ndr, int ndr_flags, const struct nbt_netlogon_packet *r)
-{
- {
- uint32_t _flags_save_STRUCT = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
- if (ndr_flags & NDR_SCALARS) {
- NDR_CHECK(ndr_push_align(ndr, 8));
- NDR_CHECK(ndr_push_nbt_netlogon_command(ndr, NDR_SCALARS, r->command));
- NDR_CHECK(ndr_push_set_switch_value(ndr, &r->req, r->command));
- NDR_CHECK(ndr_push_nbt_netlogon_request(ndr, NDR_SCALARS, &r->req));
- }
- if (ndr_flags & NDR_BUFFERS) {
- NDR_CHECK(ndr_push_nbt_netlogon_request(ndr, NDR_BUFFERS, &r->req));
- }
- ndr->flags = _flags_save_STRUCT;
- }
- return NDR_ERR_SUCCESS;
-}
-
-_PUBLIC_ enum ndr_err_code ndr_pull_nbt_netlogon_packet(struct ndr_pull *ndr, int ndr_flags, struct nbt_netlogon_packet *r)
-{
- {
- uint32_t _flags_save_STRUCT = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
- if (ndr_flags & NDR_SCALARS) {
- NDR_CHECK(ndr_pull_align(ndr, 8));
- NDR_CHECK(ndr_pull_nbt_netlogon_command(ndr, NDR_SCALARS, &r->command));
- NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->req, r->command));
- NDR_CHECK(ndr_pull_nbt_netlogon_request(ndr, NDR_SCALARS, &r->req));
- }
- if (ndr_flags & NDR_BUFFERS) {
- NDR_CHECK(ndr_pull_nbt_netlogon_request(ndr, NDR_BUFFERS, &r->req));
- }
- ndr->flags = _flags_save_STRUCT;
- }
- return NDR_ERR_SUCCESS;
-}
-
-_PUBLIC_ void ndr_print_nbt_netlogon_packet(struct ndr_print *ndr, const char *name, const struct nbt_netlogon_packet *r)
-{
- ndr_print_struct(ndr, name, "nbt_netlogon_packet");
- {
- uint32_t _flags_save_STRUCT = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
- ndr->depth++;
- ndr_print_nbt_netlogon_command(ndr, "command", r->command);
- ndr_print_set_switch_value(ndr, &r->req, r->command);
- ndr_print_nbt_netlogon_request(ndr, "req", &r->req);
- ndr->depth--;
- ndr->flags = _flags_save_STRUCT;
- }
-}
-
-static enum ndr_err_code ndr_push_nbt_cldap_netlogon_1(struct ndr_push *ndr, int ndr_flags, const struct nbt_cldap_netlogon_1 *r)
-{
- if (ndr_flags & NDR_SCALARS) {
- NDR_CHECK(ndr_push_align(ndr, 4));
- NDR_CHECK(ndr_push_nbt_netlogon_command(ndr, NDR_SCALARS, r->type));
- {
- uint32_t _flags_save_string = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->pdc_name));
- ndr->flags = _flags_save_string;
- }
- {
- uint32_t _flags_save_string = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
- ndr->flags = _flags_save_string;
- }
- {
- uint32_t _flags_save_string = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->domain_name));
- ndr->flags = _flags_save_string;
- }
- NDR_CHECK(ndr_push_nbt_netlogon_version(ndr, NDR_SCALARS, 1));
- NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lmnt_token));
- NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lm20_token));
- }
- if (ndr_flags & NDR_BUFFERS) {
- }
- return NDR_ERR_SUCCESS;
-}
-
-static enum ndr_err_code ndr_pull_nbt_cldap_netlogon_1(struct ndr_pull *ndr, int ndr_flags, struct nbt_cldap_netlogon_1 *r)
-{
- if (ndr_flags & NDR_SCALARS) {
- NDR_CHECK(ndr_pull_align(ndr, 4));
- NDR_CHECK(ndr_pull_nbt_netlogon_command(ndr, NDR_SCALARS, &r->type));
- {
- uint32_t _flags_save_string = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->pdc_name));
- ndr->flags = _flags_save_string;
- }
- {
- uint32_t _flags_save_string = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
- ndr->flags = _flags_save_string;
- }
- {
- uint32_t _flags_save_string = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->domain_name));
- ndr->flags = _flags_save_string;
- }
- NDR_CHECK(ndr_pull_nbt_netlogon_version(ndr, NDR_SCALARS, &r->nt_version));
- NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lmnt_token));
- NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lm20_token));
- }
- if (ndr_flags & NDR_BUFFERS) {
- }
- return NDR_ERR_SUCCESS;
-}
-
-_PUBLIC_ void ndr_print_nbt_cldap_netlogon_1(struct ndr_print *ndr, const char *name, const struct nbt_cldap_netlogon_1 *r)
-{
- ndr_print_struct(ndr, name, "nbt_cldap_netlogon_1");
- ndr->depth++;
- ndr_print_nbt_netlogon_command(ndr, "type", r->type);
- ndr_print_string(ndr, "pdc_name", r->pdc_name);
- ndr_print_string(ndr, "user_name", r->user_name);
- ndr_print_string(ndr, "domain_name", r->domain_name);
- ndr_print_nbt_netlogon_version(ndr, "nt_version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?1:r->nt_version);
- ndr_print_uint16(ndr, "lmnt_token", r->lmnt_token);
- ndr_print_uint16(ndr, "lm20_token", r->lm20_token);
- ndr->depth--;
-}
-
-static enum ndr_err_code ndr_push_nbt_cldap_netlogon_3(struct ndr_push *ndr, int ndr_flags, const struct nbt_cldap_netlogon_3 *r)
-{
- if (ndr_flags & NDR_SCALARS) {
- NDR_CHECK(ndr_push_align(ndr, 4));
- NDR_CHECK(ndr_push_nbt_netlogon_command(ndr, NDR_SCALARS, r->type));
- {
- uint32_t _flags_save_string = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->pdc_name));
- ndr->flags = _flags_save_string;
- }
- {
- uint32_t _flags_save_string = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
- ndr->flags = _flags_save_string;
- }
- {
- uint32_t _flags_save_string = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->domain_name));
- ndr->flags = _flags_save_string;
- }
- NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->domain_uuid));
- NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->unknown_uuid));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->forest));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->dns_domain));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->pdc_dns_name));
- NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->pdc_ip));
- NDR_CHECK(ndr_push_nbt_server_type(ndr, NDR_SCALARS, r->server_type));
- NDR_CHECK(ndr_push_nbt_netlogon_version(ndr, NDR_SCALARS, 3));
- NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lmnt_token));
- NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lm20_token));
- }
- if (ndr_flags & NDR_BUFFERS) {
- }
- return NDR_ERR_SUCCESS;
-}
-
-static enum ndr_err_code ndr_pull_nbt_cldap_netlogon_3(struct ndr_pull *ndr, int ndr_flags, struct nbt_cldap_netlogon_3 *r)
-{
- if (ndr_flags & NDR_SCALARS) {
- NDR_CHECK(ndr_pull_align(ndr, 4));
- NDR_CHECK(ndr_pull_nbt_netlogon_command(ndr, NDR_SCALARS, &r->type));
- {
- uint32_t _flags_save_string = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->pdc_name));
- ndr->flags = _flags_save_string;
- }
- {
- uint32_t _flags_save_string = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
- ndr->flags = _flags_save_string;
- }
- {
- uint32_t _flags_save_string = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->domain_name));
- ndr->flags = _flags_save_string;
- }
- NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->domain_uuid));
- NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->unknown_uuid));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->forest));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->dns_domain));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->pdc_dns_name));
- NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->pdc_ip));
- NDR_CHECK(ndr_pull_nbt_server_type(ndr, NDR_SCALARS, &r->server_type));
- NDR_CHECK(ndr_pull_nbt_netlogon_version(ndr, NDR_SCALARS, &r->nt_version));
- NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lmnt_token));
- NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lm20_token));
- }
- if (ndr_flags & NDR_BUFFERS) {
- }
- return NDR_ERR_SUCCESS;
-}
-
-_PUBLIC_ void ndr_print_nbt_cldap_netlogon_3(struct ndr_print *ndr, const char *name, const struct nbt_cldap_netlogon_3 *r)
-{
- ndr_print_struct(ndr, name, "nbt_cldap_netlogon_3");
- ndr->depth++;
- ndr_print_nbt_netlogon_command(ndr, "type", r->type);
- ndr_print_string(ndr, "pdc_name", r->pdc_name);
- ndr_print_string(ndr, "user_name", r->user_name);
- ndr_print_string(ndr, "domain_name", r->domain_name);
- ndr_print_GUID(ndr, "domain_uuid", &r->domain_uuid);
- ndr_print_GUID(ndr, "unknown_uuid", &r->unknown_uuid);
- ndr_print_nbt_string(ndr, "forest", r->forest);
- ndr_print_nbt_string(ndr, "dns_domain", r->dns_domain);
- ndr_print_nbt_string(ndr, "pdc_dns_name", r->pdc_dns_name);
- ndr_print_ipv4address(ndr, "pdc_ip", r->pdc_ip);
- ndr_print_nbt_server_type(ndr, "server_type", r->server_type);
- ndr_print_nbt_netlogon_version(ndr, "nt_version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?3:r->nt_version);
- ndr_print_uint16(ndr, "lmnt_token", r->lmnt_token);
- ndr_print_uint16(ndr, "lm20_token", r->lm20_token);
- ndr->depth--;
-}
-
-_PUBLIC_ enum ndr_err_code ndr_push_nbt_cldap_netlogon_5(struct ndr_push *ndr, int ndr_flags, const struct nbt_cldap_netlogon_5 *r)
-{
- if (ndr_flags & NDR_SCALARS) {
- NDR_CHECK(ndr_push_align(ndr, 4));
- NDR_CHECK(ndr_push_nbt_netlogon_command(ndr, NDR_SCALARS, r->type));
- NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->sbz));
- NDR_CHECK(ndr_push_nbt_server_type(ndr, NDR_SCALARS, r->server_type));
- NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->domain_uuid));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->forest));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->dns_domain));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->pdc_dns_name));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->domain));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->pdc_name));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->user_name));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->server_site));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->client_site));
- NDR_CHECK(ndr_push_nbt_netlogon_version(ndr, NDR_SCALARS, 5));
- NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lmnt_token));
- NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lm20_token));
- }
- if (ndr_flags & NDR_BUFFERS) {
- }
- return NDR_ERR_SUCCESS;
-}
-
-_PUBLIC_ enum ndr_err_code ndr_pull_nbt_cldap_netlogon_5(struct ndr_pull *ndr, int ndr_flags, struct nbt_cldap_netlogon_5 *r)
-{
- if (ndr_flags & NDR_SCALARS) {
- NDR_CHECK(ndr_pull_align(ndr, 4));
- NDR_CHECK(ndr_pull_nbt_netlogon_command(ndr, NDR_SCALARS, &r->type));
- NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->sbz));
- NDR_CHECK(ndr_pull_nbt_server_type(ndr, NDR_SCALARS, &r->server_type));
- NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->domain_uuid));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->forest));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->dns_domain));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->pdc_dns_name));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->domain));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->pdc_name));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->user_name));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->server_site));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->client_site));
- NDR_CHECK(ndr_pull_nbt_netlogon_version(ndr, NDR_SCALARS, &r->nt_version));
- NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lmnt_token));
- NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lm20_token));
- }
- if (ndr_flags & NDR_BUFFERS) {
- }
- return NDR_ERR_SUCCESS;
-}
-
-_PUBLIC_ void ndr_print_nbt_cldap_netlogon_5(struct ndr_print *ndr, const char *name, const struct nbt_cldap_netlogon_5 *r)
-{
- ndr_print_struct(ndr, name, "nbt_cldap_netlogon_5");
- ndr->depth++;
- ndr_print_nbt_netlogon_command(ndr, "type", r->type);
- ndr_print_uint16(ndr, "sbz", r->sbz);
- ndr_print_nbt_server_type(ndr, "server_type", r->server_type);
- ndr_print_GUID(ndr, "domain_uuid", &r->domain_uuid);
- ndr_print_nbt_string(ndr, "forest", r->forest);
- ndr_print_nbt_string(ndr, "dns_domain", r->dns_domain);
- ndr_print_nbt_string(ndr, "pdc_dns_name", r->pdc_dns_name);
- ndr_print_nbt_string(ndr, "domain", r->domain);
- ndr_print_nbt_string(ndr, "pdc_name", r->pdc_name);
- ndr_print_nbt_string(ndr, "user_name", r->user_name);
- ndr_print_nbt_string(ndr, "server_site", r->server_site);
- ndr_print_nbt_string(ndr, "client_site", r->client_site);
- ndr_print_nbt_netlogon_version(ndr, "nt_version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?5:r->nt_version);
- ndr_print_uint16(ndr, "lmnt_token", r->lmnt_token);
- ndr_print_uint16(ndr, "lm20_token", r->lm20_token);
- ndr->depth--;
-}
-
-static enum ndr_err_code ndr_push_nbt_cldap_netlogon_13(struct ndr_push *ndr, int ndr_flags, const struct nbt_cldap_netlogon_13 *r)
-{
- if (ndr_flags & NDR_SCALARS) {
- NDR_CHECK(ndr_push_align(ndr, 4));
- NDR_CHECK(ndr_push_nbt_netlogon_command(ndr, NDR_SCALARS, r->type));
- NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->sbz));
- NDR_CHECK(ndr_push_nbt_server_type(ndr, NDR_SCALARS, r->server_type));
- NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->domain_uuid));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->forest));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->dns_domain));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->pdc_dns_name));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->domain));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->pdc_name));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->user_name));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->server_site));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->client_site));
- NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->dc_sock_addr_size));
- {
- struct ndr_push *_ndr_dc_sock_addr;
- NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_dc_sock_addr, 0, r->dc_sock_addr_size));
- NDR_CHECK(ndr_push_nbt_dc_sock_addr(_ndr_dc_sock_addr, NDR_SCALARS, &r->dc_sock_addr));
- NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_dc_sock_addr, 0, r->dc_sock_addr_size));
- }
- NDR_CHECK(ndr_push_nbt_netlogon_version(ndr, NDR_SCALARS, 13));
- NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lmnt_token));
- NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lm20_token));
- }
- if (ndr_flags & NDR_BUFFERS) {
- }
- return NDR_ERR_SUCCESS;
-}
-
-static enum ndr_err_code ndr_pull_nbt_cldap_netlogon_13(struct ndr_pull *ndr, int ndr_flags, struct nbt_cldap_netlogon_13 *r)
-{
- if (ndr_flags & NDR_SCALARS) {
- NDR_CHECK(ndr_pull_align(ndr, 4));
- NDR_CHECK(ndr_pull_nbt_netlogon_command(ndr, NDR_SCALARS, &r->type));
- NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->sbz));
- NDR_CHECK(ndr_pull_nbt_server_type(ndr, NDR_SCALARS, &r->server_type));
- NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->domain_uuid));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->forest));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->dns_domain));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->pdc_dns_name));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->domain));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->pdc_name));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->user_name));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->server_site));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->client_site));
- NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->dc_sock_addr_size));
- {
- struct ndr_pull *_ndr_dc_sock_addr;
- NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_dc_sock_addr, 0, r->dc_sock_addr_size));
- NDR_CHECK(ndr_pull_nbt_dc_sock_addr(_ndr_dc_sock_addr, NDR_SCALARS, &r->dc_sock_addr));
- NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_dc_sock_addr, 0, r->dc_sock_addr_size));
- }
- NDR_CHECK(ndr_pull_nbt_netlogon_version(ndr, NDR_SCALARS, &r->nt_version));
- NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lmnt_token));
- NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lm20_token));
- }
- if (ndr_flags & NDR_BUFFERS) {
- }
- return NDR_ERR_SUCCESS;
-}
-
-_PUBLIC_ void ndr_print_nbt_cldap_netlogon_13(struct ndr_print *ndr, const char *name, const struct nbt_cldap_netlogon_13 *r)
-{
- ndr_print_struct(ndr, name, "nbt_cldap_netlogon_13");
- ndr->depth++;
- ndr_print_nbt_netlogon_command(ndr, "type", r->type);
- ndr_print_uint16(ndr, "sbz", r->sbz);
- ndr_print_nbt_server_type(ndr, "server_type", r->server_type);
- ndr_print_GUID(ndr, "domain_uuid", &r->domain_uuid);
- ndr_print_nbt_string(ndr, "forest", r->forest);
- ndr_print_nbt_string(ndr, "dns_domain", r->dns_domain);
- ndr_print_nbt_string(ndr, "pdc_dns_name", r->pdc_dns_name);
- ndr_print_nbt_string(ndr, "domain", r->domain);
- ndr_print_nbt_string(ndr, "pdc_name", r->pdc_name);
- ndr_print_nbt_string(ndr, "user_name", r->user_name);
- ndr_print_nbt_string(ndr, "server_site", r->server_site);
- ndr_print_nbt_string(ndr, "client_site", r->client_site);
- ndr_print_uint8(ndr, "dc_sock_addr_size", r->dc_sock_addr_size);
- ndr_print_nbt_dc_sock_addr(ndr, "dc_sock_addr", &r->dc_sock_addr);
- ndr_print_nbt_netlogon_version(ndr, "nt_version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?13:r->nt_version);
- ndr_print_uint16(ndr, "lmnt_token", r->lmnt_token);
- ndr_print_uint16(ndr, "lm20_token", r->lm20_token);
- ndr->depth--;
-}
-
-_PUBLIC_ enum ndr_err_code ndr_push_nbt_cldap_netlogon_15(struct ndr_push *ndr, int ndr_flags, const struct nbt_cldap_netlogon_15 *r)
-{
- if (ndr_flags & NDR_SCALARS) {
- NDR_CHECK(ndr_push_align(ndr, 4));
- NDR_CHECK(ndr_push_nbt_netlogon_command(ndr, NDR_SCALARS, r->type));
- NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->sbz));
- NDR_CHECK(ndr_push_nbt_server_type(ndr, NDR_SCALARS, r->server_type));
- NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->domain_uuid));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->forest));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->dns_domain));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->pdc_dns_name));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->domain));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->pdc_name));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->user_name));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->server_site));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->client_site));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->next_closest_site));
- NDR_CHECK(ndr_push_nbt_netlogon_version(ndr, NDR_SCALARS, 15));
- NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lmnt_token));
- NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lm20_token));
- }
- if (ndr_flags & NDR_BUFFERS) {
- }
- return NDR_ERR_SUCCESS;
-}
-
-_PUBLIC_ enum ndr_err_code ndr_pull_nbt_cldap_netlogon_15(struct ndr_pull *ndr, int ndr_flags, struct nbt_cldap_netlogon_15 *r)
-{
- if (ndr_flags & NDR_SCALARS) {
- NDR_CHECK(ndr_pull_align(ndr, 4));
- NDR_CHECK(ndr_pull_nbt_netlogon_command(ndr, NDR_SCALARS, &r->type));
- NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->sbz));
- NDR_CHECK(ndr_pull_nbt_server_type(ndr, NDR_SCALARS, &r->server_type));
- NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->domain_uuid));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->forest));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->dns_domain));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->pdc_dns_name));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->domain));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->pdc_name));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->user_name));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->server_site));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->client_site));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->next_closest_site));
- NDR_CHECK(ndr_pull_nbt_netlogon_version(ndr, NDR_SCALARS, &r->nt_version));
- NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lmnt_token));
- NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lm20_token));
- }
- if (ndr_flags & NDR_BUFFERS) {
- }
- return NDR_ERR_SUCCESS;
-}
-
-_PUBLIC_ void ndr_print_nbt_cldap_netlogon_15(struct ndr_print *ndr, const char *name, const struct nbt_cldap_netlogon_15 *r)
-{
- ndr_print_struct(ndr, name, "nbt_cldap_netlogon_15");
- ndr->depth++;
- ndr_print_nbt_netlogon_command(ndr, "type", r->type);
- ndr_print_uint16(ndr, "sbz", r->sbz);
- ndr_print_nbt_server_type(ndr, "server_type", r->server_type);
- ndr_print_GUID(ndr, "domain_uuid", &r->domain_uuid);
- ndr_print_nbt_string(ndr, "forest", r->forest);
- ndr_print_nbt_string(ndr, "dns_domain", r->dns_domain);
- ndr_print_nbt_string(ndr, "pdc_dns_name", r->pdc_dns_name);
- ndr_print_nbt_string(ndr, "domain", r->domain);
- ndr_print_nbt_string(ndr, "pdc_name", r->pdc_name);
- ndr_print_nbt_string(ndr, "user_name", r->user_name);
- ndr_print_nbt_string(ndr, "server_site", r->server_site);
- ndr_print_nbt_string(ndr, "client_site", r->client_site);
- ndr_print_nbt_string(ndr, "next_closest_site", r->next_closest_site);
- ndr_print_nbt_netlogon_version(ndr, "nt_version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?15:r->nt_version);
- ndr_print_uint16(ndr, "lmnt_token", r->lmnt_token);
- ndr_print_uint16(ndr, "lm20_token", r->lm20_token);
- ndr->depth--;
-}
-
-_PUBLIC_ enum ndr_err_code ndr_push_nbt_cldap_netlogon_29(struct ndr_push *ndr, int ndr_flags, const struct nbt_cldap_netlogon_29 *r)
-{
- if (ndr_flags & NDR_SCALARS) {
- NDR_CHECK(ndr_push_align(ndr, 4));
- NDR_CHECK(ndr_push_nbt_netlogon_command(ndr, NDR_SCALARS, r->type));
- NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->sbz));
- NDR_CHECK(ndr_push_nbt_server_type(ndr, NDR_SCALARS, r->server_type));
- NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->domain_uuid));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->forest));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->dns_domain));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->pdc_dns_name));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->domain));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->pdc_name));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->user_name));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->server_site));
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->client_site));
- NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->dc_sock_addr_size));
- {
- struct ndr_push *_ndr_dc_sock_addr;
- NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_dc_sock_addr, 0, r->dc_sock_addr_size));
- NDR_CHECK(ndr_push_nbt_dc_sock_addr(_ndr_dc_sock_addr, NDR_SCALARS, &r->dc_sock_addr));
- NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_dc_sock_addr, 0, r->dc_sock_addr_size));
- }
- NDR_CHECK(ndr_push_nbt_string(ndr, NDR_SCALARS, r->next_closest_site));
- NDR_CHECK(ndr_push_nbt_netlogon_version(ndr, NDR_SCALARS, 29));
- NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lmnt_token));
- NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lm20_token));
- }
- if (ndr_flags & NDR_BUFFERS) {
- }
- return NDR_ERR_SUCCESS;
-}
-
-_PUBLIC_ enum ndr_err_code ndr_pull_nbt_cldap_netlogon_29(struct ndr_pull *ndr, int ndr_flags, struct nbt_cldap_netlogon_29 *r)
-{
- if (ndr_flags & NDR_SCALARS) {
- NDR_CHECK(ndr_pull_align(ndr, 4));
- NDR_CHECK(ndr_pull_nbt_netlogon_command(ndr, NDR_SCALARS, &r->type));
- NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->sbz));
- NDR_CHECK(ndr_pull_nbt_server_type(ndr, NDR_SCALARS, &r->server_type));
- NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->domain_uuid));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->forest));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->dns_domain));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->pdc_dns_name));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->domain));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->pdc_name));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->user_name));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->server_site));
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->client_site));
- NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->dc_sock_addr_size));
- {
- struct ndr_pull *_ndr_dc_sock_addr;
- NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_dc_sock_addr, 0, r->dc_sock_addr_size));
- NDR_CHECK(ndr_pull_nbt_dc_sock_addr(_ndr_dc_sock_addr, NDR_SCALARS, &r->dc_sock_addr));
- NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_dc_sock_addr, 0, r->dc_sock_addr_size));
- }
- NDR_CHECK(ndr_pull_nbt_string(ndr, NDR_SCALARS, &r->next_closest_site));
- NDR_CHECK(ndr_pull_nbt_netlogon_version(ndr, NDR_SCALARS, &r->nt_version));
- NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lmnt_token));
- NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lm20_token));
- }
- if (ndr_flags & NDR_BUFFERS) {
- }
- return NDR_ERR_SUCCESS;
-}
-
-_PUBLIC_ void ndr_print_nbt_cldap_netlogon_29(struct ndr_print *ndr, const char *name, const struct nbt_cldap_netlogon_29 *r)
-{
- ndr_print_struct(ndr, name, "nbt_cldap_netlogon_29");
- ndr->depth++;
- ndr_print_nbt_netlogon_command(ndr, "type", r->type);
- ndr_print_uint16(ndr, "sbz", r->sbz);
- ndr_print_nbt_server_type(ndr, "server_type", r->server_type);
- ndr_print_GUID(ndr, "domain_uuid", &r->domain_uuid);
- ndr_print_nbt_string(ndr, "forest", r->forest);
- ndr_print_nbt_string(ndr, "dns_domain", r->dns_domain);
- ndr_print_nbt_string(ndr, "pdc_dns_name", r->pdc_dns_name);
- ndr_print_nbt_string(ndr, "domain", r->domain);
- ndr_print_nbt_string(ndr, "pdc_name", r->pdc_name);
- ndr_print_nbt_string(ndr, "user_name", r->user_name);
- ndr_print_nbt_string(ndr, "server_site", r->server_site);
- ndr_print_nbt_string(ndr, "client_site", r->client_site);
- ndr_print_uint8(ndr, "dc_sock_addr_size", r->dc_sock_addr_size);
- ndr_print_nbt_dc_sock_addr(ndr, "dc_sock_addr", &r->dc_sock_addr);
- ndr_print_nbt_string(ndr, "next_closest_site", r->next_closest_site);
- ndr_print_nbt_netlogon_version(ndr, "nt_version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?29:r->nt_version);
- ndr_print_uint16(ndr, "lmnt_token", r->lmnt_token);
- ndr_print_uint16(ndr, "lm20_token", r->lm20_token);
- ndr->depth--;
-}
-
-_PUBLIC_ enum ndr_err_code ndr_push_nbt_cldap_netlogon(struct ndr_push *ndr, int ndr_flags, const union nbt_cldap_netlogon *r)
+_PUBLIC_ enum ndr_err_code ndr_push_nbt_netlogon_response_from_pdc(struct ndr_push *ndr, int ndr_flags, const struct nbt_netlogon_response_from_pdc *r)
{
{
- uint32_t _flags_save_UNION = ndr->flags;
+ uint32_t _flags_save_STRUCT = ndr->flags;
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
if (ndr_flags & NDR_SCALARS) {
- int level = ndr_push_get_switch_value(ndr, r);
- switch (level) {
- case 0: {
- NDR_CHECK(ndr_push_nbt_cldap_netlogon_1(ndr, NDR_SCALARS, &r->logon1));
- break; }
-
- case 1: {
- NDR_CHECK(ndr_push_nbt_cldap_netlogon_1(ndr, NDR_SCALARS, &r->logon1));
- break; }
-
- case 2: {
- NDR_CHECK(ndr_push_nbt_cldap_netlogon_3(ndr, NDR_SCALARS, &r->logon3));
- break; }
-
- case 3: {
- NDR_CHECK(ndr_push_nbt_cldap_netlogon_3(ndr, NDR_SCALARS, &r->logon3));
- break; }
-
- case 4: {
- NDR_CHECK(ndr_push_nbt_cldap_netlogon_5(ndr, NDR_SCALARS, &r->logon5));
- break; }
-
- case 5: {
- NDR_CHECK(ndr_push_nbt_cldap_netlogon_5(ndr, NDR_SCALARS, &r->logon5));
- break; }
-
- case 6: {
- NDR_CHECK(ndr_push_nbt_cldap_netlogon_5(ndr, NDR_SCALARS, &r->logon5));
- break; }
-
- case 7: {
- NDR_CHECK(ndr_push_nbt_cldap_netlogon_5(ndr, NDR_SCALARS, &r->logon5));
- break; }
-
- case 8: {
- NDR_CHECK(ndr_push_nbt_cldap_netlogon_13(ndr, NDR_SCALARS, &r->logon13));
- break; }
-
- case 9: {
- NDR_CHECK(ndr_push_nbt_cldap_netlogon_13(ndr, NDR_SCALARS, &r->logon13));
- break; }
-
- case 10: {
- NDR_CHECK(ndr_push_nbt_cldap_netlogon_13(ndr, NDR_SCALARS, &r->logon13));
- break; }
-
- case 11: {
- NDR_CHECK(ndr_push_nbt_cldap_netlogon_13(ndr, NDR_SCALARS, &r->logon13));
- break; }
-
- case 12: {
- NDR_CHECK(ndr_push_nbt_cldap_netlogon_13(ndr, NDR_SCALARS, &r->logon13));
- break; }
-
- case 13: {
- NDR_CHECK(ndr_push_nbt_cldap_netlogon_13(ndr, NDR_SCALARS, &r->logon13));
- break; }
-
- case 14: {
- NDR_CHECK(ndr_push_nbt_cldap_netlogon_13(ndr, NDR_SCALARS, &r->logon13));
- break; }
-
- case 15: {
- NDR_CHECK(ndr_push_nbt_cldap_netlogon_13(ndr, NDR_SCALARS, &r->logon13));
- break; }
-
- case 16: {
- NDR_CHECK(ndr_push_nbt_cldap_netlogon_1(ndr, NDR_SCALARS, &r->logon1));
- break; }
-
- case 17: {
- NDR_CHECK(ndr_push_nbt_cldap_netlogon_1(ndr, NDR_SCALARS, &r->logon1));
- break; }
-
- case 18: {
- NDR_CHECK(ndr_push_nbt_cldap_netlogon_3(ndr, NDR_SCALARS, &r->logon3));
- break; }
-
- case 19: {
- NDR_CHECK(ndr_push_nbt_cldap_netlogon_3(ndr, NDR_SCALARS, &r->logon3));
- break; }
-
- case 20: {
- NDR_CHECK(ndr_push_nbt_cldap_netlogon_15(ndr, NDR_SCALARS, &r->logon15));
- break; }
-
- case 21: {
- NDR_CHECK(ndr_push_nbt_cldap_netlogon_15(ndr, NDR_SCALARS, &r->logon15));
- break; }
-
- case 22: {
- NDR_CHECK(ndr_push_nbt_cldap_netlogon_15(ndr, NDR_SCALARS, &r->logon15));
- break; }
-
- case 23: {
- NDR_CHECK(ndr_push_nbt_cldap_netlogon_15(ndr, NDR_SCALARS, &r->logon15));
- break; }
-
- case 24: {
- NDR_CHECK(ndr_push_nbt_cldap_netlogon_15(ndr, NDR_SCALARS, &r->logon15));
- break; }
-
- case 25: {
- NDR_CHECK(ndr_push_nbt_cldap_netlogon_15(ndr, NDR_SCALARS, &r->logon15));
- break; }
-
- case 26: {
- NDR_CHECK(ndr_push_nbt_cldap_netlogon_15(ndr, NDR_SCALARS, &r->logon15));
- break; }
-
- case 27: {
- NDR_CHECK(ndr_push_nbt_cldap_netlogon_15(ndr, NDR_SCALARS, &r->logon15));
- break; }
-
- case 28: {
- NDR_CHECK(ndr_push_nbt_cldap_netlogon_15(ndr, NDR_SCALARS, &r->logon15));
- break; }
-
- case 29: {
- NDR_CHECK(ndr_push_nbt_cldap_netlogon_29(ndr, NDR_SCALARS, &r->logon29));
- break; }
-
- case 30: {
- NDR_CHECK(ndr_push_nbt_cldap_netlogon_29(ndr, NDR_SCALARS, &r->logon29));
- break; }
-
- case 31: {
- NDR_CHECK(ndr_push_nbt_cldap_netlogon_29(ndr, NDR_SCALARS, &r->logon29));
- break; }
-
- default:
- return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
- }
- }
- if (ndr_flags & NDR_BUFFERS) {
- int level = ndr_push_get_switch_value(ndr, r);
- switch (level) {
- case 0:
- break;
-
- case 1:
- break;
-
- case 2:
- break;
-
- case 3:
- break;
-
- case 4:
- break;
-
- case 5:
- break;
-
- case 6:
- break;
-
- case 7:
- break;
-
- case 8:
- break;
-
- case 9:
- break;
-
- case 10:
- break;
-
- case 11:
- break;
-
- case 12:
- break;
-
- case 13:
- break;
-
- case 14:
- break;
-
- case 15:
- break;
-
- case 16:
- break;
-
- case 17:
- break;
-
- case 18:
- break;
-
- case 19:
- break;
-
- case 20:
- break;
-
- case 21:
- break;
-
- case 22:
- break;
-
- case 23:
- break;
-
- case 24:
- break;
-
- case 25:
- break;
-
- case 26:
- break;
-
- case 27:
- break;
-
- case 28:
- break;
-
- case 29:
- break;
-
- case 30:
- break;
-
- case 31:
- break;
-
- default:
- return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+ NDR_CHECK(ndr_push_align(ndr, 4));
+ NDR_CHECK(ndr_push_netlogon_command(ndr, NDR_SCALARS, r->command));
+ {
+ uint32_t _flags_save_string = ndr->flags;
+ ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
+ NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->pdc_name));
+ ndr->flags = _flags_save_string;
}
- }
- ndr->flags = _flags_save_UNION;
- }
- return NDR_ERR_SUCCESS;
-}
-
-_PUBLIC_ enum ndr_err_code ndr_pull_nbt_cldap_netlogon(struct ndr_pull *ndr, int ndr_flags, union nbt_cldap_netlogon *r)
-{
- int level;
- {
- uint32_t _flags_save_UNION = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
- level = ndr_pull_get_switch_value(ndr, r);
- if (ndr_flags & NDR_SCALARS) {
- switch (level) {
- case 0: {
- NDR_CHECK(ndr_pull_nbt_cldap_netlogon_1(ndr, NDR_SCALARS, &r->logon1));
- break; }
-
- case 1: {
- NDR_CHECK(ndr_pull_nbt_cldap_netlogon_1(ndr, NDR_SCALARS, &r->logon1));
- break; }
-
- case 2: {
- NDR_CHECK(ndr_pull_nbt_cldap_netlogon_3(ndr, NDR_SCALARS, &r->logon3));
- break; }
-
- case 3: {
- NDR_CHECK(ndr_pull_nbt_cldap_netlogon_3(ndr, NDR_SCALARS, &r->logon3));
- break; }
-
- case 4: {
- NDR_CHECK(ndr_pull_nbt_cldap_netlogon_5(ndr, NDR_SCALARS, &r->logon5));
- break; }
-
- case 5: {
- NDR_CHECK(ndr_pull_nbt_cldap_netlogon_5(ndr, NDR_SCALARS, &r->logon5));
- break; }
-
- case 6: {
- NDR_CHECK(ndr_pull_nbt_cldap_netlogon_5(ndr, NDR_SCALARS, &r->logon5));
- break; }
-
- case 7: {
- NDR_CHECK(ndr_pull_nbt_cldap_netlogon_5(ndr, NDR_SCALARS, &r->logon5));
- break; }
-
- case 8: {
- NDR_CHECK(ndr_pull_nbt_cldap_netlogon_13(ndr, NDR_SCALARS, &r->logon13));
- break; }
-
- case 9: {
- NDR_CHECK(ndr_pull_nbt_cldap_netlogon_13(ndr, NDR_SCALARS, &r->logon13));
- break; }
-
- case 10: {
- NDR_CHECK(ndr_pull_nbt_cldap_netlogon_13(ndr, NDR_SCALARS, &r->logon13));
- break; }
-
- case 11: {
- NDR_CHECK(ndr_pull_nbt_cldap_netlogon_13(ndr, NDR_SCALARS, &r->logon13));
- break; }
-
- case 12: {
- NDR_CHECK(ndr_pull_nbt_cldap_netlogon_13(ndr, NDR_SCALARS, &r->logon13));
- break; }
-
- case 13: {
- NDR_CHECK(ndr_pull_nbt_cldap_netlogon_13(ndr, NDR_SCALARS, &r->logon13));
- break; }
-
- case 14: {
- NDR_CHECK(ndr_pull_nbt_cldap_netlogon_13(ndr, NDR_SCALARS, &r->logon13));
- break; }
-
- case 15: {
- NDR_CHECK(ndr_pull_nbt_cldap_netlogon_13(ndr, NDR_SCALARS, &r->logon13));
- break; }
-
- case 16: {
- NDR_CHECK(ndr_pull_nbt_cldap_netlogon_1(ndr, NDR_SCALARS, &r->logon1));
- break; }
-
- case 17: {
- NDR_CHECK(ndr_pull_nbt_cldap_netlogon_1(ndr, NDR_SCALARS, &r->logon1));
- break; }
-
- case 18: {
- NDR_CHECK(ndr_pull_nbt_cldap_netlogon_3(ndr, NDR_SCALARS, &r->logon3));
- break; }
-
- case 19: {
- NDR_CHECK(ndr_pull_nbt_cldap_netlogon_3(ndr, NDR_SCALARS, &r->logon3));
- break; }
-
- case 20: {
- NDR_CHECK(ndr_pull_nbt_cldap_netlogon_15(ndr, NDR_SCALARS, &r->logon15));
- break; }
-
- case 21: {
- NDR_CHECK(ndr_pull_nbt_cldap_netlogon_15(ndr, NDR_SCALARS, &r->logon15));
- break; }
-
- case 22: {
- NDR_CHECK(ndr_pull_nbt_cldap_netlogon_15(ndr, NDR_SCALARS, &r->logon15));
- break; }
-
- case 23: {
- NDR_CHECK(ndr_pull_nbt_cldap_netlogon_15(ndr, NDR_SCALARS, &r->logon15));
- break; }
-
- case 24: {
- NDR_CHECK(ndr_pull_nbt_cldap_netlogon_15(ndr, NDR_SCALARS, &r->logon15));
- break; }
-
- case 25: {
- NDR_CHECK(ndr_pull_nbt_cldap_netlogon_15(ndr, NDR_SCALARS, &r->logon15));
- break; }
-
- case 26: {
- NDR_CHECK(ndr_pull_nbt_cldap_netlogon_15(ndr, NDR_SCALARS, &r->logon15));
- break; }
-
- case 27: {
- NDR_CHECK(ndr_pull_nbt_cldap_netlogon_15(ndr, NDR_SCALARS, &r->logon15));
- break; }
-
- case 28: {
- NDR_CHECK(ndr_pull_nbt_cldap_netlogon_15(ndr, NDR_SCALARS, &r->logon15));
- break; }
-
- case 29: {
- NDR_CHECK(ndr_pull_nbt_cldap_netlogon_29(ndr, NDR_SCALARS, &r->logon29));
- break; }
-
- case 30: {
- NDR_CHECK(ndr_pull_nbt_cldap_netlogon_29(ndr, NDR_SCALARS, &r->logon29));
- break; }
-
- case 31: {
- NDR_CHECK(ndr_pull_nbt_cldap_netlogon_29(ndr, NDR_SCALARS, &r->logon29));
- break; }
-
- default:
- return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+ {
+ uint32_t _flags_save_DATA_BLOB = ndr->flags;
+ ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN2);
+ NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_pad));
+ ndr->flags = _flags_save_DATA_BLOB;
}
- }
- if (ndr_flags & NDR_BUFFERS) {
- switch (level) {
- case 0:
- break;
-
- case 1:
- break;
-
- case 2:
- break;
-
- case 3:
- break;
-
- case 4:
- break;
-
- case 5:
- break;
-
- case 6:
- break;
-
- case 7:
- break;
-
- case 8:
- break;
-
- case 9:
- break;
-
- case 10:
- break;
-
- case 11:
- break;
-
- case 12:
- break;
-
- case 13:
- break;
-
- case 14:
- break;
-
- case 15:
- break;
-
- case 16:
- break;
-
- case 17:
- break;
-
- case 18:
- break;
-
- case 19:
- break;
-
- case 20:
- break;
-
- case 21:
- break;
-
- case 22:
- break;
-
- case 23:
- break;
-
- case 24:
- break;
-
- case 25:
- break;
-
- case 26:
- break;
-
- case 27:
- break;
-
- case 28:
- break;
-
- case 29:
- break;
-
- case 30:
- break;
-
- case 31:
- break;
-
- default:
- return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
+ {
+ uint32_t _flags_save_string = ndr->flags;
+ ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
+ NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->unicode_pdc_name));
+ ndr->flags = _flags_save_string;
}
+ {
+ uint32_t _flags_save_string = ndr->flags;
+ ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
+ NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->domain_name));
+ ndr->flags = _flags_save_string;
+ }
+ NDR_CHECK(ndr_push_netlogon_nt_version_flags(ndr, NDR_SCALARS, r->nt_version));
+ NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lmnt_token));
+ NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lm20_token));
+ }
+ if (ndr_flags & NDR_BUFFERS) {
}
- ndr->flags = _flags_save_UNION;
- }
- return NDR_ERR_SUCCESS;
-}
-
-_PUBLIC_ void ndr_print_nbt_cldap_netlogon(struct ndr_print *ndr, const char *name, const union nbt_cldap_netlogon *r)
-{
- int level;
- {
- uint32_t _flags_save_UNION = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
- level = ndr_print_get_switch_value(ndr, r);
- ndr_print_union(ndr, name, level, "nbt_cldap_netlogon");
- switch (level) {
- case 0:
- ndr_print_nbt_cldap_netlogon_1(ndr, "logon1", &r->logon1);
- break;
-
- case 1:
- ndr_print_nbt_cldap_netlogon_1(ndr, "logon1", &r->logon1);
- break;
-
- case 2:
- ndr_print_nbt_cldap_netlogon_3(ndr, "logon3", &r->logon3);
- break;
-
- case 3:
- ndr_print_nbt_cldap_netlogon_3(ndr, "logon3", &r->logon3);
- break;
-
- case 4:
- ndr_print_nbt_cldap_netlogon_5(ndr, "logon5", &r->logon5);
- break;
-
- case 5:
- ndr_print_nbt_cldap_netlogon_5(ndr, "logon5", &r->logon5);
- break;
-
- case 6:
- ndr_print_nbt_cldap_netlogon_5(ndr, "logon5", &r->logon5);
- break;
-
- case 7:
- ndr_print_nbt_cldap_netlogon_5(ndr, "logon5", &r->logon5);
- break;
-
- case 8:
- ndr_print_nbt_cldap_netlogon_13(ndr, "logon13", &r->logon13);
- break;
-
- case 9:
- ndr_print_nbt_cldap_netlogon_13(ndr, "logon13", &r->logon13);
- break;
-
- case 10:
- ndr_print_nbt_cldap_netlogon_13(ndr, "logon13", &r->logon13);
- break;
-
- case 11:
- ndr_print_nbt_cldap_netlogon_13(ndr, "logon13", &r->logon13);
- break;
-
- case 12:
- ndr_print_nbt_cldap_netlogon_13(ndr, "logon13", &r->logon13);
- break;
-
- case 13:
- ndr_print_nbt_cldap_netlogon_13(ndr, "logon13", &r->logon13);
- break;
-
- case 14:
- ndr_print_nbt_cldap_netlogon_13(ndr, "logon13", &r->logon13);
- break;
-
- case 15:
- ndr_print_nbt_cldap_netlogon_13(ndr, "logon13", &r->logon13);
- break;
-
- case 16:
- ndr_print_nbt_cldap_netlogon_1(ndr, "logon1", &r->logon1);
- break;
-
- case 17:
- ndr_print_nbt_cldap_netlogon_1(ndr, "logon1", &r->logon1);
- break;
-
- case 18:
- ndr_print_nbt_cldap_netlogon_3(ndr, "logon3", &r->logon3);
- break;
-
- case 19:
- ndr_print_nbt_cldap_netlogon_3(ndr, "logon3", &r->logon3);
- break;
-
- case 20:
- ndr_print_nbt_cldap_netlogon_15(ndr, "logon15", &r->logon15);
- break;
-
- case 21:
- ndr_print_nbt_cldap_netlogon_15(ndr, "logon15", &r->logon15);
- break;
-
- case 22:
- ndr_print_nbt_cldap_netlogon_15(ndr, "logon15", &r->logon15);
- break;
-
- case 23:
- ndr_print_nbt_cldap_netlogon_15(ndr, "logon15", &r->logon15);
- break;
-
- case 24:
- ndr_print_nbt_cldap_netlogon_15(ndr, "logon15", &r->logon15);
- break;
-
- case 25:
- ndr_print_nbt_cldap_netlogon_15(ndr, "logon15", &r->logon15);
- break;
-
- case 26:
- ndr_print_nbt_cldap_netlogon_15(ndr, "logon15", &r->logon15);
- break;
-
- case 27:
- ndr_print_nbt_cldap_netlogon_15(ndr, "logon15", &r->logon15);
- break;
-
- case 28:
- ndr_print_nbt_cldap_netlogon_15(ndr, "logon15", &r->logon15);
- break;
-
- case 29:
- ndr_print_nbt_cldap_netlogon_29(ndr, "logon29", &r->logon29);
- break;
-
- case 30:
- ndr_print_nbt_cldap_netlogon_29(ndr, "logon29", &r->logon29);
- break;
-
- case 31:
- ndr_print_nbt_cldap_netlogon_29(ndr, "logon29", &r->logon29);
- break;
-
- default:
- ndr_print_bad_level(ndr, name, level);
- }
- ndr->flags = _flags_save_UNION;
+ ndr->flags = _flags_save_STRUCT;
}
-}
-
-static enum ndr_err_code ndr_push_nbt_ntlogon_command(struct ndr_push *ndr, int ndr_flags, enum nbt_ntlogon_command r)
-{
- NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
return NDR_ERR_SUCCESS;
}
-static enum ndr_err_code ndr_pull_nbt_ntlogon_command(struct ndr_pull *ndr, int ndr_flags, enum nbt_ntlogon_command *r)
+_PUBLIC_ enum ndr_err_code ndr_pull_nbt_netlogon_response_from_pdc(struct ndr_pull *ndr, int ndr_flags, struct nbt_netlogon_response_from_pdc *r)
{
- uint16_t v;
- NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
- *r = v;
+ {
+ uint32_t _flags_save_STRUCT = ndr->flags;
+ ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
+ if (ndr_flags & NDR_SCALARS) {
+ NDR_CHECK(ndr_pull_align(ndr, 4));
+ NDR_CHECK(ndr_pull_netlogon_command(ndr, NDR_SCALARS, &r->command));
+ {
+ uint32_t _flags_save_string = ndr->flags;
+ ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
+ NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->pdc_name));
+ ndr->flags = _flags_save_string;
+ }
+ {
+ uint32_t _flags_save_DATA_BLOB = ndr->flags;
+ ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN2);
+ NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_pad));
+ ndr->flags = _flags_save_DATA_BLOB;
+ }
+ {
+ uint32_t _flags_save_string = ndr->flags;
+ ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
+ NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->unicode_pdc_name));
+ ndr->flags = _flags_save_string;
+ }
+ {
+ uint32_t _flags_save_string = ndr->flags;
+ ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
+ NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->domain_name));
+ ndr->flags = _flags_save_string;
+ }
+ NDR_CHECK(ndr_pull_netlogon_nt_version_flags(ndr, NDR_SCALARS, &r->nt_version));
+ NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lmnt_token));
+ NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lm20_token));
+ }
+ if (ndr_flags & NDR_BUFFERS) {
+ }
+ ndr->flags = _flags_save_STRUCT;
+ }
return NDR_ERR_SUCCESS;
}
-_PUBLIC_ void ndr_print_nbt_ntlogon_command(struct ndr_print *ndr, const char *name, enum nbt_ntlogon_command r)
+_PUBLIC_ void ndr_print_nbt_netlogon_response_from_pdc(struct ndr_print *ndr, const char *name, const struct nbt_netlogon_response_from_pdc *r)
{
- const char *val = NULL;
-
- switch (r) {
- case NTLOGON_SAM_LOGON: val = "NTLOGON_SAM_LOGON"; break;
- case NTLOGON_SAM_LOGON_REPLY: val = "NTLOGON_SAM_LOGON_REPLY"; break;
- case NTLOGON_SAM_LOGON_REPLY15: val = "NTLOGON_SAM_LOGON_REPLY15"; break;
- case NTLOGON_RESPONSE_FROM_PDC2: val = "NTLOGON_RESPONSE_FROM_PDC2"; break;
+ ndr_print_struct(ndr, name, "nbt_netlogon_response_from_pdc");
+ {
+ uint32_t _flags_save_STRUCT = ndr->flags;
+ ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
+ ndr->depth++;
+ ndr_print_netlogon_command(ndr, "command", r->command);
+ ndr_print_string(ndr, "pdc_name", r->pdc_name);
+ ndr_print_DATA_BLOB(ndr, "_pad", r->_pad);
+ ndr_print_string(ndr, "unicode_pdc_name", r->unicode_pdc_name);
+ ndr_print_string(ndr, "domain_name", r->domain_name);
+ ndr_print_netlogon_nt_version_flags(ndr, "nt_version", r->nt_version);
+ ndr_print_uint16(ndr, "lmnt_token", r->lmnt_token);
+ ndr_print_uint16(ndr, "lm20_token", r->lm20_token);
+ ndr->depth--;
+ ndr->flags = _flags_save_STRUCT;
}
- ndr_print_enum(ndr, name, "ENUM", val, r);
}
-static enum ndr_err_code ndr_push_nbt_ntlogon_sam_logon(struct ndr_push *ndr, int ndr_flags, const struct nbt_ntlogon_sam_logon *r)
+static enum ndr_err_code ndr_push_nbt_db_change_info(struct ndr_push *ndr, int ndr_flags, const struct nbt_db_change_info *r)
{
if (ndr_flags & NDR_SCALARS) {
- NDR_CHECK(ndr_push_align(ndr, 4));
- NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->request_count));
- {
- uint32_t _flags_save_string = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->computer_name));
- ndr->flags = _flags_save_string;
- }
- {
- uint32_t _flags_save_string = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
- ndr->flags = _flags_save_string;
- }
- {
- uint32_t _flags_save_string = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->mailslot_name));
- ndr->flags = _flags_save_string;
- }
- NDR_CHECK(ndr_push_samr_AcctFlags(ndr, NDR_SCALARS, r->acct_control));
- NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid0(&r->sid, ndr->flags)));
- {
- struct ndr_push *_ndr_sid;
- NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_sid, 0, ndr_size_dom_sid0(&r->sid, ndr->flags)));
- NDR_CHECK(ndr_push_dom_sid0(_ndr_sid, NDR_SCALARS|NDR_BUFFERS, &r->sid));
- NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_sid, 0, ndr_size_dom_sid0(&r->sid, ndr->flags)));
- }
- NDR_CHECK(ndr_push_nbt_netlogon_version(ndr, NDR_SCALARS, r->nt_version));
- NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lmnt_token));
- NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lm20_token));
+ NDR_CHECK(ndr_push_align(ndr, 8));
+ NDR_CHECK(ndr_push_netr_SamDatabaseID(ndr, NDR_SCALARS, r->db_index));
+ NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->serial));
+ NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->timestamp));
}
if (ndr_flags & NDR_BUFFERS) {
}
return NDR_ERR_SUCCESS;
}
-static enum ndr_err_code ndr_pull_nbt_ntlogon_sam_logon(struct ndr_pull *ndr, int ndr_flags, struct nbt_ntlogon_sam_logon *r)
+static enum ndr_err_code ndr_pull_nbt_db_change_info(struct ndr_pull *ndr, int ndr_flags, struct nbt_db_change_info *r)
{
if (ndr_flags & NDR_SCALARS) {
- NDR_CHECK(ndr_pull_align(ndr, 4));
- NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->request_count));
- {
- uint32_t _flags_save_string = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->computer_name));
- ndr->flags = _flags_save_string;
- }
- {
- uint32_t _flags_save_string = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
- ndr->flags = _flags_save_string;
- }
- {
- uint32_t _flags_save_string = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->mailslot_name));
- ndr->flags = _flags_save_string;
- }
- NDR_CHECK(ndr_pull_samr_AcctFlags(ndr, NDR_SCALARS, &r->acct_control));
- NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sid_size));
- {
- struct ndr_pull *_ndr_sid;
- NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_sid, 0, r->sid_size));
- NDR_CHECK(ndr_pull_dom_sid0(_ndr_sid, NDR_SCALARS|NDR_BUFFERS, &r->sid));
- NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_sid, 0, r->sid_size));
- }
- NDR_CHECK(ndr_pull_nbt_netlogon_version(ndr, NDR_SCALARS, &r->nt_version));
- NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lmnt_token));
- NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lm20_token));
+ NDR_CHECK(ndr_pull_align(ndr, 8));
+ NDR_CHECK(ndr_pull_netr_SamDatabaseID(ndr, NDR_SCALARS, &r->db_index));
+ NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->serial));
+ NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->timestamp));
}
if (ndr_flags & NDR_BUFFERS) {
}
return NDR_ERR_SUCCESS;
}
-_PUBLIC_ void ndr_print_nbt_ntlogon_sam_logon(struct ndr_print *ndr, const char *name, const struct nbt_ntlogon_sam_logon *r)
+_PUBLIC_ void ndr_print_nbt_db_change_info(struct ndr_print *ndr, const char *name, const struct nbt_db_change_info *r)
{
- ndr_print_struct(ndr, name, "nbt_ntlogon_sam_logon");
+ ndr_print_struct(ndr, name, "nbt_db_change_info");
ndr->depth++;
- ndr_print_uint16(ndr, "request_count", r->request_count);
- ndr_print_string(ndr, "computer_name", r->computer_name);
- ndr_print_string(ndr, "user_name", r->user_name);
- ndr_print_string(ndr, "mailslot_name", r->mailslot_name);
- ndr_print_samr_AcctFlags(ndr, "acct_control", r->acct_control);
- ndr_print_uint32(ndr, "sid_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_dom_sid0(&r->sid, ndr->flags):r->sid_size);
- ndr_print_dom_sid0(ndr, "sid", &r->sid);
- ndr_print_nbt_netlogon_version(ndr, "nt_version", r->nt_version);
- ndr_print_uint16(ndr, "lmnt_token", r->lmnt_token);
- ndr_print_uint16(ndr, "lm20_token", r->lm20_token);
+ ndr_print_netr_SamDatabaseID(ndr, "db_index", r->db_index);
+ ndr_print_hyper(ndr, "serial", r->serial);
+ ndr_print_NTTIME(ndr, "timestamp", r->timestamp);
ndr->depth--;
}
-static enum ndr_err_code ndr_push_nbt_ntlogon_sam_logon_reply(struct ndr_push *ndr, int ndr_flags, const struct nbt_ntlogon_sam_logon_reply *r)
+static enum ndr_err_code ndr_push_NETLOGON_DB_CHANGE(struct ndr_push *ndr, int ndr_flags, const struct NETLOGON_DB_CHANGE *r)
{
+ uint32_t cntr_dbchange_0;
if (ndr_flags & NDR_SCALARS) {
- NDR_CHECK(ndr_push_align(ndr, 4));
+ NDR_CHECK(ndr_push_align(ndr, 8));
+ NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->serial_lo));
+ NDR_CHECK(ndr_push_time_t(ndr, NDR_SCALARS, r->timestamp));
+ NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pulse));
+ NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->random));
{
uint32_t _flags_save_string = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server));
+ ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
+ NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->pdc_name));
ndr->flags = _flags_save_string;
}
+ {
+ uint32_t _flags_save_string = ndr->flags;
+ ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
+ NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->domain));
+ ndr->flags = _flags_save_string;
+ }
+ {
+ uint32_t _flags_save_DATA_BLOB = ndr->flags;
+ ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN2);
+ NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_pad));
+ ndr->flags = _flags_save_DATA_BLOB;
+ }
{
uint32_t _flags_save_string = ndr->flags;
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
+ NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->unicode_pdc_name));
ndr->flags = _flags_save_string;
}
{
uint32_t _flags_save_string = ndr->flags;
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->domain));
+ NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->unicode_domain));
ndr->flags = _flags_save_string;
}
- NDR_CHECK(ndr_push_nbt_netlogon_version(ndr, NDR_SCALARS, r->nt_version));
- NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lmnt_token));
- NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lm20_token));
+ NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->db_count));
+ for (cntr_dbchange_0 = 0; cntr_dbchange_0 < r->db_count; cntr_dbchange_0++) {
+ NDR_CHECK(ndr_push_nbt_db_change_info(ndr, NDR_SCALARS, &r->dbchange[cntr_dbchange_0]));
+ }
+ NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid0(&r->sid, ndr->flags)));
+ {
+ struct ndr_push *_ndr_sid;
+ NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_sid, 0, ndr_size_dom_sid0(&r->sid, ndr->flags)));
+ NDR_CHECK(ndr_push_dom_sid0(_ndr_sid, NDR_SCALARS|NDR_BUFFERS, &r->sid));
+ NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_sid, 0, ndr_size_dom_sid0(&r->sid, ndr->flags)));
+ }
+ NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->message_format_version));
+ NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->message_token));
}
if (ndr_flags & NDR_BUFFERS) {
}
return NDR_ERR_SUCCESS;
}
-static enum ndr_err_code ndr_pull_nbt_ntlogon_sam_logon_reply(struct ndr_pull *ndr, int ndr_flags, struct nbt_ntlogon_sam_logon_reply *r)
+static enum ndr_err_code ndr_pull_NETLOGON_DB_CHANGE(struct ndr_pull *ndr, int ndr_flags, struct NETLOGON_DB_CHANGE *r)
{
+ uint32_t cntr_dbchange_0;
+ TALLOC_CTX *_mem_save_dbchange_0;
if (ndr_flags & NDR_SCALARS) {
- NDR_CHECK(ndr_pull_align(ndr, 4));
+ NDR_CHECK(ndr_pull_align(ndr, 8));
+ NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->serial_lo));
+ NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, &r->timestamp));
+ NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pulse));
+ NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->random));
{
uint32_t _flags_save_string = ndr->flags;
- ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server));
+ ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
+ NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->pdc_name));
+ ndr->flags = _flags_save_string;
+ }
+ {
+ uint32_t _flags_save_string = ndr->flags;
+ ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
+ NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->domain));
ndr->flags = _flags_save_string;
}
+ {
+ uint32_t _flags_save_DATA_BLOB = ndr->flags;
+ ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN2);
+ NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_pad));
+ ndr->flags = _flags_save_DATA_BLOB;
+ }
{
uint32_t _flags_save_string = ndr->flags;
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
+ NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->unicode_pdc_name));
ndr->flags = _flags_save_string;
}
{
uint32_t _flags_save_string = ndr->flags;
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
- NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->domain));
+ NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->unicode_domain));
ndr->flags = _flags_save_string;
}
- NDR_CHECK(ndr_pull_nbt_netlogon_version(ndr, NDR_SCALARS, &r->nt_version));
- NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lmnt_token));
- NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lm20_token));
+ NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->db_count));
+ NDR_PULL_ALLOC_N(ndr, r->dbchange, r->db_count);
+ _mem_save_dbchange_0 = NDR_PULL_GET_MEM_CTX(ndr);
+ NDR_PULL_SET_MEM_CTX(ndr, r->dbchange, 0);
+ for (cntr_dbchange_0 = 0; cntr_dbchange_0 < r->db_count; cntr_dbchange_0++) {
+ NDR_CHECK(ndr_pull_nbt_db_change_info(ndr, NDR_SCALARS, &r->dbchange[cntr_dbchange_0]));
+ }
+ NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dbchange_0, 0);
+ NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sid_size));
+ {
+ struct ndr_pull *_ndr_sid;
+ NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_sid, 0, r->sid_size));
+ NDR_CHECK(ndr_pull_dom_sid0(_ndr_sid, NDR_SCALARS|NDR_BUFFERS, &r->sid));
+ NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_sid, 0, r->sid_size));
+ }
+ NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->message_format_version));
+ NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->message_token));
}
if (ndr_flags & NDR_BUFFERS) {
}
return NDR_ERR_SUCCESS;
}
-_PUBLIC_ void ndr_print_nbt_ntlogon_sam_logon_reply(struct ndr_print *ndr, const char *name, const struct nbt_ntlogon_sam_logon_reply *r)
+_PUBLIC_ void ndr_print_NETLOGON_DB_CHANGE(struct ndr_print *ndr, const char *name, const struct NETLOGON_DB_CHANGE *r)
{
- ndr_print_struct(ndr, name, "nbt_ntlogon_sam_logon_reply");
+ uint32_t cntr_dbchange_0;
+ ndr_print_struct(ndr, name, "NETLOGON_DB_CHANGE");
ndr->depth++;
- ndr_print_string(ndr, "server", r->server);
- ndr_print_string(ndr, "user_name", r->user_name);
+ ndr_print_uint32(ndr, "serial_lo", r->serial_lo);
+ ndr_print_time_t(ndr, "timestamp", r->timestamp);
+ ndr_print_uint32(ndr, "pulse", r->pulse);
+ ndr_print_uint32(ndr, "random", r->random);
+ ndr_print_string(ndr, "pdc_name", r->pdc_name);
ndr_print_string(ndr, "domain", r->domain);
- ndr_print_nbt_netlogon_version(ndr, "nt_version", r->nt_version);
- ndr_print_uint16(ndr, "lmnt_token", r->lmnt_token);
- ndr_print_uint16(ndr, "lm20_token", r->lm20_token);
+ ndr_print_DATA_BLOB(ndr, "_pad", r->_pad);
+ ndr_print_string(ndr, "unicode_pdc_name", r->unicode_pdc_name);
+ ndr_print_string(ndr, "unicode_domain", r->unicode_domain);
+ ndr_print_uint32(ndr, "db_count", r->db_count);
+ ndr->print(ndr, "%s: ARRAY(%d)", "dbchange", (int)r->db_count);
+ ndr->depth++;
+ for (cntr_dbchange_0=0;cntr_dbchange_0<r->db_count;cntr_dbchange_0++) {
+ char *idx_0=NULL;
+ if (asprintf(&idx_0, "[%d]", cntr_dbchange_0) != -1) {
+ ndr_print_nbt_db_change_info(ndr, "dbchange", &r->dbchange[cntr_dbchange_0]);
+ free(idx_0);
+ }
+ }
+ ndr->depth--;
+ ndr_print_uint32(ndr, "sid_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_dom_sid0(&r->sid, ndr->flags):r->sid_size);
+ ndr_print_dom_sid0(ndr, "sid", &r->sid);
+ ndr_print_uint32(ndr, "message_format_version", r->message_format_version);
+ ndr_print_uint32(ndr, "message_token", r->message_token);
ndr->depth--;
}
-static enum ndr_err_code ndr_push_nbt_ntlogon_request(struct ndr_push *ndr, int ndr_flags, const union nbt_ntlogon_request *r)
+static enum ndr_err_code ndr_push_nbt_netlogon_request(struct ndr_push *ndr, int ndr_flags, const union nbt_netlogon_request *r)
{
if (ndr_flags & NDR_SCALARS) {
int level = ndr_push_get_switch_value(ndr, r);
switch (level) {
- case NTLOGON_SAM_LOGON: {
- NDR_CHECK(ndr_push_nbt_ntlogon_sam_logon(ndr, NDR_SCALARS, &r->logon));
- break; }
-
- case NTLOGON_SAM_LOGON_REPLY: {
- NDR_CHECK(ndr_push_nbt_ntlogon_sam_logon_reply(ndr, NDR_SCALARS, &r->reply));
+ case LOGON_SAM_LOGON_REQUEST: {
+ NDR_CHECK(ndr_push_NETLOGON_SAM_LOGON_REQUEST(ndr, NDR_SCALARS, &r->logon));
break; }
- case NTLOGON_SAM_LOGON_REPLY15: {
- NDR_CHECK(ndr_push_nbt_ntlogon_sam_logon_reply(ndr, NDR_SCALARS, &r->reply));
+ case LOGON_PRIMARY_QUERY: {
+ NDR_CHECK(ndr_push_nbt_netlogon_query_for_pdc(ndr, NDR_SCALARS, &r->pdc));
break; }
- case NTLOGON_RESPONSE_FROM_PDC2: {
- NDR_CHECK(ndr_push_nbt_netlogon_response_from_pdc2(ndr, NDR_SCALARS, &r->reply2));
+ case NETLOGON_ANNOUNCE_UAS: {
+ NDR_CHECK(ndr_push_NETLOGON_DB_CHANGE(ndr, NDR_SCALARS, &r->uas));
break; }
default:
if (ndr_flags & NDR_BUFFERS) {
int level = ndr_push_get_switch_value(ndr, r);
switch (level) {
- case NTLOGON_SAM_LOGON:
- NDR_CHECK(ndr_push_nbt_ntlogon_sam_logon(ndr, NDR_BUFFERS, &r->logon));
- break;
-
- case NTLOGON_SAM_LOGON_REPLY:
+ case LOGON_SAM_LOGON_REQUEST:
+ NDR_CHECK(ndr_push_NETLOGON_SAM_LOGON_REQUEST(ndr, NDR_BUFFERS, &r->logon));
break;
- case NTLOGON_SAM_LOGON_REPLY15:
+ case LOGON_PRIMARY_QUERY:
break;
- case NTLOGON_RESPONSE_FROM_PDC2:
+ case NETLOGON_ANNOUNCE_UAS:
+ NDR_CHECK(ndr_push_NETLOGON_DB_CHANGE(ndr, NDR_BUFFERS, &r->uas));
break;
default:
return NDR_ERR_SUCCESS;
}
-static enum ndr_err_code ndr_pull_nbt_ntlogon_request(struct ndr_pull *ndr, int ndr_flags, union nbt_ntlogon_request *r)
+static enum ndr_err_code ndr_pull_nbt_netlogon_request(struct ndr_pull *ndr, int ndr_flags, union nbt_netlogon_request *r)
{
int level;
level = ndr_pull_get_switch_value(ndr, r);
if (ndr_flags & NDR_SCALARS) {
switch (level) {
- case NTLOGON_SAM_LOGON: {
- NDR_CHECK(ndr_pull_nbt_ntlogon_sam_logon(ndr, NDR_SCALARS, &r->logon));
- break; }
-
- case NTLOGON_SAM_LOGON_REPLY: {
- NDR_CHECK(ndr_pull_nbt_ntlogon_sam_logon_reply(ndr, NDR_SCALARS, &r->reply));
+ case LOGON_SAM_LOGON_REQUEST: {
+ NDR_CHECK(ndr_pull_NETLOGON_SAM_LOGON_REQUEST(ndr, NDR_SCALARS, &r->logon));
break; }
- case NTLOGON_SAM_LOGON_REPLY15: {
- NDR_CHECK(ndr_pull_nbt_ntlogon_sam_logon_reply(ndr, NDR_SCALARS, &r->reply));
+ case LOGON_PRIMARY_QUERY: {
+ NDR_CHECK(ndr_pull_nbt_netlogon_query_for_pdc(ndr, NDR_SCALARS, &r->pdc));
break; }
- case NTLOGON_RESPONSE_FROM_PDC2: {
- NDR_CHECK(ndr_pull_nbt_netlogon_response_from_pdc2(ndr, NDR_SCALARS, &r->reply2));
+ case NETLOGON_ANNOUNCE_UAS: {
+ NDR_CHECK(ndr_pull_NETLOGON_DB_CHANGE(ndr, NDR_SCALARS, &r->uas));
break; }
default:
}
if (ndr_flags & NDR_BUFFERS) {
switch (level) {
- case NTLOGON_SAM_LOGON:
- NDR_CHECK(ndr_pull_nbt_ntlogon_sam_logon(ndr, NDR_BUFFERS, &r->logon));
- break;
-
- case NTLOGON_SAM_LOGON_REPLY:
+ case LOGON_SAM_LOGON_REQUEST:
+ NDR_CHECK(ndr_pull_NETLOGON_SAM_LOGON_REQUEST(ndr, NDR_BUFFERS, &r->logon));
break;
- case NTLOGON_SAM_LOGON_REPLY15:
+ case LOGON_PRIMARY_QUERY:
break;
- case NTLOGON_RESPONSE_FROM_PDC2:
+ case NETLOGON_ANNOUNCE_UAS:
+ NDR_CHECK(ndr_pull_NETLOGON_DB_CHANGE(ndr, NDR_BUFFERS, &r->uas));
break;
default:
return NDR_ERR_SUCCESS;
}
-_PUBLIC_ void ndr_print_nbt_ntlogon_request(struct ndr_print *ndr, const char *name, const union nbt_ntlogon_request *r)
+_PUBLIC_ void ndr_print_nbt_netlogon_request(struct ndr_print *ndr, const char *name, const union nbt_netlogon_request *r)
{
int level;
level = ndr_print_get_switch_value(ndr, r);
- ndr_print_union(ndr, name, level, "nbt_ntlogon_request");
+ ndr_print_union(ndr, name, level, "nbt_netlogon_request");
switch (level) {
- case NTLOGON_SAM_LOGON:
- ndr_print_nbt_ntlogon_sam_logon(ndr, "logon", &r->logon);
- break;
-
- case NTLOGON_SAM_LOGON_REPLY:
- ndr_print_nbt_ntlogon_sam_logon_reply(ndr, "reply", &r->reply);
+ case LOGON_SAM_LOGON_REQUEST:
+ ndr_print_NETLOGON_SAM_LOGON_REQUEST(ndr, "logon", &r->logon);
break;
- case NTLOGON_SAM_LOGON_REPLY15:
- ndr_print_nbt_ntlogon_sam_logon_reply(ndr, "reply", &r->reply);
+ case LOGON_PRIMARY_QUERY:
+ ndr_print_nbt_netlogon_query_for_pdc(ndr, "pdc", &r->pdc);
break;
- case NTLOGON_RESPONSE_FROM_PDC2:
- ndr_print_nbt_netlogon_response_from_pdc2(ndr, "reply2", &r->reply2);
+ case NETLOGON_ANNOUNCE_UAS:
+ ndr_print_NETLOGON_DB_CHANGE(ndr, "uas", &r->uas);
break;
default:
}
}
-_PUBLIC_ enum ndr_err_code ndr_push_nbt_ntlogon_packet(struct ndr_push *ndr, int ndr_flags, const struct nbt_ntlogon_packet *r)
+_PUBLIC_ enum ndr_err_code ndr_push_nbt_netlogon_packet(struct ndr_push *ndr, int ndr_flags, const struct nbt_netlogon_packet *r)
{
{
uint32_t _flags_save_STRUCT = ndr->flags;
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
if (ndr_flags & NDR_SCALARS) {
- NDR_CHECK(ndr_push_align(ndr, 4));
- NDR_CHECK(ndr_push_nbt_ntlogon_command(ndr, NDR_SCALARS, r->command));
+ NDR_CHECK(ndr_push_align(ndr, 8));
+ NDR_CHECK(ndr_push_netlogon_command(ndr, NDR_SCALARS, r->command));
NDR_CHECK(ndr_push_set_switch_value(ndr, &r->req, r->command));
- NDR_CHECK(ndr_push_nbt_ntlogon_request(ndr, NDR_SCALARS, &r->req));
+ NDR_CHECK(ndr_push_nbt_netlogon_request(ndr, NDR_SCALARS, &r->req));
}
if (ndr_flags & NDR_BUFFERS) {
- NDR_CHECK(ndr_push_nbt_ntlogon_request(ndr, NDR_BUFFERS, &r->req));
+ NDR_CHECK(ndr_push_nbt_netlogon_request(ndr, NDR_BUFFERS, &r->req));
}
ndr->flags = _flags_save_STRUCT;
}
return NDR_ERR_SUCCESS;
}
-_PUBLIC_ enum ndr_err_code ndr_pull_nbt_ntlogon_packet(struct ndr_pull *ndr, int ndr_flags, struct nbt_ntlogon_packet *r)
+_PUBLIC_ enum ndr_err_code ndr_pull_nbt_netlogon_packet(struct ndr_pull *ndr, int ndr_flags, struct nbt_netlogon_packet *r)
{
{
uint32_t _flags_save_STRUCT = ndr->flags;
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
if (ndr_flags & NDR_SCALARS) {
- NDR_CHECK(ndr_pull_align(ndr, 4));
- NDR_CHECK(ndr_pull_nbt_ntlogon_command(ndr, NDR_SCALARS, &r->command));
+ NDR_CHECK(ndr_pull_align(ndr, 8));
+ NDR_CHECK(ndr_pull_netlogon_command(ndr, NDR_SCALARS, &r->command));
NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->req, r->command));
- NDR_CHECK(ndr_pull_nbt_ntlogon_request(ndr, NDR_SCALARS, &r->req));
+ NDR_CHECK(ndr_pull_nbt_netlogon_request(ndr, NDR_SCALARS, &r->req));
}
if (ndr_flags & NDR_BUFFERS) {
- NDR_CHECK(ndr_pull_nbt_ntlogon_request(ndr, NDR_BUFFERS, &r->req));
+ NDR_CHECK(ndr_pull_nbt_netlogon_request(ndr, NDR_BUFFERS, &r->req));
}
ndr->flags = _flags_save_STRUCT;
}
return NDR_ERR_SUCCESS;
}
-_PUBLIC_ void ndr_print_nbt_ntlogon_packet(struct ndr_print *ndr, const char *name, const struct nbt_ntlogon_packet *r)
+_PUBLIC_ void ndr_print_nbt_netlogon_packet(struct ndr_print *ndr, const char *name, const struct nbt_netlogon_packet *r)
{
- ndr_print_struct(ndr, name, "nbt_ntlogon_packet");
+ ndr_print_struct(ndr, name, "nbt_netlogon_packet");
{
uint32_t _flags_save_STRUCT = ndr->flags;
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
ndr->depth++;
- ndr_print_nbt_ntlogon_command(ndr, "command", r->command);
+ ndr_print_netlogon_command(ndr, "command", r->command);
ndr_print_set_switch_value(ndr, &r->req, r->command);
- ndr_print_nbt_ntlogon_request(ndr, "req", &r->req);
+ ndr_print_nbt_netlogon_request(ndr, "req", &r->req);
ndr->depth--;
ndr->flags = _flags_save_STRUCT;
}
#ifndef _HEADER_NDR_nbt
#define _HEADER_NDR_nbt
-#include "libcli/nbt/libnbt.h"
+#include "../libcli/netlogon.h"
+#include "../libcli/nbt/libnbt.h"
#define NDR_NBT_CALL_COUNT (0)
void ndr_print_nbt_operation(struct ndr_print *ndr, const char *name, uint16_t r);
void ndr_print_nbt_name_type(struct ndr_print *ndr, const char *name, enum nbt_name_type r);
enum ndr_err_code ndr_push_nbt_name(struct ndr_push *ndr, int ndr_flags, const struct nbt_name *r);
enum ndr_err_code ndr_pull_nbt_name(struct ndr_pull *ndr, int ndr_flags, struct nbt_name *r);
void ndr_print_nbt_name(struct ndr_print *ndr, const char *name, const struct nbt_name *r);
+enum ndr_err_code ndr_push_nbt_qclass(struct ndr_push *ndr, int ndr_flags, enum nbt_qclass r);
+enum ndr_err_code ndr_pull_nbt_qclass(struct ndr_pull *ndr, int ndr_flags, enum nbt_qclass *r);
void ndr_print_nbt_qclass(struct ndr_print *ndr, const char *name, enum nbt_qclass r);
+enum ndr_err_code ndr_push_nbt_qtype(struct ndr_push *ndr, int ndr_flags, enum nbt_qtype r);
+enum ndr_err_code ndr_pull_nbt_qtype(struct ndr_pull *ndr, int ndr_flags, enum nbt_qtype *r);
void ndr_print_nbt_qtype(struct ndr_print *ndr, const char *name, enum nbt_qtype r);
void ndr_print_nbt_name_question(struct ndr_print *ndr, const char *name, const struct nbt_name_question *r);
void ndr_print_nb_flags(struct ndr_print *ndr, const char *name, uint16_t r);
void ndr_print_nbt_status_name(struct ndr_print *ndr, const char *name, const struct nbt_status_name *r);
void ndr_print_nbt_rdata_status(struct ndr_print *ndr, const char *name, const struct nbt_rdata_status *r);
void ndr_print_nbt_rdata_data(struct ndr_print *ndr, const char *name, const struct nbt_rdata_data *r);
+enum ndr_err_code ndr_push_nbt_rdata(struct ndr_push *ndr, int ndr_flags, const union nbt_rdata *r);
+enum ndr_err_code ndr_pull_nbt_rdata(struct ndr_pull *ndr, int ndr_flags, union nbt_rdata *r);
void ndr_print_nbt_rdata(struct ndr_print *ndr, const char *name, const union nbt_rdata *r);
+enum ndr_err_code ndr_push_nbt_res_rec(struct ndr_push *ndr, int ndr_flags, const struct nbt_res_rec *r);
void ndr_print_nbt_res_rec(struct ndr_print *ndr, const char *name, const struct nbt_res_rec *r);
enum ndr_err_code ndr_push_nbt_name_packet(struct ndr_push *ndr, int ndr_flags, const struct nbt_name_packet *r);
enum ndr_err_code ndr_pull_nbt_name_packet(struct ndr_pull *ndr, int ndr_flags, struct nbt_name_packet *r);
enum ndr_err_code ndr_push_nbt_dgram_packet(struct ndr_push *ndr, int ndr_flags, const struct nbt_dgram_packet *r);
enum ndr_err_code ndr_pull_nbt_dgram_packet(struct ndr_pull *ndr, int ndr_flags, struct nbt_dgram_packet *r);
void ndr_print_nbt_dgram_packet(struct ndr_print *ndr, const char *name, const struct nbt_dgram_packet *r);
-void ndr_print_nbt_netlogon_command(struct ndr_print *ndr, const char *name, enum nbt_netlogon_command r);
-void ndr_print_nbt_netlogon_version(struct ndr_print *ndr, const char *name, uint32_t r);
+enum ndr_err_code ndr_push_nbt_sockaddr(struct ndr_push *ndr, int ndr_flags, const struct nbt_sockaddr *r);
+enum ndr_err_code ndr_pull_nbt_sockaddr(struct ndr_pull *ndr, int ndr_flags, struct nbt_sockaddr *r);
+void ndr_print_nbt_sockaddr(struct ndr_print *ndr, const char *name, const struct nbt_sockaddr *r);
+size_t ndr_size_nbt_sockaddr(const struct nbt_sockaddr *r, int flags);
+enum ndr_err_code ndr_push_nbt_server_type(struct ndr_push *ndr, int ndr_flags, uint32_t r);
+enum ndr_err_code ndr_pull_nbt_server_type(struct ndr_pull *ndr, int ndr_flags, uint32_t *r);
+void ndr_print_nbt_server_type(struct ndr_print *ndr, const char *name, uint32_t r);
+enum ndr_err_code ndr_push_netlogon_nt_version_flags(struct ndr_push *ndr, int ndr_flags, uint32_t r);
+enum ndr_err_code ndr_pull_netlogon_nt_version_flags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r);
+void ndr_print_netlogon_nt_version_flags(struct ndr_print *ndr, const char *name, uint32_t r);
+enum ndr_err_code ndr_push_netlogon_command(struct ndr_push *ndr, int ndr_flags, enum netlogon_command r);
+enum ndr_err_code ndr_pull_netlogon_command(struct ndr_pull *ndr, int ndr_flags, enum netlogon_command *r);
+void ndr_print_netlogon_command(struct ndr_print *ndr, const char *name, enum netlogon_command r);
+enum ndr_err_code ndr_push_NETLOGON_SAM_LOGON_REQUEST(struct ndr_push *ndr, int ndr_flags, const struct NETLOGON_SAM_LOGON_REQUEST *r);
+enum ndr_err_code ndr_pull_NETLOGON_SAM_LOGON_REQUEST(struct ndr_pull *ndr, int ndr_flags, struct NETLOGON_SAM_LOGON_REQUEST *r);
+void ndr_print_NETLOGON_SAM_LOGON_REQUEST(struct ndr_print *ndr, const char *name, const struct NETLOGON_SAM_LOGON_REQUEST *r);
+enum ndr_err_code ndr_push_NETLOGON_SAM_LOGON_RESPONSE_NT40(struct ndr_push *ndr, int ndr_flags, const struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *r);
+enum ndr_err_code ndr_pull_NETLOGON_SAM_LOGON_RESPONSE_NT40(struct ndr_pull *ndr, int ndr_flags, struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *r);
+void ndr_print_NETLOGON_SAM_LOGON_RESPONSE_NT40(struct ndr_print *ndr, const char *name, const struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *r);
+enum ndr_err_code ndr_push_NETLOGON_SAM_LOGON_RESPONSE(struct ndr_push *ndr, int ndr_flags, const struct NETLOGON_SAM_LOGON_RESPONSE *r);
+enum ndr_err_code ndr_pull_NETLOGON_SAM_LOGON_RESPONSE(struct ndr_pull *ndr, int ndr_flags, struct NETLOGON_SAM_LOGON_RESPONSE *r);
+void ndr_print_NETLOGON_SAM_LOGON_RESPONSE(struct ndr_print *ndr, const char *name, const struct NETLOGON_SAM_LOGON_RESPONSE *r);
+enum ndr_err_code ndr_push_NETLOGON_SAM_LOGON_RESPONSE_EX(struct ndr_push *ndr, int ndr_flags, const struct NETLOGON_SAM_LOGON_RESPONSE_EX *r);
+enum ndr_err_code ndr_pull_NETLOGON_SAM_LOGON_RESPONSE_EX(struct ndr_pull *ndr, int ndr_flags, struct NETLOGON_SAM_LOGON_RESPONSE_EX *r);
+void ndr_print_NETLOGON_SAM_LOGON_RESPONSE_EX(struct ndr_print *ndr, const char *name, const struct NETLOGON_SAM_LOGON_RESPONSE_EX *r);
void ndr_print_nbt_netlogon_query_for_pdc(struct ndr_print *ndr, const char *name, const struct nbt_netlogon_query_for_pdc *r);
-void ndr_print_nbt_netlogon_query_for_pdc2(struct ndr_print *ndr, const char *name, const struct nbt_netlogon_query_for_pdc2 *r);
+enum ndr_err_code ndr_push_nbt_netlogon_response_from_pdc(struct ndr_push *ndr, int ndr_flags, const struct nbt_netlogon_response_from_pdc *r);
+enum ndr_err_code ndr_pull_nbt_netlogon_response_from_pdc(struct ndr_pull *ndr, int ndr_flags, struct nbt_netlogon_response_from_pdc *r);
void ndr_print_nbt_netlogon_response_from_pdc(struct ndr_print *ndr, const char *name, const struct nbt_netlogon_response_from_pdc *r);
-void ndr_print_nbt_server_type(struct ndr_print *ndr, const char *name, uint32_t r);
-void ndr_print_nbt_dc_sock_addr(struct ndr_print *ndr, const char *name, const struct nbt_dc_sock_addr *r);
-void ndr_print_nbt_netlogon_response_from_pdc2(struct ndr_print *ndr, const char *name, const struct nbt_netlogon_response_from_pdc2 *r);
-void ndr_print_nbt_db_change(struct ndr_print *ndr, const char *name, const struct nbt_db_change *r);
-void ndr_print_nbt_netlogon_announce_uas(struct ndr_print *ndr, const char *name, const struct nbt_netlogon_announce_uas *r);
+void ndr_print_nbt_db_change_info(struct ndr_print *ndr, const char *name, const struct nbt_db_change_info *r);
+void ndr_print_NETLOGON_DB_CHANGE(struct ndr_print *ndr, const char *name, const struct NETLOGON_DB_CHANGE *r);
void ndr_print_nbt_netlogon_request(struct ndr_print *ndr, const char *name, const union nbt_netlogon_request *r);
enum ndr_err_code ndr_push_nbt_netlogon_packet(struct ndr_push *ndr, int ndr_flags, const struct nbt_netlogon_packet *r);
enum ndr_err_code ndr_pull_nbt_netlogon_packet(struct ndr_pull *ndr, int ndr_flags, struct nbt_netlogon_packet *r);
void ndr_print_nbt_netlogon_packet(struct ndr_print *ndr, const char *name, const struct nbt_netlogon_packet *r);
-void ndr_print_nbt_cldap_netlogon_1(struct ndr_print *ndr, const char *name, const struct nbt_cldap_netlogon_1 *r);
-void ndr_print_nbt_cldap_netlogon_3(struct ndr_print *ndr, const char *name, const struct nbt_cldap_netlogon_3 *r);
-enum ndr_err_code ndr_push_nbt_cldap_netlogon_5(struct ndr_push *ndr, int ndr_flags, const struct nbt_cldap_netlogon_5 *r);
-enum ndr_err_code ndr_pull_nbt_cldap_netlogon_5(struct ndr_pull *ndr, int ndr_flags, struct nbt_cldap_netlogon_5 *r);
-void ndr_print_nbt_cldap_netlogon_5(struct ndr_print *ndr, const char *name, const struct nbt_cldap_netlogon_5 *r);
-void ndr_print_nbt_cldap_netlogon_13(struct ndr_print *ndr, const char *name, const struct nbt_cldap_netlogon_13 *r);
-enum ndr_err_code ndr_push_nbt_cldap_netlogon_15(struct ndr_push *ndr, int ndr_flags, const struct nbt_cldap_netlogon_15 *r);
-enum ndr_err_code ndr_pull_nbt_cldap_netlogon_15(struct ndr_pull *ndr, int ndr_flags, struct nbt_cldap_netlogon_15 *r);
-void ndr_print_nbt_cldap_netlogon_15(struct ndr_print *ndr, const char *name, const struct nbt_cldap_netlogon_15 *r);
-enum ndr_err_code ndr_push_nbt_cldap_netlogon_29(struct ndr_push *ndr, int ndr_flags, const struct nbt_cldap_netlogon_29 *r);
-enum ndr_err_code ndr_pull_nbt_cldap_netlogon_29(struct ndr_pull *ndr, int ndr_flags, struct nbt_cldap_netlogon_29 *r);
-void ndr_print_nbt_cldap_netlogon_29(struct ndr_print *ndr, const char *name, const struct nbt_cldap_netlogon_29 *r);
-enum ndr_err_code ndr_push_nbt_cldap_netlogon(struct ndr_push *ndr, int ndr_flags, const union nbt_cldap_netlogon *r);
-enum ndr_err_code ndr_pull_nbt_cldap_netlogon(struct ndr_pull *ndr, int ndr_flags, union nbt_cldap_netlogon *r);
-void ndr_print_nbt_cldap_netlogon(struct ndr_print *ndr, const char *name, const union nbt_cldap_netlogon *r);
-void ndr_print_nbt_ntlogon_command(struct ndr_print *ndr, const char *name, enum nbt_ntlogon_command r);
-void ndr_print_nbt_ntlogon_sam_logon(struct ndr_print *ndr, const char *name, const struct nbt_ntlogon_sam_logon *r);
-void ndr_print_nbt_ntlogon_sam_logon_reply(struct ndr_print *ndr, const char *name, const struct nbt_ntlogon_sam_logon_reply *r);
-void ndr_print_nbt_ntlogon_request(struct ndr_print *ndr, const char *name, const union nbt_ntlogon_request *r);
-enum ndr_err_code ndr_push_nbt_ntlogon_packet(struct ndr_push *ndr, int ndr_flags, const struct nbt_ntlogon_packet *r);
-enum ndr_err_code ndr_pull_nbt_ntlogon_packet(struct ndr_pull *ndr, int ndr_flags, struct nbt_ntlogon_packet *r);
-void ndr_print_nbt_ntlogon_packet(struct ndr_print *ndr, const char *name, const struct nbt_ntlogon_packet *r);
void ndr_print_nbt_browse_opcode(struct ndr_print *ndr, const char *name, enum nbt_browse_opcode r);
void ndr_print_nbt_browse_host_announcement(struct ndr_print *ndr, const char *name, const struct nbt_browse_host_announcement *r);
void ndr_print_nbt_browse_announcement_request(struct ndr_print *ndr, const char *name, const struct nbt_browse_announcement_request *r);
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
return false;
}
- pull = ndr_pull_init_blob(&blob, r);
+ pull = ndr_pull_init_blob(&blob, r, NULL);
if (pull == NULL) {
talloc_free(r);
return false;
uint32 usriX_code_page;
string usriX_profile;
string usriX_home_dir_drive;
+ uint32 usriX_user_id;
uint32 usriX_primary_group_id;
+ uint32 usriX_password_expired;
} USER_INFO_X;
[nopush,nopull] NET_API_STATUS NetUserAdd(
import "misc.idl", "security.idl", "svcctl.idl", "samr.idl";
[
-helper("libcli/nbt/libnbt.h")
+ helper("../libcli/netlogon.h", "../libcli/nbt/libnbt.h")
]
interface nbt
{
nbt_name_type type;
} nbt_name;
- typedef [enum16bit] enum {
+ typedef [public,enum16bit] enum {
NBT_QCLASS_IP = 0x01
} nbt_qclass;
- typedef [enum16bit] enum {
+ typedef [public,enum16bit] enum {
NBT_QTYPE_ADDRESS = 0x0001,
NBT_QTYPE_NAMESERVICE = 0x0002,
NBT_QTYPE_NULL = 0x000A,
uint8 data[length];
} nbt_rdata_data;
- typedef [nodiscriminant] union {
+ typedef [nodiscriminant,public] union {
[case(NBT_QTYPE_NETBIOS)] nbt_rdata_netbios netbios;
[case(NBT_QTYPE_STATUS)] nbt_rdata_status status;
[default] nbt_rdata_data data;
* together with NBT_QTYPE_NETBIOS
* for WACK replies
*/
-#define NBT_RES_REC_LEVEL(rr_type, rdata) (\
- (((rr_type) == NBT_QTYPE_NETBIOS) && \
- talloc_check_name(ndr, "struct ndr_push") && \
- ((rdata).data.length == 2)) \
- ? 0 : rr_type)
-
- typedef [flag(LIBNDR_PRINT_ARRAY_HEX)] struct {
+ typedef [flag(LIBNDR_PRINT_ARRAY_HEX),nopush] struct {
nbt_name name;
nbt_qtype rr_type;
nbt_qclass rr_class;
uint32 ttl;
- [switch_is(NBT_RES_REC_LEVEL(rr_type, rdata))] nbt_rdata rdata;
+ [switch_is(rr_type)] nbt_rdata rdata;
} nbt_res_rec;
typedef [flag(NDR_NOALIGN|NDR_BIG_ENDIAN|NDR_PAHEX),public] struct {
} nbt_dgram_packet;
- /*******************************************/
- /* \MAILSLOT\NET\NETLOGON mailslot requests */
- typedef enum {
- NETLOGON_QUERY_FOR_PDC = 0x7,
- NETLOGON_ANNOUNCE_UAS = 0xa,
- NETLOGON_RESPONSE_FROM_PDC = 0xc,
- NETLOGON_QUERY_FOR_PDC2 = 0x12,
- NETLOGON_RESPONSE_FROM_PDC2 = 0x17,
- NETLOGON_RESPONSE_FROM_PDC_USER = 0x19
- } nbt_netlogon_command;
-
- typedef [flag(NDR_LITTLE_ENDIAN),bitmap32bit] bitmap {
- NETLOGON_VERSION_1 = 0x00000001,
- NETLOGON_VERSION_5 = 0x00000002,
- NETLOGON_VERSION_5EX = 0x00000004,
- NETLOGON_VERSION_5EX_WITH_IP = 0x00000008,
- NETLOGON_VERSION_WITH_CLOSEST_SITE = 0x00000010,
- NETLOGON_VERSION_AVOID_NT4_EMUL = 0x01000000,
- NETLOGON_VERSION_PDC = 0x10000000,
- NETLOGON_VERSION_IP = 0x20000000,
- NETLOGON_VERSION_LOCAL = 0x40000000,
- NETLOGON_VERSION_GC = 0x80000000
- } nbt_netlogon_version;
+ /******************************************
+ * \MAILSLOT\NET\NETLOGON mailslot requests
+ * and
+ * \MAILSLOT\NET\NTLOGON mailslot requests
+ */
- /* query for pdc request */
- typedef struct {
- astring computer_name;
- astring mailslot_name;
- [flag(NDR_ALIGN2)] DATA_BLOB _pad;
- nstring unicode_name;
- nbt_netlogon_version nt_version;
- uint16 lmnt_token;
- uint16 lm20_token;
- } nbt_netlogon_query_for_pdc;
-
- /* query for pdc request - new style */
- typedef struct {
- uint16 request_count;
- nstring computer_name;
- nstring user_name;
- astring mailslot_name;
- uint32 unknown[2];
- nbt_netlogon_version nt_version;
- uint16 lmnt_token;
- uint16 lm20_token;
- } nbt_netlogon_query_for_pdc2;
-
- /* response from pdc */
- typedef struct {
- astring pdc_name;
- [flag(NDR_ALIGN2)] DATA_BLOB _pad;
- nstring unicode_pdc_name;
- nstring domain_name;
- nbt_netlogon_version nt_version;
- uint16 lmnt_token;
- uint16 lm20_token;
- } nbt_netlogon_response_from_pdc;
+ typedef [public,gensize] struct {
+ uint32 sockaddr_family;
+ [flag(NDR_BIG_ENDIAN)] ipv4address pdc_ip;
+ [flag(NDR_REMAINING)] DATA_BLOB remaining;
+ } nbt_sockaddr;
- typedef [bitmap32bit] bitmap {
+ typedef [bitmap32bit,public] bitmap {
NBT_SERVER_PDC = 0x00000001,
NBT_SERVER_GC = 0x00000004,
NBT_SERVER_LDAP = 0x00000008,
NBT_SERVER_FULL_SECRET_DOMAIN_6 = 0x00001000
} nbt_server_type;
- typedef struct {
- uint32 family;
- [flag(NDR_BIG_ENDIAN)] ipv4address pdc_ip;
- [flag(NDR_REMAINING)] DATA_BLOB remaining;
- } nbt_dc_sock_addr;
-
- /* response from pdc - type2 */
- typedef struct {
+ typedef [bitmap32bit,public] bitmap {
+ NETLOGON_NT_VERSION_1 = 0x00000001,
+ NETLOGON_NT_VERSION_5 = 0x00000002,
+ NETLOGON_NT_VERSION_5EX = 0x00000004,
+ NETLOGON_NT_VERSION_5EX_WITH_IP = 0x00000008,
+ NETLOGON_NT_VERSION_WITH_CLOSEST_SITE = 0x00000010,
+ NETLOGON_NT_VERSION_AVIOD_NT4EMUL = 0x01000000,
+ NETLOGON_NT_VERSION_PDC = 0x10000000,
+ NETLOGON_NT_VERSION_IP = 0x20000000,
+ NETLOGON_NT_VERSION_LOCAL = 0x40000000,
+ NETLOGON_NT_VERSION_GC = 0x80000000
+ } netlogon_nt_version_flags;
+
+ typedef [enum16bit,public] enum {
+ LOGON_PRIMARY_QUERY = 7, /* Was also NETLOGON_QUERY_FOR_PDC */
+ NETLOGON_ANNOUNCE_UAS = 10,
+ NETLOGON_RESPONSE_FROM_PDC = 12,
+ LOGON_SAM_LOGON_REQUEST = 18, /* Was also NETLOGON_QUERY_FOR_PDC2, NTLOGON_SAM_LOGON */
+ LOGON_SAM_LOGON_RESPONSE = 19, /* Was also NTLOGON_SAM_LOGON_REPLY */
+ LOGON_SAM_LOGON_PAUSE_RESPONSE = 20,
+ LOGON_SAM_LOGON_USER_UNKNOWN = 21, /* Was also NTLOGON_SAM_LOGON_REPLY15 */
+ LOGON_SAM_LOGON_RESPONSE_EX = 23, /* was NETLOGON_RESPONSE_FROM_PDC2 */
+ LOGON_SAM_LOGON_PAUSE_RESPONSE_EX = 24,
+ LOGON_SAM_LOGON_USER_UNKNOWN_EX = 25 /* was NETLOGON_RESPONSE_FROM_PDC_USER */
+ } netlogon_command;
+
+ typedef bitmap samr_AcctFlags samr_AcctFlags;
+
+ /* query to dc hand marshaled, as it has 'optional'
+ * parts */
+ typedef [nopull,nopush] struct {
+ uint16 request_count;
+ nstring computer_name;
+ nstring user_name;
+ astring mailslot_name;
+ samr_AcctFlags acct_control;
+ [value(ndr_size_dom_sid0(&sid, ndr->flags))] uint32 sid_size;
+ /* The manual alignment is required because this
+ * structure is marked flag(NDR_NOALIGN) via the
+ * nbt_netlogon_packet below.
+ *
+ * However, both MUST only be present if sid_size > 0
+ */
[flag(NDR_ALIGN4)] DATA_BLOB _pad;
- nbt_server_type server_type;
- GUID domain_uuid;
- nbt_string forest;
- nbt_string dns_domain;
- nbt_string pdc_dns_name;
- nbt_string domain;
- nbt_string pdc_name;
- nbt_string user_name;
- nbt_string server_site;
- nbt_string client_site;
- uint8 dc_sock_addr_size;
- [subcontext(0),subcontext_size(dc_sock_addr_size)] nbt_dc_sock_addr dc_sock_addr;
- nbt_netlogon_version nt_version;
+ [subcontext(0),subcontext_size(sid_size)] dom_sid0 sid;
+ netlogon_nt_version_flags nt_version;
uint16 lmnt_token;
uint16 lm20_token;
- } nbt_netlogon_response_from_pdc2;
-
- typedef enum netr_SamDatabaseID netr_SamDatabaseID;
-
- /* announce change to UAS or SAM */
- typedef struct {
- netr_SamDatabaseID db_index;
- hyper serial;
- NTTIME timestamp;
- } nbt_db_change;
-
- /* used to announce SAM changes */
- typedef struct {
- uint32 serial_lo;
- time_t timestamp;
- uint32 pulse;
- uint32 random;
- astring pdc_name;
- astring domain;
- [flag(NDR_ALIGN2)] DATA_BLOB _pad;
- nstring unicode_pdc_name;
- nstring unicode_domain;
- uint32 db_count;
- nbt_db_change dbchange[db_count];
- [value(ndr_size_dom_sid0(&sid, ndr->flags))] uint32 sid_size;
- [subcontext(0),subcontext_size(sid_size)] dom_sid0 sid;
- nbt_netlogon_version nt_version;
- uint16 lmnt_token;
- uint16 lm20_token;
- } nbt_netlogon_announce_uas;
-
- typedef [nodiscriminant] union {
- [case(NETLOGON_QUERY_FOR_PDC)] nbt_netlogon_query_for_pdc pdc;
- [case(NETLOGON_QUERY_FOR_PDC2)] nbt_netlogon_query_for_pdc2 pdc2;
- [case(NETLOGON_ANNOUNCE_UAS)] nbt_netlogon_announce_uas uas;
- [case(NETLOGON_RESPONSE_FROM_PDC)] nbt_netlogon_response_from_pdc response;
- [case(NETLOGON_RESPONSE_FROM_PDC2)] nbt_netlogon_response_from_pdc2 response2;
- [case(NETLOGON_RESPONSE_FROM_PDC_USER)] nbt_netlogon_response_from_pdc2 response2;
- } nbt_netlogon_request;
+ } NETLOGON_SAM_LOGON_REQUEST;
typedef [flag(NDR_NOALIGN),public] struct {
- nbt_netlogon_command command;
- [switch_is(command)] nbt_netlogon_request req;
- } nbt_netlogon_packet;
-
- /*******************************************/
- /* CLDAP netlogon response */
-
- /* note that these structures are very similar to, but not
- quite identical to, the netlogon structures above */
-
- typedef struct {
- nbt_netlogon_command type;
- nstring pdc_name;
+ netlogon_command command;
+ nstring server;
nstring user_name;
- nstring domain_name;
- [value(1)] nbt_netlogon_version nt_version;
+ nstring domain;
+ netlogon_nt_version_flags nt_version;
uint16 lmnt_token;
uint16 lm20_token;
- } nbt_cldap_netlogon_1;
+ } NETLOGON_SAM_LOGON_RESPONSE_NT40;
- typedef struct {
- nbt_netlogon_command type;
+ typedef [flag(NDR_NOALIGN),public] struct {
+ netlogon_command command;
nstring pdc_name;
nstring user_name;
nstring domain_name;
GUID domain_uuid;
- GUID unknown_uuid;
+ GUID zero_uuid;
nbt_string forest;
nbt_string dns_domain;
nbt_string pdc_dns_name;
ipv4address pdc_ip;
nbt_server_type server_type;
- [value(3)] nbt_netlogon_version nt_version;
+ netlogon_nt_version_flags nt_version;
uint16 lmnt_token;
uint16 lm20_token;
- } nbt_cldap_netlogon_3;
+ } NETLOGON_SAM_LOGON_RESPONSE;
- typedef [public] struct {
- nbt_netlogon_command type;
- uint16 sbz;
+ /* response from pdc hand marshaled (we have an additional
+ * function that uses this structure), as it has 'optional'
+ * parts */
+ typedef [flag(NDR_NOALIGN),public] struct {
+ netlogon_command command;
+ uint16 sbz; /* From the docs */
nbt_server_type server_type;
GUID domain_uuid;
nbt_string forest;
nbt_string user_name;
nbt_string server_site;
nbt_string client_site;
- [value(5)] nbt_netlogon_version nt_version;
- uint16 lmnt_token;
- uint16 lm20_token;
- } nbt_cldap_netlogon_5;
- typedef struct {
- nbt_netlogon_command type;
- uint16 sbz;
- nbt_server_type server_type;
- GUID domain_uuid;
- nbt_string forest;
- nbt_string dns_domain;
- nbt_string pdc_dns_name;
- nbt_string domain;
- nbt_string pdc_name;
- nbt_string user_name;
- nbt_string server_site;
- nbt_string client_site;
- uint8 dc_sock_addr_size;
- [subcontext(0),subcontext_size(dc_sock_addr_size)] nbt_dc_sock_addr dc_sock_addr;
- [value(13)] nbt_netlogon_version nt_version;
- uint16 lmnt_token;
- uint16 lm20_token;
- } nbt_cldap_netlogon_13;
+ /* Optional on NETLOGON_NT_VERSION_5EX_WITH_IP */
+ [value(ndr_size_nbt_sockaddr(&sockaddr, ndr->flags))] uint8 sockaddr_size;
+ [subcontext(0),subcontext_size(sockaddr_size)] nbt_sockaddr sockaddr;
- typedef [public] struct {
- nbt_netlogon_command type;
- uint16 sbz;
- nbt_server_type server_type;
- GUID domain_uuid;
- nbt_string forest;
- nbt_string dns_domain;
- nbt_string pdc_dns_name;
- nbt_string domain;
- nbt_string pdc_name;
- nbt_string user_name;
- nbt_string server_site;
- nbt_string client_site;
+ /* Optional on NETLOGON_NT_VERSION_WITH_CLOSEST_SITE */
nbt_string next_closest_site;
- [value(15)] nbt_netlogon_version nt_version;
- uint16 lmnt_token;
- uint16 lm20_token;
- } nbt_cldap_netlogon_15;
- typedef [public] struct {
- nbt_netlogon_command type;
- uint16 sbz;
- nbt_server_type server_type;
- GUID domain_uuid;
- nbt_string forest;
- nbt_string dns_domain;
- nbt_string pdc_dns_name;
- nbt_string domain;
- nbt_string pdc_name;
- nbt_string user_name;
- nbt_string server_site;
- nbt_string client_site;
- uint8 dc_sock_addr_size;
- [subcontext(0),subcontext_size(dc_sock_addr_size)] nbt_dc_sock_addr dc_sock_addr;
- nbt_string next_closest_site;
- [value(29)] nbt_netlogon_version nt_version;
+ netlogon_nt_version_flags nt_version;
uint16 lmnt_token;
uint16 lm20_token;
- } nbt_cldap_netlogon_29;
-
- typedef [flag(NDR_NOALIGN),public,nodiscriminant] union {
- [case(0)] nbt_cldap_netlogon_1 logon1;
- [case(1)] nbt_cldap_netlogon_1 logon1;
- [case(2)] nbt_cldap_netlogon_3 logon3;
- [case(3)] nbt_cldap_netlogon_3 logon3;
- [case(4)] nbt_cldap_netlogon_5 logon5;
- [case(5)] nbt_cldap_netlogon_5 logon5;
- [case(6)] nbt_cldap_netlogon_5 logon5;
- [case(7)] nbt_cldap_netlogon_5 logon5;
- [case(8)] nbt_cldap_netlogon_13 logon13;
- [case(9)] nbt_cldap_netlogon_13 logon13;
- [case(10)] nbt_cldap_netlogon_13 logon13;
- [case(11)] nbt_cldap_netlogon_13 logon13;
- [case(12)] nbt_cldap_netlogon_13 logon13;
- [case(13)] nbt_cldap_netlogon_13 logon13;
- [case(14)] nbt_cldap_netlogon_13 logon13;
- [case(15)] nbt_cldap_netlogon_13 logon13;
- [case(16)] nbt_cldap_netlogon_1 logon1;
- [case(17)] nbt_cldap_netlogon_1 logon1;
- [case(18)] nbt_cldap_netlogon_3 logon3;
- [case(19)] nbt_cldap_netlogon_3 logon3;
- [case(20)] nbt_cldap_netlogon_15 logon15;
- [case(21)] nbt_cldap_netlogon_15 logon15;
- [case(22)] nbt_cldap_netlogon_15 logon15;
- [case(23)] nbt_cldap_netlogon_15 logon15;
- [case(24)] nbt_cldap_netlogon_15 logon15;
- [case(25)] nbt_cldap_netlogon_15 logon15;
- [case(26)] nbt_cldap_netlogon_15 logon15;
- [case(27)] nbt_cldap_netlogon_15 logon15;
- [case(28)] nbt_cldap_netlogon_15 logon15;
- [case(29)] nbt_cldap_netlogon_29 logon29;
- [case(30)] nbt_cldap_netlogon_29 logon29;
- [case(31)] nbt_cldap_netlogon_29 logon29;
- } nbt_cldap_netlogon;
-
- /*******************************************/
- /* \MAILSLOT\NET\NTLOGON mailslot requests */
- typedef enum {
- NTLOGON_SAM_LOGON = 0x12,
- NTLOGON_SAM_LOGON_REPLY = 0x13,
- NTLOGON_SAM_LOGON_REPLY15 = 0x15,
- NTLOGON_RESPONSE_FROM_PDC2 = 0x17
- } nbt_ntlogon_command;
+ } NETLOGON_SAM_LOGON_RESPONSE_EX;
+ /* query for pdc request */
typedef struct {
- uint16 request_count;
- nstring computer_name;
- nstring user_name;
+ astring computer_name;
astring mailslot_name;
- samr_AcctFlags acct_control;
- [value(ndr_size_dom_sid0(&sid, ndr->flags))] uint32 sid_size;
- [subcontext(0),subcontext_size(sid_size)] dom_sid0 sid;
- nbt_netlogon_version nt_version;
+ [flag(NDR_ALIGN2)] DATA_BLOB _pad;
+ nstring unicode_name;
+ netlogon_nt_version_flags nt_version;
uint16 lmnt_token;
uint16 lm20_token;
- } nbt_ntlogon_sam_logon;
+ } nbt_netlogon_query_for_pdc;
- typedef struct {
- nstring server;
- nstring user_name;
- nstring domain;
- nbt_netlogon_version nt_version;
+ /* response from pdc */
+ typedef [flag(NDR_NOALIGN),public] struct {
+ netlogon_command command;
+ astring pdc_name;
+ [flag(NDR_ALIGN2)] DATA_BLOB _pad;
+ nstring unicode_pdc_name;
+ nstring domain_name;
+ netlogon_nt_version_flags nt_version;
uint16 lmnt_token;
uint16 lm20_token;
- } nbt_ntlogon_sam_logon_reply;
+ } nbt_netlogon_response_from_pdc;
+
+ typedef enum netr_SamDatabaseID netr_SamDatabaseID;
+
+ /* used to announce SAM changes - MS-NRPC 2.2.1.5.1 */
+ typedef struct {
+ netr_SamDatabaseID db_index;
+ hyper serial;
+ NTTIME timestamp;
+ } nbt_db_change_info;
+
+ typedef struct {
+ uint32 serial_lo;
+ time_t timestamp;
+ uint32 pulse;
+ uint32 random;
+ astring pdc_name;
+ astring domain;
+ [flag(NDR_ALIGN2)] DATA_BLOB _pad;
+ nstring unicode_pdc_name;
+ nstring unicode_domain;
+ uint32 db_count;
+ nbt_db_change_info dbchange[db_count];
+ [value(ndr_size_dom_sid0(&sid, ndr->flags))] uint32 sid_size;
+ [subcontext(0),subcontext_size(sid_size)] dom_sid0 sid;
+ uint32 message_format_version;
+ uint32 message_token;
+ } NETLOGON_DB_CHANGE;
typedef [nodiscriminant] union {
- [case(NTLOGON_SAM_LOGON)] nbt_ntlogon_sam_logon logon;
- [case(NTLOGON_SAM_LOGON_REPLY)] nbt_ntlogon_sam_logon_reply reply;
- [case(NTLOGON_SAM_LOGON_REPLY15)] nbt_ntlogon_sam_logon_reply reply;
- [case(NTLOGON_RESPONSE_FROM_PDC2)] nbt_netlogon_response_from_pdc2 reply2;
- } nbt_ntlogon_request;
+ [case(LOGON_SAM_LOGON_REQUEST)] NETLOGON_SAM_LOGON_REQUEST logon;
+ [case(LOGON_PRIMARY_QUERY)] nbt_netlogon_query_for_pdc pdc;
+ [case(NETLOGON_ANNOUNCE_UAS)] NETLOGON_DB_CHANGE uas;
+ } nbt_netlogon_request;
+
+#if 0
+ [case(NETLOGON_RESPONSE_FROM_PDC)] nbt_netlogon_response_from_pdc response;
+ [case(NETLOGON_RESPONSE_FROM_PDC_USER)] nbt_netlogon_response_from_pdc2 response2;
+
+ [case(LOGON_SAM_LOGON_PAUSE_RESPONSE)] NETLOGON_SAM_LOGON_RESPONSE reply;
+ [case(LOGON_SAM_LOGON_RESPONSE)] NETLOGON_SAM_LOGON_RESPONSE reply;
+ [case(LOGON_SAM_LOGON_USER_UNKNOWN)] NETLOGON_SAM_LOGON_RESPONSE reply;
+ [case(LOGON_SAM_LOGON_RESPONSE_EX)] NETLOGON_SAM_LOGON_RESPONSE_EX reply_ex;
+ [case(LOGON_SAM_LOGON_PAUSE_RESPONSE_EX)] NETLOGON_SAM_LOGON_RESPONSE_EX reply_ex;
+ [case(LOGON_SAM_LOGON_USER_UNKNOWN_EX)] NETLOGON_SAM_LOGON_RESPONSE_EX reply_ex;
+#endif
typedef [flag(NDR_NOALIGN),public] struct {
- nbt_ntlogon_command command;
- [switch_is(command)] nbt_ntlogon_request req;
- } nbt_ntlogon_packet;
+ netlogon_command command;
+ [switch_is(command)] nbt_netlogon_request req;
+ } nbt_netlogon_packet;
/********************************************************/
/* \MAILSLOT\BROWSE mailslot requests */
/*
initialise a ndr parse structure from a data blob
*/
-_PUBLIC_ struct ndr_pull *ndr_pull_init_blob(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx)
+_PUBLIC_ struct ndr_pull *ndr_pull_init_blob(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience)
{
struct ndr_pull *ndr;
/*
pull a struct from a blob using NDR
*/
-_PUBLIC_ enum ndr_err_code ndr_pull_struct_blob(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx, void *p,
- ndr_pull_flags_fn_t fn)
+_PUBLIC_ enum ndr_err_code ndr_pull_struct_blob(const DATA_BLOB *blob,
+ TALLOC_CTX *mem_ctx,
+ struct smb_iconv_convenience *iconv_convenience,
+ void *p,
+ ndr_pull_flags_fn_t fn)
{
struct ndr_pull *ndr;
- ndr = ndr_pull_init_blob(blob, mem_ctx);
+ ndr = ndr_pull_init_blob(blob, mem_ctx, iconv_convenience);
NDR_ERR_HAVE_NO_MEMORY(ndr);
NDR_CHECK(fn(ndr, NDR_SCALARS|NDR_BUFFERS, p));
return NDR_ERR_SUCCESS;
/*
pull a struct from a blob using NDR - failing if all bytes are not consumed
*/
-_PUBLIC_ enum ndr_err_code ndr_pull_struct_blob_all(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx, void *p,
- ndr_pull_flags_fn_t fn)
+_PUBLIC_ enum ndr_err_code ndr_pull_struct_blob_all(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx,
+ struct smb_iconv_convenience *iconv_convenience,
+ void *p, ndr_pull_flags_fn_t fn)
{
struct ndr_pull *ndr;
- ndr = ndr_pull_init_blob(blob, mem_ctx);
+ ndr = ndr_pull_init_blob(blob, mem_ctx, iconv_convenience);
NDR_ERR_HAVE_NO_MEMORY(ndr);
NDR_CHECK(fn(ndr, NDR_SCALARS|NDR_BUFFERS, p));
if (ndr->offset < ndr->data_size) {
uint32_t level, ndr_pull_flags_fn_t fn)
{
struct ndr_pull *ndr;
- ndr = ndr_pull_init_blob(blob, mem_ctx);
+ ndr = ndr_pull_init_blob(blob, mem_ctx, NULL);
NDR_ERR_HAVE_NO_MEMORY(ndr);
NDR_CHECK(ndr_pull_set_switch_value(ndr, p, level));
NDR_CHECK(fn(ndr, NDR_SCALARS|NDR_BUFFERS, p));
uint32_t level, ndr_pull_flags_fn_t fn)
{
struct ndr_pull *ndr;
- ndr = ndr_pull_init_blob(blob, mem_ctx);
+ ndr = ndr_pull_init_blob(blob, mem_ctx, NULL);
NDR_ERR_HAVE_NO_MEMORY(ndr);
NDR_CHECK(ndr_pull_set_switch_value(ndr, p, level));
NDR_CHECK(fn(ndr, NDR_SCALARS|NDR_BUFFERS, p));
/*
push a struct to a blob using NDR
*/
-_PUBLIC_ enum ndr_err_code ndr_push_struct_blob(DATA_BLOB *blob, TALLOC_CTX *mem_ctx, const void *p,
- ndr_push_flags_fn_t fn)
+_PUBLIC_ enum ndr_err_code ndr_push_struct_blob(DATA_BLOB *blob,
+ TALLOC_CTX *mem_ctx,
+ struct smb_iconv_convenience *iconv_convenience,
+ const void *p,
+ ndr_push_flags_fn_t fn)
{
struct ndr_push *ndr;
ndr = ndr_push_init_ctx(mem_ctx);
_PUBLIC_ NTSTATUS dcerpc_floor_get_lhs_data(struct epm_floor *epm_floor, struct ndr_syntax_id *syntax)
{
TALLOC_CTX *mem_ctx = talloc_init("floor_get_lhs_data");
- struct ndr_pull *ndr = ndr_pull_init_blob(&epm_floor->lhs.lhs_data, mem_ctx);
+ struct ndr_pull *ndr = ndr_pull_init_blob(&epm_floor->lhs.lhs_data, mem_ctx, NULL);
enum ndr_err_code ndr_err;
uint16_t if_version=0;
prs_mem_free( &r_ps );
- pull = ndr_pull_init_blob(&blob, req);
+ pull = ndr_pull_init_blob(&blob, req, NULL);
if (pull == NULL) {
return NT_STATUS_NO_MEMORY;
}
blob.data = data;
blob.length = size;
- ndr_pull = ndr_pull_init_blob(&blob, mem_ctx);
+ ndr_pull = ndr_pull_init_blob(&blob, mem_ctx, NULL);
ndr_pull->flags |= LIBNDR_FLAG_REF_ALLOC;
ndr_err = f->ndr_pull(ndr_pull, NDR_IN, st);
blob.data = data;
blob.length = size;
- ndr_pull = ndr_pull_init_blob(&blob, mem_ctx);
+ ndr_pull = ndr_pull_init_blob(&blob, mem_ctx, NULL);
ndr_pull->flags |= LIBNDR_FLAG_REF_ALLOC;
ndr_err = f->ndr_pull(ndr_pull, flags, st);
dump_data(0, v_blob.data, v_blob.length);
}
- ndr_v_pull = ndr_pull_init_blob(&v_blob, mem_ctx);
+ ndr_v_pull = ndr_pull_init_blob(&v_blob, mem_ctx, NULL);
ndr_v_pull->flags |= LIBNDR_FLAG_REF_ALLOC;
ndr_err = f->ndr_pull(ndr_v_pull, flags, v_st);
}
cli->evt_inbuf = tmp;
- res = recv(cli->fd, cli->evt_inbuf + old_size, available, 0);
+ res = sys_recv(cli->fd, cli->evt_inbuf + old_size, available, 0);
if (res == -1) {
DEBUG(10, ("recv failed: %s\n", strerror(errno)));
status = map_nt_error_from_unix(errno);
return;
}
- sent = send(cli->fd, req->outbuf + req->sent,
+ sent = sys_send(cli->fd, req->outbuf + req->sent,
to_send - req->sent, 0);
if (sent < 0) {
struct in_addr dc_ip;
const char *my_acct_name = NULL;
const char *my_mailslot = NULL;
- struct nbt_ntlogon_packet packet;
- struct nbt_ntlogon_sam_logon *s;
+ struct nbt_netlogon_packet packet;
+ struct NETLOGON_SAM_LOGON_REQUEST *s;
enum ndr_err_code ndr_err;
DATA_BLOB blob;
struct dom_sid my_sid;
return false;
}
- packet.command = NTLOGON_SAM_LOGON;
+ packet.command = LOGON_SAM_LOGON_REQUEST;
s = &packet.req.logon;
s->request_count = 0;
s->lm20_token = 0xffff;
if (DEBUGLEVEL >= 10) {
- NDR_PRINT_DEBUG(nbt_ntlogon_packet, &packet);
+ NDR_PRINT_DEBUG(nbt_netlogon_packet, &packet);
}
- ndr_err = ndr_push_struct_blob(&blob, mem_ctx, &packet,
- (ndr_push_flags_fn_t)ndr_push_nbt_ntlogon_packet);
+ ndr_err = ndr_push_struct_blob(&blob, mem_ctx, NULL, &packet,
+ (ndr_push_flags_fn_t)ndr_push_nbt_netlogon_packet);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return false;
}
const char *domain_name,
uint32_t *nt_version,
const char **dc_name,
- union nbt_cldap_netlogon **reply)
+ struct netlogon_samlogon_response **_r)
{
struct packet_struct *packet;
const char *my_mailslot = NULL;
struct in_addr dc_ip;
DATA_BLOB blob;
- union nbt_cldap_netlogon r;
+ struct netlogon_samlogon_response r;
union dgram_message_body p;
enum ndr_err_code ndr_err;
+ NTSTATUS status;
const char *returned_dc = NULL;
const char *returned_domain = NULL;
blob = p.smb.body.trans.data;
- if (!pull_mailslot_cldap_reply(mem_ctx, &blob,
- &r, nt_version))
- {
+ ZERO_STRUCT(r);
+
+ status = pull_netlogon_samlogon_response(&blob, mem_ctx, NULL, &r);
+ if (!NT_STATUS_IS_OK(status)) {
return false;
}
- switch (*nt_version) {
- case 1:
- case 16:
- case 17:
-
- returned_domain = r.logon1.domain_name;
- returned_dc = r.logon1.pdc_name;
- break;
- case 2:
- case 3:
- case 18:
- case 19:
- returned_domain = r.logon3.domain_name;
- returned_dc = r.logon3.pdc_name;
- break;
- case 4:
- case 5:
- case 6:
- case 7:
- returned_domain = r.logon5.domain;
- returned_dc = r.logon5.pdc_name;
- break;
- case 8:
- case 9:
- case 10:
- case 11:
- case 12:
- case 13:
- case 14:
- case 15:
- returned_domain = r.logon13.domain;
- returned_dc = r.logon13.pdc_name;
- break;
- case 20:
- case 21:
- case 22:
- case 23:
- case 24:
- case 25:
- case 26:
- case 27:
- case 28:
- returned_domain = r.logon15.domain;
- returned_dc = r.logon15.pdc_name;
- break;
- case 29:
- case 30:
- case 31:
- returned_domain = r.logon29.domain;
- returned_dc = r.logon29.pdc_name;
- break;
- default:
- return false;
- }
+ map_netlogon_samlogon_response(&r);
+
+ /* do we still need this ? */
+ *nt_version = r.ntver;
+
+ returned_domain = r.data.nt5_ex.domain;
+ returned_dc = r.data.nt5_ex.pdc_name;
if (!strequal(returned_domain, domain_name)) {
DEBUG(3, ("GetDC: Expected domain %s, got %s\n",
if (**dc_name == '\\') *dc_name += 1;
if (**dc_name == '\\') *dc_name += 1;
- if (reply) {
- *reply = (union nbt_cldap_netlogon *)talloc_memdup(
- mem_ctx, &r, sizeof(union nbt_cldap_netlogon));
- if (!*reply) {
+ if (_r) {
+ *_r = (struct netlogon_samlogon_response *)talloc_memdup(
+ mem_ctx, &r, sizeof(struct netlogon_samlogon_response));
+ if (!*_r) {
return false;
}
}
return NULL;
}
- cli = talloc(NULL, struct cli_state);
+ cli = TALLOC_ZERO_P(NULL, struct cli_state);
if (!cli) {
return NULL;
}
- ZERO_STRUCTP(cli);
-
cli->port = 0;
cli->fd = -1;
cli->cnum = -1;
*ecode = SVAL(cli->inbuf,smb_err);
}
-/* Return a UNIX errno from a NT status code */
-static const struct {
- NTSTATUS status;
- int error;
-} nt_errno_map[] = {
- {NT_STATUS_ACCESS_VIOLATION, EACCES},
- {NT_STATUS_INVALID_HANDLE, EBADF},
- {NT_STATUS_ACCESS_DENIED, EACCES},
- {NT_STATUS_OBJECT_NAME_NOT_FOUND, ENOENT},
- {NT_STATUS_OBJECT_PATH_NOT_FOUND, ENOENT},
- {NT_STATUS_SHARING_VIOLATION, EBUSY},
- {NT_STATUS_OBJECT_PATH_INVALID, ENOTDIR},
- {NT_STATUS_OBJECT_NAME_COLLISION, EEXIST},
- {NT_STATUS_PATH_NOT_COVERED, ENOENT},
- {NT_STATUS_UNSUCCESSFUL, EINVAL},
- {NT_STATUS_NOT_IMPLEMENTED, ENOSYS},
- {NT_STATUS_IN_PAGE_ERROR, EFAULT},
- {NT_STATUS_BAD_NETWORK_NAME, ENOENT},
-#ifdef EDQUOT
- {NT_STATUS_PAGEFILE_QUOTA, EDQUOT},
- {NT_STATUS_QUOTA_EXCEEDED, EDQUOT},
- {NT_STATUS_REGISTRY_QUOTA_LIMIT, EDQUOT},
- {NT_STATUS_LICENSE_QUOTA_EXCEEDED, EDQUOT},
-#endif
-#ifdef ETIME
- {NT_STATUS_TIMER_NOT_CANCELED, ETIME},
-#endif
- {NT_STATUS_INVALID_PARAMETER, EINVAL},
- {NT_STATUS_NO_SUCH_DEVICE, ENODEV},
- {NT_STATUS_NO_SUCH_FILE, ENOENT},
-#ifdef ENODATA
- {NT_STATUS_END_OF_FILE, ENODATA},
-#endif
-#ifdef ENOMEDIUM
- {NT_STATUS_NO_MEDIA_IN_DEVICE, ENOMEDIUM},
- {NT_STATUS_NO_MEDIA, ENOMEDIUM},
-#endif
- {NT_STATUS_NONEXISTENT_SECTOR, ESPIPE},
- {NT_STATUS_NO_MEMORY, ENOMEM},
- {NT_STATUS_CONFLICTING_ADDRESSES, EADDRINUSE},
- {NT_STATUS_NOT_MAPPED_VIEW, EINVAL},
- {NT_STATUS_UNABLE_TO_FREE_VM, EADDRINUSE},
- {NT_STATUS_ACCESS_DENIED, EACCES},
- {NT_STATUS_BUFFER_TOO_SMALL, ENOBUFS},
- {NT_STATUS_WRONG_PASSWORD, EACCES},
- {NT_STATUS_LOGON_FAILURE, EACCES},
- {NT_STATUS_INVALID_WORKSTATION, EACCES},
- {NT_STATUS_INVALID_LOGON_HOURS, EACCES},
- {NT_STATUS_PASSWORD_EXPIRED, EACCES},
- {NT_STATUS_ACCOUNT_DISABLED, EACCES},
- {NT_STATUS_DISK_FULL, ENOSPC},
- {NT_STATUS_INVALID_PIPE_STATE, EPIPE},
- {NT_STATUS_PIPE_BUSY, EPIPE},
- {NT_STATUS_PIPE_DISCONNECTED, EPIPE},
- {NT_STATUS_PIPE_NOT_AVAILABLE, ENOSYS},
- {NT_STATUS_FILE_IS_A_DIRECTORY, EISDIR},
- {NT_STATUS_NOT_SUPPORTED, ENOSYS},
- {NT_STATUS_NOT_A_DIRECTORY, ENOTDIR},
- {NT_STATUS_DIRECTORY_NOT_EMPTY, ENOTEMPTY},
- {NT_STATUS_NETWORK_UNREACHABLE, ENETUNREACH},
- {NT_STATUS_HOST_UNREACHABLE, EHOSTUNREACH},
- {NT_STATUS_CONNECTION_ABORTED, ECONNABORTED},
- {NT_STATUS_CONNECTION_REFUSED, ECONNREFUSED},
- {NT_STATUS_TOO_MANY_LINKS, EMLINK},
- {NT_STATUS_NETWORK_BUSY, EBUSY},
- {NT_STATUS_DEVICE_DOES_NOT_EXIST, ENODEV},
-#ifdef ELIBACC
- {NT_STATUS_DLL_NOT_FOUND, ELIBACC},
-#endif
- {NT_STATUS_PIPE_BROKEN, EPIPE},
- {NT_STATUS_REMOTE_NOT_LISTENING, ECONNREFUSED},
- {NT_STATUS_NETWORK_ACCESS_DENIED, EACCES},
- {NT_STATUS_TOO_MANY_OPENED_FILES, EMFILE},
-#ifdef EPROTO
- {NT_STATUS_DEVICE_PROTOCOL_ERROR, EPROTO},
-#endif
- {NT_STATUS_FLOAT_OVERFLOW, ERANGE},
- {NT_STATUS_FLOAT_UNDERFLOW, ERANGE},
- {NT_STATUS_INTEGER_OVERFLOW, ERANGE},
- {NT_STATUS_MEDIA_WRITE_PROTECTED, EROFS},
- {NT_STATUS_PIPE_CONNECTED, EISCONN},
- {NT_STATUS_MEMORY_NOT_ALLOCATED, EFAULT},
- {NT_STATUS_FLOAT_INEXACT_RESULT, ERANGE},
- {NT_STATUS_ILL_FORMED_PASSWORD, EACCES},
- {NT_STATUS_PASSWORD_RESTRICTION, EACCES},
- {NT_STATUS_ACCOUNT_RESTRICTION, EACCES},
- {NT_STATUS_PORT_CONNECTION_REFUSED, ECONNREFUSED},
- {NT_STATUS_NAME_TOO_LONG, ENAMETOOLONG},
- {NT_STATUS_REMOTE_DISCONNECT, ESHUTDOWN},
- {NT_STATUS_CONNECTION_DISCONNECTED, ECONNABORTED},
- {NT_STATUS_CONNECTION_RESET, ENETRESET},
-#ifdef ENOTUNIQ
- {NT_STATUS_IP_ADDRESS_CONFLICT1, ENOTUNIQ},
- {NT_STATUS_IP_ADDRESS_CONFLICT2, ENOTUNIQ},
-#endif
- {NT_STATUS_PORT_MESSAGE_TOO_LONG, EMSGSIZE},
- {NT_STATUS_PROTOCOL_UNREACHABLE, ENOPROTOOPT},
- {NT_STATUS_ADDRESS_ALREADY_EXISTS, EADDRINUSE},
- {NT_STATUS_PORT_UNREACHABLE, EHOSTUNREACH},
- {NT_STATUS_IO_TIMEOUT, ETIMEDOUT},
- {NT_STATUS_RETRY, EAGAIN},
-#ifdef ENOTUNIQ
- {NT_STATUS_DUPLICATE_NAME, ENOTUNIQ},
-#endif
-#ifdef ECOMM
- {NT_STATUS_NET_WRITE_FAULT, ECOMM},
-#endif
-#ifdef EXDEV
- {NT_STATUS_NOT_SAME_DEVICE, EXDEV},
-#endif
- {NT_STATUS(0), 0}
-};
-
-/****************************************************************************
- The following mappings need tidying up and moving into libsmb/errormap.c...
-****************************************************************************/
-
-static int cli_errno_from_nt(NTSTATUS status)
-{
- int i;
- DEBUG(10,("cli_errno_from_nt: 32 bit codes: code=%08x\n", NT_STATUS_V(status)));
-
- /* Status codes without this bit set are not errors */
-
- if (!(NT_STATUS_V(status) & 0xc0000000)) {
- return 0;
- }
-
- for (i=0;nt_errno_map[i].error;i++) {
- if (NT_STATUS_V(nt_errno_map[i].status) ==
- NT_STATUS_V(status)) return nt_errno_map[i].error;
- }
-
- /* for all other cases - a default code */
- return EINVAL;
-}
/* Return a UNIX errno appropriate for the error received in the last
packet. */
if (cli_is_nt_error(cli)) {
status = cli_nt_error(cli);
- return cli_errno_from_nt(status);
+ return map_errno_from_nt_status(status);
}
if (cli_is_dos_error(cli)) {
cli_dos_error(cli, &eclass, &ecode);
status = dos_to_ntstatus(eclass, ecode);
- return cli_errno_from_nt(status);
+ return map_errno_from_nt_status(status);
}
/*
Unix SMB/CIFS implementation.
client quota functions
Copyright (C) Stefan (metze) Metzmacher 2003
-
+
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/>.
*/
0x00000016, DESIRED_ACCESS_PIPE,
0x00000000, FILE_SHARE_READ|FILE_SHARE_WRITE,
FILE_OPEN, 0x00000000, 0x03);
-
+
if (*quota_fnum == (-1)) {
return False;
}
{
if (!qt_list)
return;
-
+
if ((*qt_list)->mem_ctx)
talloc_destroy((*qt_list)->mem_ctx);
if (rdata_count < 40) {
return False;
}
-
+
/* offset to next quota record.
* 4 bytes IVAL(rdata,0)
* unused here...
return False;
}
#endif /* LARGE_SMB_OFF_T */
-
+
sid_parse(rdata+40,sid_len,&qt.sid);
qt.qtype = SMB_USER_QUOTA_TYPE;
SIVAL(params, 4,0x00000024);
SIVAL(params, 8,0x00000000);
SIVAL(params,12,0x00000024);
-
+
sid_len = ndr_size_dom_sid(&pqt->sid, 0);
data_len = sid_len+8;
SIVAL(data, 0, 0x00000000);
SIVAL(data, 4, sid_len);
sid_linearize(data+8, sid_len, &pqt->sid);
-
+
if (!cli_send_nt_trans(cli,
NT_TRANSACT_GET_USER_QUOTA,
0,
unsigned int rparam_count=0, rdata_count=0;
unsigned int sid_len;
memset(data,'\0',112);
-
+
if (!cli||!pqt) {
smb_panic("cli_set_user_quota() called with NULL Pointer!");
}
SBIG_UINT(data,24,pqt->softlim);
SBIG_UINT(data,32,pqt->hardlim);
sid_linearize(data+40, sid_len, &pqt->sid);
-
+
if (!cli_send_nt_trans(cli,
NT_TRANSACT_SET_USER_QUOTA,
0,
SIVAL(params, 4,0x00000000);
SIVAL(params, 8,0x00000000);
SIVAL(params,12,0x00000000);
-
+
if (!cli_send_nt_trans(cli,
NT_TRANSACT_GET_USER_QUOTA,
0,
DEBUG(1,("Failed to send NT_TRANSACT_GET_USER_QUOTA\n"));
goto cleanup;
}
-
+
SAFE_FREE(rparam);
SAFE_FREE(rdata);
if (!cli_receive_nt_trans(cli,
} else {
ret = True;
}
-
+
if (rdata_count == 0) {
break;
}
talloc_destroy(mem_ctx);
goto cleanup;
}
-
+
if ((tmp_list_ent->quotas=TALLOC_ZERO_P(mem_ctx,SMB_NTQUOTA_STRUCT))==NULL) {
DEBUG(0,("TALLOC_ZERO() failed\n"));
talloc_destroy(mem_ctx);
goto cleanup;
}
-
+
memcpy(tmp_list_ent->quotas,&qt,sizeof(qt));
tmp_list_ent->mem_ctx = mem_ctx;
-
+
DLIST_ADD((*pqt_list),tmp_list_ent);
}
}
-
+
ret = True;
cleanup:
SAFE_FREE(rparam);
SAFE_FREE(rdata);
-
+
return ret;
}
}
setup = TRANSACT2_QFSINFO;
-
+
SSVAL(param,0,SMB_FS_QUOTA_INFORMATION);
-
+
if (!cli_send_trans(cli, SMBtrans2,
NULL,
0, 0,
NULL, 0, 560)) {
goto cleanup;
}
-
+
if (!cli_receive_trans(cli, SMBtrans2,
&rparam, &rparam_count,
&rdata, &rdata_count)) {
if (rdata_count < 48) {
goto cleanup;
}
-
+
/* unknown_1 24 NULL bytes in pdata*/
/* the soft quotas 8 bytes (SMB_BIG_UINT)*/
data, 48, 0)) {
goto cleanup;
}
-
+
if (!cli_receive_trans(cli, SMBtrans2,
&rparam, &rparam_count,
&rdata, &rdata_count)) {
case SMB_USER_QUOTA_TYPE:
{
fstring username_str = {0};
-
+
if (_sidtostring) {
_sidtostring(username_str,&qt->sid,_numeric);
} else {
static NTSTATUS make_dc_info_from_cldap_reply(TALLOC_CTX *mem_ctx,
uint32_t flags,
struct sockaddr_storage *ss,
- uint32_t nt_version,
- union nbt_cldap_netlogon *r,
+ struct NETLOGON_SAM_LOGON_RESPONSE_EX *r,
struct netr_DsRGetDCNameInfo **info);
/****************************************************************
/****************************************************************
****************************************************************/
-#define SET_STRING(x) \
- talloc_strdup(mem_ctx, x); \
- NT_STATUS_HAVE_NO_MEMORY(x);
-
-static NTSTATUS map_logon29_from_cldap_reply(TALLOC_CTX *mem_ctx,
- uint32_t flags,
- struct sockaddr_storage *ss,
- uint32_t nt_version,
- union nbt_cldap_netlogon *r,
- struct nbt_cldap_netlogon_29 *p)
-{
- char addr[INET6_ADDRSTRLEN];
-
- ZERO_STRUCTP(p);
-
- print_sockaddr(addr, sizeof(addr), ss);
-
- /* FIXME */
- p->dc_sock_addr_size = 0x10; /* the w32 winsock addr size */
- p->dc_sock_addr.family = 2; /* AF_INET */
- p->dc_sock_addr.pdc_ip = talloc_strdup(mem_ctx, addr);
-
- switch (nt_version & 0x0000001f) {
- case 0:
- return NT_STATUS_INVALID_PARAMETER;
- case 1:
- case 16:
- case 17:
- p->pdc_name = SET_STRING(r->logon1.pdc_name);
- p->domain = SET_STRING(r->logon1.domain_name);
-
- if (flags & DS_PDC_REQUIRED) {
- p->server_type = NBT_SERVER_WRITABLE |
- NBT_SERVER_PDC;
- }
- break;
- case 2:
- case 3:
- case 18:
- case 19:
- p->pdc_name = SET_STRING(r->logon3.pdc_name);
- p->domain = SET_STRING(r->logon3.domain_name);
- p->pdc_dns_name = SET_STRING(r->logon3.pdc_dns_name);
- p->dns_domain = SET_STRING(r->logon3.dns_domain);
- p->server_type = r->logon3.server_type;
- p->forest = SET_STRING(r->logon3.forest);
- p->domain_uuid = r->logon3.domain_uuid;
-
- break;
- case 4:
- case 5:
- case 6:
- case 7:
- p->pdc_name = SET_STRING(r->logon5.pdc_name);
- p->domain = SET_STRING(r->logon5.domain);
- p->pdc_dns_name = SET_STRING(r->logon5.pdc_dns_name);
- p->dns_domain = SET_STRING(r->logon5.dns_domain);
- p->server_type = r->logon5.server_type;
- p->forest = SET_STRING(r->logon5.forest);
- p->domain_uuid = r->logon5.domain_uuid;
- p->server_site = SET_STRING(r->logon5.server_site);
- p->client_site = SET_STRING(r->logon5.client_site);
-
- break;
- case 8:
- case 9:
- case 10:
- case 11:
- case 12:
- case 13:
- case 14:
- case 15:
- p->pdc_name = SET_STRING(r->logon13.pdc_name);
- p->domain = SET_STRING(r->logon13.domain);
- p->pdc_dns_name = SET_STRING(r->logon13.pdc_dns_name);
- p->dns_domain = SET_STRING(r->logon13.dns_domain);
- p->server_type = r->logon13.server_type;
- p->forest = SET_STRING(r->logon13.forest);
- p->domain_uuid = r->logon13.domain_uuid;
- p->server_site = SET_STRING(r->logon13.server_site);
- p->client_site = SET_STRING(r->logon13.client_site);
-
- break;
- case 20:
- case 21:
- case 22:
- case 23:
- case 24:
- case 25:
- case 26:
- case 27:
- case 28:
- p->pdc_name = SET_STRING(r->logon15.pdc_name);
- p->domain = SET_STRING(r->logon15.domain);
- p->pdc_dns_name = SET_STRING(r->logon15.pdc_dns_name);
- p->dns_domain = SET_STRING(r->logon15.dns_domain);
- p->server_type = r->logon15.server_type;
- p->forest = SET_STRING(r->logon15.forest);
- p->domain_uuid = r->logon15.domain_uuid;
- p->server_site = SET_STRING(r->logon15.server_site);
- p->client_site = SET_STRING(r->logon15.client_site);
-
- break;
- case 29:
- case 30:
- case 31:
- p->pdc_name = SET_STRING(r->logon29.pdc_name);
- p->domain = SET_STRING(r->logon29.domain);
- p->pdc_dns_name = SET_STRING(r->logon29.pdc_dns_name);
- p->dns_domain = SET_STRING(r->logon29.dns_domain);
- p->server_type = r->logon29.server_type;
- p->forest = SET_STRING(r->logon29.forest);
- p->domain_uuid = r->logon29.domain_uuid;
- p->server_site = SET_STRING(r->logon29.server_site);
- p->client_site = SET_STRING(r->logon29.client_site);
- p->next_closest_site = SET_STRING(r->logon29.next_closest_site);
-
- break;
- default:
- return NT_STATUS_INVALID_PARAMETER;
- }
-
- return NT_STATUS_OK;
-}
-
-/****************************************************************
-****************************************************************/
-
static NTSTATUS store_cldap_reply(TALLOC_CTX *mem_ctx,
uint32_t flags,
struct sockaddr_storage *ss,
uint32_t nt_version,
- union nbt_cldap_netlogon *r)
+ struct NETLOGON_SAM_LOGON_RESPONSE_EX *r)
{
DATA_BLOB blob;
enum ndr_err_code ndr_err;
NTSTATUS status;
- struct nbt_cldap_netlogon_29 logon29;
+ char addr[INET6_ADDRSTRLEN];
- status = map_logon29_from_cldap_reply(mem_ctx, flags, ss,
- nt_version, r, &logon29);
- if (!NT_STATUS_IS_OK(status)) {
- return status;
- }
+ print_sockaddr(addr, sizeof(addr), ss);
+
+ /* FIXME */
+ r->sockaddr_size = 0x10; /* the w32 winsock addr size */
+ r->sockaddr.sockaddr_family = 2; /* AF_INET */
+ r->sockaddr.pdc_ip = talloc_strdup(mem_ctx, addr);
- ndr_err = ndr_push_struct_blob(&blob, mem_ctx, &logon29,
- (ndr_push_flags_fn_t)ndr_push_nbt_cldap_netlogon_29);
+ ndr_err = ndr_push_struct_blob(&blob, mem_ctx, NULL, r,
+ (ndr_push_flags_fn_t)ndr_push_NETLOGON_SAM_LOGON_RESPONSE_EX);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return ndr_map_error2ntstatus(ndr_err);
}
- if (logon29.domain) {
- status = dsgetdcname_cache_store(mem_ctx, logon29.domain, &blob);
+ if (r->domain) {
+ status = dsgetdcname_cache_store(mem_ctx, r->domain, &blob);
if (!NT_STATUS_IS_OK(status)) {
goto done;
}
- if (logon29.client_site) {
- sitename_store(logon29.domain, logon29.client_site);
+ if (r->client_site) {
+ sitename_store(r->domain, r->client_site);
}
}
- if (logon29.dns_domain) {
- status = dsgetdcname_cache_store(mem_ctx, logon29.dns_domain, &blob);
+ if (r->dns_domain) {
+ status = dsgetdcname_cache_store(mem_ctx, r->dns_domain, &blob);
if (!NT_STATUS_IS_OK(status)) {
goto done;
}
- if (logon29.client_site) {
- sitename_store(logon29.dns_domain, logon29.client_site);
+ if (r->client_site) {
+ sitename_store(r->dns_domain, r->client_site);
}
}
+ status = NT_STATUS_OK;
+
done:
data_blob_free(&blob);
/****************************************************************
****************************************************************/
-static uint32_t get_cldap_reply_server_flags(union nbt_cldap_netlogon *r,
+static uint32_t get_cldap_reply_server_flags(struct netlogon_samlogon_response *r,
uint32_t nt_version)
{
switch (nt_version & 0x0000001f) {
case 3:
case 18:
case 19:
- return r->logon3.server_type;
+ return r->data.nt5.server_type;
case 4:
case 5:
case 6:
case 7:
- return r->logon5.server_type;
+ return r->data.nt5_ex.server_type;
case 8:
case 9:
case 10:
case 13:
case 14:
case 15:
- return r->logon13.server_type;
+ return r->data.nt5_ex.server_type;
case 20:
case 21:
case 22:
case 26:
case 27:
case 28:
- return r->logon15.server_type;
+ return r->data.nt5_ex.server_type;
case 29:
case 30:
case 31:
- return r->logon29.server_type;
+ return r->data.nt5_ex.server_type;
default:
return 0;
}
DATA_BLOB blob;
enum ndr_err_code ndr_err;
struct netr_DsRGetDCNameInfo *info;
- union nbt_cldap_netlogon p;
- struct nbt_cldap_netlogon_29 r;
+ struct NETLOGON_SAM_LOGON_RESPONSE_EX r;
NTSTATUS status;
if (!gencache_init()) {
return NT_STATUS_NO_MEMORY;
}
- ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, &r,
- (ndr_pull_flags_fn_t)ndr_pull_nbt_cldap_netlogon_29);
+ ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, NULL, &r,
+ (ndr_pull_flags_fn_t)ndr_pull_NETLOGON_SAM_LOGON_RESPONSE_EX);
data_blob_free(&blob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return ndr_map_error2ntstatus(ndr_err);
}
- p.logon29 = r;
-
status = make_dc_info_from_cldap_reply(mem_ctx, flags, NULL,
- 29,
- &p, &info);
+ &r, &info);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
static NTSTATUS make_dc_info_from_cldap_reply(TALLOC_CTX *mem_ctx,
uint32_t flags,
struct sockaddr_storage *ss,
- uint32_t nt_version,
- union nbt_cldap_netlogon *r,
+ struct NETLOGON_SAM_LOGON_RESPONSE_EX *r,
struct netr_DsRGetDCNameInfo **info)
{
const char *dc_hostname = NULL;
dc_address_type = DS_ADDRESS_TYPE_INET;
}
- switch (nt_version & 0x0000001f) {
- case 0:
- case 1:
- case 16:
- case 17:
- if (!ss) {
- dc_address = r->logon1.pdc_name;
- dc_address_type = DS_ADDRESS_TYPE_NETBIOS;
- }
-
- map_dc_and_domain_names(flags,
- r->logon1.pdc_name,
- r->logon1.domain_name,
- NULL,
- NULL,
- &dc_flags,
- &dc_hostname,
- &dc_domain_name);
-
- if (flags & DS_PDC_REQUIRED) {
- dc_flags = NBT_SERVER_WRITABLE | NBT_SERVER_PDC;
- }
- break;
- case 2:
- case 3:
- case 18:
- case 19:
- if (!ss) {
- dc_address = r->logon3.pdc_ip;
- dc_address_type = DS_ADDRESS_TYPE_INET;
- }
-
- map_dc_and_domain_names(flags,
- r->logon3.pdc_name,
- r->logon3.domain_name,
- r->logon3.pdc_dns_name,
- r->logon3.dns_domain,
- &dc_flags,
- &dc_hostname,
- &dc_domain_name);
-
- dc_flags |= r->logon3.server_type;
- dc_forest = r->logon3.forest;
- dc_domain_guid = &r->logon3.domain_uuid;
-
- break;
- case 4:
- case 5:
- case 6:
- case 7:
- if (!ss) {
- dc_address = r->logon5.pdc_name;
- dc_address_type = DS_ADDRESS_TYPE_NETBIOS;
- }
-
- map_dc_and_domain_names(flags,
- r->logon5.pdc_name,
- r->logon5.domain,
- r->logon5.pdc_dns_name,
- r->logon5.dns_domain,
- &dc_flags,
- &dc_hostname,
- &dc_domain_name);
-
- dc_flags |= r->logon5.server_type;
- dc_forest = r->logon5.forest;
- dc_domain_guid = &r->logon5.domain_uuid;
- dc_server_site = r->logon5.server_site;
- dc_client_site = r->logon5.client_site;
-
- break;
- case 8:
- case 9:
- case 10:
- case 11:
- case 12:
- case 13:
- case 14:
- case 15:
- if (!ss) {
- dc_address = r->logon13.dc_sock_addr.pdc_ip;
- dc_address_type = DS_ADDRESS_TYPE_INET;
- }
-
- map_dc_and_domain_names(flags,
- r->logon13.pdc_name,
- r->logon13.domain,
- r->logon13.pdc_dns_name,
- r->logon13.dns_domain,
- &dc_flags,
- &dc_hostname,
- &dc_domain_name);
-
- dc_flags |= r->logon13.server_type;
- dc_forest = r->logon13.forest;
- dc_domain_guid = &r->logon13.domain_uuid;
- dc_server_site = r->logon13.server_site;
- dc_client_site = r->logon13.client_site;
-
- break;
- case 20:
- case 21:
- case 22:
- case 23:
- case 24:
- case 25:
- case 26:
- case 27:
- case 28:
- if (!ss) {
- dc_address = r->logon15.pdc_name;
- dc_address_type = DS_ADDRESS_TYPE_NETBIOS;
- }
+ if (!ss && r->sockaddr.pdc_ip) {
+ dc_address = r->sockaddr.pdc_ip;
+ dc_address_type = DS_ADDRESS_TYPE_INET;
+ } else {
+ dc_address = r->pdc_name;
+ dc_address_type = DS_ADDRESS_TYPE_NETBIOS;
+ }
- map_dc_and_domain_names(flags,
- r->logon15.pdc_name,
- r->logon15.domain,
- r->logon15.pdc_dns_name,
- r->logon15.dns_domain,
- &dc_flags,
- &dc_hostname,
- &dc_domain_name);
-
- dc_flags |= r->logon15.server_type;
- dc_forest = r->logon15.forest;
- dc_domain_guid = &r->logon15.domain_uuid;
- dc_server_site = r->logon15.server_site;
- dc_client_site = r->logon15.client_site;
-
- break;
- case 29:
- case 30:
- case 31:
- if (!ss) {
- dc_address = r->logon29.dc_sock_addr.pdc_ip;
- dc_address_type = DS_ADDRESS_TYPE_INET;
- }
+ map_dc_and_domain_names(flags,
+ r->pdc_name,
+ r->domain,
+ r->pdc_dns_name,
+ r->dns_domain,
+ &dc_flags,
+ &dc_hostname,
+ &dc_domain_name);
- map_dc_and_domain_names(flags,
- r->logon29.pdc_name,
- r->logon29.domain,
- r->logon29.pdc_dns_name,
- r->logon29.dns_domain,
- &dc_flags,
- &dc_hostname,
- &dc_domain_name);
-
- dc_flags |= r->logon29.server_type;
- dc_forest = r->logon29.forest;
- dc_domain_guid = &r->logon29.domain_uuid;
- dc_server_site = r->logon29.server_site;
- dc_client_site = r->logon29.client_site;
-
- break;
- default:
- return NT_STATUS_INVALID_PARAMETER;
- }
+ dc_flags |= r->server_type;
+ dc_forest = r->forest;
+ dc_domain_guid = &r->domain_uuid;
+ dc_server_site = r->server_site;
+ dc_client_site = r->client_site;
return make_domain_controller_info(mem_ctx,
dc_hostname,
uint32_t nt_version = 0;
if (flags & DS_PDC_REQUIRED) {
- nt_version |= NETLOGON_VERSION_PDC;
+ nt_version |= NETLOGON_NT_VERSION_PDC;
}
if (flags & DS_GC_SERVER_REQUIRED) {
- nt_version |= NETLOGON_VERSION_GC;
+ nt_version |= NETLOGON_NT_VERSION_GC;
}
if (flags & DS_TRY_NEXTCLOSEST_SITE) {
- nt_version |= NETLOGON_VERSION_WITH_CLOSEST_SITE;
+ nt_version |= NETLOGON_NT_VERSION_WITH_CLOSEST_SITE;
}
if (flags & DS_IP_REQUIRED) {
- nt_version |= NETLOGON_VERSION_IP;
+ nt_version |= NETLOGON_NT_VERSION_IP;
}
return nt_version;
{
int i = 0;
bool valid_dc = false;
- union nbt_cldap_netlogon *r = NULL;
- uint32_t nt_version = NETLOGON_VERSION_5 |
- NETLOGON_VERSION_5EX;
+ struct netlogon_samlogon_response *r = NULL;
+ uint32_t nt_version = NETLOGON_NT_VERSION_5 |
+ NETLOGON_NT_VERSION_5EX;
uint32_t ret_flags = 0;
NTSTATUS status;
if (ads_cldap_netlogon(mem_ctx, dclist[i].hostname,
domain_name,
- &nt_version,
+ nt_version,
&r))
{
+ nt_version = r->ntver;
ret_flags = get_cldap_reply_server_flags(r, nt_version);
if (check_cldap_reply_required_flags(ret_flags, flags)) {
}
status = make_dc_info_from_cldap_reply(mem_ctx, flags, &dclist[i].ss,
- nt_version, r, info);
+ &r->data.nt5_ex, info);
if (NT_STATUS_IS_OK(status)) {
return store_cldap_reply(mem_ctx, flags, &dclist[i].ss,
- nt_version, r);
+ nt_version, &r->data.nt5_ex);
}
return status;
int i;
const char *dc_name = NULL;
fstring tmp_dc_name;
- union nbt_cldap_netlogon *r = NULL;
+ struct netlogon_samlogon_response *r = NULL;
bool store_cache = false;
- uint32_t nt_version = NETLOGON_VERSION_1 |
- NETLOGON_VERSION_5 |
- NETLOGON_VERSION_5EX_WITH_IP;
+ uint32_t nt_version = NETLOGON_NT_VERSION_1 |
+ NETLOGON_NT_VERSION_5 |
+ NETLOGON_NT_VERSION_5EX_WITH_IP;
if (!msg_ctx) {
msg_ctx = msg_context(mem_ctx);
&dclist[i].ss,
tmp_dc_name))
{
- struct nbt_cldap_netlogon_1 logon1;
+ struct NETLOGON_SAM_LOGON_RESPONSE_NT40 logon1;
- r = TALLOC_ZERO_P(mem_ctx, union nbt_cldap_netlogon);
+ r = TALLOC_ZERO_P(mem_ctx, struct netlogon_samlogon_response);
NT_STATUS_HAVE_NO_MEMORY(r);
ZERO_STRUCT(logon1);
- nt_version = NETLOGON_VERSION_1;
+ nt_version = NETLOGON_NT_VERSION_1;
logon1.nt_version = nt_version;
- logon1.pdc_name = tmp_dc_name;
- logon1.domain_name = talloc_strdup_upper(mem_ctx, domain_name);
- NT_STATUS_HAVE_NO_MEMORY(logon1.domain_name);
+ logon1.server = tmp_dc_name;
+ logon1.domain = talloc_strdup_upper(mem_ctx, domain_name);
+ NT_STATUS_HAVE_NO_MEMORY(logon1.domain);
- r->logon1 = logon1;
+ r->data.nt4 = logon1;
+ r->ntver = nt_version;
namecache_store(tmp_dc_name, NBT_NAME_SERVER, 1, &ip_list);
make_reply:
status = make_dc_info_from_cldap_reply(mem_ctx, flags, &dclist[i].ss,
- nt_version, r, info);
+ &r->data.nt5_ex, info);
if (NT_STATUS_IS_OK(status) && store_cache) {
return store_cldap_reply(mem_ctx, flags, &dclist[i].ss,
- nt_version, r);
+ nt_version, &r->data.nt5_ex);
}
return status;
unsigned int aflags;
unsigned int amask;
DOM_SID sid;
- SEC_ACCESS mask;
+ uint32_t mask;
const struct perm_value *v;
struct perm_value {
const char *perm;
} else {
uint32 crc;
- crc = crc32_calc_buffer((const char *)data, length);
+ crc = crc32_calc_buffer(data, length);
if (!msrpc_gen(sig, "dddd", NTLMSSP_SIGN_VERSION, 0, crc, ntlmssp_state->ntlmv1_seq_num)) {
return NT_STATUS_NO_MEMORY;
}
}
} else {
uint32 crc;
- crc = crc32_calc_buffer((const char *)data, length);
+ crc = crc32_calc_buffer(data, length);
if (!msrpc_gen(sig, "dddd", NTLMSSP_SIGN_VERSION, 0, crc, ntlmssp_state->ntlmv1_seq_num)) {
return NT_STATUS_NO_MEMORY;
}
NDR_PRINT_DEBUG(netsamlogoncache_entry, &r);
}
- ndr_err = ndr_push_struct_blob(&blob, mem_ctx, &r,
+ ndr_err = ndr_push_struct_blob(&blob, mem_ctx, NULL, &r,
(ndr_push_flags_fn_t)ndr_push_netsamlogoncache_entry);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
DEBUG(0,("netsamlogon_cache_store: failed to push entry to cache\n"));
blob = data_blob_const(data.dptr, data.dsize);
- ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, &r,
+ ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, NULL, &r,
(ndr_pull_flags_fn_t)ndr_pull_netsamlogoncache_entry);
if (DEBUGLEVEL >= 10) {
* of the remaining bytes
*/
crc32_given = IVAL(dec_buffer.data, 0);
- crc32_calc = crc32_calc_buffer((const char *)dec_buffer.data + 4 , dec_buffer.length - 4);
+ crc32_calc = crc32_calc_buffer(dec_buffer.data + 4 , dec_buffer.length - 4);
if (crc32_given != crc32_calc) {
DEBUG(1,("CRC32: given[0x%08X] calc[0x%08X]\n",
crc32_given, crc32_calc));
#include "includes.h"
-/*********************************************************
- Change the domain password on the PDC.
-
- Just changes the password betwen the two values specified.
-
- Caller must have the cli connected to the netlogon pipe
- already.
-**********************************************************/
-
-static NTSTATUS just_change_the_password(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
- const unsigned char orig_trust_passwd_hash[16],
- const char *new_trust_pwd_cleartext,
- const unsigned char new_trust_passwd_hash[16],
- uint32 sec_channel_type)
-{
- NTSTATUS result;
- uint32_t neg_flags = NETLOGON_NEG_AUTH2_ADS_FLAGS;
-
- result = rpccli_netlogon_setup_creds(cli,
- cli->desthost, /* server name */
- lp_workgroup(), /* domain */
- global_myname(), /* client name */
- global_myname(), /* machine account name */
- orig_trust_passwd_hash,
- sec_channel_type,
- &neg_flags);
-
- if (!NT_STATUS_IS_OK(result)) {
- DEBUG(3,("just_change_the_password: unable to setup creds (%s)!\n",
- nt_errstr(result)));
- return result;
- }
-
- if (neg_flags & NETLOGON_NEG_PASSWORD_SET2) {
-
- struct netr_Authenticator clnt_creds, srv_cred;
- struct netr_CryptPassword new_password;
- struct samr_CryptPassword password_buf;
-
- netlogon_creds_client_step(cli->dc, &clnt_creds);
-
- encode_pw_buffer(password_buf.data, new_trust_pwd_cleartext, STR_UNICODE);
-
- SamOEMhash(password_buf.data, cli->dc->sess_key, 516);
- memcpy(new_password.data, password_buf.data, 512);
- new_password.length = IVAL(password_buf.data, 512);
-
- result = rpccli_netr_ServerPasswordSet2(cli, mem_ctx,
- cli->dc->remote_machine,
- cli->dc->mach_acct,
- sec_channel_type,
- global_myname(),
- &clnt_creds,
- &srv_cred,
- &new_password);
-
- /* Always check returned credentials. */
- if (!netlogon_creds_client_check(cli->dc, &srv_cred.cred)) {
- DEBUG(0,("rpccli_netr_ServerPasswordSet2: "
- "credentials chain check failed\n"));
- return NT_STATUS_ACCESS_DENIED;
- }
-
- } else {
-
- struct netr_Authenticator clnt_creds, srv_cred;
- struct samr_Password new_password;
-
- netlogon_creds_client_step(cli->dc, &clnt_creds);
-
- cred_hash3(new_password.hash,
- new_trust_passwd_hash,
- cli->dc->sess_key, 1);
-
- result = rpccli_netr_ServerPasswordSet(cli, mem_ctx,
- cli->dc->remote_machine,
- cli->dc->mach_acct,
- sec_channel_type,
- global_myname(),
- &clnt_creds,
- &srv_cred,
- &new_password);
-
- /* Always check returned credentials. */
- if (!netlogon_creds_client_check(cli->dc, &srv_cred.cred)) {
- DEBUG(0,("rpccli_netr_ServerPasswordSet: "
- "credentials chain check failed\n"));
- return NT_STATUS_ACCESS_DENIED;
- }
- }
-
- if (!NT_STATUS_IS_OK(result)) {
- DEBUG(0,("just_change_the_password: unable to change password (%s)!\n",
- nt_errstr(result)));
- }
- return result;
-}
-
/*********************************************************
Change the domain password on the PDC.
Store the password ourselves, but use the supplied password
E_md4hash(new_trust_passwd, new_trust_passwd_hash);
- nt_status = just_change_the_password(cli, mem_ctx,
- orig_trust_passwd_hash,
- new_trust_passwd,
- new_trust_passwd_hash,
- sec_channel_type);
+ nt_status = rpccli_netlogon_set_trust_password(cli, mem_ctx,
+ orig_trust_passwd_hash,
+ new_trust_passwd,
+ new_trust_passwd_hash,
+ sec_channel_type);
if (NT_STATUS_IS_OK(nt_status)) {
DEBUG(3,("%s : trust_pw_change_and_store_it: Changed password.\n",
rootsbindir="\${SBINDIR}"
lockdir="\${VARDIR}/locks"
piddir="\${VARDIR}/locks"
+ncalrpcdir="\${VARDIR}/ncalrpc"
test "${mandir}" || mandir="\${prefix}/man"
logfilebase="\${VARDIR}"
privatedir="\${prefix}/private"
codepagedir="\${MODULESDIR}"
statedir="\${VARDIR}/lib/samba"
cachedir="\${VARDIR}/lib/samba"
+ ncalrpcdir="\${VARDIR}/ncalrpc"
AC_DEFINE(FHS_COMPATIBLE, 1, [Whether to use fully FHS-compatible paths])
;;
esac])
;;
esac])
+#################################################
+# set ncalrpc directory location
+AC_ARG_WITH(ncalprcdir,
+[AS_HELP_STRING([--with-ncalprcdir=DIR], [Where to put ncalrpc sockets ($ac_default_prefix/var/ncalrpc)])],
+[ case "$withval" in
+ yes|no)
+ #
+ # Just in case anybody calls it without argument
+ #
+ AC_MSG_WARN([--with-ncalrpcdir called without argument - will use default])
+ ;;
+ * )
+ ncalrpcdir="$withval"
+ ;;
+ esac])
+
#################################################
# set SWAT directory location
AC_ARG_WITH(swatdir,
AC_SUBST(configdir)
AC_SUBST(lockdir)
AC_SUBST(piddir)
+AC_SUBST(ncalrpcdir)
AC_SUBST(logfilebase)
AC_SUBST(ctdbdir)
AC_SUBST(privatedir)
SMB_ACE4_INT_T *last;
} SMB_ACL4_INT_T;
-extern int try_chown(connection_struct *conn, const char *fname, uid_t uid, gid_t gid);
-extern NTSTATUS unpack_nt_owners(int snum, uid_t *puser, gid_t *pgrp,
- uint32 security_info_sent, SEC_DESC *psd);
-
static SMB_ACL4_INT_T *get_validated_aclint(SMB4ACL_T *acl)
{
SMB_ACL4_INT_T *aclint = (SMB_ACL4_INT_T *)acl;
}
for (aceint=aclint->first; aceint!=NULL; aceint=(SMB_ACE4_INT_T *)aceint->next) {
- SEC_ACCESS mask;
+ uint32_t mask;
DOM_SID sid;
SMB_ACE4PROP_T *ace = &aceint->prop;
DEBUG(10, ("mapped %d to %s\n", ace->who.id,
sid_string_dbg(&sid)));
- init_sec_access(&mask, ace->aceMask);
+ mask = ace->aceMask;
init_sec_ace(&nt_ace_list[good_aces++], &sid,
ace->aceType, mask,
ace->aceFlags & 0xf);
smbacl4_vfs_params *params,
uid_t ownerUID,
gid_t ownerGID,
- SEC_ACE *ace_nt, /* input */
+ const SEC_ACE *ace_nt, /* input */
SMB_ACE4PROP_T *ace_v4 /* output */
)
{
static SMB4ACL_T *smbacl4_win2nfs4(
const char *filename,
- SEC_ACL *dacl,
+ const SEC_ACL *dacl,
smbacl4_vfs_params *pparams,
uid_t ownerUID,
gid_t ownerGID
NTSTATUS smb_set_nt_acl_nfs4(files_struct *fsp,
uint32 security_info_sent,
- SEC_DESC *psd,
+ const SEC_DESC *psd,
set_nfs4acl_native_fn_t set_nfs4_native)
{
smbacl4_vfs_params params;
size_t sd_size;
struct timespec ts;
- ndr_err = ndr_pull_struct_blob(pblob, ctx, &xacl,
+ ndr_err = ndr_pull_struct_blob(pblob, ctx, NULL, &xacl,
(ndr_pull_flags_fn_t)ndr_pull_xattr_NTACL);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
uint8_t *val = NULL;
uint8_t *tmp;
ssize_t sizeret;
- int saved_errno;
+ int saved_errno = 0;
ZERO_STRUCTP(pblob);
return NT_STATUS_OK;
}
-static int mkdir_acl_xattr(vfs_handle_struct *handle, const char *path, mode_t mode)
-{
- return SMB_VFS_NEXT_MKDIR(handle, path, mode);
-}
-
-static int rmdir_acl_xattr(vfs_handle_struct *handle, const char *path)
-{
- return SMB_VFS_NEXT_RMDIR(handle, path);
-}
-
-static int open_acl_xattr(vfs_handle_struct *handle, const char *fname, files_struct *fsp, int flags, mode_t mode)
-{
- return SMB_VFS_NEXT_OPEN(handle, fname, fsp, flags, mode);
-}
-
-static int unlink_acl_xattr(vfs_handle_struct *handle, const char *fname)
-{
- return SMB_VFS_NEXT_UNLINK(handle, fname);
-}
-
static NTSTATUS get_nt_acl_xattr_internal(vfs_handle_struct *handle,
files_struct *fsp,
const char *name,
return status;
}
+static int mkdir_acl_xattr(vfs_handle_struct *handle, const char *path, mode_t mode)
+{
+ return SMB_VFS_NEXT_MKDIR(handle, path, mode);
+}
+
+/*********************************************************************
+ * Currently this only works for existing files. Need to work on
+ * inheritance for new files.
+*********************************************************************/
+
+static int open_acl_xattr(vfs_handle_struct *handle, const char *fname, files_struct *fsp, int flags, mode_t mode)
+{
+ uint32_t access_granted = 0;
+ SEC_DESC *pdesc = NULL;
+ NTSTATUS status = get_nt_acl_xattr_internal(handle,
+ NULL,
+ fname,
+ (OWNER_SECURITY_INFORMATION |
+ GROUP_SECURITY_INFORMATION |
+ DACL_SECURITY_INFORMATION),
+ &pdesc);
+ if (NT_STATUS_IS_OK(status)) {
+ /* See if we can access it. */
+ if (!se_access_check(pdesc,
+ handle->conn->server_info->ptok,
+ fsp->access_mask,
+ &access_granted,
+ &status)) {
+ errno = map_errno_from_nt_status(status);
+ return -1;
+ }
+ }
+
+ return SMB_VFS_NEXT_OPEN(handle, fname, fsp, flags, mode);
+}
+
static NTSTATUS fget_nt_acl_xattr(vfs_handle_struct *handle, files_struct *fsp,
uint32 security_info, SEC_DESC **ppdesc)
{
security_info, ppdesc);
}
-static NTSTATUS create_acl_blob(SEC_DESC *psd, DATA_BLOB *pblob)
+static NTSTATUS create_acl_blob(const SEC_DESC *psd, DATA_BLOB *pblob)
{
struct xattr_NTACL xacl;
struct security_descriptor_timestamp sd_ts;
xacl.version = 2;
xacl.info.sd_ts = &sd_ts;
- xacl.info.sd_ts->sd = psd;
+ xacl.info.sd_ts->sd = CONST_DISCARD(SEC_DESC *, psd);
unix_timespec_to_nt_time(&xacl.info.sd_ts->last_changed, curr);
ndr_err = ndr_push_struct_blob(
- pblob, ctx, &xacl,
+ pblob, ctx, NULL, &xacl,
(ndr_push_flags_fn_t)ndr_push_xattr_NTACL);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
DATA_BLOB *pblob)
{
int ret;
- int saved_errno;
+ int saved_errno = 0;
DEBUG(10,("store_acl_blob: storing blob length %u on file %s\n",
(unsigned int)pblob->length, fsp->fsp_name));
}
static NTSTATUS fset_nt_acl_xattr(vfs_handle_struct *handle, files_struct *fsp,
- uint32 security_info_sent, SEC_DESC *psd)
+ uint32 security_info_sent, const SEC_DESC *psd)
{
NTSTATUS status;
DATA_BLOB blob;
return status;
}
+ if ((security_info_sent & DACL_SECURITY_INFORMATION) &&
+ psd->dacl != NULL &&
+ (psd->type & (SE_DESC_DACL_AUTO_INHERITED|
+ SE_DESC_DACL_AUTO_INHERIT_REQ))==
+ (SE_DESC_DACL_AUTO_INHERITED|
+ SE_DESC_DACL_AUTO_INHERIT_REQ) ) {
+ SEC_DESC *new_psd = NULL;
+ status = append_parent_acl(fsp, psd, &new_psd);
+ if (!NT_STATUS_IS_OK(status)) {
+ /* Lower level acl set succeeded,
+ * so still return OK. */
+ return NT_STATUS_OK;
+ }
+ psd = new_psd;
+ }
+
create_acl_blob(psd, &blob);
store_acl_blob(fsp, &blob);
static vfs_op_tuple skel_op_tuples[] =
{
{SMB_VFS_OP(mkdir_acl_xattr), SMB_VFS_OP_MKDIR, SMB_VFS_LAYER_TRANSPARENT},
- {SMB_VFS_OP(rmdir_acl_xattr), SMB_VFS_OP_RMDIR, SMB_VFS_LAYER_TRANSPARENT},
{SMB_VFS_OP(open_acl_xattr), SMB_VFS_OP_OPEN, SMB_VFS_LAYER_TRANSPARENT},
- {SMB_VFS_OP(unlink_acl_xattr),SMB_VFS_OP_UNLINK,SMB_VFS_LAYER_TRANSPARENT},
/* NT File ACL operations */
{
SEC_ACE *nt_ace_list;
DOM_SID owner_sid, group_sid;
- SEC_ACCESS mask;
SEC_ACL *psa = NULL;
int good_aces;
size_t sd_size;
good_aces = 0;
while (afs_ace != NULL) {
- uint32 nt_rights;
+ uint32_t nt_rights;
uint8 flag = SEC_ACE_FLAG_OBJECT_INHERIT |
SEC_ACE_FLAG_CONTAINER_INHERIT;
else
nt_rights = afs_to_nt_file_rights(afs_ace->rights);
- init_sec_access(&mask, nt_rights);
init_sec_ace(&nt_ace_list[good_aces++], &(afs_ace->sid),
- SEC_ACE_TYPE_ACCESS_ALLOWED, mask, flag);
+ SEC_ACE_TYPE_ACCESS_ALLOWED, nt_rights, flag);
afs_ace = afs_ace->next;
}
static bool nt_to_afs_acl(const char *filename,
uint32 security_info_sent,
- struct security_descriptor *psd,
+ const struct security_descriptor *psd,
uint32 (*nt_to_afs_rights)(const char *filename,
const SEC_ACE *ace),
struct afs_acl *afs_acl)
{
- SEC_ACL *dacl;
+ const SEC_ACL *dacl;
int i;
/* Currently we *only* look at the dacl */
dacl = psd->dacl;
for (i = 0; i < dacl->num_aces; i++) {
- SEC_ACE *ace = &(dacl->aces[i]);
+ const SEC_ACE *ace = &(dacl->aces[i]);
const char *dom_name, *name;
enum lsa_SidType name_type;
char *p;
static NTSTATUS afs_set_nt_acl(vfs_handle_struct *handle, files_struct *fsp,
uint32 security_info_sent,
- struct security_descriptor *psd)
+ const struct security_descriptor *psd)
{
struct afs_acl old_afs_acl, new_afs_acl;
struct afs_acl dir_acl, file_acl;
NTSTATUS afsacl_fset_nt_acl(vfs_handle_struct *handle,
files_struct *fsp,
uint32 security_info_sent,
- SEC_DESC *psd)
+ const SEC_DESC *psd)
{
return afs_set_nt_acl(handle, fsp, security_info_sent, psd);
}
return True;
}
-static NTSTATUS aixjfs2_set_nt_acl_common(files_struct *fsp, uint32 security_info_sent, SEC_DESC *psd)
+static NTSTATUS aixjfs2_set_nt_acl_common(files_struct *fsp, uint32 security_info_sent, const SEC_DESC *psd)
{
acl_type_t acl_type_info;
NTSTATUS result = NT_STATUS_ACCESS_DENIED;
return result;
}
-NTSTATUS aixjfs2_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp, uint32 security_info_sent, SEC_DESC *psd)
+NTSTATUS aixjfs2_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp, uint32 security_info_sent, const SEC_DESC *psd)
{
return aixjfs2_set_nt_acl_common(fsp, security_info_sent, psd);
}
return result;
}
-static NTSTATUS vfswrap_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp, uint32 security_info_sent, SEC_DESC *psd)
+static NTSTATUS vfswrap_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp, uint32 security_info_sent, const SEC_DESC *psd)
{
NTSTATUS result;
SEC_DESC **ppdesc);
static NTSTATUS smb_full_audit_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp,
uint32 security_info_sent,
- SEC_DESC *psd);
+ const SEC_DESC *psd);
static int smb_full_audit_chmod_acl(vfs_handle_struct *handle,
const char *path, mode_t mode);
static int smb_full_audit_fchmod_acl(vfs_handle_struct *handle, files_struct *fsp,
static NTSTATUS smb_full_audit_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp,
uint32 security_info_sent,
- SEC_DESC *psd)
+ const SEC_DESC *psd)
{
NTSTATUS result;
"who: %d\n", gace->aceType, gace->aceIFlags,
gace->aceFlags, gace->aceMask, gace->aceWho));
- memset(&smbace, 0, sizeof(SMB4ACE_T));
+ ZERO_STRUCT(smbace);
if (gace->aceIFlags & ACE4_IFLAG_SPECIAL_ID) {
smbace.flags |= SMB_ACE4_ID_SPECIAL;
switch (gace->aceWho) {
return True;
}
-static NTSTATUS gpfsacl_set_nt_acl_internal(files_struct *fsp, uint32 security_info_sent, SEC_DESC *psd)
+static NTSTATUS gpfsacl_set_nt_acl_internal(files_struct *fsp, uint32 security_info_sent, const SEC_DESC *psd)
{
struct gpfs_acl *acl;
NTSTATUS result = NT_STATUS_ACCESS_DENIED;
return result;
}
-static NTSTATUS gpfsacl_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp, uint32 security_info_sent, SEC_DESC *psd)
+static NTSTATUS gpfsacl_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp, uint32 security_info_sent, const SEC_DESC *psd)
{
return gpfsacl_set_nt_acl_internal(fsp, security_info_sent, psd);
}
if (haveAllowEntry[i]==True)
continue;
- memset(&ace, 0, sizeof(SMB_ACE4PROP_T));
+ ZERO_STRUCT(ace);
ace.aceType = SMB_ACE4_ACCESS_ALLOWED_ACE_TYPE;
ace.flags |= SMB_ACE4_ID_SPECIAL;
ace.who.special_id = i;
}
/* don't add complementary DENY ACEs here */
- memset(&fake_fsp, 0, sizeof(struct files_struct));
+ ZERO_STRUCT(fake_fsp);
fake_fsp.fsp_name = (char *)path; /* no file_new is needed here */
/* put the acl */
--- /dev/null
+/*
+ * traffic-analyzer VFS module. Measure the smb traffic users create
+ * on the net.
+ *
+ * Copyright (C) Holger Hetterich, 2008
+ * Copyright (C) Jeremy Allison, 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.
+ *
+ * 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"
+
+/* abstraction for the send_over_network function */
+
+enum sock_type {INTERNET_SOCKET = 0, UNIX_DOMAIN_SOCKET};
+
+#define LOCAL_PATHNAME "/var/tmp/stadsocket"
+
+static int vfs_smb_traffic_analyzer_debug_level = DBGC_VFS;
+
+static enum sock_type smb_traffic_analyzer_connMode(vfs_handle_struct *handle)
+{
+ connection_struct *conn = handle->conn;
+ const char *Mode;
+ Mode=lp_parm_const_string(SNUM(conn), "smb_traffic_analyzer","mode", \
+ "internet_socket");
+ if (strstr(Mode,"unix_domain_socket")) {
+ return UNIX_DOMAIN_SOCKET;
+ } else {
+ return INTERNET_SOCKET;
+ }
+}
+
+/* Connect to an internet socket */
+
+static int smb_traffic_analyzer_connect_inet_socket(vfs_handle_struct *handle,
+ const char *name, uint16_t port)
+{
+ /* Create a streaming Socket */
+ int sockfd = -1;
+ struct addrinfo hints;
+ struct addrinfo *ailist = NULL;
+ struct addrinfo *res = NULL;
+ int ret;
+
+ ZERO_STRUCT(hints);
+ /* By default make sure it supports TCP. */
+ hints.ai_socktype = SOCK_STREAM;
+ hints.ai_flags = AI_ADDRCONFIG;
+
+ ret = getaddrinfo(name,
+ NULL,
+ &hints,
+ &ailist);
+
+ if (ret) {
+ DEBUG(3,("smb_traffic_analyzer_connect_inet_socket: "
+ "getaddrinfo failed for name %s [%s]\n",
+ name,
+ gai_strerror(ret) ));
+ return -1;
+ }
+
+ DEBUG(3,("smb_traffic_analyzer: Internet socket mode. Hostname: %s,"
+ "Port: %i\n", name, port));
+
+ for (res = ailist; res; res = res->ai_next) {
+ struct sockaddr_storage ss;
+
+ if (!res->ai_addr || res->ai_addrlen == 0) {
+ continue;
+ }
+
+ ZERO_STRUCT(ss);
+ memcpy(&ss, res->ai_addr, res->ai_addrlen);
+
+ sockfd = open_socket_out(SOCK_STREAM, &ss, port, 10000);
+ if (sockfd != -1) {
+ break;
+ }
+ }
+
+ if (ailist) {
+ freeaddrinfo(ailist);
+ }
+
+ if (sockfd == -1) {
+ DEBUG(1, ("smb_traffic_analyzer: unable to create "
+ "socket, error is %s",
+ strerror(errno)));
+ return -1;
+ }
+
+ return sockfd;
+}
+
+/* Connect to a unix domain socket */
+
+static int smb_traffic_analyzer_connect_unix_socket(vfs_handle_struct *handle,
+ const char *name)
+{
+ /* Create the socket to stad */
+ int len, sock;
+ struct sockaddr_un remote;
+
+ DEBUG(7, ("smb_traffic_analyzer_connect_unix_socket: "
+ "Unix domain socket mode. Using %s\n",
+ name ));
+
+ if ((sock = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
+ DEBUG(1, ("smb_traffic_analyzer_connect_unix_socket: "
+ "Couldn't create socket, "
+ "make sure stad is running!\n"));
+ }
+ remote.sun_family = AF_UNIX;
+ strlcpy(remote.sun_path, name,
+ sizeof(remote.sun_path));
+ len=strlen(remote.sun_path) + sizeof(remote.sun_family);
+ if (connect(sock, (struct sockaddr *)&remote, len) == -1 ) {
+ DEBUG(1, ("smb_traffic_analyzer_connect_unix_socket: "
+ "Could not connect to "
+ "socket, make sure\nstad is running!\n"));
+ close(sock);
+ return -1;
+ }
+ return sock;
+}
+
+/* Private data allowing shared connection sockets. */
+
+struct refcounted_sock {
+ struct refcounted_sock *next, *prev;
+ char *name;
+ uint16_t port;
+ int sock;
+ unsigned int ref_count;
+};
+
+/* Send data over a socket */
+
+static void smb_traffic_analyzer_send_data(vfs_handle_struct *handle,
+ ssize_t result,
+ const char *file_name,
+ bool Write)
+{
+ struct refcounted_sock *rf_sock = NULL;
+ struct timeval tv;
+ time_t tv_sec;
+ struct tm *tm = NULL;
+ int seconds;
+ char *str = NULL;
+ size_t len;
+
+ SMB_VFS_HANDLE_GET_DATA(handle, rf_sock, struct refcounted_sock, return);
+
+ if (rf_sock == NULL || rf_sock->sock == -1) {
+ DEBUG(1, ("smb_traffic_analyzer_send_data: socket is "
+ "closed\n"));
+ return;
+ }
+
+ GetTimeOfDay(&tv);
+ tv_sec = convert_timespec_to_time_t(convert_timeval_to_timespec(tv));
+ tm = localtime(&tv_sec);
+ if (!tm) {
+ return;
+ }
+ seconds=(float) (tv.tv_usec / 1000);
+
+ str = talloc_asprintf(talloc_tos(),
+ "V1,%u,\"%s\",\"%s\",\"%c\",\"%s\",\"%s\","
+ "\"%04d-%02d-%02d %02d:%02d:%02d.%03d\"\n",
+ (unsigned int)result,
+ handle->conn->server_info->sanitized_username,
+ pdb_get_domain(handle->conn->server_info->sam_account),
+ Write ? 'W' : 'R',
+ handle->conn->connectpath,
+ file_name,
+ tm->tm_year+1900,
+ tm->tm_mon+1,
+ tm->tm_mday,
+ tm->tm_hour,
+ tm->tm_min,
+ tm->tm_sec,
+ (int)seconds);
+
+ if (!str) {
+ return;
+ }
+
+ len = strlen(str);
+
+ DEBUG(10, ("smb_traffic_analyzer_send_data_socket: sending %s\n",
+ str));
+ if (write_data(rf_sock->sock, str, len) != len) {
+ DEBUG(1, ("smb_traffic_analyzer_send_data_socket: "
+ "error sending data to socket!\n"));
+ return ;
+ }
+}
+
+static struct refcounted_sock *sock_list;
+
+static void smb_traffic_analyzer_free_data(void **pptr)
+{
+ struct refcounted_sock *rf_sock = *(struct refcounted_sock **)pptr;
+ if (rf_sock == NULL) {
+ return;
+ }
+ rf_sock->ref_count--;
+ if (rf_sock->ref_count != 0) {
+ return;
+ }
+ if (rf_sock->sock != -1) {
+ close(rf_sock->sock);
+ }
+ DLIST_REMOVE(sock_list, rf_sock);
+ TALLOC_FREE(rf_sock);
+}
+
+static int smb_traffic_analyzer_connect(struct vfs_handle_struct *handle,
+ const char *service,
+ const char *user)
+{
+ connection_struct *conn = handle->conn;
+ enum sock_type st = smb_traffic_analyzer_connMode(handle);
+ struct refcounted_sock *rf_sock = NULL;
+ const char *name = (st == UNIX_DOMAIN_SOCKET) ? LOCAL_PATHNAME :
+ lp_parm_const_string(SNUM(conn),
+ "smb_traffic_analyzer",
+ "host", "localhost");
+ uint16_t port = (st == UNIX_DOMAIN_SOCKET) ? 0 :
+ atoi( lp_parm_const_string(SNUM(conn),
+ "smb_traffic_analyzer", "port", "9430"));
+
+ /* Are we already connected ? */
+ for (rf_sock = sock_list; rf_sock; rf_sock = rf_sock->next) {
+ if (port == rf_sock->port &&
+ (strcmp(name, rf_sock->name) == 0)) {
+ break;
+ }
+ }
+
+ /* If we're connected already, just increase the
+ * reference count. */
+ if (rf_sock) {
+ rf_sock->ref_count++;
+ } else {
+ /* New connection. */
+ rf_sock = TALLOC_ZERO_P(NULL, struct refcounted_sock);
+ if (rf_sock == NULL) {
+ errno = ENOMEM;
+ return -1;
+ }
+ rf_sock->name = talloc_strdup(rf_sock, name);
+ if (rf_sock->name == NULL) {
+ TALLOC_FREE(rf_sock);
+ errno = ENOMEM;
+ return -1;
+ }
+ rf_sock->port = port;
+ rf_sock->ref_count = 1;
+
+ if (st == UNIX_DOMAIN_SOCKET) {
+ rf_sock->sock = smb_traffic_analyzer_connect_unix_socket(handle,
+ name);
+ } else {
+
+ rf_sock->sock = smb_traffic_analyzer_connect_inet_socket(handle,
+ name,
+ port);
+ }
+ if (rf_sock->sock == -1) {
+ TALLOC_FREE(rf_sock);
+ return -1;
+ }
+ DLIST_ADD(sock_list, rf_sock);
+ }
+
+ /* Store the private data. */
+ SMB_VFS_HANDLE_SET_DATA(handle, rf_sock, smb_traffic_analyzer_free_data,
+ struct refcounted_sock, return -1);
+ return SMB_VFS_NEXT_CONNECT(handle, service, user);
+}
+
+/* VFS Functions: write, read, pread, pwrite for now */
+
+static ssize_t smb_traffic_analyzer_read(vfs_handle_struct *handle, \
+ files_struct *fsp, void *data, size_t n)
+{
+ ssize_t result;
+
+ result = SMB_VFS_NEXT_READ(handle, fsp, data, n);
+ DEBUG(10, ("smb_traffic_analyzer_read: READ: %s\n", fsp->fsp_name ));
+
+ smb_traffic_analyzer_send_data(handle,
+ result,
+ fsp->fsp_name,
+ false);
+ return result;
+}
+
+
+static ssize_t smb_traffic_analyzer_pread(vfs_handle_struct *handle, \
+ files_struct *fsp, void *data, size_t n, SMB_OFF_T offset)
+{
+ ssize_t result;
+
+ result = SMB_VFS_NEXT_PREAD(handle, fsp, data, n, offset);
+
+ DEBUG(10, ("smb_traffic_analyzer_pread: PREAD: %s\n", fsp->fsp_name ));
+
+ smb_traffic_analyzer_send_data(handle,
+ result,
+ fsp->fsp_name,
+ false);
+
+ return result;
+}
+
+static ssize_t smb_traffic_analyzer_write(vfs_handle_struct *handle, \
+ files_struct *fsp, const void *data, size_t n)
+{
+ ssize_t result;
+
+ result = SMB_VFS_NEXT_WRITE(handle, fsp, data, n);
+
+ DEBUG(10, ("smb_traffic_analyzer_write: WRITE: %s\n", fsp->fsp_name ));
+
+ smb_traffic_analyzer_send_data(handle,
+ result,
+ fsp->fsp_name,
+ true);
+ return result;
+}
+
+static ssize_t smb_traffic_analyzer_pwrite(vfs_handle_struct *handle, \
+ files_struct *fsp, const void *data, size_t n, SMB_OFF_T offset)
+{
+ ssize_t result;
+
+ result = SMB_VFS_NEXT_PWRITE(handle, fsp, data, n, offset);
+
+ DEBUG(10, ("smb_traffic_analyzer_pwrite: PWRITE: %s\n", fsp->fsp_name ));
+
+ smb_traffic_analyzer_send_data(handle,
+ result,
+ fsp->fsp_name,
+ true);
+ return result;
+}
+
+/* VFS operations we use */
+
+static vfs_op_tuple smb_traffic_analyzer_tuples[] = {
+
+ {SMB_VFS_OP(smb_traffic_analyzer_connect), SMB_VFS_OP_CONNECT,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_traffic_analyzer_read), SMB_VFS_OP_READ,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_traffic_analyzer_pread), SMB_VFS_OP_PREAD,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_traffic_analyzer_write), SMB_VFS_OP_WRITE,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_traffic_analyzer_pwrite), SMB_VFS_OP_PWRITE,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(NULL),SMB_VFS_OP_NOOP,SMB_VFS_LAYER_NOOP}
+};
+
+/* Module initialization */
+
+NTSTATUS vfs_smb_traffic_analyzer_init(void)
+{
+ NTSTATUS ret = smb_register_vfs(SMB_VFS_INTERFACE_VERSION, \
+ "smb_traffic_analyzer", smb_traffic_analyzer_tuples);
+
+ if (!NT_STATUS_IS_OK(ret)) {
+ return ret;
+ }
+
+ vfs_smb_traffic_analyzer_debug_level =
+ debug_add_class("smb_traffic_analyzer");
+
+ if (vfs_smb_traffic_analyzer_debug_level == -1) {
+ vfs_smb_traffic_analyzer_debug_level = DBGC_VFS;
+ DEBUG(1, ("smb_traffic_analyzer_init: Couldn't register custom"
+ "debugging class!\n"));
+ } else {
+ DEBUG(3, ("smb_traffic_analyzer_init: Debug class number of"
+ "'smb_traffic_analyzer': %d\n", \
+ vfs_smb_traffic_analyzer_debug_level));
+ }
+
+ return ret;
+}
blob = data_blob_const(data->dptr, data->dsize);
ndr_err = ndr_pull_struct_blob(
- &blob, result, result,
+ &blob, result, NULL, result,
(ndr_pull_flags_fn_t)ndr_pull_tdb_xattrs);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
enum ndr_err_code ndr_err;
ndr_err = ndr_push_struct_blob(
- &blob, mem_ctx, attribs,
+ &blob, mem_ctx, NULL, attribs,
(ndr_push_flags_fn_t)ndr_push_tdb_xattrs);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
*/
static NTSTATUS zfs_set_nt_acl(vfs_handle_struct *handle, files_struct *fsp,
uint32 security_info_sent,
- struct security_descriptor *psd)
+ const struct security_descriptor *psd)
{
return smb_set_nt_acl_nfs4(fsp, security_info_sent, psd,
zfs_process_smbacl);
static NTSTATUS zfsacl_fset_nt_acl(vfs_handle_struct *handle,
files_struct *fsp,
uint32 security_info_sent,
- SEC_DESC *psd)
+ const SEC_DESC *psd)
{
return zfs_set_nt_acl(handle, fsp, security_info_sent, psd);
}
break;
}
- case QUERYFORPDC:
+ case LOGON_PRIMARY_QUERY:
{
fstring mach_str, getdc_str;
fstring source_name;
/* Construct reply. */
q = outbuf;
- SSVAL(q, 0, QUERYFORPDC_R);
+ SSVAL(q, 0, NETLOGON_RESPONSE_FROM_PDC);
q += 2;
fstrcpy(reply_name,my_name);
DEBUG(5,("process_logon_packet: GETDC request from %s at IP %s, \
reporting %s domain %s 0x%x ntversion=%x lm_nt token=%x lm_20 token=%x\n",
mach_str,inet_ntoa(p->ip), reply_name, lp_workgroup(),
- QUERYFORPDC_R, (uint32)ntversion, (uint32)lmnttoken,
+ NETLOGON_RESPONSE_FROM_PDC, (uint32)ntversion, (uint32)lmnttoken,
(uint32)lm20token ));
dump_data(4, (uint8 *)outbuf, PTR_DIFF(q, outbuf));
return;
}
- case SAMLOGON:
+ case LOGON_SAM_LOGON_REQUEST:
{
fstring getdc_str;
domainsidsize = IVAL(q, 0);
q += 4;
- DEBUG(5,("process_logon_packet: SAMLOGON sidsize %d, len = %d\n", domainsidsize, len));
+ DEBUG(5,("process_logon_packet: LOGON_SAM_LOGON_REQUEST sidsize %d, len = %d\n", domainsidsize, len));
if (domainsidsize < (len - PTR_DIFF(q, buf)) && (domainsidsize != 0)) {
q += domainsidsize;
lm20token = SVAL(q, 6);
q += 8;
- DEBUG(3,("process_logon_packet: SAMLOGON sidsize %d ntv %d\n", domainsidsize, ntversion));
+ DEBUG(3,("process_logon_packet: LOGON_SAM_LOGON_REQUEST sidsize %d ntv %d\n", domainsidsize, ntversion));
/*
* we respond regadless of whether the machine is in our password
*/
pull_ucs2_fstring(ascuser, uniuser);
pull_ucs2_fstring(asccomp, unicomp);
- DEBUG(5,("process_logon_packet: SAMLOGON user %s\n", ascuser));
+ DEBUG(5,("process_logon_packet: LOGON_SAM_LOGON_REQUEST user %s\n", ascuser));
fstrcpy(reply_name, "\\\\"); /* Here it wants \\LOGONSERVER. */
fstrcat(reply_name, my_name);
- DEBUG(5,("process_logon_packet: SAMLOGON request from %s(%s) for %s, returning logon svr %s domain %s code %x token=%x\n",
+ DEBUG(5,("process_logon_packet: LOGON_SAM_LOGON_REQUEST request from %s(%s) for %s, returning logon svr %s domain %s code %x token=%x\n",
asccomp,inet_ntoa(p->ip), ascuser, reply_name, lp_workgroup(),
- SAMLOGON_R ,lmnttoken));
+ LOGON_SAM_LOGON_RESPONSE ,lmnttoken));
/* Construct reply. */
/* never, at least for now */
if ((ntversion < 11) || (SEC_ADS != lp_security()) || (ROLE_DOMAIN_PDC != lp_server_role())) {
if (SVAL(uniuser, 0) == 0) {
- SSVAL(q, 0, SAMLOGON_UNK_R); /* user unknown */
+ SSVAL(q, 0, LOGON_SAM_LOGON_USER_UNKNOWN); /* user unknown */
} else {
- SSVAL(q, 0, SAMLOGON_R);
+ SSVAL(q, 0, LOGON_SAM_LOGON_RESPONSE);
}
q += 2;
return;
}
if (SVAL(uniuser, 0) == 0) {
- SIVAL(q, 0, SAMLOGON_AD_UNK_R); /* user unknown */
+ SIVAL(q, 0, LOGON_SAM_LOGON_USER_UNKNOWN_EX); /* user unknown */
} else {
- SIVAL(q, 0, SAMLOGON_AD_R);
+ SIVAL(q, 0, LOGON_SAM_LOGON_RESPONSE_EX);
}
q += 4;
/* Announce change to UAS or SAM. Send by the domain controller when a
replication event is required. */
- case SAM_UAS_CHANGE:
- DEBUG(5, ("Got SAM_UAS_CHANGE\n"));
+ case NETLOGON_ANNOUNCE_UAS:
+ DEBUG(5, ("Got NETLOGON_ANNOUNCE_UAS\n"));
break;
default:
--- /dev/null
+/*
+ Unix SMB/CIFS implementation.
+
+ Winbind client API
+
+ Copyright (C) Gerald (Jerry) Carter 2007
+
+
+ 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
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/* Required Headers */
+
+#include "libwbclient.h"
+
+/** @brief Convert a binary GUID to a character string
+ *
+ * @param guid Binary Guid
+ * @param **guid_string Resulting character string
+ *
+ * @return #wbcErr
+ **/
+
+wbcErr wbcGuidToString(const struct wbcGuid *guid,
+ char **guid_string)
+{
+ wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
+
+ if (!guid) {
+ wbc_status = WBC_ERR_INVALID_PARAM;
+ BAIL_ON_WBC_ERROR(wbc_status);
+ }
+
+ *guid_string = talloc_asprintf(NULL,
+ "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
+ guid->time_low, guid->time_mid,
+ guid->time_hi_and_version,
+ guid->clock_seq[0],
+ guid->clock_seq[1],
+ guid->node[0], guid->node[1],
+ guid->node[2], guid->node[3],
+ guid->node[4], guid->node[5]);
+ BAIL_ON_PTR_ERROR((*guid_string), wbc_status);
+
+ wbc_status = WBC_ERR_SUCCESS;
+
+done:
+ return wbc_status;
+}
+
+/** @brief Convert a character string to a binary GUID
+ *
+ * @param *str Character string
+ * @param guid Resulting binary GUID
+ *
+ * @return #wbcErr
+ **/
+
+wbcErr wbcStringToGuid(const char *str,
+ struct wbcGuid *guid)
+{
+ uint32_t time_low;
+ uint32_t time_mid, time_hi_and_version;
+ uint32_t clock_seq[2];
+ uint32_t node[6];
+ int i;
+ wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
+
+ if (!guid) {
+ wbc_status = WBC_ERR_INVALID_PARAM;
+ BAIL_ON_WBC_ERROR(wbc_status);
+ }
+
+ if (!str) {
+ wbc_status = WBC_ERR_INVALID_PARAM;
+ BAIL_ON_WBC_ERROR(wbc_status);
+ }
+
+ if (11 == sscanf(str, "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
+ &time_low, &time_mid, &time_hi_and_version,
+ &clock_seq[0], &clock_seq[1],
+ &node[0], &node[1], &node[2], &node[3], &node[4], &node[5])) {
+ wbc_status = WBC_ERR_SUCCESS;
+ } else if (11 == sscanf(str, "{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
+ &time_low, &time_mid, &time_hi_and_version,
+ &clock_seq[0], &clock_seq[1],
+ &node[0], &node[1], &node[2], &node[3], &node[4], &node[5])) {
+ wbc_status = WBC_ERR_SUCCESS;
+ }
+
+ BAIL_ON_WBC_ERROR(wbc_status);
+
+ guid->time_low = time_low;
+ guid->time_mid = time_mid;
+ guid->time_hi_and_version = time_hi_and_version;
+ guid->clock_seq[0] = clock_seq[0];
+ guid->clock_seq[1] = clock_seq[1];
+
+ for (i=0;i<6;i++) {
+ guid->node[i] = node[i];
+ }
+
+ wbc_status = WBC_ERR_SUCCESS;
+
+done:
+ return wbc_status;
+}
/** @brief Set the highwater mark for allocated gids.
*
- * @param uid_hwm The new gid highwater mark value
+ * @param gid_hwm The new gid highwater mark value
*
* @return #wbcErr
**/
Winbind client API
Copyright (C) Gerald (Jerry) Carter 2007
+ Copyright (C) Guenther Deschner 2008
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
return wbc_status;
}
+static wbcErr wbc_create_logon_info(TALLOC_CTX *mem_ctx,
+ const struct winbindd_response *resp,
+ struct wbcLogonUserInfo **_i)
+{
+ wbcErr wbc_status = WBC_ERR_SUCCESS;
+ struct wbcLogonUserInfo *i;
+
+ i = talloc_zero(mem_ctx, struct wbcLogonUserInfo);
+ BAIL_ON_PTR_ERROR(i, wbc_status);
+
+ wbc_status = wbc_create_auth_info(i, resp, &i->info);
+ BAIL_ON_WBC_ERROR(wbc_status);
+
+ if (resp->data.auth.krb5ccname) {
+ wbc_status = wbcAddNamedBlob(&i->num_blobs,
+ &i->blobs,
+ "krb5ccname",
+ 0,
+ (uint8_t *)resp->data.auth.krb5ccname,
+ strlen(resp->data.auth.krb5ccname)+1);
+ BAIL_ON_WBC_ERROR(wbc_status);
+ }
+
+ if (resp->data.auth.unix_username) {
+ wbc_status = wbcAddNamedBlob(&i->num_blobs,
+ &i->blobs,
+ "unix_username",
+ 0,
+ (uint8_t *)resp->data.auth.unix_username,
+ strlen(resp->data.auth.unix_username)+1);
+ BAIL_ON_WBC_ERROR(wbc_status);
+ }
+
+ *_i = i;
+ i = NULL;
+done:
+ if (!WBC_ERROR_IS_OK(wbc_status) && i) {
+ wbcFreeMemory(i->blobs);
+ }
+
+ talloc_free(i);
+ return wbc_status;
+}
+
/** @brief Authenticate with more detailed information
*
* @param params Input parameters, WBC_AUTH_USER_LEVEL_HASH
params->account_name,
sizeof(request.data.auth.user)-1);
}
+
strncpy(request.data.auth.pass,
params->password.plaintext,
sizeof(request.data.auth.pass)-1);
BAIL_ON_WBC_ERROR(wbc_status);
}
+ if (params->flags) {
+ request.flags |= params->flags;
+ }
+
wbc_status = wbcRequestResponse(cmd,
&request,
&response);
return wbc_status;
}
+/** @brief Trigger an extended logoff notification to Winbind for a specific user
+ *
+ * @param params A wbcLogoffUserParams structure
+ * @param error User output details on error
+ *
+ * @return #wbcErr
+ *
+ **/
+
+wbcErr wbcLogoffUserEx(const struct wbcLogoffUserParams *params,
+ struct wbcAuthErrorInfo **error)
+{
+ struct winbindd_request request;
+ struct winbindd_response response;
+ wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
+ int i;
+
+ /* validate input */
+
+ if (!params || !params->username) {
+ wbc_status = WBC_ERR_INVALID_PARAM;
+ BAIL_ON_WBC_ERROR(wbc_status);
+ }
+
+ if ((params->num_blobs > 0) && (params->blobs == NULL)) {
+ wbc_status = WBC_ERR_INVALID_PARAM;
+ BAIL_ON_WBC_ERROR(wbc_status);
+ }
+ if ((params->num_blobs == 0) && (params->blobs != NULL)) {
+ wbc_status = WBC_ERR_INVALID_PARAM;
+ BAIL_ON_WBC_ERROR(wbc_status);
+ }
+
+ ZERO_STRUCT(request);
+ ZERO_STRUCT(response);
+
+ strncpy(request.data.logoff.user, params->username,
+ sizeof(request.data.logoff.user)-1);
+
+ for (i=0; i<params->num_blobs; i++) {
+
+ if (strcasecmp(params->blobs[i].name, "ccfilename") == 0) {
+ if (params->blobs[i].blob.data) {
+ strncpy(request.data.logoff.krb5ccname,
+ (const char *)params->blobs[i].blob.data,
+ sizeof(request.data.logoff.krb5ccname) - 1);
+ }
+ continue;
+ }
+
+ if (strcasecmp(params->blobs[i].name, "user_uid") == 0) {
+ if (params->blobs[i].blob.data) {
+ memcpy(&request.data.logoff.uid,
+ params->blobs[i].blob.data,
+ MIN(params->blobs[i].blob.length,
+ sizeof(request.data.logoff.uid)));
+ }
+ continue;
+ }
+
+ if (strcasecmp(params->blobs[i].name, "flags") == 0) {
+ if (params->blobs[i].blob.data) {
+ memcpy(&request.flags,
+ params->blobs[i].blob.data,
+ MIN(params->blobs[i].blob.length,
+ sizeof(request.flags)));
+ }
+ continue;
+ }
+ }
+
+ /* Send request */
+
+ wbc_status = wbcRequestResponse(WINBINDD_PAM_LOGOFF,
+ &request,
+ &response);
+
+ /* Take the response above and return it to the caller */
+ if (response.data.auth.nt_status != 0) {
+ if (error) {
+ wbc_status = wbc_create_error_info(NULL,
+ &response,
+ error);
+ BAIL_ON_WBC_ERROR(wbc_status);
+ }
+
+ wbc_status = WBC_ERR_AUTH_ERROR;
+ BAIL_ON_WBC_ERROR(wbc_status);
+ }
+ BAIL_ON_WBC_ERROR(wbc_status);
+
+ done:
+ return wbc_status;
+}
+
/** @brief Trigger a logoff notification to Winbind for a specific user
*
* @param username Name of user to remove from Winbind's list of
done:
return wbc_status;
}
+
+/** @brief Logon a User
+ *
+ * @param[in] params Pointer to a wbcLogonUserParams structure
+ * @param[out] info Pointer to a pointer to a wbcLogonUserInfo structure
+ * @param[out] error Pointer to a pointer to a wbcAuthErrorInfo structure
+ * @param[out] policy Pointer to a pointer to a wbcUserPasswordPolicyInfo structure
+ *
+ * @return #wbcErr
+ *
+ **/
+
+wbcErr wbcLogonUser(const struct wbcLogonUserParams *params,
+ struct wbcLogonUserInfo **info,
+ struct wbcAuthErrorInfo **error,
+ struct wbcUserPasswordPolicyInfo **policy)
+{
+ wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
+ int cmd = 0;
+ struct winbindd_request request;
+ struct winbindd_response response;
+ uint32_t i;
+
+ ZERO_STRUCT(request);
+ ZERO_STRUCT(response);
+
+ if (info) {
+ *info = NULL;
+ }
+ if (error) {
+ *error = NULL;
+ }
+ if (policy) {
+ *policy = NULL;
+ }
+
+ if (!params) {
+ wbc_status = WBC_ERR_INVALID_PARAM;
+ BAIL_ON_WBC_ERROR(wbc_status);
+ }
+
+ if (!params->username) {
+ wbc_status = WBC_ERR_INVALID_PARAM;
+ BAIL_ON_WBC_ERROR(wbc_status);
+ }
+
+ if ((params->num_blobs > 0) && (params->blobs == NULL)) {
+ wbc_status = WBC_ERR_INVALID_PARAM;
+ BAIL_ON_WBC_ERROR(wbc_status);
+ }
+ if ((params->num_blobs == 0) && (params->blobs != NULL)) {
+ wbc_status = WBC_ERR_INVALID_PARAM;
+ BAIL_ON_WBC_ERROR(wbc_status);
+ }
+
+ /* Initialize request */
+
+ cmd = WINBINDD_PAM_AUTH;
+ request.flags = WBFLAG_PAM_INFO3_TEXT |
+ WBFLAG_PAM_USER_SESSION_KEY |
+ WBFLAG_PAM_LMKEY;
+
+ if (!params->password) {
+ wbc_status = WBC_ERR_INVALID_PARAM;
+ BAIL_ON_WBC_ERROR(wbc_status);
+ }
+
+ strncpy(request.data.auth.user,
+ params->username,
+ sizeof(request.data.auth.user)-1);
+
+ strncpy(request.data.auth.pass,
+ params->password,
+ sizeof(request.data.auth.pass)-1);
+
+ for (i=0; i<params->num_blobs; i++) {
+
+ if (strcasecmp(params->blobs[i].name, "krb5_cc_type") == 0) {
+ if (params->blobs[i].blob.data) {
+ strncpy(request.data.auth.krb5_cc_type,
+ (const char *)params->blobs[i].blob.data,
+ sizeof(request.data.auth.krb5_cc_type) - 1);
+ }
+ continue;
+ }
+
+ if (strcasecmp(params->blobs[i].name, "user_uid") == 0) {
+ if (params->blobs[i].blob.data) {
+ memcpy(&request.data.auth.uid,
+ params->blobs[i].blob.data,
+ MIN(sizeof(request.data.auth.uid),
+ params->blobs[i].blob.length));
+ }
+ continue;
+ }
+
+ if (strcasecmp(params->blobs[i].name, "flags") == 0) {
+ if (params->blobs[i].blob.data) {
+ uint32_t flags;
+ memcpy(&flags,
+ params->blobs[i].blob.data,
+ MIN(sizeof(flags),
+ params->blobs[i].blob.length));
+ request.flags |= flags;
+ }
+ continue;
+ }
+
+ if (strcasecmp(params->blobs[i].name, "membership_of") == 0) {
+ if (params->blobs[i].blob.data &&
+ params->blobs[i].blob.data[0] > 0) {
+ strncpy(request.data.auth.require_membership_of_sid,
+ (const char *)params->blobs[i].blob.data,
+ sizeof(request.data.auth.require_membership_of_sid) - 1);
+ }
+ continue;
+ }
+ }
+
+ wbc_status = wbcRequestResponse(cmd,
+ &request,
+ &response);
+
+ if (response.data.auth.nt_status != 0) {
+ if (error) {
+ wbc_status = wbc_create_error_info(NULL,
+ &response,
+ error);
+ BAIL_ON_WBC_ERROR(wbc_status);
+ }
+
+ wbc_status = WBC_ERR_AUTH_ERROR;
+ BAIL_ON_WBC_ERROR(wbc_status);
+ }
+ BAIL_ON_WBC_ERROR(wbc_status);
+
+ if (info) {
+ wbc_status = wbc_create_logon_info(NULL,
+ &response,
+ info);
+ BAIL_ON_WBC_ERROR(wbc_status);
+ }
+
+ if (policy) {
+ wbc_status = wbc_create_password_policy_info(NULL,
+ &response,
+ policy);
+ BAIL_ON_WBC_ERROR(wbc_status);
+ }
+
+done:
+ if (response.extra_data.data)
+ free(response.extra_data.data);
+
+ return wbc_status;
+}
*
* @param *account The given user name
* @param *num_groups Number of elements returned in the groups array
- * @param **groups Pointer to resulting gid_t array.
+ * @param **_groups Pointer to resulting gid_t array.
*
* @return #wbcErr
**/
/** @brief Convert a SID to a domain and name
*
* @param *sid Pointer to the domain SID to be resolved
- * @param domain Resolved Domain name (possibly "")
- * @param name Resolved User or group name
- * @param *name_type Pointet to the resolved SID type
+ * @param pdomain Resolved Domain name (possibly "")
+ * @param pname Resolved User or group name
+ * @param *pname_type Pointet to the resolved SID type
*
* @return #wbcErr
*
/** @brief Enumerate the domain trusts known by Winbind
*
* @param domain Name of the domain to query for a DC
- * @flags Bit flags used to control the domain location query
+ * @param flags Bit flags used to control the domain location query
* @param *dc_info Pointer to the returned domain controller information
*
* @return #wbcErr
return wbc_status;
}
+
+static wbcErr wbc_create_domain_controller_info_ex(TALLOC_CTX *mem_ctx,
+ const struct winbindd_response *resp,
+ struct wbcDomainControllerInfoEx **_i)
+{
+ wbcErr wbc_status = WBC_ERR_SUCCESS;
+ struct wbcDomainControllerInfoEx *i;
+ struct wbcGuid guid;
+
+ i = talloc(mem_ctx, struct wbcDomainControllerInfoEx);
+ BAIL_ON_PTR_ERROR(i, wbc_status);
+
+ i->dc_unc = talloc_strdup(i, resp->data.dsgetdcname.dc_unc);
+ BAIL_ON_PTR_ERROR(i->dc_unc, wbc_status);
+
+ i->dc_address = talloc_strdup(i, resp->data.dsgetdcname.dc_address);
+ BAIL_ON_PTR_ERROR(i->dc_address, wbc_status);
+
+ i->dc_address_type = resp->data.dsgetdcname.dc_address_type;
+
+ wbc_status = wbcStringToGuid(resp->data.dsgetdcname.domain_guid, &guid);
+ if (WBC_ERROR_IS_OK(wbc_status)) {
+ i->domain_guid = talloc(i, struct wbcGuid);
+ BAIL_ON_PTR_ERROR(i->domain_guid, wbc_status);
+
+ *i->domain_guid = guid;
+ } else {
+ i->domain_guid = NULL;
+ }
+
+ i->domain_name = talloc_strdup(i, resp->data.dsgetdcname.domain_name);
+ BAIL_ON_PTR_ERROR(i->domain_name, wbc_status);
+
+ if (resp->data.dsgetdcname.forest_name[0] != '\0') {
+ i->forest_name = talloc_strdup(i,
+ resp->data.dsgetdcname.forest_name);
+ BAIL_ON_PTR_ERROR(i->forest_name, wbc_status);
+ } else {
+ i->forest_name = NULL;
+ }
+
+ i->dc_flags = resp->data.dsgetdcname.dc_flags;
+
+ if (resp->data.dsgetdcname.dc_site_name[0] != '\0') {
+ i->dc_site_name = talloc_strdup(i,
+ resp->data.dsgetdcname.dc_site_name);
+ BAIL_ON_PTR_ERROR(i->dc_site_name, wbc_status);
+ } else {
+ i->dc_site_name = NULL;
+ }
+
+ if (resp->data.dsgetdcname.client_site_name[0] != '\0') {
+ i->client_site_name = talloc_strdup(i,
+ resp->data.dsgetdcname.client_site_name);
+ BAIL_ON_PTR_ERROR(i->client_site_name, wbc_status);
+ } else {
+ i->client_site_name = NULL;
+ }
+
+ *_i = i;
+ i = NULL;
+
+done:
+ talloc_free(i);
+ return wbc_status;
+}
+
+/** @brief Get extended domain controller information
+ *
+ * @param domain Name of the domain to query for a DC
+ * @param guid Guid of the domain to query for a DC
+ * @param site Site of the domain to query for a DC
+ * @param flags Bit flags used to control the domain location query
+ * @param *dc_info Pointer to the returned extended domain controller information
+ *
+ * @return #wbcErr
+ *
+ **/
+
+wbcErr wbcLookupDomainControllerEx(const char *domain,
+ struct wbcGuid *guid,
+ const char *site,
+ uint32_t flags,
+ struct wbcDomainControllerInfoEx **dc_info)
+{
+ wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
+ struct winbindd_request request;
+ struct winbindd_response response;
+
+ /* validate input params */
+
+ if (!domain || !dc_info) {
+ wbc_status = WBC_ERR_INVALID_PARAM;
+ BAIL_ON_WBC_ERROR(wbc_status);
+ }
+
+ ZERO_STRUCT(request);
+ ZERO_STRUCT(response);
+
+ request.data.dsgetdcname.flags = flags;
+
+ strncpy(request.data.dsgetdcname.domain_name, domain,
+ sizeof(request.data.dsgetdcname.domain_name)-1);
+
+ if (site) {
+ strncpy(request.data.dsgetdcname.site_name, site,
+ sizeof(request.data.dsgetdcname.site_name)-1);
+ }
+
+ if (guid) {
+ char *str = NULL;
+
+ wbc_status = wbcGuidToString(guid, &str);
+ BAIL_ON_WBC_ERROR(wbc_status);
+
+ strncpy(request.data.dsgetdcname.domain_guid, str,
+ sizeof(request.data.dsgetdcname.domain_guid)-1);
+
+ wbcFreeMemory(str);
+ }
+
+ /* Send request */
+
+ wbc_status = wbcRequestResponse(WINBINDD_DSGETDCNAME,
+ &request,
+ &response);
+ BAIL_ON_WBC_ERROR(wbc_status);
+
+ if (dc_info) {
+ wbc_status = wbc_create_domain_controller_info_ex(NULL,
+ &response,
+ dc_info);
+ BAIL_ON_WBC_ERROR(wbc_status);
+ }
+
+ wbc_status = WBC_ERR_SUCCESS;
+done:
+ return wbc_status;
+}
+
+/** @brief Initialize a named blob and add to list of blobs
+ *
+ * @param[in,out] num_blobs Pointer to the number of blobs
+ * @param[in,out] blobs Pointer to an array of blobs
+ * @param[in] name Name of the new named blob
+ * @param[in] flags Flags of the new named blob
+ * @param[in] data Blob data of new blob
+ * @param[in] length Blob data length of new blob
+ *
+ * @return #wbcErr
+ *
+ **/
+
+wbcErr wbcAddNamedBlob(size_t *num_blobs,
+ struct wbcNamedBlob **blobs,
+ const char *name,
+ uint32_t flags,
+ uint8_t *data,
+ size_t length)
+{
+ wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
+ struct wbcNamedBlob blob;
+
+ *blobs = talloc_realloc(NULL, *blobs, struct wbcNamedBlob,
+ *(num_blobs)+1);
+ BAIL_ON_PTR_ERROR(*blobs, wbc_status);
+
+ blob.name = talloc_strdup(*blobs, name);
+ BAIL_ON_PTR_ERROR(blob.name, wbc_status);
+ blob.flags = flags;
+ blob.blob.length = length;
+ blob.blob.data = (uint8_t *)talloc_memdup(*blobs, data, length);
+ BAIL_ON_PTR_ERROR(blob.blob.data, wbc_status);
+
+ (*(blobs))[*num_blobs] = blob;
+ *(num_blobs) += 1;
+
+ wbc_status = WBC_ERR_SUCCESS;
+done:
+ if (!WBC_ERROR_IS_OK(wbc_status) && blobs) {
+ wbcFreeMemory(*blobs);
+ }
+ return wbc_status;
+}
#define WBC_SID_ATTR_GROUP_RESOURCE 0x20000000
#define WBC_SID_ATTR_GROUP_LOGON_ID 0xC0000000
+/**
+ * @brief Windows GUID
+ *
+ **/
+
+struct wbcGuid {
+ uint32_t time_low;
+ uint16_t time_mid;
+ uint16_t time_hi_and_version;
+ uint8_t clock_seq[2];
+ uint8_t node[6];
+};
+
/**
* @brief Domain Information
**/
} password;
};
+/**
+ * @brief Generic Blob
+ **/
+
+struct wbcBlob {
+ uint8_t *data;
+ size_t length;
+};
+
+/**
+ * @brief Named Blob
+ **/
+
+struct wbcNamedBlob {
+ const char *name;
+ uint32_t flags;
+ struct wbcBlob blob;
+};
+
+/**
+ * @brief Logon User Parameters
+ **/
+
+struct wbcLogonUserParams {
+ const char *username;
+ const char *password;
+ size_t num_blobs;
+ struct wbcNamedBlob *blobs;
+};
+
/**
* @brief ChangePassword Parameters
**/
struct wbcSidWithAttr *sids;
};
+/**
+ * @brief Logon User Information
+ *
+ * Some of the strings are maybe NULL
+ **/
+
+struct wbcLogonUserInfo {
+ struct wbcAuthUserInfo *info;
+ size_t num_blobs;
+ struct wbcNamedBlob *blobs;
+};
+
/* wbcAuthUserInfo->user_flags */
#define WBC_AUTH_USER_INFO_GUEST 0x00000001
WBC_PWD_CHANGE_REJECT_COMPLEXITY=5
};
+/**
+ * @brief Logoff User Parameters
+ **/
+
+struct wbcLogoffUserParams {
+ const char *username;
+ size_t num_blobs;
+ struct wbcNamedBlob *blobs;
+};
+
/*
* DomainControllerInfo struct
*/
char *dc_name;
};
-
+/*
+ * DomainControllerInfoEx struct
+ */
+struct wbcDomainControllerInfoEx {
+ const char *dc_unc;
+ const char *dc_address;
+ uint16_t dc_address_type;
+ struct wbcGuid *domain_guid;
+ const char *domain_name;
+ const char *forest_name;
+ uint32_t dc_flags;
+ const char *dc_site_name;
+ const char *client_site_name;
+};
/*
* Memory Management
wbcErr wbcStringToSid(const char *sid_string,
struct wbcDomainSid *sid);
+/*
+ * Utility functions for dealing with GUIDs
+ */
+
+wbcErr wbcGuidToString(const struct wbcGuid *guid,
+ char **guid_string);
+
+wbcErr wbcStringToGuid(const char *guid_string,
+ struct wbcGuid *guid);
+
wbcErr wbcPing(void);
wbcErr wbcLibraryDetails(struct wbcLibraryDetails **details);
uint32_t flags,
struct wbcDomainControllerInfo **dc_info);
+wbcErr wbcLookupDomainControllerEx(const char *domain,
+ struct wbcGuid *guid,
+ const char *site,
+ uint32_t flags,
+ struct wbcDomainControllerInfoEx **dc_info);
+
/*
* Athenticate functions
*/
struct wbcAuthUserInfo **info,
struct wbcAuthErrorInfo **error);
+wbcErr wbcLogonUser(const struct wbcLogonUserParams *params,
+ struct wbcLogonUserInfo **info,
+ struct wbcAuthErrorInfo **error,
+ struct wbcUserPasswordPolicyInfo **policy);
+
wbcErr wbcLogoffUser(const char *username,
uid_t uid,
const char *ccfilename);
+wbcErr wbcLogoffUserEx(const struct wbcLogoffUserParams *params,
+ struct wbcAuthErrorInfo **error);
+
wbcErr wbcChangeUserPassword(const char *username,
const char *old_password,
const char *new_password);
*/
wbcErr wbcCheckTrustCredentials(const char *domain,
struct wbcAuthErrorInfo **error);
-
+/*
+ * Helper functions
+ */
+wbcErr wbcAddNamedBlob(size_t *num_blobs,
+ struct wbcNamedBlob **blobs,
+ const char *name,
+ uint32_t flags,
+ uint8_t *data,
+ size_t length);
#endif /* _WBCLIENT_H */
#include "pam_winbind.h"
+static int wbc_error_to_pam_error(wbcErr status)
+{
+ switch (status) {
+ case WBC_ERR_SUCCESS:
+ return PAM_SUCCESS;
+ case WBC_ERR_NOT_IMPLEMENTED:
+ return PAM_SERVICE_ERR;
+ case WBC_ERR_UNKNOWN_FAILURE:
+ break;
+ case WBC_ERR_NO_MEMORY:
+ return PAM_BUF_ERR;
+ case WBC_ERR_INVALID_SID:
+ case WBC_ERR_INVALID_PARAM:
+ break;
+ case WBC_ERR_WINBIND_NOT_AVAILABLE:
+ return PAM_AUTHINFO_UNAVAIL;
+ case WBC_ERR_DOMAIN_NOT_FOUND:
+ return PAM_AUTHINFO_UNAVAIL;
+ case WBC_ERR_INVALID_RESPONSE:
+ return PAM_BUF_ERR;
+ case WBC_ERR_NSS_ERROR:
+ return PAM_USER_UNKNOWN;
+ case WBC_ERR_AUTH_ERROR:
+ return PAM_AUTH_ERR;
+ case WBC_ERR_UNKNOWN_USER:
+ return PAM_USER_UNKNOWN;
+ case WBC_ERR_UNKNOWN_GROUP:
+ return PAM_USER_UNKNOWN;
+ case WBC_ERR_PWD_CHANGE_FAILED:
+ break;
+ }
+
+ /* be paranoid */
+ return PAM_AUTH_ERR;
+}
+
static const char *_pam_error_code_str(int err)
{
switch (err) {
return "PAM_ABORT";
case PAM_AUTHTOK_EXPIRED:
return "PAM_AUTHTOK_EXPIRED";
+#ifdef PAM_MODULE_UNKNOWN
case PAM_MODULE_UNKNOWN:
return "PAM_MODULE_UNKNOWN";
+#endif
+#ifdef PAM_BAD_ITEM
case PAM_BAD_ITEM:
return "PAM_BAD_ITEM";
+#endif
+#ifdef PAM_CONV_AGAIN
case PAM_CONV_AGAIN:
return "PAM_CONV_AGAIN";
+#endif
+#ifdef PAM_INCOMPLETE
case PAM_INCOMPLETE:
return "PAM_INCOMPLETE";
+#endif
default:
return NULL;
}
ctrl |= WINBIND_WARN_PWD_EXPIRE;
}
+ if (iniparser_getboolean(d, "global:mkhomedir", false)) {
+ ctrl |= WINBIND_MKHOMEDIR;
+ }
+
config_from_pam:
/* step through arguments */
for (i=argc,v=argv; i-- > 0; ++v) {
ctrl |= WINBIND_KRB5_CCACHE_TYPE;
else if (!strcasecmp(*v, "cached_login"))
ctrl |= WINBIND_CACHED_LOGIN;
+ else if (!strcasecmp(*v, "mkhomedir"))
+ ctrl |= WINBIND_MKHOMEDIR;
else {
__pam_log(pamh, ctrl, LOG_ERR,
"pam_parse: unknown option: %s", *v);
return ctrl;
};
-static void _pam_winbind_free_context(struct pwb_context *ctx)
+static int _pam_winbind_free_context(struct pwb_context *ctx)
{
+ if (!ctx) {
+ return 0;
+ }
+
if (ctx->dict) {
iniparser_freedict(ctx->dict);
}
- SAFE_FREE(ctx);
+ return 0;
}
static int _pam_winbind_init_context(pam_handle_t *pamh,
{
struct pwb_context *r = NULL;
- r = (struct pwb_context *)malloc(sizeof(struct pwb_context));
+ r = TALLOC_ZERO_P(NULL, struct pwb_context);
if (!r) {
return PAM_BUF_ERR;
}
- ZERO_STRUCTP(r);
+ talloc_set_destructor(r, _pam_winbind_free_context);
r->pamh = pamh;
r->flags = flags;
r->argv = argv;
r->ctrl = _pam_parse(pamh, flags, argc, argv, &r->dict);
if (r->ctrl == -1) {
- _pam_winbind_free_context(r);
+ TALLOC_FREE(r);
return PAM_SYSTEM_ERR;
}
"(error_status = %d)", pamh, data,
error_status);
}
- SAFE_FREE(data);
+ TALLOC_FREE(data);
}
return ret;
}
-static int pam_winbind_request(struct pwb_context *ctx,
- enum winbindd_cmd req_type,
- struct winbindd_request *request,
- struct winbindd_response *response)
-{
- /* Fill in request and send down pipe */
- winbindd_init_request(request, req_type);
-
- if (winbind_write_sock(request, sizeof(*request), 0, 0) == -1) {
- _pam_log(ctx, LOG_ERR,
- "pam_winbind_request: write to socket failed!");
- winbind_close_sock();
- return PAM_SERVICE_ERR;
- }
-
- /* Wait for reply */
- if (winbindd_read_reply(response) == -1) {
- _pam_log(ctx, LOG_ERR,
- "pam_winbind_request: read from socket failed!");
- winbind_close_sock();
- return PAM_SERVICE_ERR;
- }
-
- /* We are done with the socket - close it and avoid mischeif */
- winbind_close_sock();
-
- /* Copy reply data from socket */
- if (response->result == WINBINDD_OK) {
- return PAM_SUCCESS;
- }
-
- /* no need to check for pam_error codes for getpwnam() */
- switch (req_type) {
-
- case WINBINDD_GETPWNAM:
- case WINBINDD_LOOKUPNAME:
- if (strlen(response->data.auth.nt_status_string) > 0) {
- _pam_log(ctx, LOG_ERR,
- "request failed, NT error was %s",
- response->data.auth.nt_status_string);
- } else {
- _pam_log(ctx, LOG_ERR, "request failed");
- }
- return PAM_USER_UNKNOWN;
- default:
- break;
- }
-
- if (response->data.auth.pam_error != PAM_SUCCESS) {
- _pam_log(ctx, LOG_ERR,
- "request failed: %s, "
- "PAM error was %s (%d), NT error was %s",
- response->data.auth.error_string,
- pam_strerror(ctx->pamh, response->data.auth.pam_error),
- response->data.auth.pam_error,
- response->data.auth.nt_status_string);
- return response->data.auth.pam_error;
- }
-
- _pam_log(ctx, LOG_ERR, "request failed, but PAM error 0!");
-
- return PAM_SERVICE_ERR;
-}
-
static int pam_winbind_request_log(struct pwb_context *ctx,
- enum winbindd_cmd req_type,
- struct winbindd_request *request,
- struct winbindd_response *response,
- const char *user)
+ int retval,
+ const char *user,
+ const char *fn)
{
- int retval;
-
- retval = pam_winbind_request(ctx, req_type, request, response);
-
switch (retval) {
case PAM_AUTH_ERR:
/* incorrect password */
return retval;
case PAM_SUCCESS:
/* Otherwise, the authentication looked good */
- switch (req_type) {
- case WINBINDD_INFO:
- break;
- case WINBINDD_PAM_AUTH:
- _pam_log(ctx, LOG_NOTICE,
- "user '%s' granted access", user);
- break;
- case WINBINDD_PAM_CHAUTHTOK:
- _pam_log(ctx, LOG_NOTICE,
- "user '%s' password changed", user);
- break;
- default:
- _pam_log(ctx, LOG_NOTICE,
- "user '%s' OK", user);
- break;
+ if (strcmp(fn, "wbcLogonUser") == 0) {
+ _pam_log(ctx, LOG_NOTICE,
+ "user '%s' granted access", user);
+ } else {
+ _pam_log(ctx, LOG_NOTICE,
+ "user '%s' OK", user);
}
-
return retval;
default:
/* we don't know anything about this return value */
_pam_log(ctx, LOG_ERR,
- "internal module error (retval = %d, user = '%s')",
- retval, user);
+ "internal module error (retval = %s(%d), user = '%s')",
+ _pam_error_code_str(retval), retval, user);
return retval;
}
}
+static int wbc_auth_error_to_pam_error(struct pwb_context *ctx,
+ struct wbcAuthErrorInfo *e,
+ wbcErr status,
+ const char *username,
+ const char *fn)
+{
+ int ret = PAM_AUTH_ERR;
+
+ if (WBC_ERROR_IS_OK(status)) {
+ _pam_log_debug(ctx, LOG_DEBUG, "request %s succeeded",
+ fn);
+ ret = PAM_SUCCESS;
+ return pam_winbind_request_log(ctx, ret, username, fn);
+ }
+
+ if (e) {
+ if (e->pam_error != PAM_SUCCESS) {
+ _pam_log(ctx, LOG_ERR,
+ "request %s failed: %s, "
+ "PAM error: %s (%d), NTSTATUS: %s, "
+ "Error message was: %s",
+ fn,
+ wbcErrorString(status),
+ _pam_error_code_str(e->pam_error),
+ e->pam_error,
+ e->nt_string,
+ e->display_string);
+ ret = e->pam_error;
+ return pam_winbind_request_log(ctx, ret, username, fn);
+ }
+
+ _pam_log(ctx, LOG_ERR, "request %s failed, but PAM error 0!", fn);
+
+ ret = PAM_SERVICE_ERR;
+ return pam_winbind_request_log(ctx, ret, username, fn);
+ }
+
+ ret = wbc_error_to_pam_error(status);
+ return pam_winbind_request_log(ctx, ret, username, fn);
+}
+
+
/**
* send a password expiry message if required
*
*/
static void _pam_warn_password_expiry(struct pwb_context *ctx,
- const struct winbindd_response *response,
+ const struct wbcAuthUserInfo *info,
+ const struct wbcUserPasswordPolicyInfo *policy,
int warn_pwd_expire,
bool *already_expired)
{
time_t now = time(NULL);
time_t next_change = 0;
+ if (!info || !policy) {
+ return;
+ }
+
if (already_expired) {
*already_expired = false;
}
- /* accounts with ACB_PWNOEXP set never receive a warning */
- if (response->data.auth.info3.acct_flags & ACB_PWNOEXP) {
+ /* accounts with WBC_ACB_PWNOEXP set never receive a warning */
+ if (info->acct_flags & WBC_ACB_PWNOEXP) {
return;
}
/* no point in sending a warning if this is a grace logon */
- if (PAM_WB_GRACE_LOGON(response->data.auth.info3.user_flgs)) {
+ if (PAM_WB_GRACE_LOGON(info->user_flags)) {
return;
}
/* check if the info3 must change timestamp has been set */
- next_change = response->data.auth.info3.pass_must_change_time;
+ next_change = info->pass_must_change_time;
if (_pam_send_password_expiry_message(ctx, next_change, now,
warn_pwd_expire,
/* now check for the global password policy */
/* good catch from Ralf Haferkamp: an expiry of "never" is translated
* to -1 */
- if (response->data.auth.policy.expire <= 0) {
+ if (policy->expire <= 0) {
return;
}
- next_change = response->data.auth.info3.pass_last_set_time +
- response->data.auth.policy.expire;
+ next_change = info->pass_last_set_time + policy->expire;
if (_pam_send_password_expiry_message(ctx, next_change, now,
warn_pwd_expire,
int sid_list_buffer_size)
{
const char* sid_string;
- struct winbindd_response sid_response;
/* lookup name? */
if (IS_SID_STRING(name)) {
sid_string = name;
} else {
- struct winbindd_request sid_request;
-
- ZERO_STRUCT(sid_request);
- ZERO_STRUCT(sid_response);
+ wbcErr wbc_status;
+ struct wbcDomainSid sid;
+ enum wbcSidType type;
+ char *sid_str;
_pam_log_debug(ctx, LOG_DEBUG,
"no sid given, looking up: %s\n", name);
- /* fortunatly winbindd can handle non-separated names */
- strncpy(sid_request.data.name.name, name,
- sizeof(sid_request.data.name.name) - 1);
-
- if (pam_winbind_request_log(ctx, WINBINDD_LOOKUPNAME,
- &sid_request, &sid_response,
- user)) {
+ wbc_status = wbcLookupName("", name, &sid, &type);
+ if (!WBC_ERROR_IS_OK(wbc_status)) {
_pam_log(ctx, LOG_INFO,
"could not lookup name: %s\n", name);
return false;
}
- sid_string = sid_response.data.sid.sid;
+ wbc_status = wbcSidToString(&sid, &sid_str);
+ if (!WBC_ERROR_IS_OK(wbc_status)) {
+ return false;
+ }
+
+ wbcFreeMemory(sid_str);
+ sid_string = sid_str;
}
if (!safe_append_string(sid_list_buffer, sid_string,
*/
static void _pam_setup_krb5_env(struct pwb_context *ctx,
- const char *krb5ccname)
+ struct wbcLogonUserInfo *info)
{
char var[PATH_MAX];
int ret;
+ uint32_t i;
+ const char *krb5ccname = NULL;
if (off(ctx->ctrl, WINBIND_KRB5_AUTH)) {
return;
}
+ if (!info) {
+ return;
+ }
+
+ for (i=0; i < info->num_blobs; i++) {
+ if (strcasecmp(info->blobs[i].name, "krb5ccname") == 0) {
+ krb5ccname = (const char *)info->blobs[i].blob.data;
+ break;
+ }
+ }
+
if (!krb5ccname || (strlen(krb5ccname) == 0)) {
return;
}
}
}
+/**
+ * Copy unix username if available (further processed in PAM).
+ *
+ * @param ctx PAM winbind context
+ * @param user_ret A pointer that holds a pointer to a string
+ * @param unix_username A username
+ *
+ * @return void.
+ */
+
+static void _pam_setup_unix_username(struct pwb_context *ctx,
+ char **user_ret,
+ struct wbcLogonUserInfo *info)
+{
+ const char *unix_username = NULL;
+ uint32_t i;
+
+ if (!user_ret || !info) {
+ return;
+ }
+
+ for (i=0; i < info->num_blobs; i++) {
+ if (strcasecmp(info->blobs[i].name, "unix_username") == 0) {
+ unix_username = (const char *)info->blobs[i].blob.data;
+ break;
+ }
+ }
+
+ if (!unix_username || !unix_username[0]) {
+ return;
+ }
+
+ *user_ret = strdup(unix_username);
+}
+
/**
* Set string into the PAM stack.
*
return;
}
- ret = pam_set_data(ctx->pamh, data_name, (void *)strdup(value),
+ ret = pam_set_data(ctx->pamh, data_name, talloc_strdup(NULL, value),
_pam_winbind_cleanup_func);
if (ret) {
_pam_log_debug(ctx, LOG_DEBUG,
"Could not set data %s: %s\n",
data_name, pam_strerror(ctx->pamh, ret));
}
-
}
/**
*/
static void _pam_set_data_info3(struct pwb_context *ctx,
- struct winbindd_response *response)
+ const struct wbcAuthUserInfo *info)
{
_pam_set_data_string(ctx, PAM_WINBIND_HOMEDIR,
- response->data.auth.info3.home_dir);
+ info->home_directory);
_pam_set_data_string(ctx, PAM_WINBIND_LOGONSCRIPT,
- response->data.auth.info3.logon_script);
+ info->logon_script);
_pam_set_data_string(ctx, PAM_WINBIND_LOGONSERVER,
- response->data.auth.info3.logon_srv);
+ info->logon_server);
_pam_set_data_string(ctx, PAM_WINBIND_PROFILEPATH,
- response->data.auth.info3.profile_path);
+ info->profile_path);
}
/**
}
}
+static bool _pam_check_remark_auth_err(struct pwb_context *ctx,
+ const struct wbcAuthErrorInfo *e,
+ const char *nt_status_string,
+ int *pam_error)
+{
+ const char *ntstatus = NULL;
+ const char *error_string = NULL;
+
+ if (!e || !pam_error) {
+ return false;
+ }
+
+ ntstatus = e->nt_string;
+ if (!ntstatus) {
+ return false;
+ }
+
+ if (strcasecmp(ntstatus, nt_status_string) == 0) {
+
+ error_string = _get_ntstatus_error_string(nt_status_string);
+ if (error_string) {
+ _make_remark(ctx, PAM_ERROR_MSG, error_string);
+ *pam_error = e->pam_error;
+ return true;
+ }
+
+ if (e->display_string) {
+ _make_remark(ctx, PAM_ERROR_MSG, e->display_string);
+ *pam_error = e->pam_error;
+ return true;
+ }
+
+ _make_remark(ctx, PAM_ERROR_MSG, nt_status_string);
+ *pam_error = e->pam_error;
+
+ return true;
+ }
+
+ return false;
+};
+
/**
* Compose Password Restriction String for a PAM_ERROR_MSG conversation.
*
- * @param response The struct winbindd_response.
+ * @param i The wbcUserPasswordPolicyInfo struct.
*
- * @return string (caller needs to free).
+ * @return string (caller needs to talloc_free).
*/
-static char *_pam_compose_pwd_restriction_string(struct winbindd_response *response)
+static char *_pam_compose_pwd_restriction_string(struct pwb_context *ctx,
+ struct wbcUserPasswordPolicyInfo *i)
{
char *str = NULL;
- size_t offset = 0, ret = 0, str_size = 1024;
- str = (char *)malloc(str_size);
- if (!str) {
- return NULL;
+ if (!i) {
+ goto failed;
}
- memset(str, '\0', str_size);
-
- offset = snprintf(str, str_size, "Your password ");
- if (offset == -1) {
+ str = talloc_asprintf(ctx, "Your password ");
+ if (!str) {
goto failed;
}
- if (response->data.auth.policy.min_length_password > 0) {
- ret = snprintf(str+offset, str_size-offset,
+ if (i->min_length_password > 0) {
+ str = talloc_asprintf_append(str,
"must be at least %d characters; ",
- response->data.auth.policy.min_length_password);
- if (ret == -1) {
+ i->min_length_password);
+ if (!str) {
goto failed;
}
- offset += ret;
}
- if (response->data.auth.policy.password_history > 0) {
- ret = snprintf(str+offset, str_size-offset,
+ if (i->password_history > 0) {
+ str = talloc_asprintf_append(str,
"cannot repeat any of your previous %d "
"passwords; ",
- response->data.auth.policy.password_history);
- if (ret == -1) {
+ i->password_history);
+ if (!str) {
goto failed;
}
- offset += ret;
}
- if (response->data.auth.policy.password_properties &
- DOMAIN_PASSWORD_COMPLEX) {
- ret = snprintf(str+offset, str_size-offset,
+ if (i->password_properties & WBC_DOMAIN_PASSWORD_COMPLEX) {
+ str = talloc_asprintf_append(str,
"must contain capitals, numerals "
"or punctuation; "
"and cannot contain your account "
"or full name; ");
- if (ret == -1) {
+ if (!str) {
goto failed;
}
- offset += ret;
}
- ret = snprintf(str+offset, str_size-offset,
+ str = talloc_asprintf_append(str,
"Please type a different password. "
"Type a password which meets these requirements in "
"both text boxes.");
- if (ret == -1) {
+ if (!str) {
goto failed;
}
return str;
failed:
- SAFE_FREE(str);
+ TALLOC_FREE(str);
return NULL;
}
+static int _pam_create_homedir(struct pwb_context *ctx,
+ const char *dirname,
+ mode_t mode)
+{
+ struct stat sbuf;
+
+ if (stat(dirname, &sbuf) == 0) {
+ return PAM_SUCCESS;
+ }
+
+ if (mkdir(dirname, mode) != 0) {
+
+ _make_remark_format(ctx, PAM_TEXT_INFO,
+ "Creating directory: %s failed: %s",
+ dirname, strerror(errno));
+ _pam_log(ctx, LOG_ERR, "could not create dir: %s (%s)",
+ dirname, strerror(errno));
+ return PAM_PERM_DENIED;
+ }
+
+ return PAM_SUCCESS;
+}
+
+static int _pam_chown_homedir(struct pwb_context *ctx,
+ const char *dirname,
+ uid_t uid,
+ gid_t gid)
+{
+ if (chown(dirname, uid, gid) != 0) {
+ _pam_log(ctx, LOG_ERR, "failed to chown user homedir: %s (%s)",
+ dirname, strerror(errno));
+ return PAM_PERM_DENIED;
+ }
+
+ return PAM_SUCCESS;
+}
+
+static int _pam_mkhomedir(struct pwb_context *ctx)
+{
+ struct passwd *pwd = NULL;
+ char *token = NULL;
+ char *create_dir = NULL;
+ char *user_dir = NULL;
+ int ret;
+ const char *username;
+ mode_t mode = 0700;
+ char *safe_ptr = NULL;
+ char *p = NULL;
+
+ /* Get the username */
+ ret = pam_get_user(ctx->pamh, &username, NULL);
+ if ((ret != PAM_SUCCESS) || (!username)) {
+ _pam_log_debug(ctx, LOG_DEBUG, "can not get the username");
+ return PAM_SERVICE_ERR;
+ }
+
+ pwd = getpwnam(username);
+ if (pwd == NULL) {
+ _pam_log_debug(ctx, LOG_DEBUG, "can not get the username");
+ return PAM_USER_UNKNOWN;
+ }
+ _pam_log_debug(ctx, LOG_DEBUG, "homedir is: %s", pwd->pw_dir);
+
+ ret = _pam_create_homedir(ctx, pwd->pw_dir, 0700);
+ if (ret == PAM_SUCCESS) {
+ ret = _pam_chown_homedir(ctx, pwd->pw_dir,
+ pwd->pw_uid,
+ pwd->pw_gid);
+ }
+
+ if (ret == PAM_SUCCESS) {
+ return ret;
+ }
+
+ /* maybe we need to create parent dirs */
+ create_dir = talloc_strdup(ctx, "/");
+ if (!create_dir) {
+ return PAM_BUF_ERR;
+ }
+
+ /* find final directory */
+ user_dir = strrchr(pwd->pw_dir, '/');
+ if (!user_dir) {
+ return PAM_BUF_ERR;
+ }
+ user_dir++;
+
+ _pam_log(ctx, LOG_DEBUG, "final directory: %s", user_dir);
+
+ p = pwd->pw_dir;
+
+ while ((token = strtok_r(p, "/", &safe_ptr)) != NULL) {
+
+ mode = 0755;
+
+ p = NULL;
+
+ _pam_log_debug(ctx, LOG_DEBUG, "token is %s", token);
+
+ create_dir = talloc_asprintf_append(create_dir, "%s/", token);
+ if (!create_dir) {
+ return PAM_BUF_ERR;
+ }
+ _pam_log_debug(ctx, LOG_DEBUG, "current_dir is %s", create_dir);
+
+ if (strcmp(token, user_dir) == 0) {
+ _pam_log_debug(ctx, LOG_DEBUG, "assuming last directory: %s", token);
+ mode = 0700;
+ }
+
+ ret = _pam_create_homedir(ctx, create_dir, mode);
+ if (ret) {
+ return ret;
+ }
+ }
+
+ return _pam_chown_homedir(ctx, create_dir,
+ pwd->pw_uid,
+ pwd->pw_gid);
+}
+
/* talk to winbindd */
static int winbind_auth_request(struct pwb_context *ctx,
const char *user,
const char *member,
const char *cctype,
const int warn_pwd_expire,
- struct winbindd_response *p_response,
+ struct wbcAuthErrorInfo **p_error,
+ struct wbcLogonUserInfo **p_info,
+ struct wbcUserPasswordPolicyInfo **p_policy,
time_t *pwd_last_set,
char **user_ret)
{
- struct winbindd_request request;
- struct winbindd_response response;
- int ret;
- bool already_expired = false;
+ wbcErr wbc_status;
+
+ struct wbcLogonUserParams logon;
+ char membership_of[1024];
+ uid_t user_uid = -1;
+ uint32_t flags = WBFLAG_PAM_INFO3_TEXT |
+ WBFLAG_PAM_GET_PWD_POLICY;
+
+ struct wbcLogonUserInfo *info = NULL;
+ struct wbcAuthUserInfo *user_info = NULL;
+ struct wbcAuthErrorInfo *error = NULL;
+ struct wbcUserPasswordPolicyInfo *policy = NULL;
- ZERO_STRUCT(request);
- ZERO_STRUCT(response);
+ int ret = PAM_AUTH_ERR;
+ int i;
+ const char *codes[] = {
+ "NT_STATUS_PASSWORD_EXPIRED",
+ "NT_STATUS_PASSWORD_MUST_CHANGE",
+ "NT_STATUS_INVALID_WORKSTATION",
+ "NT_STATUS_INVALID_LOGON_HOURS",
+ "NT_STATUS_ACCOUNT_EXPIRED",
+ "NT_STATUS_ACCOUNT_DISABLED",
+ "NT_STATUS_ACCOUNT_LOCKED_OUT",
+ "NT_STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT",
+ "NT_STATUS_NOLOGON_SERVER_TRUST_ACCOUNT",
+ "NT_STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT",
+ "NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND",
+ "NT_STATUS_NO_LOGON_SERVERS",
+ "NT_STATUS_WRONG_PASSWORD",
+ "NT_STATUS_ACCESS_DENIED"
+ };
if (pwd_last_set) {
*pwd_last_set = 0;
}
- strncpy(request.data.auth.user, user,
- sizeof(request.data.auth.user)-1);
-
- strncpy(request.data.auth.pass, pass,
- sizeof(request.data.auth.pass)-1);
-
- request.data.auth.krb5_cc_type[0] = '\0';
- request.data.auth.uid = -1;
-
- request.flags = WBFLAG_PAM_INFO3_TEXT | WBFLAG_PAM_GET_PWD_POLICY;
-
/* Krb5 auth always has to go against the KDC of the user's realm */
if (ctx->ctrl & WINBIND_KRB5_AUTH) {
- request.flags |= WBFLAG_PAM_CONTACT_TRUSTDOM;
+ flags |= WBFLAG_PAM_CONTACT_TRUSTDOM;
}
if (ctx->ctrl & (WINBIND_KRB5_AUTH|WINBIND_CACHED_LOGIN)) {
if (pwd == NULL) {
return PAM_USER_UNKNOWN;
}
- request.data.auth.uid = pwd->pw_uid;
+ user_uid = pwd->pw_uid;
}
if (ctx->ctrl & WINBIND_KRB5_AUTH) {
_pam_log_debug(ctx, LOG_DEBUG,
"enabling krb5 login flag\n");
- request.flags |= WBFLAG_PAM_KRB5 |
- WBFLAG_PAM_FALLBACK_AFTER_KRB5;
+ flags |= WBFLAG_PAM_KRB5 |
+ WBFLAG_PAM_FALLBACK_AFTER_KRB5;
}
if (ctx->ctrl & WINBIND_CACHED_LOGIN) {
_pam_log_debug(ctx, LOG_DEBUG,
"enabling cached login flag\n");
- request.flags |= WBFLAG_PAM_CACHED_LOGIN;
+ flags |= WBFLAG_PAM_CACHED_LOGIN;
}
if (user_ret) {
*user_ret = NULL;
- request.flags |= WBFLAG_PAM_UNIX_NAME;
+ flags |= WBFLAG_PAM_UNIX_NAME;
}
if (cctype != NULL) {
- strncpy(request.data.auth.krb5_cc_type, cctype,
- sizeof(request.data.auth.krb5_cc_type) - 1);
_pam_log_debug(ctx, LOG_DEBUG,
"enabling request for a %s krb5 ccache\n",
cctype);
}
- request.data.auth.require_membership_of_sid[0] = '\0';
-
if (member != NULL) {
- if (!winbind_name_list_to_sid_string_list(ctx, user,
- member,
- request.data.auth.require_membership_of_sid,
- sizeof(request.data.auth.require_membership_of_sid))) {
+ ZERO_STRUCT(membership_of);
+ if (!winbind_name_list_to_sid_string_list(ctx, user, member,
+ membership_of,
+ sizeof(membership_of))) {
_pam_log_debug(ctx, LOG_ERR,
"failed to serialize membership of sid "
"\"%s\"\n", member);
}
}
- ret = pam_winbind_request_log(ctx, WINBINDD_PAM_AUTH,
- &request, &response, user);
+ ZERO_STRUCT(logon);
- if (pwd_last_set) {
- *pwd_last_set = response.data.auth.info3.pass_last_set_time;
+ logon.username = user;
+ logon.password = pass;
+
+ wbc_status = wbcAddNamedBlob(&logon.num_blobs,
+ &logon.blobs,
+ "krb5_cc_type",
+ 0,
+ (uint8_t *)cctype,
+ strlen(cctype)+1);
+ if (!WBC_ERROR_IS_OK(wbc_status)) {
+ goto done;
+ }
+
+ wbc_status = wbcAddNamedBlob(&logon.num_blobs,
+ &logon.blobs,
+ "flags",
+ 0,
+ (uint8_t *)&flags,
+ sizeof(flags));
+ if (!WBC_ERROR_IS_OK(wbc_status)) {
+ goto done;
}
- if (p_response) {
- /* We want to process the response in the caller. */
- *p_response = response;
+ wbc_status = wbcAddNamedBlob(&logon.num_blobs,
+ &logon.blobs,
+ "user_uid",
+ 0,
+ (uint8_t *)&user_uid,
+ sizeof(user_uid));
+ if (!WBC_ERROR_IS_OK(wbc_status)) {
+ goto done;
+ }
+
+ wbc_status = wbcAddNamedBlob(&logon.num_blobs,
+ &logon.blobs,
+ "membership_of",
+ 0,
+ (uint8_t *)membership_of,
+ sizeof(membership_of));
+ if (!WBC_ERROR_IS_OK(wbc_status)) {
+ goto done;
+ }
+
+ wbc_status = wbcLogonUser(&logon, &info, &error, &policy);
+ ret = wbc_auth_error_to_pam_error(ctx, error, wbc_status,
+ user, "wbcLogonUser");
+ wbcFreeMemory(logon.blobs);
+ logon.blobs = NULL;
+
+ if (info && info->info) {
+ user_info = info->info;
+ }
+
+ if (pwd_last_set && user_info) {
+ *pwd_last_set = user_info->pass_last_set_time;
+ }
+
+ if (p_info && info) {
+ *p_info = info;
+ }
+
+ if (p_policy && policy) {
+ *p_policy = policy;
+ }
+
+ if (p_error && error) {
+ /* We want to process the error in the caller. */
+ *p_error = error;
return ret;
}
- if (ret) {
- PAM_WB_REMARK_CHECK_RESPONSE_RET(ctx, response,
- "NT_STATUS_PASSWORD_EXPIRED");
- PAM_WB_REMARK_CHECK_RESPONSE_RET(ctx, response,
- "NT_STATUS_PASSWORD_MUST_CHANGE");
- PAM_WB_REMARK_CHECK_RESPONSE_RET(ctx, response,
- "NT_STATUS_INVALID_WORKSTATION");
- PAM_WB_REMARK_CHECK_RESPONSE_RET(ctx, response,
- "NT_STATUS_INVALID_LOGON_HOURS");
- PAM_WB_REMARK_CHECK_RESPONSE_RET(ctx, response,
- "NT_STATUS_ACCOUNT_EXPIRED");
- PAM_WB_REMARK_CHECK_RESPONSE_RET(ctx, response,
- "NT_STATUS_ACCOUNT_DISABLED");
- PAM_WB_REMARK_CHECK_RESPONSE_RET(ctx, response,
- "NT_STATUS_ACCOUNT_LOCKED_OUT");
- PAM_WB_REMARK_CHECK_RESPONSE_RET(ctx, response,
- "NT_STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT");
- PAM_WB_REMARK_CHECK_RESPONSE_RET(ctx, response,
- "NT_STATUS_NOLOGON_SERVER_TRUST_ACCOUNT");
- PAM_WB_REMARK_CHECK_RESPONSE_RET(ctx, response,
- "NT_STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT");
- PAM_WB_REMARK_CHECK_RESPONSE_RET(ctx, response,
- "NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND");
- PAM_WB_REMARK_CHECK_RESPONSE_RET(ctx, response,
- "NT_STATUS_NO_LOGON_SERVERS");
- PAM_WB_REMARK_CHECK_RESPONSE_RET(ctx, response,
- "NT_STATUS_WRONG_PASSWORD");
- PAM_WB_REMARK_CHECK_RESPONSE_RET(ctx, response,
- "NT_STATUS_ACCESS_DENIED");
+ for (i=0; i<ARRAY_SIZE(codes); i++) {
+ int _ret = ret;
+ if (_pam_check_remark_auth_err(ctx, error, codes[i], &_ret)) {
+ ret = _ret;
+ goto done;
+ }
}
- if (ret == PAM_SUCCESS) {
+ if ((ret == PAM_SUCCESS) && user_info && policy && info) {
+
+ bool already_expired = false;
/* warn a user if the password is about to expire soon */
- _pam_warn_password_expiry(ctx, &response,
+ _pam_warn_password_expiry(ctx, user_info, policy,
warn_pwd_expire,
&already_expired);
if (already_expired == true) {
- SMB_TIME_T last_set;
- last_set = response.data.auth.info3.pass_last_set_time;
+
+ SMB_TIME_T last_set = user_info->pass_last_set_time;
+
_pam_log_debug(ctx, LOG_DEBUG,
"Password has expired "
"(Password was last set: %lld, "
"%lld (now it's: %lu))\n",
(long long int)last_set,
(long long int)last_set +
- response.data.auth.policy.expire,
+ policy->expire,
time(NULL));
return PAM_AUTHTOK_EXPIRED;
}
/* inform about logon type */
- _pam_warn_logon_type(ctx, user,
- response.data.auth.info3.user_flgs);
+ _pam_warn_logon_type(ctx, user, user_info->user_flags);
/* inform about krb5 failures */
- _pam_warn_krb5_failure(ctx, user,
- response.data.auth.info3.user_flgs);
+ _pam_warn_krb5_failure(ctx, user, user_info->user_flags);
/* set some info3 info for other modules in the stack */
- _pam_set_data_info3(ctx, &response);
+ _pam_set_data_info3(ctx, user_info);
/* put krb5ccname into env */
- _pam_setup_krb5_env(ctx, response.data.auth.krb5ccname);
+ _pam_setup_krb5_env(ctx, info);
/* If winbindd returned a username, return the pointer to it
* here. */
- if (user_ret && response.data.auth.unix_username[0]) {
- /* We have to trust it's a null terminated string. */
- *user_ret = strndup(response.data.auth.unix_username,
- sizeof(response.data.auth.unix_username) - 1);
- }
+ _pam_setup_unix_username(ctx, user_ret, info);
+ }
+
+ done:
+ if (logon.blobs) {
+ wbcFreeMemory(logon.blobs);
+ }
+ if (info && info->blobs) {
+ wbcFreeMemory(info->blobs);
+ }
+ if (error && !p_error) {
+ wbcFreeMemory(error);
+ }
+ if (info && !p_info) {
+ wbcFreeMemory(info);
+ }
+ if (policy && !p_policy) {
+ wbcFreeMemory(policy);
}
return ret;
const char *newpass,
time_t pwd_last_set)
{
- struct winbindd_request request;
- struct winbindd_response response;
- int ret;
+ wbcErr wbc_status;
+ struct wbcChangePasswordParams params;
+ struct wbcAuthErrorInfo *error = NULL;
+ struct wbcUserPasswordPolicyInfo *policy = NULL;
+ enum wbcPasswordChangeRejectReason reject_reason = -1;
+ uint32_t flags = 0;
- ZERO_STRUCT(request);
- ZERO_STRUCT(response);
+ int i;
+ const char *codes[] = {
+ "NT_STATUS_BACKUP_CONTROLLER",
+ "NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND",
+ "NT_STATUS_NO_LOGON_SERVERS",
+ "NT_STATUS_ACCESS_DENIED",
+ "NT_STATUS_PWD_TOO_SHORT", /* TODO: tell the min pwd length ? */
+ "NT_STATUS_PWD_TOO_RECENT", /* TODO: tell the minage ? */
+ "NT_STATUS_PWD_HISTORY_CONFLICT" /* TODO: tell the history length ? */
+ };
+ int ret = PAM_AUTH_ERR;
+
+ ZERO_STRUCT(params);
- if (request.data.chauthtok.user == NULL) {
- return -2;
+ if (ctx->ctrl & WINBIND_KRB5_AUTH) {
+ flags |= WBFLAG_PAM_KRB5 |
+ WBFLAG_PAM_CONTACT_TRUSTDOM;
}
- strncpy(request.data.chauthtok.user, user,
- sizeof(request.data.chauthtok.user) - 1);
-
- if (oldpass != NULL) {
- strncpy(request.data.chauthtok.oldpass, oldpass,
- sizeof(request.data.chauthtok.oldpass) - 1);
- } else {
- request.data.chauthtok.oldpass[0] = '\0';
+ if (ctx->ctrl & WINBIND_CACHED_LOGIN) {
+ flags |= WBFLAG_PAM_CACHED_LOGIN;
}
- if (newpass != NULL) {
- strncpy(request.data.chauthtok.newpass, newpass,
- sizeof(request.data.chauthtok.newpass) - 1);
- } else {
- request.data.chauthtok.newpass[0] = '\0';
- }
+ params.account_name = user;
+ params.level = WBC_AUTH_USER_LEVEL_PLAIN;
+ params.old_password.plaintext = oldpass;
+ params.new_password.plaintext = newpass;
+ params.flags = flags;
- if (ctx->ctrl & WINBIND_KRB5_AUTH) {
- request.flags = WBFLAG_PAM_KRB5 |
- WBFLAG_PAM_CONTACT_TRUSTDOM;
- }
+ wbc_status = wbcChangeUserPasswordEx(¶ms, &error, &reject_reason, &policy);
+ ret = wbc_auth_error_to_pam_error(ctx, error, wbc_status,
+ user, "wbcChangeUserPasswordEx");
- if (ctx->ctrl & WINBIND_CACHED_LOGIN) {
- request.flags |= WBFLAG_PAM_CACHED_LOGIN;
+ if (WBC_ERROR_IS_OK(wbc_status)) {
+ _pam_log(ctx, LOG_NOTICE,
+ "user '%s' password changed", user);
+ return PAM_SUCCESS;
}
- ret = pam_winbind_request_log(ctx, WINBINDD_PAM_CHAUTHTOK,
- &request, &response, user);
-
- if (ret == PAM_SUCCESS) {
+ if (!error) {
+ wbcFreeMemory(policy);
return ret;
}
- PAM_WB_REMARK_CHECK_RESPONSE_RET(ctx, response,
- "NT_STATUS_BACKUP_CONTROLLER");
- PAM_WB_REMARK_CHECK_RESPONSE_RET(ctx, response,
- "NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND");
- PAM_WB_REMARK_CHECK_RESPONSE_RET(ctx, response,
- "NT_STATUS_NO_LOGON_SERVERS");
- PAM_WB_REMARK_CHECK_RESPONSE_RET(ctx, response,
- "NT_STATUS_ACCESS_DENIED");
-
- /* TODO: tell the min pwd length ? */
- PAM_WB_REMARK_CHECK_RESPONSE_RET(ctx, response,
- "NT_STATUS_PWD_TOO_SHORT");
-
- /* TODO: tell the minage ? */
- PAM_WB_REMARK_CHECK_RESPONSE_RET(ctx, response,
- "NT_STATUS_PWD_TOO_RECENT");
-
- /* TODO: tell the history length ? */
- PAM_WB_REMARK_CHECK_RESPONSE_RET(ctx, response,
- "NT_STATUS_PWD_HISTORY_CONFLICT");
+ for (i=0; i<ARRAY_SIZE(codes); i++) {
+ int _ret = ret;
+ if (_pam_check_remark_auth_err(ctx, error, codes[i], &_ret)) {
+ ret = _ret;
+ goto done;
+ }
+ }
- if (!strcasecmp(response.data.auth.nt_status_string,
+ if (!strcasecmp(error->nt_string,
"NT_STATUS_PASSWORD_RESTRICTION")) {
char *pwd_restriction_string = NULL;
- SMB_TIME_T min_pwd_age;
- uint32_t reject_reason = response.data.auth.reject_reason;
- min_pwd_age = response.data.auth.policy.min_passwordage;
+ SMB_TIME_T min_pwd_age = 0;
+
+ if (policy) {
+ min_pwd_age = policy->min_passwordage;
+ }
/* FIXME: avoid to send multiple PAM messages after another */
switch (reject_reason) {
case -1:
break;
- case SAMR_REJECT_OTHER:
+ case WBC_PWD_CHANGE_REJECT_OTHER:
if ((min_pwd_age > 0) &&
(pwd_last_set + min_pwd_age > time(NULL))) {
PAM_WB_REMARK_DIRECT(ctx,
"NT_STATUS_PWD_TOO_RECENT");
}
break;
- case SAMR_REJECT_TOO_SHORT:
+ case WBC_PWD_CHANGE_REJECT_TOO_SHORT:
PAM_WB_REMARK_DIRECT(ctx,
"NT_STATUS_PWD_TOO_SHORT");
break;
- case SAMR_REJECT_IN_HISTORY:
+ case WBC_PWD_CHANGE_REJECT_IN_HISTORY:
PAM_WB_REMARK_DIRECT(ctx,
"NT_STATUS_PWD_HISTORY_CONFLICT");
break;
- case SAMR_REJECT_COMPLEXITY:
+ case WBC_PWD_CHANGE_REJECT_COMPLEXITY:
_make_remark(ctx, PAM_ERROR_MSG,
"Password does not meet "
"complexity requirements");
}
pwd_restriction_string =
- _pam_compose_pwd_restriction_string(&response);
+ _pam_compose_pwd_restriction_string(ctx, policy);
if (pwd_restriction_string) {
_make_remark(ctx, PAM_ERROR_MSG,
pwd_restriction_string);
- SAFE_FREE(pwd_restriction_string);
+ TALLOC_FREE(pwd_restriction_string);
}
}
+ done:
+ wbcFreeMemory(error);
+ wbcFreeMemory(policy);
return ret;
}
* sure it's really a winbind user, this is important when stacking PAM
* modules in the 'account' or 'password' facility. */
+ wbcErr wbc_status;
struct passwd *pwd = NULL;
- struct winbindd_request request;
- struct winbindd_response response;
- int ret;
-
- ZERO_STRUCT(request);
- ZERO_STRUCT(response);
+ struct passwd *wb_pwd = NULL;
pwd = getpwnam(user);
if (pwd == NULL) {
return 1;
}
- strncpy(request.data.username, user,
- sizeof(request.data.username) - 1);
-
- ret = pam_winbind_request_log(ctx, WINBINDD_GETPWNAM,
- &request, &response, user);
+ wbc_status = wbcGetpwnam(user, &wb_pwd);
+ wbcFreeMemory(wb_pwd);
+ if (!WBC_ERROR_IS_OK(wbc_status)) {
+ _pam_log(ctx, LOG_DEBUG, "valid_user: wbcGetpwnam gave %s\n",
+ wbcErrorString(wbc_status));
+ }
- switch (ret) {
- case PAM_USER_UNKNOWN:
+ switch (wbc_status) {
+ case WBC_ERR_UNKNOWN_USER:
return 1;
- case PAM_SUCCESS:
+ case WBC_ERR_SUCCESS:
return 0;
default:
break;
if (ctx->dict) {
char *key = NULL;
- if (!asprintf(&key, "global:%s", item)) {
+ key = talloc_asprintf(ctx, "global:%s", item);
+ if (!key) {
goto out;
}
parm_opt = iniparser_getstr(ctx->dict, key);
- SAFE_FREE(key);
+ TALLOC_FREE(key);
_pam_log_debug(ctx, LOG_INFO, "CONFIG file: %s '%s'\n",
item, parm_opt);
if (ctx->dict) {
char *key = NULL;
- if (!asprintf(&key, "global:%s", item)) {
+ key = talloc_asprintf(ctx, "global:%s", item);
+ if (!key) {
goto out;
}
parm_opt = iniparser_getint(ctx->dict, key, -1);
- SAFE_FREE(key);
+ TALLOC_FREE(key);
_pam_log_debug(ctx, LOG_INFO,
"CONFIG file: %s '%d'\n",
static char winbind_get_separator(struct pwb_context *ctx)
{
- struct winbindd_request request;
- struct winbindd_response response;
+ wbcErr wbc_status;
+ static struct wbcInterfaceDetails *details = NULL;
- ZERO_STRUCT(request);
- ZERO_STRUCT(response);
+ wbc_status = wbcInterfaceDetails(&details);
+ if (!WBC_ERROR_IS_OK(wbc_status)) {
+ _pam_log(ctx, LOG_ERR,
+ "Could not retrieve winbind interface details: %s",
+ wbcErrorString(wbc_status));
+ return '\0';
+ }
- if (pam_winbind_request_log(ctx, WINBINDD_INFO,
- &request, &response, NULL)) {
+ if (!details) {
return '\0';
}
- return response.data.info.winbind_separator;
+ return details->winbind_separator;
}
+
/**
* Convert a upn to a name.
*
static char* winbind_upn_to_username(struct pwb_context *ctx,
const char *upn)
{
- struct winbindd_request req;
- struct winbindd_response resp;
- int retval;
- char *account_name;
- int account_name_len;
char sep;
+ wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
+ struct wbcDomainSid sid;
+ enum wbcSidType type;
+ char *domain;
+ char *name;
/* This cannot work when the winbind separator = @ */
/* Convert the UPN to a SID */
- ZERO_STRUCT(req);
- ZERO_STRUCT(resp);
-
- strncpy(req.data.name.dom_name, "",
- sizeof(req.data.name.dom_name) - 1);
- strncpy(req.data.name.name, upn,
- sizeof(req.data.name.name) - 1);
- retval = pam_winbind_request_log(ctx, WINBINDD_LOOKUPNAME,
- &req, &resp, upn);
- if (retval != PAM_SUCCESS) {
+ wbc_status = wbcLookupName("", upn, &sid, &type);
+ if (!WBC_ERROR_IS_OK(wbc_status)) {
return NULL;
}
/* Convert the the SID back to the sAMAccountName */
- ZERO_STRUCT(req);
- strncpy(req.data.sid, resp.data.sid.sid, sizeof(req.data.sid)-1);
- ZERO_STRUCT(resp);
- retval = pam_winbind_request_log(ctx, WINBINDD_LOOKUPSID,
- &req, &resp, upn);
- if (retval != PAM_SUCCESS) {
+ wbc_status = wbcLookupSid(&sid, &domain, &name, &type);
+ if (!WBC_ERROR_IS_OK(wbc_status)) {
return NULL;
}
- account_name_len = asprintf(&account_name, "%s\\%s",
- resp.data.name.dom_name,
- resp.data.name.name);
-
- return account_name;
+ return talloc_asprintf(ctx, "%s\\%s", domain, name);
}
PAM_EXTERN
real_username);
if (samaccountname) {
free(real_username);
- real_username = samaccountname;
+ real_username = strdup(samaccountname);
}
}
/* Now use the username to look up password */
retval = winbind_auth_request(ctx, real_username, password,
- member, cctype, warn_pwd_expire, NULL,
+ member, cctype, warn_pwd_expire,
+ NULL, NULL, NULL,
NULL, &username_ret);
if (retval == PAM_NEW_AUTHTOK_REQD ||
char *new_authtok_required_during_auth = NULL;
- if (!asprintf(&new_authtok_required, "%d", retval)) {
+ new_authtok_required = talloc_asprintf(NULL, "%d", retval);
+ if (!new_authtok_required) {
retval = PAM_BUF_ERR;
goto out;
}
retval = PAM_SUCCESS;
- if (!asprintf(&new_authtok_required_during_auth, "%d", true)) {
+ new_authtok_required_during_auth = talloc_asprintf(NULL, "%d", true);
+ if (!new_authtok_required_during_auth) {
retval = PAM_BUF_ERR;
goto out;
}
_PAM_LOG_FUNCTION_LEAVE("pam_sm_authenticate", ctx, retval);
- _pam_winbind_free_context(ctx);
+ TALLOC_FREE(ctx);
return retval;
}
_PAM_LOG_FUNCTION_LEAVE("pam_sm_setcred", ctx, ret);
- _pam_winbind_free_context(ctx);
+ TALLOC_FREE(ctx);
return ret;
}
_PAM_LOG_FUNCTION_LEAVE("pam_sm_acct_mgmt", ctx, ret);
- _pam_winbind_free_context(ctx);
+ TALLOC_FREE(ctx);
return ret;
}
int pam_sm_open_session(pam_handle_t *pamh, int flags,
int argc, const char **argv)
{
- int ret = PAM_SYSTEM_ERR;
+ int ret = PAM_SUCCESS;
struct pwb_context *ctx = NULL;
ret = _pam_winbind_init_context(pamh, flags, argc, argv, &ctx);
_PAM_LOG_FUNCTION_ENTER("pam_sm_open_session", ctx);
- ret = PAM_SUCCESS;
-
+ if (ctx->ctrl & WINBIND_MKHOMEDIR) {
+ /* check and create homedir */
+ ret = _pam_mkhomedir(ctx);
+ }
out:
_PAM_LOG_FUNCTION_LEAVE("pam_sm_open_session", ctx, ret);
- _pam_winbind_free_context(ctx);
+ TALLOC_FREE(ctx);
return ret;
}
{
int retval = PAM_SUCCESS;
struct pwb_context *ctx = NULL;
+ struct wbcLogoffUserParams logoff;
retval = _pam_winbind_init_context(pamh, flags, argc, argv, &ctx);
if (retval) {
if (ctx->ctrl & WINBIND_KRB5_AUTH) {
/* destroy the ccache here */
- struct winbindd_request request;
- struct winbindd_response response;
+
+ wbcErr wbc_status;
+ struct wbcAuthErrorInfo *error = NULL;
+
+ uint32_t flags = 0;
const char *user;
const char *ccname = NULL;
struct passwd *pwd = NULL;
- ZERO_STRUCT(request);
- ZERO_STRUCT(response);
-
retval = pam_get_user(pamh, &user, "Username: ");
if (retval) {
_pam_log(ctx, LOG_ERR,
"user has no KRB5CCNAME environment");
}
- strncpy(request.data.logoff.user, user,
- sizeof(request.data.logoff.user) - 1);
-
- if (ccname) {
- strncpy(request.data.logoff.krb5ccname, ccname,
- sizeof(request.data.logoff.krb5ccname) - 1);
- }
-
pwd = getpwnam(user);
if (pwd == NULL) {
retval = PAM_USER_UNKNOWN;
goto out;
}
- request.data.logoff.uid = pwd->pw_uid;
- request.flags = WBFLAG_PAM_KRB5 |
- WBFLAG_PAM_CONTACT_TRUSTDOM;
+ flags = WBFLAG_PAM_KRB5 |
+ WBFLAG_PAM_CONTACT_TRUSTDOM;
+
+ ZERO_STRUCT(logoff);
+
+ logoff.username = user;
- retval = pam_winbind_request_log(ctx,
- WINBINDD_PAM_LOGOFF,
- &request, &response, user);
+ wbc_status = wbcAddNamedBlob(&logoff.num_blobs,
+ &logoff.blobs,
+ "ccfilename",
+ 0,
+ (uint8_t *)ccname,
+ strlen(ccname)+1);
+ if (!WBC_ERROR_IS_OK(wbc_status)) {
+ goto out;
+ }
+
+ wbc_status = wbcAddNamedBlob(&logoff.num_blobs,
+ &logoff.blobs,
+ "flags",
+ 0,
+ (uint8_t *)&flags,
+ sizeof(flags));
+ if (!WBC_ERROR_IS_OK(wbc_status)) {
+ goto out;
+ }
+
+ wbc_status = wbcAddNamedBlob(&logoff.num_blobs,
+ &logoff.blobs,
+ "user_uid",
+ 0,
+ (uint8_t *)&pwd->pw_uid,
+ sizeof(pwd->pw_uid));
+ if (!WBC_ERROR_IS_OK(wbc_status)) {
+ goto out;
+ }
+
+ wbc_status = wbcLogoffUserEx(&logoff, &error);
+ retval = wbc_auth_error_to_pam_error(ctx, error, wbc_status,
+ user, "wbcLogoffUser");
+ wbcFreeMemory(error);
+ wbcFreeMemory(logoff.blobs);
+
+ if (!WBC_ERROR_IS_OK(wbc_status)) {
+ _pam_log(ctx, LOG_INFO,
+ "failed to logoff user %s: %s\n",
+ user, wbcErrorString(wbc_status));
+ }
}
out:
+ if (logoff.blobs) {
+ wbcFreeMemory(logoff.blobs);
+ }
_PAM_LOG_FUNCTION_LEAVE("pam_sm_close_session", ctx, retval);
- _pam_winbind_free_context(ctx);
+ TALLOC_FREE(ctx);
return retval;
}
int retry = 0;
char *username_ret = NULL;
- struct winbindd_response response;
+ struct wbcAuthErrorInfo *error = NULL;
struct pwb_context *ctx = NULL;
- ZERO_STRUCT(response);
-
ret = _pam_winbind_init_context(pamh, flags, argc, argv, &ctx);
if (ret) {
goto out;
time_t pwdlastset_prelim = 0;
/* instruct user what is happening */
-#define greeting "Changing password for "
- Announce = (char *) malloc(sizeof(greeting) + strlen(user));
- if (Announce == NULL) {
+
+#define greeting "Changing password for"
+ Announce = talloc_asprintf(ctx, "%s %s", greeting, user);
+ if (!Announce) {
_pam_log(ctx, LOG_CRIT,
"password - out of memory");
ret = PAM_BUF_ERR;
goto out;
}
- (void) strcpy(Announce, greeting);
- (void) strcpy(Announce + sizeof(greeting) - 1, user);
#undef greeting
lctrl = ctx->ctrl | WINBIND__OLD_PASSWORD;
"(current) NT password: ",
NULL,
(const char **) &pass_old);
+ TALLOC_FREE(Announce);
if (ret != PAM_SUCCESS) {
_pam_log(ctx, LOG_NOTICE,
"password - (old) token not obtained");
/* verify that this is the password for this user */
ret = winbind_auth_request(ctx, user, pass_old,
- NULL, NULL, 0, &response,
+ NULL, NULL, 0,
+ &error, NULL, NULL,
&pwdlastset_prelim, NULL);
if (ret != PAM_ACCT_EXPIRED &&
const char *member = NULL;
const char *cctype = NULL;
int warn_pwd_expire;
+ struct wbcLogonUserInfo *info = NULL;
+ struct wbcUserPasswordPolicyInfo *policy = NULL;
member = get_member_from_config(ctx);
cctype = get_krb5_cc_type_from_config(ctx);
* */
ret = winbind_auth_request(ctx, user, pass_new,
- member, cctype, 0, &response,
+ member, cctype, 0,
+ &error, &info, &policy,
NULL, &username_ret);
_pam_overwrite(pass_new);
_pam_overwrite(pass_old);
if (ret == PAM_SUCCESS) {
+ struct wbcAuthUserInfo *user_info = NULL;
+
+ if (info && info->info) {
+ user_info = info->info;
+ }
+
/* warn a user if the password is about to
* expire soon */
- _pam_warn_password_expiry(ctx, &response,
+ _pam_warn_password_expiry(ctx, user_info, policy,
warn_pwd_expire,
NULL);
/* set some info3 info for other modules in the
* stack */
- _pam_set_data_info3(ctx, &response);
+ _pam_set_data_info3(ctx, user_info);
/* put krb5ccname into env */
- _pam_setup_krb5_env(ctx,
- response.data.auth.krb5ccname);
+ _pam_setup_krb5_env(ctx, info);
if (username_ret) {
pam_set_item(pamh, PAM_USER,
username_ret);
free(username_ret);
}
+
+ wbcFreeMemory(info);
+ wbcFreeMemory(policy);
}
goto out;
}
out:
+ {
+ /* Deal with offline errors. */
+ int i;
+ const char *codes[] = {
+ "NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND",
+ "NT_STATUS_NO_LOGON_SERVERS",
+ "NT_STATUS_ACCESS_DENIED"
+ };
+
+ for (i=0; i<ARRAY_SIZE(codes); i++) {
+ int _ret;
+ if (_pam_check_remark_auth_err(ctx, error, codes[i], &_ret)) {
+ break;
+ }
+ }
+ }
- /* Deal with offline errors. */
- PAM_WB_REMARK_CHECK_RESPONSE(ctx, response,
- "NT_STATUS_NO_LOGON_SERVERS");
- PAM_WB_REMARK_CHECK_RESPONSE(ctx, response,
- "NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND");
- PAM_WB_REMARK_CHECK_RESPONSE(ctx, response,
- "NT_STATUS_ACCESS_DENIED");
+ wbcFreeMemory(error);
_PAM_LOG_FUNCTION_LEAVE("pam_sm_chauthtok", ctx, ret);
- _pam_winbind_free_context(ctx);
+ TALLOC_FREE(ctx);
return ret;
}
#include "../lib/replace/replace.h"
#include "system/syslog.h"
#include "system/time.h"
+#include <talloc.h>
+#include "libwbclient/wbclient.h"
#define MODULE_NAME "pam_winbind"
#define PAM_SM_AUTH
#define WINBIND_SILENT 0x00000800
#define WINBIND_DEBUG_STATE 0x00001000
#define WINBIND_WARN_PWD_EXPIRE 0x00002000
+#define WINBIND_MKHOMEDIR 0x00004000
/*
* here is the string to inform the user that the new passwords they
};\
};
-#define PAM_WB_REMARK_DIRECT_RET(h,f,x)\
-{\
- const char *error_string = NULL; \
- error_string = _get_ntstatus_error_string(x);\
- if (error_string != NULL) {\
- _make_remark(h, f, PAM_ERROR_MSG, error_string);\
- return ret;\
- };\
- _make_remark(h, f, PAM_ERROR_MSG, x);\
- return ret;\
-};
-
-#define PAM_WB_REMARK_CHECK_RESPONSE(c,x,y)\
-{\
- const char *ntstatus = x.data.auth.nt_status_string; \
- const char *error_string = NULL; \
- if (!strcasecmp(ntstatus,y)) {\
- error_string = _get_ntstatus_error_string(y);\
- if (error_string != NULL) {\
- _make_remark(c, PAM_ERROR_MSG, error_string);\
- };\
- if (x.data.auth.error_string[0] != '\0') {\
- _make_remark(c, PAM_ERROR_MSG, x.data.auth.error_string);\
- };\
- _make_remark(c, PAM_ERROR_MSG, y);\
- };\
-};
-
-#define PAM_WB_REMARK_CHECK_RESPONSE_RET(c,x,y)\
-{\
- const char *ntstatus = x.data.auth.nt_status_string; \
- const char *error_string = NULL; \
- if (!strcasecmp(ntstatus,y)) {\
- error_string = _get_ntstatus_error_string(y);\
- if (error_string != NULL) {\
- _make_remark(c, PAM_ERROR_MSG, error_string);\
- return ret;\
- };\
- if (x.data.auth.error_string[0] != '\0') {\
- _make_remark(c, PAM_ERROR_MSG, x.data.auth.error_string);\
- return ret;\
- };\
- _make_remark(c, PAM_ERROR_MSG, y);\
- return ret;\
- };\
-};
-
-/* from samr.idl */
-#define DOMAIN_PASSWORD_COMPLEX 0x00000001
-
-#define SAMR_REJECT_OTHER 0x00000000
-#define SAMR_REJECT_TOO_SHORT 0x00000001
-#define SAMR_REJECT_IN_HISTORY 0x00000002
-#define SAMR_REJECT_COMPLEXITY 0x00000005
-
-#define ACB_PWNOEXP 0x00000200
-
-/* from netlogon.idl */
-#define NETLOGON_CACHED_ACCOUNT 0x00000004
-#define NETLOGON_GRACE_LOGON 0x01000000
-
-/* from include/rpc_netlogon.h */
#define LOGON_KRB5_FAIL_CLOCK_SKEW 0x02000000
-#define PAM_WB_CACHED_LOGON(x) (x & NETLOGON_CACHED_ACCOUNT)
+#define PAM_WB_CACHED_LOGON(x) (x & WBC_AUTH_USER_INFO_CACHED_ACCOUNT)
#define PAM_WB_KRB5_CLOCK_SKEW(x) (x & LOGON_KRB5_FAIL_CLOCK_SKEW)
-#define PAM_WB_GRACE_LOGON(x) ((NETLOGON_CACHED_ACCOUNT|NETLOGON_GRACE_LOGON) == ( x & (NETLOGON_CACHED_ACCOUNT|NETLOGON_GRACE_LOGON)))
+#define PAM_WB_GRACE_LOGON(x) ((WBC_AUTH_USER_INFO_CACHED_ACCOUNT|WBC_AUTH_USER_INFO_GRACE_LOGON) == ( x & (WBC_AUTH_USER_INFO_CACHED_ACCOUNT|WBC_AUTH_USER_INFO_GRACE_LOGON)))
struct pwb_context {
pam_handle_t *pamh;
dictionary *dict;
uint32_t ctrl;
};
+
+#define TALLOC_FREE(ctx) do { if ((ctx) != NULL) {talloc_free(ctx); ctx=NULL;} } while(0)
+#define TALLOC_ZERO_P(ctx, type) (type *)_talloc_zero(ctx, sizeof(type), #type)
+#define TALLOC_P(ctx, type) (type *)talloc_named_const(ctx, sizeof(type), #type)
+
ZERO_STRUCT(request);
ZERO_STRUCT(response);
- fstrcpy(request.domain_name, domain_name);
- request.flags = flags;
+ fstrcpy(request.data.dsgetdcname.domain_name, domain_name);
+ request.data.dsgetdcname.flags = flags;
request.flags |= DS_DIRECTORY_SERVICE_REQUIRED;
/* Display response */
- d_printf("%s\n", response.data.dc_name);
+ d_printf("%s\n", response.data.dsgetdcname.dc_unc);
+ d_printf("%s\n", response.data.dsgetdcname.dc_address);
+ d_printf("%d\n", response.data.dsgetdcname.dc_address_type);
+ d_printf("%s\n", response.data.dsgetdcname.domain_guid);
+ d_printf("%s\n", response.data.dsgetdcname.domain_name);
+ d_printf("%s\n", response.data.dsgetdcname.forest_name);
+ d_printf("0x%08x\n", response.data.dsgetdcname.dc_flags);
+ d_printf("%s\n", response.data.dsgetdcname.dc_site_name);
+ d_printf("%s\n", response.data.dsgetdcname.client_site_name);
return true;
}
/*
Unix SMB/CIFS implementation.
kerberos locator plugin
- Copyright (C) Guenther Deschner 2007
+ Copyright (C) Guenther Deschner 2007-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
*/
#include "nsswitch/winbind_client.h"
+#include "libwbclient/wbclient.h"
#ifndef DEBUG_KRB5
#undef DEBUG_KRB5
static bool ask_winbind(const char *realm, char **dcname)
{
- NSS_STATUS status;
- struct winbindd_request request;
- struct winbindd_response response;
+ wbcErr wbc_status;
+ const char *dc = NULL;
+ struct wbcDomainControllerInfoEx *dc_info = NULL;
+ uint32_t flags;
- ZERO_STRUCT(request);
- ZERO_STRUCT(response);
+ flags = WBC_LOOKUP_DC_KDC_REQUIRED |
+ WBC_LOOKUP_DC_IS_DNS_NAME |
+ WBC_LOOKUP_DC_RETURN_DNS_NAME |
+ WBC_LOOKUP_DC_IP_REQUIRED;
- request.flags = 0x40020600;
- /* DS_KDC_REQUIRED |
- DS_IS_DNS_NAME |
- DS_RETURN_DNS_NAME |
- DS_IP_REQUIRED */
+ wbc_status = wbcLookupDomainControllerEx(realm, NULL, NULL, flags, &dc_info);
- strncpy(request.domain_name, realm,
- sizeof(request.domain_name)-1);
-
- status = winbindd_request_response(WINBINDD_DSGETDCNAME,
- &request, &response);
- if (status != NSS_STATUS_SUCCESS) {
+ if (!WBC_ERROR_IS_OK(wbc_status)) {
#ifdef DEBUG_KRB5
fprintf(stderr,"[%5u]: smb_krb5_locator_lookup: failed with: %s\n",
- (unsigned int)getpid(), nss_err_str(status));
+ (unsigned int)getpid(), wbcErrorString(wbc_status));
#endif
return false;
}
- *dcname = strdup(response.data.dc_name);
+ if (dc_info->dc_address) {
+ dc = dc_info->dc_address;
+ if (dc[0] == '\\') dc++;
+ if (dc[0] == '\\') dc++;
+ }
+
+ if (!dc && dc_info->dc_unc) {
+ dc = dc_info->dc_unc;
+ if (dc[0] == '\\') dc++;
+ if (dc[0] == '\\') dc++;
+ }
+
+ if (!dc) {
+ wbcFreeMemory(dc_info);
+ return false;
+ }
+
+ *dcname = strdup(dc);
if (!*dcname) {
+ wbcFreeMemory(dc_info);
return false;
}
+ wbcFreeMemory(dc_info);
return true;
}
uint32_t initial_blob_len; /* blobs in extra_data */
uint32_t challenge_blob_len;
} ccache_ntlm_auth;
+ struct {
+ fstring domain_name;
+ fstring domain_guid;
+ fstring site_name;
+ uint32_t flags;
+ } dsgetdcname;
/* padding -- needed to fix alignment between 32bit and 64bit libs.
The size is the sizeof the union without the padding aligned on
struct {
uint32_t auth_blob_len; /* blob in extra_data */
} ccache_ntlm_auth;
+ struct {
+ fstring dc_unc;
+ fstring dc_address;
+ uint32_t dc_address_type;
+ fstring domain_guid;
+ fstring domain_name;
+ fstring forest_name;
+ uint32_t dc_flags;
+ fstring dc_site_name;
+ fstring client_site_name;
+ } dsgetdcname;
} data;
/* Variable length return data */
*/
#include "includes.h"
+#include "printing.h"
bool bLoaded = False;
int iKeepalive;
int iminreceivefile;
struct param_opt_struct *param_opt;
+ int cups_connection_timeout;
};
static struct global Globals;
.enum_list = NULL,
.flags = FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL,
},
+ {
+ .label = "cups connection timeout",
+ .type = P_INTEGER,
+ .p_class = P_GLOBAL,
+ .ptr = &Globals.cups_connection_timeout,
+ .special = NULL,
+ .enum_list = NULL,
+ .flags = FLAG_ADVANCED,
+ },
{
.label = "iprint server",
.type = P_STRING,
}
}
+/**
+ * Free the allocated data for one parameter for a given share.
+ */
+static void free_parameter(int snum, struct parm_struct parm)
+{
+ void *parm_ptr;
+
+ if (parm.ptr == NULL); {
+ return;
+ }
+
+ if (snum < 0) {
+ parm_ptr = parm.ptr;
+ } else if (parm.p_class != P_LOCAL) {
+ return;
+ } else {
+ parm_ptr = lp_local_ptr(snum, parm.ptr);
+ }
+
+ if ((parm.type == P_STRING) ||
+ (parm.type == P_USTRING))
+ {
+ string_free((char**)parm_ptr);
+ } else if (parm.type == P_LIST) {
+ TALLOC_FREE(*((char***)parm_ptr));
+ }
+}
+
+/**
+ * Free the allocated parameter data for a share.
+ */
+static void free_parameters(int snum)
+{
+ uint32_t i;
+
+ for (i=0; parm_table[i].label; i++) {
+ free_parameter(snum, parm_table[i]);
+ }
+}
+
+/**
+ * Free the allocated global parameters.
+ */
+static void free_global_parameters(void)
+{
+ free_parameters(GLOBAL_SECTION_SNUM);
+}
+
/***************************************************************************
Initialise the global parameter structure.
***************************************************************************/
}
done_init = True;
} else {
- for (i = 0; parm_table[i].label; i++) {
- if ((parm_table[i].type == P_STRING ||
- parm_table[i].type == P_USTRING) &&
- parm_table[i].ptr)
- {
- string_free((char **)parm_table[i].ptr);
- }
- }
+ free_global_parameters();
}
memset((void *)&Globals, '\0', sizeof(Globals));
* to never expire, though, when this runs out the afs client will
* forget the token. Set to 0 to get NEVERDATE.*/
Globals.iAfsTokenLifetime = 604800;
+ Globals.cups_connection_timeout = CUPS_DEFAULT_CONNECTION_TIMEOUT;
/* these parameters are set to defaults that are more appropriate
for the increasing samba install base:
FN_LOCAL_STRING(lp_cups_options, szCupsOptions)
FN_GLOBAL_STRING(lp_cups_server, &Globals.szCupsServer)
FN_GLOBAL_STRING(lp_iprint_server, &Globals.szIPrintServer)
+FN_GLOBAL_INTEGER(lp_cups_connection_timeout, &Globals.cups_connection_timeout)
FN_GLOBAL_CONST_STRING(lp_ctdbd_socket, &Globals.ctdbdSocket)
FN_GLOBAL_LIST(lp_cluster_addresses, &Globals.szClusterAddresses)
FN_GLOBAL_BOOL(lp_clustering, &Globals.clustering)
static void init_copymap(struct service *pservice);
static bool hash_a_service(const char *name, int number);
static void free_service_byindex(int iService);
+static void free_param_opts(struct param_opt_struct **popts);
static char * canonicalize_servicename(const char *name);
static void show_parameter(int parmIndex);
static bool is_synonym_of(int parm1, int parm2, bool *inverse);
copy_service(pservice, &sDefault, NULL);
}
+
+/**
+ * free a param_opts structure.
+ * param_opts handling should be moved to talloc;
+ * then this whole functions reduces to a TALLOC_FREE().
+ */
+
+static void free_param_opts(struct param_opt_struct **popts)
+{
+ struct param_opt_struct *opt, *next_opt;
+
+ if (popts == NULL) {
+ return;
+ }
+
+ if (*popts != NULL) {
+ DEBUG(5, ("Freeing parametrics:\n"));
+ }
+ opt = *popts;
+ while (opt != NULL) {
+ string_free(&opt->key);
+ string_free(&opt->value);
+ TALLOC_FREE(opt->list);
+ next_opt = opt->next;
+ SAFE_FREE(opt);
+ opt = next_opt;
+ }
+ *popts = NULL;
+}
+
/***************************************************************************
Free the dynamically allocated parts of a service struct.
***************************************************************************/
static void free_service(struct service *pservice)
{
- int i;
- struct param_opt_struct *data, *pdata;
if (!pservice)
return;
DEBUG(5, ("free_service: Freeing service %s\n",
pservice->szService));
+ free_parameters(getservicebyname(pservice->szService, NULL));
+
string_free(&pservice->szService);
bitmap_free(pservice->copymap);
- for (i = 0; parm_table[i].label; i++) {
- if ((parm_table[i].type == P_STRING ||
- parm_table[i].type == P_USTRING) &&
- parm_table[i].p_class == P_LOCAL)
- string_free((char **)
- (((char *)pservice) +
- PTR_DIFF(parm_table[i].ptr, &sDefault)));
- else if (parm_table[i].type == P_LIST &&
- parm_table[i].p_class == P_LOCAL)
- TALLOC_FREE(*((char ***)
- (((char *)pservice) +
- PTR_DIFF(parm_table[i].ptr,
- &sDefault))));
- }
-
- data = pservice->param_opt;
- if (data)
- DEBUG(5,("Freeing parametrics:\n"));
- while (data) {
- DEBUG(5,("[%s = %s]\n", data->key, data->value));
- string_free(&data->key);
- string_free(&data->value);
- TALLOC_FREE(data->list);
- pdata = data->next;
- SAFE_FREE(data);
- data = pdata;
- }
+ free_param_opts(&pservice->param_opt);
ZERO_STRUCTP(pservice);
}
int i;
struct service tservice;
int num_to_alloc = iNumServices + 1;
- struct param_opt_struct *data, *pdata;
tservice = *pservice;
if (i >= 0) {
/* Clean all parametric options for service */
/* They will be added during parsing again */
- data = ServicePtrs[i]->param_opt;
- while (data) {
- string_free(&data->key);
- string_free(&data->value);
- TALLOC_FREE(data->list);
- pdata = data->next;
- SAFE_FREE(data);
- data = pdata;
- }
- ServicePtrs[i]->param_opt = NULL;
+ free_param_opts(&ServicePtrs[i]->param_opt);
return (i);
}
}
If pcopymapDest is NULL then copy all fields
***************************************************************************/
+/**
+ * Add a parametric option to a param_opt_struct,
+ * replacing old value, if already present.
+ */
+static void set_param_opt(struct param_opt_struct **opt_list,
+ const char *opt_name,
+ const char *opt_value)
+{
+ struct param_opt_struct *new_opt, *opt;
+ bool not_added;
+
+ if (opt_list == NULL) {
+ return;
+ }
+
+ opt = *opt_list;
+ not_added = true;
+
+ /* Traverse destination */
+ while (opt) {
+ /* If we already have same option, override it */
+ if (strwicmp(opt->key, opt_name) == 0) {
+ string_free(&opt->value);
+ TALLOC_FREE(opt->list);
+ opt->value = SMB_STRDUP(opt_value);
+ not_added = false;
+ break;
+ }
+ opt = opt->next;
+ }
+ if (not_added) {
+ new_opt = SMB_XMALLOC_P(struct param_opt_struct);
+ new_opt->key = SMB_STRDUP(opt_name);
+ new_opt->value = SMB_STRDUP(opt_value);
+ new_opt->list = NULL;
+ DLIST_ADD(*opt_list, new_opt);
+ }
+}
+
static void copy_service(struct service *pserviceDest, struct service *pserviceSource,
struct bitmap *pcopymapDest)
{
int i;
bool bcopyall = (pcopymapDest == NULL);
- struct param_opt_struct *data, *pdata, *paramo;
- bool not_added;
+ struct param_opt_struct *data;
for (i = 0; parm_table[i].label; i++)
if (parm_table[i].ptr && parm_table[i].p_class == P_LOCAL &&
data = pserviceSource->param_opt;
while (data) {
- not_added = True;
- pdata = pserviceDest->param_opt;
- /* Traverse destination */
- while (pdata) {
- /* If we already have same option, override it */
- if (strwicmp(pdata->key, data->key) == 0) {
- string_free(&pdata->value);
- TALLOC_FREE(data->list);
- pdata->value = SMB_STRDUP(data->value);
- not_added = False;
- break;
- }
- pdata = pdata->next;
- }
- if (not_added) {
- paramo = SMB_XMALLOC_P(struct param_opt_struct);
- paramo->key = SMB_STRDUP(data->key);
- paramo->value = SMB_STRDUP(data->value);
- paramo->list = NULL;
- DLIST_ADD(pserviceDest->param_opt, paramo);
- }
+ set_param_opt(&pserviceDest->param_opt, data->key, data->value);
data = data->next;
}
}
return conf_ctx;
}
-static bool process_registry_service(struct smbconf_service *service)
+static bool process_smbconf_service(struct smbconf_service *service)
{
uint32_t count;
bool ret;
goto done;
}
- ret = process_registry_service(service);
+ ret = process_smbconf_service(service);
if (!ret) {
goto done;
}
if (strequal(service[count]->name, GLOBAL_NAME)) {
continue;
}
- ret = process_registry_service(service[count]);
+ ret = process_smbconf_service(service[count]);
if (!ret) {
goto done;
}
int parmnum, i;
void *parm_ptr = NULL; /* where we are going to store the result */
void *def_ptr = NULL;
- struct param_opt_struct *paramo, *data;
- bool not_added;
+ struct param_opt_struct **opt_list;
parmnum = map_parameter(pszParmName);
if (parmnum < 0) {
- TALLOC_CTX *frame;
-
if (strchr(pszParmName, ':') == NULL) {
DEBUG(0, ("Ignoring unknown parameter \"%s\"\n",
pszParmName));
* We've got a parametric option
*/
- frame = talloc_stackframe();
+ opt_list = (snum < 0)
+ ? &Globals.param_opt : &ServicePtrs[snum]->param_opt;
+ set_param_opt(opt_list, pszParmName, pszParmValue);
- not_added = True;
- data = (snum < 0)
- ? Globals.param_opt : ServicePtrs[snum]->param_opt;
- /* Traverse destination */
- while (data) {
- /* If we already have same option, override it */
- if (strwicmp(data->key, pszParmName) == 0) {
- string_free(&data->value);
- TALLOC_FREE(data->list);
- data->value = SMB_STRDUP(pszParmValue);
- not_added = False;
- break;
- }
- data = data->next;
- }
- if (not_added) {
- paramo = SMB_XMALLOC_P(struct param_opt_struct);
- paramo->key = SMB_STRDUP(pszParmName);
- paramo->value = SMB_STRDUP(pszParmValue);
- paramo->list = NULL;
- if (snum < 0) {
- DLIST_ADD(Globals.param_opt, paramo);
- } else {
- DLIST_ADD(ServicePtrs[snum]->param_opt,
- paramo);
- }
- }
-
- TALLOC_FREE(frame);
return (True);
}
pszParmName));
return (True);
}
- parm_ptr =
- ((char *)ServicePtrs[snum]) + PTR_DIFF(def_ptr,
- &sDefault);
+ parm_ptr = lp_local_ptr(snum, def_ptr);
}
if (snum >= 0) {
Auto-load one printer.
***************************************************************************/
-void lp_add_one_printer(char *name, char *comment)
+void lp_add_one_printer(const char *name, const char *comment, void *pdata)
{
int printers = lp_servicenumber(PRINTERS_NAME);
int i;
/* Now release all resources allocated to global
parameters and the default service */
- for (i = 0; parm_table[i].label; i++)
- {
- if ( parm_table[i].type == P_STRING
- || parm_table[i].type == P_USTRING )
- {
- string_free( (char**)parm_table[i].ptr );
- }
- else if (parm_table[i].type == P_LIST) {
- TALLOC_FREE( *((char***)parm_table[i].ptr) );
- }
- }
+ free_global_parameters();
}
return in_client;
}
-
-
-
/***************************************************************************
Load the services array from the services file. Return True on success,
False on failure.
{
char *n2 = NULL;
bool bRetval;
- struct param_opt_struct *data, *pdata;
bRetval = False;
lp_save_defaults();
}
+ free_param_opts(&Globals.param_opt);
+
/* We get sections first, so have to start 'behind' to make up */
iServiceIndex = -1;
- if (Globals.param_opt != NULL) {
- data = Globals.param_opt;
- while (data) {
- string_free(&data->key);
- string_free(&data->value);
- TALLOC_FREE(data->list);
- pdata = data->next;
- SAFE_FREE(data);
- data = pdata;
- }
- Globals.param_opt = NULL;
- }
-
if (lp_config_backend_is_file()) {
n2 = alloc_sub_basic(get_current_username(),
current_user_info.domain,
--- /dev/null
+/*
+ * Unix SMB/CIFS implementation.
+ * Test for lp_load()
+ * Copyright (C) Michael Adam 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.
+ *
+ * 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"
+
+extern bool AllowDebugChange;
+
+int main(int argc, const char **argv)
+{
+ const char *config_file = get_dyn_CONFIGFILE();
+ int ret = 0;
+ poptContext pc;
+ char *count_str = NULL;
+ int i, count = 1;
+
+ struct poptOption long_options[] = {
+ POPT_AUTOHELP
+ {"count", 'c', POPT_ARG_STRING, &count_str, 1,
+ "Load config <count> number of times"},
+ POPT_COMMON_DEBUGLEVEL
+ POPT_TABLEEND
+ };
+
+ TALLOC_CTX *frame = talloc_stackframe();
+
+ load_case_tables();
+ DEBUGLEVEL_CLASS[DBGC_ALL] = 0;
+
+ pc = poptGetContext(NULL, argc, argv, long_options,
+ POPT_CONTEXT_KEEP_FIRST);
+ poptSetOtherOptionHelp(pc, "[OPTION...] <config-file>");
+
+ while(poptGetNextOpt(pc) != -1);
+
+ setup_logging(poptGetArg(pc), True);
+
+ if (poptPeekArg(pc)) {
+ config_file = poptGetArg(pc);
+ }
+
+ poptFreeContext(pc);
+
+ if (count_str != NULL) {
+ count = atoi(count_str);
+ }
+
+ dbf = x_stderr;
+ /* Don't let the debuglevel be changed by smb.conf. */
+ AllowDebugChange = False;
+
+ for (i=0; i < count; i++) {
+ printf("call lp_load() #%d: ", i+1);
+ if (!lp_load_with_registry_shares(config_file,
+ False, /* global only */
+ True, /* save defaults */
+ False, /*add_ipc */
+ True)) /*init globals */
+ {
+ printf("ERROR.\n");
+ ret = 1;
+ goto done;
+ }
+ printf("ok.\n");
+ }
+
+
+done:
+ TALLOC_FREE(frame);
+ gfree_loadparm();
+ return ret;
+}
+
return True;
}
+bool secrets_store_local_schannel_key(uint8_t schannel_key[16])
+{
+ return secrets_store(SECRETS_LOCAL_SCHANNEL_KEY, schannel_key, 16);
+}
+
+bool secrets_fetch_local_schannel_key(uint8_t schannel_key[16])
+{
+ size_t size = 0;
+ uint8_t *key;
+
+ key = (uint8_t *)secrets_fetch(SECRETS_LOCAL_SCHANNEL_KEY, &size);
+ if (key == NULL) {
+ return false;
+ }
+
+ if (size != 16) {
+ SAFE_FREE(key);
+ return false;
+ }
+
+ memcpy(schannel_key, key, 16);
+ SAFE_FREE(key);
+ return true;
+}
+
/**
* Form a key for fetching the machine trust account sec channel type
*
/* load all printcap printers */
if (lp_load_printers() && lp_servicenumber(PRINTERS_NAME) >= 0)
- pcap_printer_fn(lp_add_one_printer);
+ pcap_printer_fn(lp_add_one_printer, NULL);
}
size_t buflen;
} *notify_queue_head = NULL;
+static struct timed_event *notify_event;
static bool create_send_ctx(void)
{
num_messages = 0;
}
+/*******************************************************************
+ Event handler to send the messages.
+*******************************************************************/
+
+static void print_notify_event_send_messages(struct event_context *event_ctx,
+ struct timed_event *te,
+ const struct timeval *now,
+ void *private_data)
+{
+ /* Remove this timed event handler. */
+ TALLOC_FREE(notify_event);
+
+ change_to_root_user();
+ print_notify_send_messages(smbd_messaging_context(), 0);
+}
+
/**********************************************************************
deep copy a SPOOLSS_NOTIFY_MSG structure using a TALLOC_CTX
*********************************************************************/
DLIST_ADD_END(notify_queue_head, pnqueue, struct notify_queue *);
num_messages++;
+
+ if (smbd_event_context()) {
+ /* Add an event for 1 second's time to send this queue. */
+ notify_event = event_add_timed(smbd_event_context(), NULL,
+ timeval_current_ofs(1,0),
+ "print_notify",
+ print_notify_event_send_messages, NULL);
+ }
+
}
static void send_notify_field_values(const char *sharename, uint32 type,
}
}
close_file(fsp, NORMAL_CLOSE);
+ fsp = NULL;
/* Get file version info (if available) for new file */
filepath = driver_unix_convert(conn,new_file,&stat_buf);
}
}
close_file(fsp, NORMAL_CLOSE);
+ fsp = NULL;
if (use_version && (new_major != old_major || new_minor != old_minor)) {
/* Compare versions and choose the larger version number */
{
SEC_ACE ace[5]; /* max number of ace entries */
int i = 0;
- SEC_ACCESS sa;
+ uint32_t sa;
SEC_ACL *psa = NULL;
SEC_DESC_BUF *sdb = NULL;
SEC_DESC *psd = NULL;
/* Create an ACE where Everyone is allowed to print */
- init_sec_access(&sa, PRINTER_ACE_PRINT);
+ sa = PRINTER_ACE_PRINT;
init_sec_ace(&ace[i++], &global_sid_World, SEC_ACE_TYPE_ACCESS_ALLOWED,
sa, SEC_ACE_FLAG_CONTAINER_INHERIT);
sid_copy(&domadmins_sid, get_global_sam_sid());
sid_append_rid(&domadmins_sid, DOMAIN_GROUP_RID_ADMINS);
- init_sec_access(&sa, PRINTER_ACE_FULL_CONTROL);
+ sa = PRINTER_ACE_FULL_CONTROL;
init_sec_ace(&ace[i++], &domadmins_sid,
SEC_ACE_TYPE_ACCESS_ALLOWED, sa,
SEC_ACE_FLAG_OBJECT_INHERIT | SEC_ACE_FLAG_INHERIT_ONLY);
else if (secrets_fetch_domain_sid(lp_workgroup(), &adm_sid)) {
sid_append_rid(&adm_sid, DOMAIN_USER_RID_ADMIN);
- init_sec_access(&sa, PRINTER_ACE_FULL_CONTROL);
+ sa = PRINTER_ACE_FULL_CONTROL;
init_sec_ace(&ace[i++], &adm_sid,
SEC_ACE_TYPE_ACCESS_ALLOWED, sa,
SEC_ACE_FLAG_OBJECT_INHERIT | SEC_ACE_FLAG_INHERIT_ONLY);
/* add BUILTIN\Administrators as FULL CONTROL */
- init_sec_access(&sa, PRINTER_ACE_FULL_CONTROL);
+ sa = PRINTER_ACE_FULL_CONTROL;
init_sec_ace(&ace[i++], &global_sid_Builtin_Administrators,
SEC_ACE_TYPE_ACCESS_ALLOWED, sa,
SEC_ACE_FLAG_OBJECT_INHERIT | SEC_ACE_FLAG_INHERIT_ONLY);
#include "includes.h"
-typedef struct pcap_cache {
+struct pcap_cache {
char *name;
char *comment;
struct pcap_cache *next;
-} pcap_cache_t;
+};
-static pcap_cache_t *pcap_cache = NULL;
+/* The systemwide printcap cache. */
+static struct pcap_cache *pcap_cache = NULL;
-bool pcap_cache_add(const char *name, const char *comment)
+bool pcap_cache_add_specific(struct pcap_cache **ppcache, const char *name, const char *comment)
{
- pcap_cache_t *p;
+ struct pcap_cache *p;
- if (name == NULL || ((p = SMB_MALLOC_P(pcap_cache_t)) == NULL))
- return False;
+ if (name == NULL || ((p = SMB_MALLOC_P(struct pcap_cache)) == NULL))
+ return false;
p->name = SMB_STRDUP(name);
p->comment = (comment && *comment) ? SMB_STRDUP(comment) : NULL;
- p->next = pcap_cache;
- pcap_cache = p;
+ DEBUG(11,("pcap_cache_add_specific: Adding name %s info %s\n",
+ p->name, p->comment ? p->comment : ""));
+
+ p->next = *ppcache;
+ *ppcache = p;
- return True;
+ return true;
}
-static void pcap_cache_destroy(pcap_cache_t *cache)
+void pcap_cache_destroy_specific(struct pcap_cache **pp_cache)
{
- pcap_cache_t *p, *next;
+ struct pcap_cache *p, *next;
- for (p = cache; p != NULL; p = next) {
+ for (p = *pp_cache; p != NULL; p = next) {
next = p->next;
SAFE_FREE(p->name);
SAFE_FREE(p->comment);
SAFE_FREE(p);
}
+ *pp_cache = NULL;
+}
+
+bool pcap_cache_add(const char *name, const char *comment)
+{
+ return pcap_cache_add_specific(&pcap_cache, name, comment);
}
bool pcap_cache_loaded(void)
return (pcap_cache != NULL);
}
+void pcap_cache_replace(const struct pcap_cache *pcache)
+{
+ const struct pcap_cache *p;
+
+ pcap_cache_destroy_specific(&pcap_cache);
+ for (p = pcache; p; p = p->next) {
+ pcap_cache_add(p->name, p->comment);
+ }
+}
+
void pcap_cache_reload(void)
{
const char *pcap_name = lp_printcapname();
bool pcap_reloaded = False;
- pcap_cache_t *tmp_cache = NULL;
+ struct pcap_cache *tmp_cache = NULL;
XFILE *pcap_file;
char *pcap_line;
DEBUG(3, ("reload status: %s\n", (pcap_reloaded) ? "ok" : "error"));
if (pcap_reloaded)
- pcap_cache_destroy(tmp_cache);
+ pcap_cache_destroy_specific(&tmp_cache);
else {
- pcap_cache_destroy(pcap_cache);
+ pcap_cache_destroy_specific(&pcap_cache);
pcap_cache = tmp_cache;
}
bool pcap_printername_ok(const char *printername)
{
- pcap_cache_t *p;
+ struct pcap_cache *p;
for (p = pcap_cache; p != NULL; p = p->next)
if (strequal(p->name, printername))
}
/***************************************************************************
-run a function on each printer name in the printcap file. The function is
-passed the primary name and the comment (if possible). Note the fn() takes
-strings in DOS codepage. This means the xxx_printer_fn() calls must be fixed
-to return DOS codepage. FIXME !! JRA.
-
-XXX: I'm not sure if this comment still applies.. Anyone? -Rob
+run a function on each printer name in the printcap file.
***************************************************************************/
-void pcap_printer_fn(void (*fn)(char *, char *))
+
+void pcap_printer_fn_specific(const struct pcap_cache *pc,
+ void (*fn)(const char *, const char *, void *),
+ void *pdata)
{
- pcap_cache_t *p;
+ const struct pcap_cache *p;
- for (p = pcap_cache; p != NULL; p = p->next)
- fn(p->name, p->comment);
+ for (p = pc; p != NULL; p = p->next)
+ fn(p->name, p->comment, pdata);
return;
}
+
+void pcap_printer_fn(void (*fn)(const char *, const char *, void *), void *pdata)
+{
+ return pcap_printer_fn_specific(pcap_cache, fn, pdata);
+}
* Support code for the Common UNIX Printing System ("CUPS")
*
* Copyright 1999-2003 by Michael R Sweet.
+ * Copyright 2008 Jeremy Allison.
*
* 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/>.
*/
+/*
+ * JRA. Converted to utf8 pull/push.
+ */
+
#include "includes.h"
#include "printing.h"
#include <cups/cups.h>
#include <cups/language.h>
+static SIG_ATOMIC_T gotalarm;
+
+/***************************************************************
+ Signal function to tell us we timed out.
+****************************************************************/
+
+static void gotalarm_sig(void)
+{
+ gotalarm = 1;
+}
+
extern userdom_struct current_user_info;
/*
return (NULL);
}
-static http_t *cups_connect(void)
+static http_t *cups_connect(TALLOC_CTX *frame)
{
- http_t *http;
- char *server, *p;
+ http_t *http = NULL;
+ char *server = NULL, *p = NULL;
int port;
-
+ int timeout = lp_cups_connection_timeout();
+ size_t size;
+
if (lp_cups_server() != NULL && strlen(lp_cups_server()) > 0) {
- server = smb_xstrdup(lp_cups_server());
+ if (!push_utf8_talloc(frame, &server, lp_cups_server(), &size)) {
+ return NULL;
+ }
} else {
- server = smb_xstrdup(cupsServer());
+ server = talloc_strdup(frame,cupsServer());
+ }
+ if (!server) {
+ return NULL;
}
p = strchr(server, ':');
} else {
port = ippPort();
}
-
+
DEBUG(10, ("connecting to cups server %s:%d\n",
server, port));
- if ((http = httpConnect(server, port)) == NULL) {
- DEBUG(0,("Unable to connect to CUPS server %s:%d - %s\n",
+ gotalarm = 0;
+
+ if (timeout) {
+ CatchSignal(SIGALRM, SIGNAL_CAST gotalarm_sig);
+ alarm(timeout);
+ }
+
+ http = httpConnect(server, port);
+
+ CatchSignal(SIGALRM, SIGNAL_CAST SIG_IGN);
+ alarm(0);
+
+ if (http == NULL) {
+ DEBUG(0,("Unable to connect to CUPS server %s:%d - %s\n",
server, port, strerror(errno)));
- SAFE_FREE(server);
- return NULL;
}
- SAFE_FREE(server);
return http;
}
-bool cups_cache_reload(void)
+static void send_pcap_info(const char *name, const char *info, void *pd)
+{
+ int fd = *(int *)pd;
+ size_t namelen = name ? strlen(name)+1 : 0;
+ size_t infolen = info ? strlen(info)+1 : 0;
+
+ DEBUG(11,("send_pcap_info: writing namelen %u\n", (unsigned int)namelen));
+ if (sys_write(fd, &namelen, sizeof(namelen)) != sizeof(namelen)) {
+ DEBUG(10,("send_pcap_info: namelen write failed %s\n",
+ strerror(errno)));
+ return;
+ }
+ DEBUG(11,("send_pcap_info: writing infolen %u\n", (unsigned int)infolen));
+ if (sys_write(fd, &infolen, sizeof(infolen)) != sizeof(infolen)) {
+ DEBUG(10,("send_pcap_info: infolen write failed %s\n",
+ strerror(errno)));
+ return;
+ }
+ if (namelen) {
+ DEBUG(11,("send_pcap_info: writing name %s\n", name));
+ if (sys_write(fd, name, namelen) != namelen) {
+ DEBUG(10,("send_pcap_info: name write failed %s\n",
+ strerror(errno)));
+ return;
+ }
+ }
+ if (infolen) {
+ DEBUG(11,("send_pcap_info: writing info %s\n", info));
+ if (sys_write(fd, info, infolen) != infolen) {
+ DEBUG(10,("send_pcap_info: info write failed %s\n",
+ strerror(errno)));
+ return;
+ }
+ }
+}
+
+static bool cups_cache_reload_async(int fd)
{
+ TALLOC_CTX *frame = talloc_stackframe();
+ struct pcap_cache *tmp_pcap_cache = NULL;
http_t *http = NULL; /* HTTP connection to server */
ipp_t *request = NULL, /* IPP Request */
*response = NULL; /* IPP Response */
{
"printer-name",
"printer-info"
- };
+ };
bool ret = False;
+ size_t size;
DEBUG(5, ("reloading cups printcap cache\n"));
* Try to connect to the server...
*/
- if ((http = cups_connect()) == NULL) {
+ if ((http = cups_connect(frame)) == NULL) {
goto out;
}
language = cupsLangDefault();
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
- "attributes-charset", NULL, cupsLangEncoding(language));
+ "attributes-charset", NULL, "utf-8");
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL, language->language);
while (attr != NULL && attr->group_tag == IPP_TAG_PRINTER) {
if (strcmp(attr->name, "printer-name") == 0 &&
- attr->value_tag == IPP_TAG_NAME)
- name = attr->values[0].string.text;
+ attr->value_tag == IPP_TAG_NAME) {
+ if (!pull_utf8_talloc(frame,
+ &name,
+ attr->values[0].string.text,
+ &size)) {
+ goto out;
+ }
+ }
if (strcmp(attr->name, "printer-info") == 0 &&
- attr->value_tag == IPP_TAG_TEXT)
- info = attr->values[0].string.text;
+ attr->value_tag == IPP_TAG_TEXT) {
+ if (!pull_utf8_talloc(frame,
+ &info,
+ attr->values[0].string.text,
+ &size)) {
+ goto out;
+ }
+ }
attr = attr->next;
}
if (name == NULL)
break;
- if (!pcap_cache_add(name, info)) {
+ if (!pcap_cache_add_specific(&tmp_pcap_cache, name, info)) {
goto out;
}
}
request->request.op.request_id = 1;
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
- "attributes-charset", NULL, cupsLangEncoding(language));
+ "attributes-charset", NULL, "utf-8");
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL, language->language);
while (attr != NULL && attr->group_tag == IPP_TAG_PRINTER) {
if (strcmp(attr->name, "printer-name") == 0 &&
- attr->value_tag == IPP_TAG_NAME)
- name = attr->values[0].string.text;
+ attr->value_tag == IPP_TAG_NAME) {
+ if (!pull_utf8_talloc(frame,
+ &name,
+ attr->values[0].string.text,
+ &size)) {
+ goto out;
+ }
+ }
if (strcmp(attr->name, "printer-info") == 0 &&
- attr->value_tag == IPP_TAG_TEXT)
- info = attr->values[0].string.text;
+ attr->value_tag == IPP_TAG_TEXT) {
+ if (!pull_utf8_talloc(frame,
+ &info,
+ attr->values[0].string.text,
+ &size)) {
+ goto out;
+ }
+ }
attr = attr->next;
}
if (name == NULL)
break;
- if (!pcap_cache_add(name, info)) {
+ if (!pcap_cache_add_specific(&tmp_pcap_cache, name, info)) {
goto out;
}
}
if (http)
httpClose(http);
+ /* Send all the entries up the pipe. */
+ if (tmp_pcap_cache) {
+ pcap_printer_fn_specific(tmp_pcap_cache,
+ send_pcap_info,
+ (void *)&fd);
+
+ pcap_cache_destroy_specific(&tmp_pcap_cache);
+ }
+ TALLOC_FREE(frame);
return ret;
}
+static struct pcap_cache *local_pcap_copy;
+struct fd_event *cache_fd_event;
+
+static bool cups_pcap_load_async(int *pfd)
+{
+ int fds[2];
+ pid_t pid;
+
+ *pfd = -1;
+
+ if (cache_fd_event) {
+ DEBUG(3,("cups_pcap_load_async: already waiting for "
+ "a refresh event\n" ));
+ return false;
+ }
+
+ DEBUG(5,("cups_pcap_load_async: asynchronously loading cups printers\n"));
+
+ if (pipe(fds) == -1) {
+ return false;
+ }
+
+ pid = sys_fork();
+ if (pid == (pid_t)-1) {
+ DEBUG(10,("cups_pcap_load_async: fork failed %s\n",
+ strerror(errno) ));
+ close(fds[0]);
+ close(fds[1]);
+ return false;
+ }
+
+ if (pid) {
+ DEBUG(10,("cups_pcap_load_async: child pid = %u\n",
+ (unsigned int)pid ));
+ /* Parent. */
+ close(fds[1]);
+ *pfd = fds[0];
+ return true;
+ }
+
+ /* Child. */
+ if (!reinit_after_fork(smbd_messaging_context(), true)) {
+ DEBUG(0,("cups_pcap_load_async: reinit_after_fork() failed\n"));
+ smb_panic("cups_pcap_load_async: reinit_after_fork() failed");
+ }
+
+ close(fds[0]);
+ cups_cache_reload_async(fds[1]);
+ close(fds[1]);
+ _exit(0);
+}
+
+static void cups_async_callback(struct event_context *event_ctx,
+ struct fd_event *event,
+ uint16 flags,
+ void *p)
+{
+ TALLOC_CTX *frame = talloc_stackframe();
+ int fd = *(int *)p;
+ struct pcap_cache *tmp_pcap_cache = NULL;
+
+ DEBUG(5,("cups_async_callback: callback received for printer data. "
+ "fd = %d\n", fd));
+
+ while (1) {
+ char *name = NULL, *info = NULL;
+ size_t namelen = 0, infolen = 0;
+ ssize_t ret = -1;
+
+ ret = sys_read(fd, &namelen, sizeof(namelen));
+ if (ret == 0) {
+ /* EOF */
+ break;
+ }
+ if (ret != sizeof(namelen)) {
+ DEBUG(10,("cups_async_callback: namelen read failed %d %s\n",
+ errno, strerror(errno)));
+ break;
+ }
+
+ DEBUG(11,("cups_async_callback: read namelen %u\n",
+ (unsigned int)namelen));
+
+ ret = sys_read(fd, &infolen, sizeof(infolen));
+ if (ret == 0) {
+ /* EOF */
+ break;
+ }
+ if (ret != sizeof(infolen)) {
+ DEBUG(10,("cups_async_callback: infolen read failed %s\n",
+ strerror(errno)));
+ break;
+ }
+
+ DEBUG(11,("cups_async_callback: read infolen %u\n",
+ (unsigned int)infolen));
+
+ if (namelen) {
+ name = TALLOC_ARRAY(frame, char, namelen);
+ if (!name) {
+ break;
+ }
+ ret = sys_read(fd, name, namelen);
+ if (ret == 0) {
+ /* EOF */
+ break;
+ }
+ if (ret != namelen) {
+ DEBUG(10,("cups_async_callback: name read failed %s\n",
+ strerror(errno)));
+ break;
+ }
+ DEBUG(11,("cups_async_callback: read name %s\n",
+ name));
+ } else {
+ name = NULL;
+ }
+ if (infolen) {
+ info = TALLOC_ARRAY(frame, char, infolen);
+ if (!info) {
+ break;
+ }
+ ret = sys_read(fd, info, infolen);
+ if (ret == 0) {
+ /* EOF */
+ break;
+ }
+ if (ret != infolen) {
+ DEBUG(10,("cups_async_callback: info read failed %s\n",
+ strerror(errno)));
+ break;
+ }
+ DEBUG(11,("cups_async_callback: read info %s\n",
+ info));
+ } else {
+ info = NULL;
+ }
+
+ /* Add to our local pcap cache. */
+ pcap_cache_add_specific(&tmp_pcap_cache, name, info);
+ TALLOC_FREE(name);
+ TALLOC_FREE(info);
+ }
+
+ TALLOC_FREE(frame);
+ if (tmp_pcap_cache) {
+ /* We got a namelist, replace our local cache. */
+ pcap_cache_destroy_specific(&local_pcap_copy);
+ local_pcap_copy = tmp_pcap_cache;
+
+ /* And the systemwide pcap cache. */
+ pcap_cache_replace(local_pcap_copy);
+ } else {
+ DEBUG(2,("cups_async_callback: failed to read a new "
+ "printer list\n"));
+ }
+ close(fd);
+ TALLOC_FREE(p);
+ TALLOC_FREE(cache_fd_event);
+}
+
+bool cups_cache_reload(void)
+{
+ int *p_pipe_fd = TALLOC_P(NULL, int);
+
+ if (!p_pipe_fd) {
+ return false;
+ }
+
+ *p_pipe_fd = -1;
+
+ /* Set up an async refresh. */
+ if (!cups_pcap_load_async(p_pipe_fd)) {
+ return false;
+ }
+ if (!local_pcap_copy) {
+ /* We have no local cache, wait directly for
+ * async refresh to complete.
+ */
+ DEBUG(10,("cups_cache_reload: sync read on fd %d\n",
+ *p_pipe_fd ));
+
+ cups_async_callback(smbd_event_context(),
+ NULL,
+ EVENT_FD_READ,
+ (void *)p_pipe_fd);
+ if (!local_pcap_copy) {
+ return false;
+ }
+ } else {
+ /* Replace the system cache with our
+ * local copy. */
+ pcap_cache_replace(local_pcap_copy);
+
+ DEBUG(10,("cups_cache_reload: async read on fd %d\n",
+ *p_pipe_fd ));
+
+ /* Trigger an event when the pipe can be read. */
+ cache_fd_event = event_add_fd(smbd_event_context(),
+ NULL, *p_pipe_fd,
+ EVENT_FD_READ,
+ cups_async_callback,
+ (void *)p_pipe_fd);
+ if (!cache_fd_event) {
+ close(*p_pipe_fd);
+ TALLOC_FREE(p_pipe_fd);
+ return false;
+ }
+ }
+ return true;
+}
/*
* 'cups_job_delete()' - Delete a job.
static int cups_job_delete(const char *sharename, const char *lprm_command, struct printjob *pjob)
{
+ TALLOC_CTX *frame = talloc_stackframe();
int ret = 1; /* Return value */
http_t *http = NULL; /* HTTP connection to server */
ipp_t *request = NULL, /* IPP Request */
*response = NULL; /* IPP Response */
cups_lang_t *language = NULL; /* Default language */
+ char *user = NULL;
char uri[HTTP_MAX_URI]; /* printer-uri attribute */
-
+ size_t size;
DEBUG(5,("cups_job_delete(%s, %p (%d))\n", sharename, pjob, pjob->sysjob));
* Try to connect to the server...
*/
- if ((http = cups_connect()) == NULL) {
+ if ((http = cups_connect(frame)) == NULL) {
goto out;
}
language = cupsLangDefault();
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
- "attributes-charset", NULL, cupsLangEncoding(language));
+ "attributes-charset", NULL, "utf-8");
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL, language->language);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "job-uri", NULL, uri);
+ if (!push_utf8_talloc(frame, &user, pjob->user, &size)) {
+ goto out;
+ }
+
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
- NULL, pjob->user);
+ NULL, user);
/*
* Do the request and get back a response...
if (http)
httpClose(http);
+ TALLOC_FREE(frame);
return ret;
}
static int cups_job_pause(int snum, struct printjob *pjob)
{
+ TALLOC_CTX *frame = talloc_stackframe();
int ret = 1; /* Return value */
http_t *http = NULL; /* HTTP connection to server */
ipp_t *request = NULL, /* IPP Request */
*response = NULL; /* IPP Response */
cups_lang_t *language = NULL; /* Default language */
+ char *user = NULL;
char uri[HTTP_MAX_URI]; /* printer-uri attribute */
-
+ size_t size;
DEBUG(5,("cups_job_pause(%d, %p (%d))\n", snum, pjob, pjob->sysjob));
* Try to connect to the server...
*/
- if ((http = cups_connect()) == NULL) {
+ if ((http = cups_connect(frame)) == NULL) {
goto out;
}
language = cupsLangDefault();
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
- "attributes-charset", NULL, cupsLangEncoding(language));
+ "attributes-charset", NULL, "utf-8");
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL, language->language);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "job-uri", NULL, uri);
+ if (!push_utf8_talloc(frame, &user, pjob->user, &size)) {
+ goto out;
+ }
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
- NULL, pjob->user);
+ NULL, user);
/*
* Do the request and get back a response...
if (http)
httpClose(http);
+ TALLOC_FREE(frame);
return ret;
}
static int cups_job_resume(int snum, struct printjob *pjob)
{
+ TALLOC_CTX *frame = talloc_stackframe();
int ret = 1; /* Return value */
http_t *http = NULL; /* HTTP connection to server */
ipp_t *request = NULL, /* IPP Request */
*response = NULL; /* IPP Response */
cups_lang_t *language = NULL; /* Default language */
+ char *user = NULL;
char uri[HTTP_MAX_URI]; /* printer-uri attribute */
-
+ size_t size;
DEBUG(5,("cups_job_resume(%d, %p (%d))\n", snum, pjob, pjob->sysjob));
* Try to connect to the server...
*/
- if ((http = cups_connect()) == NULL) {
+ if ((http = cups_connect(frame)) == NULL) {
goto out;
}
language = cupsLangDefault();
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
- "attributes-charset", NULL, cupsLangEncoding(language));
+ "attributes-charset", NULL, "utf-8");
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL, language->language);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "job-uri", NULL, uri);
+ if (!push_utf8_talloc(frame, &user, pjob->user, &size)) {
+ goto out;
+ }
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
- NULL, pjob->user);
+ NULL, user);
/*
* Do the request and get back a response...
if (http)
httpClose(http);
+ TALLOC_FREE(frame);
return ret;
}
static int cups_job_submit(int snum, struct printjob *pjob)
{
+ TALLOC_CTX *frame = talloc_stackframe();
int ret = 1; /* Return value */
http_t *http = NULL; /* HTTP connection to server */
ipp_t *request = NULL, /* IPP Request */
char *new_jobname = NULL;
int num_options = 0;
cups_option_t *options = NULL;
+ char *printername = NULL;
+ char *user = NULL;
+ char *jobname = NULL;
+ char *cupsoptions = NULL;
+ char *filename = NULL;
+ size_t size;
char addr[INET6_ADDRSTRLEN];
DEBUG(5,("cups_job_submit(%d, %p (%d))\n", snum, pjob, pjob->sysjob));
* Try to connect to the server...
*/
- if ((http = cups_connect()) == NULL) {
+ if ((http = cups_connect(frame)) == NULL) {
goto out;
}
language = cupsLangDefault();
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
- "attributes-charset", NULL, cupsLangEncoding(language));
+ "attributes-charset", NULL, "utf-8");
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL, language->language);
+ if (!push_utf8_talloc(frame, &printername, PRINTERNAME(snum), &size)) {
+ goto out;
+ }
slprintf(uri, sizeof(uri) - 1, "ipp://localhost/printers/%s",
- PRINTERNAME(snum));
+ printername);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
"printer-uri", NULL, uri);
+ if (!push_utf8_talloc(frame, &user, pjob->user, &size)) {
+ goto out;
+ }
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
- NULL, pjob->user);
+ NULL, user);
clientname = client_name(get_client_fd());
if (strcmp(clientname, "UNKNOWN") == 0) {
"job-originating-host-name", NULL,
clientname);
- if (asprintf(&new_jobname,"%s%.8u %s", PRINT_SPOOL_PREFIX,
- (unsigned int)pjob->smbjob, pjob->jobname) < 0) {
+ if (!push_utf8_talloc(frame, &jobname, pjob->jobname, &size)) {
+ goto out;
+ }
+ new_jobname = talloc_asprintf(frame,
+ "%s%.8u %s", PRINT_SPOOL_PREFIX,
+ (unsigned int)pjob->smbjob,
+ jobname);
+ if (new_jobname == NULL) {
goto out;
}
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "job-name", NULL,
new_jobname);
- /*
- * add any options defined in smb.conf
+ /*
+ * add any options defined in smb.conf
*/
+ if (!push_utf8_talloc(frame, &cupsoptions, lp_cups_options(snum), &size)) {
+ goto out;
+ }
num_options = 0;
options = NULL;
- num_options = cupsParseOptions(lp_cups_options(snum), num_options, &options);
+ num_options = cupsParseOptions(cupsoptions, num_options, &options);
if ( num_options )
- cupsEncodeOptions(request, num_options, options);
+ cupsEncodeOptions(request, num_options, options);
/*
* Do the request and get back a response...
*/
- slprintf(uri, sizeof(uri) - 1, "/printers/%s", PRINTERNAME(snum));
+ slprintf(uri, sizeof(uri) - 1, "/printers/%s", printername);
+ if (!push_utf8_talloc(frame, &filename, pjob->filename, &size)) {
+ goto out;
+ }
if ((response = cupsDoFileRequest(http, request, uri, pjob->filename)) != NULL) {
if (response->request.status.status_code >= IPP_OK_CONFLICT) {
DEBUG(0,("Unable to print file to %s - %s\n", PRINTERNAME(snum),
if (http)
httpClose(http);
- SAFE_FREE(new_jobname);
+ TALLOC_FREE(frame);
return ret;
}
static int cups_queue_get(const char *sharename,
enum printing_types printing_type,
char *lpq_command,
- print_queue_struct **q,
+ print_queue_struct **q,
print_status_struct *status)
{
- fstring printername;
+ TALLOC_CTX *frame = talloc_stackframe();
+ char *printername = NULL;
http_t *http = NULL; /* HTTP connection to server */
ipp_t *request = NULL, /* IPP Request */
*response = NULL; /* IPP Response */
qalloc = 0; /* Number of queue entries allocated */
print_queue_struct *queue = NULL, /* Queue entries */
*temp; /* Temporary pointer for queue */
- const char *user_name, /* job-originating-user-name attribute */
- *job_name; /* job-name attribute */
+ char *user_name = NULL, /* job-originating-user-name attribute */
+ *job_name = NULL; /* job-name attribute */
int job_id; /* job-id attribute */
int job_k_octets; /* job-k-octets attribute */
time_t job_time; /* time-at-creation attribute */
ipp_jstate_t job_status; /* job-status attribute */
int job_priority; /* job-priority attribute */
+ size_t size;
static const char *jattrs[] = /* Requested job attributes */
{
"job-id",
*q = NULL;
- /* HACK ALERT!!! The problem with support the 'printer name'
- option is that we key the tdb off the sharename. So we will
- overload the lpq_command string to pass in the printername
- (which is basically what we do for non-cups printers ... using
+ /* HACK ALERT!!! The problem with support the 'printer name'
+ option is that we key the tdb off the sharename. So we will
+ overload the lpq_command string to pass in the printername
+ (which is basically what we do for non-cups printers ... using
the lpq_command to get the queue listing). */
- fstrcpy( printername, lpq_command );
-
- DEBUG(5,("cups_queue_get(%s, %p, %p)\n", printername, q, status));
+ if (!push_utf8_talloc(frame, &printername, lpq_command, &size)) {
+ goto out;
+ }
+ DEBUG(5,("cups_queue_get(%s, %p, %p)\n", lpq_command, q, status));
/*
* Make sure we don't ask for passwords...
* Try to connect to the server...
*/
- if ((http = cups_connect()) == NULL) {
+ if ((http = cups_connect(frame)) == NULL) {
goto out;
}
language = cupsLangDefault();
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
- "attributes-charset", NULL, cupsLangEncoding(language));
+ "attributes-charset", NULL, "utf-8");
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL, language->language);
job_time = attr->values[0].integer;
if (strcmp(attr->name, "job-name") == 0 &&
- attr->value_tag == IPP_TAG_NAME)
- job_name = attr->values[0].string.text;
+ attr->value_tag == IPP_TAG_NAME) {
+ if (!pull_utf8_talloc(frame,
+ &job_name,
+ attr->values[0].string.text,
+ &size)) {
+ goto out;
+ }
+ }
if (strcmp(attr->name, "job-originating-user-name") == 0 &&
- attr->value_tag == IPP_TAG_NAME)
- user_name = attr->values[0].string.text;
+ attr->value_tag == IPP_TAG_NAME) {
+ if (!pull_utf8_talloc(frame,
+ &user_name,
+ attr->values[0].string.text,
+ &size)) {
+ goto out;
+ }
+ }
attr = attr->next;
}
LPQ_PRINTING;
temp->priority = job_priority;
temp->time = job_time;
- strncpy(temp->fs_user, user_name, sizeof(temp->fs_user) - 1);
- strncpy(temp->fs_file, job_name, sizeof(temp->fs_file) - 1);
+ strlcpy(temp->fs_user, user_name, sizeof(temp->fs_user));
+ strlcpy(temp->fs_file, job_name, sizeof(temp->fs_file));
qcount ++;
request->request.op.request_id = 1;
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
- "attributes-charset", NULL, cupsLangEncoding(language));
+ "attributes-charset", NULL, "utf-8");
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL, language->language);
}
if ((attr = ippFindAttribute(response, "printer-state-message",
- IPP_TAG_TEXT)) != NULL)
- fstrcpy(status->message, attr->values[0].string.text);
+ IPP_TAG_TEXT)) != NULL) {
+ char *msg = NULL;
+ if (!pull_utf8_talloc(frame, &msg,
+ attr->values[0].string.text,
+ &size)) {
+ goto out;
+ }
+ fstrcpy(status->message, msg);
+ }
/*
* Return the job queue...
if (http)
httpClose(http);
+ TALLOC_FREE(frame);
return qcount;
}
static int cups_queue_pause(int snum)
{
+ TALLOC_CTX *frame = talloc_stackframe();
int ret = 1; /* Return value */
http_t *http = NULL; /* HTTP connection to server */
ipp_t *request = NULL, /* IPP Request */
*response = NULL; /* IPP Response */
cups_lang_t *language = NULL; /* Default language */
+ char *printername = NULL;
+ char *username = NULL;
char uri[HTTP_MAX_URI]; /* printer-uri attribute */
-
+ size_t size;
DEBUG(5,("cups_queue_pause(%d)\n", snum));
* Try to connect to the server...
*/
- if ((http = cups_connect()) == NULL) {
+ if ((http = cups_connect(frame)) == NULL) {
goto out;
}
language = cupsLangDefault();
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
- "attributes-charset", NULL, cupsLangEncoding(language));
+ "attributes-charset", NULL, "utf-8");
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL, language->language);
+ if (!push_utf8_talloc(frame, &printername, PRINTERNAME(snum), &size)) {
+ goto out;
+ }
slprintf(uri, sizeof(uri) - 1, "ipp://localhost/printers/%s",
- PRINTERNAME(snum));
+ printername);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, uri);
+ if (!push_utf8_talloc(frame, &username, current_user_info.unix_name, &size)) {
+ goto out;
+ }
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
- NULL, current_user_info.unix_name);
+ NULL, username);
/*
* Do the request and get back a response...
if (http)
httpClose(http);
+ TALLOC_FREE(frame);
return ret;
}
static int cups_queue_resume(int snum)
{
+ TALLOC_CTX *frame = talloc_stackframe();
int ret = 1; /* Return value */
http_t *http = NULL; /* HTTP connection to server */
ipp_t *request = NULL, /* IPP Request */
*response = NULL; /* IPP Response */
cups_lang_t *language = NULL; /* Default language */
+ char *printername = NULL;
+ char *username = NULL;
char uri[HTTP_MAX_URI]; /* printer-uri attribute */
-
+ size_t size;
DEBUG(5,("cups_queue_resume(%d)\n", snum));
* Try to connect to the server...
*/
- if ((http = cups_connect()) == NULL) {
+ if ((http = cups_connect(frame)) == NULL) {
goto out;
}
language = cupsLangDefault();
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
- "attributes-charset", NULL, cupsLangEncoding(language));
+ "attributes-charset", NULL, "utf-8");
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL, language->language);
+ if (!push_utf8_talloc(frame, &printername, PRINTERNAME(snum), &size)) {
+ goto out;
+ }
slprintf(uri, sizeof(uri) - 1, "ipp://localhost/printers/%s",
- PRINTERNAME(snum));
+ printername);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, uri);
+ if (!push_utf8_talloc(frame, &username, current_user_info.unix_name, &size)) {
+ goto out;
+ }
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
- NULL, current_user_info.unix_name);
+ NULL, username);
/*
* Do the request and get back a response...
if (http)
httpClose(http);
+ TALLOC_FREE(frame);
return ret;
}
bool cups_pull_comment_location(NT_PRINTER_INFO_LEVEL_2 *printer)
{
+ TALLOC_CTX *frame = talloc_stackframe();
http_t *http = NULL; /* HTTP connection to server */
ipp_t *request = NULL, /* IPP Request */
*response = NULL; /* IPP Response */
ipp_attribute_t *attr; /* Current attribute */
cups_lang_t *language = NULL; /* Default language */
- char *name, /* printer-name attribute */
- *info, /* printer-info attribute */
- *location; /* printer-location attribute */
char uri[HTTP_MAX_URI];
+ char *server = NULL;
+ char *sharename = NULL;
+ char *name = NULL;
static const char *requested[] =/* Requested attributes */
{
"printer-name",
"printer-location"
};
bool ret = False;
+ size_t size;
DEBUG(5, ("pulling %s location\n", printer->sharename));
* Try to connect to the server...
*/
- if ((http = cups_connect()) == NULL) {
+ if ((http = cups_connect(frame)) == NULL) {
goto out;
}
language = cupsLangDefault();
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
- "attributes-charset", NULL, cupsLangEncoding(language));
+ "attributes-charset", NULL, "utf-8");
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL, language->language);
+ if (lp_cups_server() != NULL && strlen(lp_cups_server()) > 0) {
+ if (!push_utf8_talloc(frame, &server, lp_cups_server(), &size)) {
+ goto out;
+ }
+ } else {
+ server = talloc_strdup(frame,cupsServer());
+ }
+ if (server) {
+ goto out;
+ }
+ if (!push_utf8_talloc(frame, &sharename, printer->sharename, &size)) {
+ goto out;
+ }
slprintf(uri, sizeof(uri) - 1, "ipp://%s/printers/%s",
- lp_cups_server(), printer->sharename);
+ server, sharename);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
"printer-uri", NULL, uri);
* Pull the needed attributes from this printer...
*/
- name = NULL;
- info = NULL;
- location = NULL;
-
while ( attr && (attr->group_tag == IPP_TAG_PRINTER) ) {
+ if (strcmp(attr->name, "printer-name") == 0 &&
+ attr->value_tag == IPP_TAG_NAME) {
+ if (!pull_utf8_talloc(frame,
+ &name,
+ attr->values[0].string.text,
+ &size)) {
+ goto out;
+ }
+ }
+
/* Grab the comment if we don't have one */
if ( (strcmp(attr->name, "printer-info") == 0)
&& (attr->value_tag == IPP_TAG_TEXT)
- && !strlen(printer->comment) )
+ && !strlen(printer->comment) )
{
+ char *comment = NULL;
+ if (!pull_utf8_talloc(frame,
+ &comment,
+ attr->values[0].string.text,
+ &size)) {
+ goto out;
+ }
DEBUG(5,("cups_pull_comment_location: Using cups comment: %s\n",
- attr->values[0].string.text));
+ comment));
strlcpy(printer->comment,
- attr->values[0].string.text,
- sizeof(printer->comment));
+ comment,
+ sizeof(printer->comment));
}
- /* Grab the location if we don't have one */
+ /* Grab the location if we don't have one */
if ( (strcmp(attr->name, "printer-location") == 0)
- && (attr->value_tag == IPP_TAG_TEXT)
+ && (attr->value_tag == IPP_TAG_TEXT)
&& !strlen(printer->location) )
{
+ char *location = NULL;
+ if (!pull_utf8_talloc(frame,
+ &location,
+ attr->values[0].string.text,
+ &size)) {
+ goto out;
+ }
DEBUG(5,("cups_pull_comment_location: Using cups location: %s\n",
- attr->values[0].string.text));
- fstrcpy(printer->location,attr->values[0].string.text);
+ location));
+ strlcpy(printer->location,
+ location,
+ sizeof(printer->location));
}
attr = attr->next;
}
/*
- * See if we have everything needed...
+ * We have everything needed...
*/
- if (name == NULL)
+ if (name != NULL)
break;
-
}
ret = True;
if (http)
httpClose(http);
+ TALLOC_FREE(frame);
return ret;
}
static WERROR construct_registry_sd(TALLOC_CTX *ctx, SEC_DESC **psd)
{
SEC_ACE ace[3];
- SEC_ACCESS mask;
size_t i = 0;
SEC_DESC *sd;
SEC_ACL *acl;
/* basic access for Everyone */
- init_sec_access(&mask, REG_KEY_READ);
init_sec_ace(&ace[i++], &global_sid_World, SEC_ACE_TYPE_ACCESS_ALLOWED,
- mask, 0);
+ REG_KEY_READ, 0);
/* Full Access 'BUILTIN\Administrators' */
- init_sec_access(&mask, REG_KEY_ALL);
init_sec_ace(&ace[i++], &global_sid_Builtin_Administrators,
- SEC_ACE_TYPE_ACCESS_ALLOWED, mask, 0);
+ SEC_ACE_TYPE_ACCESS_ALLOWED, REG_KEY_ALL, 0);
/* Full Access 'NT Authority\System' */
- init_sec_access(&mask, REG_KEY_ALL );
init_sec_ace(&ace[i++], &global_sid_System, SEC_ACE_TYPE_ACCESS_ALLOWED,
- mask, 0);
+ REG_KEY_ALL, 0);
/* create the security descriptor */
return result;
}
+
+/*********************************************************
+ Change the domain password on the PDC.
+
+ Just changes the password betwen the two values specified.
+
+ Caller must have the cli connected to the netlogon pipe
+ already.
+**********************************************************/
+
+NTSTATUS rpccli_netlogon_set_trust_password(struct rpc_pipe_client *cli,
+ TALLOC_CTX *mem_ctx,
+ const unsigned char orig_trust_passwd_hash[16],
+ const char *new_trust_pwd_cleartext,
+ const unsigned char new_trust_passwd_hash[16],
+ uint32_t sec_channel_type)
+{
+ NTSTATUS result;
+ uint32_t neg_flags = NETLOGON_NEG_AUTH2_ADS_FLAGS;
+ struct netr_Authenticator clnt_creds, srv_cred;
+
+ result = rpccli_netlogon_setup_creds(cli,
+ cli->desthost, /* server name */
+ lp_workgroup(), /* domain */
+ global_myname(), /* client name */
+ global_myname(), /* machine account name */
+ orig_trust_passwd_hash,
+ sec_channel_type,
+ &neg_flags);
+
+ if (!NT_STATUS_IS_OK(result)) {
+ DEBUG(3,("rpccli_netlogon_set_trust_password: unable to setup creds (%s)!\n",
+ nt_errstr(result)));
+ return result;
+ }
+
+ netlogon_creds_client_step(cli->dc, &clnt_creds);
+
+ if (neg_flags & NETLOGON_NEG_PASSWORD_SET2) {
+
+ struct netr_CryptPassword new_password;
+
+ init_netr_CryptPassword(new_trust_pwd_cleartext,
+ cli->dc->sess_key,
+ &new_password);
+
+ result = rpccli_netr_ServerPasswordSet2(cli, mem_ctx,
+ cli->dc->remote_machine,
+ cli->dc->mach_acct,
+ sec_channel_type,
+ global_myname(),
+ &clnt_creds,
+ &srv_cred,
+ &new_password);
+ if (!NT_STATUS_IS_OK(result)) {
+ DEBUG(0,("rpccli_netr_ServerPasswordSet2 failed: %s\n",
+ nt_errstr(result)));
+ return result;
+ }
+ } else {
+
+ struct samr_Password new_password;
+
+ cred_hash3(new_password.hash,
+ new_trust_passwd_hash,
+ cli->dc->sess_key, 1);
+
+ result = rpccli_netr_ServerPasswordSet(cli, mem_ctx,
+ cli->dc->remote_machine,
+ cli->dc->mach_acct,
+ sec_channel_type,
+ global_myname(),
+ &clnt_creds,
+ &srv_cred,
+ &new_password);
+ if (!NT_STATUS_IS_OK(result)) {
+ DEBUG(0,("rpccli_netr_ServerPasswordSet failed: %s\n",
+ nt_errstr(result)));
+ return result;
+ }
+ }
+
+ /* Always check returned credentials. */
+ if (!netlogon_creds_client_check(cli->dc, &srv_cred.cred)) {
+ DEBUG(0,("credentials chain check failed\n"));
+ return NT_STATUS_ACCESS_DENIED;
+ }
+
+ return result;
+}
+
r->lmpassword = lmpassword;
r->ntpassword = ntpassword;
}
+
+/*************************************************************************
+ inits a netr_CryptPassword structure
+ *************************************************************************/
+
+void init_netr_CryptPassword(const char *pwd,
+ unsigned char session_key[16],
+ struct netr_CryptPassword *pwd_buf)
+{
+ struct samr_CryptPassword password_buf;
+
+ encode_pw_buffer(password_buf.data, pwd, STR_UNICODE);
+
+ SamOEMhash(password_buf.data, session_key, 516);
+ memcpy(pwd_buf->data, password_buf.data, 512);
+ pwd_buf->length = IVAL(password_buf.data, 512);
+}
prs_mem_free( &r_ps );
- pull = ndr_pull_init_blob(&blob, mem_ctx);
+ pull = ndr_pull_init_blob(&blob, mem_ctx, NULL);
if (pull == NULL) {
return NT_STATUS_NO_MEMORY;
}
DOM_SID adm_sid;
SEC_ACE ace[3];
- SEC_ACCESS mask;
SEC_ACL *psa = NULL;
- init_sec_access(&mask, LSA_POLICY_EXECUTE);
- init_sec_ace(&ace[0], &global_sid_World, SEC_ACE_TYPE_ACCESS_ALLOWED, mask, 0);
+ init_sec_ace(&ace[0], &global_sid_World, SEC_ACE_TYPE_ACCESS_ALLOWED, LSA_POLICY_EXECUTE, 0);
sid_copy(&adm_sid, get_global_sam_sid());
sid_append_rid(&adm_sid, DOMAIN_GROUP_RID_ADMINS);
- init_sec_access(&mask, LSA_POLICY_ALL_ACCESS);
- init_sec_ace(&ace[1], &adm_sid, SEC_ACE_TYPE_ACCESS_ALLOWED, mask, 0);
+ init_sec_ace(&ace[1], &adm_sid, SEC_ACE_TYPE_ACCESS_ALLOWED, LSA_POLICY_ALL_ACCESS, 0);
sid_copy(&local_adm_sid, &global_sid_Builtin);
sid_append_rid(&local_adm_sid, BUILTIN_ALIAS_RID_ADMINS);
- init_sec_access(&mask, LSA_POLICY_ALL_ACCESS);
- init_sec_ace(&ace[2], &local_adm_sid, SEC_ACE_TYPE_ACCESS_ALLOWED, mask, 0);
+ init_sec_ace(&ace[2], &local_adm_sid, SEC_ACE_TYPE_ACCESS_ALLOWED, LSA_POLICY_ALL_ACCESS, 0);
if((psa = make_sec_acl(mem_ctx, NT4_ACL_REVISION, 3, ace)) == NULL)
return NT_STATUS_NO_MEMORY;
{
DOM_SID domadmin_sid;
SEC_ACE ace[5]; /* at most 5 entries */
- SEC_ACCESS mask;
size_t i = 0;
SEC_ACL *psa = NULL;
/* basic access for Everyone */
- init_sec_access(&mask, map->generic_execute | map->generic_read );
- init_sec_ace(&ace[i++], &global_sid_World, SEC_ACE_TYPE_ACCESS_ALLOWED, mask, 0);
+ init_sec_ace(&ace[i++], &global_sid_World, SEC_ACE_TYPE_ACCESS_ALLOWED,
+ map->generic_execute | map->generic_read, 0);
/* add Full Access 'BUILTIN\Administrators' and 'BUILTIN\Account Operators */
- init_sec_access(&mask, map->generic_all);
-
- init_sec_ace(&ace[i++], &global_sid_Builtin_Administrators, SEC_ACE_TYPE_ACCESS_ALLOWED, mask, 0);
- init_sec_ace(&ace[i++], &global_sid_Builtin_Account_Operators, SEC_ACE_TYPE_ACCESS_ALLOWED, mask, 0);
+ init_sec_ace(&ace[i++], &global_sid_Builtin_Administrators,
+ SEC_ACE_TYPE_ACCESS_ALLOWED, map->generic_all, 0);
+ init_sec_ace(&ace[i++], &global_sid_Builtin_Account_Operators,
+ SEC_ACE_TYPE_ACCESS_ALLOWED, map->generic_all, 0);
/* Add Full Access for Domain Admins if we are a DC */
if ( IS_DC ) {
sid_copy( &domadmin_sid, get_global_sam_sid() );
sid_append_rid( &domadmin_sid, DOMAIN_GROUP_RID_ADMINS );
- init_sec_ace(&ace[i++], &domadmin_sid, SEC_ACE_TYPE_ACCESS_ALLOWED, mask, 0);
+ init_sec_ace(&ace[i++], &domadmin_sid,
+ SEC_ACE_TYPE_ACCESS_ALLOWED, map->generic_all, 0);
}
/* if we have a sid, give it some special access */
if ( sid ) {
- init_sec_access( &mask, sid_access );
- init_sec_ace(&ace[i++], sid, SEC_ACE_TYPE_ACCESS_ALLOWED, mask, 0);
+ init_sec_ace(&ace[i++], sid, SEC_ACE_TYPE_ACCESS_ALLOWED, sid_access, 0);
}
/* create the security descriptor */
DEBUG(5,("_srvsvc_NetShareAdd: %d\n", __LINE__));
- *r->out.parm_error = 0;
+ if (r->out.parm_error) {
+ *r->out.parm_error = 0;
+ }
get_current_user(&user,p);
connection_struct *conn = NULL;
int snum;
char *oldcwd = NULL;
+ struct security_descriptor *psd = NULL;
+ uint32_t security_info_sent = 0;
ZERO_STRUCT(st);
goto error_exit;
}
+ psd = r->in.sd_buf->sd;
+ security_info_sent = r->in.securityinformation;
+
+ if (psd->owner_sid==0) {
+ security_info_sent &= ~OWNER_SECURITY_INFORMATION;
+ }
+ if (psd->group_sid==0) {
+ security_info_sent &= ~GROUP_SECURITY_INFORMATION;
+ }
+ if (psd->sacl==0) {
+ security_info_sent &= ~SACL_SECURITY_INFORMATION;
+ }
+ if (psd->dacl==0) {
+ security_info_sent &= ~DACL_SECURITY_INFORMATION;
+ }
+
+ /* Convert all the generic bits. */
+ security_acl_map_generic(psd->dacl, &file_generic_mapping);
+ security_acl_map_generic(psd->sacl, &file_generic_mapping);
+
nt_status = SMB_VFS_FSET_NT_ACL(fsp,
- r->in.securityinformation,
- r->in.sd_buf->sd);
+ security_info_sent,
+ psd);
if (!NT_STATUS_IS_OK(nt_status) ) {
DEBUG(3,("_srvsvc_NetSetFileSecurity: Unable to set NT ACL "
static SEC_DESC* construct_scm_sd( TALLOC_CTX *ctx )
{
SEC_ACE ace[2];
- SEC_ACCESS mask;
size_t i = 0;
SEC_DESC *sd;
SEC_ACL *acl;
/* basic access for Everyone */
- init_sec_access(&mask, SC_MANAGER_READ_ACCESS );
- init_sec_ace(&ace[i++], &global_sid_World, SEC_ACE_TYPE_ACCESS_ALLOWED, mask, 0);
+ init_sec_ace(&ace[i++], &global_sid_World,
+ SEC_ACE_TYPE_ACCESS_ALLOWED, SC_MANAGER_READ_ACCESS, 0);
/* Full Access 'BUILTIN\Administrators' */
- init_sec_access(&mask,SC_MANAGER_ALL_ACCESS );
- init_sec_ace(&ace[i++], &global_sid_Builtin_Administrators, SEC_ACE_TYPE_ACCESS_ALLOWED, mask, 0);
+ init_sec_ace(&ace[i++], &global_sid_Builtin_Administrators,
+ SEC_ACE_TYPE_ACCESS_ALLOWED, SC_MANAGER_ALL_ACCESS, 0);
/* create the security descriptor */
]
)
-SMB_EXT_LIB_FROM_PKGCONFIG(LIBTDB, tdb >= 1.1.0,
+SMB_EXT_LIB_FROM_PKGCONFIG(LIBTDB, tdb >= 1.1.3,
[],
[
m4_include(../lib/tdb/libtdb.m4)
m4_include(auth/config.m4)
m4_include(kdc/config.m4)
m4_include(ntvfs/sysdep/config.m4)
-m4_include(lib/appweb/config.m4)
m4_include(nsswitch/config.m4)
dnl Samba 4 files
MDLD = $(SHLD)
MDLD_FLAGS = $(LDSHFLAGS)
-samba4srcdir = $(call abspath,$(srcdir)/../source4)
+samba4srcdir = $(srcdir)/../source4
# Flags used for the samba 4 files
# $(srcdir)/include is required for config.h
poptsrcdir := $(samba4srcdir)/../lib/popt
socketwrappersrcdir := $(samba4srcdir)/../lib/socket_wrapper
nsswrappersrcdir := $(samba4srcdir)/../lib/nss_wrapper
-appwebsrcdir := $(samba4srcdir)/lib/appweb
libstreamsrcdir := $(samba4srcdir)/lib/stream
libutilsrcdir := $(samba4srcdir)/lib/util
libtdrsrcdir := $(samba4srcdir)/lib/tdr
libdbwrapsrcdir := $(samba4srcdir)/lib/dbwrap
-libcryptosrcdir := $(samba4srcdir)/lib/crypto
+libcryptosrcdir := $(samba4srcdir)/../lib/crypto
libtorturesrcdir := $(samba4srcdir)/lib/torture
libcompressionsrcdir := $(samba4srcdir)/../lib/compression
libgencachesrcdir := $(samba4srcdir)/lib
ntptrsrcdir := $(samba4srcdir)/ntptr
clientsrcdir := $(samba4srcdir)/client
libclisrcdir := $(samba4srcdir)/libcli
-ejsscriptsrcdir := $(samba4srcdir)/scripting/ejs
+libclinbtsrcdir := $(samba4srcdir)/../libcli/nbt
pyscriptsrcdir := $(samba4srcdir)/scripting/python
kdcsrcdir := $(samba4srcdir)/kdc
smbreadlinesrcdir := $(samba4srcdir)/lib/smbreadline
tdbsrcdir := $(samba4srcdir)/../lib/tdb
ldbsrcdir := $(samba4srcdir)/lib/ldb
tallocsrcdir := $(samba4srcdir)/../lib/talloc
+comsrcdir := $(samba4srcdir)/lib/com
override ASN1C = bin/asn1_compile4
override ET_COMPILER = bin/compile_et4
include samba4-data.mk
proto:: $(PROTO_HEADERS)
modules:: $(PLUGINS)
-all:: basics bin/smbd4 bin/regpatch4 bin/regdiff4 bin/regshell4 bin/regtree4 bin/smbclient4
+all:: basics bin/samba4 bin/regpatch4 bin/regdiff4 bin/regshell4 bin/regtree4 bin/smbclient4
torture:: basics bin/smbtorture4
everything:: basics $(patsubst %,%4,$(BINARIES))
basename=`basename $f .idl`
ndr="librpc/gen_ndr/ndr_$basename.c"
- if [ -f $ndr ] && false; then
+ if [ -f $ndr ]; then
if [ "x`find librpc/idl/$f -newer $ndr -print`" = "xlibrpc/idl/$f" ]; then
list="$list librpc/idl/$f"
fi
--- /dev/null
+#!/bin/sh
+#
+# Copyright (C) Guenther Deschner 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.
+#
+# 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/>.
+
+tempdir=`mktemp -d /tmp/wb_padXXXXXX`
+test -n "$tempdir" || exit 1
+cat >> $tempdir/wb_pad.c << _EOF
+#include "nsswitch/winbind_client.h"
+
+int main(int argc, const char **argv)
+{
+ struct winbindd_request req;
+ struct winbindd_response resp;
+
+ if (argc != 2) {
+ printf("usage: %s [req|resp]\n", argv[0]);
+ return 0;
+ }
+
+ if (strcmp(argv[1], "req") == 0) {
+ printf("%d\n", (uint32_t)sizeof(req));
+ }
+ if (strcmp(argv[1], "resp") == 0) {
+ printf("%d\n", (uint32_t)sizeof(resp));
+ }
+
+ return 0;
+}
+_EOF
+
+cleanup() {
+ rm -f $tempdir/wb_pad_32 $tempdir/wb_pad_64 $tempdir/wb_pad.c
+ rmdir $tempdir
+}
+
+cflags="-I. -I./../lib/replace -Iinclude"
+${CC:-gcc} -m32 $RPM_OPT_FLAGS $CFLAGS -o $tempdir/wb_pad_32 $cflags $tempdir/wb_pad.c
+if [ $? -ne 0 ]; then
+ cleanup
+ exit 1
+fi
+${CC:-gcc} -m64 $RPM_OPT_FLAGS $CFLAGS -o $tempdir/wb_pad_64 $cflags $tempdir/wb_pad.c
+if [ $? -ne 0 ]; then
+ cleanup
+ exit 1
+fi
+
+out_64_req=`$tempdir/wb_pad_64 req`
+out_64_resp=`$tempdir/wb_pad_64 resp`
+out_32_req=`$tempdir/wb_pad_32 req`
+out_32_resp=`$tempdir/wb_pad_32 resp`
+
+cleanup
+
+if test "$out_64_req" != "$out_32_req"; then
+ echo "winbind request size differs!"
+ echo "64bit: $out_64_req"
+ echo "32bit: $out_32_req"
+ exit 1
+fi
+
+if test "$out_64_resp" != "$out_32_resp"; then
+ echo "winbind response size differs!"
+ echo "64bit: $out_64_resp"
+ echo "32bit: $out_32_resp"
+ exit 1
+fi
+
+exit 0
static SEC_DESC* construct_service_sd( TALLOC_CTX *ctx )
{
SEC_ACE ace[4];
- SEC_ACCESS mask;
size_t i = 0;
SEC_DESC *sd = NULL;
SEC_ACL *acl = NULL;
/* basic access for Everyone */
- init_sec_access(&mask, SERVICE_READ_ACCESS );
- init_sec_ace(&ace[i++], &global_sid_World, SEC_ACE_TYPE_ACCESS_ALLOWED, mask, 0);
+ init_sec_ace(&ace[i++], &global_sid_World,
+ SEC_ACE_TYPE_ACCESS_ALLOWED, SERVICE_READ_ACCESS, 0);
- init_sec_access(&mask,SERVICE_EXECUTE_ACCESS );
- init_sec_ace(&ace[i++], &global_sid_Builtin_Power_Users, SEC_ACE_TYPE_ACCESS_ALLOWED, mask, 0);
+ init_sec_ace(&ace[i++], &global_sid_Builtin_Power_Users,
+ SEC_ACE_TYPE_ACCESS_ALLOWED, SERVICE_EXECUTE_ACCESS, 0);
- init_sec_access(&mask,SERVICE_ALL_ACCESS );
- init_sec_ace(&ace[i++], &global_sid_Builtin_Server_Operators, SEC_ACE_TYPE_ACCESS_ALLOWED, mask, 0);
- init_sec_ace(&ace[i++], &global_sid_Builtin_Administrators, SEC_ACE_TYPE_ACCESS_ALLOWED, mask, 0);
+ init_sec_ace(&ace[i++], &global_sid_Builtin_Server_Operators,
+ SEC_ACE_TYPE_ACCESS_ALLOWED, SERVICE_ALL_ACCESS, 0);
+ init_sec_ace(&ace[i++], &global_sid_Builtin_Administrators,
+ SEC_ACE_TYPE_ACCESS_ALLOWED, SERVICE_ALL_ACCESS, 0);
/* create the security descriptor */
/* Free vfs_connection_struct */
handle = conn->vfs_handles;
while(handle) {
- DLIST_REMOVE(conn->vfs_handles, handle);
thandle = handle->next;
+ DLIST_REMOVE(conn->vfs_handles, handle);
if (handle->free_data)
handle->free_data(&handle->data);
handle = thandle;
return NT_STATUS_OK;
}
-void destroy_fake_file_handle(struct fake_file_handle **fh)
-{
- if (!fh) {
- return;
- }
- TALLOC_FREE(*fh);
-}
-
NTSTATUS close_fake_file(files_struct *fsp)
{
file_free(fsp);
SMB processing whilst resolving.
If the saved_last_component != 0, then the unmodified last component
-of the pathname is returned there. This is used in an exceptional
-case in reply_mv (so far). If saved_last_component == 0 then nothing
+of the pathname is returned there. If saved_last_component == 0 then nothing
is returned there.
If last_component_wcard is true then a MS wildcard was detected and
chain_fsp = fsp;
- /* A new fsp invalidates a negative fsp_fi_cache. */
- if (fsp_fi_cache.fsp == NULL) {
- ZERO_STRUCT(fsp_fi_cache);
- }
+ /* A new fsp invalidates the positive and
+ negative fsp_fi_cache as the new fsp is pushed
+ at the start of the list and we search from
+ a cache hit to the *end* of the list. */
+
+ ZERO_STRUCT(fsp_fi_cache);
*result = fsp;
return NT_STATUS_OK;
fsp_fi_cache.id = id;
for (fsp=Files;fsp;fsp=fsp->next) {
- if ( fsp->fh->fd != -1 &&
- file_id_equal(&fsp->file_id, &id)) {
+ if (file_id_equal(&fsp->file_id, &id)) {
/* Setup positive cache. */
fsp_fi_cache.fsp = fsp;
return fsp;
files_struct *fsp;
for (fsp = start_fsp->next;fsp;fsp=fsp->next) {
- if ( fsp->fh->fd != -1 &&
- file_id_equal(&fsp->file_id, &start_fsp->file_id)) {
+ if (file_id_equal(&fsp->file_id, &start_fsp->file_id)) {
return fsp;
}
}
string_free(&fsp->fsp_name);
- if (fsp->fake_file_handle) {
- destroy_fake_file_handle(&fsp->fake_file_handle);
- }
+ TALLOC_FREE(fsp->fake_file_handle);
if (fsp->fh->ref_count == 1) {
SAFE_FREE(fsp->fh);
/* Get the file handle and hence the file name. */
/*
* NB. The setup array has already been transformed
- * via SVAL and so is in gost byte order.
+ * via SVAL and so is in host byte order.
*/
pnum = ((int)setup[1]) & 0xFFFF;
subcommand = ((int)setup[0]) & 0xFFFF;
status = NT_STATUS_OK;
if (blob.length > 0) {
enum ndr_err_code ndr_err;
- ndr_err = ndr_pull_struct_blob(&blob, notify->array, notify->array,
+ ndr_err = ndr_pull_struct_blob(&blob, notify->array, NULL, notify->array,
(ndr_pull_flags_fn_t)ndr_pull_notify_array);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
status = ndr_map_error2ntstatus(ndr_err);
tmp_ctx = talloc_new(notify);
NT_STATUS_HAVE_NO_MEMORY(tmp_ctx);
- ndr_err = ndr_push_struct_blob(&blob, tmp_ctx, notify->array,
+ ndr_err = ndr_push_struct_blob(&blob, tmp_ctx, NULL, notify->array,
(ndr_push_flags_fn_t)ndr_push_notify_array);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(tmp_ctx);
return;
}
- ndr_err = ndr_pull_struct_blob(data, tmp_ctx, &ev,
+ ndr_err = ndr_pull_struct_blob(data, tmp_ctx, NULL, &ev,
(ndr_pull_flags_fn_t)ndr_pull_notify_event);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(tmp_ctx);
tmp_ctx = talloc_new(notify);
- ndr_err = ndr_push_struct_blob(&data, tmp_ctx, &ev,
+ ndr_err = ndr_push_struct_blob(&data, tmp_ctx, NULL, &ev,
(ndr_push_flags_fn_t)ndr_push_notify_event);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(tmp_ctx);
static NTSTATUS set_sd(files_struct *fsp, uint8 *data, uint32 sd_len,
uint32 security_info_sent)
{
+ extern const struct generic_mapping file_generic_mapping;
SEC_DESC *psd = NULL;
NTSTATUS status;
security_info_sent &= ~DACL_SECURITY_INFORMATION;
}
+ /* Convert all the generic bits. */
+ security_acl_map_generic(psd->dacl, &file_generic_mapping);
+ security_acl_map_generic(psd->sacl, &file_generic_mapping);
+
status = SMB_VFS_FSET_NT_ACL(fsp, security_info_sent, psd);
TALLOC_FREE(psd);
&& (create_disposition != FILE_CREATE)
&& (share_access & FILE_SHARE_DELETE)
&& (access_mask & DELETE_ACCESS)
- && (((dos_mode(conn, fname, &sbuf) & FILE_ATTRIBUTE_READONLY)
- && !lp_delete_readonly(SNUM(conn)))
- || !can_delete_file_in_directory(conn, fname))) {
+ && (!can_delete_file_in_directory(conn, fname))) {
status = NT_STATUS_ACCESS_DENIED;
goto fail;
}
fsp->access_mask = FILE_GENERIC_ALL;
+ /* Convert all the generic bits. */
+ security_acl_map_generic(sd->dacl, &file_generic_mapping);
+ security_acl_map_generic(sd->sacl, &file_generic_mapping);
+
status = SMB_VFS_FSET_NT_ACL(fsp, sec_info_sent, sd);
fsp->access_mask = saved_access_mask;
not get. Deny entries are implicit on get with ace->perms = 0.
****************************************************************************/
-static SEC_ACCESS map_canon_ace_perms(int snum,
+static uint32_t map_canon_ace_perms(int snum,
enum security_ace_type *pacl_type,
mode_t perms,
bool directory_ace)
{
- SEC_ACCESS sa;
- uint32 nt_mask = 0;
+ uint32_t nt_mask = 0;
*pacl_type = SEC_ACE_TYPE_ACCESS_ALLOWED;
DEBUG(10,("map_canon_ace_perms: Mapped (UNIX) %x to (NT) %x\n",
(unsigned int)perms, (unsigned int)nt_mask ));
- init_sec_access(&sa,nt_mask);
- return sa;
+ return nt_mask;
}
/****************************************************************************
Unpack a SEC_DESC into a UNIX owner and group.
****************************************************************************/
-NTSTATUS unpack_nt_owners(int snum, uid_t *puser, gid_t *pgrp, uint32 security_info_sent, SEC_DESC *psd)
+NTSTATUS unpack_nt_owners(int snum, uid_t *puser, gid_t *pgrp, uint32 security_info_sent, const SEC_DESC *psd)
{
DOM_SID owner_sid;
DOM_SID grp_sid;
Unpack a SEC_DESC into two canonical ace lists.
****************************************************************************/
-static bool create_canon_ace_lists(files_struct *fsp, SMB_STRUCT_STAT *pst,
- DOM_SID *pfile_owner_sid,
- DOM_SID *pfile_grp_sid,
- canon_ace **ppfile_ace, canon_ace **ppdir_ace,
- SEC_ACL *dacl)
+static bool create_canon_ace_lists(files_struct *fsp,
+ SMB_STRUCT_STAT *pst,
+ DOM_SID *pfile_owner_sid,
+ DOM_SID *pfile_grp_sid,
+ canon_ace **ppfile_ace,
+ canon_ace **ppdir_ace,
+ const SEC_ACL *dacl)
{
bool all_aces_are_inherit_only = (fsp->is_directory ? True : False);
canon_ace *file_ace = NULL;
succeeding.
****************************************************************************/
-static bool unpack_canon_ace(files_struct *fsp,
- SMB_STRUCT_STAT *pst,
- DOM_SID *pfile_owner_sid,
- DOM_SID *pfile_grp_sid,
- canon_ace **ppfile_ace, canon_ace **ppdir_ace,
- uint32 security_info_sent, SEC_DESC *psd)
+static bool unpack_canon_ace(files_struct *fsp,
+ SMB_STRUCT_STAT *pst,
+ DOM_SID *pfile_owner_sid,
+ DOM_SID *pfile_grp_sid,
+ canon_ace **ppfile_ace,
+ canon_ace **ppdir_ace,
+ uint32 security_info_sent,
+ const SEC_DESC *psd)
{
canon_ace *file_ace = NULL;
canon_ace *dir_ace = NULL;
*/
for (ace = file_ace; ace != NULL; ace = ace->next) {
- SEC_ACCESS acc;
-
- acc = map_canon_ace_perms(SNUM(conn),
+ uint32_t acc = map_canon_ace_perms(SNUM(conn),
&nt_acl_type,
ace->perms,
S_ISDIR(sbuf->st_mode));
/* The User must have access to a profile share - even
* if we can't map the SID. */
if (lp_profile_acls(SNUM(conn))) {
- SEC_ACCESS acc;
-
- init_sec_access(&acc,FILE_GENERIC_ALL);
init_sec_ace(&nt_ace_list[num_aces++],
&global_sid_Builtin_Users,
SEC_ACE_TYPE_ACCESS_ALLOWED,
- acc, 0);
+ FILE_GENERIC_ALL, 0);
}
for (ace = dir_ace; ace != NULL; ace = ace->next) {
- SEC_ACCESS acc;
-
- acc = map_canon_ace_perms(SNUM(conn),
+ uint32_t acc = map_canon_ace_perms(SNUM(conn),
&nt_acl_type,
ace->perms,
S_ISDIR(sbuf->st_mode));
/* The User must have access to a profile share - even
* if we can't map the SID. */
if (lp_profile_acls(SNUM(conn))) {
- SEC_ACCESS acc;
-
- init_sec_access(&acc,FILE_GENERIC_ALL);
- init_sec_ace(&nt_ace_list[num_aces++], &global_sid_Builtin_Users, SEC_ACE_TYPE_ACCESS_ALLOWED, acc,
+ init_sec_ace(&nt_ace_list[num_aces++], &global_sid_Builtin_Users, SEC_ACE_TYPE_ACCESS_ALLOWED, FILE_GENERIC_ALL,
SEC_ACE_FLAG_OBJECT_INHERIT|SEC_ACE_FLAG_CONTAINER_INHERIT|
SEC_ACE_FLAG_INHERIT_ONLY|0);
}
Take care of parent ACL inheritance.
****************************************************************************/
-static NTSTATUS append_parent_acl(files_struct *fsp,
- SMB_STRUCT_STAT *psbuf,
- SEC_DESC *psd,
+NTSTATUS append_parent_acl(files_struct *fsp,
+ const SEC_DESC *pcsd,
SEC_DESC **pp_new_sd)
{
SEC_DESC *parent_sd = NULL;
files_struct *parent_fsp = NULL;
- TALLOC_CTX *mem_ctx = talloc_parent(psd);
+ TALLOC_CTX *mem_ctx = talloc_tos();
char *parent_name = NULL;
SEC_ACE *new_ace = NULL;
- unsigned int num_aces = psd->dacl->num_aces;
+ unsigned int num_aces = pcsd->dacl->num_aces;
SMB_STRUCT_STAT sbuf;
NTSTATUS status;
int info;
unsigned int i, j;
- bool is_dacl_protected = (psd->type & SE_DESC_DACL_PROTECTED);
+ SEC_DESC *psd = dup_sec_desc(talloc_tos(), pcsd);
+ bool is_dacl_protected = (pcsd->type & SE_DESC_DACL_PROTECTED);
ZERO_STRUCT(sbuf);
- if (mem_ctx == NULL) {
+ if (psd == NULL) {
return NT_STATUS_NO_MEMORY;
}
parent_name));
}
- /* This sucks. psd should be const and we should
- * be doing a deep-copy here. We're getting away
- * with is as we know parent_sd is talloced off
- * talloc_tos() as well as psd. JRA. */
-
psd->dacl->aces = new_ace;
psd->dacl->num_aces = i;
psd->type &= ~(SE_DESC_DACL_AUTO_INHERITED|
This should be the only external function needed for the UNIX style set ACL.
****************************************************************************/
-NTSTATUS set_nt_acl(files_struct *fsp, uint32 security_info_sent, SEC_DESC *psd)
+NTSTATUS set_nt_acl(files_struct *fsp, uint32 security_info_sent, const SEC_DESC *psd)
{
connection_struct *conn = fsp->conn;
uid_t user = (uid_t)-1;
SE_DESC_DACL_AUTO_INHERIT_REQ))==
(SE_DESC_DACL_AUTO_INHERITED|
SE_DESC_DACL_AUTO_INHERIT_REQ) ) {
- status = append_parent_acl(fsp, &sbuf, psd, &psd);
+ SEC_DESC *new_sd = NULL;
+ status = append_parent_acl(fsp, psd, &new_sd);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
+ psd = new_sd;
}
acl_perms = unpack_canon_ace( fsp, &sbuf, &file_owner_sid, &file_grp_sid,
****************************************************************************/
static NTSTATUS receive_message_or_smb(TALLOC_CTX *mem_ctx, char **buffer,
- size_t *buffer_len, int timeout,
+ size_t *buffer_len,
size_t *p_unread, bool *p_encrypted)
{
fd_set r_fds, w_fds;
again:
- if (timeout >= 0) {
- to.tv_sec = timeout / 1000;
- to.tv_usec = (timeout % 1000) * 1000;
- } else {
- to.tv_sec = SMBD_SELECT_TIMEOUT;
- to.tv_usec = 0;
- }
+ to.tv_sec = SMBD_SELECT_TIMEOUT;
+ to.tv_usec = 0;
/*
* Note that this call must be before processing any SMB
/* Did we timeout ? */
if (selrtn == 0) {
- return NT_STATUS_IO_TIMEOUT;
+ goto again;
}
/*
return;
}
-/****************************************************************************
- Setup the needed select timeout in milliseconds.
-****************************************************************************/
-
-static int setup_select_timeout(void)
-{
- int select_timeout;
-
- select_timeout = SMBD_SELECT_TIMEOUT*1000;
-
- if (print_notify_messages_pending()) {
- select_timeout = MIN(select_timeout, 1000);
- }
-
- return select_timeout;
-}
-
/****************************************************************************
Check if services need reloading.
****************************************************************************/
}
}
-/****************************************************************************
- Process any timeout housekeeping. Return False if the caller should exit.
-****************************************************************************/
-
-static void timeout_processing(int *select_timeout,
- time_t *last_timeout_processing_time)
-{
- time_t t;
-
- *last_timeout_processing_time = t = time(NULL);
-
- /* become root again if waiting */
- change_to_root_user();
-
- /* check if we need to reload services */
- check_reload(t);
-
- if(global_machine_password_needs_changing &&
- /* for ADS we need to do a regular ADS password change, not a domain
- password change */
- lp_security() == SEC_DOMAIN) {
-
- unsigned char trust_passwd_hash[16];
- time_t lct;
- void *lock;
-
- /*
- * We're in domain level security, and the code that
- * read the machine password flagged that the machine
- * password needs changing.
- */
-
- /*
- * First, open the machine password file with an exclusive lock.
- */
-
- lock = secrets_get_trust_account_lock(NULL, lp_workgroup());
-
- if (lock == NULL) {
- DEBUG(0,("process: unable to lock the machine account password for \
-machine %s in domain %s.\n", global_myname(), lp_workgroup() ));
- return;
- }
-
- if(!secrets_fetch_trust_account_password(lp_workgroup(), trust_passwd_hash, &lct, NULL)) {
- DEBUG(0,("process: unable to read the machine account password for \
-machine %s in domain %s.\n", global_myname(), lp_workgroup()));
- TALLOC_FREE(lock);
- return;
- }
-
- /*
- * Make sure someone else hasn't already done this.
- */
-
- if(t < lct + lp_machine_password_timeout()) {
- global_machine_password_needs_changing = False;
- TALLOC_FREE(lock);
- return;
- }
-
- /* always just contact the PDC here */
-
- change_trust_account_password( lp_workgroup(), NULL);
- global_machine_password_needs_changing = False;
- TALLOC_FREE(lock);
- }
-
- /* update printer queue caches if necessary */
-
- update_monitored_printq_cache();
-
- /*
- * Now we are root, check if the log files need pruning.
- * Force a log file check.
- */
- force_check_log_size();
- check_log_size();
-
- /* Send any queued printer notify message to interested smbd's. */
-
- print_notify_send_messages(smbd_messaging_context(), 0);
-
- /*
- * Modify the select timeout depending upon
- * what we have remaining in our queues.
- */
-
- *select_timeout = setup_select_timeout();
-
- return;
-}
-
/****************************************************************************
Process commands from the client
****************************************************************************/
void smbd_process(void)
{
- time_t last_timeout_processing_time = time(NULL);
unsigned int num_smbs = 0;
size_t unread_bytes = 0;
max_recv = MIN(lp_maxxmit(),BUFFER_SIZE);
while (True) {
- int select_timeout = setup_select_timeout();
- int num_echos;
+ NTSTATUS status;
char *inbuf = NULL;
size_t inbuf_len = 0;
bool encrypted = false;
errno = 0;
- /* Did someone ask for immediate checks on things like blocking locks ? */
- if (select_timeout == 0) {
- timeout_processing(&select_timeout,
- &last_timeout_processing_time);
- num_smbs = 0; /* Reset smb counter. */
- }
-
run_events(smbd_event_context(), 0, NULL, NULL);
- while (True) {
- NTSTATUS status;
-
- status = receive_message_or_smb(
- talloc_tos(), &inbuf, &inbuf_len,
- select_timeout, &unread_bytes, &encrypted);
-
- if (NT_STATUS_IS_OK(status)) {
- break;
- }
-
- if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
- timeout_processing(
- &select_timeout,
- &last_timeout_processing_time);
- continue;
- }
+ status = receive_message_or_smb(
+ talloc_tos(), &inbuf, &inbuf_len,
+ &unread_bytes, &encrypted);
+ if (!NT_STATUS_IS_OK(status)) {
DEBUG(3, ("receive_message_or_smb failed: %s, "
"exiting\n", nt_errstr(status)));
return;
-
- num_smbs = 0; /* Reset smb counter. */
}
-
- /*
- * Ensure we do timeout processing if the SMB we just got was
- * only an echo request. This allows us to set the select
- * timeout in 'receive_message_or_smb()' to any value we like
- * without worrying that the client will send echo requests
- * faster than the select timeout, thus starving out the
- * essential processing (change notify, blocking locks) that
- * the timeout code does. JRA.
- */
- num_echos = smb_echo_count;
-
process_smb(inbuf, inbuf_len, unread_bytes, encrypted);
TALLOC_FREE(inbuf);
- if (smb_echo_count != num_echos) {
- timeout_processing(&select_timeout,
- &last_timeout_processing_time);
- num_smbs = 0; /* Reset smb counter. */
- }
-
num_smbs++;
- /*
- * If we are getting smb requests in a constant stream
- * with no echos, make sure we attempt timeout processing
- * every select_timeout milliseconds - but only check for this
- * every 200 smb requests.
- */
-
- if ((num_smbs % 200) == 0) {
- time_t new_check_time = time(NULL);
- if(new_check_time - last_timeout_processing_time >= (select_timeout/1000)) {
- timeout_processing(
- &select_timeout,
- &last_timeout_processing_time);
- num_smbs = 0; /* Reset smb counter. */
- last_timeout_processing_time = new_check_time; /* Reset time. */
- }
- }
-
/* The timeout_processing function isn't run nearly
often enough to implement 'max log size' without
overrunning the size of the file by many megabytes.
/* look in server.c for some explanation of these variables */
extern enum protocol_types Protocol;
extern int max_recv;
-unsigned int smb_echo_count = 0;
extern uint32 global_client_caps;
extern bool global_encrypted_passwords_negotiated;
}
/****************************************************************************
- Check if we have a correct fsp pointing to a file. Replacement for the
- CHECK_FSP macro.
+ Check if we have a correct fsp pointing to a file.
****************************************************************************/
bool check_fsp(connection_struct *conn, struct smb_request *req,
fsp = file_fsp(SVAL(req->inbuf,smb_vwv0));
/*
- * We can only use CHECK_FSP if we know it's not a directory.
+ * We can only use check_fsp if we know it's not a directory.
*/
if(!fsp || (fsp->conn != conn) || (fsp->vuid != req->vuid)) {
TALLOC_FREE(req->outbuf);
- smb_echo_count++;
-
END_PROFILE(SMBecho);
return;
}
DEBUG(3,("rename_internals_fsp: succeeded doing rename on %s -> %s\n",
fsp->fsp_name,newname));
- rename_open_files(conn, lck, newname);
-
notify_rename(conn, fsp->is_directory, fsp->fsp_name, newname);
+ rename_open_files(conn, lck, newname);
+
/*
* A rename acts as a new file create w.r.t. allowing an initial delete
* on close, probably because in Windows there is a new handle to the
return True;
}
+/*
+ * Do the recurring log file and smb.conf reload checks.
+ */
+
+static bool housekeeping_fn(const struct timeval *now, void *private_data)
+{
+ change_to_root_user();
+
+ /* update printer queue caches if necessary */
+ update_monitored_printq_cache();
+
+ /* check if we need to reload services */
+ check_reload(time(NULL));
+
+ /* Change machine password if neccessary. */
+ attempt_machine_password_change();
+
+ /*
+ * Force a log file check.
+ */
+ force_check_log_size();
+ check_log_size();
+ return true;
+}
/****************************************************************************
main program.
exit(1);
}
+ if (!(event_add_idle(smbd_event_context(), NULL,
+ timeval_set(SMBD_SELECT_TIMEOUT, 0),
+ "housekeeping", housekeeping_fn, NULL))) {
+ DEBUG(0, ("Could not add housekeeping event\n"));
+ exit(1);
+ }
+
#ifdef CLUSTER_SUPPORT
if (lp_clustering()) {
bool requires_resume_key;
int info_level;
char *directory = NULL;
- const char *mask = NULL;
+ char *mask = NULL;
char *p;
int last_entry_off=0;
int dptr_num = -1;
return;
}
- ntstatus = unix_convert(ctx, conn, directory, True, &directory, NULL, &sbuf);
+ ntstatus = unix_convert(ctx, conn, directory, True, &directory, &mask, &sbuf);
if (!NT_STATUS_IS_OK(ntstatus)) {
reply_nterror(req, ntstatus);
return;
if(p == NULL) {
/* Windows and OS/2 systems treat search on the root '\' as if it were '\*' */
if((directory[0] == '.') && (directory[1] == '\0')) {
- mask = "*";
+ mask = talloc_strdup(ctx,"*");
+ if (!mask) {
+ reply_nterror(req, NT_STATUS_NO_MEMORY);
+ return;
+ }
mask_contains_wcard = True;
- } else {
- mask = directory;
}
directory = talloc_strdup(talloc_tos(), "./");
if (!directory) {
return;
}
} else {
- mask = p+1;
*p = 0;
}
static int net_ads_cldap_netlogon(struct net_context *c, ADS_STRUCT *ads)
{
char addr[INET6_ADDRSTRLEN];
- struct nbt_cldap_netlogon_5 reply;
+ struct NETLOGON_SAM_LOGON_RESPONSE_EX reply;
print_sockaddr(addr, sizeof(addr), &ads->ldap.ss);
if ( !ads_cldap_netlogon_5(talloc_tos(), addr, ads->server.realm, &reply ) ) {
addr);
d_printf("Response Type: ");
- switch (reply.type) {
- case SAMLOGON_AD_UNK_R:
- d_printf("SAMLOGON\n");
+ switch (reply.command) {
+ case LOGON_SAM_LOGON_USER_UNKNOWN_EX:
+ d_printf("LOGON_SAM_LOGON_USER_UNKNOWN_EX\n");
break;
- case SAMLOGON_AD_R:
- d_printf("SAMLOGON_USER\n");
+ case LOGON_SAM_LOGON_RESPONSE_EX:
+ d_printf("LOGON_SAM_LOGON_RESPONSE_EX\n");
break;
default:
- d_printf("0x%x\n", reply.type);
+ d_printf("0x%x\n", reply.command);
break;
}
{
ADS_STRUCT *ads;
char addr[INET6_ADDRSTRLEN];
- struct nbt_cldap_netlogon_5 reply;
+ struct NETLOGON_SAM_LOGON_RESPONSE_EX reply;
if (c->display_usage) {
d_printf("Usage:\n"
int get_my_ip_address( struct sockaddr_storage **pp_ss )
{
- struct iface_struct nics[MAX_INTERFACES];
int i, n;
struct sockaddr_storage *list = NULL;
int count = 0;
- /* find the first non-loopback address from our list of interfaces */
+ /* Honor the configured list of interfaces to register */
- n = get_interfaces(nics, MAX_INTERFACES);
+ load_interfaces();
+ n = iface_count();
if (n <= 0) {
return -1;
}
for ( i=0; i<n; i++ ) {
- if (is_loopback_addr(&nics[i].ip)) {
+ const struct sockaddr_storage *nic_sa_storage = NULL;
+
+ if ((nic_sa_storage = iface_n_sockaddr_storage(i)) == NULL)
+ continue;
+
+ /* Don't register loopback addresses */
+ if (is_loopback_addr(nic_sa_storage)) {
continue;
}
-#if defined(HAVE_IPV6)
- if ((nics[i].ip.ss_family == AF_INET6)) {
- memcpy(&list[count++], &nics[i].ip,
- sizeof(struct sockaddr_storage));
- } else
-#endif
- if (nics[i].ip.ss_family == AF_INET) {
- memcpy(&list[count++], &nics[i].ip,
- sizeof(struct sockaddr_storage));
- }
+
+ memcpy(&list[count++], nic_sa_storage, sizeof(struct sockaddr_storage));
}
*pp_ss = list;
const char *whoami, struct functable *table);
void net_display_usage_from_functable(struct functable *table);
+const char *net_share_type_str(int num_type);
+
/* The following definitions come from utils/netlookup.c */
NTSTATUS net_lookup_name_from_sid(struct net_context *c,
#define ERRMSG_BOTH_SERVER_IPADDRESS "\nTarget server and IP address both "\
"specified. Do not set both at the same time. The target IP address was used\n"
-const char *share_type[] = {
- "Disk",
- "Print",
- "Dev",
- "IPC"
-};
-
static int errmsg_not_implemented(void)
{
d_printf("\nNot implemented\n");
const char *comment, void *state)
{
d_printf("%-12s %-8.8s %-50s\n",
- share_name, share_type[type], comment);
+ share_name, net_share_type_str(type), comment);
}
static void share_fn(const char *share_name, uint32 type,
const char *username, const char *netname)
{
d_printf("%-14.14s %-8.8s %5d\n",
- netname, share_type[conn_type], opens);
+ netname, net_share_type_str(conn_type), opens);
}
static int rap_session_info(struct net_context *c, int argc, const char **argv)
static int net_mode_share;
static bool sync_files(struct copy_clistate *cp_clistate, const char *mask);
-extern const char *share_type[];
-
/**
* @file net_rpc.c
*
if (c->opt_long_list_entries) {
d_printf("%-12s %-8.8s %-50s\n",
r->shi1_netname,
- share_type[r->shi1_type & ~(STYPE_TEMPORARY|STYPE_HIDDEN)],
+ net_share_type_str(r->shi1_type & ~(STYPE_TEMPORARY|STYPE_HIDDEN)),
r->shi1_remark);
} else {
d_printf("%s\n", r->shi1_netname);
blob.data = sd->data;
blob.length = sd->size;
- ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, &sec_desc,
+ ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, NULL, &sec_desc,
(ndr_pull_flags_fn_t)ndr_pull_security_descriptor);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
status = ndr_map_error2ntstatus(ndr_err);
* Unix SMB/CIFS implementation.
* Helper routines for net
* Copyright (C) Volker Lendecke 2006
+ * Copyright (C) Kai Blin 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
d_printf("%s\n", table[i].usage);
}
}
+
+const char *net_share_type_str(int num_type)
+{
+ switch(num_type) {
+ case 0: return "Disk";
+ case 1: return "Print";
+ case 2: return "Dev";
+ case 3: return "IPC";
+ default: return "Unknown";
+ }
+}
unsigned int aflags = 0;
unsigned int amask = 0;
DOM_SID sid;
- SEC_ACCESS mask;
+ uint32_t mask;
const struct perm_value *v;
char *str = SMB_STRDUP(orig_str);
TALLOC_CTX *frame = talloc_stackframe();
unsigned int aflags = 0;
unsigned int amask = 0;
DOM_SID sid;
- SEC_ACCESS mask;
+ uint32_t mask;
const struct perm_value *v;
char *str = SMB_STRDUP(orig_str);
TALLOC_CTX *frame = talloc_stackframe();
cname = poptGetArg(pc);
caddr = poptGetArg(pc);
+ poptFreeContext(pc);
+
if ( cname && ! caddr ) {
printf ( "ERROR: You must specify both a machine name and an IP address.\n" );
- return(1);
+ ret = 1;
+ goto done;
}
if (new_local_machine) {
if (!lp_load_with_registry_shares(config_file,False,True,False,True)) {
fprintf(stderr,"Error loading services.\n");
- return(1);
+ ret = 1;
+ goto done;
}
fprintf(stderr,"Loaded services file OK.\n");
(s=lp_servicenumber(section_name)) == -1) {
fprintf(stderr,"Unknown section %s\n",
section_name);
- return(1);
+ ret = 1;
+ goto done;
}
if (parameter_name) {
if (!dump_a_parameter( s, parameter_name, stdout, isGlobal)) {
fprintf(stderr,"Parameter %s unknown for section %s\n",
parameter_name, section_name);
- return(1);
+ ret = 1;
+ goto done;
}
} else {
if (isGlobal == True)
else
lp_dump_one(stdout, show_defaults, s);
}
- return(ret);
+ goto done;
}
lp_dump(stdout, show_defaults, lp_numservices());
}
}
}
+
+done:
TALLOC_FREE(frame);
- return(ret);
+ gfree_loadparm();
+ return ret;
}
{
/* show machine name rather PID on table "Open Files"? */
if (PID_or_Machine) {
- PIDMAP *p;
+ PIDMAP *p, *next;
- for (p = pidmap; p != NULL; ) {
+ for (p = pidmap; p != NULL; p = next) {
+ next = p->next;
DLIST_REMOVE(pidmap, p);
SAFE_FREE(p->machine);
SAFE_FREE(p);
--- /dev/null
+/*
+ * idmap_adex: Support for AD Forests
+ *
+ * Copyright (C) Gerald (Jerry) Carter 2006-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 2 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, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "includes.h"
+#include "idmap_adex.h"
+
+#undef DBGC_CLASS
+#define DBGC_CLASS DBGC_IDMAP
+
+/**********************************************************************
+**********************************************************************/
+
+ char *find_attr_string(char **list, size_t num_lines, const char *substr)
+{
+ int i;
+ int cmplen = strlen(substr);
+
+ for (i = 0; i < num_lines; i++) {
+ /* make sure to avoid substring matches like uid
+ and uidNumber */
+ if ((StrnCaseCmp(list[i], substr, cmplen) == 0) &&
+ (list[i][cmplen] == '=')) {
+ /* Don't return an empty string */
+ if (list[i][cmplen + 1] != '\0')
+ return &(list[i][cmplen + 1]);
+
+ return NULL;
+ }
+ }
+
+ return NULL;
+}
+
+/**********************************************************************
+**********************************************************************/
+
+ bool is_object_class(char **list, size_t num_lines, const char *substr)
+{
+ int i;
+
+ for (i = 0; i < num_lines; i++) {
+ if (strequal(list[i], substr)) {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+/**********************************************************************
+ Find out about the cell (e.g. use2307Attrs, etc...)
+**********************************************************************/
+
+ NTSTATUS cell_lookup_settings(struct likewise_cell * cell)
+{
+ NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
+
+ /* Parameter check */
+
+ if (!cell) {
+ nt_status = NT_STATUS_INVALID_PARAMETER;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+ /* Only supporting Forest-wide, schema based searches */
+
+ cell_set_flags(cell, LWCELL_FLAG_USE_RFC2307_ATTRS);
+ cell_set_flags(cell, LWCELL_FLAG_SEARCH_FOREST);
+
+ cell->provider = &ccp_unified;
+
+ nt_status = NT_STATUS_OK;
+
+done:
+ if (!NT_STATUS_IS_OK(nt_status)) {
+ DEBUG(1,("LWI: Failed to obtain cell settings (%s)\n",
+ nt_errstr(nt_status)));
+ }
+
+ return nt_status;
+}
+
+
+static NTSTATUS cell_lookup_forest(struct likewise_cell *c)
+{
+ NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
+ struct gc_info *gc = NULL;
+
+ if (!c) {
+ return NT_STATUS_INVALID_PARAMETER;
+ }
+
+ if ((gc = TALLOC_ZERO_P(NULL, struct gc_info)) == NULL) {
+ nt_status = NT_STATUS_NO_MEMORY;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+ /* Query the rootDSE for the forest root naming conect first.
+ Check that the a GC server for the forest has not already
+ been added */
+
+ nt_status = gc_find_forest_root(gc, cell_dns_domain(c));
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+ c->forest_name = talloc_strdup(c, gc->forest_name);
+ BAIL_ON_PTR_ERROR(c->forest_name, nt_status);
+
+done:
+ if (gc) {
+ talloc_free(gc);
+ }
+
+ return nt_status;
+}
+
+/**********************************************************************
+**********************************************************************/
+
+ NTSTATUS cell_locate_membership(ADS_STRUCT * ads)
+{
+ ADS_STATUS status;
+ char *domain_dn = ads_build_dn(lp_realm());
+ NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
+ DOM_SID sid;
+ struct likewise_cell *cell = NULL;
+
+ /* In the Likewise plugin, I had to support the concept of cells
+ based on the machine's membership in an OU. However, now I'll
+ just assume our membership in the forest cell */
+
+ DEBUG(2, ("locate_cell_membership: Located membership "
+ "in cell \"%s\"\n", domain_dn));
+
+ if ((cell = cell_new()) == NULL) {
+ nt_status = NT_STATUS_NO_MEMORY;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+ status = ads_domain_sid(ads, &sid);
+ if (!ADS_ERR_OK(status)) {
+ DEBUG(3,("locate_cell_membership: Failed to find "
+ "domain SID for %s\n", domain_dn));
+ }
+
+ /* save the SID and search base for our domain */
+
+ cell_set_dns_domain(cell, lp_realm());
+ cell_set_connection(cell, ads);
+ cell_set_dn(cell, domain_dn);
+ cell_set_domain_sid(cell, &sid);
+
+ /* Now save our forest root */
+
+ cell_lookup_forest(cell);
+
+ /* Add the cell to the list */
+
+ if (!cell_list_add(cell)) {
+ nt_status = NT_STATUS_INSUFFICIENT_RESOURCES;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+ /* Done! */
+ nt_status = NT_STATUS_OK;
+
+done:
+ if (!NT_STATUS_IS_OK(nt_status)) {
+ DEBUG(0,("LWI: Failed to locate cell membership (%s)\n",
+ nt_errstr(nt_status)));
+ }
+
+ SAFE_FREE(domain_dn);
+
+ return nt_status;
+}
+
+/*********************************************************************
+ ********************************************************************/
+
+ int min_id_value(void)
+{
+ int id_val;
+
+ id_val = lp_parm_int(-1, "lwidentity", "min_id_value", MIN_ID_VALUE);
+
+ /* Still don't let it go below 50 */
+
+ return MAX(50, id_val);
+}
+
+/********************************************************************
+ *******************************************************************/
+
+ char *cell_dn_to_dns(const char *dn)
+{
+ NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
+ char *domain = NULL;
+ char *dns_name = NULL;
+ const char *tmp_dn;
+ char *buffer = NULL;
+ TALLOC_CTX *frame = talloc_stackframe();
+
+ if (!dn || !*dn) {
+ goto done;
+ }
+
+ tmp_dn = talloc_strdup(frame, dn);
+ BAIL_ON_PTR_ERROR(tmp_dn, nt_status);
+
+ while (next_token_talloc(frame, &tmp_dn, &buffer, ",")) {
+
+ /* skip everything up the where DC=... begins */
+ if (StrnCaseCmp(buffer, "DC=", 3) != 0)
+ continue;
+
+ if (!domain) {
+ domain = talloc_strdup(frame, &buffer[3]);
+ } else {
+ domain = talloc_asprintf_append(domain, ".%s",
+ &buffer[3]);
+ }
+ BAIL_ON_PTR_ERROR(domain, nt_status);
+ }
+
+ dns_name = SMB_STRDUP(domain);
+ BAIL_ON_PTR_ERROR(dns_name, nt_status);
+
+ nt_status = NT_STATUS_OK;
+
+done:
+ PRINT_NTSTATUS_ERROR(nt_status, "cell_dn_to_dns", 1);
+
+ talloc_destroy(frame);
+
+ return dns_name;
+}
+
+/*********************************************************************
+ ********************************************************************/
+
+ NTSTATUS get_sid_type(ADS_STRUCT *ads,
+ LDAPMessage *msg,
+ enum lsa_SidType *type)
+{
+ NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
+ uint32_t atype;
+
+ if (!ads_pull_uint32(ads, msg, "sAMAccountType", &atype)) {
+ nt_status = NT_STATUS_INVALID_USER_BUFFER;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+ switch (atype &0xF0000000) {
+ case ATYPE_SECURITY_GLOBAL_GROUP:
+ *type = SID_NAME_DOM_GRP;
+ break;
+ case ATYPE_SECURITY_LOCAL_GROUP:
+ *type = SID_NAME_ALIAS;
+ break;
+ case ATYPE_NORMAL_ACCOUNT:
+ case ATYPE_WORKSTATION_TRUST:
+ case ATYPE_INTERDOMAIN_TRUST:
+ *type = SID_NAME_USER;
+ break;
+ default:
+ *type = SID_NAME_USE_NONE;
+ nt_status = NT_STATUS_INVALID_ACCOUNT_NAME;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+ nt_status = NT_STATUS_OK;
+
+done:
+ return nt_status;
+}
--- /dev/null
+/*
+ * idmap_adex: Domain search interface
+ *
+ * Copyright (C) Gerald (Jerry) Carter 2007-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 2 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, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "includes.h"
+#include "idmap_adex.h"
+
+#undef DBGC_CLASS
+#define DBGC_CLASS DBGC_IDMAP
+
+struct dc_info {
+ struct dc_info *prev, *next;
+ char *dns_name;
+ struct likewise_cell *domain_cell;
+};
+
+static struct dc_info *_dc_server_list = NULL;
+
+
+/**********************************************************************
+ *********************************************************************/
+
+static struct dc_info *dc_list_head(void)
+{
+ return _dc_server_list;
+}
+
+/**********************************************************************
+ *********************************************************************/
+
+static NTSTATUS dc_add_domain(const char *domain)
+{
+ NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
+ struct dc_info *dc = NULL;
+
+ if (!domain) {
+ return NT_STATUS_INVALID_PARAMETER;
+ }
+
+ DEBUG(10,("dc_add_domain: Attempting to add domain %s\n", domain));
+
+ /* Check for duplicates */
+
+ dc = dc_list_head();
+ while (dc) {
+ if (strequal (dc->dns_name, domain))
+ break;
+ dc = dc->next;
+ }
+
+ if (dc) {
+ DEBUG(10,("dc_add_domain: %s already in list\n", domain));
+ return NT_STATUS_OK;
+ }
+
+ dc = TALLOC_ZERO_P(NULL, struct dc_info);
+ BAIL_ON_PTR_ERROR(dc, nt_status);
+
+ dc->dns_name = talloc_strdup(dc, domain);
+ BAIL_ON_PTR_ERROR(dc->dns_name, nt_status);
+
+ DLIST_ADD_END(_dc_server_list, dc, struct dc_info*);
+
+ nt_status = NT_STATUS_OK;
+
+ DEBUG(5,("dc_add_domain: Successfully added %s\n", domain));
+
+done:
+ if (!NT_STATUS_IS_OK(nt_status)) {
+ talloc_destroy(dc);
+ DEBUG(0,("LWI: Failed to add new DC connection for %s (%s)\n",
+ domain, nt_errstr(nt_status)));
+ }
+
+ return nt_status;
+}
+
+/**********************************************************************
+ *********************************************************************/
+
+static void dc_server_list_destroy(void)
+{
+ struct dc_info *dc = dc_list_head();
+
+ while (dc) {
+ struct dc_info *p = dc->next;
+
+ cell_destroy(dc->domain_cell);
+ talloc_destroy(dc);
+
+ dc = p;
+ }
+
+ return;
+}
+
+
+/**********************************************************************
+ *********************************************************************/
+
+ NTSTATUS domain_init_list(void)
+{
+ NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
+ struct winbindd_tdc_domain *domains = NULL;
+ size_t num_domains = 0;
+ int i;
+
+ if (_dc_server_list != NULL) {
+ dc_server_list_destroy();
+ }
+
+ /* Add our domain */
+
+ nt_status = dc_add_domain(lp_realm());
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+ if (!wcache_tdc_fetch_list(&domains, &num_domains)) {
+ nt_status = NT_STATUS_CANT_ACCESS_DOMAIN_INFO;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+ /* Add all domains with an incoming trust path */
+
+ for (i=0; i<num_domains; i++) {
+ uint32_t flags = (NETR_TRUST_FLAG_INBOUND|NETR_TRUST_FLAG_IN_FOREST);
+
+ /* We just require one of the flags to be set here */
+
+ if (domains[i].trust_flags & flags) {
+ nt_status = dc_add_domain(domains[i].dns_name);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+ }
+
+ nt_status = NT_STATUS_OK;
+
+done:
+ if (!NT_STATUS_IS_OK(nt_status)) {
+ DEBUG(2,("LWI: Failed to initialize DC list (%s)\n",
+ nt_errstr(nt_status)));
+ }
+
+ TALLOC_FREE(domains);
+
+ return nt_status;
+}
+
+/********************************************************************
+ *******************************************************************/
+
+static NTSTATUS dc_do_search(struct dc_info *dc,
+ const char *search_base,
+ int scope,
+ const char *expr,
+ const char **attrs,
+ LDAPMessage ** msg)
+{
+ ADS_STATUS status = ADS_ERROR_NT(NT_STATUS_UNSUCCESSFUL);
+ NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
+
+ status = cell_do_search(dc->domain_cell, search_base,
+ scope, expr, attrs, msg);
+ nt_status = ads_ntstatus(status);
+
+ return nt_status;
+}
+
+/**********************************************************************
+ *********************************************************************/
+
+static struct dc_info *dc_find_domain(const char *dns_domain)
+{
+ struct dc_info *dc = dc_list_head();
+
+ if (!dc)
+ return NULL;
+
+ while (dc) {
+ if (strequal(dc->dns_name, dns_domain)) {
+ return dc;
+ }
+
+ dc = dc->next;
+ }
+
+ return NULL;
+}
+
+/**********************************************************************
+ *********************************************************************/
+
+ NTSTATUS dc_search_domains(struct likewise_cell **cell,
+ LDAPMessage **msg,
+ const char *dn,
+ const DOM_SID *sid)
+{
+ NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
+ TALLOC_CTX *frame = talloc_stackframe();
+ char *dns_domain;
+ const char *attrs[] = { "*", NULL };
+ struct dc_info *dc = NULL;
+ const char *base = NULL;
+
+ if (!dn || !*dn) {
+ nt_status = NT_STATUS_INVALID_PARAMETER;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+ dns_domain = cell_dn_to_dns(dn);
+ BAIL_ON_PTR_ERROR(dns_domain, nt_status);
+
+ if ((dc = dc_find_domain(dns_domain)) == NULL) {
+ nt_status = NT_STATUS_TRUSTED_DOMAIN_FAILURE;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+ /* Reparse the cell settings for the domain if necessary */
+
+ if (!dc->domain_cell) {
+ char *base_dn;
+
+ base_dn = ads_build_dn(dc->dns_name);
+ BAIL_ON_PTR_ERROR(base_dn, nt_status);
+
+ nt_status = cell_connect_dn(&dc->domain_cell, base_dn);
+ SAFE_FREE(base_dn);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+ nt_status = cell_lookup_settings(dc->domain_cell);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+ /* By definition this is already part of a larger
+ forest-wide search scope */
+
+ cell_set_flags(dc->domain_cell, LWCELL_FLAG_SEARCH_FOREST);
+ }
+
+ /* Check whether we are operating in non-schema or RFC2307
+ mode */
+
+ if (cell_flags(dc->domain_cell) & LWCELL_FLAG_USE_RFC2307_ATTRS) {
+ nt_status = dc_do_search(dc, dn, LDAP_SCOPE_BASE,
+ "(objectclass=*)", attrs, msg);
+ } else {
+ const char *sid_str = NULL;
+ char *filter = NULL;
+
+ sid_str = sid_string_talloc(frame, sid);
+ BAIL_ON_PTR_ERROR(sid_str, nt_status);
+
+ filter = talloc_asprintf(frame, "(keywords=backLink=%s)",
+ sid_str);
+ BAIL_ON_PTR_ERROR(filter, nt_status);
+
+ base = cell_search_base(dc->domain_cell);
+ BAIL_ON_PTR_ERROR(base, nt_status);
+
+ nt_status = dc_do_search(dc, base, LDAP_SCOPE_SUBTREE,
+ filter, attrs, msg);
+ }
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+ *cell = dc->domain_cell;
+
+done:
+ talloc_destroy(CONST_DISCARD(char*, base));
+ talloc_destroy(frame);
+
+ return nt_status;
+}
--- /dev/null
+/*
+ * idmap_adex: Global Catalog search interface
+ *
+ * Copyright (C) Gerald (Jerry) Carter 2007-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 2 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, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "includes.h"
+#include "idmap_adex.h"
+
+#undef DBGC_CLASS
+#define DBGC_CLASS DBGC_IDMAP
+
+static struct gc_info *_gc_server_list = NULL;
+
+
+/**********************************************************************
+ *********************************************************************/
+
+static struct gc_info *gc_list_head(void)
+{
+ return _gc_server_list;
+}
+
+/**********************************************************************
+ Checks if either of the domains is a subdomain of the other
+ *********************************************************************/
+
+static bool is_subdomain(const char* a, const char *b)
+{
+ char *s;
+ TALLOC_CTX *frame = talloc_stackframe();
+ char *x, *y;
+ bool ret = false;
+
+ /* Trivial cases */
+
+ if (!a && !b)
+ return true;
+
+ if (!a || !b)
+ return false;
+
+ /* Normalize the case */
+
+ x = talloc_strdup(frame, a);
+ y = talloc_strdup(frame, b);
+ if (!x || !y) {
+ ret = false;
+ goto done;
+ }
+
+ strupper_m(x);
+ strupper_m(y);
+
+ /* Exact match */
+
+ if (strcmp(x, y) == 0) {
+ ret = true;
+ goto done;
+ }
+
+ /* Check for trailing substrings */
+
+ s = strstr_m(x, y);
+ if (s && (strlen(s) == strlen(y))) {
+ ret = true;
+ goto done;
+ }
+
+ s = strstr_m(y, x);
+ if (s && (strlen(s) == strlen(x))) {
+ ret = true;
+ goto done;
+ }
+
+done:
+ talloc_destroy(frame);
+
+ return ret;
+}
+
+/**********************************************************************
+ *********************************************************************/
+
+ NTSTATUS gc_find_forest_root(struct gc_info *gc, const char *domain)
+{
+ ADS_STRUCT *ads = NULL;
+ ADS_STATUS ads_status;
+ NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
+ struct NETLOGON_SAM_LOGON_RESPONSE_EX cldap_reply;
+ TALLOC_CTX *frame = talloc_stackframe();
+
+ if (!gc || !domain) {
+ return NT_STATUS_INVALID_PARAMETER;
+ }
+
+ ZERO_STRUCT(cldap_reply);
+
+ ads = ads_init(domain, NULL, NULL);
+ BAIL_ON_PTR_ERROR(ads, nt_status);
+
+ ads->auth.flags = ADS_AUTH_NO_BIND;
+ ads_status = ads_connect(ads);
+ if (!ADS_ERR_OK(ads_status)) {
+ DEBUG(4, ("find_forest_root: ads_connect(%s) failed! (%s)\n",
+ domain, ads_errstr(ads_status)));
+ }
+ nt_status = ads_ntstatus(ads_status);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+ if (!ads_cldap_netlogon_5(frame,
+ ads->config.ldap_server_name,
+ ads->config.realm,
+ &cldap_reply))
+ {
+ DEBUG(4,("find_forest_root: Failed to get a CLDAP reply from %s!\n",
+ ads->server.ldap_server));
+ nt_status = NT_STATUS_IO_TIMEOUT;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+ gc->forest_name = talloc_strdup(gc, cldap_reply.forest);
+ BAIL_ON_PTR_ERROR(gc->forest_name, nt_status);
+
+done:
+ if (ads) {
+ ads_destroy(&ads);
+ }
+
+ return nt_status;
+}
+
+/**********************************************************************
+ *********************************************************************/
+
+static NTSTATUS gc_add_forest(const char *domain)
+{
+ NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
+ struct gc_info *gc = NULL;
+ struct gc_info *find_gc = NULL;
+ char *dn;
+ ADS_STRUCT *ads = NULL;
+ struct likewise_cell *primary_cell = NULL;
+
+ primary_cell = cell_list_head();
+ if (!primary_cell) {
+ nt_status = NT_STATUS_INVALID_SERVER_STATE;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+ /* Check for duplicates based on domain name first as this
+ requires no connection */
+
+ find_gc = gc_list_head();
+ while (find_gc) {
+ if (strequal (find_gc->forest_name, domain))
+ break;
+ find_gc = find_gc->next;
+ }
+
+ if (find_gc) {
+ DEBUG(10,("gc_add_forest: %s already in list\n", find_gc->forest_name));
+ return NT_STATUS_OK;
+ }
+
+ if ((gc = TALLOC_ZERO_P(NULL, struct gc_info)) == NULL) {
+ nt_status = NT_STATUS_NO_MEMORY;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+ /* Query the rootDSE for the forest root naming conect first.
+ Check that the a GC server for the forest has not already
+ been added */
+
+ nt_status = gc_find_forest_root(gc, domain);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+ find_gc = gc_list_head();
+ while (find_gc) {
+ if (strequal (find_gc->forest_name, gc->forest_name))
+ break;
+ find_gc = find_gc->next;
+ }
+
+ if (find_gc) {
+ DEBUG(10,("gc_add_forest: Forest %s already in list\n",
+ find_gc->forest_name));
+ return NT_STATUS_OK;
+ }
+
+ /* Not found, so add it here. Make sure we connect to
+ a DC in _this_ domain and not the forest root. */
+
+ dn = ads_build_dn(gc->forest_name);
+ BAIL_ON_PTR_ERROR(dn, nt_status);
+
+ gc->search_base = talloc_strdup(gc, dn);
+ SAFE_FREE(dn);
+ BAIL_ON_PTR_ERROR(gc->search_base, nt_status);
+
+#if 0
+ /* Can't use cell_connect_dn() here as there is no way to
+ specifiy the LWCELL_FLAG_GC_CELL flag setting for cell_connect() */
+
+ nt_status = cell_connect_dn(&gc->forest_cell, gc->search_base);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+#else
+
+ gc->forest_cell = cell_new();
+ BAIL_ON_PTR_ERROR(gc->forest_cell, nt_status);
+
+ /* Set the DNS domain, dn, etc ... and add it to the list */
+
+ cell_set_dns_domain(gc->forest_cell, gc->forest_name);
+ cell_set_dn(gc->forest_cell, gc->search_base);
+ cell_set_flags(gc->forest_cell, LWCELL_FLAG_GC_CELL);
+#endif
+
+ /* It is possible to belong to a non-forest cell and a
+ non-provisioned forest (at our domain levele). In that
+ case, we should just inherit the flags from our primary
+ cell since the GC searches will match our own schema
+ model. */
+
+ if (strequal(primary_cell->forest_name, gc->forest_name)
+ || is_subdomain(primary_cell->dns_domain, gc->forest_name))
+ {
+ cell_set_flags(gc->forest_cell, cell_flags(primary_cell));
+ } else {
+ /* outside of our domain */
+
+ nt_status = cell_connect(gc->forest_cell);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+ nt_status = cell_lookup_settings(gc->forest_cell);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+ /* Drop the connection now that we have the settings */
+
+ ads = cell_connection(gc->forest_cell);
+ ads_destroy(&ads);
+ cell_set_connection(gc->forest_cell, NULL);
+ }
+
+ DLIST_ADD_END(_gc_server_list, gc, struct gc_info*);
+
+ DEBUG(10,("gc_add_forest: Added %s to Global Catalog list of servers\n",
+ gc->forest_name));
+
+ nt_status = NT_STATUS_OK;
+
+done:
+ if (!NT_STATUS_IS_OK(nt_status)) {
+ talloc_destroy(gc);
+ DEBUG(3,("LWI: Failed to add new GC connection for %s (%s)\n",
+ domain, nt_errstr(nt_status)));
+ }
+
+ return nt_status;
+}
+
+/**********************************************************************
+ *********************************************************************/
+
+static void gc_server_list_destroy(void)
+{
+ struct gc_info *gc = gc_list_head();
+
+ while (gc) {
+ struct gc_info *p = gc->next;
+
+ cell_destroy(gc->forest_cell);
+ talloc_destroy(gc);
+
+ gc = p;
+ }
+
+ _gc_server_list = NULL;
+
+ return;
+}
+
+/**********************************************************************
+ Setup the initial list of forests and initial the forest cell
+ settings for each. FIXME!!!
+ *********************************************************************/
+
+ NTSTATUS gc_init_list(void)
+{
+ NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
+ struct winbindd_tdc_domain *domains = NULL;
+ size_t num_domains = 0;
+ int i;
+
+ if (_gc_server_list != NULL) {
+ gc_server_list_destroy();
+ }
+
+ if (!wcache_tdc_fetch_list(&domains, &num_domains)) {
+ nt_status = NT_STATUS_CANT_ACCESS_DOMAIN_INFO;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+ /* Find our forest first. Have to try all domains here starting
+ with our own. gc_add_forest() filters duplicates */
+
+ nt_status = gc_add_forest(lp_realm());
+ WARN_ON_NTSTATUS_ERROR(nt_status);
+
+ for (i=0; i<num_domains; i++) {
+ uint32_t flags = (NETR_TRUST_FLAG_IN_FOREST);
+
+ /* I think we should be able to break out of loop once
+ we add a GC for our forest and not have to test every one.
+ In fact, this entire loop is probably irrelevant since
+ the GC location code should always find a GC given lp_realm().
+ Will have to spend time testing before making the change.
+ --jerry */
+
+ if ((domains[i].trust_flags & flags) == flags) {
+ nt_status = gc_add_forest(domains[i].dns_name);
+ WARN_ON_NTSTATUS_ERROR(nt_status);
+ /* Don't BAIL here since not every domain may
+ have a GC server */
+ }
+ }
+
+ /* Now add trusted forests. gc_add_forest() will filter out
+ duplicates. Check everything with an incoming trust path
+ that is not in our own forest. */
+
+ for (i=0; i<num_domains; i++) {
+ uint32_t flags = domains[i].trust_flags;
+ uint32_t attribs = domains[i].trust_attribs;
+
+ /* Skip non_AD domains */
+
+ if (strlen(domains[i].dns_name) == 0) {
+ continue;
+ }
+
+ /* Only add a GC for a forest outside of our own.
+ Ignore QUARANTINED/EXTERNAL trusts */
+
+ if ((flags & NETR_TRUST_FLAG_INBOUND)
+ && !(flags & NETR_TRUST_FLAG_IN_FOREST)
+ && (attribs & NETR_TRUST_ATTRIBUTE_FOREST_TRANSITIVE))
+ {
+ nt_status = gc_add_forest(domains[i].dns_name);
+ WARN_ON_NTSTATUS_ERROR(nt_status);
+ }
+ }
+
+ nt_status = NT_STATUS_OK;
+
+done:
+ if (!NT_STATUS_IS_OK(nt_status)) {
+ DEBUG(2,("LWI: Failed to initialized GC list (%s)\n",
+ nt_errstr(nt_status)));
+ }
+
+ TALLOC_FREE(domains);
+
+ return nt_status;
+}
+
+
+/**********************************************************************
+ *********************************************************************/
+
+ struct gc_info *gc_search_start(void)
+{
+ NTSTATUS nt_status = NT_STATUS_OK;
+ struct gc_info *gc = gc_list_head();
+
+ if (!gc) {
+ nt_status = gc_init_list();
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+ gc = gc_list_head();
+ }
+
+done:
+ if (!NT_STATUS_IS_OK(nt_status)) {
+ DEBUG(2,("LWI: Failed to initialize GC list (%s)\n",
+ nt_errstr(nt_status)));
+ }
+
+ return gc;
+}
+
+/**********************************************************************
+ Search Global Catalog. Always search our own forest. The flags set
+ controls whether or not we search cross forest. Assume that the
+ resulting set is always returned from one GC so that we don't have to
+ both combining the LDAPMessage * results
+ *********************************************************************/
+
+ NTSTATUS gc_search_forest(struct gc_info *gc,
+ LDAPMessage **msg,
+ const char *filter)
+{
+ NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
+ ADS_STATUS ads_status = ADS_ERROR_NT(NT_STATUS_UNSUCCESSFUL);
+ const char *attrs[] = {"*", NULL};
+ LDAPMessage *m = NULL;
+
+ if (!gc || !msg || !filter) {
+ nt_status = NT_STATUS_INVALID_PARAMETER;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+ /* When you have multiple domain trees in a forest, the
+ GC will search all naming contexts when you send it
+ and empty ("") base search suffix. Tested against
+ Windows 2003. */
+
+ ads_status = cell_do_search(gc->forest_cell, "",
+ LDAP_SCOPE_SUBTREE, filter, attrs, &m);
+ nt_status = ads_ntstatus(ads_status);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+ *msg = m;
+
+done:
+ if (!NT_STATUS_IS_OK(nt_status)) {
+ DEBUG(2,("LWI: Forest wide search %s failed (%s)\n",
+ filter, nt_errstr(nt_status)));
+ }
+
+ return nt_status;
+}
+
+/**********************************************************************
+ Search all forests via GC and return the results in an array of
+ ADS_STRUCT/LDAPMessage pairs.
+ *********************************************************************/
+
+ NTSTATUS gc_search_all_forests(const char *filter,
+ ADS_STRUCT ***ads_list,
+ LDAPMessage ***msg_list,
+ int *num_resp, uint32_t flags)
+{
+ NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
+ struct gc_info *gc = NULL;
+ uint32_t test_flags = ADEX_GC_SEARCH_CHECK_UNIQUE;
+
+ *ads_list = NULL;
+ *msg_list = NULL;
+ *num_resp = 0;
+
+ if ((gc = gc_search_start()) == NULL) {
+ nt_status = NT_STATUS_INVALID_DOMAIN_STATE;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+ while (gc) {
+ LDAPMessage *m = NULL;
+
+ nt_status = gc_search_forest(gc, &m, filter);
+ if (!NT_STATUS_IS_OK(nt_status)) {
+ gc = gc->next;
+ continue;
+ }
+
+ nt_status = add_ads_result_to_array(cell_connection(gc->forest_cell),
+ m, ads_list, msg_list,
+ num_resp);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+ /* If there can only be one match, then we are done */
+
+ if ((*num_resp > 0) && ((flags & test_flags) == test_flags)) {
+ break;
+ }
+
+ gc = gc->next;
+ }
+
+ if (*num_resp == 0) {
+ nt_status = NT_STATUS_OBJECT_NAME_NOT_FOUND;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+ nt_status = NT_STATUS_OK;
+
+done:
+ return nt_status;
+}
+
+/**********************************************************************
+ Search all forests via GC and return the results in an array of
+ ADS_STRUCT/LDAPMessage pairs.
+ *********************************************************************/
+
+ NTSTATUS gc_search_all_forests_unique(const char *filter,
+ ADS_STRUCT **ads,
+ LDAPMessage **msg)
+{
+ ADS_STRUCT **ads_list = NULL;
+ LDAPMessage **msg_list = NULL;
+ int num_resp;
+ NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
+
+ nt_status = gc_search_all_forests(filter, &ads_list,
+ &msg_list, &num_resp,
+ ADEX_GC_SEARCH_CHECK_UNIQUE);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+ nt_status = check_result_unique(ads_list[0], msg_list[0]);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+ *ads = ads_list[0];
+ *msg = msg_list[0];
+
+done:
+ /* Be care that we don't free the msg result being returned */
+
+ if (!NT_STATUS_IS_OK(nt_status)) {
+ free_result_array(ads_list, msg_list, num_resp);
+ } else {
+ talloc_destroy(ads_list);
+ talloc_destroy(msg_list);
+ }
+
+ return nt_status;
+}
+
+/*********************************************************************
+ ********************************************************************/
+
+ NTSTATUS gc_name_to_sid(const char *domain,
+ const char *name,
+ DOM_SID *sid,
+ enum lsa_SidType *sid_type)
+{
+ TALLOC_CTX *frame = talloc_stackframe();
+ char *p, *name_user;
+ NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
+ char *name_filter;
+ ADS_STRUCT *ads = NULL;
+ LDAPMessage *msg = NULL;
+ LDAPMessage *e = NULL;
+ char *dn = NULL;
+ char *dns_domain = NULL;
+ ADS_STRUCT **ads_list = NULL;
+ LDAPMessage **msg_list = NULL;
+ int num_resp = 0;
+ int i;
+
+ /* Strip the "DOMAIN\" prefix if necessary and search for
+ a matching sAMAccountName in the forest */
+
+ if ((p = strchr_m( name, '\\' )) == NULL)
+ name_user = talloc_strdup( frame, name );
+ else
+ name_user = talloc_strdup( frame, p+1 );
+ BAIL_ON_PTR_ERROR(name_user, nt_status);
+
+ name_filter = talloc_asprintf(frame, "(sAMAccountName=%s)", name_user);
+ BAIL_ON_PTR_ERROR(name_filter, nt_status);
+
+ nt_status = gc_search_all_forests(name_filter, &ads_list,
+ &msg_list, &num_resp, 0);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+ /* Assume failure until we know otherwise*/
+
+ nt_status = NT_STATUS_OBJECT_NAME_NOT_FOUND;
+
+ /* Match the domain name from the DN */
+
+ for (i=0; i<num_resp; i++) {
+ ads = ads_list[i];
+ msg = msg_list[i];
+
+ e = ads_first_entry(ads, msg);
+ while (e) {
+ struct winbindd_tdc_domain *domain_rec;
+
+ dn = ads_get_dn(ads, e);
+ BAIL_ON_PTR_ERROR(dn, nt_status);
+
+ dns_domain = cell_dn_to_dns(dn);
+ SAFE_FREE(dn);
+ BAIL_ON_PTR_ERROR(dns_domain, nt_status);
+
+ domain_rec = wcache_tdc_fetch_domain(frame, dns_domain);
+ SAFE_FREE(dns_domain);
+
+ /* Ignore failures and continue the search */
+
+ if (!domain_rec) {
+ e = ads_next_entry(ads, e);
+ continue;
+ }
+
+ /* Check for a match on the domain name */
+
+ if (strequal(domain, domain_rec->domain_name)) {
+ if (!ads_pull_sid(ads, e, "objectSid", sid)) {
+ nt_status = NT_STATUS_INVALID_SID;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+ talloc_destroy(domain_rec);
+
+ nt_status = get_sid_type(ads, msg, sid_type);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+ /* We're done! */
+ nt_status = NT_STATUS_OK;
+ break;
+ }
+
+ /* once more around thew merry-go-round */
+
+ talloc_destroy(domain_rec);
+ e = ads_next_entry(ads, e);
+ }
+ }
+
+done:
+ free_result_array(ads_list, msg_list, num_resp);
+ talloc_destroy(frame);
+
+ return nt_status;
+}
+
+/********************************************************************
+ Pull an attribute string value
+ *******************************************************************/
+
+static NTSTATUS get_object_account_name(ADS_STRUCT *ads,
+ LDAPMessage *msg,
+ char **name)
+{
+ NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
+ char *sam_name = NULL;
+ struct winbindd_tdc_domain *domain_rec = NULL;
+ char *dns_domain = NULL;
+ char *dn = NULL;
+ TALLOC_CTX *frame = talloc_stackframe();
+ int len;
+
+ /* Check parameters */
+
+ if (!ads || !msg || !name) {
+ nt_status = NT_STATUS_INVALID_PARAMETER;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+ /* get the name and domain */
+
+ dn = ads_get_dn(ads, msg);
+ BAIL_ON_PTR_ERROR(dn, nt_status);
+
+ DEBUG(10,("get_object_account_name: dn = \"%s\"\n", dn));
+
+ dns_domain = cell_dn_to_dns(dn);
+ SAFE_FREE(dn);
+ BAIL_ON_PTR_ERROR(dns_domain, nt_status);
+
+ domain_rec = wcache_tdc_fetch_domain(frame, dns_domain);
+ SAFE_FREE(dns_domain);
+
+ if (!domain_rec) {
+ nt_status = NT_STATUS_TRUSTED_DOMAIN_FAILURE;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+ sam_name = ads_pull_string(ads, frame, msg, "sAMAccountName");
+ BAIL_ON_PTR_ERROR(sam_name, nt_status);
+
+ len = asprintf(name, "%s\\%s", domain_rec->domain_name, sam_name);
+ if (len == -1) {
+ *name = NULL;
+ BAIL_ON_PTR_ERROR((*name), nt_status);
+ }
+
+ nt_status = NT_STATUS_OK;
+
+done:
+ talloc_destroy(frame);
+
+ return nt_status;
+}
+
+/*********************************************************************
+ ********************************************************************/
+
+ NTSTATUS gc_sid_to_name(const DOM_SID *sid,
+ char **name,
+ enum lsa_SidType *sid_type)
+{
+ TALLOC_CTX *frame = talloc_stackframe();
+ NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
+ char *filter;
+ ADS_STRUCT *ads = NULL;
+ LDAPMessage *msg = NULL;
+ char *sid_string;
+
+ *name = NULL;
+
+ sid_string = sid_binstring(sid);
+ BAIL_ON_PTR_ERROR(sid_string, nt_status);
+
+ filter = talloc_asprintf(frame, "(objectSid=%s)", sid_string);
+ SAFE_FREE(sid_string);
+ BAIL_ON_PTR_ERROR(filter, nt_status);
+
+ nt_status = gc_search_all_forests_unique(filter, &ads, &msg);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+ nt_status = get_object_account_name(ads, msg, name);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+ nt_status = get_sid_type(ads, msg, sid_type);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+done:
+ ads_msgfree(ads, msg);
+ talloc_destroy(frame);
+
+ return nt_status;
+}
+
+/**********************************************************************
+ *********************************************************************/
+
+ NTSTATUS add_ads_result_to_array(ADS_STRUCT *ads,
+ LDAPMessage *msg,
+ ADS_STRUCT ***ads_list,
+ LDAPMessage ***msg_list,
+ int *size)
+{
+ NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
+ ADS_STRUCT **ads_tmp = NULL;
+ LDAPMessage **msg_tmp = NULL;
+ int count = *size;
+
+ if (!ads || !msg) {
+ nt_status = NT_STATUS_INVALID_PARAMETER;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+#if 0
+ /* Don't add a response with no entries */
+
+ if (ads_count_replies(ads, msg) == 0) {
+ return NT_STATUS_OK;
+ }
+#endif
+
+ if (count == 0) {
+ ads_tmp = TALLOC_ARRAY(NULL, ADS_STRUCT*, 1);
+ BAIL_ON_PTR_ERROR(ads_tmp, nt_status);
+
+ msg_tmp = TALLOC_ARRAY(NULL, LDAPMessage*, 1);
+ BAIL_ON_PTR_ERROR(msg_tmp, nt_status);
+ } else {
+ ads_tmp = TALLOC_REALLOC_ARRAY(*ads_list, *ads_list, ADS_STRUCT*,
+ count+1);
+ BAIL_ON_PTR_ERROR(ads_tmp, nt_status);
+
+ msg_tmp = TALLOC_REALLOC_ARRAY(*msg_list, *msg_list, LDAPMessage*,
+ count+1);
+ BAIL_ON_PTR_ERROR(msg_tmp, nt_status);
+ }
+
+ ads_tmp[count] = ads;
+ msg_tmp[count] = msg;
+ count++;
+
+ *ads_list = ads_tmp;
+ *msg_list = msg_tmp;
+ *size = count;
+
+ nt_status = NT_STATUS_OK;
+
+done:
+ if (!NT_STATUS_IS_OK(nt_status)) {
+ talloc_destroy(ads_tmp);
+ talloc_destroy(msg_tmp);
+ }
+
+ return nt_status;
+}
+
+/**********************************************************************
+ Frees search results. Do not free the ads_list as these are
+ references back to the GC search structures.
+ *********************************************************************/
+
+ void free_result_array(ADS_STRUCT **ads_list,
+ LDAPMessage **msg_list,
+ int num_resp)
+{
+ int i;
+
+ for (i=0; i<num_resp; i++) {
+ ads_msgfree(ads_list[i], msg_list[i]);
+ }
+
+ talloc_destroy(ads_list);
+ talloc_destroy(msg_list);
+}
+
+/**********************************************************************
+ Check that we have exactly one entry from the search
+ *********************************************************************/
+
+ NTSTATUS check_result_unique(ADS_STRUCT *ads, LDAPMessage *msg)
+{
+ NTSTATUS nt_status;
+ int count;
+
+ count = ads_count_replies(ads, msg);
+
+ if (count <= 0) {
+ nt_status = NT_STATUS_OBJECT_NAME_NOT_FOUND;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+ if (count > 1) {
+ nt_status = NT_STATUS_DUPLICATE_NAME;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+ nt_status = NT_STATUS_OK;
+
+done:
+ return nt_status;
+}
--- /dev/null
+/*
+ * idmap_adex: Support for D Forests
+ *
+ * Copyright (C) Gerald (Jerry) Carter 2006-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 2 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, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "includes.h"
+#include "idmap_adex.h"
+
+#undef DBGC_CLASS
+#define DBGC_CLASS DBGC_IDMAP
+
+#define WINBIND_CCACHE_NAME "MEMORY:winbind_ccache"
+
+NTSTATUS init_module(void);
+
+/*
+ * IdMap backend
+ */
+
+/********************************************************************
+ Basic init function responsible for determining our current mode
+ (standalone or using Centeris Cells). This must return success or
+ it will be dropped from the idmap backend list.
+ *******************************************************************/
+
+static NTSTATUS _idmap_adex_init(struct idmap_domain *dom,
+ const char *params)
+{
+ ADS_STRUCT *ads = NULL;
+ ADS_STATUS status;
+ static NTSTATUS init_status = NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
+ DOM_SID domain_sid;
+ fstring dcname;
+ struct sockaddr_storage ip;
+ struct likewise_cell *lwcell;
+
+ if (NT_STATUS_IS_OK(init_status))
+ return NT_STATUS_OK;
+
+ /* Silently fail if we are not a member server in security = ads */
+
+ if ((lp_server_role() != ROLE_DOMAIN_MEMBER) ||
+ (lp_security() != SEC_ADS)) {
+ init_status = NT_STATUS_INVALID_SERVER_STATE;
+ BAIL_ON_NTSTATUS_ERROR(init_status);
+ }
+
+ /* fetch our domain SID first */
+
+ if (!secrets_fetch_domain_sid(lp_workgroup(), &domain_sid)) {
+ init_status = NT_STATUS_CANT_ACCESS_DOMAIN_INFO;
+ BAIL_ON_NTSTATUS_ERROR(init_status);
+ }
+
+ /* reuse the same ticket cache as winbindd */
+
+ setenv("KRB5CCNAME", WINBIND_CCACHE_NAME, 1);
+
+ /* Establish a connection to a DC */
+
+ if ((ads = ads_init(lp_realm(), lp_workgroup(), NULL)) == NULL) {
+ init_status = NT_STATUS_NO_MEMORY;
+ BAIL_ON_NTSTATUS_ERROR(init_status);
+ }
+
+ ads->auth.password =
+ secrets_fetch_machine_password(lp_workgroup(), NULL, NULL);
+ ads->auth.realm = SMB_STRDUP(lp_realm());
+
+ /* get the DC name here to setup the server affinity cache and
+ local krb5.conf */
+
+ get_dc_name(lp_workgroup(), lp_realm(), dcname, &ip);
+
+ status = ads_connect(ads);
+ if (!ADS_ERR_OK(status)) {
+ DEBUG(0, ("_idmap_adex_init: ads_connect() failed! (%s)\n",
+ ads_errstr(status)));
+ }
+ init_status = ads_ntstatus(status);
+ BAIL_ON_NTSTATUS_ERROR(init_status);
+
+
+ /* Find out cell membership */
+
+ init_status = cell_locate_membership(ads);
+ if (!NT_STATUS_IS_OK(init_status)) {
+ DEBUG(0,("LWI: Fail to locate cell membership (%s).",
+ nt_errstr(init_status)));
+ goto done;
+ }
+
+ /* Fill in the cell information */
+
+ lwcell = cell_list_head();
+
+ init_status = cell_lookup_settings(lwcell);
+ BAIL_ON_NTSTATUS_ERROR(init_status);
+
+ /* Miscellaneous setup. E.g. set up the list of GC
+ servers and domain list for our forest (does not actually
+ connect). */
+
+ init_status = gc_init_list();
+ BAIL_ON_NTSTATUS_ERROR(init_status);
+
+ init_status = domain_init_list();
+ BAIL_ON_NTSTATUS_ERROR(init_status);
+
+done:
+ if (!NT_STATUS_IS_OK(init_status)) {
+ DEBUG(1,("Likewise initialization failed (%s)\n",
+ nt_errstr(init_status)));
+ }
+
+ /* cleanup */
+
+ if (!NT_STATUS_IS_OK(init_status)) {
+ cell_list_destroy();
+
+ /* init_status stores the failure reason but we need to
+ return success or else idmap_init() will drop us from the
+ backend list */
+ return NT_STATUS_OK;
+ }
+
+ init_status = NT_STATUS_OK;
+
+ return init_status;
+}
+
+/**********************************************************************
+ *********************************************************************/
+
+static NTSTATUS _idmap_adex_get_sid_from_id(struct
+ idmap_domain
+ *dom, struct
+ id_map
+ **ids)
+{
+ int i;
+ bool one_mapped = false;
+ bool all_mapped = true;
+ NTSTATUS nt_status;
+ struct likewise_cell *cell;
+
+ nt_status = _idmap_adex_init(dom, NULL);
+ if (!NT_STATUS_IS_OK(nt_status))
+ return nt_status;
+
+ if ((cell = cell_list_head()) == NULL) {
+ return NT_STATUS_INVALID_SERVER_STATE;
+ }
+
+ /* have to work through these one by one */
+ for (i = 0; ids[i]; i++) {
+ NTSTATUS status;
+ status = cell->provider->get_sid_from_id(ids[i]->sid,
+ ids[i]->xid.id,
+ ids[i]->xid.type);
+ /* Fail if we cannot find any DC */
+ if (NT_STATUS_EQUAL
+ (status, NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND)) {
+ return status;
+ }
+
+ if (!NT_STATUS_IS_OK(status)) {
+ ids[i]->status = ID_UNMAPPED;
+ all_mapped = false;
+ continue;
+ }
+
+ ids[i]->status = ID_MAPPED;
+ one_mapped = true;
+ }
+
+ return NT_STATUS_OK;
+}
+
+/**********************************************************************
+ *********************************************************************/
+
+static NTSTATUS _idmap_adex_get_id_from_sid(struct
+ idmap_domain
+ *dom, struct
+ id_map
+ **ids)
+{
+ int i;
+ bool one_mapped = false;
+ bool all_mapped = true;
+ NTSTATUS nt_status;
+ struct likewise_cell *cell;
+
+ nt_status = _idmap_adex_init(dom, NULL);
+ if (!NT_STATUS_IS_OK(nt_status))
+ return nt_status;
+
+ if ((cell = cell_list_head()) == NULL) {
+ return NT_STATUS_INVALID_SERVER_STATE;
+ }
+
+ /* have to work through these one by one */
+ for (i = 0; ids[i]; i++) {
+ NTSTATUS status;
+ status = cell->provider->get_id_from_sid(&ids[i]->xid.id,
+ &ids[i]->xid.
+ type, ids[i]->sid);
+ /* Fail if we cannot find any DC */
+ if (NT_STATUS_EQUAL
+ (status, NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND)) {
+ return status;
+ }
+
+ if (!NT_STATUS_IS_OK(status)) {
+ ids[i]->status = ID_UNMAPPED;
+ all_mapped = false;
+ continue;
+ }
+
+ ids[i]->status = ID_MAPPED;
+ one_mapped = true;
+ }
+
+ return NT_STATUS_OK;
+}
+
+/**********************************************************************
+ *********************************************************************/
+
+static NTSTATUS _idmap_adex_set_mapping(struct
+ idmap_domain
+ *dom, const struct
+ id_map *map)
+{
+ DEBUG(0, ("_idmap_adex_set_mapping: not implemented\n"));
+ return NT_STATUS_NOT_IMPLEMENTED;
+}
+
+/**********************************************************************
+ *********************************************************************/
+
+static NTSTATUS _idmap_adex_remove_mapping(struct
+ idmap_domain
+ *dom, const
+ struct
+ id_map
+ *map)
+{
+ DEBUG(0, ("_idmap_adex_remove_mapping: not implemented\n"));
+ return NT_STATUS_NOT_IMPLEMENTED;
+}
+
+/**********************************************************************
+ *********************************************************************/
+
+static NTSTATUS _idmap_adex_dump(struct idmap_domain
+ *dom, struct id_map **maps, int *num_map)
+{
+ return NT_STATUS_NOT_IMPLEMENTED;
+}
+
+/**********************************************************************
+ *********************************************************************/
+
+static NTSTATUS _idmap_adex_close(struct idmap_domain
+ *dom)
+{
+ /* FIXME! need to do cleanup here */
+
+ return NT_STATUS_OK;
+}
+
+/*
+ * IdMap NSS plugin
+ */
+
+/**********************************************************************
+ *********************************************************************/
+
+static NTSTATUS _nss_adex_init(struct nss_domain_entry
+ *e)
+{
+ return _idmap_adex_init(NULL, NULL);
+}
+
+/**********************************************************************
+ *********************************************************************/
+
+static NTSTATUS _nss_adex_get_info(struct
+ nss_domain_entry *e,
+ const DOM_SID * sid,
+ TALLOC_CTX * ctx,
+ ADS_STRUCT * ads,
+ LDAPMessage * msg,
+ char **homedir,
+ char **shell, char **gecos, gid_t * p_gid)
+{
+ NTSTATUS nt_status;
+ struct likewise_cell *cell;
+
+ nt_status = _idmap_adex_init(NULL, NULL);
+ if (!NT_STATUS_IS_OK(nt_status))
+ return nt_status;
+
+ if ((cell = cell_list_head()) == NULL) {
+ return NT_STATUS_INVALID_SERVER_STATE;
+ }
+
+ return cell->provider->get_nss_info(sid, ctx, homedir,
+ shell, gecos, p_gid);
+}
+
+/**********************************************************************
+ *********************************************************************/
+
+static NTSTATUS _nss_adex_map_to_alias(TALLOC_CTX * mem_ctx, const char
+ *domain, const char
+ *name, char **alias)
+{
+ NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
+ struct likewise_cell *cell = NULL;
+
+ nt_status = _idmap_adex_init(NULL, NULL);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+ if ((cell = cell_list_head()) == NULL) {
+ nt_status = NT_STATUS_INVALID_SERVER_STATE;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+ nt_status = cell->provider->map_to_alias(mem_ctx, domain,
+ name, alias);
+
+ /* go ahead and allow the cache mgr to mark this in
+ negative cache */
+
+ if (!NT_STATUS_IS_OK(nt_status))
+ nt_status = NT_STATUS_NONE_MAPPED;
+
+done:
+ return nt_status;
+}
+
+/**********************************************************************
+ *********************************************************************/
+
+static NTSTATUS _nss_adex_map_from_alias(TALLOC_CTX * mem_ctx, const char
+ *domain, const char
+ *alias, char **name)
+{
+ NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
+ struct likewise_cell *cell = NULL;
+
+ nt_status = _idmap_adex_init(NULL, NULL);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+ if ((cell = cell_list_head()) == NULL) {
+ nt_status = NT_STATUS_INVALID_SERVER_STATE;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+
+ nt_status = cell->provider->map_from_alias(mem_ctx, domain,
+ alias, name);
+
+ /* go ahead and allow the cache mgr to mark this in
+ negative cache */
+
+ if (!NT_STATUS_IS_OK(nt_status))
+ nt_status = NT_STATUS_NONE_MAPPED;
+
+done:
+ return nt_status;
+}
+
+/**********************************************************************
+ *********************************************************************/
+
+static NTSTATUS _nss_adex_close(void)
+{
+ return NT_STATUS_NOT_IMPLEMENTED;
+}
+
+/**********************************************************************
+ *********************************************************************/
+
+static struct idmap_methods adex_idmap_methods = {
+
+ .init = _idmap_adex_init,
+ .unixids_to_sids = _idmap_adex_get_sid_from_id,
+ .sids_to_unixids = _idmap_adex_get_id_from_sid,
+ .set_mapping = _idmap_adex_set_mapping,
+ .remove_mapping = _idmap_adex_remove_mapping,
+ .dump_data = _idmap_adex_dump,
+ .close_fn = _idmap_adex_close
+};
+static struct nss_info_methods adex_nss_methods = {
+ .init = _nss_adex_init,
+ .get_nss_info = _nss_adex_get_info,
+ .map_to_alias = _nss_adex_map_to_alias,
+ .map_from_alias = _nss_adex_map_from_alias,
+ .close_fn = _nss_adex_close
+};
+
+/**********************************************************************
+ Register with the idmap and idmap_nss subsystems. We have to protect
+ against the idmap and nss_info interfaces being in a half-registered
+ state.
+ **********************************************************************/
+NTSTATUS idmap_adex_init(void)
+{
+ static NTSTATUS idmap_status = NT_STATUS_UNSUCCESSFUL;
+ static NTSTATUS nss_status = NT_STATUS_UNSUCCESSFUL;
+ if (!NT_STATUS_IS_OK(idmap_status)) {
+ idmap_status =
+ smb_register_idmap(SMB_IDMAP_INTERFACE_VERSION,
+ "adex", &adex_idmap_methods);
+ if (!NT_STATUS_IS_OK(idmap_status)) {
+ DEBUG(0,
+ ("idmap_centeris_init: Failed to register the adex"
+ "idmap plugin.\n"));
+ return idmap_status;
+ }
+ }
+
+ if (!NT_STATUS_IS_OK(nss_status)) {
+ nss_status =
+ smb_register_idmap_nss(SMB_NSS_INFO_INTERFACE_VERSION,
+ "adex", &adex_nss_methods);
+ if (!NT_STATUS_IS_OK(nss_status)) {
+ DEBUG(0,
+ ("idmap_adex_init: Failed to register the adex"
+ "nss plugin.\n"));
+ return nss_status;
+ }
+ }
+
+ return NT_STATUS_OK;
+}
+
+static NTSTATUS nss_info_adex_init(void)
+{
+ return idmap_adex_init();
+}
--- /dev/null
+/*
+ * idmap_centeris: Support for Local IDs and Centeris Cell Structure
+ *
+ * Copyright (C) Gerald (Jerry) Carter 2006-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 2 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, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef _IDMAP_ADEX_H
+#define _IDMAP_ADEX_H
+
+#include "winbindd/winbindd.h"
+
+#define ADEX_CELL_RDN "$LikewiseIdentityCell"
+
+#define ADEX_OC_USER "centerisLikewiseUser"
+#define ADEX_OC_GROUP "centerisLikewiseGroup"
+
+#define AD_USER "User"
+#define AD_GROUP "Group"
+
+#define ADEX_OC_POSIX_USER "posixAccount"
+#define ADEX_OC_POSIX_GROUP "posixGroup"
+
+#define ADEX_ATTR_UIDNUM "uidNumber"
+#define ADEX_ATTR_GIDNUM "gidNUmber"
+#define ADEX_ATTR_HOMEDIR "unixHomeDirectory"
+#define ADEX_ATTR_USERPW "unixUserPassword"
+#define ADEX_ATTR_GROUPALIAS "groupAlias" /* Not part of RFC2307 */
+#define ADEX_ATTR_SHELL "loginShell"
+#define ADEX_ATTR_GECOS "gecos"
+#define ADEX_ATTR_UID "uid"
+#define ADEX_ATTR_DISPLAYNAME "displayName"
+
+#define MIN_ID_VALUE 100
+
+#define BAIL_ON_NTSTATUS_ERROR(x) \
+ do { \
+ if (!NT_STATUS_IS_OK(x)) { \
+ DEBUG(10,("Failed! (%s)\n", nt_errstr(x))); \
+ goto done; \
+ } \
+ } \
+ while (0); \
+
+#define WARN_ON_NTSTATUS_ERROR(x) \
+ do { \
+ if (!NT_STATUS_IS_OK(x)) { \
+ DEBUG(10,("Failure ignored! (%s)\n", nt_errstr(x))); \
+ } \
+ } \
+ while (0); \
+
+#define BAIL_ON_ADS_ERROR(x) \
+ do { \
+ if (!ADS_ERR_OK(x)) { \
+ goto done; \
+ } \
+ } \
+ while (0);
+
+#define BAIL_ON_PTR_ERROR(p, x) \
+ do { \
+ if ((p) == NULL ) { \
+ DEBUG(10,("NULL pointer!\n")); \
+ x = NT_STATUS_NO_MEMORY; \
+ goto done; \
+ } \
+ } while (0);
+
+#define PRINT_NTSTATUS_ERROR(x, hdr, level) \
+ do { \
+ if (!NT_STATUS_IS_OK(x)) { \
+ DEBUG(level,("LWI ("hdr"): %s\n", nt_errstr(x))); \
+ } \
+ } while(0);
+/*
+ * Cell Provider API
+ */
+
+struct cell_provider_api {
+ NTSTATUS(*get_sid_from_id) (DOM_SID * sid,
+ uint32_t id, enum id_type type);
+ NTSTATUS(*get_id_from_sid) (uint32_t * id,
+ enum id_type * type, const DOM_SID * sid);
+ NTSTATUS(*get_nss_info) (const DOM_SID * sid,
+ TALLOC_CTX * ctx,
+ char **homedir,
+ char **shell, char **gecos, gid_t * p_gid);
+ NTSTATUS(*map_to_alias) (TALLOC_CTX * mem_ctx,
+ const char *domain,
+ const char *name, char **alias);
+ NTSTATUS(*map_from_alias) (TALLOC_CTX * mem_ctx,
+ const char *domain,
+ const char *alias, char **name);
+};
+
+/* registered providers */
+
+extern struct cell_provider_api ccp_unified;
+extern struct cell_provider_api ccp_local;
+
+#define LWCELL_FLAG_USE_RFC2307_ATTRS 0x00000001
+#define LWCELL_FLAG_SEARCH_FOREST 0x00000002
+#define LWCELL_FLAG_GC_CELL 0x00000004
+#define LWCELL_FLAG_LOCAL_MODE 0x00000008
+
+struct likewise_cell {
+ struct likewise_cell *prev, *next;
+ ADS_STRUCT *conn;
+ struct likewise_cell *gc_search_cell;
+ DOM_SID domain_sid;
+ char *dns_domain;
+ char *forest_name;
+ char *dn;
+ struct GUID *links; /* only held by owning cell */
+ size_t num_links;
+ uint32_t flags;
+ struct cell_provider_api *provider;
+};
+
+/* Search flags used for Global Catalog API */
+
+#define ADEX_GC_SEARCH_CHECK_UNIQUE 0x00000001
+
+struct gc_info {
+ struct gc_info *prev, *next;
+ char *forest_name;
+ char *search_base;
+ struct likewise_cell *forest_cell;
+};
+
+/* Available functions outside of idmap_lwidentity.c */
+
+/* cell_util.c */
+
+char *find_attr_string(char **list, size_t num_lines, const char *substr);
+bool is_object_class(char **list, size_t num_lines, const char *substr);
+int min_id_value(void);
+char *cell_dn_to_dns(const char *dn);
+NTSTATUS get_sid_type(ADS_STRUCT *ads,
+ LDAPMessage *msg,
+ enum lsa_SidType *type);
+
+NTSTATUS cell_locate_membership(ADS_STRUCT * ads);
+NTSTATUS cell_lookup_settings(struct likewise_cell * cell);
+NTSTATUS cell_follow_links(struct likewise_cell *cell);
+NTSTATUS cell_set_local_provider(void);
+
+/* likewise_cell.c */
+
+struct likewise_cell *cell_new(void);
+struct likewise_cell *cell_list_head(void);
+
+bool cell_list_add(struct likewise_cell *cell);
+bool cell_list_remove(struct likewise_cell * cell);
+
+void cell_list_destroy(void);
+void cell_destroy(struct likewise_cell *c);
+void cell_set_forest_searches(struct likewise_cell *c,
+ bool search);
+void cell_set_dns_domain(struct likewise_cell *c,
+ const char *dns_domain);
+void cell_set_connection(struct likewise_cell *c,
+ ADS_STRUCT *ads);
+void cell_set_dn(struct likewise_cell *c,
+ const char *dn);
+void cell_set_domain_sid(struct likewise_cell *c,
+ DOM_SID *sid);
+void cell_set_flags(struct likewise_cell *c, uint32_t flags);
+void cell_clear_flags(struct likewise_cell *c, uint32_t flags);
+
+const char* cell_search_base(struct likewise_cell *c);
+const char *cell_dns_domain(struct likewise_cell *c);
+ADS_STRUCT *cell_connection(struct likewise_cell *c);
+bool cell_search_forest(struct likewise_cell *c);
+ADS_STATUS cell_do_search(struct likewise_cell *c,
+ const char *search_base,
+ int scope,
+ const char *expr,
+ const char **attrs,
+ LDAPMessage ** msg);
+uint32_t cell_flags(struct likewise_cell *c);
+
+NTSTATUS cell_connect_dn(struct likewise_cell **c,
+ const char *dn);
+NTSTATUS cell_connect(struct likewise_cell *c);
+
+
+/* gc_util.c */
+
+NTSTATUS gc_init_list(void);
+
+NTSTATUS gc_find_forest_root(struct gc_info *gc,
+ const char *domain);
+
+struct gc_info *gc_search_start(void);
+
+NTSTATUS gc_search_forest(struct gc_info *gc,
+ LDAPMessage **msg,
+ const char *filter);
+
+NTSTATUS gc_search_all_forests(const char *filter,
+ ADS_STRUCT ***ads_list,
+ LDAPMessage ***msg_list,
+ int *num_resp, uint32_t flags);
+
+NTSTATUS gc_search_all_forests_unique(const char *filter,
+ ADS_STRUCT **ads,
+ LDAPMessage **msg);
+
+NTSTATUS gc_name_to_sid(const char *domain,
+ const char *name,
+ DOM_SID *sid,
+ enum lsa_SidType *sid_type);
+
+NTSTATUS gc_sid_to_name(const DOM_SID *sid,
+ char **name,
+ enum lsa_SidType *sid_type);
+
+NTSTATUS add_ads_result_to_array(ADS_STRUCT *ads,
+ LDAPMessage *msg,
+ ADS_STRUCT ***ads_list,
+ LDAPMessage ***msg_list,
+ int *size);
+
+void free_result_array(ADS_STRUCT **ads_list,
+ LDAPMessage **msg_list,
+ int num_resp);
+
+NTSTATUS check_result_unique(ADS_STRUCT *ads,
+ LDAPMessage *msg);
+
+
+/* domain_util.c */
+
+NTSTATUS domain_init_list(void);
+
+NTSTATUS dc_search_domains(struct likewise_cell **cell,
+ LDAPMessage **msg,
+ const char *dn,
+ const DOM_SID *user_sid);
+
+
+#endif /* _IDMAP_ADEX_H */
--- /dev/null
+/*
+ * idmap_adex: Support for AD Forests
+ *
+ * Copyright (C) Gerald (Jerry) Carter 2006-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 2 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, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "includes.h"
+#include "idmap_adex.h"
+
+#undef DBGC_CLASS
+#define DBGC_CLASS DBGC_IDMAP
+
+static struct likewise_cell *_lw_cell_list = NULL;
+
+/**********************************************************************
+ Return the current HEAD of the list
+ *********************************************************************/
+
+ struct likewise_cell *cell_list_head(void)
+{
+ return _lw_cell_list;
+}
+
+
+/**********************************************************************
+ *********************************************************************/
+
+ void cell_destroy(struct likewise_cell *c)
+{
+ if (!c)
+ return;
+
+ if (c->conn)
+ ads_destroy(&c->conn);
+
+ talloc_destroy(c);
+}
+
+/**********************************************************************
+ Free all cell entries and reset the list head to NULL
+ *********************************************************************/
+
+ void cell_list_destroy(void)
+{
+ struct likewise_cell *p = _lw_cell_list;
+
+ while (p) {
+ struct likewise_cell *q = p->next;
+
+ cell_destroy(p);
+
+ p = q;
+ }
+
+ _lw_cell_list = NULL;
+
+ return;
+}
+
+/**********************************************************************
+ Add a new cell structure to the list
+ *********************************************************************/
+
+ struct likewise_cell* cell_new(void)
+{
+ struct likewise_cell *c;
+
+ /* Each cell struct is a TALLOC_CTX* */
+
+ c = TALLOC_ZERO_P(NULL, struct likewise_cell);
+ if (!c) {
+ DEBUG(0,("cell_new: memory allocation failure!\n"));
+ return NULL;
+ }
+
+ return c;
+}
+
+/**********************************************************************
+ Add a new cell structure to the list
+ *********************************************************************/
+
+ bool cell_list_add(struct likewise_cell * cell)
+{
+ if (!cell) {
+ return false;
+ }
+
+ /* Always add to the end */
+
+ DLIST_ADD_END(_lw_cell_list, cell, struct likewise_cell *);
+
+ return true;
+}
+
+/**********************************************************************
+ Add a new cell structure to the list
+ *********************************************************************/
+
+ bool cell_list_remove(struct likewise_cell * cell)
+{
+ if (!cell) {
+ return false;
+ }
+
+ /* Remove and drop the cell structure */
+
+ DLIST_REMOVE(_lw_cell_list, cell);
+ talloc_destroy(cell);
+
+ return true;
+}
+
+/**********************************************************************
+ Set the containing DNS domain for a cell
+ *********************************************************************/
+
+ void cell_set_dns_domain(struct likewise_cell *c, const char *dns_domain)
+{
+ c->dns_domain = talloc_strdup(c, dns_domain);
+}
+
+/**********************************************************************
+ Set ADS connection for a cell
+ *********************************************************************/
+
+ void cell_set_connection(struct likewise_cell *c, ADS_STRUCT *ads)
+{
+ c->conn = ads;
+}
+
+/**********************************************************************
+ *********************************************************************/
+
+ void cell_set_flags(struct likewise_cell *c, uint32_t flags)
+{
+ c->flags |= flags;
+}
+
+/**********************************************************************
+ *********************************************************************/
+
+ void cell_clear_flags(struct likewise_cell *c, uint32_t flags)
+{
+ c->flags &= ~flags;
+}
+
+/**********************************************************************
+ Set the Cell's DN
+ *********************************************************************/
+
+ void cell_set_dn(struct likewise_cell *c, const char *dn)
+{
+ if ( c->dn) {
+ talloc_free(c->dn);
+ c->dn = NULL;
+ }
+
+ c->dn = talloc_strdup(c, dn);
+}
+
+/**********************************************************************
+ *********************************************************************/
+
+ void cell_set_domain_sid(struct likewise_cell *c, DOM_SID *sid)
+{
+ sid_copy(&c->domain_sid, sid);
+}
+
+/*
+ * Query Routines
+ */
+
+/**********************************************************************
+ *********************************************************************/
+
+ const char* cell_search_base(struct likewise_cell *c)
+{
+ if (!c)
+ return NULL;
+
+ return talloc_asprintf(c, "cn=%s,%s", ADEX_CELL_RDN, c->dn);
+}
+
+/**********************************************************************
+ *********************************************************************/
+
+ bool cell_search_forest(struct likewise_cell *c)
+{
+ uint32_t test_flags = LWCELL_FLAG_SEARCH_FOREST;
+
+ return ((c->flags & test_flags) == test_flags);
+}
+
+/**********************************************************************
+ *********************************************************************/
+
+ uint32_t cell_flags(struct likewise_cell *c)
+{
+ if (!c)
+ return 0;
+
+ return c->flags;
+}
+
+/**********************************************************************
+ *********************************************************************/
+
+ const char *cell_dns_domain(struct likewise_cell *c)
+{
+ if (!c)
+ return NULL;
+
+ return c->dns_domain;
+}
+
+/**********************************************************************
+ *********************************************************************/
+
+ ADS_STRUCT *cell_connection(struct likewise_cell *c)
+{
+ if (!c)
+ return NULL;
+
+ return c->conn;
+}
+
+/*
+ * Connection functions
+ */
+
+/********************************************************************
+ *******************************************************************/
+
+ NTSTATUS cell_connect(struct likewise_cell *c)
+{
+ ADS_STRUCT *ads = NULL;
+ ADS_STATUS ads_status;
+ fstring dc_name;
+ struct sockaddr_storage dcip;
+ NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
+
+ /* have to at least have the AD domain name */
+
+ if (!c->dns_domain) {
+ nt_status = NT_STATUS_CANT_ACCESS_DOMAIN_INFO;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+ /* clear out any old information */
+
+ if (c->conn) {
+ ads_destroy(&c->conn);
+ c->conn = NULL;
+ }
+
+ /* now setup the new connection */
+
+ ads = ads_init(c->dns_domain, NULL, NULL);
+ BAIL_ON_PTR_ERROR(ads, nt_status);
+
+ ads->auth.password =
+ secrets_fetch_machine_password(lp_workgroup(), NULL, NULL);
+ ads->auth.realm = SMB_STRDUP(lp_realm());
+
+ /* Make the connection. We should already have an initial
+ TGT using the machine creds */
+
+ if (cell_flags(c) & LWCELL_FLAG_GC_CELL) {
+ ads_status = ads_connect_gc(ads);
+ } else {
+ /* Set up server affinity for normal cells and the client
+ site name cache */
+
+ if (!get_dc_name("", c->dns_domain, dc_name, &dcip)) {
+ nt_status = NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+ ads_status = ads_connect(ads);
+ }
+
+
+ c->conn = ads;
+
+ nt_status = ads_ntstatus(ads_status);
+
+done:
+ if (!NT_STATUS_IS_OK(nt_status)) {
+ ads_destroy(&ads);
+ c->conn = NULL;
+ }
+
+ return nt_status;
+}
+
+/********************************************************************
+ *******************************************************************/
+
+ NTSTATUS cell_connect_dn(struct likewise_cell **c, const char *dn)
+{
+ NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
+ struct likewise_cell *new_cell = NULL;
+ char *dns_domain = NULL;
+
+ if (*c || !dn) {
+ nt_status = NT_STATUS_INVALID_PARAMETER;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+ if ((new_cell = cell_new()) == NULL) {
+ nt_status = NT_STATUS_NO_MEMORY;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+ /* Set the DNS domain, dn, etc ... and add it to the list */
+
+ dns_domain = cell_dn_to_dns(dn);
+ cell_set_dns_domain(new_cell, dns_domain);
+ SAFE_FREE(dns_domain);
+
+ cell_set_dn(new_cell, dn);
+
+ nt_status = cell_connect(new_cell);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+ *c = new_cell;
+
+done:
+ if (!NT_STATUS_IS_OK(nt_status)) {
+ DEBUG(1,("LWI: Failled to connect to cell \"%s\" (%s)\n",
+ dn ? dn : "NULL", nt_errstr(nt_status)));
+ talloc_destroy(new_cell);
+ }
+
+ return nt_status;
+}
+
+
+/********************************************************************
+ *******************************************************************/
+
+#define MAX_SEARCH_COUNT 2
+
+ ADS_STATUS cell_do_search(struct likewise_cell *c,
+ const char *search_base,
+ int scope,
+ const char *expr,
+ const char **attrs,
+ LDAPMessage ** msg)
+{
+ int search_count = 0;
+ ADS_STATUS status;
+ NTSTATUS nt_status;
+
+ /* check for a NULL connection */
+
+ if (!c->conn) {
+ nt_status = cell_connect(c);
+ if (!NT_STATUS_IS_OK(nt_status)) {
+ status = ADS_ERROR_NT(nt_status);
+ return status;
+ }
+ }
+
+ DEBUG(10, ("cell_do_search: Base = %s, Filter = %s, Scope = %d, GC = %s\n",
+ search_base, expr, scope,
+ c->conn->server.gc ? "yes" : "no"));
+
+ /* we try multiple times in case the ADS_STRUCT is bad
+ and we need to reconnect */
+
+ while (search_count < MAX_SEARCH_COUNT) {
+ *msg = NULL;
+ status = ads_do_search(c->conn, search_base,
+ scope, expr, attrs, msg);
+ if (ADS_ERR_OK(status)) {
+ if (DEBUGLEVEL >= 10) {
+ LDAPMessage *e = NULL;
+
+ int n = ads_count_replies(c->conn, *msg);
+
+ DEBUG(10,("cell_do_search: Located %d entries\n", n));
+
+ for (e=ads_first_entry(c->conn, *msg);
+ e!=NULL;
+ e = ads_next_entry(c->conn, e))
+ {
+ char *dn = ads_get_dn(c->conn, e);
+
+ DEBUGADD(10,(" dn: %s\n", dn ? dn : "<NULL>"));
+ SAFE_FREE(dn);
+ }
+ }
+
+ return status;
+ }
+
+
+ DEBUG(5, ("cell_do_search: search[%d] failed (%s)\n",
+ search_count, ads_errstr(status)));
+
+ search_count++;
+
+ /* Houston, we have a problem */
+
+ if (status.error_type == ENUM_ADS_ERROR_LDAP) {
+ switch (status.err.rc) {
+ case LDAP_TIMELIMIT_EXCEEDED:
+ case LDAP_TIMEOUT:
+ case -1: /* we get this error if we cannot contact
+ the LDAP server */
+ nt_status = cell_connect(c);
+ if (!NT_STATUS_IS_OK(nt_status)) {
+ status = ADS_ERROR_NT(nt_status);
+ return status;
+ }
+ break;
+ default:
+ /* we're all done here */
+ return status;
+ }
+ }
+ }
+
+ DEBUG(5, ("cell_do_search: exceeded maximum search count!\n"));
+
+ return ADS_ERROR_NT(NT_STATUS_UNSUCCESSFUL);
+}
--- /dev/null
+/*
+ * idmap_adex
+ *
+ * Provider for RFC2307 and SFU AD Forests
+ *
+ * Copyright (C) Gerald (Jerry) Carter 2006-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 2 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, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "includes.h"
+#include "idmap_adex.h"
+
+#undef DBGC_CLASS
+#define DBGC_CLASS DBGC_IDMAP
+
+/* Information needed by the LDAP search filters */
+
+enum filterType { SidFilter, IdFilter, AliasFilter };
+
+struct lwcell_filter
+{
+ enum filterType ftype;
+ bool use2307;
+ union {
+ DOM_SID sid;
+ struct {
+ uint32_t id;
+ enum id_type type;
+ } id;
+ fstring alias;
+ } filter;
+};
+
+/********************************************************************
+ *******************************************************************/
+
+static char* build_id_filter(uint32_t id,
+ enum id_type type,
+ uint32_t search_flags)
+{
+ char *filter = NULL;
+ char *oc_filter, *attr_filter;
+ NTSTATUS nt_status;
+ TALLOC_CTX *frame = talloc_stackframe();
+ bool use2307 = ((search_flags & LWCELL_FLAG_USE_RFC2307_ATTRS)
+ == LWCELL_FLAG_USE_RFC2307_ATTRS);
+ bool use_gc = ((search_flags & LWCELL_FLAG_SEARCH_FOREST)
+ == LWCELL_FLAG_SEARCH_FOREST);
+ const char *oc;
+
+ /* Construct search filter for objectclass and attributes */
+
+ switch (type) {
+ case ID_TYPE_UID:
+ oc = ADEX_OC_USER;
+ if (use2307) {
+ oc = ADEX_OC_POSIX_USER;
+ if (use_gc) {
+ oc = AD_USER;
+ }
+ }
+ oc_filter = talloc_asprintf(frame, "objectclass=%s", oc);
+ attr_filter = talloc_asprintf(frame, "%s=%u",
+ ADEX_ATTR_UIDNUM, id);
+ break;
+
+ case ID_TYPE_GID:
+ oc = ADEX_OC_GROUP;
+ if (use2307) {
+ oc = ADEX_OC_POSIX_GROUP;
+ if (use_gc) {
+ oc = AD_GROUP;
+ }
+ }
+ oc_filter = talloc_asprintf(frame, "objectclass=%s", oc);
+ attr_filter = talloc_asprintf(frame, "%s=%u",
+ ADEX_ATTR_GIDNUM, id);
+ break;
+ default:
+ return NULL;
+ }
+
+ BAIL_ON_PTR_ERROR(oc_filter, nt_status);
+ BAIL_ON_PTR_ERROR(attr_filter, nt_status);
+
+ /* Use "keywords=%s" for non-schema cells */
+
+ if (use2307) {
+ filter = talloc_asprintf(frame, "(&(%s)(%s))",
+ oc_filter, attr_filter);
+ } else {
+ filter = talloc_asprintf(frame, "(&(keywords=%s)(keywords=%s))",
+ oc_filter, attr_filter);
+ }
+
+ talloc_destroy(oc_filter);
+ talloc_destroy(attr_filter);
+
+done:
+ /* Don't destroy the stackframe CTX since we are returning
+ memory from it */
+
+ return filter;
+}
+
+/********************************************************************
+ *******************************************************************/
+
+static char* build_alias_filter(const char *alias, uint32_t search_flags)
+{
+ char *filter = NULL;
+ char *user_attr_filter, *group_attr_filter;
+ NTSTATUS nt_status;
+ TALLOC_CTX *frame = talloc_stackframe();
+ bool use2307 = ((search_flags & LWCELL_FLAG_USE_RFC2307_ATTRS)
+ == LWCELL_FLAG_USE_RFC2307_ATTRS);
+ bool search_forest = ((search_flags & LWCELL_FLAG_SEARCH_FOREST)
+ == LWCELL_FLAG_SEARCH_FOREST);
+
+ /* Construct search filter for objectclass and attributes */
+
+ user_attr_filter = talloc_asprintf(frame, "%s=%s",
+ ADEX_ATTR_UID, alias);
+ group_attr_filter = talloc_asprintf(frame, "%s=%s",
+ ADEX_ATTR_DISPLAYNAME, alias);
+ BAIL_ON_PTR_ERROR(user_attr_filter, nt_status);
+ BAIL_ON_PTR_ERROR(group_attr_filter, nt_status);
+
+ /* Use "keywords=%s" for non-schema cells */
+
+ if (use2307) {
+ filter = talloc_asprintf(frame,
+ "(|(&(%s)(objectclass=%s))(&(%s)(objectclass=%s)))",
+ user_attr_filter,
+ search_forest ? AD_USER : ADEX_OC_POSIX_USER,
+ group_attr_filter,
+ search_forest ? AD_GROUP : ADEX_OC_POSIX_GROUP);
+ } else {
+ filter = talloc_asprintf(frame,
+ "(|(keywords=%s)(keywords=%s))",
+ user_attr_filter,
+ group_attr_filter);
+ }
+
+ talloc_destroy(user_attr_filter);
+ talloc_destroy(group_attr_filter);
+
+done:
+ /* Don't destroy the stackframe CTX since we are returning
+ memory from it */
+
+ return filter;
+}
+
+
+/********************************************************************
+ *******************************************************************/
+
+static NTSTATUS search_cell(struct likewise_cell *c,
+ LDAPMessage **msg,
+ const struct lwcell_filter *fdata)
+{
+ NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
+ TALLOC_CTX* frame = talloc_stackframe();
+ char *filter = NULL;
+ const char *base = NULL;
+ ADS_STATUS ads_status = ADS_ERROR_NT(NT_STATUS_UNSUCCESSFUL);
+ const char *attrs[] = { "*", NULL };
+ int count;
+ char *sid_str;
+
+ /* get the filter and other search parameters */
+
+ switch (fdata->ftype) {
+ case SidFilter:
+ sid_str = sid_string_talloc(frame, &fdata->filter.sid);
+ BAIL_ON_PTR_ERROR(sid_str, nt_status);
+
+ filter = talloc_asprintf(frame, "(keywords=backLink=%s)",
+ sid_str);
+ break;
+ case IdFilter:
+ filter = build_id_filter(fdata->filter.id.id,
+ fdata->filter.id.type,
+ cell_flags(c));
+ break;
+ case AliasFilter:
+ filter = build_alias_filter(fdata->filter.alias,
+ cell_flags(c));
+ break;
+ default:
+ nt_status = NT_STATUS_INVALID_PARAMETER;
+ break;
+ }
+ BAIL_ON_PTR_ERROR(filter, nt_status);
+
+ base = cell_search_base(c);
+ BAIL_ON_PTR_ERROR(base, nt_status);
+
+ ads_status = cell_do_search(c, base, LDAP_SCOPE_SUBTREE,
+ filter, attrs, msg);
+
+ nt_status = ads_ntstatus(ads_status);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+ /* Now check that we got only one reply */
+
+ count = ads_count_replies(c->conn, *msg);
+ if (count < 1) {
+ nt_status = NT_STATUS_OBJECT_NAME_NOT_FOUND;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+ if ( count > 1) {
+ nt_status = NT_STATUS_DUPLICATE_NAME;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+done:
+ PRINT_NTSTATUS_ERROR(nt_status, "search_cell", 4);
+
+ talloc_destroy(CONST_DISCARD(char*, base));
+ talloc_destroy(frame);
+
+ return nt_status;
+}
+
+/********************************************************************
+ *******************************************************************/
+
+static NTSTATUS search_domain(struct likewise_cell **cell,
+ LDAPMessage **msg,
+ const char *dn,
+ const DOM_SID *sid)
+{
+ NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
+ TALLOC_CTX* frame = talloc_stackframe();
+ int count;
+
+ nt_status = dc_search_domains(cell, msg, dn, sid);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+ /* Now check that we got only one reply */
+
+ count = ads_count_replies(cell_connection(*cell), *msg);
+ if (count < 1) {
+ nt_status = NT_STATUS_OBJECT_NAME_NOT_FOUND;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+ if ( count > 1) {
+ nt_status = NT_STATUS_DUPLICATE_NAME;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+done:
+ PRINT_NTSTATUS_ERROR(nt_status, "search_domain", 4);
+ talloc_destroy(frame);
+
+ return nt_status;
+}
+
+
+/********************************************************************
+ Check that a DN is within the forest scope.
+ *******************************************************************/
+
+static bool check_forest_scope(const char *dn)
+{
+ NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
+ TALLOC_CTX *frame = talloc_stackframe();
+ char *p = NULL;
+ char *q = NULL;
+ char *dns_domain = NULL;
+ struct winbindd_tdc_domain *domain;
+
+ /* If the DN does *not* contain "$LikewiseIdentityCell",
+ assume this is a schema mode forest and it is in the
+ forest scope by definition. */
+
+ if ((p = strstr_m(dn, ADEX_CELL_RDN)) == NULL) {
+ nt_status = NT_STATUS_OK;
+ goto done;
+ }
+
+ /* If this is a non-schema forest, then make sure that the DN
+ is in the form "...,cn=$LikewiseIdentityCell,DC=..." */
+
+ if ((q = strchr_m(p, ',')) == NULL) {
+ nt_status = NT_STATUS_OBJECT_NAME_INVALID;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+ q++;
+ if (StrnCaseCmp(q, "dc=", 3) != 0) {
+ nt_status = NT_STATUS_OBJECT_PATH_NOT_FOUND;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+
+ dns_domain = cell_dn_to_dns(q);
+ BAIL_ON_PTR_ERROR(dns_domain, nt_status);
+
+ domain = wcache_tdc_fetch_domain(frame, dns_domain);
+ if (!domain) {
+ nt_status = NT_STATUS_TRUSTED_DOMAIN_FAILURE;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+ nt_status = NT_STATUS_OK;
+
+done:
+ talloc_destroy(frame);
+ SAFE_FREE(dns_domain);
+
+ return NT_STATUS_IS_OK(nt_status);
+}
+
+
+
+/********************************************************************
+ Check that only one result was returned within the forest cell
+ scope.
+ *******************************************************************/
+
+static NTSTATUS check_result_unique_scoped(ADS_STRUCT **ads_list,
+ LDAPMessage **msg_list,
+ int num_resp,
+ char **dn,
+ DOM_SID *user_sid)
+{
+ NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
+ int i;
+ ADS_STRUCT *ads = NULL;
+ LDAPMessage *msg = NULL;
+ int count = 0;
+ char *entry_dn = NULL;
+ TALLOC_CTX *frame = talloc_stackframe();
+
+ if (!dn || !user_sid) {
+ nt_status = NT_STATUS_INVALID_PARAMETER;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+ *dn = NULL;
+
+ if (!ads_list || !msg_list || (num_resp == 0)) {
+ nt_status = NT_STATUS_NO_SUCH_FILE;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+ /* Loop over all msgs */
+
+ for (i=0; i<num_resp; i++) {
+ LDAPMessage *e = ads_first_entry(ads_list[i], msg_list[i]);
+
+ while (e) {
+ entry_dn = ads_get_dn(ads_list[i], e);
+ BAIL_ON_PTR_ERROR(entry_dn, nt_status);
+
+ if (check_forest_scope(entry_dn)) {
+ count++;
+
+ /* If we've already broken the condition, no
+ need to continue */
+
+ if (count > 1) {
+ nt_status = NT_STATUS_DUPLICATE_NAME;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+ ads = ads_list[i];
+ msg = e;
+ *dn = SMB_STRDUP(entry_dn);
+ BAIL_ON_PTR_ERROR((*dn), nt_status);
+ }
+
+ e = ads_next_entry(ads_list[i], e);
+ SAFE_FREE(entry_dn);
+ }
+ }
+
+ if (!ads || !msg) {
+ nt_status = NT_STATUS_OBJECT_NAME_NOT_FOUND;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+ /* If we made is through the loop, then grab the user_sid and
+ run home to base */
+
+ /*
+ Try and get the SID from either objectSid or keywords.
+ We cannot use pull_sid() here since we want to try
+ both methods and not only one or the other (and we
+ have no full likewise_cell struct.
+
+ Fail if both are unavailable
+ */
+
+ if (!ads_pull_sid(ads, msg, "objectSid", user_sid)) {
+ char **keywords;
+ char *s;
+ size_t num_lines = 0;
+
+ keywords = ads_pull_strings(ads, frame, msg, "keywords",
+ &num_lines);
+ BAIL_ON_PTR_ERROR(keywords, nt_status);
+
+ s = find_attr_string(keywords, num_lines, "backLink");
+ if (!s) {
+ nt_status = NT_STATUS_INTERNAL_DB_CORRUPTION;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+ if (!string_to_sid(user_sid, s)) {
+ nt_status = NT_STATUS_INVALID_SID;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+ }
+
+ nt_status = NT_STATUS_OK;
+
+done:
+ if (!NT_STATUS_IS_OK(nt_status)) {
+ SAFE_FREE(*dn);
+ }
+
+ talloc_destroy(frame);
+ SAFE_FREE(entry_dn);
+
+ return nt_status;
+}
+
+/********************************************************************
+ Search all forests. Each forest can have it's own forest-cell
+ settings so we have to generate the filter for each search.
+ We don't use gc_search_all_forests() since we may have a different
+ schema model in each forest and need to construct the search
+ filter for each GC search.
+ *******************************************************************/
+
+static NTSTATUS search_forest(struct likewise_cell *forest_cell,
+ LDAPMessage **msg,
+ const struct lwcell_filter *fdata)
+{
+ NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
+ TALLOC_CTX *frame = talloc_stackframe();
+ char *filter = NULL;
+ char *dn = NULL;
+ struct gc_info *gc = NULL;
+ ADS_STRUCT **ads_list = NULL;
+ LDAPMessage **msg_list = NULL;
+ int num_resp = 0;
+ LDAPMessage *m;
+ DOM_SID user_sid;
+ struct likewise_cell *domain_cell = NULL;
+
+ if ((gc = gc_search_start()) == NULL) {
+ nt_status = NT_STATUS_INVALID_DOMAIN_STATE;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+ while (gc) {
+ char *sid_binstr = NULL;
+ uint32_t flags = LWCELL_FLAG_SEARCH_FOREST;
+
+ m = NULL;
+
+ flags |= cell_flags(gc->forest_cell);
+
+ switch (fdata->ftype) {
+ case SidFilter:
+ sid_binstr = sid_binstring(&fdata->filter.sid);
+ BAIL_ON_PTR_ERROR(sid_binstr, nt_status);
+
+ filter = talloc_asprintf(frame, "(objectSid=%s)", sid_binstr);
+ SAFE_FREE(sid_binstr);
+ break;
+ case IdFilter:
+ filter = build_id_filter(fdata->filter.id.id,
+ fdata->filter.id.type, flags);
+ break;
+ case AliasFilter:
+ filter = build_alias_filter(fdata->filter.alias, flags);
+ break;
+ }
+
+ /* First find the sparse object in GC */
+ nt_status = gc_search_forest(gc, &m, filter);
+ if (!NT_STATUS_IS_OK(nt_status)) {
+ gc = gc->next;
+ continue;
+ }
+
+ nt_status = add_ads_result_to_array(cell_connection(gc->forest_cell),
+ m, &ads_list, &msg_list,
+ &num_resp);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+ gc = gc->next;
+ }
+
+ /* Uniqueness check across forests */
+
+ nt_status = check_result_unique_scoped(ads_list, msg_list, num_resp,
+ &dn, &user_sid);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+ nt_status = search_domain(&domain_cell, &m, dn, &user_sid);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+ /* Save the connection and results in the return parameters */
+
+ forest_cell->gc_search_cell = domain_cell;
+ *msg = m;
+
+done:
+ PRINT_NTSTATUS_ERROR(nt_status, "search_forest", 4);
+
+ SAFE_FREE(dn);
+
+ free_result_array(ads_list, msg_list, num_resp);
+ talloc_destroy(frame);
+
+ return nt_status;
+}
+
+/********************************************************************
+ *******************************************************************/
+
+static NTSTATUS search_cell_list(struct likewise_cell **c,
+ LDAPMessage **m,
+ const struct lwcell_filter *fdata)
+{
+ NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
+ struct likewise_cell *cell = NULL;
+ LDAPMessage *msg = NULL;
+ struct likewise_cell *result_cell = NULL;
+
+ if ((cell = cell_list_head()) == NULL) {
+ nt_status = NT_STATUS_INVALID_SERVER_STATE;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+ while (cell) {
+ /* Clear any previous GC search results */
+
+ cell->gc_search_cell = NULL;
+
+ if (cell_search_forest(cell)) {
+ nt_status = search_forest(cell, &msg, fdata);
+ } else {
+ nt_status = search_cell(cell, &msg, fdata);
+ }
+
+ /* Always point to the search result cell.
+ In forests this might be for another domain
+ which means the schema model may be different */
+
+ result_cell = cell->gc_search_cell ?
+ cell->gc_search_cell : cell;
+
+ /* Check if we are done */
+
+ if (NT_STATUS_IS_OK(nt_status)) {
+ break;
+ }
+
+ /* No luck. Free memory and hit the next cell.
+ Forest searches always set the gc_search_cell
+ so give preference to that connection if possible. */
+
+ ads_msgfree(cell_connection(result_cell), msg);
+ msg = NULL;
+
+ cell = cell->next;
+ }
+
+ /* This might be assigning NULL but that is ok as long as we
+ give back the proper error code */
+
+ *c = result_cell;
+ *m = msg;
+
+done:
+ PRINT_NTSTATUS_ERROR(nt_status, "search_cell_list", 3);
+
+ return nt_status;
+}
+
+/********************************************************************
+ Pull the SID from an object which is always stored in the keywords
+ attribute as "backLink=S-1-5-21-..."
+ *******************************************************************/
+
+static NTSTATUS pull_sid(struct likewise_cell *c,
+ LDAPMessage *msg,
+ DOM_SID *sid)
+{
+ NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
+ TALLOC_CTX *frame = talloc_stackframe();
+ ADS_STRUCT *ads = NULL;
+
+ ads = cell_connection(c);
+
+ /*
+ We have two ways of getting the sid:
+ (a) from the objectSID in case of a GC search,
+ (b) from backLink in the case of a cell search.
+ Pull the keywords attributes and grab the backLink.
+ */
+
+ if (!ads_pull_sid(ads, msg, "objectSid", sid)) {
+ char **keywords;
+ char *s;
+ size_t num_lines = 0;
+
+ keywords = ads_pull_strings(ads, frame, msg,
+ "keywords", &num_lines);
+ BAIL_ON_PTR_ERROR(keywords, nt_status);
+
+ s = find_attr_string(keywords, num_lines, "backLink");
+ if (!s) {
+ nt_status = NT_STATUS_INTERNAL_DB_CORRUPTION;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+ if (!string_to_sid(sid, s)) {
+ nt_status = NT_STATUS_INVALID_SID;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+ }
+
+ nt_status = NT_STATUS_OK;
+
+done:
+ talloc_destroy(frame);
+
+ return nt_status;
+}
+
+/********************************************************************
+ *******************************************************************/
+
+static NTSTATUS get_object_type(struct likewise_cell *c,
+ LDAPMessage *msg,
+ enum id_type *type)
+{
+ TALLOC_CTX *ctx = talloc_stackframe();
+ char **oc_list = NULL;
+ NTSTATUS nt_status = NT_STATUS_OK;
+ size_t list_size = 0;
+ char *s = NULL;
+ ADS_STRUCT *ads = NULL;
+
+ ads = cell_connection(c);
+
+ /* Deal with RFC 2307 support first */
+
+ if (cell_flags(c) & LWCELL_FLAG_USE_RFC2307_ATTRS) {
+ oc_list = ads_pull_strings(ads, ctx, msg,
+ "objectClass", &list_size);
+ if (!oc_list) {
+ nt_status = NT_STATUS_INTERNAL_DB_CORRUPTION;
+ goto done;
+ }
+
+ /* Check for posix classes and AD classes */
+
+ if (is_object_class(oc_list, list_size, ADEX_OC_POSIX_USER)
+ || is_object_class(oc_list, list_size, AD_USER)) {
+ *type = ID_TYPE_UID;
+ } else if (is_object_class(oc_list, list_size, ADEX_OC_POSIX_GROUP)
+ || is_object_class(oc_list, list_size, AD_GROUP)) {
+ *type = ID_TYPE_GID;
+ } else {
+ *type = ID_TYPE_NOT_SPECIFIED;
+ nt_status = NT_STATUS_INVALID_PARAMETER;
+ }
+ } else {
+ /* Default to non-schema mode */
+
+ oc_list = ads_pull_strings(ads, ctx, msg,
+ "keywords", &list_size);
+ if (!oc_list) {
+ nt_status = NT_STATUS_INTERNAL_DB_CORRUPTION;
+ goto done;
+ }
+
+ s = find_attr_string(oc_list, list_size, "objectClass");
+ if (!s) {
+ nt_status = NT_STATUS_INTERNAL_DB_CORRUPTION;
+ goto done;
+ }
+
+ if (strequal(s, ADEX_OC_USER)) {
+ *type = ID_TYPE_UID;
+ } else if (strequal(s, ADEX_OC_GROUP)) {
+ *type = ID_TYPE_GID;
+ } else {
+ *type = ID_TYPE_NOT_SPECIFIED;
+ nt_status = NT_STATUS_INVALID_PARAMETER;
+ }
+ }
+
+ nt_status = NT_STATUS_OK;
+
+done:
+ talloc_destroy(ctx);
+
+ return nt_status;
+}
+
+/********************************************************************
+ Pull an attribute uint32_t value
+ *******************************************************************/
+
+static NTSTATUS get_object_uint32(struct likewise_cell *c,
+ LDAPMessage *msg,
+ const char *attrib,
+ uint32_t *x)
+{
+ NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
+ char **keywords = NULL;
+ size_t list_size = 0;
+ TALLOC_CTX *frame = talloc_stackframe();
+ ADS_STRUCT *ads = NULL;
+
+ ads = cell_connection(c);
+
+ /* Deal with RFC2307 schema */
+
+ if (cell_flags(c) & LWCELL_FLAG_USE_RFC2307_ATTRS) {
+ if (!ads_pull_uint32(ads, msg, attrib, x)) {
+ nt_status = NT_STATUS_OBJECT_NAME_NOT_FOUND;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+ } else {
+ /* Non-schema mode */
+ char *s = NULL;
+ uint32_t num;
+
+ keywords = ads_pull_strings(ads, frame, msg, "keywords",
+ &list_size);
+ BAIL_ON_PTR_ERROR(keywords, nt_status);
+
+ s = find_attr_string(keywords, list_size, attrib);
+ if (!s) {
+ nt_status = NT_STATUS_OBJECT_NAME_NOT_FOUND;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+ num = strtoll(s, NULL, 10);
+ if (errno == ERANGE) {
+ nt_status = NT_STATUS_OBJECT_NAME_NOT_FOUND;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+ *x = num;
+ }
+
+ nt_status = NT_STATUS_OK;
+
+done:
+ talloc_destroy(frame);
+
+ return nt_status;
+}
+
+/********************************************************************
+ *******************************************************************/
+
+static NTSTATUS get_object_id(struct likewise_cell *c,
+ LDAPMessage *msg,
+ enum id_type type,
+ uint32_t *id)
+{
+ NTSTATUS nt_status = NT_STATUS_OK;
+ const char *id_attr;
+
+ /* Figure out which attribute we need to pull */
+
+ switch (type) {
+ case ID_TYPE_UID:
+ id_attr = ADEX_ATTR_UIDNUM;
+ break;
+ case ID_TYPE_GID:
+ id_attr = ADEX_ATTR_GIDNUM;
+ break;
+ default:
+ nt_status = NT_STATUS_INVALID_PARAMETER;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ break;
+ }
+
+ nt_status = get_object_uint32(c, msg, id_attr, id);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+done:
+ return nt_status;
+}
+
+/********************************************************************
+ Pull the uid/gid and type from an object. This differs depending on
+ the cell flags.
+ *******************************************************************/
+
+static NTSTATUS pull_id(struct likewise_cell *c,
+ LDAPMessage *msg,
+ uint32_t *id,
+ enum id_type *type)
+{
+ NTSTATUS nt_status;
+
+ nt_status = get_object_type(c, msg, type);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+ nt_status = get_object_id(c, msg, *type, id);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+done:
+ return nt_status;
+}
+
+/********************************************************************
+ Pull an attribute string value
+ *******************************************************************/
+
+static NTSTATUS get_object_string(struct likewise_cell *c,
+ LDAPMessage *msg,
+ TALLOC_CTX *ctx,
+ const char *attrib,
+ char **string)
+{
+ NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
+ char **keywords = NULL;
+ size_t list_size = 0;
+ TALLOC_CTX *frame = talloc_stackframe();
+ ADS_STRUCT *ads = NULL;
+
+ *string = NULL;
+
+ ads = cell_connection(c);
+
+ /* Deal with RFC2307 schema */
+
+ if (cell_flags(c) & LWCELL_FLAG_USE_RFC2307_ATTRS) {
+ *string = ads_pull_string(ads, ctx, msg, attrib);
+ } else {
+ /* Non-schema mode */
+
+ char *s = NULL;
+
+ keywords = ads_pull_strings(ads, frame, msg,
+ "keywords", &list_size);
+ if (!keywords) {
+ nt_status = NT_STATUS_NO_MEMORY;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+ s = find_attr_string(keywords, list_size, attrib);
+ if (s) {
+ *string = talloc_strdup(ctx, s);
+ }
+ }
+
+ if (!*string) {
+ nt_status = NT_STATUS_OBJECT_NAME_NOT_FOUND;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+ nt_status = NT_STATUS_OK;
+
+done:
+ talloc_destroy(frame);
+
+ return nt_status;
+}
+
+/********************************************************************
+ Pull the struct passwd fields for a user
+ *******************************************************************/
+
+static NTSTATUS pull_nss_info(struct likewise_cell *c,
+ LDAPMessage *msg,
+ TALLOC_CTX *ctx,
+ char **homedir,
+ char **shell,
+ char **gecos,
+ gid_t *p_gid)
+{
+ NTSTATUS nt_status;
+
+ nt_status = get_object_string(c, msg, ctx, ADEX_ATTR_HOMEDIR, homedir);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+ nt_status = get_object_string(c, msg, ctx, ADEX_ATTR_SHELL, shell);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+ nt_status = get_object_string(c, msg, ctx, ADEX_ATTR_GECOS, gecos);
+ /* Gecos is often not set so ignore failures */
+
+ nt_status = get_object_uint32(c, msg, ADEX_ATTR_GIDNUM, p_gid);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+done:
+ return nt_status;
+}
+
+/********************************************************************
+ Pull the struct passwd fields for a user
+ *******************************************************************/
+
+static NTSTATUS pull_alias(struct likewise_cell *c,
+ LDAPMessage *msg,
+ TALLOC_CTX *ctx,
+ char **alias)
+{
+ NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
+ enum id_type type;
+ const char *attr = NULL;
+
+ /* Figure out if this is a user or a group */
+
+ nt_status = get_object_type(c, msg, &type);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+ switch (type) {
+ case ID_TYPE_UID:
+ attr = ADEX_ATTR_UID;
+ break;
+ case ID_TYPE_GID:
+ /* What is the group attr for RFC2307 Forests? */
+ attr = ADEX_ATTR_DISPLAYNAME;
+ break;
+ default:
+ nt_status = NT_STATUS_INVALID_PARAMETER;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ break;
+ }
+
+ nt_status = get_object_string(c, msg, ctx, attr, alias);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+done:
+ return nt_status;
+}
+
+/********************************************************************
+ *******************************************************************/
+
+static NTSTATUS _ccp_get_sid_from_id(DOM_SID * sid,
+ uint32_t id, enum id_type type)
+{
+ struct likewise_cell *cell = NULL;
+ LDAPMessage *msg = NULL;
+ NTSTATUS nt_status;
+ struct lwcell_filter filter;
+
+ filter.ftype = IdFilter;
+ filter.filter.id.id = id;
+ filter.filter.id.type = type;
+
+ nt_status = search_cell_list(&cell, &msg, &filter);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+ nt_status = pull_sid(cell, msg, sid);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+done:
+ ads_msgfree(cell->conn, msg);
+
+ return nt_status;
+}
+
+/********************************************************************
+ *******************************************************************/
+
+static NTSTATUS _ccp_get_id_from_sid(uint32_t * id,
+ enum id_type *type,
+ const DOM_SID * sid)
+{
+ struct likewise_cell *cell = NULL;
+ LDAPMessage *msg = NULL;
+ NTSTATUS nt_status;
+ struct lwcell_filter filter;
+
+ filter.ftype = SidFilter;
+ sid_copy(&filter.filter.sid, sid);
+
+ nt_status = search_cell_list(&cell, &msg, &filter);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+ nt_status = pull_id(cell, msg, id, type);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+ if (*id < min_id_value()) {
+ nt_status = NT_STATUS_INVALID_PARAMETER;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+done:
+ ads_msgfree(cell->conn, msg);
+
+ return nt_status;
+}
+
+/********************************************************************
+ *******************************************************************/
+
+static NTSTATUS _ccp_nss_get_info(const DOM_SID * sid,
+ TALLOC_CTX * ctx,
+ char **homedir,
+ char **shell,
+ char **gecos, gid_t * p_gid)
+{
+ struct likewise_cell *cell = NULL;
+ LDAPMessage *msg = NULL;
+ NTSTATUS nt_status;
+ struct lwcell_filter filter;
+ enum id_type type;
+
+ filter.ftype = SidFilter;
+ sid_copy(&filter.filter.sid, sid);
+
+ nt_status = search_cell_list(&cell, &msg, &filter);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+ nt_status = get_object_type(cell, msg, &type);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+ if (type != ID_TYPE_UID) {
+ nt_status = NT_STATUS_NO_SUCH_USER;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+ nt_status = pull_nss_info(cell, msg, ctx, homedir, shell, gecos,
+ (uint32_t*) p_gid);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+done:
+ ads_msgfree(cell->conn, msg);
+
+ return nt_status;
+}
+
+/**********************************************************************
+ *********************************************************************/
+
+static NTSTATUS _ccp_map_to_alias(TALLOC_CTX *ctx,
+ const char *domain,
+ const char *name, char **alias)
+{
+ TALLOC_CTX *frame = talloc_stackframe();
+ NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
+ DOM_SID sid;
+ struct likewise_cell *cell = NULL;
+ LDAPMessage *msg = NULL;
+ struct lwcell_filter filter;
+ enum lsa_SidType sid_type;
+
+ /* Convert the name to a SID */
+
+ nt_status = gc_name_to_sid(domain, name, &sid, &sid_type);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+ /* Find the user/group */
+
+ filter.ftype = SidFilter;
+ sid_copy(&filter.filter.sid, &sid);
+
+ nt_status = search_cell_list(&cell, &msg, &filter);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+ /* Pull the alias and return */
+
+ nt_status = pull_alias(cell, msg, ctx, alias);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+done:
+ PRINT_NTSTATUS_ERROR(nt_status, "map_to_alias", 3);
+
+ talloc_destroy(frame);
+ ads_msgfree(cell_connection(cell), msg);
+
+ return nt_status;
+}
+
+/**********************************************************************
+ Map from an alias name to the canonical, qualified name.
+ Ensure that the alias is only pull from the closest in which
+ the user or gorup is enabled in
+ *********************************************************************/
+
+static NTSTATUS _ccp_map_from_alias(TALLOC_CTX *mem_ctx,
+ const char *domain,
+ const char *alias, char **name)
+{
+ TALLOC_CTX *frame = talloc_stackframe();
+ NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
+ DOM_SID sid;
+ struct likewise_cell *cell_alias = NULL;
+ LDAPMessage *msg_alias = NULL;
+ struct likewise_cell *cell_sid = NULL;
+ LDAPMessage *msg_sid = NULL;
+ struct lwcell_filter filter;
+ char *canonical_name = NULL;
+ enum lsa_SidType type;
+
+ /* Find the user/group */
+
+ filter.ftype = AliasFilter;
+ fstrcpy(filter.filter.alias, alias);
+
+ nt_status = search_cell_list(&cell_alias, &msg_alias, &filter);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+ nt_status = pull_sid(cell_alias, msg_alias, &sid);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+ /* Now search again for the SID according to the cell list.
+ Verify that the cell of both search results is the same
+ so that we only match an alias from the closest cell
+ in which a user/group has been instantied. */
+
+ filter.ftype = SidFilter;
+ sid_copy(&filter.filter.sid, &sid);
+
+ nt_status = search_cell_list(&cell_sid, &msg_sid, &filter);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+ if (cell_alias != cell_sid) {
+ nt_status = NT_STATUS_OBJECT_PATH_NOT_FOUND;
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+ }
+
+ /* Finally do the GC sid/name conversion */
+
+ nt_status = gc_sid_to_name(&sid, &canonical_name, &type);
+ BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+ *name = talloc_strdup(mem_ctx, canonical_name);
+ BAIL_ON_PTR_ERROR((*name), nt_status);
+
+ nt_status = NT_STATUS_OK;
+
+done:
+ PRINT_NTSTATUS_ERROR(nt_status, "map_from_alias", 3);
+
+ ads_msgfree(cell_connection(cell_alias), msg_alias);
+ ads_msgfree(cell_connection(cell_sid), msg_sid);
+
+ SAFE_FREE(canonical_name);
+
+ talloc_destroy(frame);
+
+ return nt_status;
+}
+
+/********************************************************************
+ *******************************************************************/
+
+struct cell_provider_api ccp_unified = {
+ .get_sid_from_id = _ccp_get_sid_from_id,
+ .get_id_from_sid = _ccp_get_id_from_sid,
+ .get_nss_info = _ccp_nss_get_info,
+ .map_to_alias = _ccp_map_to_alias,
+ .map_from_alias = _ccp_map_from_alias
+};
*/
static NTSTATUS idmap_tdb2_alloc_load(void)
{
- const char *range;
uid_t low_uid = 0;
uid_t high_uid = 0;
gid_t low_gid = 0;
gid_t high_gid = 0;
- uint32 low_id, high_id;
+ uint32 low_id;
/* see if a idmap script is configured */
idmap_tdb2_state.idmap_script = lp_parm_const_string(-1, "idmap",
uint32_t high_hwm;
uint32_t hwm;
int res;
+ NTSTATUS status;
+
+ status = idmap_tdb2_open_db();
+ NT_STATUS_NOT_OK_RETURN(status);
/* Get current high water mark */
switch (xid->type) {
const char *hwmtype;
uint32_t hwm;
uint32_t high_hwm;
+ NTSTATUS status;
+
+ status = idmap_tdb2_open_db();
+ NT_STATUS_NOT_OK_RETURN(status);
/* Get current high water mark */
switch (xid->type) {
NTSTATUS ret;
TDB_DATA data;
char *keystr;
+ NTSTATUS status;
+
+ status = idmap_tdb2_open_db();
+ NT_STATUS_NOT_OK_RETURN(status);
if (!ctx || !map) {
return NT_STATUS_INVALID_PARAMETER;
TDB_DATA data;
char *keystr;
unsigned long rec_id = 0;
+ NTSTATUS status;
+
+ status = idmap_tdb2_open_db();
+ NT_STATUS_NOT_OK_RETURN(status);
if ((keystr = sid_string_talloc(ctx, map->sid)) == NULL) {
DEBUG(0, ("Out of memory!\n"));
return NT_STATUS_NONE_MAPPED;
}
- idmap_cache_set_sid2uid(sid, gid);
+ idmap_cache_set_sid2gid(sid, gid);
return NT_STATUS_OK;
}
DEBUG(10,("ads: lookup_groupmem: got sid %s from "
"cache\n", sid_string_dbg(&sid)));
sid_copy(&(*sid_mem)[*num_names], &sid);
- (*names)[*num_names] = talloc_asprintf(*names, "%s%c%s",
- domain_name,
- *lp_winbind_separator(),
- name );
+ (*names)[*num_names] = fill_domain_username_talloc(
+ *names,
+ domain_name,
+ name,
+ true);
(*name_types)[*num_names] = name_type;
(*num_names)++;
{
sid_copy(&(*sid_mem)[*num_names],
&sid_mem_nocache[i]);
- (*names)[*num_names] = talloc_asprintf( *names,
- "%s%c%s",
- domains_nocache[i],
- *lp_winbind_separator(),
- names_nocache[i] );
+ (*names)[*num_names] =
+ fill_domain_username_talloc(
+ *names,
+ domains_nocache[i],
+ names_nocache[i],
+ true);
(*name_types)[*num_names] = name_types_nocache[i];
(*num_names)++;
}
/********************************************************************
The lookup name call first contacts a DC in its own domain
- and fallbacks to contact a DC in the forest in our domain doesn't
+ and fallbacks to contact a DC if the forest in our domain doesn't
know the name.
********************************************************************/
fstring name )
{
struct ip_service ip_list;
- uint32_t nt_version = NETLOGON_VERSION_1;
+ uint32_t nt_version = NETLOGON_NT_VERSION_1;
ip_list.ss = *pss;
ip_list.port = 0;
SMB_ASSERT(continuation != NULL);
+ DEBUG(10, ("Sending request to child pid %d (domain=%s)\n",
+ (int)child->pid,
+ (child->domain != NULL) ? child->domain->name : "''"));
+
state = TALLOC_P(mem_ctx, struct winbindd_async_request);
if (state == NULL) {
TALLOC_FREE(state->reply_timeout_event);
- SMB_ASSERT(state->child_pid != (pid_t)0);
+ /* If child exists and is not already reaped,
+ send kill signal to child. */
- /* If not already reaped, send kill signal to child. */
- if (state->child->pid == state->child_pid) {
+ if ((state->child->pid != (pid_t)0) &&
+ (state->child->pid != (pid_t)-1) &&
+ (state->child->pid == state->child_pid)) {
kill(state->child_pid, SIGTERM);
/*
return; /* Busy */
}
+ /*
+ * This may be a reschedule, so we might
+ * have an existing timeout event pending on
+ * the first entry in the child->requests list
+ * (we only send one request at a time).
+ * Ensure we free it before we reschedule.
+ * Bug #5814, from hargagan <shargagan@novell.com>.
+ * JRA.
+ */
+
+ TALLOC_FREE(request->reply_timeout_event);
+
if ((child->pid == 0) && (!fork_domain_child(child))) {
- /* Cancel all outstanding requests */
+ /* fork_domain_child failed.
+ Cancel all outstanding requests */
while (request != NULL) {
/* request might be free'd in the continuation */
struct winbindd_async_request *next = request->next;
- request->continuation(request->private_data, False);
+
+ async_request_fail(request);
request = next;
}
return;
child->event.flags = 0;
child->pid = 0;
+ if (child->requests) {
+ /*
+ * schedule_async_request() will also
+ * clear this event but the call is
+ * idempotent so it doesn't hurt to
+ * cover all possible future code
+ * paths. JRA.
+ */
+ TALLOC_FREE(child->requests->reply_timeout_event);
+ }
+
schedule_async_request(child);
}
{
fstring name;
- fill_domain_username(name, domain, user, True);
+ if (domain != NULL) {
+ fill_domain_username(name, domain, user, True);
+ } else {
+ fstrcpy(name, user);
+ }
safe_strcat(name, ",", sizeof(name)-1);
string_append(pp_members, name);
*p_num_members += 1;
continue;
}
- add_member(domain->name, names[i], pp_members, p_num_members);
+ add_member(NULL, names[i], pp_members, p_num_members);
}
done:
void winbindd_dsgetdcname(struct winbindd_cli_state *state)
{
- state->request.domain_name
- [sizeof(state->request.domain_name)-1] = '\0';
+ state->request.data.dsgetdcname.domain_name
+ [sizeof(state->request.data.dsgetdcname.domain_name)-1] = '\0';
+ state->request.data.dsgetdcname.site_name
+ [sizeof(state->request.data.dsgetdcname.site_name)-1] = '\0';
+ state->request.data.dsgetdcname.domain_guid
+ [sizeof(state->request.data.dsgetdcname.domain_guid)-1] = '\0';
DEBUG(3, ("[%5lu]: dsgetdcname for %s\n", (unsigned long)state->pid,
- state->request.domain_name));
+ state->request.data.dsgetdcname.domain_name));
sendto_child(state, locator_child());
}
return ds_flags;
}
-
static enum winbindd_result dual_dsgetdcname(struct winbindd_domain *domain,
struct winbindd_cli_state *state)
{
NTSTATUS result;
struct netr_DsRGetDCNameInfo *info = NULL;
- const char *dc = NULL;
uint32_t ds_flags = 0;
+ struct GUID guid, *guid_ptr = NULL;
+ const char *guid_str = NULL;
- state->request.domain_name
- [sizeof(state->request.domain_name)-1] = '\0';
+ state->request.data.dsgetdcname.domain_name
+ [sizeof(state->request.data.dsgetdcname.domain_name)-1] = '\0';
+ state->request.data.dsgetdcname.site_name
+ [sizeof(state->request.data.dsgetdcname.site_name)-1] = '\0';
+ state->request.data.dsgetdcname.domain_guid
+ [sizeof(state->request.data.dsgetdcname.domain_guid)-1] = '\0';
DEBUG(3, ("[%5lu]: dsgetdcname for %s\n", (unsigned long)state->pid,
- state->request.domain_name));
+ state->request.data.dsgetdcname.domain_name));
ds_flags = get_dsgetdc_flags(state->request.flags);
- result = dsgetdcname(state->mem_ctx, winbind_messaging_context(),
- state->request.domain_name,
- NULL, NULL, ds_flags, &info);
-
- if (!NT_STATUS_IS_OK(result)) {
- return WINBINDD_ERROR;
+ result = GUID_from_string(state->request.data.dsgetdcname.domain_guid,
+ &guid);
+ if (NT_STATUS_IS_OK(result) && !GUID_all_zero(&guid)) {
+ guid_ptr = &guid;
}
- if (info->dc_address) {
- dc = strip_hostname(info->dc_address);
- }
+ result = dsgetdcname(state->mem_ctx,
+ winbind_messaging_context(),
+ state->request.data.dsgetdcname.domain_name,
+ guid_ptr,
+ state->request.data.dsgetdcname.site_name,
+ ds_flags,
+ &info);
- if ((!dc || !is_ipaddress_v4(dc)) && info->dc_unc) {
- dc = strip_hostname(info->dc_unc);
+ if (!NT_STATUS_IS_OK(result)) {
+ return WINBINDD_ERROR;
}
- if (!dc || !*dc) {
+ guid_str = GUID_string(state->mem_ctx, &info->domain_guid);
+ if (!guid_str) {
return WINBINDD_ERROR;
}
- fstrcpy(state->response.data.dc_name, dc);
+ fstrcpy(state->response.data.dsgetdcname.dc_unc, info->dc_unc);
+ fstrcpy(state->response.data.dsgetdcname.dc_address, info->dc_address);
+ state->response.data.dsgetdcname.dc_address_type = info->dc_address_type;
+ fstrcpy(state->response.data.dsgetdcname.domain_guid, guid_str);
+ fstrcpy(state->response.data.dsgetdcname.domain_name, info->domain_name);
+ fstrcpy(state->response.data.dsgetdcname.forest_name, info->forest_name);
+ state->response.data.dsgetdcname.dc_flags = info->dc_flags;
+ fstrcpy(state->response.data.dsgetdcname.dc_site_name, info->dc_site_name);
+ fstrcpy(state->response.data.dsgetdcname.client_site_name, info->client_site_name);
return WINBINDD_OK;
}
DATA_BLOB blob;
enum ndr_err_code ndr_err;
- ndr_err = ndr_push_struct_blob(&blob, mem_ctx, info3,
+ ndr_err = ndr_push_struct_blob(&blob, mem_ctx, NULL, info3,
(ndr_push_flags_fn_t)ndr_push_netr_SamInfo3);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
DEBUG(0,("append_info3_as_ndr: failed to append\n"));
void parse_add_domuser(void *buf, char *domuser, int *len);
bool canonicalize_username(fstring username_inout, fstring domain, fstring user);
void fill_domain_username(fstring name, const char *domain, const char *user, bool can_assume);
+char *fill_domain_username_talloc(TALLOC_CTX *ctx,
+ const char *domain,
+ const char *user,
+ bool can_assume);
const char *get_winbind_pipe_dir(void) ;
char *get_winbind_priv_pipe_dir(void) ;
int open_winbindd_socket(void);
}
for (r=0; r<tmp_names.count; r++) {
- (*names)[i+r] = CONST_DISCARD(char *, tmp_names.names[r].string);
+ (*names)[i+r] = fill_domain_username_talloc(mem_ctx,
+ domain->name,
+ tmp_names.names[r].string,
+ true);
(*name_types)[i+r] = tmp_types.ids[r];
}
const char *alternative_name = NULL;
char *idmap_config_option;
const char *param;
+ const char **ignored_domains, **dom;
+ ignored_domains = lp_parm_string_list(-1, "winbind", "ignore domains", NULL);
+ for (dom=ignored_domains; dom && *dom; dom++) {
+ if (gen_fnmatch(*dom, domain_name) == 0) {
+ DEBUG(2,("Ignoring domain '%s'\n", domain_name));
+ return NULL;
+ }
+ }
+
/* ignore alt_name if we are not in an AD domain */
if ( (lp_security() == SEC_ADS) && alt_name && *alt_name) {
&dom_list[i].sid );
}
+ if (d == NULL) {
+ continue;
+ }
+
DEBUG(10,("rescan_forest_root_trusts: Following trust path "
"for domain tree root %s (%s)\n",
d->name, d->alt_name ));
&cache_methods,
&dom_list[i].sid );
}
+
+ if (d == NULL) {
+ continue;
+ }
DEBUG(10,("Following trust path for domain %s (%s)\n",
d->name, d->alt_name ));
temp = state;
while(temp != NULL) {
- struct getent_state *next;
+ struct getent_state *next = temp->next;
/* Free sam entries then list entry */
SAFE_FREE(state->sam_entries);
DLIST_REMOVE(state, state);
- next = temp->next;
SAFE_FREE(temp);
temp = next;
}
}
- safe_strcpy(buf, user, *len);
+ safe_strcpy((char *)buf, user, *len);
}
/* Ensure an incoming username from NSS is fully qualified. Replace the
}
}
+/**
+ * talloc version of fill_domain_username()
+ * return NULL on talloc failure.
+ */
+char *fill_domain_username_talloc(TALLOC_CTX *mem_ctx,
+ const char *domain,
+ const char *user,
+ bool can_assume)
+{
+ char *tmp_user, *name;
+
+ tmp_user = talloc_strdup(mem_ctx, user);
+ strlower_m(tmp_user);
+
+ if (can_assume && assume_domain(domain)) {
+ name = tmp_user;
+ } else {
+ name = talloc_asprintf(mem_ctx, "%s%c%s",
+ domain,
+ *lp_winbind_separator(),
+ tmp_user);
+ TALLOC_FREE(tmp_user);
+ }
+
+ return name;
+}
+
/*
* Winbindd socket accessor functions
*/
pidldir := $(srcdir)/../pidl
-BASEDIR = $(prefix)
-TORTUREDIR = $(libdir)/torture
-SWATDIR = $(datadir)/swat
-JSDIR = $(datadir)/js
-SETUPDIR = $(datadir)/setup
-NCALRPCDIR = $(localstatedir)/ncalrpc
+basedir = $(prefix)
+torturedir = $(libdir)/torture
+swatdir = $(datadir)/swat
+setupdir = $(datadir)/setup
+ncalrpcdir = $(localstatedir)/ncalrpc
BNLD = $(LD)
BNLD_FLAGS = $(LDFLAGS) $(SYS_LDFLAGS)
libutilsrcdir := lib/util
libtdrsrcdir := lib/tdr
libdbwrapsrcdir := lib/dbwrap
-libcryptosrcdir := lib/crypto
+libcryptosrcdir := ../lib/crypto
libtorturesrcdir := lib/torture
smb_serversrcdir := smb_server
libcompressionsrcdir := ../lib/compression
ntptrsrcdir := ntptr
librpcsrcdir := librpc
libclisrcdir := libcli
-ejsscriptsrcdir := scripting/ejs
+libclinbtsrcdir := ../libcli/nbt
pyscriptsrcdir := $(srcdir)/scripting/python
kdcsrcdir := kdc
ntp_signdsrcdir := ntp_signd
wmisrcdir := lib/wmi
tallocsrcdir := ../lib/talloc
+comsrcdir := $(srcdir)/lib/com
include data.mk
+$(foreach SCRIPT,$(wildcard scripting/bin/*),$(eval $(call binary_install_template,$(SCRIPT))))
+
+$(DESTDIR)$(bindir)/%: scripting/bin/% installdirs
+ @mkdir -p $(@D)
+ @echo Installing $(@F) as $@
+ @if test -f $@; then echo -n ""; rm -f $@.old; mv $@ $@.old; fi
+ @cp $< $@
+ @chmod $(INSTALLPERMS) $@
+
pythonmods:: $(PYTHON_PYS) $(PYTHON_SO)
DEP_FILES = $(patsubst %.ho,%.hd,$(patsubst %.o,%.d,$(ALL_OBJS))) \
include $(srcdir)/static_deps.mk
endif
+clean::
+ @find ../lib ../libcli -name '*.o' -o -name '*.hd' | xargs rm -f
+
DEFAULT_HEADERS = $(srcdir)/lib/util/dlinklist.h \
$(srcdir)/version.h
showlayout::
@echo 'Samba will be installed into:'
- @echo ' basedir: $(BASEDIR)'
+ @echo ' basedir: $(basedir)'
@echo ' bindir: $(bindir)'
@echo ' sbindir: $(sbindir)'
@echo ' libdir: $(libdir)'
@echo ' piddir: $(piddir)'
@echo ' lockdir: $(lockdir)'
@echo ' logfilebase: $(logfilebase)'
- @echo ' setupdir: $(SETUPDIR)'
- @echo ' jsdir: $(JSDIR)'
- @echo ' swatdir: $(SWATDIR)'
+ @echo ' setupdir: $(setupdir)'
+ @echo ' swatdir: $(swatdir)'
@echo ' mandir: $(mandir)'
- @echo ' torturedir: $(TORTUREDIR)'
+ @echo ' torturedir: $(torturedir)'
@echo ' datadir: $(datadir)'
@echo ' winbindd_socket_dir: $(winbindd_socket_dir)'
@echo ' ntp_signd_socket_dir: $(ntp_signd_socket_dir)'
# The permissions to give the executables
INSTALLPERMS = 0755
-install:: showlayout everything installbin installsbin installdat installswat installmisc \
+install:: showlayout everything installbin installsbin installdat installmisc \
installlib installheader installpc installplugins
# DESTDIR is used here to prevent packagers wasting their time
installdirs::
@$(SHELL) $(srcdir)/script/installdirs.sh \
- $(DESTDIR)$(BASEDIR) \
+ $(DESTDIR)$(basedir) \
$(DESTDIR)$(bindir) \
$(DESTDIR)$(sbindir) \
- $(DESTDIR)$(TORTUREDIR) \
+ $(DESTDIR)$(torturedir) \
$(DESTDIR)$(libdir) \
$(DESTDIR)$(modulesdir) \
$(DESTDIR)$(mandir) \
$(DESTDIR)$(logfilebase) \
$(DESTDIR)$(privatedir)/tls \
$(DESTDIR)$(includedir) \
- $(DESTDIR)$(PKGCONFIGDIR) \
+ $(DESTDIR)$(pkgconfigdir) \
$(DESTDIR)$(sysconfdir)
installbin:: installdirs
installdat:: installdirs
@$(SHELL) $(srcdir)/script/installdat.sh $(DESTDIR)$(datadir) $(srcdir)
-installswat:: installdirs
-#SWAT has been disabled until further notice
-# @$(SHELL) $(srcdir)/script/installswat.sh $(DESTDIR)$(SWATDIR) $(srcdir)
-
installman:: manpages installdirs
@$(SHELL) $(srcdir)/script/installman.sh $(DESTDIR)$(mandir) $(MANPAGES)
installmisc:: installdirs
- @$(SHELL) $(srcdir)/script/installmisc.sh $(srcdir) $(DESTDIR)$(JSDIR) $(DESTDIR)$(SETUPDIR) $(DESTDIR)$(bindir)
+ @$(SHELL) $(srcdir)/script/installmisc.sh $(srcdir) $(DESTDIR)$(setupdir)
installpc:: installdirs
- @$(SHELL) $(srcdir)/script/installpc.sh $(builddir) $(DESTDIR)$(PKGCONFIGDIR) $(PC_FILES)
+ @$(SHELL) $(srcdir)/script/installpc.sh $(builddir) $(DESTDIR)$(pkgconfigdir) $(PC_FILES)
-uninstall:: uninstallbin uninstallman uninstallmisc uninstalllib uninstallheader \
- uninstallplugins
+uninstall:: uninstallbin uninstallsbin uninstalldat uninstallmisc uninstalllib uninstallheader \
+ uninstallman uninstallpc uninstallplugins
uninstallmisc::
- #FIXME
+ @echo "Removing MISC files"
+ @rm -rf $(DESTDIR)$(setupdir)/*
$(DESTDIR)$(bindir)/%: bin/% installdirs
@mkdir -p $(@D)
@cp $< $@
@chmod $(INSTALLPERMS) $@
+uninstalldat::
+ @echo "Removing DAT files"
+ @rm -fr $(DESTDIR)$(datadir)/*
+
uninstallbin::
uninstalllib::
+ @echo "Removing libraries"
@$(SHELL) $(srcdir)/script/uninstalllib.sh $(DESTDIR)$(libdir) $(SHARED_LIBS)
- #@$(SHELL) $(srcdir)/script/uninstalllib.sh $(DESTDIR)$(libdir) $(STATIC_LIBS)
uninstallheader::
- @$(SHELL) $(srcdir)/script/uninstallheader.sh $(DESTDIR)$(includedir) $(PUBLIC_HEADERS)
+ @echo "Removing headers"
+ @rm -fr $(DESTDIR)$(includedir)/*
uninstallman::
+ @echo "Removing manpages"
@$(SHELL) $(srcdir)/script/uninstallman.sh $(DESTDIR)$(mandir) $(MANPAGES)
uninstallplugins::
+uninstallpc::
+ @echo "Removing package configurations"
+ @cd $(DESTDIR)$(pkgconfigdir); rm -f $(notdir $(PC_FILES))
+
config.status:
@echo "config.status does not exist. Please run ./configure."
@/bin/false
-source/build/smb_build/TODO
-source/lib/registry/TODO
-source/lib/tdr/TODO
-source/pidl/TODO
+build/smb_build/TODO
+lib/registry/TODO
+lib/tdr/TODO
+pidl/TODO
- seperate adminlog mechanism (as opposed to the current DEBUG log,
which is not really aimed at administrators but more at developers)
# This file was automatically generated by SWIG (http://www.swig.org).
-# Version 1.3.35
+# Version 1.3.36
#
# Don't modify this file, modify the SWIG interface instead.
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
- * Version 1.3.35
+ * Version 1.3.36
*
* This file is not intended to be easily readable and contains a number of
* coding conventions designed to improve portability and efficiency. Do not make
# endif
#endif
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+# pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
# define SWIGUNUSEDPARM(p)
#define SWIG_name "_auth"
-#define SWIGVERSION 0x010335
+#define SWIGVERSION 0x010336
#define SWIG_VERSION SWIGVERSION
PyObject *resultobj = 0;
TALLOC_CTX *arg1 = (TALLOC_CTX *) 0 ;
struct loadparm_context *arg2 = (struct loadparm_context *) 0 ;
- struct auth_session_info *result = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
char * kwnames[] = {
(char *) "lp_ctx", NULL
};
+ struct auth_session_info *result = 0 ;
arg2 = loadparm_init(NULL);
arg1 = NULL;
PyObject *resultobj = 0;
TALLOC_CTX *arg1 = (TALLOC_CTX *) 0 ;
struct loadparm_context *arg2 = (struct loadparm_context *) 0 ;
- struct auth_session_info *result = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
char * kwnames[] = {
(char *) "lp_ctx", NULL
};
+ struct auth_session_info *result = 0 ;
arg2 = loadparm_init(NULL);
arg1 = NULL;
# This file was automatically generated by SWIG (http://www.swig.org).
-# Version 1.3.35
+# Version 1.3.36
#
# Don't modify this file, modify the SWIG interface instead.
#include "includes.h"
#include "librpc/gen_ndr/samr.h" /* for struct samrPassword */
-#include "lib/crypto/crypto.h"
+#include "../lib/crypto/crypto.h"
#include "libcli/auth/libcli_auth.h"
#include "auth/credentials/credentials.h"
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
- * Version 1.3.35
+ * Version 1.3.36
*
* This file is not intended to be easily readable and contains a number of
* coding conventions designed to improve portability and efficiency. Do not make
# endif
#endif
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+# pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
# define SWIGUNUSEDPARM(p)
#define SWIG_name "_credentials"
-#define SWIGVERSION 0x010335
+#define SWIGVERSION 0x010336
#define SWIG_VERSION SWIGVERSION
SWIGINTERN PyObject *_wrap_Credentials_get_username(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
cli_credentials *arg1 = (cli_credentials *) 0 ;
- char *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char * kwnames[] = {
(char *) "self", NULL
};
+ char *result = 0 ;
arg1 = NULL;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Credentials_get_username",kwnames,&obj0)) SWIG_fail;
cli_credentials *arg1 = (cli_credentials *) 0 ;
char *arg2 = (char *) 0 ;
enum credentials_obtained arg3 = (enum credentials_obtained) CRED_SPECIFIED ;
- bool result;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char * kwnames[] = {
(char *) "self",(char *) "value",(char *) "obtained", NULL
};
+ bool result;
arg1 = NULL;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:Credentials_set_username",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
SWIGINTERN PyObject *_wrap_Credentials_get_password(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
cli_credentials *arg1 = (cli_credentials *) 0 ;
- char *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char * kwnames[] = {
(char *) "self", NULL
};
+ char *result = 0 ;
arg1 = NULL;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Credentials_get_password",kwnames,&obj0)) SWIG_fail;
cli_credentials *arg1 = (cli_credentials *) 0 ;
char *arg2 = (char *) 0 ;
enum credentials_obtained arg3 = (enum credentials_obtained) CRED_SPECIFIED ;
- bool result;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char * kwnames[] = {
(char *) "self",(char *) "val",(char *) "obtained", NULL
};
+ bool result;
arg1 = NULL;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:Credentials_set_password",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
SWIGINTERN PyObject *_wrap_Credentials_get_domain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
cli_credentials *arg1 = (cli_credentials *) 0 ;
- char *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char * kwnames[] = {
(char *) "self", NULL
};
+ char *result = 0 ;
arg1 = NULL;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Credentials_get_domain",kwnames,&obj0)) SWIG_fail;
cli_credentials *arg1 = (cli_credentials *) 0 ;
char *arg2 = (char *) 0 ;
enum credentials_obtained arg3 = (enum credentials_obtained) CRED_SPECIFIED ;
- bool result;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char * kwnames[] = {
(char *) "self",(char *) "val",(char *) "obtained", NULL
};
+ bool result;
arg1 = NULL;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:Credentials_set_domain",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
SWIGINTERN PyObject *_wrap_Credentials_get_realm(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
cli_credentials *arg1 = (cli_credentials *) 0 ;
- char *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char * kwnames[] = {
(char *) "self", NULL
};
+ char *result = 0 ;
arg1 = NULL;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Credentials_get_realm",kwnames,&obj0)) SWIG_fail;
cli_credentials *arg1 = (cli_credentials *) 0 ;
char *arg2 = (char *) 0 ;
enum credentials_obtained arg3 = (enum credentials_obtained) CRED_SPECIFIED ;
- bool result;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char * kwnames[] = {
(char *) "self",(char *) "val",(char *) "obtained", NULL
};
+ bool result;
arg1 = NULL;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:Credentials_set_realm",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
SWIGINTERN PyObject *_wrap_Credentials_get_bind_dn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
cli_credentials *arg1 = (cli_credentials *) 0 ;
- char *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char * kwnames[] = {
(char *) "self", NULL
};
+ char *result = 0 ;
arg1 = NULL;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Credentials_get_bind_dn",kwnames,&obj0)) SWIG_fail;
PyObject *resultobj = 0;
cli_credentials *arg1 = (cli_credentials *) 0 ;
char *arg2 = (char *) 0 ;
- bool result;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char * kwnames[] = {
(char *) "self",(char *) "bind_dn", NULL
};
+ bool result;
arg1 = NULL;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:Credentials_set_bind_dn",kwnames,&obj0,&obj1)) SWIG_fail;
SWIGINTERN PyObject *_wrap_Credentials_get_workstation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
cli_credentials *arg1 = (cli_credentials *) 0 ;
- char *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char * kwnames[] = {
(char *) "self", NULL
};
+ char *result = 0 ;
arg1 = NULL;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Credentials_get_workstation",kwnames,&obj0)) SWIG_fail;
cli_credentials *arg1 = (cli_credentials *) 0 ;
char *arg2 = (char *) 0 ;
enum credentials_obtained arg3 = (enum credentials_obtained) CRED_SPECIFIED ;
- bool result;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char * kwnames[] = {
(char *) "self",(char *) "workstation",(char *) "obtained", NULL
};
+ bool result;
arg1 = NULL;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:Credentials_set_workstation",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
PyObject *resultobj = 0;
cli_credentials *arg1 = (cli_credentials *) 0 ;
struct loadparm_context *arg2 = (struct loadparm_context *) 0 ;
- NTSTATUS result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
char * kwnames[] = {
(char *) "self",(char *) "lp_ctx", NULL
};
+ NTSTATUS result;
arg1 = NULL;
arg2 = loadparm_init(NULL);
SWIGINTERN PyObject *_wrap_Credentials_is_anonymous(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
cli_credentials *arg1 = (cli_credentials *) 0 ;
- bool result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char * kwnames[] = {
(char *) "self", NULL
};
+ bool result;
arg1 = NULL;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Credentials_is_anonymous",kwnames,&obj0)) SWIG_fail;
PyObject *resultobj = 0;
cli_credentials *arg1 = (cli_credentials *) 0 ;
TALLOC_CTX *arg2 = (TALLOC_CTX *) 0 ;
- struct samr_Password *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char * kwnames[] = {
(char *) "self", NULL
};
+ struct samr_Password *result = 0 ;
arg1 = NULL;
arg2 = NULL;
SWIGINTERN PyObject *_wrap_Credentials_authentication_requested(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
cli_credentials *arg1 = (cli_credentials *) 0 ;
- bool result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char * kwnames[] = {
(char *) "self", NULL
};
+ bool result;
arg1 = NULL;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Credentials_authentication_requested",kwnames,&obj0)) SWIG_fail;
SWIGINTERN PyObject *_wrap_Credentials_wrong_password(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
cli_credentials *arg1 = (cli_credentials *) 0 ;
- bool result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char * kwnames[] = {
(char *) "self", NULL
};
+ bool result;
arg1 = NULL;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Credentials_wrong_password",kwnames,&obj0)) SWIG_fail;
SWIGINTERN PyObject *_wrap_Credentials_set_cmdline_callbacks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
cli_credentials *arg1 = (cli_credentials *) 0 ;
- bool result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char * kwnames[] = {
(char *) "self", NULL
};
+ bool result;
arg1 = NULL;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Credentials_set_cmdline_callbacks",kwnames,&obj0)) SWIG_fail;
arg1 = (cli_credentials *)(argp1);
}
delete_cli_credentials(arg1);
-
resultobj = SWIG_Py_Void();
return resultobj;
fail:
static int gensec_sasl_dispose(struct gensec_sasl_state *gensec_sasl_state)
{
sasl_dispose(&gensec_sasl_state->conn);
- return 0;
+ return SASL_OK;
}
static NTSTATUS gensec_sasl_client_start(struct gensec_security *gensec_security)
NT_STATUS_HAVE_NO_MEMORY(*gensec_security);
(*gensec_security)->ops = NULL;
+ (*gensec_security)->private_data = NULL;
ZERO_STRUCT((*gensec_security)->target);
ZERO_STRUCT((*gensec_security)->peer_addr);
(*gensec_security)->private_data = NULL;
(*gensec_security)->subcontext = true;
+ (*gensec_security)->want_features = parent->want_features;
(*gensec_security)->event_ctx = parent->event_ctx;
(*gensec_security)->msg_ctx = parent->msg_ctx;
(*gensec_security)->lp_ctx = parent->lp_ctx;
_PUBLIC_ void gensec_want_feature(struct gensec_security *gensec_security,
uint32_t feature)
{
- gensec_security->want_features |= feature;
+ if (!gensec_security->ops || !gensec_security->ops->want_feature) {
+ gensec_security->want_features |= feature;
+ return;
+ }
+ gensec_security->ops->want_feature(gensec_security, feature);
}
/**
NTSTATUS (*session_key)(struct gensec_security *gensec_security, DATA_BLOB *session_key);
NTSTATUS (*session_info)(struct gensec_security *gensec_security,
struct auth_session_info **session_info);
+ void (*want_feature)(struct gensec_security *gensec_security,
+ uint32_t feature);
bool (*have_feature)(struct gensec_security *gensec_security,
uint32_t feature);
bool enabled;
struct socket_context;
NTSTATUS gensec_socket_init(struct gensec_security *gensec_security,
+ TALLOC_CTX *mem_ctx,
struct socket_context *current_socket,
struct event_context *ev,
void (*recv_handler)(void *, uint16_t),
OM_uint32 maj_stat, min_stat;
krb5_keyblock *subkey;
+ if (gensec_gssapi_state->sasl_state != STAGE_DONE) {
+ return NT_STATUS_NO_USER_SESSION_KEY;
+ }
+
if (gensec_gssapi_state->session_key.data) {
*session_key = gensec_gssapi_state->session_key;
return NT_STATUS_OK;
*session_key = data_blob_talloc(gensec_gssapi_state,
KRB5_KEY_DATA(subkey), KRB5_KEY_LENGTH(subkey));
krb5_free_keyblock(gensec_gssapi_state->smb_krb5_context->krb5_context, subkey);
- if (gensec_gssapi_state->sasl_state == STAGE_DONE) {
- /* only cache in the done stage */
- gensec_gssapi_state->session_key = *session_key;
- }
+ gensec_gssapi_state->session_key = *session_key;
dump_data_pw("KRB5 Session Key:\n", session_key->data, session_key->length);
return NT_STATUS_OK;
krb5_keyblock *skey;
krb5_error_code err = -1;
+ if (gensec_krb5_state->state_position != GENSEC_KRB5_DONE) {
+ return NT_STATUS_NO_USER_SESSION_KEY;
+ }
+
if (gensec_krb5_state->session_key.data) {
*session_key = gensec_krb5_state->session_key;
return NT_STATUS_OK;
*/
#include "includes.h"
-#include "lib/crypto/crypto.h"
+#include "../lib/crypto/crypto.h"
#include "auth/auth.h"
#include "auth/gensec/schannel.h"
#include "auth/credentials/credentials.h"
"computerName: CASE_INSENSITIVE\n" \
"flatname: CASE_INSENSITIVE\n";
- path = smbd_tmp_path(mem_ctx, lp_ctx, "schannel.ldb");
+ path = private_path(mem_ctx, lp_ctx, "schannel.ldb");
if (!path) {
return NULL;
}
return NT_STATUS_NO_MEMORY;
}
- ret = ldb_search_exp_fmt(ldb, mem_ctx, &res,
+ ret = ldb_search(ldb, mem_ctx, &res,
NULL, LDB_SCOPE_SUBTREE, NULL,
"(&(computerName=%s)(flatname=%s))", computer_name, domain);
if (ret != LDB_SUCCESS) {
}
/* Turn a normal socket into a potentially GENSEC wrapped socket */
+/* CAREFUL: this function will steal 'current_socket' */
NTSTATUS gensec_socket_init(struct gensec_security *gensec_security,
+ TALLOC_CTX *mem_ctx,
struct socket_context *current_socket,
struct event_context *ev,
void (*recv_handler)(void *, uint16_t),
struct socket_context *new_sock;
NTSTATUS nt_status;
- nt_status = socket_create_with_ops(current_socket, &gensec_socket_ops, &new_sock,
+ nt_status = socket_create_with_ops(mem_ctx, &gensec_socket_ops, &new_sock,
SOCKET_TYPE_STREAM, current_socket->flags | SOCKET_FLAG_ENCRYPT);
if (!NT_STATUS_IS_OK(nt_status)) {
*new_socket = NULL;
gensec_socket = talloc(new_sock, struct gensec_socket);
if (gensec_socket == NULL) {
*new_socket = NULL;
+ talloc_free(new_sock);
return NT_STATUS_NO_MEMORY;
}
new_sock->private_data = gensec_socket;
gensec_socket->socket = current_socket;
- if (talloc_reference(gensec_socket, current_socket) == NULL) {
- *new_socket = NULL;
- return NT_STATUS_NO_MEMORY;
- }
-
/* Nothing to do here, if we are not actually wrapping on this socket */
if (!gensec_have_feature(gensec_security, GENSEC_FEATURE_SEAL) &&
!gensec_have_feature(gensec_security, GENSEC_FEATURE_SIGN)) {
gensec_socket->wrap = false;
+ talloc_steal(gensec_socket, current_socket);
*new_socket = new_sock;
return NT_STATUS_OK;
}
gensec_socket->packet = packet_init(gensec_socket);
if (gensec_socket->packet == NULL) {
*new_socket = NULL;
+ talloc_free(new_sock);
return NT_STATUS_NO_MEMORY;
}
/* TODO: full-request that knows about maximum packet size */
+ talloc_steal(gensec_socket, current_socket);
*new_socket = new_sock;
return NT_STATUS_OK;
}
return NT_STATUS_INVALID_PARAMETER;
}
+static void gensec_spnego_want_feature(struct gensec_security *gensec_security,
+ uint32_t feature)
+{
+ struct spnego_state *spnego_state = (struct spnego_state *)gensec_security->private_data;
+
+ if (!spnego_state || !spnego_state->sub_sec_security) {
+ gensec_security->want_features |= feature;
+ return;
+ }
+
+ gensec_want_feature(spnego_state->sub_sec_security,
+ feature);
+}
+
static bool gensec_spnego_have_feature(struct gensec_security *gensec_security,
uint32_t feature)
{
.unwrap_packets = gensec_spnego_unwrap_packets,
.session_key = gensec_spnego_session_key,
.session_info = gensec_spnego_session_info,
+ .want_feature = gensec_spnego_want_feature,
.have_feature = gensec_spnego_have_feature,
.enabled = true,
.priority = GENSEC_SPNEGO
This version is built to use a keyblock, rather than needing the
original password.
*/
- int kerberos_kinit_keyblock_cc(krb5_context ctx, krb5_ccache cc,
+ krb5_error_code kerberos_kinit_keyblock_cc(krb5_context ctx, krb5_ccache cc,
krb5_principal principal, krb5_keyblock *keyblock,
time_t *expire_time, time_t *kdc_time)
{
simulate a kinit, putting the tgt in the given credentials cache.
Orignally by remus@snapserver.com
*/
- int kerberos_kinit_password_cc(krb5_context ctx, krb5_ccache cc,
+ krb5_error_code kerberos_kinit_password_cc(krb5_context ctx, krb5_ccache cc,
krb5_principal principal, const char *password,
time_t *expire_time, time_t *kdc_time)
{
krb5_principal principal;
};
-static int free_principal(struct principal_container *pc)
+static krb5_error_code free_principal(struct principal_container *pc)
{
/* current heimdal - 0.6.3, which we need anyway, fixes segfaults here */
krb5_free_principal(pc->smb_krb5_context->krb5_context, pc->principal);
return 0;
}
-static int free_keytab(struct keytab_container *ktc)
+static krb5_error_code free_keytab(struct keytab_container *ktc)
{
- krb5_kt_close(ktc->smb_krb5_context->krb5_context, ktc->keytab);
-
- return 0;
+ return krb5_kt_close(ktc->smb_krb5_context->krb5_context, ktc->keytab);
}
-int smb_krb5_open_keytab(TALLOC_CTX *mem_ctx,
+krb5_error_code smb_krb5_open_keytab(TALLOC_CTX *mem_ctx,
struct smb_krb5_context *smb_krb5_context,
const char *keytab_name, struct keytab_container **ktc)
{
krb5_keytab keytab;
- int ret;
+ krb5_error_code ret;
ret = krb5_kt_resolve(smb_krb5_context->krb5_context, keytab_name, &keytab);
if (ret) {
DEBUG(1,("failed to open krb5 keytab: %s\n",
return 0;
}
-static int create_keytab(TALLOC_CTX *parent_ctx,
+static krb5_error_code create_keytab(TALLOC_CTX *parent_ctx,
struct cli_credentials *machine_account,
struct smb_krb5_context *smb_krb5_context,
const char **enctype_strings,
return ret;
}
-int smb_krb5_update_keytab(TALLOC_CTX *parent_ctx,
+krb5_error_code smb_krb5_update_keytab(TALLOC_CTX *parent_ctx,
struct cli_credentials *machine_account,
struct smb_krb5_context *smb_krb5_context,
const char **enctype_strings,
return ret;
}
-int smb_krb5_create_memory_keytab(TALLOC_CTX *parent_ctx,
+krb5_error_code smb_krb5_create_memory_keytab(TALLOC_CTX *parent_ctx,
struct cli_credentials *machine_account,
struct smb_krb5_context *smb_krb5_context,
const char **enctype_strings,
krb5_krbhst_info *hi;
};
-static int smb_krb5_context_destroy_1(struct smb_krb5_context *ctx)
+static krb5_error_code smb_krb5_context_destroy_1(struct smb_krb5_context *ctx)
{
krb5_free_context(ctx->krb5_context);
return 0;
}
-static int smb_krb5_context_destroy_2(struct smb_krb5_context *ctx)
+static krb5_error_code smb_krb5_context_destroy_2(struct smb_krb5_context *ctx)
{
/* Otherwise krb5_free_context will try and close what we have already free()ed */
krb5_set_warn_dest(ctx->krb5_context, NULL);
io.in.workgroup = ""; /* only used with SPNEGO, disabled above */
io.in.options = smb_options;
+ lp_smbcli_session_options(ctx->auth_ctx->lp_ctx, &io.in.session_options);
status = smb_composite_connect(&io, mem_ctx, lp_resolve_context(ctx->auth_ctx->lp_ctx),
ctx->auth_ctx->event_ctx);
*/
#include "includes.h"
-#include "lib/crypto/crypto.h"
+#include "../lib/crypto/crypto.h"
#include "librpc/gen_ndr/netlogon.h"
#include "libcli/auth/libcli_auth.h"
#include "param/param.h"
{
struct gensec_ntlmssp_state *gensec_ntlmssp_state = (struct gensec_ntlmssp_state *)gensec_security->private_data;
+ if (gensec_ntlmssp_state->expected_state != NTLMSSP_DONE) {
+ return NT_STATUS_NO_USER_SESSION_KEY;
+ }
+
if (!gensec_ntlmssp_state->session_key.data) {
return NT_STATUS_NO_USER_SESSION_KEY;
}
#include "includes.h"
#include "auth/ntlmssp/ntlmssp.h"
#include "auth/ntlmssp/msrpc_parse.h"
-#include "lib/crypto/crypto.h"
+#include "../lib/crypto/crypto.h"
#include "libcli/auth/libcli_auth.h"
#include "auth/credentials/credentials.h"
#include "auth/gensec/gensec.h"
#include "includes.h"
#include "auth/ntlmssp/ntlmssp.h"
#include "auth/ntlmssp/msrpc_parse.h"
-#include "lib/crypto/crypto.h"
-#include "system/filesys.h"
+#include "../lib/crypto/crypto.h"
#include "libcli/auth/libcli_auth.h"
#include "auth/credentials/credentials.h"
#include "auth/gensec/gensec.h"
{
struct gensec_ntlmssp_state *gensec_ntlmssp_state = (struct gensec_ntlmssp_state *)gensec_security->private_data;
DATA_BLOB struct_blob;
- char dnsname[MAXHOSTNAMELEN], dnsdomname[MAXHOSTNAMELEN];
- const char *p;
uint32_t neg_flags = 0;
uint32_t ntlmssp_command, chal_flags;
const uint8_t *cryptkey;
gensec_ntlmssp_state->chal = data_blob_talloc(gensec_ntlmssp_state, cryptkey, 8);
gensec_ntlmssp_state->internal_chal = data_blob_talloc(gensec_ntlmssp_state, cryptkey, 8);
- dnsname[0] = '\0';
- if (gethostname(dnsname, sizeof(dnsname)) == -1) {
- DEBUG(0,("gethostname failed\n"));
- return NT_STATUS_UNSUCCESSFUL;
- }
-
- /* This should be a 'netbios domain -> DNS domain' mapping */
- p = strchr(dnsname, '.');
- if (p != NULL) {
- safe_strcpy(dnsdomname, p+1, sizeof(dnsdomname));
- strlower_m(dnsdomname);
- } else {
- dnsdomname[0] = '\0';
- }
-
/* This creates the 'blob' of names that appears at the end of the packet */
- if (chal_flags & NTLMSSP_CHAL_TARGET_INFO)
- {
+ if (chal_flags & NTLMSSP_CHAL_TARGET_INFO) {
+ char dnsdomname[MAXHOSTNAMELEN], dnsname[MAXHOSTNAMELEN];
const char *target_name_dns = "";
+
+ /* Find out the DNS domain name */
+ dnsdomname[0] = '\0';
+ safe_strcpy(dnsdomname, lp_realm(gensec_security->lp_ctx), sizeof(dnsdomname) - 1);
+ strlower_m(dnsdomname);
+
+ /* Find out the DNS host name */
+ safe_strcpy(dnsname, gensec_ntlmssp_state->server_name, sizeof(dnsname) - 1);
+ if (dnsdomname[0] != '\0') {
+ safe_strcat(dnsname, ".", sizeof(dnsname) - 1);
+ safe_strcat(dnsname, dnsdomname, sizeof(dnsname) - 1);
+ }
+ strlower_m(dnsname);
+
if (chal_flags |= NTLMSSP_TARGET_TYPE_DOMAIN) {
target_name_dns = dnsdomname;
} else if (chal_flags |= NTLMSSP_TARGET_TYPE_SERVER) {
}
{
- /* Marshel the packet in the right format, be it unicode or ASCII */
+ /* Marshal the packet in the right format, be it unicode or ASCII */
const char *gen_string;
if (gensec_ntlmssp_state->unicode) {
gen_string = "CdUdbddB";
#include "auth/auth.h"
#include "auth/ntlmssp/ntlmssp.h"
#include "auth/ntlmssp/msrpc_parse.h"
-#include "lib/crypto/crypto.h"
+#include "../lib/crypto/crypto.h"
#include "auth/credentials/credentials.h"
#include "auth/gensec/gensec.h"
#include "param/param.h"
# Run this script to build samba from git.
+while true; do
+ case $1 in
+ (--version-file)
+ VERSION_FILE=$2
+ shift 2
+ ;;
+ (*)
+ break
+ ;;
+ esac
+done
+
## insert all possible names (only works with
## autoconf 2.x)
TESTAUTOHEADER="autoheader autoheader-2.53 autoheader2.50 autoheader259 autoheader253"
fi
echo "$0: running script/mkversion.sh"
-./script/mkversion.sh || exit 1
+./script/mkversion.sh $VERSION_FILE || exit 1
rm -rf autom4te*.cache
rm -f configure include/config_tmp.h*
winbindd_privileged_socket_dir="${localstatedir}/lib/winbindd_privileged"
ntp_signd_socket_dir="${localstatedir}/run/ntp_signd"
-# Check to prevent installing directly under /usr without the FHS
-AS_IF([test ${prefix} == /usr],[
- AC_MSG_ERROR([Don't install directly under "/usr" without using the FHS option (--with-fhs). This could lead to file loss!])
-])
+AC_ARG_ENABLE(fhs,
+[AS_HELP_STRING([--enable-fhs],[Use FHS-compliant paths (default=no)])],
+[fhs=$enableval],
+[fhs=no]
+)
-AC_ARG_WITH(fhs,
-[AS_HELP_STRING([--with-fhs],[Use FHS-compliant paths (default=no)])],
+if test x$fhs = xyes; then
lockdir="${localstatedir}/lib/samba"
piddir="${localstatedir}/run/samba"
logfilebase="${localstatedir}/log/samba"
ntp_signd_socket_dir="${localstatedir}/run/samba/ntp_signd"
winbindd_socket_dir="${localstatedir}/run/samba/winbindd"
winbindd_privileged_socket_dir="${localstatedir}/lib/samba/winbindd_privileged"
-)
+else
+ # Check to prevent installing directly under /usr without the FHS
+ AS_IF([test $prefix == /usr || $prefix == /usr/local],[
+ AC_MSG_ERROR([Don't install directly under "/usr" or "/usr/local" without using the FHS option (--enable-fhs). This could lead to file loss!])
+ ])
+fi
#################################################
# set private directory location
print "Summary:\n\n";
showitem($output, "SSL in SWAT and LDAP", ["GNUTLS"]);
- showitem($output, "threads in smbd (see --with-pthread)", ["PTHREAD"]);
+ showitem($output, "threads in server (see --with-pthread)", ["PTHREAD"]);
showitem($output, "intelligent command line editing", ["READLINE"]);
showitem($output, "changing process titles (see --with-setproctitle)", ["SETPROCTITLE"]);
showitem($output, "using extended attributes", ["XATTR"]);
int num_interfaces;
TALLOC_CTX *tmp_ctx = talloc_new(cldapd);
NTSTATUS status;
+ int i;
num_interfaces = iface_count(ifaces);
if (!lp_bind_interfaces_only(lp_ctx)) {
status = cldapd_add_socket(cldapd, lp_ctx, "0.0.0.0");
NT_STATUS_NOT_OK_RETURN(status);
- } else {
- int i;
-
- for (i=0; i<num_interfaces; i++) {
- const char *address = talloc_strdup(tmp_ctx, iface_n_ip(ifaces, i));
- status = cldapd_add_socket(cldapd, lp_ctx, address);
- NT_STATUS_NOT_OK_RETURN(status);
- }
+ }
+
+ /* now we have to also listen on the specific interfaces,
+ so that replies always come from the right IP */
+ for (i=0; i<num_interfaces; i++) {
+ const char *address = talloc_strdup(tmp_ctx, iface_n_ip(ifaces, i));
+ status = cldapd_add_socket(cldapd, lp_ctx, address);
+ NT_STATUS_NOT_OK_RETURN(status);
}
talloc_free(tmp_ctx);
# Start SUBSYSTEM CLDAPD
[MODULE::CLDAPD]
INIT_FUNCTION = server_service_cldapd_init
-SUBSYSTEM = smbd
+SUBSYSTEM = samba
PRIVATE_DEPENDENCIES = \
LIBCLI_CLDAP LIBNETIF process_model
# End SUBSYSTEM CLDAPD
struct ldb_dn *dom_dn;
/* try and find the domain */
- ret = ldb_search_exp_fmt(sam_ctx, mem_ctx, &ref_res,
- partitions_basedn, LDB_SCOPE_ONELEVEL,
- ref_attrs,
- "(&(&(objectClass=crossRef)(dnsRoot=%s))(nETBIOSName=*))",
- ldb_binary_encode_string(mem_ctx, domain));
+ ret = ldb_search(sam_ctx, mem_ctx, &ref_res,
+ partitions_basedn, LDB_SCOPE_ONELEVEL,
+ ref_attrs,
+ "(&(&(objectClass=crossRef)(dnsRoot=%s))(nETBIOSName=*))",
+ ldb_binary_encode_string(mem_ctx, domain));
if (ret != LDB_SUCCESS) {
DEBUG(2,("Unable to find referece to '%s' in sam: %s\n",
ldb_errstring(sam_ctx)));
return NT_STATUS_NO_SUCH_DOMAIN;
} else if (ref_res->count == 1) {
- talloc_steal(mem_ctx, dom_res);
dom_dn = ldb_msg_find_attr_as_dn(sam_ctx, mem_ctx, ref_res->msgs[0], "ncName");
if (!dom_dn) {
return NT_STATUS_NO_SUCH_DOMAIN;
}
- ret = ldb_search(sam_ctx, dom_dn,
- LDB_SCOPE_BASE, "objectClass=domain",
- dom_attrs, &dom_res);
+ ret = ldb_search(sam_ctx, mem_ctx, &dom_res,
+ dom_dn, LDB_SCOPE_BASE, dom_attrs,
+ "objectClass=domain");
if (ret != LDB_SUCCESS) {
DEBUG(2,("Error finding domain '%s'/'%s' in sam: %s\n", domain, ldb_dn_get_linearized(dom_dn), ldb_errstring(sam_ctx)));
return NT_STATUS_NO_SUCH_DOMAIN;
}
- talloc_steal(mem_ctx, dom_res);
if (dom_res->count != 1) {
DEBUG(2,("Error finding domain '%s'/'%s' in sam\n", domain, ldb_dn_get_linearized(dom_dn)));
return NT_STATUS_NO_SUCH_DOMAIN;
struct ldb_dn *dom_dn;
/* try and find the domain */
- ret = ldb_search_exp_fmt(sam_ctx, mem_ctx, &ref_res,
- partitions_basedn, LDB_SCOPE_ONELEVEL,
- ref_attrs,
- "(&(objectClass=crossRef)(ncName=*)(nETBIOSName=%s))",
- ldb_binary_encode_string(mem_ctx, netbios_domain));
+ ret = ldb_search(sam_ctx, mem_ctx, &ref_res,
+ partitions_basedn, LDB_SCOPE_ONELEVEL,
+ ref_attrs,
+ "(&(objectClass=crossRef)(ncName=*)(nETBIOSName=%s))",
+ ldb_binary_encode_string(mem_ctx, netbios_domain));
if (ret != LDB_SUCCESS) {
DEBUG(2,("Unable to find referece to '%s' in sam: %s\n",
ldb_errstring(sam_ctx)));
return NT_STATUS_NO_SUCH_DOMAIN;
} else if (ref_res->count == 1) {
- talloc_steal(mem_ctx, dom_res);
dom_dn = ldb_msg_find_attr_as_dn(sam_ctx, mem_ctx, ref_res->msgs[0], "ncName");
if (!dom_dn) {
return NT_STATUS_NO_SUCH_DOMAIN;
}
- ret = ldb_search(sam_ctx, dom_dn,
- LDB_SCOPE_BASE, "objectClass=domain",
- dom_attrs, &dom_res);
+ ret = ldb_search(sam_ctx, mem_ctx, &dom_res,
+ dom_dn, LDB_SCOPE_BASE, dom_attrs,
+ "objectClass=domain");
if (ret != LDB_SUCCESS) {
DEBUG(2,("Error finding domain '%s'/'%s' in sam: %s\n", domain, ldb_dn_get_linearized(dom_dn), ldb_errstring(sam_ctx)));
return NT_STATUS_NO_SUCH_DOMAIN;
}
- talloc_steal(mem_ctx, dom_res);
if (dom_res->count != 1) {
DEBUG(2,("Error finding domain '%s'/'%s' in sam\n", domain, ldb_dn_get_linearized(dom_dn)));
return NT_STATUS_NO_SUCH_DOMAIN;
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return NT_STATUS_INVALID_PARAMETER;
}
- ret = ldb_search_exp_fmt(sam_ctx, mem_ctx, &dom_res,
+ ret = ldb_search(sam_ctx, mem_ctx, &dom_res,
NULL, LDB_SCOPE_SUBTREE,
dom_attrs,
"(&(objectCategory=DomainDNS)(objectGUID=%s))",
return NT_STATUS_INVALID_PARAMETER;
}
- ret = ldb_search_exp_fmt(sam_ctx, mem_ctx, &dom_res,
+ ret = ldb_search(sam_ctx, mem_ctx, &dom_res,
NULL, LDB_SCOPE_SUBTREE,
dom_attrs,
"(&(objectCategory=DomainDNS)(objectSID=%s))",
return NT_STATUS_NO_SUCH_DOMAIN;
} else if (dom_res->count == 1) {
/* try and find the domain */
- ret = ldb_search_exp_fmt(sam_ctx, mem_ctx, &ref_res,
+ ret = ldb_search(sam_ctx, mem_ctx, &ref_res,
partitions_basedn, LDB_SCOPE_ONELEVEL,
ref_attrs,
"(&(objectClass=crossRef)(ncName=%s))",
acct_control = acct_control & (ACB_TEMPDUP | ACB_NORMAL | ACB_DOMTRUST | ACB_WSTRUST | ACB_SVRTRUST);
/* We must exclude disabled accounts, but otherwise do the bitwise match the client asked for */
- ret = ldb_search_exp_fmt(sam_ctx, mem_ctx, &user_res,
+ ret = ldb_search(sam_ctx, mem_ctx, &user_res,
dom_res->msgs[0]->dn, LDB_SCOPE_SUBTREE,
none_attrs,
"(&(objectClass=user)(samAccountName=%s)"
server_type |= NBT_SERVER_KDC;
}
- if (!ldb_dn_compare_base(ldb_get_root_basedn(sam_ctx), ldb_get_default_basedn(sam_ctx))) {
+ if (ldb_dn_compare(ldb_get_root_basedn(sam_ctx), ldb_get_default_basedn(sam_ctx)) == 0) {
server_type |= NBT_SERVER_DS_DNS_FOREST;
}
/* could check if the user exists */
if (user_known) {
- netlogon->nt5_ex.command = LOGON_SAM_LOGON_RESPONSE_EX;
+ netlogon->data.nt5_ex.command = LOGON_SAM_LOGON_RESPONSE_EX;
} else {
- netlogon->nt5_ex.command = LOGON_SAM_LOGON_USER_UNKNOWN_EX;
+ netlogon->data.nt5_ex.command = LOGON_SAM_LOGON_USER_UNKNOWN_EX;
}
- netlogon->nt5_ex.server_type = server_type;
- netlogon->nt5_ex.domain_uuid = domain_uuid;
- netlogon->nt5_ex.forest = realm;
- netlogon->nt5_ex.dns_domain = dns_domain;
- netlogon->nt5_ex.pdc_dns_name = pdc_dns_name;
- netlogon->nt5_ex.domain = flatname;
- netlogon->nt5_ex.pdc_name = lp_netbios_name(lp_ctx);
- netlogon->nt5_ex.user_name = user;
- netlogon->nt5_ex.server_site = server_site;
- netlogon->nt5_ex.client_site = client_site;
+ netlogon->data.nt5_ex.server_type = server_type;
+ netlogon->data.nt5_ex.domain_uuid = domain_uuid;
+ netlogon->data.nt5_ex.forest = realm;
+ netlogon->data.nt5_ex.dns_domain = dns_domain;
+ netlogon->data.nt5_ex.pdc_dns_name = pdc_dns_name;
+ netlogon->data.nt5_ex.domain = flatname;
+ netlogon->data.nt5_ex.pdc_name = lp_netbios_name(lp_ctx);
+ netlogon->data.nt5_ex.user_name = user;
+ netlogon->data.nt5_ex.server_site = server_site;
+ netlogon->data.nt5_ex.client_site = client_site;
if (version & NETLOGON_NT_VERSION_5EX_WITH_IP) {
/* Clearly this needs to be fixed up for IPv6 */
extra_flags = NETLOGON_NT_VERSION_5EX_WITH_IP;
- netlogon->nt5_ex.sockaddr.sa_family = 2;
- netlogon->nt5_ex.sockaddr.pdc_ip = pdc_ip;
- netlogon->nt5_ex.sockaddr.remaining = data_blob_talloc_zero(mem_ctx, 8);
+ netlogon->data.nt5_ex.sockaddr.sa_family = 2;
+ netlogon->data.nt5_ex.sockaddr.pdc_ip = pdc_ip;
+ netlogon->data.nt5_ex.sockaddr.remaining = data_blob_talloc_zero(mem_ctx, 8);
}
- netlogon->nt5_ex.nt_version = NETLOGON_NT_VERSION_1|NETLOGON_NT_VERSION_5EX|extra_flags;
- netlogon->nt5_ex.lmnt_token = 0xFFFF;
- netlogon->nt5_ex.lm20_token = 0xFFFF;
+ netlogon->data.nt5_ex.nt_version = NETLOGON_NT_VERSION_1|NETLOGON_NT_VERSION_5EX|extra_flags;
+ netlogon->data.nt5_ex.lmnt_token = 0xFFFF;
+ netlogon->data.nt5_ex.lm20_token = 0xFFFF;
} else if (version & NETLOGON_NT_VERSION_5) {
netlogon->ntver = NETLOGON_NT_VERSION_5;
/* could check if the user exists */
if (user_known) {
- netlogon->nt5.command = LOGON_SAM_LOGON_RESPONSE;
+ netlogon->data.nt5.command = LOGON_SAM_LOGON_RESPONSE;
} else {
- netlogon->nt5.command = LOGON_SAM_LOGON_USER_UNKNOWN;
+ netlogon->data.nt5.command = LOGON_SAM_LOGON_USER_UNKNOWN;
}
- netlogon->nt5.pdc_name = pdc_name;
- netlogon->nt5.user_name = user;
- netlogon->nt5.domain_name = flatname;
- netlogon->nt5.domain_uuid = domain_uuid;
- netlogon->nt5.forest = realm;
- netlogon->nt5.dns_domain = dns_domain;
- netlogon->nt5.pdc_dns_name = pdc_dns_name;
- netlogon->nt5.pdc_ip = pdc_ip;
- netlogon->nt5.server_type = server_type;
- netlogon->nt5.nt_version = NETLOGON_NT_VERSION_1|NETLOGON_NT_VERSION_5;
- netlogon->nt5.lmnt_token = 0xFFFF;
- netlogon->nt5.lm20_token = 0xFFFF;
+ netlogon->data.nt5.pdc_name = pdc_name;
+ netlogon->data.nt5.user_name = user;
+ netlogon->data.nt5.domain_name = flatname;
+ netlogon->data.nt5.domain_uuid = domain_uuid;
+ netlogon->data.nt5.forest = realm;
+ netlogon->data.nt5.dns_domain = dns_domain;
+ netlogon->data.nt5.pdc_dns_name = pdc_dns_name;
+ netlogon->data.nt5.pdc_ip = pdc_ip;
+ netlogon->data.nt5.server_type = server_type;
+ netlogon->data.nt5.nt_version = NETLOGON_NT_VERSION_1|NETLOGON_NT_VERSION_5;
+ netlogon->data.nt5.lmnt_token = 0xFFFF;
+ netlogon->data.nt5.lm20_token = 0xFFFF;
} else /* (version & NETLOGON_NT_VERSION_1) and all other cases */ {
netlogon->ntver = NETLOGON_NT_VERSION_1;
/* could check if the user exists */
if (user_known) {
- netlogon->nt4.command = LOGON_SAM_LOGON_RESPONSE;
+ netlogon->data.nt4.command = LOGON_SAM_LOGON_RESPONSE;
} else {
- netlogon->nt4.command = LOGON_SAM_LOGON_USER_UNKNOWN;
+ netlogon->data.nt4.command = LOGON_SAM_LOGON_USER_UNKNOWN;
}
- netlogon->nt4.server = pdc_name;
- netlogon->nt4.user_name = user;
- netlogon->nt4.domain = flatname;
- netlogon->nt4.nt_version = NETLOGON_NT_VERSION_1;
- netlogon->nt4.lmnt_token = 0xFFFF;
- netlogon->nt4.lm20_token = 0xFFFF;
+ netlogon->data.nt4.server = pdc_name;
+ netlogon->data.nt4.user_name = user;
+ netlogon->data.nt4.domain = flatname;
+ netlogon->data.nt4.nt_version = NETLOGON_NT_VERSION_1;
+ netlogon->data.nt4.lmnt_token = 0xFFFF;
+ netlogon->data.nt4.lm20_token = 0xFFFF;
}
return NT_STATUS_OK;
attrs[i] = NULL;
}
- lreq = talloc(mem_ctx, struct ldb_request);
- if (lreq == NULL) goto nomem;
-
res = talloc_zero(mem_ctx, struct ldb_result);
if (res == NULL) goto nomem;
- lreq->operation = LDB_SEARCH;
- lreq->op.search.base = basedn;
- lreq->op.search.scope = scope;
- lreq->op.search.tree = search->tree;
- lreq->op.search.attrs = attrs;
-
- lreq->controls = NULL;
+ ldb_ret = ldb_build_search_req_ex(&lreq, cldapd->samctx, mem_ctx,
+ basedn, scope,
+ search->tree, attrs,
+ NULL,
+ res, ldb_search_default_callback,
+ NULL);
- lreq->context = res;
- lreq->callback = ldb_search_default_callback;
+ if (ldb_ret != LDB_SUCCESS) {
+ goto reply;
+ }
/* Copy the timeout from the incoming call */
ldb_set_timeout(cldapd->samctx, lreq, search->timelimit);
static struct dd_iohandle * open_file(struct resolve_context *resolve_ctx,
struct event_context *ev,
const char * which, const char **ports,
- struct smbcli_options *smb_options)
+ struct smbcli_options *smb_options,
+ struct smbcli_session_options *smb_session_options)
{
int options = 0;
const char * path = NULL;
path = check_arg_pathname("if");
handle = dd_open_path(resolve_ctx, ev, path, ports,
check_arg_numeric("ibs"), options,
- smb_options);
+ smb_options, smb_session_options);
} else if (strcmp(which, "of") == 0) {
options |= DD_WRITE;
path = check_arg_pathname("of");
handle = dd_open_path(resolve_ctx, ev, path, ports,
check_arg_numeric("obs"), options,
- smb_options);
+ smb_options, smb_session_options);
} else {
SMB_ASSERT(0);
return(NULL);
struct dd_iohandle * ofile;
struct smbcli_options options;
+ struct smbcli_session_options session_options;
ibs = check_arg_numeric("ibs");
obs = check_arg_numeric("obs");
count = check_arg_numeric("count");
lp_smbcli_options(lp_ctx, &options);
+ lp_smbcli_session_options(lp_ctx, &session_options);
/* Allocate IO buffer. We need more than the max IO size because we
* could accumulate a remainder if ibs and obs don't match.
(unsigned long long)iomax, options.max_xmit));
if (!(ifile = open_file(lp_resolve_context(lp_ctx), ev, "if",
- lp_smb_ports(lp_ctx), &options))) {
+ lp_smb_ports(lp_ctx), &options,
+ &session_options))) {
return(FILESYS_EXIT_CODE);
}
if (!(ofile = open_file(lp_resolve_context(lp_ctx), ev, "of",
- lp_smb_ports(lp_ctx), &options))) {
+ lp_smb_ports(lp_ctx), &options,
+ &session_options))) {
return(FILESYS_EXIT_CODE);
}
#define DD_OPLOCK 0x00000008
struct smbcli_options;
+struct smbcli_session_options;
struct event_context;
struct dd_iohandle * dd_open_path(struct resolve_context *resolve_ctx,
const char * path,
const char **ports,
uint64_t io_size, int options,
- struct smbcli_options *smb_options);
+ struct smbcli_options *smb_options,
+ struct smbcli_session_options *smb_session_options);
bool dd_fill_block(struct dd_iohandle * h, uint8_t * buf,
uint64_t * buf_size, uint64_t need_size, uint64_t block_size);
bool dd_flush_block(struct dd_iohandle * h, uint8_t * buf,
const char * host,
const char **ports,
const char * share,
- struct smbcli_options *options)
+ struct smbcli_options *options,
+ struct smbcli_session_options *session_options)
{
NTSTATUS ret;
struct smbcli_state * cli = NULL;
ret = smbcli_full_connection(NULL, &cli, host, ports, share,
NULL /* devtype */,
cmdline_credentials, resolve_ctx,
- ev, options);
+ ev, options,
+ session_options);
if (!NT_STATUS_IS_OK(ret)) {
fprintf(stderr, "%s: connecting to //%s/%s: %s\n",
const char * path,
uint64_t io_size,
int options,
- struct smbcli_options *smb_options)
+ struct smbcli_options *smb_options,
+ struct smbcli_session_options *smb_session_options)
{
struct cifs_handle * smbh;
smbh->h.io_seek = smb_seek_func;
if ((smbh->cli = init_smb_session(resolve_ctx, ev, host, ports, share,
- smb_options)) == NULL) {
+ smb_options, smb_session_options)) == NULL) {
return(NULL);
}
const char **ports,
uint64_t io_size,
int options,
- struct smbcli_options *smb_options)
+ struct smbcli_options *smb_options,
+ struct smbcli_session_options *smb_session_options)
{
if (file_exist(path)) {
return(open_fd_handle(path, io_size, options));
return(open_cifs_handle(resolve_ctx, ev, host, ports,
share, remain,
- io_size, options, smb_options));
+ io_size, options, smb_options,
+ smb_session_options));
}
return(open_fd_handle(path, io_size, options));
const char *specified_server, const char **ports,
const char *specified_share,
struct cli_credentials *cred,
- struct smbcli_options *options)
+ struct smbcli_options *options,
+ struct smbcli_session_options *session_options)
{
NTSTATUS status;
char *server, *share;
status = smbcli_full_connection(ctx, &ctx->cli, server, ports,
share, NULL, cred, resolve_ctx,
- ev_ctx, options);
+ ev_ctx, options, session_options);
if (!NT_STATUS_IS_OK(status)) {
d_printf("Connection to \\\\%s\\%s failed - %s\n",
server, share, nt_errstr(status));
struct smbclient_context *ctx;
const char *cmdstr = NULL;
struct smbcli_options smb_options;
+ struct smbcli_session_options smb_session_options;
struct poptOption long_options[] = {
POPT_AUTOHELP
poptFreeContext(pc);
lp_smbcli_options(cmdline_lp_ctx, &smb_options);
+ lp_smbcli_session_options(cmdline_lp_ctx, &smb_session_options);
ev_ctx = s4_event_context_init(talloc_autofree_context());
if (!do_connect(ctx, ev_ctx, lp_resolve_context(cmdline_lp_ctx),
desthost, lp_smb_ports(cmdline_lp_ctx), service,
- cmdline_credentials, &smb_options))
+ cmdline_credentials, &smb_options, &smb_session_options))
return 1;
if (base_directory)
/*****************************************************
return a connection to a server
*******************************************************/
-static struct smbcli_state *do_connection(const char *the_service, bool unicode, int maxprotocol)
+static struct smbcli_state *do_connection(const char *the_service, bool unicode, int maxprotocol,
+ struct smbcli_session_options session_options)
{
struct smbcli_state *c;
struct nmb_name called, calling;
if (!smbcli_session_setup(c, username,
password, strlen(password),
password, strlen(password),
- workgroup)) {
+ workgroup, session_options)) {
/* if a password was not supplied then try again with a
null username */
if (password[0] || !username[0] ||
- !smbcli_session_setup(c, "", "", 0, "", 0, workgroup)) {
+ !smbcli_session_setup(c, "", "", 0, "", 0, workgroup,
+ session_options)) {
DEBUG(0,("%d: session setup failed: %s\n",
sys_getpid(), smbcli_errstr(c)));
talloc_free(c);
int fd, closed = 0, res = 1;
pid_t parentpid = getppid();
struct smb_conn_opt conn_options;
+ struct smbcli_session_options session_options;
+
+ lp_smbcli_session_options(lp_ctx, &session_options);
memset(&conn_options, 0, sizeof(conn_options));
DEBUG(2,("mount.smbfs[%d]: got signal, getting new socket\n", sys_getpid()));
c = do_connection(the_service,
lp_unicode(lp_ctx),
- lp_cli_maxprotocol(lp_ctx));
+ lp_cli_maxprotocol(lp_ctx),
+ session_options);
}
}
struct smbcli_state *c;
char *args[20];
int i, status;
+ struct smbcli_session_options session_options;
if (realpath(mpoint, mount_point) == NULL) {
fprintf(stderr, "Could not resolve mount point %s\n", mpoint);
return;
}
+ lp_smbcli_session_options(lp_ctx, &session_options);
- c = do_connection(service, lp_unicode(lp_ctx), lp_cli_maxprotocol(lp_ctx));
+ c = do_connection(service, lp_unicode(lp_ctx), lp_cli_maxprotocol(lp_ctx),
+ session_options);
if (!c) {
fprintf(stderr,"SMB connection failed\n");
exit(1);
#!/bin/sh
-killall smbd
+killall samba
sleep 1
-killall -9 smbd
+killall -9 samba
killall -9 valgrind
type=$1
-xterm -e $type bin/smbd -s /home/tridge/samba/samba4.svn/prefix/etc/smb.conf.node1 -M single -i &
-xterm -e $type bin/smbd -s /home/tridge/samba/samba4.svn/prefix/etc/smb.conf.node2 -M single -i &
+xterm -e $type bin/samba -s /home/tridge/samba/samba4.svn/prefix/etc/smb.conf.node1 -M single -i &
+xterm -e $type bin/samba -s /home/tridge/samba/samba4.svn/prefix/etc/smb.conf.node2 -M single -i &
]
)
-SMB_EXT_LIB_FROM_PKGCONFIG(LIBTDB, tdb >= 1.1.0,
+SMB_EXT_LIB_FROM_PKGCONFIG(LIBTDB, tdb >= 1.1.3,
[],
[
m4_include(../lib/tdb/libtdb.m4)
m4_include(auth/config.m4)
m4_include(kdc/config.m4)
m4_include(ntvfs/sysdep/config.m4)
-m4_include(lib/appweb/config.m4)
m4_include(nsswitch/config.m4)
#################################################
goto failed;
}
- ret = ldb_search_exp_fmt(ldb, tmp_ctx, &res, ldb_get_default_basedn(ldb), LDB_SCOPE_BASE, attrs, "objectSid=*");
+ ret = ldb_search(ldb, tmp_ctx, &res, ldb_get_default_basedn(ldb), LDB_SCOPE_BASE, attrs, "objectSid=*");
if (ret != LDB_SUCCESS) {
goto failed;
}
- ret = ldb_search(ldb, ldb_dn_new(tmp_ctx, ldb, ""), LDB_SCOPE_BASE, NULL, root_attrs, &root_res);
+ ret = ldb_search(ldb, tmp_ctx, &root_res, ldb_dn_new(tmp_ctx, ldb, ""), LDB_SCOPE_BASE, root_attrs, NULL);
if (ret) {
DEBUG(1,("Searching for dsServiceName in rootDSE failed: %s\n",
ldb_errstring(ldb)));
goto failed;
}
- talloc_steal(tmp_ctx, root_res);
if (root_res->count != 1) {
goto failed;
goto failed;
}
- ret = ldb_search(ldb, samdb_ntds_settings_dn(ldb), LDB_SCOPE_BASE, NULL, attrs, &res);
+ ret = ldb_search(ldb, tmp_ctx, &res, samdb_ntds_settings_dn(ldb), LDB_SCOPE_BASE, attrs, NULL);
if (ret) {
goto failed;
}
- talloc_steal(tmp_ctx, res);
if (res->count != 1) {
goto failed;
goto failed;
}
- ret = ldb_search(ldb, samdb_ntds_settings_dn(ldb), LDB_SCOPE_BASE, NULL, attrs, &res);
+ ret = ldb_search(ldb, tmp_ctx, &res, samdb_ntds_settings_dn(ldb), LDB_SCOPE_BASE, attrs, NULL);
if (ret) {
goto failed;
}
- talloc_steal(tmp_ctx, res);
if (res->count != 1) {
goto failed;
return false;
}
- ret = ldb_search(ldb, ldb_get_default_basedn(ldb), LDB_SCOPE_BASE, NULL, dom_attrs, &dom_res);
+ ret = ldb_search(ldb, tmp_ctx, &dom_res, ldb_get_default_basedn(ldb), LDB_SCOPE_BASE, dom_attrs, NULL);
if (ret) {
DEBUG(1,("Searching for fSMORoleOwner in %s failed: %s\n",
ldb_dn_get_linearized(ldb_get_default_basedn(ldb)),
ldb_errstring(ldb)));
goto failed;
}
- talloc_steal(tmp_ctx, dom_res);
if (dom_res->count != 1) {
goto failed;
}
}
/* Query cn=ntds settings,.... */
- ret = ldb_search(ldb, samdb_ntds_settings_dn(ldb), LDB_SCOPE_BASE, NULL, attrs, &res);
+ ret = ldb_search(ldb, tmp_ctx, &res, samdb_ntds_settings_dn(ldb), LDB_SCOPE_BASE, attrs, NULL);
if (ret) {
+ talloc_free(tmp_ctx);
return false;
}
if (res->count != 1) {
- talloc_free(res);
+ talloc_free(tmp_ctx);
return false;
}
options = ldb_msg_find_attr_as_int(res->msgs[0], "options", 0);
- talloc_free(res);
talloc_free(tmp_ctx);
/* if options attribute has the 0x00000001 flag set, then enable the global catlog */
if (local_ctx == NULL) return LDB_ERR_OPERATIONS_ERROR;
while ((sdn = ldb_dn_get_parent(local_ctx, sdn))) {
- ret = ldb_search(ldb, sdn, LDB_SCOPE_BASE,
- "(|(|(objectClass=domain)(objectClass=builtinDomain))(objectClass=samba4LocalDomain))", attrs, &res);
+ ret = ldb_search(ldb, local_ctx, &res, sdn, LDB_SCOPE_BASE, attrs,
+ "(|(|(objectClass=domain)(objectClass=builtinDomain))(objectClass=samba4LocalDomain))");
if (ret == LDB_SUCCESS) {
- talloc_steal(local_ctx, res);
if (res->count == 1) {
break;
}
struct ldb_result *res_domain_ref;
char *escaped_domain = ldb_binary_encode_string(mem_ctx, domain_name);
/* find the domain's DN */
- int ret_domain = ldb_search_exp_fmt(ldb, mem_ctx,
+ int ret_domain = ldb_search(ldb, mem_ctx,
&res_domain_ref,
samdb_partitions_dn(ldb, mem_ctx),
LDB_SCOPE_ONELEVEL,
}
if (res_domain_ref->count == 0) {
- ret_domain = ldb_search_exp_fmt(ldb, mem_ctx,
+ ret_domain = ldb_search(ldb, mem_ctx,
&res_domain_ref,
samdb_dns_domain_to_dn(ldb, mem_ctx, domain_name),
LDB_SCOPE_BASE,
# Start SUBSYSTEM DREPL_SRV
[MODULE::DREPL_SRV]
INIT_FUNCTION = server_service_drepl_init
-SUBSYSTEM = smbd
+SUBSYSTEM = samba
PRIVATE_DEPENDENCIES = \
SAMDB \
process_model
basedn = ldb_dn_new(s, s->samdb, NULL);
W_ERROR_HAVE_NO_MEMORY(basedn);
- ret = ldb_search(s->samdb, basedn, LDB_SCOPE_BASE,
- "(objectClass=*)", attrs, &r);
+ ret = ldb_search(s->samdb, s, &r, basedn, LDB_SCOPE_BASE, attrs,
+ "(objectClass=*)");
talloc_free(basedn);
if (ret != LDB_SUCCESS) {
return WERR_FOOBAR;
talloc_free(r);
return WERR_FOOBAR;
}
- talloc_steal(s, r);
el = ldb_msg_find_element(r->msgs[0], "namingContexts");
if (!el) {
DEBUG(2, ("dreplsrv_refresh_partition(%s)\n",
ldb_dn_get_linearized(p->dn)));
- ret = ldb_search(s->samdb, p->dn, LDB_SCOPE_BASE,
- "(objectClass=*)", attrs, &r);
+ ret = ldb_search(s->samdb, mem_ctx, &r, p->dn, LDB_SCOPE_BASE, attrs,
+ "(objectClass=*)");
if (ret != LDB_SUCCESS) {
return WERR_FOOBAR;
} else if (r->count != 1) {
talloc_free(r);
return WERR_FOOBAR;
}
- talloc_steal(mem_ctx, r);
ZERO_STRUCT(p->nc);
p->nc.dn = ldb_dn_alloc_linearized(p, p->dn);
#include "librpc/gen_ndr/ndr_misc.h"
#include "librpc/gen_ndr/ndr_drsuapi.h"
#include "librpc/gen_ndr/ndr_drsblobs.h"
-#include "lib/crypto/crypto.h"
+#include "../lib/crypto/crypto.h"
#include "libcli/auth/libcli_auth.h"
#include "param/param.h"
return DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR;
}
- ret = ldb_search(ldb_ctx, service_dn, LDB_SCOPE_BASE, "(objectClass=nTDSService)",
- directory_attrs, &res);
+ ret = ldb_search(ldb_ctx, tmp_ctx, &res, service_dn, LDB_SCOPE_BASE,
+ directory_attrs, "(objectClass=nTDSService)");
if (ret != LDB_SUCCESS && ret != LDB_ERR_NO_SUCH_OBJECT) {
DEBUG(1, ("ldb_search: dn: %s not found: %s", service_dn_str, ldb_errstring(ldb_ctx)));
DEBUG(1, ("ldb_search: dn: %s not found", service_dn_str));
return DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
}
- talloc_steal(tmp_ctx, res);
spnmappings = ldb_msg_find_element(res->msgs[0], "sPNMappings");
if (!spnmappings || spnmappings->num_values == 0) {
realm = krb5_princ_realm(smb_krb5_context->krb5_context, principal);
- ldb_ret = ldb_search_exp_fmt(sam_ctx, mem_ctx, &domain_res,
+ ldb_ret = ldb_search(sam_ctx, mem_ctx, &domain_res,
samdb_partitions_dn(sam_ctx, mem_ctx),
LDB_SCOPE_ONELEVEL,
domain_attrs,
const char *result_filter = NULL;
struct ldb_dn *name_dn = NULL;
- struct smb_krb5_context *smb_krb5_context;
- ret = smb_krb5_init_context(mem_ctx,
- ldb_get_event_context(sam_ctx),
- (struct loadparm_context *)ldb_get_opaque(sam_ctx, "loadparm"),
- &smb_krb5_context);
-
- if (ret) {
- return WERR_NOMEM;
- }
+ struct smb_krb5_context *smb_krb5_context = NULL;
info1->status = DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR;
info1->dns_domain_name = NULL;
/* here we need to set the domain_filter and/or the result_filter */
switch (format_offered) {
+ case DRSUAPI_DS_NAME_FORMAT_UNKNOWN:
+ {
+ int i;
+ enum drsuapi_DsNameFormat formats[] = {
+ DRSUAPI_DS_NAME_FORMAT_FQDN_1779, DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL,
+ DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT, DRSUAPI_DS_NAME_FORMAT_CANONICAL,
+ DRSUAPI_DS_NAME_FORMAT_GUID, DRSUAPI_DS_NAME_FORMAT_DISPLAY,
+ DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL,
+ DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY,
+ DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX
+ };
+ WERROR werr;
+ for (i=0; i < ARRAY_SIZE(formats); i++) {
+ werr = DsCrackNameOneName(sam_ctx, mem_ctx, format_flags, formats[i], format_desired, name, info1);
+ if (!W_ERROR_IS_OK(werr)) {
+ return werr;
+ }
+ if (info1->status != DRSUAPI_DS_NAME_STATUS_NOT_FOUND) {
+ return werr;
+ }
+ }
+ return werr;
+ }
+
case DRSUAPI_DS_NAME_FORMAT_CANONICAL:
case DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX:
{
case DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL: {
krb5_principal principal;
char *unparsed_name;
+
+ ret = smb_krb5_init_context(mem_ctx,
+ ldb_get_event_context(sam_ctx),
+ (struct loadparm_context *)ldb_get_opaque(sam_ctx, "loadparm"),
+ &smb_krb5_context);
+
+ if (ret) {
+ return WERR_NOMEM;
+ }
+
ret = krb5_parse_name(smb_krb5_context->krb5_context, name, &principal);
if (ret) {
info1->status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
krb5_principal principal;
char *unparsed_name_short;
char *service;
+
+ ret = smb_krb5_init_context(mem_ctx,
+ ldb_get_event_context(sam_ctx),
+ (struct loadparm_context *)ldb_get_opaque(sam_ctx, "loadparm"),
+ &smb_krb5_context);
+
+ if (ret) {
+ return WERR_NOMEM;
+ }
+
ret = krb5_parse_name(smb_krb5_context->krb5_context, name, &principal);
if (ret == 0 && principal->name.name_string.len < 2) {
info1->status = DRSUAPI_DS_NAME_STATUS_NOT_FOUND;
if (domain_filter) {
/* if we have a domain_filter look it up and set the result_basedn and the dns_domain_name */
- ldb_ret = ldb_search_exp_fmt(sam_ctx, mem_ctx, &domain_res,
+ ldb_ret = ldb_search(sam_ctx, mem_ctx, &domain_res,
partitions_basedn,
LDB_SCOPE_ONELEVEL,
domain_attrs,
if (domain_res) {
result_basedn = samdb_result_dn(sam_ctx, mem_ctx, domain_res->msgs[0], "ncName", NULL);
- ret = ldb_search_exp_fmt(sam_ctx, mem_ctx, &res,
+ ret = ldb_search(sam_ctx, mem_ctx, &res,
result_basedn, LDB_SCOPE_SUBTREE,
result_attrs, "%s", result_filter);
if (ret != LDB_SUCCESS) {
result_attrs,
NULL,
res,
- ldb_search_default_callback);
+ ldb_search_default_callback,
+ NULL);
if (ret == LDB_SUCCESS) {
struct ldb_search_options_control *search_options;
search_options = talloc(req, struct ldb_search_options_control);
return WERR_OK;
}
- ldb_set_timeout(sam_ctx, req, 0); /* use default timeout */
-
ret = ldb_request(sam_ctx, req);
if (ret == LDB_SUCCESS) {
if (samdb_find_attribute(sam_ctx, result, "objectClass", "domain")) {
- ldb_ret = ldb_search_exp_fmt(sam_ctx, mem_ctx, &domain_res,
+ ldb_ret = ldb_search(sam_ctx, mem_ctx, &domain_res,
partitions_basedn,
LDB_SCOPE_ONELEVEL,
domain_attrs,
return WERR_OK;
}
dom_sid->num_auths--;
- ldb_ret = ldb_search_exp_fmt(sam_ctx, mem_ctx, &domain_res,
+ ldb_ret = ldb_search(sam_ctx, mem_ctx, &domain_res,
NULL,
LDB_SCOPE_BASE,
attrs,
return WERR_OK;
}
- ldb_ret = ldb_search_exp_fmt(sam_ctx, mem_ctx, &domain_res2,
+ ldb_ret = ldb_search(sam_ctx, mem_ctx, &domain_res2,
partitions_basedn,
LDB_SCOPE_ONELEVEL,
domain_attrs,
const char **nt4_domain,
const char **nt4_account)
{
- uint32_t format_offered = DRSUAPI_DS_NAME_FORMAT_UKNOWN;
+ uint32_t format_offered = DRSUAPI_DS_NAME_FORMAT_UNKNOWN;
/* Handle anonymous bind */
if (!name || !*name) {
format_offered = DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT;
} else if (strchr_m(name, '/')) {
format_offered = DRSUAPI_DS_NAME_FORMAT_CANONICAL;
+ } else {
+ return NT_STATUS_NO_SUCH_USER;
}
return crack_name_to_nt4_name(mem_ctx, ev_ctx, lp_ctx, format_offered, name, nt4_domain, nt4_account);
/*
ldb database library
- Copyright (C) Amdrew Bartlett <abartlet@samba.org> 2007
+ Copyright (C) Andrew Bartlett <abartlet@samba.org> 2007
+ Copyright (C) Simo Sorce <idra@samba.org> 2008
Copyright (C) Andrew Tridgell 2004
This program is free software; you can redistribute it and/or modify
struct anr_context {
bool found_anr;
struct ldb_module *module;
+ struct ldb_request *req;
};
/**
* parse tree with an 'or' of all the anr attributes in the schema.
*/
-typedef struct ldb_parse_tree *(*anr_parse_tree_callback_t)(TALLOC_CTX *mem_ctx,
- const struct ldb_val *match,
- void *context);
-
-
/**
- * Callback function to do the heavy lifting for the for the parse tree walker
+ * Callback function to do the heavy lifting for the parse tree walker
*/
-struct ldb_parse_tree *anr_replace_callback(TALLOC_CTX *mem_ctx,
- const struct ldb_val *match,
- void *context)
+static int anr_replace_value(struct anr_context *ac,
+ TALLOC_CTX *mem_ctx,
+ const struct ldb_val *match,
+ struct ldb_parse_tree **ntree)
{
struct ldb_parse_tree *tree = NULL;
- struct anr_context *anr_context = talloc_get_type(context, struct anr_context);
- struct ldb_module *module = anr_context->module;
+ struct ldb_module *module = ac->module;
struct ldb_parse_tree *match_tree;
- uint8_t *p;
- enum ldb_parse_op op;
struct dsdb_attribute *cur;
const struct dsdb_schema *schema = dsdb_get_schema(module->ldb);
+ uint8_t *p;
+ enum ldb_parse_op op;
+
if (!schema) {
ldb_asprintf_errstring(module->ldb, "no schema with which to construct anr filter");
- return NULL;
+ return LDB_ERR_OPERATIONS_ERROR;
}
- anr_context->found_anr = true;
+ ac->found_anr = true;
if (match->length > 1 && match->data[0] == '=') {
- DATA_BLOB *match2 = talloc(tree, DATA_BLOB);
+ DATA_BLOB *match2 = talloc(mem_ctx, DATA_BLOB);
*match2 = data_blob_const(match->data+1, match->length - 1);
if (match2 == NULL){
ldb_oom(module->ldb);
- return NULL;
+ return LDB_ERR_OPERATIONS_ERROR;
}
match = match2;
op = LDB_OP_EQUALITY;
tree = make_parse_list(module, mem_ctx, LDB_OP_OR, tree, match_tree);
if (tree == NULL) {
ldb_oom(module->ldb);
- return NULL;
+ return LDB_ERR_OPERATIONS_ERROR;
}
} else {
tree = match_tree;
DATA_BLOB *second_match = talloc(tree, DATA_BLOB);
if (!first_match || !second_match) {
ldb_oom(module->ldb);
- return NULL;
+ return LDB_ERR_OPERATIONS_ERROR;
}
*first_match = data_blob_const(match->data, p-match->data);
*second_match = data_blob_const(p+1, match->length - (p-match->data) - 1);
match_tree_1 = make_match_tree(module, mem_ctx, op, "givenName", first_match);
match_tree_2 = make_match_tree(module, mem_ctx, op, "sn", second_match);
- first_split_filter = make_parse_list(module, context, LDB_OP_AND, match_tree_1, match_tree_2);
+ first_split_filter = make_parse_list(module, ac, LDB_OP_AND, match_tree_1, match_tree_2);
if (first_split_filter == NULL){
ldb_oom(module->ldb);
- return NULL;
+ return LDB_ERR_OPERATIONS_ERROR;
}
match_tree_1 = make_match_tree(module, mem_ctx, op, "sn", first_match);
match_tree_2 = make_match_tree(module, mem_ctx, op, "givenName", second_match);
- second_split_filter = make_parse_list(module, context, LDB_OP_AND, match_tree_1, match_tree_2);
+ second_split_filter = make_parse_list(module, ac, LDB_OP_AND, match_tree_1, match_tree_2);
if (second_split_filter == NULL){
ldb_oom(module->ldb);
- return NULL;
+ return LDB_ERR_OPERATIONS_ERROR;
}
split_filters = make_parse_list(module, mem_ctx, LDB_OP_OR,
first_split_filter, second_split_filter);
if (split_filters == NULL) {
ldb_oom(module->ldb);
- return NULL;
+ return LDB_ERR_OPERATIONS_ERROR;
}
if (tree) {
tree = split_filters;
}
}
- return tree;
+ *ntree = tree;
+ return LDB_SUCCESS;
}
/*
replace any occurances of an attribute with a new, generated attribute tree
*/
-struct ldb_parse_tree *anr_replace_subtrees(struct ldb_parse_tree *tree,
- const char *attr,
- anr_parse_tree_callback_t callback,
- void *context)
+static int anr_replace_subtrees(struct anr_context *ac,
+ struct ldb_parse_tree *tree,
+ const char *attr,
+ struct ldb_parse_tree **ntree)
{
+ int ret;
int i;
- struct ldb_parse_tree *tmp;
switch (tree->operation) {
case LDB_OP_AND:
case LDB_OP_OR:
for (i=0;i<tree->u.list.num_elements;i++) {
- tmp = anr_replace_subtrees(tree->u.list.elements[i],
- attr, callback, context);
- if (tmp) tree->u.list.elements[i] = tmp;
+ ret = anr_replace_subtrees(ac, tree->u.list.elements[i],
+ attr, &tree->u.list.elements[i]);
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
+ *ntree = tree;
}
break;
case LDB_OP_NOT:
- tmp = anr_replace_subtrees(tree->u.isnot.child, attr, callback, context);
- if (tmp) tree->u.isnot.child = tmp;
+ ret = anr_replace_subtrees(ac, tree->u.isnot.child, attr, &tree->u.isnot.child);
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
+ *ntree = tree;
break;
case LDB_OP_EQUALITY:
if (ldb_attr_cmp(tree->u.equality.attr, attr) == 0) {
- tmp = callback(tree, &tree->u.equality.value,
- context);
- if (tmp) tree = tmp;
+ ret = anr_replace_value(ac, tree, &tree->u.equality.value, ntree);
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
}
break;
case LDB_OP_SUBSTRING:
tree->u.substring.end_with_wildcard == 1 &&
tree->u.substring.chunks[0] != NULL &&
tree->u.substring.chunks[1] == NULL) {
- tmp = callback(tree, tree->u.substring.chunks[0], context);
- if (tmp) tree = tmp;
+ ret = anr_replace_value(ac, tree, tree->u.substring.chunks[0], ntree);
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
}
}
break;
+ default:
+ break;
+ }
+
+ return LDB_SUCCESS;
+}
+
+static int anr_search_callback(struct ldb_request *req, struct ldb_reply *ares)
+{
+ struct anr_context *ac;
+
+ ac = talloc_get_type(req->context, struct anr_context);
+
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
+
+ switch (ares->type) {
+ case LDB_REPLY_ENTRY:
+ return ldb_module_send_entry(ac->req, ares->message);
+
+ case LDB_REPLY_REFERRAL:
+ return ldb_module_send_referral(ac->req, ares->referral);
+
+ case LDB_REPLY_DONE:
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, LDB_SUCCESS);
+
}
- return tree;
+ return LDB_SUCCESS;
}
/* search */
static int anr_search(struct ldb_module *module, struct ldb_request *req)
{
struct ldb_parse_tree *anr_tree;
- struct anr_context *context = talloc(req, struct anr_context);
- if (!context) {
+ struct ldb_request *down_req;
+ struct anr_context *ac;
+ int ret;
+
+ ac = talloc(req, struct anr_context);
+ if (!ac) {
ldb_oom(module->ldb);
return LDB_ERR_OPERATIONS_ERROR;
}
- context->module = module;
- context->found_anr = false;
+ ac->module = module;
+ ac->req = req;
+ ac->found_anr = false;
#if 0
printf("oldanr : %s\n", ldb_filter_from_tree (0, req->op.search.tree));
#endif
- /* Yes, this is a problem with req->op.search.tree being const... */
- anr_tree = anr_replace_subtrees(req->op.search.tree, "anr", anr_replace_callback, context);
- if (!anr_tree) {
- talloc_free(context);
+ ret = anr_replace_subtrees(ac, req->op.search.tree, "anr", &anr_tree);
+ if (ret != LDB_SUCCESS) {
return LDB_ERR_OPERATIONS_ERROR;
}
- if (context->found_anr) {
- /* The above function modifies the tree if it finds "anr", so no
- * point just setting this on the down_req */
-#if 0
- printf("newtree: %s\n", ldb_filter_from_tree (0, anr_tree));
-#endif
- req->op.search.tree = talloc_steal(req, anr_tree);
- } else {
- if (anr_tree != req->op.search.tree) {
- talloc_free(anr_tree);
- }
- talloc_free(context);
+ if (!ac->found_anr) {
+ talloc_free(ac);
+ return ldb_next_request(module, req);
}
- return ldb_next_request(module, req);
+
+ ret = ldb_build_search_req_ex(&down_req,
+ module->ldb, ac,
+ req->op.search.base,
+ req->op.search.scope,
+ anr_tree,
+ req->op.search.attrs,
+ req->controls,
+ ac, anr_search_callback,
+ req);
+ if (ret != LDB_SUCCESS) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ talloc_steal(down_req, anr_tree);
+
+ return ldb_next_request(module, down_req);
}
_PUBLIC_ const struct ldb_module_ops ldb_anr_module_ops = {
/*
ldb database library
- Copyright (C) Simo Sorce 2005
+ Copyright (C) Simo Sorce 2005-2008
** NOTE! The following LGPL license applies to the ldb
** library. This does NOT imply that all of Samba is released
return true;
}
-static bool inject_extended_dn(struct ldb_message *msg,
+static int inject_extended_dn(struct ldb_message *msg,
struct ldb_context *ldb,
int type,
bool remove_guid,
guid_blob = ldb_msg_find_ldb_val(msg, "objectGUID");
sid_blob = ldb_msg_find_ldb_val(msg, "objectSID");
- if (!guid_blob)
- return false;
+ if (!guid_blob) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
switch (type) {
case 0:
const char *lower_guid_hex = strlower_talloc(msg, data_blob_hex_string(msg, guid_blob));
const char *lower_sid_hex = strlower_talloc(msg, data_blob_hex_string(msg, sid_blob));
if (!lower_guid_hex || !lower_sid_hex) {
- return false;
+ return LDB_ERR_OPERATIONS_ERROR;
}
new_dn = talloc_asprintf(msg, "<GUID=%s>;<SID=%s>;%s",
lower_guid_hex,
} else {
const char *lower_guid_hex = strlower_talloc(msg, data_blob_hex_string(msg, guid_blob));
if (!lower_guid_hex) {
- return false;
+ return LDB_ERR_OPERATIONS_ERROR;
}
new_dn = talloc_asprintf(msg, "<GUID=%s>;%s",
lower_guid_hex,
if (sid) {
object_sid = dom_sid_string(msg, sid);
if (!object_sid)
- return false;
-
+ return LDB_ERR_OPERATIONS_ERROR;
+
}
/* Normal, sane format */
}
break;
default:
- return false;
+ return LDB_ERR_OPERATIONS_ERROR;
}
if (!new_dn) {
- return false;
+ return LDB_ERR_OPERATIONS_ERROR;
}
if (remove_guid) {
msg->dn = ldb_dn_new(msg, ldb, new_dn);
if (! ldb_dn_validate(msg->dn))
- return false;
+ return LDB_ERR_OPERATIONS_ERROR;
val = ldb_msg_find_ldb_val(msg, "distinguishedName");
if (val) {
ldb_msg_remove_attr(msg, "distinguishedName");
if (ldb_msg_add_steal_string(msg, "distinguishedName", new_dn))
- return false;
+ return LDB_ERR_OPERATIONS_ERROR;
}
- return true;
+ return LDB_SUCCESS;
}
/* search */
struct extended_context {
struct ldb_module *module;
- void *up_context;
- int (*up_callback)(struct ldb_context *, void *, struct ldb_reply *);
-
- const char * const *attrs;
+ struct ldb_request *req;
+ struct ldb_control *control;
+ struct ldb_dn *basedn;
+ char *wellknown_object;
+ bool inject;
bool remove_guid;
bool remove_sid;
int extended_type;
+ const char * const *cast_attrs;
};
-static int extended_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
+static int extended_callback(struct ldb_request *req, struct ldb_reply *ares)
{
struct extended_context *ac;
+ int ret;
- ac = talloc_get_type(context, struct extended_context);
+ ac = talloc_get_type(req->context, struct extended_context);
- if (ares->type == LDB_REPLY_ENTRY) {
- /* for each record returned post-process to add any derived
- attributes that have been asked for */
- if (!inject_extended_dn(ares->message, ldb, ac->extended_type, ac->remove_guid, ac->remove_sid)) {
- goto error;
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
+
+ switch (ares->type) {
+ case LDB_REPLY_ENTRY:
+ if (ac->inject) {
+ /* for each record returned post-process to add any derived
+ attributes that have been asked for */
+ ret = inject_extended_dn(ares->message, ac->module->ldb,
+ ac->extended_type, ac->remove_guid,
+ ac->remove_sid);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL, ret);
+ }
}
+
+ return ldb_module_send_entry(ac->req, ares->message);
+
+ case LDB_REPLY_REFERRAL:
+ return ldb_module_send_referral(ac->req, ares->referral);
+
+ case LDB_REPLY_DONE:
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, LDB_SUCCESS);
+
+ }
+ return LDB_SUCCESS;
+}
+
+static int extended_base_callback(struct ldb_request *req, struct ldb_reply *ares)
+{
+ struct extended_context *ac;
+ struct ldb_request *down_req;
+ struct ldb_control **saved_controls;
+ struct ldb_message_element *el;
+ int ret;
+ size_t i;
+ size_t wkn_len = 0;
+ char *valstr = NULL;
+ const char *found = NULL;
+
+ ac = talloc_get_type(req->context, struct extended_context);
+
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
}
- return ac->up_callback(ldb, ac->up_context, ares);
+ switch (ares->type) {
+ case LDB_REPLY_ENTRY:
+ if (!ac->wellknown_object) {
+ ac->basedn = ares->message->dn;
+ break;
+ }
+
+ wkn_len = strlen(ac->wellknown_object);
-error:
- talloc_free(ares);
- return LDB_ERR_OPERATIONS_ERROR;
+ el = ldb_msg_find_element(ares->message, "wellKnownObjects");
+ if (!el) {
+ ac->basedn = NULL;
+ break;
+ }
+
+ for (i=0; i < el->num_values; i++) {
+ valstr = talloc_strndup(ac,
+ (const char *)el->values[i].data,
+ el->values[i].length);
+ if (!valstr) {
+ ldb_oom(ac->module->ldb);
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+
+ if (strncasecmp(valstr, ac->wellknown_object, wkn_len) != 0) {
+ talloc_free(valstr);
+ continue;
+ }
+
+ found = &valstr[wkn_len];
+ break;
+ }
+
+ if (!found) {
+ break;
+ }
+
+ ac->basedn = ldb_dn_new(ac, ac->module->ldb, found);
+ talloc_free(valstr);
+ if (!ac->basedn) {
+ ldb_oom(ac->module->ldb);
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+
+ break;
+
+ case LDB_REPLY_REFERRAL:
+ break;
+
+ case LDB_REPLY_DONE:
+
+ if (!ac->basedn) {
+ const char *str = talloc_asprintf(req, "Base-DN '%s' not found",
+ ldb_dn_get_linearized(ac->req->op.search.base));
+ ldb_set_errstring(ac->module->ldb, str);
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_NO_SUCH_OBJECT);
+ }
+
+ ret = ldb_build_search_req_ex(&down_req,
+ ac->module->ldb, ac,
+ ac->basedn,
+ ac->req->op.search.scope,
+ ac->req->op.search.tree,
+ ac->cast_attrs,
+ ac->req->controls,
+ ac, extended_callback,
+ ac->req);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL, LDB_ERR_OPERATIONS_ERROR);
+ }
+
+ if (ac->control) {
+ /* save it locally and remove it from the list */
+ /* we do not need to replace them later as we
+ * are keeping the original req intact */
+ if (!save_controls(ac->control, down_req, &saved_controls)) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ }
+
+ /* perform the search */
+ return ldb_next_request(ac->module, down_req);
+ }
+ return LDB_SUCCESS;
}
static int extended_search(struct ldb_module *module, struct ldb_request *req)
struct ldb_request *down_req;
char **new_attrs;
int ret;
+ struct ldb_dn *base_dn = NULL;
+ enum ldb_scope base_dn_scope = LDB_SCOPE_BASE;
+ const char *base_dn_filter = NULL;
+ const char * const *base_dn_attrs = NULL;
+ char *wellknown_object = NULL;
+ static const char *dnattr[] = {
+ "distinguishedName",
+ NULL
+ };
+ static const char *wkattr[] = {
+ "wellKnownObjects",
+ NULL
+ };
+
+ if (ldb_dn_is_special(req->op.search.base)) {
+ char *dn;
+
+ dn = ldb_dn_alloc_linearized(req, req->op.search.base);
+ if (!dn) {
+ ldb_oom(module->ldb);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ if (strncasecmp(dn, "<SID=", 5) == 0) {
+ char *str;
+ char *valstr;
+ char *p;
+
+ p = strchr(dn, '=');
+ if (!p) {
+ return LDB_ERR_INVALID_DN_SYNTAX;
+ }
+
+ p[0] = '\0';
+ p++;
+
+ str = p;
+
+ p = strchr(str, '>');
+ if (!p) {
+ return LDB_ERR_INVALID_DN_SYNTAX;
+ }
+ p[0] = '\0';
+
+ if (strncasecmp(str, "S-", 2) == 0) {
+ valstr = str;
+ } else {
+ DATA_BLOB binary;
+ binary = strhex_to_data_blob(str);
+ if (!binary.data) {
+ ldb_oom(module->ldb);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ valstr = ldb_binary_encode(req, binary);
+ data_blob_free(&binary);
+ if (!valstr) {
+ ldb_oom(module->ldb);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ }
+
+ /* TODO: do a search over all partitions */
+ base_dn = ldb_get_default_basedn(module->ldb);
+ base_dn_filter = talloc_asprintf(req, "(objectSid=%s)", valstr);
+ if (!base_dn_filter) {
+ ldb_oom(module->ldb);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ base_dn_scope = LDB_SCOPE_SUBTREE;
+ base_dn_attrs = dnattr;
+ } else if (strncasecmp(dn, "<GUID=", 6) == 0) {
+ char *str;
+ char *valstr;
+ char *p;
+
+ p = strchr(dn, '=');
+ if (!p) {
+ return LDB_ERR_INVALID_DN_SYNTAX;
+ }
+
+ p[0] = '\0';
+ p++;
+
+ str = p;
+
+ p = strchr(str, '>');
+ if (!p) {
+ return LDB_ERR_INVALID_DN_SYNTAX;
+ }
+ p[0] = '\0';
+
+ if (strchr(str, '-')) {
+ valstr = str;
+ } else {
+ DATA_BLOB binary;
+ binary = strhex_to_data_blob(str);
+ if (!binary.data) {
+ ldb_oom(module->ldb);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ valstr = ldb_binary_encode(req, binary);
+ data_blob_free(&binary);
+ if (!valstr) {
+ ldb_oom(module->ldb);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ }
+
+ /* TODO: do a search over all partitions */
+ base_dn = ldb_get_default_basedn(module->ldb);
+ base_dn_filter = talloc_asprintf(req, "(objectGUID=%s)", valstr);
+ if (!base_dn_filter) {
+ ldb_oom(module->ldb);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ base_dn_scope = LDB_SCOPE_SUBTREE;
+ base_dn_attrs = dnattr;
+ } else if (strncasecmp(dn, "<WKGUID=", 8) == 0) {
+ char *tail_str;
+ char *p;
+
+ p = strchr(dn, ',');
+ if (!p) {
+ return LDB_ERR_INVALID_DN_SYNTAX;
+ }
+
+ p[0] = '\0';
+ p++;
+
+ wellknown_object = talloc_asprintf(req, "B:32:%s:", &dn[8]);
+ if (!wellknown_object) {
+ ldb_oom(module->ldb);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ tail_str = p;
+ p = strchr(tail_str, '>');
+ if (!p) {
+ return LDB_ERR_INVALID_DN_SYNTAX;
+ }
+ p[0] = '\0';
+
+ base_dn = ldb_dn_new(req, module->ldb, tail_str);
+ if (!base_dn) {
+ ldb_oom(module->ldb);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ base_dn_filter = talloc_strdup(req, "(objectClass=*)");
+ if (!base_dn_filter) {
+ ldb_oom(module->ldb);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ base_dn_scope = LDB_SCOPE_BASE;
+ base_dn_attrs = wkattr;
+ }
+ talloc_free(dn);
+ }
/* check if there's an extended dn control */
control = ldb_request_get_control(req, LDB_CONTROL_EXTENDED_DN_OID);
- if (control == NULL) {
+ if (control == NULL && base_dn_filter == NULL) {
/* not found go on */
return ldb_next_request(module, req);
}
- if (control->data) {
+ if (control && control->data) {
extended_ctrl = talloc_get_type(control->data, struct ldb_extended_dn_control);
if (!extended_ctrl) {
return LDB_ERR_PROTOCOL_ERROR;
}
}
- ac = talloc(req, struct extended_context);
+ ac = talloc_zero(req, struct extended_context);
if (ac == NULL) {
ldb_oom(module->ldb);
return LDB_ERR_OPERATIONS_ERROR;
}
ac->module = module;
- ac->up_context = req->context;
- ac->up_callback = req->callback;
- ac->attrs = req->op.search.attrs;
+ ac->req = req;
+ ac->control = control;
+ ac->basedn = NULL;
+ ac->wellknown_object = wellknown_object;
+ ac->inject = false;
ac->remove_guid = false;
ac->remove_sid = false;
- if (extended_ctrl) {
- ac->extended_type = extended_ctrl->type;
- } else {
- ac->extended_type = 0;
- }
-
- down_req = talloc_zero(req, struct ldb_request);
- if (down_req == NULL) {
- ldb_oom(module->ldb);
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- down_req->operation = req->operation;
- down_req->op.search.base = req->op.search.base;
- down_req->op.search.scope = req->op.search.scope;
- down_req->op.search.tree = req->op.search.tree;
- /* check if attrs only is specified, in that case check wether we need to modify them */
- if (req->op.search.attrs) {
- if (! is_attr_in_list(req->op.search.attrs, "objectGUID")) {
- ac->remove_guid = true;
+ if (control) {
+ ac->inject = true;
+ if (extended_ctrl) {
+ ac->extended_type = extended_ctrl->type;
+ } else {
+ ac->extended_type = 0;
}
- if (! is_attr_in_list(req->op.search.attrs, "objectSID")) {
- ac->remove_sid = true;
- }
- if (ac->remove_guid || ac->remove_sid) {
- new_attrs = copy_attrs(down_req, req->op.search.attrs);
- if (new_attrs == NULL) {
- ldb_oom(module->ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+
+ /* check if attrs only is specified, in that case check wether we need to modify them */
+ if (req->op.search.attrs) {
+ if (! is_attr_in_list(req->op.search.attrs, "objectGUID")) {
+ ac->remove_guid = true;
}
-
- if (ac->remove_guid) {
- if (!add_attrs(down_req, &new_attrs, "objectGUID"))
- return LDB_ERR_OPERATIONS_ERROR;
+ if (! is_attr_in_list(req->op.search.attrs, "objectSID")) {
+ ac->remove_sid = true;
}
- if (ac->remove_sid) {
- if (!add_attrs(down_req, &new_attrs, "objectSID"))
+ if (ac->remove_guid || ac->remove_sid) {
+ new_attrs = copy_attrs(ac, req->op.search.attrs);
+ if (new_attrs == NULL) {
+ ldb_oom(module->ldb);
return LDB_ERR_OPERATIONS_ERROR;
- }
+ }
- down_req->op.search.attrs = (const char * const *)new_attrs;
+ if (ac->remove_guid) {
+ if (!add_attrs(ac, &new_attrs, "objectGUID"))
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ if (ac->remove_sid) {
+ if (!add_attrs(ac, &new_attrs, "objectSID"))
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ ac->cast_attrs = (const char * const *)new_attrs;
+ } else {
+ ac->cast_attrs = req->op.search.attrs;
+ }
}
}
- down_req->controls = req->controls;
+ if (base_dn) {
+ ret = ldb_build_search_req(&down_req,
+ module->ldb, ac,
+ base_dn,
+ base_dn_scope,
+ base_dn_filter,
+ base_dn_attrs,
+ NULL,
+ ac, extended_base_callback,
+ req);
+ if (ret != LDB_SUCCESS) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
- /* save it locally and remove it from the list */
- /* we do not need to replace them later as we
- * are keeping the original req intact */
- if (!save_controls(control, down_req, &saved_controls)) {
- return LDB_ERR_OPERATIONS_ERROR;
+ /* perform the search */
+ return ldb_next_request(module, down_req);
}
- down_req->context = ac;
- down_req->callback = extended_callback;
- ldb_set_timeout_from_prev_req(module->ldb, req, down_req);
-
- /* perform the search */
- ret = ldb_next_request(module, down_req);
+ ret = ldb_build_search_req_ex(&down_req,
+ module->ldb, ac,
+ req->op.search.base,
+ req->op.search.scope,
+ req->op.search.tree,
+ ac->cast_attrs,
+ req->controls,
+ ac, extended_callback,
+ req);
+ if (ret != LDB_SUCCESS) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
- /* do not free down_req as the call results may be linked to it,
- * it will be freed when the upper level request get freed */
- if (ret == LDB_SUCCESS) {
- req->handle = down_req->handle;
+ if (ac->control) {
+ /* save it locally and remove it from the list */
+ /* we do not need to replace them later as we
+ * are keeping the original req intact */
+ if (!save_controls(control, down_req, &saved_controls)) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
}
- return ret;
+ /* perform the search */
+ return ldb_next_request(module, down_req);
}
static int extended_init(struct ldb_module *module)
{
- struct ldb_request *req;
int ret;
- req = talloc(module, struct ldb_request);
- if (req == NULL) {
- ldb_oom(module->ldb);
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- req->operation = LDB_REQ_REGISTER_CONTROL;
- req->op.reg_control.oid = LDB_CONTROL_EXTENDED_DN_OID;
- req->controls = NULL;
-
- ret = ldb_request(module->ldb, req);
+ ret = ldb_mod_register_control(module, LDB_CONTROL_EXTENDED_DN_OID);
if (ret != LDB_SUCCESS) {
- ldb_debug(module->ldb, LDB_DEBUG_ERROR, "extended_dn: Unable to register control with rootdse!\n");
- talloc_free(req);
+ ldb_debug(module->ldb, LDB_DEBUG_ERROR,
+ "extended_dn: Unable to register control with rootdse!\n");
return LDB_ERR_OPERATIONS_ERROR;
}
- talloc_free(req);
return ldb_next_init(module);
}
/*
ldb database library
- Copyright (C) Simo Sorce 2004-2006
+ Copyright (C) Simo Sorce 2004-2008
Copyright (C) Andrew Bartlett <abartlet@samba.org> 2005
Copyright (C) Andrew Tridgell 2005
Copyright (C) Stefan Metzmacher <metze@samba.org> 2007
#include "dsdb/samdb/samdb.h"
#include "dsdb/common/flags.h"
+struct it_context {
+ struct ldb_module *module;
+ struct ldb_request *req;
+};
+
+static int it_callback(struct ldb_request *req, struct ldb_reply *ares)
+{
+ struct it_context *ac;
+
+ ac = talloc_get_type(req->context, struct it_context);
+
+
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
+
+ if (ares->type != LDB_REPLY_DONE) {
+ ldb_set_errstring(req->handle->ldb, "Invalid reply type!");
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+}
+
/* add_record: add instancetype attribute */
static int instancetype_add(struct ldb_module *module, struct ldb_request *req)
{
struct ldb_request *down_req;
struct ldb_message *msg;
+ struct it_context *ac;
uint32_t instance_type;
int ret;
const struct ldb_control *partition_ctrl;
struct dsdb_control_current_partition);
SMB_ASSERT(partition && partition->version == DSDB_CONTROL_CURRENT_PARTITION_VERSION);
- down_req = talloc(req, struct ldb_request);
- if (down_req == NULL) {
- ldb_oom(module->ldb);
+ ac = talloc(req, struct it_context);
+ if (ac == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
-
- *down_req = *req;
+ ac->module = module;
+ ac->req = req;
/* we have to copy the message as the caller might have it as a const */
- down_req->op.add.message = msg = ldb_msg_copy_shallow(down_req, req->op.add.message);
+ msg = ldb_msg_copy_shallow(ac, req->op.add.message);
if (msg == NULL) {
- talloc_free(down_req);
ldb_oom(module->ldb);
return LDB_ERR_OPERATIONS_ERROR;
}
ret = ldb_msg_add_fmt(msg, "instanceType", "%u", instance_type);
if (ret != LDB_SUCCESS) {
- talloc_free(down_req);
ldb_oom(module->ldb);
return LDB_ERR_OPERATIONS_ERROR;
}
- ldb_set_timeout_from_prev_req(module->ldb, req, down_req);
-
- /* go on with the call chain */
- ret = ldb_next_request(module, down_req);
-
- /* do not free down_req as the call results may be linked to it,
- * it will be freed when the upper level request get freed */
- if (ret == LDB_SUCCESS) {
- req->handle = down_req->handle;
+ ret = ldb_build_add_req(&down_req, module->ldb, ac,
+ msg,
+ req->controls,
+ ac, it_callback,
+ req);
+ if (ret != LDB_SUCCESS) {
+ return ret;
}
- return ret;
+ /* go on with the call chain */
+ return ldb_next_request(module, down_req);
}
_PUBLIC_ const struct ldb_module_ops ldb_instancetype_module_ops = {
ldb database library
Copyright (C) Andrew Bartlett 2005
- Copyright (C) Simo Sorce 2006
+ Copyright (C) Simo Sorce 2006-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
struct kludge_acl_context {
struct ldb_module *module;
- void *up_context;
- int (*up_callback)(struct ldb_context *, void *, struct ldb_reply *);
+ struct ldb_request *req;
enum security_user_level user_type;
bool allowedAttributes;
bool allowedAttributesEffective;
bool allowedChildClasses;
bool allowedChildClassesEffective;
- const char **attrs;
+ const char * const *attrs;
};
/* read all objectClasses */
(comparison_fn_t)data_blob_cmp);
for (i=1 ; i < allowedClasses->num_values; i++) {
+
struct ldb_val *val1 = &allowedClasses->values[i-1];
struct ldb_val *val2 = &allowedClasses->values[i];
if (data_blob_cmp(val1, val2) == 0) {
/* find all attributes allowed by all these objectClasses */
-static int kludge_acl_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
+static int kludge_acl_callback(struct ldb_request *req, struct ldb_reply *ares)
{
struct kludge_acl_context *ac;
struct kludge_private_data *data;
int i, ret;
- ac = talloc_get_type(context, struct kludge_acl_context);
+ ac = talloc_get_type(req->context, struct kludge_acl_context);
data = talloc_get_type(ac->module->private_data, struct kludge_private_data);
- if (ares->type != LDB_REPLY_ENTRY) {
- return ac->up_callback(ldb, ac->up_context, ares);
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
}
- if (ac->allowedAttributes) {
- ret = kludge_acl_allowedAttributes(ldb, ares->message, "allowedAttributes");
- if (ret != LDB_SUCCESS) {
- return ret;
-
+ switch (ares->type) {
+ case LDB_REPLY_ENTRY:
+ if (ac->allowedAttributes) {
+ ret = kludge_acl_allowedAttributes(ac->module->ldb,
+ ares->message,
+ "allowedAttributes");
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL, ret);
+ }
}
- }
- if (ac->allowedChildClasses) {
- ret = kludge_acl_childClasses(ldb, ares->message, "allowedChildClasses");
- if (ret != LDB_SUCCESS) {
- return ret;
+ if (ac->allowedChildClasses) {
+ ret = kludge_acl_childClasses(ac->module->ldb,
+ ares->message,
+ "allowedChildClasses");
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL, ret);
+ }
}
- }
- if (data && data->password_attrs) /* if we are not initialized just get through */
- {
- switch (ac->user_type) {
- case SECURITY_SYSTEM:
- if (ac->allowedAttributesEffective) {
- ret = kludge_acl_allowedAttributes(ldb, ares->message, "allowedAttributesEffective");
- if (ret != LDB_SUCCESS) {
- return ret;
+ if (data && data->password_attrs) /* if we are not initialized just get through */
+ {
+ switch (ac->user_type) {
+ case SECURITY_SYSTEM:
+ if (ac->allowedAttributesEffective) {
+ ret = kludge_acl_allowedAttributes(ac->module->ldb, ares->message,
+ "allowedClassesAttributesEffective");
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL, ret);
+ }
}
- }
- if (ac->allowedChildClassesEffective) {
- ret = kludge_acl_childClasses(ldb, ares->message, "allowedChildClassesEffective");
- if (ret != LDB_SUCCESS) {
- return ret;
+ if (ac->allowedChildClassesEffective) {
+ ret = kludge_acl_childClasses(ac->module->ldb, ares->message,
+ "allowedClassesChildClassesEffective");
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL, ret);
+ }
}
- }
- break;
- case SECURITY_ADMINISTRATOR:
- if (ac->allowedAttributesEffective) {
- ret = kludge_acl_allowedAttributes(ldb, ares->message, "allowedAttributesEffective");
- if (ret != LDB_SUCCESS) {
- return ret;
+ break;
+
+ case SECURITY_ADMINISTRATOR:
+ if (ac->allowedAttributesEffective) {
+ ret = kludge_acl_allowedAttributes(ac->module->ldb, ares->message,
+ "allowedClassesAttributesEffective");
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL, ret);
+ }
}
- }
- if (ac->allowedChildClassesEffective) {
- ret = kludge_acl_childClasses(ldb, ares->message, "allowedChildClassesEffective");
- if (ret != LDB_SUCCESS) {
- return ret;
+ if (ac->allowedChildClassesEffective) {
+ ret = kludge_acl_childClasses(ac->module->ldb, ares->message,
+ "allowedClassesChildClassesEffective");
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL, ret);
+ }
+ }
+ /* fall through */
+ default:
+ /* remove password attributes */
+ for (i = 0; data->password_attrs[i]; i++) {
+ ldb_msg_remove_attr(ares->message, data->password_attrs[i]);
}
}
- /* fall though */
- default:
- /* remove password attributes */
- for (i = 0; data->password_attrs[i]; i++) {
- ldb_msg_remove_attr(ares->message, data->password_attrs[i]);
+ }
+
+ if (ac->allowedAttributes ||
+ ac->allowedAttributesEffective ||
+ ac->allowedChildClasses ||
+ ac->allowedChildClassesEffective) {
+
+ if (!ldb_attr_in_list(ac->attrs, "objectClass") &&
+ !ldb_attr_in_list(ac->attrs, "*")) {
+
+ ldb_msg_remove_attr(ares->message,
+ "objectClass");
}
}
- }
- if ((ac->allowedAttributes || ac->allowedAttributesEffective
- || ac->allowedChildClasses || ac->allowedChildClassesEffective) &&
- (!ldb_attr_in_list(ac->attrs, "objectClass") &&
- !ldb_attr_in_list(ac->attrs, "*"))) {
- ldb_msg_remove_attr(ares->message, "objectClass");
- }
+ return ldb_module_send_entry(ac->req, ares->message);
+
+ case LDB_REPLY_REFERRAL:
+ return ldb_module_send_referral(ac->req, ares->referral);
- return ac->up_callback(ldb, ac->up_context, ares);
+ case LDB_REPLY_DONE:
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, LDB_SUCCESS);
+
+ }
+ return LDB_SUCCESS;
}
static int kludge_acl_search(struct ldb_module *module, struct ldb_request *req)
struct kludge_acl_context *ac;
struct ldb_request *down_req;
struct kludge_private_data *data;
+ const char * const *attrs;
int ret, i;
-
- req->handle = NULL;
+ struct ldb_control *sd_control;
+ struct ldb_control **sd_saved_controls;
ac = talloc(req, struct kludge_acl_context);
if (ac == NULL) {
data = talloc_get_type(module->private_data, struct kludge_private_data);
ac->module = module;
- ac->up_context = req->context;
- ac->up_callback = req->callback;
+ ac->req = req;
ac->user_type = what_is_user(module);
ac->attrs = req->op.search.attrs;
- down_req = talloc_zero(req, struct ldb_request);
- if (down_req == NULL) {
- ldb_oom(module->ldb);
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- down_req->operation = req->operation;
- down_req->op.search.base = req->op.search.base;
- down_req->op.search.scope = req->op.search.scope;
- down_req->op.search.tree = req->op.search.tree;
- down_req->op.search.attrs = req->op.search.attrs;
-
ac->allowedAttributes = ldb_attr_in_list(req->op.search.attrs, "allowedAttributes");
ac->allowedAttributesEffective = ldb_attr_in_list(req->op.search.attrs, "allowedAttributesEffective");
ac->allowedChildClassesEffective = ldb_attr_in_list(req->op.search.attrs, "allowedChildClassesEffective");
if (ac->allowedAttributes || ac->allowedAttributesEffective || ac->allowedChildClasses || ac->allowedChildClassesEffective) {
- down_req->op.search.attrs
- = ldb_attr_list_copy_add(down_req, down_req->op.search.attrs, "objectClass");
+ attrs = ldb_attr_list_copy_add(ac, req->op.search.attrs, "objectClass");
+ } else {
+ attrs = req->op.search.attrs;
}
- /* FIXME: I hink we should copy the tree and keep the original
- * unmodified. SSS */
/* replace any attributes in the parse tree that are private,
so we don't allow a search for 'userPassword=penguin',
just as we would not allow that attribute to be returned */
case SECURITY_SYSTEM:
break;
default:
+ /* FIXME: We should copy the tree and keep the original unmodified. */
/* remove password attributes */
- for (i = 0; data && data->password_attrs && data->password_attrs[i]; i++) {
- ldb_parse_tree_attr_replace(down_req->op.search.tree,
+
+ if (!data || !data->password_attrs) {
+ break;
+ }
+ for (i = 0; data->password_attrs[i]; i++) {
+ ldb_parse_tree_attr_replace(req->op.search.tree,
data->password_attrs[i],
"kludgeACLredactedattribute");
}
}
- down_req->controls = req->controls;
-
- down_req->context = ac;
- down_req->callback = kludge_acl_callback;
- ldb_set_timeout_from_prev_req(module->ldb, req, down_req);
-
- /* perform the search */
- ret = ldb_next_request(module, down_req);
+ ret = ldb_build_search_req_ex(&down_req,
+ module->ldb, ac,
+ req->op.search.base,
+ req->op.search.scope,
+ req->op.search.tree,
+ attrs,
+ req->controls,
+ ac, kludge_acl_callback,
+ req);
+ if (ret != LDB_SUCCESS) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
- /* do not free down_req as the call results may be linked to it,
- * it will be freed when the upper level request get freed */
- if (ret == LDB_SUCCESS) {
- req->handle = down_req->handle;
+ /* check if there's an SD_FLAGS control */
+ sd_control = ldb_request_get_control(down_req, LDB_CONTROL_SD_FLAGS_OID);
+ if (sd_control) {
+ /* save it locally and remove it from the list */
+ /* we do not need to replace them later as we
+ * are keeping the original req intact */
+ if (!save_controls(sd_control, down_req, &sd_saved_controls)) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
}
- return ret;
+ /* perform the search */
+ return ldb_next_request(module, down_req);
}
/* ANY change type */
return LDB_ERR_OPERATIONS_ERROR;
}
- ret = ldb_search(module->ldb, ldb_dn_new(mem_ctx, module->ldb, "@KLUDGEACL"),
- LDB_SCOPE_BASE,
- NULL, attrs,
- &res);
+ ret = ldb_search(module->ldb, mem_ctx, &res,
+ ldb_dn_new(mem_ctx, module->ldb, "@KLUDGEACL"),
+ LDB_SCOPE_BASE, attrs, NULL);
if (ret != LDB_SUCCESS) {
goto done;
}
- talloc_steal(mem_ctx, res);
if (res->count == 0) {
goto done;
}
}
data->password_attrs[i] = NULL;
+ ret = ldb_mod_register_control(module, LDB_CONTROL_SD_FLAGS_OID);
+ if (ret != LDB_SUCCESS) {
+ ldb_debug(module->ldb, LDB_DEBUG_ERROR,
+ "partition: Unable to register control with rootdse!\n");
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
done:
talloc_free(mem_ctx);
return ldb_next_init(module);
ldb database library
Copyright (C) Andrew Bartlett <abartlet@samba.org> 2007
+ Copyright (C) Simo Sorce <idra@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
#include "ldb/include/ldb_private.h"
#include "dsdb/samdb/samdb.h"
-struct linked_attributes_context {
- enum la_step {LA_SEARCH, LA_DO_OPS, LA_DO_ORIG} step;
- struct ldb_module *module;
- struct ldb_handle *handle;
- struct ldb_request *orig_req;
-
- struct ldb_request *search_req;
- struct ldb_request **down_req;
- struct ldb_request *orig_down_req;
-
- int num_requests;
- int finished_requests;
-
- const char **linked_attrs;
+struct la_op_store {
+ struct la_op_store *next;
+ enum la_op {LA_OP_ADD, LA_OP_DEL} op;
+ struct ldb_dn *dn;
+ char *name;
+ char *value;
};
struct replace_context {
- struct linked_attributes_context *ac;
+ struct la_context *ac;
+ unsigned int num_elements;
struct ldb_message_element *el;
};
-static int linked_attributes_rename_del_search_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares);
-
-static struct linked_attributes_context *linked_attributes_init_handle(struct ldb_request *req,
- struct ldb_module *module)
-{
- struct linked_attributes_context *ac;
- struct ldb_handle *h;
+struct la_context {
+ const struct dsdb_schema *schema;
+ struct ldb_module *module;
+ struct ldb_request *req;
- h = talloc_zero(req, struct ldb_handle);
- if (h == NULL) {
- ldb_set_errstring(module->ldb, "Out of Memory");
- return NULL;
- }
+ struct replace_context *rc;
+ struct la_op_store *ops;
+ struct la_op_store *cur;
+};
- h->module = module;
+static struct la_context *linked_attributes_init(struct ldb_module *module,
+ struct ldb_request *req)
+{
+ struct la_context *ac;
- ac = talloc_zero(h, struct linked_attributes_context);
+ ac = talloc_zero(req, struct la_context);
if (ac == NULL) {
ldb_set_errstring(module->ldb, "Out of Memory");
- talloc_free(h);
return NULL;
}
- h->private_data = ac;
-
+ ac->schema = dsdb_get_schema(module->ldb);
ac->module = module;
- ac->handle = h;
- ac->orig_req = req;
-
- ac->orig_down_req = talloc(ac, struct ldb_request);
- if (!ac->orig_down_req) {
- ldb_oom(ac->module->ldb);
- return NULL;
- }
-
- *ac->orig_down_req = *req;
-
- req->handle = h;
+ ac->req = req;
return ac;
}
/* Common routine to handle reading the attributes and creating a
* series of modify requests */
-
-static int setup_modifies(struct ldb_context *ldb, TALLOC_CTX *mem_ctx,
- struct linked_attributes_context *ac,
- const struct ldb_message *msg,
- struct ldb_dn *olddn, struct ldb_dn *newdn)
+static int la_store_op(struct la_context *ac,
+ enum la_op op, char *dn,
+ const char *name, const char *value)
{
- int i, j, ret = LDB_SUCCESS;
- const struct dsdb_schema *schema = dsdb_get_schema(ldb);
- /* Look up each of the returned attributes */
- /* Find their schema */
- /* And it is an actual entry: now create a series of modify requests */
- for (i=0; i < msg->num_elements; i++) {
- int otherid;
- const struct dsdb_attribute *target_attr;
- const struct ldb_message_element *el = &msg->elements[i];
- const struct dsdb_attribute *schema_attr
- = dsdb_attribute_by_lDAPDisplayName(schema, el->name);
- if (!schema_attr) {
- ldb_asprintf_errstring(ldb,
- "attribute %s is not a valid attribute in schema", el->name);
- return LDB_ERR_OBJECT_CLASS_VIOLATION;
- }
- /* We have a valid attribute, but if it's not linked they maybe we just got an extra return on our search... */
- if (schema_attr->linkID == 0) {
- continue;
- }
-
- /* Depending on which direction this link is in, we need to find it's partner */
- if ((schema_attr->linkID & 1) == 1) {
- otherid = schema_attr->linkID - 1;
- } else {
- otherid = schema_attr->linkID + 1;
- }
-
- /* Now find the target attribute */
- target_attr = dsdb_attribute_by_linkID(schema, otherid);
- if (!target_attr) {
- ldb_asprintf_errstring(ldb,
- "attribute %s does not have valid link target", el->name);
- return LDB_ERR_OBJECT_CLASS_VIOLATION;
- }
-
- /* For each value being moded, we need to setup the modify */
- for (j=0; j < el->num_values; j++) {
- struct ldb_message_element *ret_el;
- struct ldb_request *new_req;
- struct ldb_message *new_msg;
-
- /* Create a spot in the list for the requests */
- ac->down_req = talloc_realloc(ac, ac->down_req,
- struct ldb_request *, ac->num_requests + 1);
- if (!ac->down_req) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
- }
+ struct la_op_store *os, *tmp;
+ struct ldb_dn *op_dn;
- /* Create the modify request */
- new_msg = ldb_msg_new(ac->down_req);
- if (!new_msg) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
- }
- new_msg->dn = ldb_dn_from_ldb_val(new_msg, ldb, &el->values[j]);
- if (!new_msg->dn) {
- ldb_asprintf_errstring(ldb,
- "attribute %s value %s was not a valid DN", msg->elements[i].name,
- el->values[j].data);
- return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX;
- }
-
- if (olddn) {
- ret = ldb_msg_add_empty(new_msg, target_attr->lDAPDisplayName,
- LDB_FLAG_MOD_DELETE, &ret_el);
- if (ret != LDB_SUCCESS) {
- return ret;
- }
- ret_el->values = talloc_array(new_msg, struct ldb_val, 1);
- if (!ret_el->values) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
- }
- ret_el->values[0] = data_blob_string_const(ldb_dn_get_linearized(olddn));
- ret_el->num_values = 1;
- }
-
- if (newdn) {
- ret = ldb_msg_add_empty(new_msg, target_attr->lDAPDisplayName,
- LDB_FLAG_MOD_ADD, &ret_el);
- if (ret != LDB_SUCCESS) {
- return ret;
- }
- ret_el->values = talloc_array(new_msg, struct ldb_val, 1);
- if (!ret_el->values) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ op_dn = ldb_dn_new(ac, ac->module->ldb, dn);
+ if (!op_dn) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ /* optimize out del - add operations that would end up
+ * with no changes */
+ if (ac->ops && op == LA_OP_DEL) {
+ /* do a linear search to find out if there is
+ * an equivalent add */
+ os = ac->ops;
+ while (os->next) {
+
+ tmp = os->next;
+ if (tmp->op == LA_OP_ADD) {
+
+ if ((strcmp(name, tmp->name) == 0) &&
+ (strcmp(value, tmp->value) == 0) &&
+ (ldb_dn_compare(op_dn, tmp->dn) == 0)) {
+
+ break;
}
- ret_el->values[0] = data_blob_string_const(ldb_dn_get_linearized(newdn));
- ret_el->num_values = 1;
}
+ os = os->next;
+ }
+ if (os->next) {
+ /* pair found, remove it and return */
+ os->next = tmp->next;
+ talloc_free(tmp);
+ talloc_free(op_dn);
+ return LDB_SUCCESS;
+ }
+ }
- ret = ldb_build_mod_req(&new_req, ldb, ac->down_req,
- new_msg,
- NULL,
- NULL,
- NULL);
- if (ret != LDB_SUCCESS) {
- return ret;
- }
-
- talloc_steal(new_req, new_msg);
-
- ldb_set_timeout_from_prev_req(ldb, ac->orig_req, new_req);
-
- ac->down_req[ac->num_requests] = new_req;
- ac->num_requests++;
-
-
- /* Run the new request */
- ret = ldb_next_request(ac->module, new_req);
- if (ret != LDB_SUCCESS) {
- return ret;
- }
+ os = talloc_zero(ac, struct la_op_store);
+ if (!os) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ os->op = op;
+
+ os->dn = talloc_steal(os, op_dn);
+ if (!os->dn) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ os->name = talloc_strdup(os, name);
+ if (!os->name) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ if ((op != LA_OP_DEL) && (value == NULL)) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ if (value) {
+ os->value = talloc_strdup(os, value);
+ if (!os->value) {
+ return LDB_ERR_OPERATIONS_ERROR;
}
}
- return ret;
+
+ if (ac->ops) {
+ ac->cur->next = os;
+ } else {
+ ac->ops = os;
+ }
+ ac->cur = os;
+
+ return LDB_SUCCESS;
}
+static int la_op_search_callback(struct ldb_request *req,
+ struct ldb_reply *ares);
+static int la_do_mod_request(struct la_context *ac);
+static int la_mod_callback(struct ldb_request *req,
+ struct ldb_reply *ares);
+static int la_down_req(struct la_context *ac);
+static int la_down_callback(struct ldb_request *req,
+ struct ldb_reply *ares);
+
+
+
/* add */
static int linked_attributes_add(struct ldb_module *module, struct ldb_request *req)
{
- int i;
- struct linked_attributes_context *ac;
-
- const struct dsdb_schema *schema = dsdb_get_schema(module->ldb);
- if (!schema) {
- /* without schema, this doesn't make any sense */
- return ldb_next_request(module, req);
- }
+ const struct dsdb_attribute *target_attr;
+ struct la_context *ac;
+ const char *attr_name;
+ const char *attr_val;
+ int ret;
+ int i, j;
if (ldb_dn_is_special(req->op.mod.message->dn)) {
/* do not manipulate our control entries */
return ldb_next_request(module, req);
}
-
- ac = linked_attributes_init_handle(req, module);
+ ac = linked_attributes_init(module, req);
if (!ac) {
return LDB_ERR_OPERATIONS_ERROR;
}
-
- ac->step = LA_DO_OPS;
-
+
+ if (!ac->schema) {
+ /* without schema, this doesn't make any sense */
+ talloc_free(ac);
+ return ldb_next_request(module, req);
+ }
+
/* Need to ensure we only have forward links being specified */
for (i=0; i < req->op.add.message->num_elements; i++) {
const struct ldb_message_element *el = &req->op.add.message->elements[i];
const struct dsdb_attribute *schema_attr
- = dsdb_attribute_by_lDAPDisplayName(schema, el->name);
+ = dsdb_attribute_by_lDAPDisplayName(ac->schema, el->name);
if (!schema_attr) {
ldb_asprintf_errstring(module->ldb,
- "attribute %s is not a valid attribute in schema", req->op.add.message->elements[i].name);
+ "attribute %s is not a valid attribute in schema", el->name);
return LDB_ERR_OBJECT_CLASS_VIOLATION;
}
- /* We have a valid attribute, not find out if it is linked */
+ /* We have a valid attribute, now find out if it is linked */
if (schema_attr->linkID == 0) {
continue;
}
if ((schema_attr->linkID & 1) == 1) {
/* Odd is for the target. Illigal to modify */
ldb_asprintf_errstring(module->ldb,
- "attribute %s must not be modified directly, it is a linked attribute", req->op.add.message->elements[i].name);
+ "attribute %s must not be modified directly, it is a linked attribute", el->name);
return LDB_ERR_UNWILLING_TO_PERFORM;
}
/* Even link IDs are for the originating attribute */
- }
-
- /* Now call the common routine to setup the modifies across all the attributes */
- return setup_modifies(module->ldb, ac, ac, req->op.add.message, NULL, req->op.add.message->dn);
-}
+ target_attr = dsdb_attribute_by_linkID(ac->schema, schema_attr->linkID + 1);
+ if (!target_attr) {
+ /*
+ * windows 2003 has a broken schema where
+ * the definition of msDS-IsDomainFor
+ * is missing (which is supposed to be
+ * the backlink of the msDS-HasDomainNCs
+ * attribute
+ */
+ continue;
+ }
-struct merge {
- struct ldb_dn *dn;
- bool add;
- bool ignore;
-};
+ attr_name = target_attr->lDAPDisplayName;
+ attr_val = ldb_dn_get_linearized(ac->req->op.add.message->dn);
-static int merge_cmp(struct merge *merge1, struct merge *merge2) {
- int ret;
- ret = ldb_dn_compare(merge1->dn, merge2->dn);
- if (ret == 0) {
- if (merge1->add == merge2->add) {
- return 0;
- }
- if (merge1->add == true) {
- return 1;
+ for (j = 0; j < el->num_values; j++) {
+ ret = la_store_op(ac, LA_OP_ADD,
+ (char *)el->values[j].data,
+ attr_name, attr_val);
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
}
- return -1;
}
- return ret;
+
+ /* if no linked attributes are present continue */
+ if (ac->ops == NULL) {
+ talloc_free(ac);
+ return ldb_next_request(module, req);
+ }
+
+ /* start with the first one */
+ return la_do_mod_request(ac);
}
-static int linked_attributes_mod_replace_search_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
+static int la_mod_search_callback(struct ldb_request *req, struct ldb_reply *ares)
{
- struct replace_context *ac2 = talloc_get_type(context, struct replace_context);
- struct linked_attributes_context *ac = ac2->ac;
-
- /* OK, we have one search result here: */
+ const struct dsdb_attribute *schema_attr;
+ const struct dsdb_attribute *target_attr;
+ struct ldb_message_element *search_el;
+ struct replace_context *rc;
+ struct la_context *ac;
+ const char *attr_name;
+ const char *dn;
+ int i, j;
+ int ret = LDB_SUCCESS;
- /* Only entries are interesting, and we only want the olddn */
- if (ares->type == LDB_REPLY_ENTRY
- && ldb_dn_compare(ares->message->dn, ac->orig_req->op.mod.message->dn) == 0) {
- /* only bother at all if there were some linked attributes found */
- struct ldb_message_element *search_el
- = ldb_msg_find_element(ares->message,
- ac2->el->name);
-
- /* See if this element already exists */
- if (search_el) {
+ ac = talloc_get_type(req->context, struct la_context);
+ rc = ac->rc;
+
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
- struct merge *merged_list = NULL;
+ /* Only entries are interesting, and we only want the olddn */
+ switch (ares->type) {
+ case LDB_REPLY_ENTRY:
+
+ if (ldb_dn_compare(ares->message->dn, ac->req->op.mod.message->dn) != 0) {
+ /* Guh? We only asked for this DN */
+ ldb_oom(ac->module->ldb);
+ talloc_free(ares);
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
- int ret, size = 0, i;
- struct ldb_message *msg = ldb_msg_new(ac);
- if (!msg) {
- ldb_oom(ac->module->ldb);
- return LDB_ERR_OPERATIONS_ERROR;
- }
+ dn = ldb_dn_get_linearized(ac->req->op.add.message->dn);
- /* Add all the existing elements, marking as 'proposed for delete' by setting .add = false */
- for (i=0; i < search_el->num_values; i++) {
- merged_list = talloc_realloc(ares, merged_list, struct merge, size + 1);
- merged_list[size].dn = ldb_dn_from_ldb_val(merged_list, ldb, &search_el->values[i]);
- merged_list[size].add = false;
- merged_list[size].ignore = false;
- size++;
- }
+ for (i = 0; i < rc->num_elements; i++) {
- /* Add all the new replacement elements, marking as 'proposed for add' by setting .add = true */
- for (i=0; i < ac2->el->num_values; i++) {
- merged_list = talloc_realloc(ares, merged_list, struct merge, size + 1);
- merged_list[size].dn = ldb_dn_from_ldb_val(merged_list, ldb, &ac2->el->values[i]);
- merged_list[size].add = true;
- merged_list[size].ignore = false;
- size++;
+ schema_attr = dsdb_attribute_by_lDAPDisplayName(ac->schema, rc->el[i].name);
+ if (!schema_attr) {
+ ldb_asprintf_errstring(ac->module->ldb,
+ "attribute %s is not a valid attribute in schema",
+ rc->el[i].name);
+ talloc_free(ares);
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OBJECT_CLASS_VIOLATION);
}
- /* Sort the list, so we can pick out an add and delete for the same DN, and eliminate them */
- qsort(merged_list, size,
- sizeof(*merged_list),
- (comparison_fn_t)merge_cmp);
-
- /* Now things are sorted, it is trivial to mark pairs of DNs as 'ignore' */
- for (i=0; i + 1 < size; i++) {
- if (ldb_dn_compare(merged_list[i].dn,
- merged_list[i+1].dn) == 0
- /* Fortunetly the sort also sorts 'add == false' first */
- && merged_list[i].add == false
- && merged_list[i+1].add == true) {
-
- /* Mark as ignore, so we include neither in the actual operations */
- merged_list[i].ignore = true;
- merged_list[i+1].ignore = true;
- }
- }
+ search_el = ldb_msg_find_element(ares->message,
+ rc->el[i].name);
- /* Arrange to delete anything the search found that we don't re-add */
- for (i=0; i < size; i++) {
- if (merged_list[i].ignore == false
- && merged_list[i].add == false) {
- ldb_msg_add_steal_string(msg, search_el->name,
- ldb_dn_get_linearized(merged_list[i].dn));
- }
+ /* See if this element already exists */
+ /* otherwise just ignore as
+ * the add has already been scheduled */
+ if ( ! search_el) {
+ continue;
}
- /* The DN to set on the linked attributes is the original DN of the modify message */
- msg->dn = ac->orig_req->op.mod.message->dn;
-
- ret = setup_modifies(ac->module->ldb, ac2, ac, msg, ares->message->dn, NULL);
- if (ret != LDB_SUCCESS) {
- return ret;
+ target_attr = dsdb_attribute_by_linkID(ac->schema, schema_attr->linkID + 1);
+ if (!target_attr) {
+ /*
+ * windows 2003 has a broken schema where
+ * the definition of msDS-IsDomainFor
+ * is missing (which is supposed to be
+ * the backlink of the msDS-HasDomainNCs
+ * attribute
+ */
+ continue;
}
+ attr_name = target_attr->lDAPDisplayName;
- /* Now add links for all the actually new elements */
- for (i=0; i < size; i++) {
- if (merged_list[i].ignore == false && merged_list[i].add == true) {
- ldb_msg_add_steal_string(msg, search_el->name,
- ldb_dn_get_linearized(merged_list[i].dn));
+ /* make sure we manage each value */
+ for (j = 0; j < search_el->num_values; j++) {
+ ret = la_store_op(ac, LA_OP_DEL,
+ (char *)search_el->values[j].data,
+ attr_name, dn);
+ if (ret != LDB_SUCCESS) {
+ talloc_free(ares);
+ return ldb_module_done(ac->req,
+ NULL, NULL, ret);
}
}
+ }
- ret = setup_modifies(ac->module->ldb, ac2, ac, msg, NULL, ares->message->dn);
- if (ret != LDB_SUCCESS) {
- return ret;
- }
-
- talloc_free(merged_list);
+ break;
- } else {
- /* Looks like it doesn't exist, process like an 'add' */
- struct ldb_message *msg = ldb_msg_new(ac);
- if (!msg) {
- ldb_oom(ac->module->ldb);
- return LDB_ERR_OPERATIONS_ERROR;
- }
- msg->num_elements = 1;
- msg->elements = ac2->el;
- msg->dn = ac->orig_req->op.mod.message->dn;
+ case LDB_REPLY_REFERRAL:
+ /* ignore */
+ break;
- return setup_modifies(ac->module->ldb, ac2, ac, msg, NULL, ac->orig_req->op.mod.message->dn);
- }
- talloc_free(ares);
- return LDB_SUCCESS;
- } else if (ares->type == LDB_REPLY_ENTRY) {
- /* Guh? We only asked for this DN */
- return LDB_ERR_OPERATIONS_ERROR;
+ case LDB_REPLY_DONE:
- } else {
talloc_free(ares);
+
+ /* All mods set up, start with the first one */
+ ret = la_do_mod_request(ac);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL, ret);
+ }
return LDB_SUCCESS;
}
-
-
+
+ talloc_free(ares);
+ return ret;
}
+
+
/* modify */
static int linked_attributes_modify(struct ldb_module *module, struct ldb_request *req)
{
/* Apply the modify to the linked entry */
int i, j;
- struct linked_attributes_context *ac;
-
- const struct dsdb_schema *schema = dsdb_get_schema(module->ldb);
- if (!schema) {
- /* without schema, this doesn't make any sense */
- return ldb_next_request(module, req);
- }
+ struct la_context *ac;
+ struct ldb_request *search_req;
+ int ret;
if (ldb_dn_is_special(req->op.mod.message->dn)) {
/* do not manipulate our control entries */
return ldb_next_request(module, req);
}
-
- ac = linked_attributes_init_handle(req, module);
+ ac = linked_attributes_init(module, req);
if (!ac) {
return LDB_ERR_OPERATIONS_ERROR;
}
-
- /* prepare the first operation */
- ac->step = LA_DO_OPS;
+
+ if (!ac->schema) {
+ /* without schema, this doesn't make any sense */
+ return ldb_next_request(module, req);
+ }
+
+ ac->rc = NULL;
for (i=0; i < req->op.mod.message->num_elements; i++) {
- int ret;
- struct ldb_request *new_req;
+ bool store_el = false;
+ const char *attr_name;
+ const char *attr_val;
const struct dsdb_attribute *target_attr;
const struct ldb_message_element *el = &req->op.mod.message->elements[i];
const struct dsdb_attribute *schema_attr
- = dsdb_attribute_by_lDAPDisplayName(schema, el->name);
+ = dsdb_attribute_by_lDAPDisplayName(ac->schema, el->name);
if (!schema_attr) {
ldb_asprintf_errstring(module->ldb,
- "attribute %s is not a valid attribute in schema", req->op.mod.message->elements[i].name);
+ "attribute %s is not a valid attribute in schema", el->name);
return LDB_ERR_OBJECT_CLASS_VIOLATION;
}
- /* We have a valid attribute, not find out if it is linked */
+ /* We have a valid attribute, now find out if it is linked */
if (schema_attr->linkID == 0) {
continue;
}
if ((schema_attr->linkID & 1) == 1) {
- /* Odd is for the target. Illigal to modify */
+ /* Odd is for the target. Illegal to modify */
ldb_asprintf_errstring(module->ldb,
- "attribute %s must not be modified directly, it is a linked attribute", req->op.mod.message->elements[i].name);
+ "attribute %s must not be modified directly, it is a linked attribute", el->name);
return LDB_ERR_UNWILLING_TO_PERFORM;
}
/* Even link IDs are for the originating attribute */
/* Now find the target attribute */
- target_attr = dsdb_attribute_by_linkID(schema, schema_attr->linkID + 1);
+ target_attr = dsdb_attribute_by_linkID(ac->schema, schema_attr->linkID + 1);
if (!target_attr) {
- ldb_asprintf_errstring(module->ldb,
- "attribute %s does not have valid link target", req->op.mod.message->elements[i].name);
- return LDB_ERR_OBJECT_CLASS_VIOLATION;
+ /*
+ * windows 2003 has a broken schema where
+ * the definition of msDS-IsDomainFor
+ * is missing (which is supposed to be
+ * the backlink of the msDS-HasDomainNCs
+ * attribute
+ */
+ continue;
}
- /* Replace with new set of values */
- if (((el->flags & LDB_FLAG_MOD_MASK) == LDB_FLAG_MOD_REPLACE)
- && el->num_values > 0) {
- struct replace_context *ac2 = talloc(ac, struct replace_context);
- const char **attrs = talloc_array(ac, const char *, 2);
- if (!attrs || !ac2) {
- ldb_oom(ac->module->ldb);
- return LDB_ERR_OPERATIONS_ERROR;
- }
- attrs[0] = el->name;
- attrs[1] = NULL;
-
- ac2->ac = ac;
- ac2->el = el;
-
- /* We need to setup a search, compare with the list, and then setup add/del as required */
-
- /* The callback does all the hard work here */
- ret = ldb_build_search_req(&new_req, module->ldb, req,
- req->op.mod.message->dn,
- LDB_SCOPE_BASE,
- "(objectClass=*)",
- attrs,
- NULL,
- ac2,
- linked_attributes_mod_replace_search_callback);
-
- if (ret != LDB_SUCCESS) {
- return ret;
- }
-
- talloc_steal(new_req, attrs);
-
- ret = ldb_set_timeout_from_prev_req(module->ldb, req, new_req);
-
- if (ret != LDB_SUCCESS) {
- return ret;
- }
+ attr_name = target_attr->lDAPDisplayName;
+ attr_val = ldb_dn_get_linearized(ac->req->op.mod.message->dn);
- /* Create a spot in the list for the requests */
- ac->down_req = talloc_realloc(ac, ac->down_req,
- struct ldb_request *, ac->num_requests + 1);
- if (!ac->down_req) {
- ldb_oom(ac->module->ldb);
- return LDB_ERR_OPERATIONS_ERROR;
- }
+ switch (el->flags & LDB_FLAG_MOD_MASK) {
+ case LDB_FLAG_MOD_REPLACE:
+ /* treat as just a normal add the delete part is handled by the callback */
+ store_el = true;
- ac->down_req[ac->num_requests] = talloc_steal(ac->down_req, new_req);
- ac->num_requests++;
+ /* break intentionally missing */
- ret = ldb_next_request(module, new_req);
-
- if (ret != LDB_SUCCESS) {
- return ret;
- }
-
- continue;
+ case LDB_FLAG_MOD_ADD:
- /* Delete all values case */
- } else if (((el->flags & LDB_FLAG_MOD_MASK) & (LDB_FLAG_MOD_DELETE|LDB_FLAG_MOD_REPLACE))
- && el->num_values == 0) {
- const char **attrs = talloc_array(ac, const char *, 2);
- if (!attrs) {
- ldb_oom(ac->module->ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ /* For each value being added, we need to setup the adds */
+ for (j = 0; j < el->num_values; j++) {
+ ret = la_store_op(ac, LA_OP_ADD,
+ (char *)el->values[j].data,
+ attr_name, attr_val);
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
}
- attrs[0] = el->name;
- attrs[1] = NULL;
-
- /* We need to setup a search, and then setup del as required */
-
- /* The callback does all the hard work here, acting identically to if we had delted the whole entry */
- ret = ldb_build_search_req(&new_req, module->ldb, req,
- req->op.mod.message->dn,
- LDB_SCOPE_BASE,
- "(objectClass=*)",
- attrs,
- NULL,
- ac,
- linked_attributes_rename_del_search_callback);
+ break;
- if (ret != LDB_SUCCESS) {
- return ret;
- }
-
- talloc_steal(new_req, attrs);
-
- ret = ldb_set_timeout_from_prev_req(module->ldb, req, new_req);
-
- if (ret != LDB_SUCCESS) {
- return ret;
- }
+ case LDB_FLAG_MOD_DELETE:
- /* Create a spot in the list for the requests */
- ac->down_req = talloc_realloc(ac, ac->down_req,
- struct ldb_request *, ac->num_requests + 1);
- if (!ac->down_req) {
- ldb_oom(ac->module->ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ if (el->num_values) {
+ /* For each value being deleted, we need to setup the delete */
+ for (j = 0; j < el->num_values; j++) {
+ ret = la_store_op(ac, LA_OP_DEL,
+ (char *)el->values[j].data,
+ attr_name, attr_val);
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
+ }
+ } else {
+ store_el = true;
}
- ac->down_req[ac->num_requests] = talloc_steal(ac->down_req, new_req);
- ac->num_requests++;
-
- ret = ldb_next_request(module, new_req);
-
- if (ret != LDB_SUCCESS) {
- return ret;
- }
-
- continue;
+ break;
}
- /* Prepare the modify (mod element) on the targets, for a normal modify request */
-
- /* For each value being moded, we need to setup the modify */
- for (j=0; j < el->num_values; j++) {
- /* Create the modify request */
- struct ldb_message *new_msg = ldb_msg_new(ac);
- if (!new_msg) {
- ldb_oom(module->ldb);
- return LDB_ERR_OPERATIONS_ERROR;
- }
- new_msg->dn = ldb_dn_from_ldb_val(new_msg, module->ldb, &el->values[j]);
- if (!new_msg->dn) {
- ldb_asprintf_errstring(module->ldb,
- "attribute %s value %s was not a valid DN", req->op.mod.message->elements[i].name,
- el->values[j].data);
- return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX;
- }
+ if (store_el) {
+ struct ldb_message_element *search_el;
- ret = ldb_msg_add_empty(new_msg, target_attr->lDAPDisplayName,
- el->flags & LDB_FLAG_MOD_MASK, NULL);
- if (ret != LDB_SUCCESS) {
- return ret;
- }
-
- ret = ldb_msg_add_string(new_msg, target_attr->lDAPDisplayName,
- ldb_dn_get_linearized(ac->orig_req->op.add.message->dn));
- if (ret != LDB_SUCCESS) {
- return ret;
+ if (!ac->rc) {
+ ac->rc = talloc_zero(ac, struct replace_context);
+ if (!ac->rc) {
+ ldb_oom(module->ldb);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
}
- ret = ldb_build_mod_req(&new_req, module->ldb, ac,
- new_msg,
- NULL,
- NULL,
- NULL);
- if (ret != LDB_SUCCESS) {
- return ret;
- }
-
- talloc_steal(new_req, new_msg);
-
- ret = ldb_set_timeout_from_prev_req(module->ldb, req, new_req);
-
- if (ret != LDB_SUCCESS) {
- return ret;
- }
-
- /* Now add it to the list */
- ac->down_req = talloc_realloc(ac, ac->down_req,
- struct ldb_request *, ac->num_requests + 1);
- if (!ac->down_req) {
- ldb_oom(ac->module->ldb);
+ search_el = talloc_realloc(ac->rc, ac->rc->el,
+ struct ldb_message_element,
+ ac->rc->num_elements +1);
+ if (!search_el) {
+ ldb_oom(module->ldb);
return LDB_ERR_OPERATIONS_ERROR;
}
- ac->down_req[ac->num_requests] = talloc_steal(ac->down_req, new_req);
- ac->num_requests++;
+ ac->rc->el = search_el;
- /* Run the new request */
- ret = ldb_next_request(module, new_req);
- if (ret != LDB_SUCCESS) {
- return ret;
- }
+ ac->rc->el[ac->rc->num_elements] = *el;
+ ac->rc->num_elements++;
}
}
- return LDB_SUCCESS;
-}
-static int linked_attributes_rename_del_search_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
-{
- struct linked_attributes_context *ac = talloc_get_type(context, struct linked_attributes_context);
- struct ldb_dn *olddn, *newdn;
-
- switch (ac->orig_req->operation) {
- case LDB_DELETE:
- {
- olddn = ac->orig_req->op.del.dn;
- newdn = NULL;
- break;
- }
- /* This isn't the general modify case, just the modify when we are asked to delete all values */
- case LDB_MODIFY:
- {
- olddn = ac->orig_req->op.mod.message->dn;
- newdn = NULL;
- break;
- }
- case LDB_RENAME:
- {
- olddn = ac->orig_req->op.rename.olddn;
- newdn = ac->orig_req->op.rename.newdn;
- break;
- }
- default:
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
+ /* both replace and delete without values are handled in the callback
+ * after the search on the entry to be modified is performed */
+ if (ac->rc) {
+ const char **attrs;
+
+ attrs = talloc_array(ac->rc, const char *, ac->rc->num_elements +1);
+ if (!attrs) {
+ ldb_oom(module->ldb);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ for (i = 0; i < ac->rc->num_elements; i++) {
+ attrs[i] = ac->rc->el[i].name;
+ }
+ attrs[i] = NULL;
- /* OK, we have one search result here: */
+ /* The callback does all the hard work here */
+ ret = ldb_build_search_req(&search_req, module->ldb, ac,
+ req->op.mod.message->dn,
+ LDB_SCOPE_BASE,
+ "(objectClass=*)", attrs,
+ NULL,
+ ac, la_mod_search_callback,
+ req);
- /* Only entries are interesting, and we only want the olddn */
- if (ares->type == LDB_REPLY_ENTRY
- && ldb_dn_compare(ares->message->dn, olddn) == 0) {
- /* only bother at all if there were some linked attributes found */
- if (ares->message->num_elements > 0) {
- return setup_modifies(ldb, ac, ac,
- ares->message, olddn, newdn);
+ if (ret == LDB_SUCCESS) {
+ talloc_steal(search_req, attrs);
+
+ ret = ldb_next_request(module, search_req);
}
- talloc_free(ares);
- return LDB_SUCCESS;
- } else if (ares->type == LDB_REPLY_ENTRY) {
- /* Guh? We only asked for this DN */
- return LDB_ERR_OPERATIONS_ERROR;
} else {
- talloc_free(ares);
- return LDB_SUCCESS;
+ if (ac->ops) {
+ /* start the mod requests chain */
+ ret = la_do_mod_request(ac);
+ } else {
+ /* nothing to do for this module, proceed */
+ talloc_free(ac);
+ ret = ldb_next_request(module, req);
+ }
}
-
-
+
+ return ret;
}
-/* rename */
-static int linked_attributes_rename(struct ldb_module *module, struct ldb_request *req)
+
+/* delete, rename */
+static int linked_attributes_op(struct ldb_module *module, struct ldb_request *req)
{
- /* Look up list of linked attributes */
+ struct ldb_request *search_req;
+ struct ldb_dn *base_dn;
+ struct la_context *ac;
const char **attrs;
WERROR werr;
int ret;
- struct linked_attributes_context *ac;
- struct ldb_request *new_req;
- const struct dsdb_schema *schema = dsdb_get_schema(module->ldb);
- if (!schema) {
- /* without schema, this doesn't make any sense */
- return ldb_next_request(module, req);
- }
/* This gets complex: We need to:
- - Do a search for the entry
+ - Do a search for the entry
- Wait for these result to appear
- - In the callback for the result, issue a modify request based on the linked attributes found
+ - In the callback for the result, issue a modify
+ request based on the linked attributes found
- Wait for each modify result
- - Regain our sainity
+ - Regain our sainity
*/
- ac = linked_attributes_init_handle(req, module);
+ switch (req->operation) {
+ case LDB_RENAME:
+ base_dn = req->op.rename.olddn;
+ break;
+ case LDB_DELETE:
+ base_dn = req->op.del.dn;
+ break;
+ default:
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ ac = linked_attributes_init(module, req);
if (!ac) {
return LDB_ERR_OPERATIONS_ERROR;
}
-
- werr = dsdb_linked_attribute_lDAPDisplayName_list(schema, ac, &attrs);
+
+ if (!ac->schema) {
+ /* without schema, this doesn't make any sense */
+ return ldb_next_request(module, req);
+ }
+
+ werr = dsdb_linked_attribute_lDAPDisplayName_list(ac->schema, ac, &attrs);
if (!W_ERROR_IS_OK(werr)) {
return LDB_ERR_OPERATIONS_ERROR;
}
-
- ret = ldb_build_search_req(&new_req, module->ldb, req,
- req->op.rename.olddn,
- LDB_SCOPE_BASE,
- "(objectClass=*)",
- attrs,
- NULL,
- ac,
- linked_attributes_rename_del_search_callback);
+
+ ret = ldb_build_search_req(&search_req, module->ldb, req,
+ base_dn, LDB_SCOPE_BASE,
+ "(objectClass=*)", attrs,
+ NULL,
+ ac, la_op_search_callback,
+ req);
if (ret != LDB_SUCCESS) {
return ret;
}
- talloc_steal(new_req, attrs);
+ talloc_steal(search_req, attrs);
- ret = ldb_set_timeout_from_prev_req(module->ldb, req, new_req);
+ return ldb_next_request(module, search_req);
+}
- if (ret != LDB_SUCCESS) {
- return ret;
+static int la_op_search_callback(struct ldb_request *req,
+ struct ldb_reply *ares)
+{
+ struct la_context *ac;
+ const struct dsdb_attribute *schema_attr;
+ const struct dsdb_attribute *target_attr;
+ const struct ldb_message_element *el;
+ const char *attr_name;
+ const char *deldn;
+ const char *adddn;
+ int i, j;
+ int ret;
+
+ ac = talloc_get_type(req->context, struct la_context);
+
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
+
+ /* Only entries are interesting, and we only want the olddn */
+ switch (ares->type) {
+ case LDB_REPLY_ENTRY:
+ ret = ldb_dn_compare(ares->message->dn, req->op.search.base);
+ if (ret != 0) {
+ /* Guh? We only asked for this DN */
+ talloc_free(ares);
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->message->num_elements == 0) {
+ /* only bother at all if there were some
+ * linked attributes found */
+ talloc_free(ares);
+ return LDB_SUCCESS;
+ }
+
+ switch (ac->req->operation) {
+ case LDB_DELETE:
+ deldn = ldb_dn_get_linearized(ac->req->op.del.dn);
+ adddn = NULL;
+ break;
+ case LDB_RENAME:
+ deldn = ldb_dn_get_linearized(ac->req->op.rename.olddn);
+ adddn = ldb_dn_get_linearized(ac->req->op.rename.newdn);
+ break;
+ default:
+ talloc_free(ares);
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+
+ for (i = 0; i < ares->message->num_elements; i++) {
+ el = &ares->message->elements[i];
+
+ schema_attr = dsdb_attribute_by_lDAPDisplayName(ac->schema, el->name);
+ if (!schema_attr) {
+ ldb_asprintf_errstring(ac->module->ldb,
+ "attribute %s is not a valid attribute"
+ " in schema", el->name);
+ talloc_free(ares);
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OBJECT_CLASS_VIOLATION);
+ }
+
+ /* Valid attribute, now find out if it is linked */
+ if (schema_attr->linkID == 0) {
+ /* Not a linked attribute, skip */
+ continue;
+ }
+
+ if ((schema_attr->linkID & 1) == 0) {
+ /* Odd is for the target. */
+ target_attr = dsdb_attribute_by_linkID(ac->schema, schema_attr->linkID + 1);
+ if (!target_attr) {
+ continue;
+ }
+ attr_name = target_attr->lDAPDisplayName;
+ } else {
+ target_attr = dsdb_attribute_by_linkID(ac->schema, schema_attr->linkID - 1);
+ if (!target_attr) {
+ continue;
+ }
+ attr_name = target_attr->lDAPDisplayName;
+ }
+ for (j = 0; j < el->num_values; j++) {
+ ret = la_store_op(ac, LA_OP_DEL,
+ (char *)el->values[j].data,
+ attr_name, deldn);
+ if (ret != LDB_SUCCESS) {
+ talloc_free(ares);
+ return ldb_module_done(ac->req,
+ NULL, NULL, ret);
+ }
+ if (!adddn) continue;
+ ret = la_store_op(ac, LA_OP_ADD,
+ (char *)el->values[j].data,
+ attr_name, adddn);
+ if (ret != LDB_SUCCESS) {
+ talloc_free(ares);
+ return ldb_module_done(ac->req,
+ NULL, NULL, ret);
+ }
+ }
+ }
+
+ break;
+
+ case LDB_REPLY_REFERRAL:
+ /* ignore */
+ break;
+
+ case LDB_REPLY_DONE:
+
+ talloc_free(ares);
+
+ if (ac->ops) {
+ /* start the mod requests chain */
+ ret = la_do_mod_request(ac);
+ } else {
+ ret = la_down_req(ac);
+ }
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL, ret);
+ }
+ return LDB_SUCCESS;
}
- ac->search_req = new_req;
- ac->step = LA_SEARCH;
- return ldb_next_request(module, new_req);
+ talloc_free(ares);
+ return LDB_SUCCESS;
}
-/* delete */
-static int linked_attributes_delete(struct ldb_module *module, struct ldb_request *req)
+/* do a linked attributes modify request */
+static int la_do_mod_request(struct la_context *ac)
{
- /* Look up list of linked attributes */
- const char **attrs;
- WERROR werr;
+ struct ldb_message_element *ret_el;
+ struct ldb_request *mod_req;
+ struct ldb_message *new_msg;
+ struct ldb_context *ldb;
int ret;
- struct ldb_request *new_req;
- struct linked_attributes_context *ac;
- const struct dsdb_schema *schema = dsdb_get_schema(module->ldb);
- if (!schema) {
- /* without schema, this doesn't make any sense */
- return ldb_next_request(module, req);
- }
- /* This gets complex: We need to:
- - Do a search for the entry
- - Wait for these result to appear
- - In the callback for the result, issue a modify request based on the linked attributes found
- - Wait for each modify result
- - Regain our sainity
- */
+ ldb = ac->module->ldb;
- ac = linked_attributes_init_handle(req, module);
- if (!ac) {
+ /* Create the modify request */
+ new_msg = ldb_msg_new(ac);
+ if (!new_msg) {
+ ldb_oom(ldb);
return LDB_ERR_OPERATIONS_ERROR;
}
-
- werr = dsdb_linked_attribute_lDAPDisplayName_list(schema, ac, &attrs);
- if (!W_ERROR_IS_OK(werr)) {
+ new_msg->dn = ldb_dn_copy(new_msg, ac->ops->dn);
+ if (!new_msg->dn) {
return LDB_ERR_OPERATIONS_ERROR;
- };
-
- ret = ldb_build_search_req(&new_req, module->ldb, req,
- req->op.del.dn,
- LDB_SCOPE_BASE,
- "(objectClass=*)",
- attrs,
- NULL,
- ac,
- linked_attributes_rename_del_search_callback);
+ }
+ if (ac->ops->op == LA_OP_ADD) {
+ ret = ldb_msg_add_empty(new_msg, ac->ops->name,
+ LDB_FLAG_MOD_ADD, &ret_el);
+ } else {
+ ret = ldb_msg_add_empty(new_msg, ac->ops->name,
+ LDB_FLAG_MOD_DELETE, &ret_el);
+ }
if (ret != LDB_SUCCESS) {
return ret;
}
-
- talloc_steal(new_req, attrs);
-
- ret = ldb_set_timeout_from_prev_req(module->ldb, req, new_req);
-
+ ret_el->values = talloc_array(new_msg, struct ldb_val, 1);
+ if (!ret_el->values) {
+ ldb_oom(ldb);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ ret_el->values[0] = data_blob_string_const(ac->ops->value);
+ ret_el->num_values = 1;
+
+ /* use ac->ops as the mem_ctx so that the request will be freed
+ * in the callback as soon as completed */
+ ret = ldb_build_mod_req(&mod_req, ldb, ac->ops,
+ new_msg,
+ NULL,
+ ac, la_mod_callback,
+ ac->req);
if (ret != LDB_SUCCESS) {
return ret;
}
+ talloc_steal(mod_req, new_msg);
- ac->search_req = new_req;
- ac->step = LA_SEARCH;
- return ldb_next_request(module, new_req);
+ /* Run the new request */
+ return ldb_next_request(ac->module, mod_req);
}
+static int la_mod_callback(struct ldb_request *req, struct ldb_reply *ares)
+{
+ struct la_context *ac;
+ struct la_op_store *os;
+ int ret;
-static int linked_attributes_wait_none(struct ldb_handle *handle) {
- struct linked_attributes_context *ac;
- int i, ret = LDB_ERR_OPERATIONS_ERROR;
- if (!handle || !handle->private_data) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
+ ac = talloc_get_type(req->context, struct la_context);
- if (handle->state == LDB_ASYNC_DONE) {
- return handle->status;
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
}
- handle->state = LDB_ASYNC_PENDING;
- handle->status = LDB_SUCCESS;
-
- ac = talloc_get_type(handle->private_data, struct linked_attributes_context);
-
- switch (ac->step) {
- case LA_SEARCH:
- ret = ldb_wait(ac->search_req->handle, LDB_WAIT_NONE);
-
- if (ret != LDB_SUCCESS) {
- handle->status = ret;
- goto done;
- }
- if (ac->search_req->handle->status != LDB_SUCCESS) {
- handle->status = ac->search_req->handle->status;
- goto done;
- }
-
- if (ac->search_req->handle->state != LDB_ASYNC_DONE) {
- return LDB_SUCCESS;
- }
- ac->step = LA_DO_OPS;
- return LDB_SUCCESS;
+ if (ares->type != LDB_REPLY_DONE) {
+ ldb_set_errstring(ac->module->ldb,
+ "invalid ldb_reply_type in callback");
+ talloc_free(ares);
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
- case LA_DO_OPS:
- for (i=0; i < ac->num_requests; i++) {
- ret = ldb_wait(ac->down_req[i]->handle, LDB_WAIT_NONE);
-
- if (ret != LDB_SUCCESS) {
- handle->status = ret;
- goto done;
- }
- if (ac->down_req[i]->handle->status != LDB_SUCCESS) {
- handle->status = ac->down_req[i]->handle->status;
- goto done;
- }
-
- if (ac->down_req[i]->handle->state != LDB_ASYNC_DONE) {
- return LDB_SUCCESS;
- }
- }
+ talloc_free(ares);
- /* Now run the original request */
- ac->step = LA_DO_ORIG;
- return ldb_next_request(ac->module, ac->orig_down_req);
+ if (ac->ops) {
+ os = ac->ops;
+ ac->ops = os->next;
- case LA_DO_ORIG:
- ret = ldb_wait(ac->orig_down_req->handle, LDB_WAIT_NONE);
-
- if (ret != LDB_SUCCESS) {
- handle->status = ret;
- goto done;
- }
- if (ac->orig_down_req->handle->status != LDB_SUCCESS) {
- handle->status = ac->orig_down_req->handle->status;
- goto done;
- }
-
- if (ac->orig_down_req->handle->state != LDB_ASYNC_DONE) {
- return LDB_SUCCESS;
- }
- ret = LDB_SUCCESS;
+ /* this frees the request too
+ * DO NOT access 'req' after this point */
+ talloc_free(os);
}
-done:
- handle->state = LDB_ASYNC_DONE;
- return ret;
+ /* as last op run the original request */
+ if (ac->ops) {
+ ret = la_do_mod_request(ac);
+ } else {
+ ret = la_down_req(ac);
+ }
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL, ret);
+ }
+ return LDB_SUCCESS;
}
-static int linked_attributes_wait_all(struct ldb_handle *handle) {
-
+static int la_down_req(struct la_context *ac)
+{
+ struct ldb_request *down_req;
int ret;
- while (handle->state != LDB_ASYNC_DONE) {
- ret = linked_attributes_wait_none(handle);
- if (ret != LDB_SUCCESS) {
- return ret;
- }
+ switch (ac->req->operation) {
+ case LDB_ADD:
+ ret = ldb_build_add_req(&down_req, ac->module->ldb, ac,
+ ac->req->op.add.message,
+ ac->req->controls,
+ ac, la_down_callback,
+ ac->req);
+ break;
+ case LDB_MODIFY:
+ ret = ldb_build_mod_req(&down_req, ac->module->ldb, ac,
+ ac->req->op.mod.message,
+ ac->req->controls,
+ ac, la_down_callback,
+ ac->req);
+ break;
+ case LDB_DELETE:
+ ret = ldb_build_del_req(&down_req, ac->module->ldb, ac,
+ ac->req->op.del.dn,
+ ac->req->controls,
+ ac, la_down_callback,
+ ac->req);
+ break;
+ case LDB_RENAME:
+ ret = ldb_build_rename_req(&down_req, ac->module->ldb, ac,
+ ac->req->op.rename.olddn,
+ ac->req->op.rename.newdn,
+ ac->req->controls,
+ ac, la_down_callback,
+ ac->req);
+ break;
+ default:
+ ret = LDB_ERR_OPERATIONS_ERROR;
+ }
+ if (ret != LDB_SUCCESS) {
+ return ret;
}
- return handle->status;
+ return ldb_next_request(ac->module, down_req);
}
-static int linked_attributes_wait(struct ldb_handle *handle, enum ldb_wait_type type)
+static int la_down_callback(struct ldb_request *req, struct ldb_reply *ares)
{
- if (type == LDB_WAIT_ALL) {
- return linked_attributes_wait_all(handle);
- } else {
- return linked_attributes_wait_none(handle);
+ struct la_context *ac;
+
+ ac = talloc_get_type(req->context, struct la_context);
+
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
+
+ if (ares->type != LDB_REPLY_DONE) {
+ ldb_set_errstring(ac->module->ldb,
+ "invalid ldb_reply_type in callback");
+ talloc_free(ares);
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
+
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
}
_PUBLIC_ const struct ldb_module_ops ldb_linked_attributes_module_ops = {
.name = "linked_attributes",
.add = linked_attributes_add,
.modify = linked_attributes_modify,
- .del = linked_attributes_delete,
- .rename = linked_attributes_rename,
- .wait = linked_attributes_wait,
+ .del = linked_attributes_op,
+ .rename = linked_attributes_op,
};
/*
ldb database module
- Copyright (C) Simo Sorce 2004-2006
+ Copyright (C) Simo Sorce 2004-2008
Copyright (C) Andrew Bartlett <abartlet@samba.org> 2005-2006
Copyright (C) Andrew Tridgell 2004
This allows the password database to be syncronised in a multi-master
fashion, seperate to the more difficult concerns of the main
database. (With passwords, the last writer always wins)
-
+
Each incoming add/modify is split into a remote, and a local request, done in that order.
We maintain a list of attributes that are kept locally:
/* And we merge them back into search requests when asked to do so */
-struct lpdb_context {
+struct lpdb_reply {
+ struct lpdb_reply *next;
+ struct ldb_reply *remote;
+ struct ldb_dn *local_dn;
+};
- enum lpdb_type {LPDB_ADD, LPDB_MOD, LPDB_SEARCH} type;
- enum lpdb_step {LPDB_ADD_REMOTE, LPDB_MOD_REMOTE, LPDB_MOD_SEARCH_SELF, LPDB_LOCAL, LPDB_SEARCH_REMOTE} step;
+struct lpdb_context {
struct ldb_module *module;
- struct ldb_request *orig_req;
- struct ldb_request *remote_req;
- struct ldb_request *search_req;
- struct ldb_request *local_req;
+ struct ldb_request *req;
struct ldb_message *local_message;
+ struct lpdb_reply *list;
+ struct lpdb_reply *current;
+ struct ldb_reply *remote_done;
+ struct ldb_reply *remote;
+
bool added_objectGUID;
bool added_objectClass;
- struct ldb_reply *search_res;
-};
-
-struct lpdb_local_search_context {
- struct lpdb_context *ac;
- struct ldb_reply *remote_res;
- struct ldb_reply *local_res;
};
-static struct ldb_handle *lpdb_init_handle(struct ldb_request *req, struct ldb_module *module, enum lpdb_type type)
+static struct lpdb_context *lpdb_init_context(struct ldb_module *module,
+ struct ldb_request *req)
{
struct lpdb_context *ac;
- struct ldb_handle *h;
- h = talloc_zero(req, struct ldb_handle);
- if (h == NULL) {
+ ac = talloc_zero(req, struct lpdb_context);
+ if (ac == NULL) {
ldb_set_errstring(module->ldb, "Out of Memory");
return NULL;
}
- h->module = module;
+ ac->module = module;
+ ac->req = req;
- ac = talloc_zero(h, struct lpdb_context);
- if (ac == NULL) {
- ldb_set_errstring(module->ldb, "Out of Memory");
- talloc_free(h);
- return NULL;
- }
+ return ac;
+}
- h->private_data = (void *)ac;
+static int lpdb_local_callback(struct ldb_request *req, struct ldb_reply *ares)
+{
+ struct lpdb_context *ac;
- h->state = LDB_ASYNC_INIT;
- h->status = LDB_SUCCESS;
+ ac = talloc_get_type(req->context, struct lpdb_context);
- ac->type = type;
- ac->module = module;
- ac->orig_req = req;
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
+
+ if (ares->type != LDB_REPLY_DONE) {
+ ldb_set_errstring(ac->module->ldb, "Unexpected reply type");
+ talloc_free(ares);
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
- return h;
+ talloc_free(ares);
+ return ldb_module_done(ac->req,
+ ac->remote_done->controls,
+ ac->remote_done->response,
+ ac->remote_done->error);
}
-/* Add a record, splitting password attributes from the user's main
- * record */
+/*****************************************************************************
+ * ADD
+ ****************************************************************************/
+
+static int lpdb_add_callback(struct ldb_request *req,
+ struct ldb_reply *ares);
static int local_password_add(struct ldb_module *module, struct ldb_request *req)
{
- struct ldb_handle *h;
- struct lpdb_context *ac;
struct ldb_message *remote_message;
- struct ldb_message *local_message;
+ struct ldb_request *remote_req;
+ struct lpdb_context *ac;
struct GUID objectGUID;
+ int ret;
int i;
ldb_debug(module->ldb, LDB_DEBUG_TRACE, "local_password_add\n");
}
/* From here, we assume we have password attributes to split off */
- h = lpdb_init_handle(req, module, LPDB_ADD);
- if (!h) {
+ ac = lpdb_init_context(module, req);
+ if (!ac) {
return LDB_ERR_OPERATIONS_ERROR;
}
- ac = talloc_get_type(h->private_data, struct lpdb_context);
- ac->orig_req = req;
-
- ac->remote_req = talloc(ac, struct ldb_request);
- if (ac->remote_req == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- *(ac->remote_req) = *(ac->orig_req);
-
- remote_message = ldb_msg_copy_shallow(ac->remote_req, ac->orig_req->op.add.message);
+ remote_message = ldb_msg_copy_shallow(remote_req, req->op.add.message);
if (remote_message == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
ldb_msg_remove_attr(remote_message, password_attrs[i]);
}
- ac->remote_req->op.add.message = remote_message;
-
- ac->remote_req->context = NULL;
- ac->remote_req->callback = NULL;
-
- ac->local_req = talloc(ac, struct ldb_request);
- if (ac->local_req == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
+ /* Find the objectGUID to use as the key */
+ objectGUID = samdb_result_guid(ac->req->op.add.message, "objectGUID");
- *(ac->local_req) = *(ac->orig_req);
- local_message = ldb_msg_copy_shallow(ac->local_req, ac->orig_req->op.add.message);
- if (local_message == NULL) {
+ ac->local_message = ldb_msg_copy_shallow(ac, req->op.add.message);
+ if (ac->local_message == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
/* Remove anything seen in the remote message from the local
* message (leaving only password attributes) */
- for (i=0;i<ac->remote_req->op.add.message->num_elements;i++) {
- ldb_msg_remove_attr(local_message, ac->remote_req->op.add.message->elements[i].name);
+ for (i=0; i < remote_message->num_elements; i++) {
+ ldb_msg_remove_attr(ac->local_message, remote_message->elements[i].name);
}
/* We must have an objectGUID already, or we don't know where
* to add the password. This may be changed to an 'add and
* search', to allow the directory to create the objectGUID */
- if (ldb_msg_find_ldb_val(ac->orig_req->op.add.message, "objectGUID") == NULL) {
- ldb_set_errstring(module->ldb,
- "no objectGUID found in search: local_password module must be configured below objectGUID module!\n");
+ if (ldb_msg_find_ldb_val(req->op.add.message, "objectGUID") == NULL) {
+ ldb_set_errstring(module->ldb,
+ "no objectGUID found in search: "
+ "local_password module must be "
+ "onfigured below objectGUID module!\n");
return LDB_ERR_CONSTRAINT_VIOLATION;
}
- /* Find the objectGUID to use as the key */
- objectGUID = samdb_result_guid(ac->orig_req->op.add.message, "objectGUID");
-
- local_message->dn = ldb_dn_new(local_message, module->ldb, LOCAL_BASE);
- ldb_dn_add_child_fmt(local_message->dn, PASSWORD_GUID_ATTR "=%s", GUID_string(local_message, &objectGUID));
-
- ac->local_req->op.add.message = local_message;
-
- ac->local_req->context = NULL;
- ac->local_req->callback = NULL;
-
- ac->step = LPDB_ADD_REMOTE;
+ ac->local_message->dn = ldb_dn_new(ac->local_message,
+ module->ldb, LOCAL_BASE);
+ if ((ac->local_message->dn == NULL) ||
+ ( ! ldb_dn_add_child_fmt(ac->local_message->dn,
+ PASSWORD_GUID_ATTR "=%s",
+ GUID_string(ac->local_message,
+ &objectGUID)))) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
- /* Return our own handle do deal with this call */
- req->handle = h;
+ ret = ldb_build_add_req(&remote_req, module->ldb, ac,
+ remote_message,
+ req->controls,
+ ac, lpdb_add_callback,
+ req);
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
- return ldb_next_request(module, ac->remote_req);
+ return ldb_next_request(module, remote_req);
}
-/* After adding the remote entry, add the local one */
-static int local_password_add_local(struct ldb_handle *h) {
-
+/* Add a record, splitting password attributes from the user's main
+ * record */
+static int lpdb_add_callback(struct ldb_request *req,
+ struct ldb_reply *ares)
+{
+ struct ldb_request *local_req;
struct lpdb_context *ac;
- ac = talloc_get_type(h->private_data, struct lpdb_context);
+ int ret;
+
+ ac = talloc_get_type(req->context, struct lpdb_context);
- h->state = LDB_ASYNC_INIT;
- h->status = LDB_SUCCESS;
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
- ac->step = LPDB_LOCAL;
+ if (ares->type != LDB_REPLY_DONE) {
+ ldb_set_errstring(ac->module->ldb, "Unexpected reply type");
+ talloc_free(ares);
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
- ldb_set_timeout_from_prev_req(ac->module->ldb, ac->orig_req, ac->local_req);
+ ac->remote_done = talloc_steal(ac, ares);
- /* perform the local add */
- return ldb_next_request(ac->module, ac->local_req);
+ ret = ldb_build_add_req(&local_req, ac->module->ldb, ac,
+ ac->local_message,
+ NULL,
+ ac, lpdb_local_callback,
+ ac->req);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL, ret);
+ }
+
+ ret = ldb_next_request(ac->module, local_req);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL, ret);
+ }
+ return LDB_SUCCESS;
}
-static int local_password_mod_search_self(struct ldb_handle *h);
+/*****************************************************************************
+ * MODIFY
+ ****************************************************************************/
+
+static int lpdb_modify_callabck(struct ldb_request *req,
+ struct ldb_reply *ares);
+static int lpdb_mod_search_callback(struct ldb_request *req,
+ struct ldb_reply *ares);
static int local_password_modify(struct ldb_module *module, struct ldb_request *req)
{
- struct ldb_handle *h;
struct lpdb_context *ac;
struct ldb_message *remote_message;
- struct ldb_message *local_message;
+ struct ldb_request *remote_req;
+ int ret;
int i;
ldb_debug(module->ldb, LDB_DEBUG_TRACE, "local_password_modify\n");
}
/* From here, we assume we have password attributes to split off */
- h = lpdb_init_handle(req, module, LPDB_MOD);
- if (!h) {
+ ac = lpdb_init_context(module, req);
+ if (!ac) {
return LDB_ERR_OPERATIONS_ERROR;
}
- ac = talloc_get_type(h->private_data, struct lpdb_context);
- ac->orig_req = req;
-
- ac->remote_req = talloc(ac, struct ldb_request);
- if (ac->remote_req == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- *(ac->remote_req) = *(ac->orig_req);
- remote_message = ldb_msg_copy_shallow(ac->remote_req, ac->orig_req->op.mod.message);
+ remote_message = ldb_msg_copy_shallow(ac, ac->req->op.mod.message);
if (remote_message == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
-
+
/* Remove any password attributes from the remote message */
for (i=0; i < ARRAY_SIZE(password_attrs); i++) {
ldb_msg_remove_attr(remote_message, password_attrs[i]);
}
- ac->remote_req->op.mod.message = remote_message;
-
- ac->remote_req->context = NULL;
- ac->remote_req->callback = NULL;
-
- ac->local_req = talloc(ac, struct ldb_request);
- if (ac->local_req == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- *(ac->local_req) = *(ac->orig_req);
- local_message = ldb_msg_copy_shallow(ac->local_req, ac->orig_req->op.mod.message);
- if (local_message == NULL) {
+ ac->local_message = ldb_msg_copy_shallow(ac, ac->req->op.mod.message);
+ if (ac->local_message == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
/* Remove anything seen in the remote message from the local
* message (leaving only password attributes) */
- for (i=0;i<ac->remote_req->op.mod.message->num_elements;i++) {
- ldb_msg_remove_attr(local_message, ac->remote_req->op.mod.message->elements[i].name);
+ for (i=0; i < remote_message->num_elements;i++) {
+ ldb_msg_remove_attr(ac->local_message, remote_message->elements[i].name);
}
- ac->local_req->op.mod.message = local_message;
- ac->local_message = local_message;
+ ret = ldb_build_mod_req(&remote_req, module->ldb, ac,
+ remote_message,
+ req->controls,
+ ac, lpdb_modify_callabck,
+ req);
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
- ac->local_req->context = NULL;
- ac->local_req->callback = NULL;
+ return ldb_next_request(module, remote_req);
+}
- ac->step = LPDB_MOD_REMOTE;
+/* On a modify, we don't have the objectGUID handy, so we need to
+ * search our DN for it */
+static int lpdb_modify_callabck(struct ldb_request *req,
+ struct ldb_reply *ares)
+{
+ static const char * const attrs[] = { "objectGUID", "objectClass", NULL };
+ struct ldb_request *search_req;
+ struct lpdb_context *ac;
+ int ret;
+
+ ac = talloc_get_type(req->context, struct lpdb_context);
+
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
+
+ if (ares->type != LDB_REPLY_DONE) {
+ ldb_set_errstring(ac->module->ldb, "Unexpected reply type");
+ talloc_free(ares);
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+
+ ac->remote_done = talloc_steal(ac, ares);
- /* Return our own handle do deal with this call */
- req->handle = h;
+ /* prepare the search operation */
+ ret = ldb_build_search_req(&search_req, ac->module->ldb, ac,
+ ac->req->op.mod.message->dn, LDB_SCOPE_BASE,
+ "(objectclass=*)", attrs,
+ NULL,
+ ac, lpdb_mod_search_callback,
+ ac->req);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
- return ldb_next_request(module, ac->remote_req);
+ ret = ldb_next_request(ac->module, search_req);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ return LDB_SUCCESS;
}
-/* Called when we search for our oen entry. Stores the one entry we
+/* Called when we search for our own entry. Stores the one entry we
* expect (as it is a base search) on the context pointer */
-static int get_self_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
+static int lpdb_mod_search_callback(struct ldb_request *req,
+ struct ldb_reply *ares)
{
+ struct ldb_request *local_req;
struct lpdb_context *ac;
+ struct ldb_dn *local_dn;
+ struct GUID objectGUID;
+ int ret = LDB_SUCCESS;
- ac = talloc_get_type(context, struct lpdb_context);
+ ac = talloc_get_type(req->context, struct lpdb_context);
+
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
- /* we are interested only in the single reply (base search) we receive here */
- if (ares->type == LDB_REPLY_ENTRY) {
- if (ac->search_res != NULL) {
- ldb_set_errstring(ldb, "Too many results");
+ switch (ares->type) {
+ case LDB_REPLY_ENTRY:
+ if (ac->remote != NULL) {
+ ldb_set_errstring(ac->module->ldb, "Too many results");
talloc_free(ares);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
- ac->search_res = talloc_steal(ac, ares);
- } else {
+ ac->remote = talloc_steal(ac, ares);
+ break;
+
+ case LDB_REPLY_REFERRAL:
+
+ /* ignore */
+ talloc_free(ares);
+ break;
+
+ case LDB_REPLY_DONE:
+ /* After we find out the objectGUID for the entry, modify the local
+ * password database as required */
+
talloc_free(ares);
+
+ /* if it is not an entry of type person this is an error */
+ /* TODO: remove this when sambaPassword will be in schema */
+ if (ac->remote == NULL) {
+ ldb_asprintf_errstring(ac->module->ldb,
+ "entry just modified (%s) not found!",
+ ldb_dn_get_linearized(req->op.search.base));
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (!ldb_msg_check_string_attribute(ac->remote->message,
+ "objectClass", "person")) {
+ /* Not relevent to us */
+ return ldb_module_done(ac->req,
+ ac->remote_done->controls,
+ ac->remote_done->response,
+ ac->remote_done->error);
+ }
+
+ if (ldb_msg_find_ldb_val(ac->remote->message,
+ "objectGUID") == NULL) {
+ ldb_set_errstring(ac->module->ldb,
+ "no objectGUID found in search: "
+ "local_password module must be "
+ "configured below objectGUID "
+ "module!\n");
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OBJECT_CLASS_VIOLATION);
+ }
+
+ objectGUID = samdb_result_guid(ac->remote->message,
+ "objectGUID");
+
+ local_dn = ldb_dn_new(ac, ac->module->ldb, LOCAL_BASE);
+ if ((local_dn == NULL) ||
+ ( ! ldb_dn_add_child_fmt(local_dn,
+ PASSWORD_GUID_ATTR "=%s",
+ GUID_string(ac, &objectGUID)))) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ ac->local_message->dn = local_dn;
+
+ ret = ldb_build_mod_req(&local_req, ac->module->ldb, ac,
+ ac->local_message,
+ NULL,
+ ac, lpdb_local_callback,
+ ac->req);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL, ret);
+ }
+
+ /* perform the local update */
+ ret = ldb_next_request(ac->module, local_req);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL, ret);
+ }
}
return LDB_SUCCESS;
}
-/* On a modify, we don't have the objectGUID handy, so we need to
- * search our DN for it */
-static int local_password_mod_search_self(struct ldb_handle *h) {
+/*****************************************************************************
+ * DELETE
+ ****************************************************************************/
+static int lpdb_delete_callabck(struct ldb_request *req,
+ struct ldb_reply *ares);
+static int lpdb_del_search_callback(struct ldb_request *req,
+ struct ldb_reply *ares);
+
+static int local_password_delete(struct ldb_module *module,
+ struct ldb_request *req)
+{
+ struct ldb_request *remote_req;
struct lpdb_context *ac;
- static const char * const attrs[] = { "objectGUID", "objectClass", NULL };
+ int ret;
- ac = talloc_get_type(h->private_data, struct lpdb_context);
+ ldb_debug(module->ldb, LDB_DEBUG_TRACE, "local_password_delete\n");
- /* prepare the search operation */
- ac->search_req = talloc_zero(ac, struct ldb_request);
- if (ac->search_req == NULL) {
- ldb_debug(ac->module->ldb, LDB_DEBUG_ERROR, "Out of Memory!\n");
- return LDB_ERR_OPERATIONS_ERROR;
+ /* do not manipulate our control entries */
+ if (ldb_dn_is_special(req->op.mod.message->dn)) {
+ return ldb_next_request(module, req);
+ }
+
+ /* If the caller is manipulating the local passwords directly,
+ * let them pass */
+ if (ldb_dn_compare_base(ldb_dn_new(req, module->ldb, LOCAL_BASE),
+ req->op.del.dn) == 0) {
+ return ldb_next_request(module, req);
}
- ac->search_req->operation = LDB_SEARCH;
- ac->search_req->op.search.base = ac->orig_req->op.mod.message->dn;
- ac->search_req->op.search.scope = LDB_SCOPE_BASE;
- ac->search_req->op.search.tree = ldb_parse_tree(ac->orig_req, NULL);
- if (ac->search_req->op.search.tree == NULL) {
- ldb_set_errstring(ac->module->ldb, "Invalid search filter");
+ /* From here, we assume we have password attributes to split off */
+ ac = lpdb_init_context(module, req);
+ if (!ac) {
return LDB_ERR_OPERATIONS_ERROR;
}
- ac->search_req->op.search.attrs = attrs;
- ac->search_req->controls = NULL;
- ac->search_req->context = ac;
- ac->search_req->callback = get_self_callback;
- ldb_set_timeout_from_prev_req(ac->module->ldb, ac->orig_req, ac->search_req);
- ac->step = LPDB_MOD_SEARCH_SELF;
+ ret = ldb_build_del_req(&remote_req, module->ldb, ac,
+ req->op.del.dn,
+ req->controls,
+ ac, lpdb_delete_callabck,
+ req);
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
- return ldb_next_request(ac->module, ac->search_req);
+ return ldb_next_request(module, remote_req);
}
-/* After we find out the objectGUID for the entry, modify the local
- * password database as required */
-static int local_password_mod_local(struct ldb_handle *h) {
+/* On a modify, we don't have the objectGUID handy, so we need to
+ * search our DN for it */
+static int lpdb_delete_callabck(struct ldb_request *req,
+ struct ldb_reply *ares)
+{
+ static const char * const attrs[] = { "objectGUID", "objectClass", NULL };
+ struct ldb_request *search_req;
+ struct lpdb_context *ac;
+ int ret;
+ ac = talloc_get_type(req->context, struct lpdb_context);
+
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
+
+ if (ares->type != LDB_REPLY_DONE) {
+ ldb_set_errstring(ac->module->ldb, "Unexpected reply type");
+ talloc_free(ares);
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+
+ ac->remote_done = talloc_steal(ac, ares);
+
+ /* prepare the search operation */
+ ret = ldb_build_search_req(&search_req, ac->module->ldb, ac,
+ ac->req->op.del.dn, LDB_SCOPE_BASE,
+ "(objectclass=*)", attrs,
+ NULL,
+ ac, lpdb_del_search_callback,
+ ac->req);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+
+ ret = ldb_next_request(ac->module, search_req);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ return LDB_SUCCESS;
+}
+
+/* Called when we search for our own entry. Stores the one entry we
+ * expect (as it is a base search) on the context pointer */
+static int lpdb_del_search_callback(struct ldb_request *req,
+ struct ldb_reply *ares)
+{
+ struct ldb_request *local_req;
struct lpdb_context *ac;
+ struct ldb_dn *local_dn;
struct GUID objectGUID;
- ac = talloc_get_type(h->private_data, struct lpdb_context);
-
- /* if it is not an entry of type person this is an error */
- /* TODO: remove this when these things are checked in the schema */
- if (!ac->search_res) {
- ldb_asprintf_errstring(ac->module->ldb,
- "entry just modified (%s) not found!",
- ldb_dn_get_linearized(ac->remote_req->op.mod.message->dn));
- return LDB_ERR_OPERATIONS_ERROR;
- }
- if (!ldb_msg_check_string_attribute(ac->search_res->message, "objectClass", "person")) {
- /* Not relevent to us */
- return LDB_SUCCESS;
+ int ret = LDB_SUCCESS;
+
+ ac = talloc_get_type(req->context, struct lpdb_context);
+
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
-
- if (ldb_msg_find_ldb_val(ac->search_res->message, "objectGUID") == NULL) {
- ldb_set_errstring(ac->module->ldb,
- "no objectGUID found in search: local_password module must be configured below objectGUID module!\n");
- return LDB_ERR_OBJECT_CLASS_VIOLATION;
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
}
-
- objectGUID = samdb_result_guid(ac->search_res->message, "objectGUID");
- ac->local_message->dn = ldb_dn_new(ac, ac->module->ldb, LOCAL_BASE);
- ldb_dn_add_child_fmt(ac->local_message->dn, PASSWORD_GUID_ATTR "=%s", GUID_string(ac, &objectGUID));
+ switch (ares->type) {
+ case LDB_REPLY_ENTRY:
+ if (ac->remote != NULL) {
+ ldb_set_errstring(ac->module->ldb, "Too many results");
+ talloc_free(ares);
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+
+ ac->remote = talloc_steal(ac, ares);
+ break;
+
+ case LDB_REPLY_REFERRAL:
- h->state = LDB_ASYNC_INIT;
- h->status = LDB_SUCCESS;
+ /* ignore */
+ talloc_free(ares);
+ break;
- ac->step = LPDB_LOCAL;
+ case LDB_REPLY_DONE:
+ /* After we find out the objectGUID for the entry, modify the local
+ * password database as required */
- ldb_set_timeout_from_prev_req(ac->module->ldb, ac->orig_req, ac->local_req);
+ talloc_free(ares);
+
+ /* if it is not an entry of type person this is NOT an error */
+ /* TODO: remove this when sambaPassword will be in schema */
+ if (ac->remote == NULL) {
+ return ldb_module_done(ac->req,
+ ac->remote_done->controls,
+ ac->remote_done->response,
+ ac->remote_done->error);
+ }
+ if (!ldb_msg_check_string_attribute(ac->remote->message,
+ "objectClass", "person")) {
+ /* Not relevent to us */
+ return ldb_module_done(ac->req,
+ ac->remote_done->controls,
+ ac->remote_done->response,
+ ac->remote_done->error);
+ }
+
+ if (ldb_msg_find_ldb_val(ac->remote->message,
+ "objectGUID") == NULL) {
+ ldb_set_errstring(ac->module->ldb,
+ "no objectGUID found in search: "
+ "local_password module must be "
+ "configured below objectGUID "
+ "module!\n");
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OBJECT_CLASS_VIOLATION);
+ }
+
+ objectGUID = samdb_result_guid(ac->remote->message,
+ "objectGUID");
+
+ local_dn = ldb_dn_new(ac, ac->module->ldb, LOCAL_BASE);
+ if ((local_dn == NULL) ||
+ ( ! ldb_dn_add_child_fmt(local_dn,
+ PASSWORD_GUID_ATTR "=%s",
+ GUID_string(ac, &objectGUID)))) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+
+ ret = ldb_build_del_req(&local_req, ac->module->ldb, ac,
+ local_dn,
+ NULL,
+ ac, lpdb_local_callback,
+ ac->req);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL, ret);
+ }
- /* perform the local update */
- return ldb_next_request(ac->module, ac->local_req);
+ /* perform the local update */
+ ret = ldb_next_request(ac->module, local_req);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL, ret);
+ }
+ }
+
+ return LDB_SUCCESS;
}
-static int lpdb_local_search_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
+/*****************************************************************************
+ * SEARCH
+ ****************************************************************************/
+
+static int lpdb_local_search_callback(struct ldb_request *req,
+ struct ldb_reply *ares);
+
+static int lpdb_local_search(struct lpdb_context *ac)
+{
+ struct ldb_request *local_req;
+ int ret;
+
+ ret = ldb_build_search_req(&local_req, ac->module->ldb, ac,
+ ac->current->local_dn,
+ LDB_SCOPE_BASE,
+ "(objectclass=*)",
+ ac->req->op.search.attrs,
+ NULL,
+ ac, lpdb_local_search_callback,
+ ac->req);
+ if (ret != LDB_SUCCESS) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ return ldb_next_request(ac->module, local_req);
+}
+
+static int lpdb_local_search_callback(struct ldb_request *req,
+ struct ldb_reply *ares)
{
- struct lpdb_local_search_context *local_context;
+ struct lpdb_context *ac;
+ struct ldb_reply *merge;
+ struct lpdb_reply *lr;
+ int ret;
+ int i;
+
+ ac = talloc_get_type(req->context, struct lpdb_context);
+
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
- local_context = talloc_get_type(context, struct lpdb_local_search_context);
+ lr = ac->current;
- /* we are interested only in the single reply (base search) we receive here */
+ /* we are interested only in a single reply (base search) */
switch (ares->type) {
case LDB_REPLY_ENTRY:
- {
- int i;
- if (local_context->local_res != NULL) {
- ldb_set_errstring(ldb, "Too many results to base search for password entry!");
+
+ if (lr->remote == NULL) {
+ ldb_set_errstring(ac->module->ldb,
+ "Too many results for password entry search!");
talloc_free(ares);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
-
- local_context->local_res = ares;
- /* Make sure never to return the internal key attribute to the caller */
+ merge = lr->remote;
+ lr->remote = NULL;
+
+ /* steal the local results on the remote results to be
+ * returned all together */
+ talloc_steal(merge, ares->message->elements);
+
+ /* Make sure never to return the internal key attribute */
ldb_msg_remove_attr(ares->message, PASSWORD_GUID_ATTR);
- talloc_steal(local_context->remote_res->message->elements, ares->message->elements);
for (i=0; i < ares->message->num_elements; i++) {
struct ldb_message_element *el;
- el = ldb_msg_find_element(local_context->remote_res->message,
+ el = ldb_msg_find_element(merge->message,
ares->message->elements[i].name);
if (!el) {
- if (ldb_msg_add_empty(local_context->remote_res->message,
- ares->message->elements[i].name, 0, &el) != LDB_SUCCESS) {
+ ret = ldb_msg_add_empty(merge->message,
+ ares->message->elements[i].name,
+ 0, &el);
+ if (ret != LDB_SUCCESS) {
talloc_free(ares);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_module_done(ac->req,
+ NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
*el = ares->message->elements[i];
}
}
- return local_context->ac->orig_req->callback(ldb,
- local_context->ac->orig_req->context,
- local_context->remote_res);
- }
- case LDB_REPLY_DONE:
- {
- /* Fire off the callback if there was no local entry, so we get the rest returned */
- if (local_context->local_res == NULL) {
- return local_context->ac->orig_req->callback(ldb,
- local_context->ac->orig_req->context,
- local_context->remote_res);
- }
- return LDB_SUCCESS;
+
+ /* free the rest */
+ talloc_free(ares);
+
+ return ldb_module_send_entry(ac->req, merge->message);
+
+ case LDB_REPLY_REFERRAL:
+ /* ignore */
+ talloc_free(ares);
break;
- }
- default:
- {
+
+ case LDB_REPLY_DONE:
+
talloc_free(ares);
- ldb_set_errstring(ldb, "Unexpected result type in base search for password entry!");
- return LDB_ERR_OPERATIONS_ERROR;
- }
+
+ /* if this entry was not returned yet, return it now */
+ if (lr->remote) {
+ ret = ldb_module_send_entry(ac->req, ac->remote->message);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req,
+ NULL, NULL, ret);
+ }
+ lr->remote = NULL;
+ }
+
+ if (lr->next->remote->type == LDB_REPLY_DONE) {
+ /* this was the last one */
+ return ldb_module_done(ac->req,
+ lr->next->remote->controls,
+ lr->next->remote->response,
+ lr->next->remote->error);
+ } else {
+ /* next one */
+ ac->current = lr->next;
+ talloc_free(lr);
+
+ ret = lpdb_local_search(ac);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req,
+ NULL, NULL, ret);
+ }
+ }
}
+
+ return LDB_SUCCESS;
}
/* For each entry returned in a remote search, do a local base search,
* based on the objectGUID we asked for as an additional attribute */
-static int lpdb_remote_search_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
+static int lpdb_remote_search_callback(struct ldb_request *req,
+ struct ldb_reply *ares)
{
struct lpdb_context *ac;
+ struct ldb_dn *local_dn;
+ struct GUID objectGUID;
+ struct lpdb_reply *lr;
+ int ret;
- ac = talloc_get_type(context, struct lpdb_context);
+ ac = talloc_get_type(req->context, struct lpdb_context);
- if (ares->type == LDB_REPLY_ENTRY) {
- struct ldb_request *req;
- struct lpdb_local_search_context *local_context;
- struct GUID objectGUID;
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
+ switch (ares->type) {
+ case LDB_REPLY_ENTRY:
/* No point searching further if it's not a 'person' entry */
if (!ldb_msg_check_string_attribute(ares->message, "objectClass", "person")) {
ldb_msg_remove_attr(ares->message, "objectClass");
}
- return ac->orig_req->callback(ldb, ac->orig_req->context, ares);
+ return ldb_module_send_entry(ac->req, ares->message);
}
if (ldb_msg_find_ldb_val(ares->message, "objectGUID") == NULL) {
ldb_set_errstring(ac->module->ldb,
"no objectGUID found in search: local_password module must be configured below objectGUID module!\n");
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
objectGUID = samdb_result_guid(ares->message, "objectGUID");
ldb_msg_remove_attr(ares->message, "objectClass");
}
- req = talloc_zero(ac, struct ldb_request);
- if (!req) {
- return LDB_ERR_OPERATIONS_ERROR;
+ local_dn = ldb_dn_new(ac, ac->module->ldb, LOCAL_BASE);
+ if ((local_dn == NULL) ||
+ (! ldb_dn_add_child_fmt(local_dn,
+ PASSWORD_GUID_ATTR "=%s",
+ GUID_string(ac, &objectGUID)))) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+
+ lr = talloc_zero(ac, struct lpdb_reply);
+ if (lr == NULL) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
+ lr->local_dn = talloc_steal(lr, local_dn);
+ lr->remote = talloc_steal(lr, ares);
- local_context = talloc(ac, struct lpdb_local_search_context);
- if (!local_context) {
- return LDB_ERR_OPERATIONS_ERROR;
+ if (ac->list) {
+ ac->current->next = lr;
+ } else {
+ ac->list = lr;
}
- local_context->ac = ac;
- local_context->remote_res = ares;
- local_context->local_res = NULL;
+ ac->current= lr;
+
+ break;
- req->op.search.base = ldb_dn_new(ac, ac->module->ldb, LOCAL_BASE);
- if ( ! ldb_dn_add_child_fmt(req->op.search.base, PASSWORD_GUID_ATTR "=%s", GUID_string(ac, &objectGUID))) {
- return LDB_ERR_OPERATIONS_ERROR;
+ case LDB_REPLY_REFERRAL:
+
+ return ldb_module_send_referral(ac->req, ares->referral);
+
+ case LDB_REPLY_DONE:
+
+ if (ac->list == NULL) {
+ /* found nothing */
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
}
- req->operation = LDB_SEARCH;
- req->op.search.scope = LDB_SCOPE_BASE;
- req->op.search.tree = ldb_parse_tree(req, NULL);
- if (req->op.search.tree == NULL) {
- ldb_set_errstring(ac->module->ldb, "Out of Memory");
- return LDB_ERR_OPERATIONS_ERROR;
+
+ lr = talloc_zero(ac, struct lpdb_reply);
+ if (lr == NULL) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
- req->op.search.attrs = ac->orig_req->op.search.attrs;
- req->controls = NULL;
- req->context = ac;
- req->callback = get_self_callback;
+ lr->remote = talloc_steal(lr, ares);
- ldb_set_timeout_from_prev_req(ac->module->ldb, ac->orig_req, req);
-
- req->context = local_context;
- req->callback = lpdb_local_search_callback;
+ ac->current->next = lr;
- return ldb_next_request(ac->module, req);
- } else {
- return ac->orig_req->callback(ldb, ac->orig_req->context, ares);
+ /* rewind current and start local searches */
+ ac->current= ac->list;
+
+ ret = lpdb_local_search(ac);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL, ret);
+ }
}
+
+ return LDB_SUCCESS;
}
/* Search for passwords and other attributes. The passwords are
static int local_password_search(struct ldb_module *module, struct ldb_request *req)
{
- struct ldb_handle *h;
+ struct ldb_request *remote_req;
struct lpdb_context *ac;
int i;
int ret;
return ldb_next_request(module, req);
}
+ search_attrs = NULL;
+
/* If the caller is searching for the local passwords directly, let them pass */
if (ldb_dn_compare_base(ldb_dn_new(req, module->ldb, LOCAL_BASE),
req->op.search.base) == 0) {
}
}
- h = lpdb_init_handle(req, module, LPDB_SEARCH);
- if (!h) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- ac = talloc_get_type(h->private_data, struct lpdb_context);
-
- ac->orig_req = req;
-
- ac->remote_req = talloc(ac, struct ldb_request);
- if (ac->remote_req == NULL) {
+ ac = lpdb_init_context(module, req);
+ if (!ac) {
return LDB_ERR_OPERATIONS_ERROR;
}
/* Remote search is for all attributes: if the remote LDAP server has these attributes, then it overrides the local database */
- *(ac->remote_req) = *(ac->orig_req);
-
- /* Return our own handle do deal with this call */
- ac->remote_req->handle = h;
-
- ac->remote_req->context = ac;
- ac->remote_req->callback = lpdb_remote_search_callback;
-
if (req->op.search.attrs && !ldb_attr_in_list(req->op.search.attrs, "*")) {
if (!ldb_attr_in_list(req->op.search.attrs, "objectGUID")) {
- search_attrs = ldb_attr_list_copy_add(req, req->op.search.attrs, "objectGUID");
+ search_attrs = ldb_attr_list_copy_add(ac, req->op.search.attrs, "objectGUID");
ac->added_objectGUID = true;
if (!search_attrs) {
return LDB_ERR_OPERATIONS_ERROR;
search_attrs = req->op.search.attrs;
}
if (!ldb_attr_in_list(search_attrs, "objectClass")) {
- search_attrs = ldb_attr_list_copy_add(req, search_attrs, "objectClass");
+ search_attrs = ldb_attr_list_copy_add(ac, search_attrs, "objectClass");
ac->added_objectClass = true;
if (!search_attrs) {
return LDB_ERR_OPERATIONS_ERROR;
search_attrs = req->op.search.attrs;
}
- ac->remote_req->op.search.attrs = search_attrs;
-
- ldb_set_timeout_from_prev_req(module->ldb, ac->orig_req, ac->remote_req);
-
- h->state = LDB_ASYNC_INIT;
- h->status = LDB_SUCCESS;
-
- ac->step = LPDB_SEARCH_REMOTE;
-
- /* perform the search */
- ret = ldb_next_request(module, ac->remote_req);
-
- if (ret == LDB_SUCCESS) {
- req->handle = ac->remote_req->handle;
- }
-
- return ret;
-}
-
-static int lpdb_wait(struct ldb_handle *handle) {
- struct lpdb_context *ac;
- int ret;
-
- if (!handle || !handle->private_data) {
+ ret = ldb_build_search_req_ex(&remote_req, module->ldb, ac,
+ req->op.search.base,
+ req->op.search.scope,
+ req->op.search.tree,
+ search_attrs,
+ req->controls,
+ ac, lpdb_remote_search_callback,
+ req);
+ if (ret != LDB_SUCCESS) {
return LDB_ERR_OPERATIONS_ERROR;
}
- if (handle->state == LDB_ASYNC_DONE) {
- return handle->status;
- }
-
- handle->state = LDB_ASYNC_PENDING;
- handle->status = LDB_SUCCESS;
-
- ac = talloc_get_type(handle->private_data, struct lpdb_context);
-
- switch (ac->step) {
- case LPDB_ADD_REMOTE:
- ret = ldb_wait(ac->remote_req->handle, LDB_WAIT_NONE);
-
- if (ret != LDB_SUCCESS) {
- handle->status = ret;
- goto done;
- }
- if (ac->remote_req->handle->status != LDB_SUCCESS) {
- handle->status = ac->remote_req->handle->status;
- goto done;
- }
-
- if (ac->remote_req->handle->state != LDB_ASYNC_DONE) {
- return LDB_SUCCESS;
- }
-
- /* original request done, go on */
- return local_password_add_local(handle);
-
- case LPDB_MOD_REMOTE:
- ret = ldb_wait(ac->remote_req->handle, LDB_WAIT_NONE);
-
- if (ret != LDB_SUCCESS) {
- handle->status = ret;
- goto done;
- }
- if (ac->remote_req->handle->status != LDB_SUCCESS) {
- handle->status = ac->remote_req->handle->status;
- goto done;
- }
-
- if (ac->remote_req->handle->state != LDB_ASYNC_DONE) {
- return LDB_SUCCESS;
- }
-
- /* original request done, go on */
- return local_password_mod_search_self(handle);
-
- case LPDB_MOD_SEARCH_SELF:
- ret = ldb_wait(ac->search_req->handle, LDB_WAIT_NONE);
-
- if (ret != LDB_SUCCESS) {
- handle->status = ret;
- goto done;
- }
- if (ac->search_req->handle->status != LDB_SUCCESS) {
- handle->status = ac->search_req->handle->status;
- goto done;
- }
-
- if (ac->search_req->handle->state != LDB_ASYNC_DONE) {
- return LDB_SUCCESS;
- }
-
- /* original request done, go on */
- return local_password_mod_local(handle);
-
- case LPDB_LOCAL:
- ret = ldb_wait(ac->local_req->handle, LDB_WAIT_NONE);
-
- if (ret != LDB_SUCCESS) {
- handle->status = ret;
- goto done;
- }
- if (ac->local_req->handle->status != LDB_SUCCESS) {
- handle->status = ac->local_req->handle->status;
- goto done;
- }
-
- if (ac->local_req->handle->state != LDB_ASYNC_DONE) {
- return LDB_SUCCESS;
- }
-
- break;
-
- case LPDB_SEARCH_REMOTE:
- ret = ldb_wait(ac->remote_req->handle, LDB_WAIT_NONE);
-
- if (ret != LDB_SUCCESS) {
- handle->status = ret;
- goto done;
- }
- if (ac->remote_req->handle->status != LDB_SUCCESS) {
- handle->status = ac->remote_req->handle->status;
- goto done;
- }
-
- if (ac->remote_req->handle->state != LDB_ASYNC_DONE) {
- return LDB_SUCCESS;
- }
-
- break;
-
- default:
- ret = LDB_ERR_OPERATIONS_ERROR;
- goto done;
- }
-
- ret = LDB_SUCCESS;
-
-done:
- handle->state = LDB_ASYNC_DONE;
- return ret;
-}
-
-static int lpdb_wait_all(struct ldb_handle *handle) {
-
- int ret;
-
- while (handle->state != LDB_ASYNC_DONE) {
- ret = lpdb_wait(handle);
- if (ret != LDB_SUCCESS) {
- return ret;
- }
- }
-
- return handle->status;
-}
-
-static int local_password_wait(struct ldb_handle *handle, enum ldb_wait_type type)
-{
- if (type == LDB_WAIT_ALL) {
- return lpdb_wait_all(handle);
- } else {
- return lpdb_wait(handle);
- }
+ /* perform the search */
+ return ldb_next_request(module, remote_req);
}
_PUBLIC_ const struct ldb_module_ops ldb_local_password_module_ops = {
.name = "local_password",
.add = local_password_add,
.modify = local_password_modify,
- .search = local_password_search,
- .wait = local_password_wait
+ .del = local_password_delete,
+ .search = local_password_search
};
}
module->private_data = naming_fsmo;
- ret = ldb_search(module->ldb, naming_dn,
- LDB_SCOPE_BASE,
- NULL, naming_attrs,
- &naming_res);
+ ret = ldb_search(module->ldb, mem_ctx, &naming_res,
+ naming_dn, LDB_SCOPE_BASE,
+ naming_attrs, NULL);
if (ret == LDB_ERR_NO_SUCH_OBJECT) {
ldb_debug(module->ldb, LDB_DEBUG_WARNING,
"naming_fsmo_init: no partitions dn present: (skip loading of naming contexts details)\n");
talloc_free(mem_ctx);
return ret;
}
- talloc_steal(mem_ctx, naming_res);
if (naming_res->count == 0) {
ldb_debug(module->ldb, LDB_DEBUG_WARNING,
"naming_fsmo_init: no cross-ref container present: (skip loading of naming contexts details)\n");
CN=Admins,CN=Users,DC=samba,DC=example,DC=com
*/
+
+struct norm_context {
+ struct ldb_module *module;
+ struct ldb_request *req;
+
+ const struct dsdb_schema *schema;
+};
+
static int fix_dn(struct ldb_dn *dn)
{
int i, ret;
return LDB_SUCCESS;
}
-static int normalise_search_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
+static int normalize_search_callback(struct ldb_request *req, struct ldb_reply *ares)
{
- const struct dsdb_schema *schema = dsdb_get_schema(ldb);
- struct ldb_request *orig_req = talloc_get_type(context, struct ldb_request);
- TALLOC_CTX *mem_ctx;
+ struct ldb_message *msg;
+ struct norm_context *ac;
int i, j, ret;
- /* Only entries are interesting, and we handle the case of the parent seperatly */
- if (ares->type != LDB_REPLY_ENTRY) {
- return orig_req->callback(ldb, orig_req->context, ares);
- }
+ ac = talloc_get_type(req->context, struct norm_context);
- if (!schema) {
- return orig_req->callback(ldb, orig_req->context, ares);
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
-
- mem_ctx = talloc_new(ares);
- if (!mem_ctx) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
}
- /* OK, we have one of *many* search results passing by here,
- * but we should get them one at a time */
+ /* Only entries are interesting, and we handle the case of the parent seperatly */
- ret = fix_dn(ares->message->dn);
- if (ret != LDB_SUCCESS) {
- talloc_free(mem_ctx);
- return ret;
- }
+ switch (ares->type) {
+ case LDB_REPLY_ENTRY:
- for (i = 0; i < ares->message->num_elements; i++) {
- const struct dsdb_attribute *attribute = dsdb_attribute_by_lDAPDisplayName(schema, ares->message->elements[i].name);
- if (!attribute) {
- continue;
- }
- /* Look to see if this attributeSyntax is a DN */
- if (!((strcmp(attribute->attributeSyntax_oid, "2.5.5.1") == 0) ||
- (strcmp(attribute->attributeSyntax_oid, "2.5.5.7") == 0))) {
- continue;
+ /* OK, we have one of *many* search results passing by here,
+ * but we should get them one at a time */
+ msg = ares->message;
+
+ ret = fix_dn(msg->dn);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL, ret);
}
- for (j = 0; j < ares->message->elements[i].num_values; j++) {
- const char *dn_str;
- struct ldb_dn *dn = ldb_dn_from_ldb_val(mem_ctx, ldb, &ares->message->elements[i].values[j]);
- if (!dn) {
- talloc_free(mem_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+
+ for (i = 0; i < msg->num_elements; i++) {
+ const struct dsdb_attribute *attribute = dsdb_attribute_by_lDAPDisplayName(ac->schema, msg->elements[i].name);
+ if (!attribute) {
+ continue;
}
- ret = fix_dn(dn);
- if (ret != LDB_SUCCESS) {
- talloc_free(mem_ctx);
- return ret;
+ /* Look to see if this attributeSyntax is a DN */
+ if (!((strcmp(attribute->attributeSyntax_oid, "2.5.5.1") == 0) ||
+ (strcmp(attribute->attributeSyntax_oid, "2.5.5.7") == 0))) {
+ continue;
+ }
+ for (j = 0; j < msg->elements[i].num_values; j++) {
+ const char *dn_str;
+ struct ldb_dn *dn = ldb_dn_new(ac, ac->module->ldb, (const char *)msg->elements[i].values[j].data);
+ if (!dn) {
+ return ldb_module_done(ac->req, NULL, NULL, LDB_ERR_OPERATIONS_ERROR);
+ }
+ ret = fix_dn(dn);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL, ret);
+ }
+ dn_str = talloc_steal(msg->elements[i].values, ldb_dn_get_linearized(dn));
+ msg->elements[i].values[j] = data_blob_string_const(dn_str);
+ talloc_free(dn);
}
- dn_str = talloc_steal(ares->message->elements[i].values, ldb_dn_get_linearized(dn));
- ares->message->elements[i].values[j] = data_blob_string_const(dn_str);
- talloc_free(dn);
}
+
+ return ldb_module_send_entry(ac->req, msg);
+
+ case LDB_REPLY_REFERRAL:
+
+ return ldb_module_send_referral(ac->req, ares->referral);
+
+ case LDB_REPLY_DONE:
+
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
}
- talloc_free(mem_ctx);
- return orig_req->callback(ldb, orig_req->context, ares);
+
+ return LDB_SUCCESS;
}
/* search */
static int normalise_search(struct ldb_module *module, struct ldb_request *req)
{
+ struct ldb_request *down_req;
+ struct norm_context *ac;
int ret;
- struct ldb_request *down_req = talloc(req, struct ldb_request);
- if (!down_req) {
- ldb_oom(module->ldb);
+
+ ac = talloc(req, struct norm_context);
+ if (ac == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
-
- *down_req = *req;
- down_req->context = req;
- down_req->callback = normalise_search_callback;
- ret = ldb_next_request(module, down_req);
+ ac->module = module;
+ ac->req = req;
- /* do not free down_req as the call results may be linked to it,
- * it will be freed when the upper level request get freed */
- if (ret == LDB_SUCCESS) {
- req->handle = down_req->handle;
+ /* if schema not yet present just skip over */
+ ac->schema = dsdb_get_schema(ac->module->ldb);
+ if (ac->schema == NULL) {
+ talloc_free(ac);
+ return ldb_next_request(module, req);
}
- return ret;
+
+ ret = ldb_build_search_req_ex(&down_req, module->ldb, ac,
+ req->op.search.base,
+ req->op.search.scope,
+ req->op.search.tree,
+ req->op.search.attrs,
+ req->controls,
+ ac, normalize_search_callback,
+ req);
+ if (ret != LDB_SUCCESS) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ return ldb_next_request(module, down_req);
}
+
_PUBLIC_ const struct ldb_module_ops ldb_normalise_module_ops = {
.name = "normalise",
.search = normalise_search,
/*
ldb database library
- Copyright (C) Simo Sorce 2006
+ Copyright (C) Simo Sorce 2006-2008
Copyright (C) Andrew Bartlett <abartlet@samba.org> 2005-2007
This program is free software; you can redistribute it and/or modify
struct oc_context {
- enum oc_step {OC_DO_REQ, OC_SEARCH_SELF, OC_DO_MOD,
- OC_SEARCH_ADD_PARENT, OC_DO_ADD,
- OC_SEARCH_RENAME_PARENT, OC_DO_RENAME} step;
-
struct ldb_module *module;
- struct ldb_request *orig_req;
-
- struct ldb_request *down_req;
+ struct ldb_request *req;
- struct ldb_request *search_req;
struct ldb_reply *search_res;
- struct ldb_request *add_req;
- struct ldb_request *mod_req;
- struct ldb_request *rename_req;
+ int (*step_fn)(struct oc_context *);
};
struct class_list {
const struct dsdb_class *objectclass;
};
-static int objectclass_do_add(struct ldb_handle *h);
-
-static struct ldb_handle *oc_init_handle(struct ldb_request *req, struct ldb_module *module)
+static struct oc_context *oc_init_context(struct ldb_module *module,
+ struct ldb_request *req)
{
struct oc_context *ac;
- struct ldb_handle *h;
- h = talloc_zero(req, struct ldb_handle);
- if (h == NULL) {
- ldb_set_errstring(module->ldb, "Out of Memory");
- return NULL;
- }
-
- h->module = module;
-
- ac = talloc_zero(h, struct oc_context);
+ ac = talloc_zero(req, struct oc_context);
if (ac == NULL) {
ldb_set_errstring(module->ldb, "Out of Memory");
- talloc_free(h);
return NULL;
}
- h->private_data = (void *)ac;
-
- h->state = LDB_ASYNC_INIT;
- h->status = LDB_SUCCESS;
-
ac->module = module;
- ac->orig_req = req;
+ ac->req = req;
- return h;
+ return ac;
}
+static int objectclass_do_add(struct oc_context *ac);
+
/* Sort objectClasses into correct order, and validate that all
* objectClasses specified actually exist in the schema
*/
static int objectclass_sort(struct ldb_module *module,
const struct dsdb_schema *schema,
- struct ldb_message *msg, /* so that when we create new elements, we put it on the right parent */
TALLOC_CTX *mem_ctx,
struct ldb_message_element *objectclass_element,
struct class_list **sorted_out)
int layer;
struct class_list *sorted = NULL, *parent_class = NULL,
*subclass = NULL, *unsorted = NULL, *current, *poss_subclass, *poss_parent, *new_parent;
+
/* DESIGN:
*
* We work on 4 different 'bins' (implemented here as linked lists):
for (i=0; i < objectclass_element->num_values; i++) {
current = talloc(mem_ctx, struct class_list);
if (!current) {
- ldb_set_errstring(module->ldb, "objectclass: out of memory allocating objectclass list");
- talloc_free(mem_ctx);
+ ldb_oom(module->ldb);
return LDB_ERR_OPERATIONS_ERROR;
}
current->objectclass = dsdb_class_by_lDAPDisplayName(schema, (const char *)objectclass_element->values[i].data);
struct auth_session_info *session_info
= ldb_get_opaque(module->ldb, "sessionInfo");
struct security_descriptor *sd;
- struct dom_sid *domain_sid = samdb_domain_sid(module->ldb);
+ const struct dom_sid *domain_sid = samdb_domain_sid(module->ldb);
if (!objectclass->defaultSecurityDescriptor || !domain_sid) {
return NULL;
}
-static int get_search_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
+static int get_search_callback(struct ldb_request *req, struct ldb_reply *ares)
{
struct oc_context *ac;
+ int ret;
- ac = talloc_get_type(context, struct oc_context);
+ ac = talloc_get_type(req->context, struct oc_context);
- /* we are interested only in the single reply (base search) we receive here */
- if (ares->type == LDB_REPLY_ENTRY) {
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS &&
+ ares->error != LDB_ERR_NO_SUCH_OBJECT) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
+
+ switch (ares->type) {
+ case LDB_REPLY_ENTRY:
if (ac->search_res != NULL) {
- ldb_set_errstring(ldb, "Too many results");
+ ldb_set_errstring(ac->module->ldb, "Too many results");
talloc_free(ares);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
- ac->search_res = talloc_move(ac, &ares);
- } else {
+ ac->search_res = talloc_steal(ac, ares);
+ break;
+
+ case LDB_REPLY_REFERRAL:
+ /* ignore */
+ talloc_free(ares);
+ break;
+
+ case LDB_REPLY_DONE:
talloc_free(ares);
+ ret = ac->step_fn(ac);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL, ret);
+ }
+ break;
}
return LDB_SUCCESS;
}
+static int oc_op_callback(struct ldb_request *req, struct ldb_reply *ares)
+{
+ struct oc_context *ac;
+
+ ac = talloc_get_type(req->context, struct oc_context);
+
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
+
+ if (ares->type != LDB_REPLY_DONE) {
+ talloc_free(ares);
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+}
+
/* Fix up the DN to be in the standard form, taking particular care to match the parent DN
This should mean that if the parent is:
return LDB_SUCCESS;
}
+static int objectclass_do_add(struct oc_context *ac);
+
static int objectclass_add(struct ldb_module *module, struct ldb_request *req)
{
-
- static const char * const attrs[] = { NULL };
-
- struct ldb_handle *h;
+ struct ldb_request *search_req;
struct oc_context *ac;
struct ldb_dn *parent_dn;
int ret;
return ldb_next_request(module, req);
}
- /* Need to object to this, but cn=rootdse doesn't hae an objectClass... */
+ /* Need to object to this, but cn=rootdse doesn't have an objectClass... */
if (ldb_msg_find_element(req->op.add.message,
"objectClass") == NULL) {
return ldb_next_request(module, req);
}
- h = oc_init_handle(req, module);
- if (!h) {
+ ac = oc_init_context(module, req);
+ if (ac == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
- ac = talloc_get_type(h->private_data, struct oc_context);
-
- /* return or own handle to deal with this call */
- req->handle = h;
/* If there isn't a parent, just go on to the add processing */
- if (ldb_dn_get_comp_num(ac->orig_req->op.add.message->dn) == 1) {
- return objectclass_do_add(h);
+ if (ldb_dn_get_comp_num(ac->req->op.add.message->dn) == 1) {
+ return objectclass_do_add(ac);
}
- parent_dn = ldb_dn_get_parent(ac, ac->orig_req->op.add.message->dn);
+ /* get copy of parent DN */
+ parent_dn = ldb_dn_get_parent(ac, ac->req->op.add.message->dn);
if (parent_dn == NULL) {
ldb_oom(module->ldb);
return LDB_ERR_OPERATIONS_ERROR;
}
- ret = ldb_build_search_req(&ac->search_req, module->ldb,
+ ret = ldb_build_search_req(&search_req, module->ldb,
ac, parent_dn, LDB_SCOPE_BASE,
- "(objectClass=*)",
- attrs, NULL,
- ac, get_search_callback);
+ "(objectClass=*)", NULL,
+ NULL,
+ ac, get_search_callback,
+ req);
if (ret != LDB_SUCCESS) {
return ret;
}
+ talloc_steal(search_req, parent_dn);
- talloc_steal(ac->search_req, parent_dn);
-
- ldb_set_timeout_from_prev_req(ac->module->ldb, ac->orig_req, ac->search_req);
+ ac->step_fn = objectclass_do_add;
- ac->step = OC_SEARCH_ADD_PARENT;
-
- return ldb_next_request(ac->module, ac->search_req);
+ return ldb_next_request(ac->module, search_req);
}
-static int objectclass_do_add(struct ldb_handle *h)
+static int objectclass_do_add(struct oc_context *ac)
{
const struct dsdb_schema *schema;
- struct oc_context *ac;
+ struct ldb_request *add_req;
+ char *value;
struct ldb_message_element *objectclass_element;
struct ldb_message *msg;
TALLOC_CTX *mem_ctx;
struct class_list *sorted, *current;
int ret;
-
- ac = talloc_get_type(h->private_data, struct oc_context);
+
schema = dsdb_get_schema(ac->module->ldb);
mem_ctx = talloc_new(ac);
return LDB_ERR_OPERATIONS_ERROR;
}
- ac->add_req = talloc(ac, struct ldb_request);
- if (ac->add_req == NULL) {
- talloc_free(mem_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
- }
+ msg = ldb_msg_copy_shallow(ac, ac->req->op.add.message);
- *ac->add_req = *ac->orig_req;
-
- ac->add_req->op.add.message = msg = ldb_msg_copy_shallow(ac->add_req, ac->orig_req->op.add.message);
-
- ldb_set_timeout_from_prev_req(ac->module->ldb, ac->orig_req, ac->add_req);
-
/* Check we have a valid parent */
if (ac->search_res == NULL) {
- if (ldb_dn_compare(ldb_get_root_basedn(ac->module->ldb), ac->orig_req->op.add.message->dn) == 0) {
+ if (ldb_dn_compare(ldb_get_root_basedn(ac->module->ldb),
+ msg->dn) == 0) {
/* Allow the tree to be started */
/* but don't keep any error string, it's meaningless */
ldb_set_errstring(ac->module->ldb, NULL);
} else {
ldb_asprintf_errstring(ac->module->ldb, "objectclass: Cannot add %s, parent does not exist!",
- ldb_dn_get_linearized(ac->orig_req->op.add.message->dn));
+ ldb_dn_get_linearized(msg->dn));
+ talloc_free(mem_ctx);
return LDB_ERR_UNWILLING_TO_PERFORM;
}
} else {
/* Fix up the DN to be in the standard form, taking particular care to match the parent DN */
ret = fix_dn(msg,
- ac->orig_req->op.add.message->dn,
+ ac->req->op.add.message->dn,
ac->search_res->message->dn,
&msg->dn);
if (ret != LDB_SUCCESS) {
ldb_asprintf_errstring(ac->module->ldb, "Could not munge DN %s into normal form",
- ldb_dn_get_linearized(ac->orig_req->op.add.message->dn));
+ ldb_dn_get_linearized(ac->req->op.add.message->dn));
+ talloc_free(mem_ctx);
return ret;
}
talloc_free(mem_ctx);
return LDB_ERR_OPERATIONS_ERROR;
}
- ret = objectclass_sort(ac->module, schema, msg, mem_ctx, objectclass_element, &sorted);
+ ret = objectclass_sort(ac->module, schema, mem_ctx, objectclass_element, &sorted);
if (ret != LDB_SUCCESS) {
talloc_free(mem_ctx);
return ret;
/* Move from the linked list back into an ldb msg */
for (current = sorted; current; current = current->next) {
- ret = ldb_msg_add_string(msg, "objectClass", current->objectclass->lDAPDisplayName);
+ value = talloc_strdup(msg, current->objectclass->lDAPDisplayName);
+ if (value == NULL) {
+ ldb_oom(ac->module->ldb);
+ talloc_free(mem_ctx);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ ret = ldb_msg_add_string(msg, "objectClass", value);
if (ret != LDB_SUCCESS) {
ldb_set_errstring(ac->module->ldb,
"objectclass: could not re-add sorted "
struct ldb_message_element *el;
int32_t systemFlags = 0;
if (!ldb_msg_find_element(msg, "objectCategory")) {
- ldb_msg_add_string(msg, "objectCategory",
- current->objectclass->defaultObjectCategory);
+ value = talloc_strdup(msg, current->objectclass->defaultObjectCategory);
+ if (value == NULL) {
+ ldb_oom(ac->module->ldb);
+ talloc_free(mem_ctx);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ ldb_msg_add_string(msg, "objectCategory", value);
}
if (!ldb_msg_find_element(msg, "showInAdvancedViewOnly") && (current->objectclass->defaultHidingValue == true)) {
ldb_msg_add_string(msg, "showInAdvancedViewOnly",
return ret;
}
- h->state = LDB_ASYNC_INIT;
- h->status = LDB_SUCCESS;
-
- ac->step = OC_DO_ADD;
+ ret = ldb_build_add_req(&add_req, ac->module->ldb, ac,
+ msg,
+ ac->req->controls,
+ ac, oc_op_callback,
+ ac->req);
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
/* perform the add */
- return ldb_next_request(ac->module, ac->add_req);
+ return ldb_next_request(ac->module, add_req);
}
+static int oc_modify_callback(struct ldb_request *req,
+ struct ldb_reply *ares);
+static int objectclass_do_mod(struct oc_context *ac);
+
static int objectclass_modify(struct ldb_module *module, struct ldb_request *req)
{
struct ldb_message_element *objectclass_element;
struct ldb_message *msg;
const struct dsdb_schema *schema = dsdb_get_schema(module->ldb);
+ struct class_list *sorted, *current;
+ struct ldb_request *down_req;
+ struct oc_context *ac;
+ TALLOC_CTX *mem_ctx;
+ char *value;
int ret;
ldb_debug(module->ldb, LDB_DEBUG_TRACE, "objectclass_modify\n");
}
objectclass_element = ldb_msg_find_element(req->op.mod.message, "objectClass");
+ ac = oc_init_context(module, req);
+ if (ac == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
/* If no part of this touches the objectClass, then we don't
* need to make any changes. */
/* If the only operation is the deletion of the objectClass
* then go on with just fixing the attribute case */
if (!objectclass_element) {
- struct ldb_request *down_req = talloc(req, struct ldb_request);
- if (down_req == NULL) {
- ldb_set_errstring(module->ldb, "Out of memory!");
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- *down_req = *req; /* copy the request */
-
- down_req->op.mod.message = msg = ldb_msg_copy_shallow(down_req, req->op.mod.message);
-
- if (down_req->op.mod.message == NULL) {
+ msg = ldb_msg_copy_shallow(ac, req->op.mod.message);
+ if (msg == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
return ret;
}
- /* go on with the call chain */
- ret = ldb_next_request(module, down_req);
-
- /* do not free down_req as the call results may be linked to it,
- * it will be freed when the upper level request get freed */
- if (ret == LDB_SUCCESS) {
- req->handle = down_req->handle;
+ ret = ldb_build_mod_req(&down_req, module->ldb, ac,
+ msg,
+ req->controls,
+ ac, oc_op_callback,
+ req);
+ if (ret != LDB_SUCCESS) {
+ return ret;
}
- return ret;
+
+ /* go on with the call chain */
+ return ldb_next_request(module, down_req);
}
switch (objectclass_element->flags & LDB_FLAG_MOD_MASK) {
return LDB_ERR_OBJECT_CLASS_MODS_PROHIBITED;
}
break;
+
case LDB_FLAG_MOD_REPLACE:
- {
- struct ldb_request *down_req;
- struct class_list *sorted, *current;
- TALLOC_CTX *mem_ctx;
- mem_ctx = talloc_new(req);
+ mem_ctx = talloc_new(ac);
if (mem_ctx == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
- /* prepare the first operation */
- down_req = talloc(req, struct ldb_request);
- if (down_req == NULL) {
- ldb_set_errstring(module->ldb, "Out of memory!");
+ msg = ldb_msg_copy_shallow(ac, req->op.mod.message);
+ if (msg == NULL) {
talloc_free(mem_ctx);
return LDB_ERR_OPERATIONS_ERROR;
}
-
- *down_req = *req; /* copy the request */
-
- down_req->op.mod.message = msg = ldb_msg_copy_shallow(down_req, req->op.mod.message);
-
- if (down_req->op.mod.message == NULL) {
- talloc_free(mem_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
+
ret = fix_attributes(module->ldb, schema, msg);
if (ret != LDB_SUCCESS) {
talloc_free(mem_ctx);
return ret;
}
- ret = objectclass_sort(module, schema, msg, mem_ctx, objectclass_element, &sorted);
+ ret = objectclass_sort(module, schema, mem_ctx, objectclass_element, &sorted);
if (ret != LDB_SUCCESS) {
+ talloc_free(mem_ctx);
return ret;
}
/* Move from the linked list back into an ldb msg */
for (current = sorted; current; current = current->next) {
- ret = ldb_msg_add_string(msg, "objectClass", current->objectclass->lDAPDisplayName);
+ /* copy the value as this string is on the schema
+ * context and we can't rely on it not changing
+ * before the operation is over */
+ value = talloc_strdup(msg,
+ current->objectclass->lDAPDisplayName);
+ if (value == NULL) {
+ ldb_oom(module->ldb);
+ talloc_free(mem_ctx);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ ret = ldb_msg_add_string(msg, "objectClass", value);
if (ret != LDB_SUCCESS) {
- ldb_set_errstring(module->ldb, "objectclass: could not re-add sorted objectclass to modify msg");
+ ldb_set_errstring(module->ldb,
+ "objectclass: could not re-add sorted "
+ "objectclass to modify msg");
talloc_free(mem_ctx);
return ret;
}
ret = ldb_msg_sanity_check(module->ldb, msg);
if (ret != LDB_SUCCESS) {
- talloc_free(mem_ctx);
return ret;
}
-
- /* go on with the call chain */
- ret = ldb_next_request(module, down_req);
-
- /* do not free down_req as the call results may be linked to it,
- * it will be freed when the upper level request get freed */
- if (ret == LDB_SUCCESS) {
- req->handle = down_req->handle;
+
+ ret = ldb_build_mod_req(&down_req, module->ldb, ac,
+ msg,
+ req->controls,
+ ac, oc_op_callback,
+ req);
+ if (ret != LDB_SUCCESS) {
+ return ret;
}
- return ret;
- }
+
+ /* go on with the call chain */
+ return ldb_next_request(module, down_req);
}
/* This isn't the default branch of the switch, but a 'in any
* other case'. When a delete isn't for all objectClasses for
* example
*/
- {
- struct ldb_handle *h;
- struct oc_context *ac;
-
- h = oc_init_handle(req, module);
- if (!h) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
- ac = talloc_get_type(h->private_data, struct oc_context);
-
- /* return or own handle to deal with this call */
- req->handle = h;
-
- /* prepare the first operation */
- ac->down_req = talloc(ac, struct ldb_request);
- if (ac->down_req == NULL) {
- ldb_oom(ac->module->ldb);
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- *(ac->down_req) = *req; /* copy the request */
-
- ac->down_req->op.mod.message = msg = ldb_msg_copy_shallow(ac->down_req, req->op.mod.message);
-
- if (ac->down_req->op.mod.message == NULL) {
- ldb_oom(ac->module->ldb);
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- ret = fix_attributes(ac->module->ldb, schema, msg);
- if (ret != LDB_SUCCESS) {
- ldb_oom(ac->module->ldb);
- return ret;
- }
- ac->down_req->context = NULL;
- ac->down_req->callback = NULL;
- ldb_set_timeout_from_prev_req(module->ldb, req, ac->down_req);
-
- ac->step = OC_DO_REQ;
+ msg = ldb_msg_copy_shallow(ac, req->op.mod.message);
+ if (msg == NULL) {
+ ldb_oom(module->ldb);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
- return ldb_next_request(module, ac->down_req);
+ ret = fix_attributes(module->ldb, schema, msg);
+ if (ret != LDB_SUCCESS) {
+ ldb_oom(ac->module->ldb);
+ return ret;
+ }
+
+ ret = ldb_build_mod_req(&down_req, module->ldb, ac,
+ msg,
+ req->controls,
+ ac, oc_modify_callback,
+ req);
+ if (ret != LDB_SUCCESS) {
+ return ret;
}
+
+ return ldb_next_request(module, down_req);
}
-static int objectclass_search_self(struct ldb_handle *h)
+static int oc_modify_callback(struct ldb_request *req, struct ldb_reply *ares)
{
- int ret;
- struct oc_context *ac;
static const char * const attrs[] = { "objectClass", NULL };
+ struct ldb_request *search_req;
+ struct oc_context *ac;
+ int ret;
- ac = talloc_get_type(h->private_data, struct oc_context);
+ ac = talloc_get_type(req->context, struct oc_context);
- ret = ldb_build_search_req(&ac->search_req, ac->module->ldb,
- ac, ac->orig_req->op.mod.message->dn, LDB_SCOPE_BASE,
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
+
+ if (ares->type != LDB_REPLY_DONE) {
+ talloc_free(ares);
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+
+ ret = ldb_build_search_req(&search_req, ac->module->ldb, ac,
+ ac->req->op.mod.message->dn, LDB_SCOPE_BASE,
"(objectClass=*)",
attrs, NULL,
- ac, get_search_callback);
-
+ ac, get_search_callback,
+ ac->req);
if (ret != LDB_SUCCESS) {
- return ret;
+ return ldb_module_done(ac->req, NULL, NULL, ret);
}
- ldb_set_timeout_from_prev_req(ac->module->ldb, ac->orig_req, ac->search_req);
-
- ac->step = OC_SEARCH_SELF;
+ ac->step_fn = objectclass_do_mod;
- return ldb_next_request(ac->module, ac->search_req);
+ ret = ldb_next_request(ac->module, search_req);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL, ret);
+ }
+ return LDB_SUCCESS;
}
-static int objectclass_do_mod(struct ldb_handle *h) {
+static int objectclass_do_mod(struct oc_context *ac)
+{
const struct dsdb_schema *schema;
- struct oc_context *ac;
+ struct ldb_request *mod_req;
+ char *value;
struct ldb_message_element *objectclass_element;
struct ldb_message *msg;
TALLOC_CTX *mem_ctx;
struct class_list *sorted, *current;
int ret;
-
- ac = talloc_get_type(h->private_data, struct oc_context);
- schema = dsdb_get_schema(ac->module->ldb);
- mem_ctx = talloc_new(ac);
- if (mem_ctx == NULL) {
+ if (ac->search_res == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
+ schema = dsdb_get_schema(ac->module->ldb);
- ac->mod_req = talloc(ac, struct ldb_request);
- if (ac->mod_req == NULL) {
- talloc_free(mem_ctx);
+ mem_ctx = talloc_new(ac);
+ if (mem_ctx == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
- ac->mod_req->operation = LDB_MODIFY;
- ac->mod_req->controls = NULL;
- ac->mod_req->context = ac;
- ac->mod_req->callback = NULL;
- ldb_set_timeout_from_prev_req(ac->module->ldb, ac->orig_req, ac->mod_req);
-
/* use a new message structure */
- ac->mod_req->op.mod.message = msg = ldb_msg_new(ac->mod_req);
+ msg = ldb_msg_new(ac);
if (msg == NULL) {
- ldb_set_errstring(ac->module->ldb, "objectclass: could not create new modify msg");
+ ldb_set_errstring(ac->module->ldb,
+ "objectclass: could not create new modify msg");
talloc_free(mem_ctx);
return LDB_ERR_OPERATIONS_ERROR;
}
}
/* modify dn */
- msg->dn = ac->orig_req->op.mod.message->dn;
+ msg->dn = ac->req->op.mod.message->dn;
- ret = objectclass_sort(ac->module, schema, msg, mem_ctx, objectclass_element, &sorted);
+ ret = objectclass_sort(ac->module, schema, mem_ctx, objectclass_element, &sorted);
if (ret != LDB_SUCCESS) {
return ret;
}
/* Move from the linked list back into an ldb msg */
for (current = sorted; current; current = current->next) {
- ret = ldb_msg_add_string(msg, "objectClass", current->objectclass->lDAPDisplayName);
+ value = talloc_strdup(msg, current->objectclass->lDAPDisplayName);
+ if (value == NULL) {
+ ldb_oom(ac->module->ldb);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ ret = ldb_msg_add_string(msg, "objectClass", value);
if (ret != LDB_SUCCESS) {
ldb_set_errstring(ac->module->ldb, "objectclass: could not re-add sorted objectclass to modify msg");
talloc_free(mem_ctx);
return ret;
}
-
- h->state = LDB_ASYNC_INIT;
- h->status = LDB_SUCCESS;
-
- ac->step = OC_DO_MOD;
+ ret = ldb_build_mod_req(&mod_req, ac->module->ldb, ac,
+ msg,
+ ac->req->controls,
+ ac, oc_op_callback,
+ ac->req);
+ if (ret != LDB_SUCCESS) {
+ talloc_free(mem_ctx);
+ return ret;
+ }
talloc_free(mem_ctx);
- /* perform the search */
- return ldb_next_request(ac->module, ac->mod_req);
+ /* perform the modify */
+ return ldb_next_request(ac->module, mod_req);
}
+static int objectclass_do_rename(struct oc_context *ac);
+
static int objectclass_rename(struct ldb_module *module, struct ldb_request *req)
{
-
static const char * const attrs[] = { NULL };
- struct ldb_handle *h;
+ struct ldb_request *search_req;
struct oc_context *ac;
struct ldb_dn *parent_dn;
int ret;
-
+
ldb_debug(module->ldb, LDB_DEBUG_TRACE, "objectclass_rename\n");
if (ldb_dn_is_special(req->op.rename.newdn)) { /* do not manipulate our control entries */
return ldb_next_request(module, req);
}
-
+
/* Firstly ensure we are not trying to rename it to be a child of itself */
if ((ldb_dn_compare_base(req->op.rename.olddn, req->op.rename.newdn) == 0)
&& (ldb_dn_compare(req->op.rename.olddn, req->op.rename.newdn) != 0)) {
return LDB_ERR_UNWILLING_TO_PERFORM;
}
- h = oc_init_handle(req, module);
- if (!h) {
+ ac = oc_init_context(module, req);
+ if (ac == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
- ac = talloc_get_type(h->private_data, struct oc_context);
-
- /* return or own handle to deal with this call */
- req->handle = h;
- parent_dn = ldb_dn_get_parent(ac, ac->orig_req->op.rename.newdn);
+ parent_dn = ldb_dn_get_parent(ac, req->op.rename.newdn);
if (parent_dn == NULL) {
ldb_oom(module->ldb);
return LDB_ERR_OPERATIONS_ERROR;
}
- ret = ldb_build_search_req(&ac->search_req, module->ldb,
+ ret = ldb_build_search_req(&search_req, module->ldb,
ac, parent_dn, LDB_SCOPE_BASE,
"(objectClass=*)",
attrs, NULL,
- ac, get_search_callback);
+ ac, get_search_callback,
+ req);
if (ret != LDB_SUCCESS) {
return ret;
}
- talloc_steal(ac->search_req, parent_dn);
- ldb_set_timeout_from_prev_req(ac->module->ldb, ac->orig_req, ac->search_req);
- ac->step = OC_SEARCH_RENAME_PARENT;
+ ac->step_fn = objectclass_do_rename;
- return ldb_next_request(ac->module, ac->search_req);
+ return ldb_next_request(ac->module, search_req);
}
-static int objectclass_do_rename(struct ldb_handle *h)
+static int objectclass_do_rename(struct oc_context *ac)
{
- struct oc_context *ac;
+ struct ldb_request *rename_req;
+ struct ldb_dn *fixed_dn;
int ret;
-
- ac = talloc_get_type(h->private_data, struct oc_context);
- ac->rename_req = talloc(ac, struct ldb_request);
- if (ac->rename_req == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- *ac->rename_req = *ac->orig_req;
-
- ldb_set_timeout_from_prev_req(ac->module->ldb, ac->orig_req, ac->rename_req);
-
/* Check we have a valid parent */
if (ac->search_res == NULL) {
ldb_asprintf_errstring(ac->module->ldb, "objectclass: Cannot rename %s, parent does not exist!",
- ldb_dn_get_linearized(ac->orig_req->op.rename.newdn));
+ ldb_dn_get_linearized(ac->req->op.rename.newdn));
return LDB_ERR_UNWILLING_TO_PERFORM;
}
- /* Fix up the DN to be in the standard form, taking particular care to match the parent DN */
- ret = fix_dn(ac->rename_req,
- ac->orig_req->op.rename.newdn,
- ac->search_res->message->dn,
- &ac->rename_req->op.rename.newdn);
-
+ /* Fix up the DN to be in the standard form,
+ * taking particular care to match the parent DN */
+ ret = fix_dn(ac,
+ ac->req->op.rename.newdn,
+ ac->search_res->message->dn,
+ &fixed_dn);
if (ret != LDB_SUCCESS) {
return ret;
}
* by reading the allowedChildClasses and
* allowedChildClasssesEffective attributes */
- h->state = LDB_ASYNC_INIT;
- h->status = LDB_SUCCESS;
-
- ac->step = OC_DO_RENAME;
-
- /* perform the rename */
- return ldb_next_request(ac->module, ac->rename_req);
-}
-
-static int oc_wait(struct ldb_handle *handle) {
- struct oc_context *ac;
- int ret;
-
- if (!handle || !handle->private_data) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- if (handle->state == LDB_ASYNC_DONE) {
- return handle->status;
- }
-
- handle->state = LDB_ASYNC_PENDING;
- handle->status = LDB_SUCCESS;
-
- ac = talloc_get_type(handle->private_data, struct oc_context);
-
- switch (ac->step) {
- case OC_DO_REQ:
- ret = ldb_wait(ac->down_req->handle, LDB_WAIT_NONE);
-
- if (ret != LDB_SUCCESS) {
- handle->status = ret;
- goto done;
- }
- if (ac->down_req->handle->status != LDB_SUCCESS) {
- handle->status = ac->down_req->handle->status;
- goto done;
- }
-
- if (ac->down_req->handle->state != LDB_ASYNC_DONE) {
- return LDB_SUCCESS;
- }
-
- /* mods done, go on */
- return objectclass_search_self(handle);
-
- case OC_SEARCH_SELF:
- ret = ldb_wait(ac->search_req->handle, LDB_WAIT_NONE);
-
- if (ret != LDB_SUCCESS) {
- handle->status = ret;
- goto done;
- }
- if (ac->search_req->handle->status != LDB_SUCCESS) {
- handle->status = ac->search_req->handle->status;
- goto done;
- }
-
- if (ac->search_req->handle->state != LDB_ASYNC_DONE) {
- return LDB_SUCCESS;
- }
-
- /* self search done, go on */
- return objectclass_do_mod(handle);
-
- case OC_DO_MOD:
- ret = ldb_wait(ac->mod_req->handle, LDB_WAIT_NONE);
-
- if (ret != LDB_SUCCESS) {
- handle->status = ret;
- goto done;
- }
- if (ac->mod_req->handle->status != LDB_SUCCESS) {
- handle->status = ac->mod_req->handle->status;
- goto done;
- }
-
- if (ac->mod_req->handle->state != LDB_ASYNC_DONE) {
- return LDB_SUCCESS;
- }
-
- break;
-
- case OC_SEARCH_ADD_PARENT:
- ret = ldb_wait(ac->search_req->handle, LDB_WAIT_NONE);
-
- if (ret != LDB_SUCCESS && ret != LDB_ERR_NO_SUCH_OBJECT) {
- handle->status = ret;
- goto done;
- }
- if (ac->search_req->handle->status != LDB_SUCCESS
- && ac->search_req->handle->status != LDB_ERR_NO_SUCH_OBJECT) {
- handle->status = ac->search_req->handle->status;
- goto done;
- }
-
- if (ac->search_req->handle->state != LDB_ASYNC_DONE) {
- return LDB_SUCCESS;
- }
-
- /* parent search done, go on */
- return objectclass_do_add(handle);
-
- case OC_DO_ADD:
- ret = ldb_wait(ac->add_req->handle, LDB_WAIT_NONE);
-
- if (ret != LDB_SUCCESS) {
- handle->status = ret;
- goto done;
- }
- if (ac->add_req->handle->status != LDB_SUCCESS) {
- handle->status = ac->add_req->handle->status;
- goto done;
- }
-
- if (ac->add_req->handle->state != LDB_ASYNC_DONE) {
- return LDB_SUCCESS;
- }
-
- break;
-
- case OC_SEARCH_RENAME_PARENT:
- ret = ldb_wait(ac->search_req->handle, LDB_WAIT_NONE);
-
- if (ret != LDB_SUCCESS && ret != LDB_ERR_NO_SUCH_OBJECT) {
- handle->status = ret;
- goto done;
- }
- if (ac->search_req->handle->status != LDB_SUCCESS && ac->search_req->handle->status != LDB_ERR_NO_SUCH_OBJECT) {
- handle->status = ac->search_req->handle->status;
- goto done;
- }
-
- if (ac->search_req->handle->state != LDB_ASYNC_DONE) {
- return LDB_SUCCESS;
- }
-
- /* parent search done, go on */
- return objectclass_do_rename(handle);
-
- case OC_DO_RENAME:
- ret = ldb_wait(ac->rename_req->handle, LDB_WAIT_NONE);
-
- if (ret != LDB_SUCCESS) {
- handle->status = ret;
- goto done;
- }
- if (ac->rename_req->handle->status != LDB_SUCCESS) {
- handle->status = ac->rename_req->handle->status;
- goto done;
- }
-
- if (ac->rename_req->handle->state != LDB_ASYNC_DONE) {
- return LDB_SUCCESS;
- }
-
- break;
-
- default:
- ret = LDB_ERR_OPERATIONS_ERROR;
- goto done;
- }
-
- ret = LDB_SUCCESS;
-
-done:
- handle->state = LDB_ASYNC_DONE;
- return ret;
-}
-
-static int oc_wait_all(struct ldb_handle *handle) {
-
- int ret;
-
- while (handle->state != LDB_ASYNC_DONE) {
- ret = oc_wait(handle);
- if (ret != LDB_SUCCESS) {
- return ret;
- }
+ ret = ldb_build_rename_req(&rename_req, ac->module->ldb, ac,
+ ac->req->op.rename.olddn, fixed_dn,
+ ac->req->controls,
+ ac, oc_op_callback,
+ ac->req);
+ if (ret != LDB_SUCCESS) {
+ return ret;
}
- return handle->status;
-}
-
-static int objectclass_wait(struct ldb_handle *handle, enum ldb_wait_type type)
-{
- if (type == LDB_WAIT_ALL) {
- return oc_wait_all(handle);
- } else {
- return oc_wait(handle);
- }
+ /* perform the rename */
+ return ldb_next_request(ac->module, rename_req);
}
_PUBLIC_ const struct ldb_module_ops ldb_objectclass_module_ops = {
.add = objectclass_add,
.modify = objectclass_modify,
.rename = objectclass_rename,
- .wait = objectclass_wait
};
/*
ldb database library
- Copyright (C) Simo Sorce 2004-2006
Copyright (C) Andrew Bartlett <abartlet@samba.org> 2005
Copyright (C) Andrew Tridgell 2005
+ Copyright (C) Simo Sorce 2004-2008
** NOTE! The following LGPL license applies to the ldb
** library. This does NOT imply that all of Samba is released
return 0;
}
+struct og_context {
+ struct ldb_module *module;
+ struct ldb_request *req;
+};
+
+static int og_op_callback(struct ldb_request *req, struct ldb_reply *ares)
+{
+ struct og_context *ac;
+
+ ac = talloc_get_type(req->context, struct og_context);
+
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
+
+ if (ares->type != LDB_REPLY_DONE) {
+ talloc_free(ares);
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+}
+
/* add_record: add objectGUID attribute */
static int objectguid_add(struct ldb_module *module, struct ldb_request *req)
{
enum ndr_err_code ndr_err;
int ret;
time_t t = time(NULL);
+ struct og_context *ac;
ldb_debug(module->ldb, LDB_DEBUG_TRACE, "objectguid_add_record\n");
return ldb_next_request(module, req);
}
- down_req = talloc(req, struct ldb_request);
- if (down_req == NULL) {
+ ac = talloc(req, struct og_context);
+ if (ac == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
-
- *down_req = *req;
+ ac->module = module;
+ ac->req = req;
/* we have to copy the message as the caller might have it as a const */
- down_req->op.add.message = msg = ldb_msg_copy_shallow(down_req, req->op.add.message);
+ msg = ldb_msg_copy_shallow(ac, req->op.add.message);
if (msg == NULL) {
talloc_free(down_req);
return LDB_ERR_OPERATIONS_ERROR;
&guid,
(ndr_push_flags_fn_t)ndr_push_GUID);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
- talloc_free(down_req);
return LDB_ERR_OPERATIONS_ERROR;
}
ret = ldb_msg_add_value(msg, "objectGUID", &v, NULL);
if (ret) {
- talloc_free(down_req);
return ret;
}
if (add_time_element(msg, "whenCreated", t) != 0 ||
add_time_element(msg, "whenChanged", t) != 0) {
- talloc_free(down_req);
return LDB_ERR_OPERATIONS_ERROR;
}
/* Get a sequence number from the backend */
+ /* FIXME: ldb_sequence_number is still SYNC now, when this changes,
+ * make sure this function is split and a callback is used */
ret = ldb_sequence_number(module->ldb, LDB_SEQ_NEXT, &seq_num);
if (ret == LDB_SUCCESS) {
if (add_uint64_element(msg, "uSNCreated", seq_num) != 0 ||
add_uint64_element(msg, "uSNChanged", seq_num) != 0) {
- talloc_free(down_req);
return LDB_ERR_OPERATIONS_ERROR;
}
}
- ldb_set_timeout_from_prev_req(module->ldb, req, down_req);
-
- /* go on with the call chain */
- ret = ldb_next_request(module, down_req);
-
- /* do not free down_req as the call results may be linked to it,
- * it will be freed when the upper level request get freed */
- if (ret == LDB_SUCCESS) {
- req->handle = down_req->handle;
+ ret = ldb_build_add_req(&down_req, module->ldb, ac,
+ msg,
+ req->controls,
+ ac, og_op_callback,
+ req);
+ if (ret != LDB_SUCCESS) {
+ return LDB_ERR_OPERATIONS_ERROR;
}
- return ret;
+ /* go on with the call chain */
+ return ldb_next_request(module, down_req);
}
/* modify_record: update timestamps */
int ret;
time_t t = time(NULL);
uint64_t seq_num;
+ struct og_context *ac;
ldb_debug(module->ldb, LDB_DEBUG_TRACE, "objectguid_add_record\n");
return ldb_next_request(module, req);
}
- down_req = talloc(req, struct ldb_request);
- if (down_req == NULL) {
+ ac = talloc(req, struct og_context);
+ if (ac == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
-
- *down_req = *req;
+ ac->module = module;
+ ac->req = req;
/* we have to copy the message as the caller might have it as a const */
- down_req->op.mod.message = msg = ldb_msg_copy_shallow(down_req, req->op.mod.message);
+ msg = ldb_msg_copy_shallow(ac, req->op.mod.message);
if (msg == NULL) {
- talloc_free(down_req);
return LDB_ERR_OPERATIONS_ERROR;
}
if (add_time_element(msg, "whenChanged", t) != 0) {
- talloc_free(down_req);
return LDB_ERR_OPERATIONS_ERROR;
}
ret = ldb_sequence_number(module->ldb, LDB_SEQ_NEXT, &seq_num);
if (ret == LDB_SUCCESS) {
if (add_uint64_element(msg, "uSNChanged", seq_num) != 0) {
- talloc_free(down_req);
return LDB_ERR_OPERATIONS_ERROR;
}
}
- ldb_set_timeout_from_prev_req(module->ldb, req, down_req);
-
- /* go on with the call chain */
- ret = ldb_next_request(module, down_req);
-
- /* do not free down_req as the call results may be linked to it,
- * it will be freed when the upper level request get freed */
- if (ret == LDB_SUCCESS) {
- req->handle = down_req->handle;
+ ret = ldb_build_mod_req(&down_req, module->ldb, ac,
+ msg,
+ req->controls,
+ ac, og_op_callback,
+ req);
+ if (ret != LDB_SUCCESS) {
+ return LDB_ERR_OPERATIONS_ERROR;
}
- return ret;
+ /* go on with the call chain */
+ return ldb_next_request(module, down_req);
}
_PUBLIC_ const struct ldb_module_ops ldb_objectguid_module_ops = {
-
/*
Partitions ldb module
struct ldb_dn **replicate;
};
+struct part_request {
+ struct ldb_module *module;
+ struct ldb_request *req;
+};
+
struct partition_context {
struct ldb_module *module;
- struct ldb_request *orig_req;
+ struct ldb_request *req;
+ bool got_success;
- struct ldb_request **down_req;
+ struct part_request *part_req;
int num_requests;
int finished_requests;
};
-static struct partition_context *partition_init_handle(struct ldb_request *req, struct ldb_module *module)
+static struct partition_context *partition_init_ctx(struct ldb_module *module, struct ldb_request *req)
{
struct partition_context *ac;
- struct ldb_handle *h;
- h = talloc_zero(req, struct ldb_handle);
- if (h == NULL) {
- ldb_set_errstring(module->ldb, "Out of Memory");
- return NULL;
- }
-
- h->module = module;
-
- ac = talloc_zero(h, struct partition_context);
+ ac = talloc_zero(req, struct partition_context);
if (ac == NULL) {
ldb_set_errstring(module->ldb, "Out of Memory");
- talloc_free(h);
return NULL;
}
- h->private_data = ac;
-
ac->module = module;
- ac->orig_req = req;
-
- req->handle = h;
+ ac->req = req;
return ac;
}
-static struct ldb_module *make_module_for_next_request(TALLOC_CTX *mem_ctx,
- struct ldb_context *ldb,
- struct ldb_module *module)
+#define PARTITION_FIND_OP(module, op) do { \
+ struct ldb_context *ldbctx = module->ldb; \
+ while (module && module->ops->op == NULL) module = module->next; \
+ if (module == NULL) { \
+ ldb_asprintf_errstring(ldbctx, \
+ "Unable to find backend operation for " #op ); \
+ return LDB_ERR_OPERATIONS_ERROR; \
+ } \
+} while (0)
+
+/*
+ * helper functions to call the next module in chain
+ * */
+
+int partition_request(struct ldb_module *module, struct ldb_request *request)
{
- struct ldb_module *current;
- static const struct ldb_module_ops ops; /* zero */
- current = talloc_zero(mem_ctx, struct ldb_module);
- if (current == NULL) {
- return module;
+ int ret;
+ switch (request->operation) {
+ case LDB_SEARCH:
+ PARTITION_FIND_OP(module, search);
+ ret = module->ops->search(module, request);
+ break;
+ case LDB_ADD:
+ PARTITION_FIND_OP(module, add);
+ ret = module->ops->add(module, request);
+ break;
+ case LDB_MODIFY:
+ PARTITION_FIND_OP(module, modify);
+ ret = module->ops->modify(module, request);
+ break;
+ case LDB_DELETE:
+ PARTITION_FIND_OP(module, del);
+ ret = module->ops->del(module, request);
+ break;
+ case LDB_RENAME:
+ PARTITION_FIND_OP(module, rename);
+ ret = module->ops->rename(module, request);
+ break;
+ case LDB_EXTENDED:
+ PARTITION_FIND_OP(module, extended);
+ ret = module->ops->extended(module, request);
+ break;
+ case LDB_SEQUENCE_NUMBER:
+ PARTITION_FIND_OP(module, sequence_number);
+ ret = module->ops->sequence_number(module, request);
+ break;
+ default:
+ PARTITION_FIND_OP(module, request);
+ ret = module->ops->request(module, request);
+ break;
}
-
- current->ldb = ldb;
- current->ops = &ops;
- current->prev = NULL;
- current->next = module;
- return current;
+ if (ret == LDB_SUCCESS) {
+ return ret;
+ }
+ if (!ldb_errstring(module->ldb)) {
+ /* Set a default error string, to place the blame somewhere */
+ ldb_asprintf_errstring(module->ldb,
+ "error in module %s: %s (%d)",
+ module->ops->name,
+ ldb_strerror(ret), ret);
+ }
+ return ret;
}
static struct dsdb_control_current_partition *find_partition(struct partition_private_data *data,
/**
* fire the caller's callback for every entry, but only send 'done' once.
*/
-static int partition_search_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
+static int partition_req_callback(struct ldb_request *req,
+ struct ldb_reply *ares)
{
struct partition_context *ac;
+ struct ldb_module *module;
+ struct ldb_request *nreq;
+ int ret;
- ac = talloc_get_type(context, struct partition_context);
+ ac = talloc_get_type(req->context, struct partition_context);
- if (ares->type == LDB_REPLY_ENTRY) {
- return ac->orig_req->callback(ldb, ac->orig_req->context, ares);
- } else {
- ac->finished_requests++;
- if (ac->finished_requests == ac->num_requests) {
- return ac->orig_req->callback(ldb, ac->orig_req->context, ares);
- } else {
- talloc_free(ares);
- return LDB_SUCCESS;
- }
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
-}
-/**
- * only fire the 'last' callback, and only for START-TLS for now
- */
-static int partition_other_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
-{
- struct partition_context *ac;
+ if (ares->error != LDB_SUCCESS && !ac->got_success) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
- ac = talloc_get_type(context, struct partition_context);
+ switch (ares->type) {
+ case LDB_REPLY_REFERRAL:
+ /* ignore referrals for now */
+ break;
- if (!ac->orig_req->callback) {
- talloc_free(ares);
- return LDB_SUCCESS;
- }
+ case LDB_REPLY_ENTRY:
+ if (ac->req->operation != LDB_SEARCH) {
+ ldb_set_errstring(ac->module->ldb,
+ "partition_req_callback:"
+ " Unsupported reply type for this request");
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ return ldb_module_send_entry(ac->req, ares->message);
+
+ case LDB_REPLY_DONE:
+ if (ares->error == LDB_SUCCESS) {
+ ac->got_success = true;
+ }
+ if (ac->req->operation == LDB_EXTENDED) {
+ /* FIXME: check for ares->response, replmd does not fill it ! */
+ if (ares->response) {
+ if (strcmp(ares->response->oid, LDB_EXTENDED_START_TLS_OID) != 0) {
+ ldb_set_errstring(ac->module->ldb,
+ "partition_req_callback:"
+ " Unknown extended reply, "
+ "only supports START_TLS");
+ talloc_free(ares);
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ }
+ }
- if (!ares
- || (ares->type == LDB_REPLY_EXTENDED
- && strcmp(ares->response->oid, LDB_EXTENDED_START_TLS_OID))) {
ac->finished_requests++;
if (ac->finished_requests == ac->num_requests) {
- return ac->orig_req->callback(ldb, ac->orig_req->context, ares);
+ /* this was the last one, call callback */
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response,
+ ac->got_success?LDB_SUCCESS:ares->error);
+ }
+
+ /* not the last, now call the next one */
+ module = ac->part_req[ac->finished_requests].module;
+ nreq = ac->part_req[ac->finished_requests].req;
+
+ ret = partition_request(module, nreq);
+ if (ret != LDB_SUCCESS) {
+ talloc_free(ares);
+ return ldb_module_done(ac->req, NULL, NULL, ret);
}
- talloc_free(ares);
- return LDB_SUCCESS;
+
+ break;
}
- ldb_set_errstring(ldb, "partition_other_callback: Unknown reply type, only supports START_TLS");
+
talloc_free(ares);
- return LDB_ERR_OPERATIONS_ERROR;
+ return LDB_SUCCESS;
}
-
-static int partition_send_request(struct partition_context *ac,
+static int partition_prep_request(struct partition_context *ac,
struct dsdb_control_current_partition *partition)
{
int ret;
- struct ldb_module *backend;
struct ldb_request *req;
- if (partition) {
- backend = make_module_for_next_request(ac, ac->module->ldb, partition->module);
- } else {
- backend = ac->module;
- }
-
- ac->down_req = talloc_realloc(ac, ac->down_req,
- struct ldb_request *, ac->num_requests + 1);
- if (!ac->down_req) {
+ ac->part_req = talloc_realloc(ac, ac->part_req,
+ struct part_request,
+ ac->num_requests + 1);
+ if (ac->part_req == NULL) {
ldb_oom(ac->module->ldb);
return LDB_ERR_OPERATIONS_ERROR;
}
- req = ac->down_req[ac->num_requests] = talloc(ac, struct ldb_request);
- if (req == NULL) {
- ldb_oom(ac->module->ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+
+ switch (ac->req->operation) {
+ case LDB_SEARCH:
+ ret = ldb_build_search_req_ex(&req, ac->module->ldb,
+ ac->part_req,
+ ac->req->op.search.base,
+ ac->req->op.search.scope,
+ ac->req->op.search.tree,
+ ac->req->op.search.attrs,
+ ac->req->controls,
+ ac, partition_req_callback,
+ ac->req);
+ break;
+ case LDB_ADD:
+ ret = ldb_build_add_req(&req, ac->module->ldb, ac->part_req,
+ ac->req->op.add.message,
+ ac->req->controls,
+ ac, partition_req_callback,
+ ac->req);
+ break;
+ case LDB_MODIFY:
+ ret = ldb_build_mod_req(&req, ac->module->ldb, ac->part_req,
+ ac->req->op.mod.message,
+ ac->req->controls,
+ ac, partition_req_callback,
+ ac->req);
+ break;
+ case LDB_DELETE:
+ ret = ldb_build_del_req(&req, ac->module->ldb, ac->part_req,
+ ac->req->op.del.dn,
+ ac->req->controls,
+ ac, partition_req_callback,
+ ac->req);
+ break;
+ case LDB_RENAME:
+ ret = ldb_build_rename_req(&req, ac->module->ldb, ac->part_req,
+ ac->req->op.rename.olddn,
+ ac->req->op.rename.newdn,
+ ac->req->controls,
+ ac, partition_req_callback,
+ ac->req);
+ break;
+ case LDB_EXTENDED:
+ ret = ldb_build_extended_req(&req, ac->module->ldb,
+ ac->part_req,
+ ac->req->op.extended.oid,
+ ac->req->op.extended.data,
+ ac->req->controls,
+ ac, partition_req_callback,
+ ac->req);
+ break;
+ default:
+ ldb_set_errstring(ac->module->ldb,
+ "Unsupported request type!");
+ ret = LDB_ERR_UNWILLING_TO_PERFORM;
}
-
- *req = *ac->orig_req; /* copy the request */
- if (req->controls) {
- req->controls
- = talloc_memdup(req,
- ac->orig_req->controls, talloc_get_size(ac->orig_req->controls));
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
+
+ ac->part_req[ac->num_requests].req = req;
+
+ if (ac->req->controls) {
+ req->controls = talloc_memdup(req, ac->req->controls,
+ talloc_get_size(ac->req->controls));
if (req->controls == NULL) {
ldb_oom(ac->module->ldb);
return LDB_ERR_OPERATIONS_ERROR;
}
}
- if (req->operation == LDB_SEARCH) {
- /* If the search is for 'more' than this partition,
- * then change the basedn, so a remote LDAP server
- * doesn't object */
- if (partition) {
- if (ldb_dn_compare_base(partition->dn, req->op.search.base) != 0) {
- req->op.search.base = partition->dn;
- }
- } else {
- req->op.search.base = NULL;
- }
- req->callback = partition_search_callback;
- req->context = ac;
- } else {
- req->callback = partition_other_callback;
- req->context = ac;
- }
-
if (partition) {
- ret = ldb_request_add_control(req, DSDB_CONTROL_CURRENT_PARTITION_OID, false, partition);
+ ac->part_req[ac->num_requests].module = partition->module;
+
+ ret = ldb_request_add_control(req,
+ DSDB_CONTROL_CURRENT_PARTITION_OID,
+ false, partition);
if (ret != LDB_SUCCESS) {
return ret;
}
- }
- /* Spray off search requests the backend */
- ret = ldb_next_request(backend, req);
- if (ret != LDB_SUCCESS) {
- return ret;
+ if (req->operation == LDB_SEARCH) {
+ /* If the search is for 'more' than this partition,
+ * then change the basedn, so a remote LDAP server
+ * doesn't object */
+ if (ldb_dn_compare_base(partition->dn,
+ req->op.search.base) != 0) {
+ req->op.search.base = partition->dn;
+ }
+ }
+
+ } else {
+ /* make sure you put the NEXT module here, or
+ * partition_request() will simply loop forever on itself */
+ ac->part_req[ac->num_requests].module = ac->module->next;
}
ac->num_requests++;
+
return LDB_SUCCESS;
}
+static int partition_call_first(struct partition_context *ac)
+{
+ return partition_request(ac->part_req[0].module, ac->part_req[0].req);
+}
+
/**
* Send a request down to all the partitions
*/
int i;
struct partition_private_data *data = talloc_get_type(module->private_data,
struct partition_private_data);
- int ret = partition_send_request(ac, NULL);
+ int ret = partition_prep_request(ac, NULL);
if (ret != LDB_SUCCESS) {
return ret;
}
for (i=0; data && data->partitions && data->partitions[i]; i++) {
- ret = partition_send_request(ac, data->partitions[i]);
+ ret = partition_prep_request(ac, data->partitions[i]);
if (ret != LDB_SUCCESS) {
return ret;
}
}
- return LDB_SUCCESS;
+
+ /* fire the first one */
+ return partition_call_first(ac);
}
/**
*/
static int partition_replicate(struct ldb_module *module, struct ldb_request *req, struct ldb_dn *dn)
{
+ struct partition_context *ac;
unsigned i;
int ret;
struct dsdb_control_current_partition *partition;
- struct ldb_module *backend;
struct partition_private_data *data = talloc_get_type(module->private_data,
struct partition_private_data);
+ if (!data || !data->partitions) {
+ return ldb_next_request(module, req);
+ }
if (req->operation != LDB_SEARCH) {
/* Is this a special DN, we need to replicate to every backend? */
for (i=0; data->replicate && data->replicate[i]; i++) {
if (ldb_dn_compare(data->replicate[i],
dn) == 0) {
- struct partition_context *ac;
- ac = partition_init_handle(req, module);
+ ac = partition_init_ctx(module, req);
if (!ac) {
return LDB_ERR_OPERATIONS_ERROR;
}
return ldb_next_request(module, req);
}
- backend = make_module_for_next_request(req, module->ldb, partition->module);
- if (!backend) {
+ ac = partition_init_ctx(module, req);
+ if (!ac) {
return LDB_ERR_OPERATIONS_ERROR;
}
- ret = ldb_request_add_control(req, DSDB_CONTROL_CURRENT_PARTITION_OID, false, partition);
+ /* we need to add a control but we never touch the original request */
+ ret = partition_prep_request(ac, partition);
if (ret != LDB_SUCCESS) {
return ret;
}
- /* issue request */
- return ldb_next_request(backend, req);
+ /* fire the first one */
+ return partition_call_first(ac);
}
/* search */
/* (later) consider if we should be searching multiple
* partitions (for 'invisible' partition behaviour */
+
struct ldb_control *search_control = ldb_request_get_control(req, LDB_CONTROL_SEARCH_OPTIONS_OID);
struct ldb_control *domain_scope_control = ldb_request_get_control(req, LDB_CONTROL_DOMAIN_SCOPE_OID);
return LDB_ERR_OPERATIONS_ERROR;
}
+ /*
+ * for now pass down the LDB_CONTROL_SEARCH_OPTIONS_OID control
+ * down as uncritical to make windows 2008 dcpromo happy.
+ */
+ if (search_control) {
+ search_control->critical = 0;
+ }
+
/* TODO:
Generate referrals (look for a partition under this DN) if we don't have the above control specified
*/
return LDB_ERR_OPERATIONS_ERROR;
}
}
- ac = partition_init_handle(req, module);
+ ac = partition_init_ctx(module, req);
if (!ac) {
return LDB_ERR_OPERATIONS_ERROR;
}
return partition_send_all(module, ac, req);
}
for (i=0; data && data->partitions && data->partitions[i]; i++) {
- /* Find all partitions under the search base */
- if (ldb_dn_compare_base(req->op.search.base, data->partitions[i]->dn) == 0) {
- ret = partition_send_request(ac, data->partitions[i]);
+ bool match = false, stop = false;
+ /* Find all partitions under the search base
+
+ we match if:
+
+ 1) the DN we are looking for exactly matches the partition
+ or
+ 2) the DN we are looking for is a parent of the partition and it isn't
+ a scope base search
+ or
+ 3) the DN we are looking for is a child of the partition
+ */
+ if (ldb_dn_compare(data->partitions[i]->dn, req->op.search.base) == 0) {
+ match = true;
+ if (req->op.search.scope == LDB_SCOPE_BASE) {
+ stop = true;
+ }
+ }
+ if (!match &&
+ (ldb_dn_compare_base(req->op.search.base, data->partitions[i]->dn) == 0 &&
+ req->op.search.scope != LDB_SCOPE_BASE)) {
+ match = true;
+ }
+ if (!match &&
+ ldb_dn_compare_base(data->partitions[i]->dn, req->op.search.base) == 0) {
+ match = true;
+ stop = true; /* note that this relies on partition ordering */
+ }
+ if (match) {
+ ret = partition_prep_request(ac, data->partitions[i]);
if (ret != LDB_SUCCESS) {
return ret;
}
}
+ if (stop) break;
}
/* Perhaps we didn't match any partitions. Try the main partition, only */
talloc_free(ac);
return ldb_next_request(module, req);
}
-
- return LDB_SUCCESS;
+
+ /* fire the first one */
+ return partition_call_first(ac);
+
} else {
/* Handle this like all other requests */
if (search_control && (search_options->search_options & ~LDB_SEARCH_OPTION_PHANTOM_ROOT) == 0) {
/* rename */
static int partition_rename(struct ldb_module *module, struct ldb_request *req)
{
- int i, matched = -1;
/* Find backend */
struct dsdb_control_current_partition *backend, *backend2;
struct partition_private_data *data = talloc_get_type(module->private_data,
struct partition_private_data);
- /* Skip the lot if 'data' isn't here yet (initialistion) */
+ /* Skip the lot if 'data' isn't here yet (initialization) */
if (!data) {
return LDB_ERR_OPERATIONS_ERROR;
}
return LDB_ERR_AFFECTS_MULTIPLE_DSAS;
}
- for (i=0; data && data->partitions && data->partitions[i]; i++) {
- if (ldb_dn_compare_base(req->op.rename.olddn, data->partitions[i]->dn) == 0) {
- matched = i;
- }
- }
-
- if (matched > 0) {
- ldb_asprintf_errstring(module->ldb,
- "Cannot rename from %s to %s, subtree rename would cross partition %s: %s",
- ldb_dn_get_linearized(req->op.rename.olddn),
- ldb_dn_get_linearized(req->op.rename.newdn),
- ldb_dn_get_linearized(data->partitions[matched]->dn),
- ldb_strerror(LDB_ERR_AFFECTS_MULTIPLE_DSAS));
- return LDB_ERR_AFFECTS_MULTIPLE_DSAS;
- }
-
return partition_replicate(module, req, req->op.rename.olddn);
}
struct partition_private_data);
/* Look at base DN */
/* Figure out which partition it is under */
- /* Skip the lot if 'data' isn't here yet (initialistion) */
+ /* Skip the lot if 'data' isn't here yet (initialization) */
ret = ldb_next_start_trans(module);
if (ret != LDB_SUCCESS) {
return ret;
}
for (i=0; data && data->partitions && data->partitions[i]; i++) {
- struct ldb_module *next = make_module_for_next_request(module, module->ldb, data->partitions[i]->module);
+ struct ldb_module *next = data->partitions[i]->module;
+ PARTITION_FIND_OP(next, start_transaction);
- ret = ldb_next_start_trans(next);
- talloc_free(next);
+ ret = next->ops->start_transaction(next);
if (ret != LDB_SUCCESS) {
/* Back it out, if it fails on one */
for (i--; i >= 0; i--) {
- next = make_module_for_next_request(module, module->ldb, data->partitions[i]->module);
- ldb_next_del_trans(next);
- talloc_free(next);
+ next = data->partitions[i]->module;
+ PARTITION_FIND_OP(next, del_transaction);
+
+ next->ops->del_transaction(next);
}
+ ldb_next_del_trans(module);
return ret;
}
}
/* end a transaction */
static int partition_end_trans(struct ldb_module *module)
{
- int i, ret, ret2 = LDB_SUCCESS;
+ int i, ret;
struct partition_private_data *data = talloc_get_type(module->private_data,
struct partition_private_data);
ret = ldb_next_end_trans(module);
/* Figure out which partition it is under */
/* Skip the lot if 'data' isn't here yet (initialistion) */
for (i=0; data && data->partitions && data->partitions[i]; i++) {
- struct ldb_module *next = make_module_for_next_request(module, module->ldb, data->partitions[i]->module);
-
- ret = ldb_next_end_trans(next);
- talloc_free(next);
+ struct ldb_module *next = data->partitions[i]->module;
+ PARTITION_FIND_OP(next, end_transaction);
+
+ ret = next->ops->end_transaction(next);
if (ret != LDB_SUCCESS) {
- ret2 = ret;
- }
- }
+ /* Back it out, if it fails on one */
+ for (i--; i >= 0; i--) {
+ next = data->partitions[i]->module;
+ PARTITION_FIND_OP(next, del_transaction);
- if (ret != LDB_SUCCESS) {
- /* Back it out, if it fails on one */
- for (i=0; data && data->partitions && data->partitions[i]; i++) {
- struct ldb_module *next = make_module_for_next_request(module, module->ldb, data->partitions[i]->module);
- ldb_next_del_trans(next);
- talloc_free(next);
+ next->ops->del_transaction(next);
+ }
+ ldb_next_del_trans(module);
+ return ret;
}
}
- return ret;
+
+ return LDB_SUCCESS;
}
/* delete a transaction */
/* Figure out which partition it is under */
/* Skip the lot if 'data' isn't here yet (initialistion) */
for (i=0; data && data->partitions && data->partitions[i]; i++) {
- struct ldb_module *next = make_module_for_next_request(module, module->ldb, data->partitions[i]->module);
-
- ret = ldb_next_del_trans(next);
- talloc_free(next);
+ struct ldb_module *next = data->partitions[i]->module;
+ PARTITION_FIND_OP(next, del_transaction);
+
+ ret = next->ops->del_transaction(next);
if (ret != LDB_SUCCESS) {
ret2 = ret;
}
return ret2;
}
+/* NOTE: ldb_sequence_number is still a completely SYNCHRONOUS call
+ * implemented only in ldb_rdb. It does not require ldb_wait() to be
+ * called after a request is made */
static int partition_sequence_number(struct ldb_module *module, struct ldb_request *req)
{
int i, ret;
seq_number = seq_number + req->op.seq_num.seq_num;
}
+ /* gross hack part1 */
+ ret = ldb_request_add_control(req,
+ DSDB_CONTROL_CURRENT_PARTITION_OID,
+ false, NULL);
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
+
/* Look at base DN */
/* Figure out which partition it is under */
/* Skip the lot if 'data' isn't here yet (initialistion) */
for (i=0; data && data->partitions && data->partitions[i]; i++) {
- struct ldb_module *next = make_module_for_next_request(req, module->ldb, data->partitions[i]->module);
-
- ret = ldb_request_add_control(req, DSDB_CONTROL_CURRENT_PARTITION_OID, false, data->partitions[i]);
- if (ret != LDB_SUCCESS) {
- return ret;
+
+ /* gross hack part2 */
+ int j;
+ for (j=0; req->controls[j]; j++) {
+ if (strcmp(req->controls[j]->oid, DSDB_CONTROL_CURRENT_PARTITION_OID) == 0) {
+ req->controls[j]->data = data->partitions[i];
+ break;
+ }
}
- ret = ldb_next_request(next, req);
- talloc_free(next);
+ ret = partition_request(data->partitions[i]->module, req);
if (ret != LDB_SUCCESS) {
return ret;
}
return ret;
}
timestamp = date_req->op.seq_num.seq_num;
-
+
/* Look at base DN */
/* Figure out which partition it is under */
/* Skip the lot if 'data' isn't here yet (initialistion) */
for (i=0; data && data->partitions && data->partitions[i]; i++) {
- struct ldb_module *next = make_module_for_next_request(req, module->ldb, data->partitions[i]->module);
-
- ret = ldb_next_request(next, date_req);
- talloc_free(next);
+
+ ret = partition_request(data->partitions[i]->module, req);
if (ret != LDB_SUCCESS) {
return ret;
}
switch (req->op.seq_num.flags) {
case LDB_SEQ_NEXT:
case LDB_SEQ_HIGHEST_SEQ:
-
+
req->op.seq_num.flags = 0;
/* Has someone above set a timebase sequence? */
struct partition_private_data *data;
struct ldb_dn *schema_dn;
struct partition_context *ac;
- struct ldb_module *backend;
int ret;
schema_dn = talloc_get_type(req->op.extended.data, struct ldb_dn);
return ldb_next_request(module, req);
}
- ac = partition_init_handle(req, module);
+ ac = partition_init_ctx(module, req);
if (!ac) {
return LDB_ERR_OPERATIONS_ERROR;
}
- backend = make_module_for_next_request(req, module->ldb, partition->module);
- if (!backend) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- ret = ldb_request_add_control(req, DSDB_CONTROL_CURRENT_PARTITION_OID, false, partition);
+ /* we need to add a control but we never touch the original request */
+ ret = partition_prep_request(ac, partition);
if (ret != LDB_SUCCESS) {
return ret;
}
- return ldb_next_request(backend, req);
+ /* fire the first one */
+ return partition_call_first(ac);
}
/* extended */
static int partition_extended(struct ldb_module *module, struct ldb_request *req)
{
+ struct partition_private_data *data;
struct partition_context *ac;
+ data = talloc_get_type(module->private_data, struct partition_private_data);
+ if (!data || !data->partitions) {
+ return ldb_next_request(module, req);
+ }
+
if (strcmp(req->op.extended.oid, DSDB_EXTENDED_REPLICATED_OBJECTS_OID) == 0) {
return partition_extended_replicated_objects(module, req);
}
* we need to send it to all partitions
*/
- ac = partition_init_handle(req, module);
+ ac = partition_init_ctx(module, req);
if (!ac) {
return LDB_ERR_OPERATIONS_ERROR;
}
-
+
return partition_send_all(module, ac, req);
}
-static int sort_compare(void *void1,
- void *void2, void *opaque)
+static int partition_sort_compare(const void *v1, const void *v2)
{
- struct dsdb_control_current_partition **pp1 =
- (struct dsdb_control_current_partition **)void1;
- struct dsdb_control_current_partition **pp2 =
- (struct dsdb_control_current_partition **)void2;
- struct dsdb_control_current_partition *partition1 = talloc_get_type(*pp1,
- struct dsdb_control_current_partition);
- struct dsdb_control_current_partition *partition2 = talloc_get_type(*pp2,
- struct dsdb_control_current_partition);
-
- return ldb_dn_compare(partition1->dn, partition2->dn);
+ struct dsdb_control_current_partition *p1;
+ struct dsdb_control_current_partition *p2;
+
+ p1 = *((struct dsdb_control_current_partition **)v1);
+ p2 = *((struct dsdb_control_current_partition **)v2);
+
+ return ldb_dn_compare(p1->dn, p2->dn);
}
static int partition_init(struct ldb_module *module)
return LDB_ERR_OPERATIONS_ERROR;
}
- ret = ldb_search(module->ldb, ldb_dn_new(mem_ctx, module->ldb, "@PARTITION"),
- LDB_SCOPE_BASE,
- NULL, attrs,
- &res);
+ ret = ldb_search(module->ldb, mem_ctx, &res,
+ ldb_dn_new(mem_ctx, module->ldb, "@PARTITION"),
+ LDB_SCOPE_BASE, attrs, NULL);
if (ret != LDB_SUCCESS) {
talloc_free(mem_ctx);
return ret;
}
- talloc_steal(mem_ctx, res);
if (res->count == 0) {
talloc_free(mem_ctx);
return ldb_next_init(module);
data->partitions[i] = NULL;
/* sort these into order, most to least specific */
- ldb_qsort(data->partitions, partition_attributes->num_values, sizeof(*data->partitions),
- module->ldb, sort_compare);
+ qsort(data->partitions, partition_attributes->num_values,
+ sizeof(*data->partitions), partition_sort_compare);
for (i=0; data->partitions[i]; i++) {
struct ldb_request *req;
req->operation = LDB_REQ_REGISTER_PARTITION;
req->op.reg_partition.dn = data->partitions[i]->dn;
+ req->callback = ldb_op_default_callback;
+
+ ldb_set_timeout(module->ldb, req, 0);
+
+ req->handle = ldb_handle_new(req, module->ldb);
+ if (req->handle == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
ret = ldb_request(module->ldb, req);
+ if (ret == LDB_SUCCESS) {
+ ret = ldb_wait(req->handle, LDB_WAIT_ALL);
+ }
if (ret != LDB_SUCCESS) {
ldb_debug(module->ldb, LDB_DEBUG_ERROR, "partition: Unable to register partition with rootdse!\n");
talloc_free(mem_ctx);
talloc_free(mem_ctx);
return LDB_ERR_OPERATIONS_ERROR;
}
-
+
for (i=0; i < replicate_attributes->num_values; i++) {
data->replicate[i] = ldb_dn_from_ldb_val(data->replicate, module->ldb, &replicate_attributes->values[i]);
if (!ldb_dn_validate(data->replicate[i])) {
}
}
- talloc_free(mem_ctx);
- return ldb_next_init(module);
-}
-
-static int partition_wait_none(struct ldb_handle *handle) {
- struct partition_context *ac;
- int ret;
- int i;
-
- if (!handle || !handle->private_data) {
+ ret = ldb_mod_register_control(module, LDB_CONTROL_DOMAIN_SCOPE_OID);
+ if (ret != LDB_SUCCESS) {
+ ldb_debug(module->ldb, LDB_DEBUG_ERROR,
+ "partition: Unable to register control with rootdse!\n");
return LDB_ERR_OPERATIONS_ERROR;
}
- if (handle->state == LDB_ASYNC_DONE) {
- return handle->status;
- }
-
- handle->state = LDB_ASYNC_PENDING;
- handle->status = LDB_SUCCESS;
-
- ac = talloc_get_type(handle->private_data, struct partition_context);
-
- for (i=0; i < ac->num_requests; i++) {
- ret = ldb_wait(ac->down_req[i]->handle, LDB_WAIT_NONE);
-
- if (ret != LDB_SUCCESS) {
- handle->status = ret;
- goto done;
- }
- if (ac->down_req[i]->handle->status != LDB_SUCCESS) {
- handle->status = ac->down_req[i]->handle->status;
- goto done;
- }
-
- if (ac->down_req[i]->handle->state != LDB_ASYNC_DONE) {
- return LDB_SUCCESS;
- }
- }
-
- ret = LDB_SUCCESS;
-
-done:
- handle->state = LDB_ASYNC_DONE;
- return ret;
-}
-
-
-static int partition_wait_all(struct ldb_handle *handle) {
-
- int ret;
-
- while (handle->state != LDB_ASYNC_DONE) {
- ret = partition_wait_none(handle);
- if (ret != LDB_SUCCESS) {
- return ret;
- }
+ ret = ldb_mod_register_control(module, LDB_CONTROL_SEARCH_OPTIONS_OID);
+ if (ret != LDB_SUCCESS) {
+ ldb_debug(module->ldb, LDB_DEBUG_ERROR,
+ "partition: Unable to register control with rootdse!\n");
+ return LDB_ERR_OPERATIONS_ERROR;
}
- return handle->status;
-}
-
-static int partition_wait(struct ldb_handle *handle, enum ldb_wait_type type)
-{
- if (type == LDB_WAIT_ALL) {
- return partition_wait_all(handle);
- } else {
- return partition_wait_none(handle);
- }
+ talloc_free(mem_ctx);
+ return ldb_next_init(module);
}
_PUBLIC_ const struct ldb_module_ops ldb_partition_module_ops = {
.start_transaction = partition_start_trans,
.end_transaction = partition_end_trans,
.del_transaction = partition_del_trans,
- .wait = partition_wait
};
/*
ldb database module
- Copyright (C) Simo Sorce 2004-2006
+ Copyright (C) Simo Sorce 2004-2008
Copyright (C) Andrew Bartlett <abartlet@samba.org> 2005-2006
Copyright (C) Andrew Tridgell 2004
Copyright (C) Stefan Metzmacher 2007
#include "dsdb/samdb/ldb_modules/password_modules.h"
#include "librpc/ndr/libndr.h"
#include "librpc/gen_ndr/ndr_drsblobs.h"
-#include "lib/crypto/crypto.h"
+#include "../lib/crypto/crypto.h"
#include "param/param.h"
/* If we have decided there is reason to work on this request, then
struct ph_context {
- enum ph_type {PH_ADD, PH_MOD} type;
- enum ph_step {PH_ADD_SEARCH_DOM, PH_ADD_DO_ADD, PH_MOD_DO_REQ, PH_MOD_SEARCH_SELF, PH_MOD_SEARCH_DOM, PH_MOD_DO_MOD} step;
-
struct ldb_module *module;
- struct ldb_request *orig_req;
+ struct ldb_request *req;
struct ldb_request *dom_req;
struct ldb_reply *dom_res;
- struct ldb_request *down_req;
-
- struct ldb_request *search_req;
struct ldb_reply *search_res;
- struct ldb_request *mod_req;
-
struct dom_sid *domain_sid;
+ struct domain_data *domain;
};
struct domain_data {
return LDB_SUCCESS;
}
-static struct ldb_handle *ph_init_handle(struct ldb_request *req, struct ldb_module *module, enum ph_type type)
+static struct ph_context *ph_init_context(struct ldb_module *module,
+ struct ldb_request *req)
{
struct ph_context *ac;
- struct ldb_handle *h;
- h = talloc_zero(req, struct ldb_handle);
- if (h == NULL) {
- ldb_set_errstring(module->ldb, "Out of Memory");
- return NULL;
- }
-
- h->module = module;
-
- ac = talloc_zero(h, struct ph_context);
+ ac = talloc_zero(req, struct ph_context);
if (ac == NULL) {
ldb_set_errstring(module->ldb, "Out of Memory");
- talloc_free(h);
return NULL;
}
- h->private_data = (void *)ac;
-
- h->state = LDB_ASYNC_INIT;
- h->status = LDB_SUCCESS;
-
- ac->type = type;
ac->module = module;
- ac->orig_req = req;
+ ac->req = req;
- return h;
+ return ac;
}
-static int get_domain_data_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
+static int ph_op_callback(struct ldb_request *req, struct ldb_reply *ares)
{
struct ph_context *ac;
- ac = talloc_get_type(context, struct ph_context);
+ ac = talloc_get_type(req->context, struct ph_context);
- /* we are interested only in the single reply (base search) we receive here */
- if (ares->type == LDB_REPLY_ENTRY) {
- if (ac->dom_res != NULL) {
- ldb_set_errstring(ldb, "Too many results");
- talloc_free(ares);
- return LDB_ERR_OPERATIONS_ERROR;
- }
- ac->dom_res = talloc_steal(ac, ares);
- } else {
- talloc_free(ares);
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
-
- return LDB_SUCCESS;
-}
-
-static int build_domain_data_request(struct ph_context *ac)
-{
- /* attrs[] is returned from this function in
- ac->dom_req->op.search.attrs, so it must be static, as
- otherwise the compiler can put it on the stack */
- static const char * const attrs[] = { "pwdProperties", "pwdHistoryLength", NULL };
- char *filter;
-
- ac->dom_req = talloc_zero(ac, struct ldb_request);
- if (ac->dom_req == NULL) {
- ldb_debug(ac->module->ldb, LDB_DEBUG_ERROR, "Out of Memory!\n");
- return LDB_ERR_OPERATIONS_ERROR;
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
}
- ac->dom_req->operation = LDB_SEARCH;
- ac->dom_req->op.search.base = ldb_get_default_basedn(ac->module->ldb);
- ac->dom_req->op.search.scope = LDB_SCOPE_SUBTREE;
- filter = talloc_asprintf(ac->dom_req,
- "(&(objectSid=%s)(|(|(objectClass=domain)(objectClass=builtinDomain))(objectClass=samba4LocalDomain)))",
- ldap_encode_ndr_dom_sid(ac->dom_req, ac->domain_sid));
- if (filter == NULL) {
- ldb_debug(ac->module->ldb, LDB_DEBUG_ERROR, "Out of Memory!\n");
- talloc_free(ac->dom_req);
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- ac->dom_req->op.search.tree = ldb_parse_tree(ac->dom_req, filter);
- if (ac->dom_req->op.search.tree == NULL) {
- ldb_set_errstring(ac->module->ldb, "Invalid search filter");
- talloc_free(ac->dom_req);
- return LDB_ERR_OPERATIONS_ERROR;
+ if (ares->type != LDB_REPLY_DONE) {
+ talloc_free(ares);
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
- ac->dom_req->op.search.attrs = attrs;
- ac->dom_req->controls = NULL;
- ac->dom_req->context = ac;
- ac->dom_req->callback = get_domain_data_callback;
- ldb_set_timeout_from_prev_req(ac->module->ldb, ac->orig_req, ac->dom_req);
- return LDB_SUCCESS;
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
}
-static struct domain_data *get_domain_data(struct ldb_module *module, void *ctx, struct ldb_reply *res)
+static int password_hash_add_do_add(struct ph_context *ac);
+static int ph_modify_callback(struct ldb_request *req, struct ldb_reply *ares);
+static int password_hash_mod_search_self(struct ph_context *ac);
+static int ph_mod_search_callback(struct ldb_request *req, struct ldb_reply *ares);
+static int password_hash_mod_do_mod(struct ph_context *ac);
+
+static int get_domain_data_callback(struct ldb_request *req,
+ struct ldb_reply *ares)
{
struct domain_data *data;
- const char *tmp;
struct ph_context *ac;
+ int ret;
+ char *tmp;
char *p;
- ac = talloc_get_type(ctx, struct ph_context);
+ ac = talloc_get_type(req->context, struct ph_context);
- data = talloc_zero(ac, struct domain_data);
- if (data == NULL) {
- return NULL;
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
-
- if (res == NULL) {
- ldb_debug(module->ldb, LDB_DEBUG_ERROR, "Could not find this user's domain: %s!\n", dom_sid_string(data, ac->domain_sid));
- talloc_free(data);
- return NULL;
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
}
- data->pwdProperties= samdb_result_uint(res->message, "pwdProperties", 0);
- data->store_cleartext = data->pwdProperties & DOMAIN_PASSWORD_STORE_CLEARTEXT;
- data->pwdHistoryLength = samdb_result_uint(res->message, "pwdHistoryLength", 0);
+ switch (ares->type) {
+ case LDB_REPLY_ENTRY:
+ if (ac->domain != NULL) {
+ ldb_set_errstring(ac->module->ldb, "Too many results");
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
- /* For a domain DN, this puts things in dotted notation */
- /* For builtin domains, this will give details for the host,
- * but that doesn't really matter, as it's just used for salt
- * and kerberos principals, which don't exist here */
+ data = talloc_zero(ac, struct domain_data);
+ if (data == NULL) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
- tmp = ldb_dn_canonical_string(ctx, res->message->dn);
- if (!tmp) {
- return NULL;
- }
-
- /* But it puts a trailing (or just before 'builtin') / on things, so kill that */
- p = strchr(tmp, '/');
- if (p) {
- p[0] = '\0';
- }
+ data->pwdProperties = samdb_result_uint(ares->message, "pwdProperties", 0);
+ data->store_cleartext = data->pwdProperties & DOMAIN_PASSWORD_STORE_CLEARTEXT;
+ data->pwdHistoryLength = samdb_result_uint(ares->message, "pwdHistoryLength", 0);
+
+ /* For a domain DN, this puts things in dotted notation */
+ /* For builtin domains, this will give details for the host,
+ * but that doesn't really matter, as it's just used for salt
+ * and kerberos principals, which don't exist here */
+
+ tmp = ldb_dn_canonical_string(data, ares->message->dn);
+ if (!tmp) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+
+ /* But it puts a trailing (or just before 'builtin') / on things, so kill that */
+ p = strchr(tmp, '/');
+ if (p) {
+ p[0] = '\0';
+ }
- if (tmp != NULL) {
data->dns_domain = strlower_talloc(data, tmp);
if (data->dns_domain == NULL) {
- ldb_debug(module->ldb, LDB_DEBUG_ERROR, "Out of memory!\n");
- return NULL;
+ ldb_oom(ac->module->ldb);
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
data->realm = strupper_talloc(data, tmp);
if (data->realm == NULL) {
- ldb_debug(module->ldb, LDB_DEBUG_ERROR, "Out of memory!\n");
- return NULL;
+ ldb_oom(ac->module->ldb);
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
+ /* FIXME: NetbIOS name is *always* the first domain component ?? -SSS */
p = strchr(tmp, '.');
if (p) {
p[0] = '\0';
}
data->netbios_domain = strupper_talloc(data, tmp);
if (data->netbios_domain == NULL) {
- ldb_debug(module->ldb, LDB_DEBUG_ERROR, "Out of memory!\n");
- return NULL;
+ ldb_oom(ac->module->ldb);
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+
+ talloc_free(tmp);
+ ac->domain = data;
+ break;
+
+ case LDB_REPLY_DONE:
+
+ /* call the next step */
+ switch (ac->req->operation) {
+ case LDB_ADD:
+ ret = password_hash_add_do_add(ac);
+ break;
+
+ case LDB_MODIFY:
+ ret = password_hash_mod_do_mod(ac);
+ break;
+
+ default:
+ ret = LDB_ERR_OPERATIONS_ERROR;
+ break;
+ }
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL, ret);
}
+
+ case LDB_REPLY_REFERRAL:
+ /* ignore */
+ break;
}
- return data;
+ talloc_free(ares);
+ return LDB_SUCCESS;
+}
+
+static int build_domain_data_request(struct ph_context *ac)
+{
+ /* attrs[] is returned from this function in
+ ac->dom_req->op.search.attrs, so it must be static, as
+ otherwise the compiler can put it on the stack */
+ static const char * const attrs[] = { "pwdProperties", "pwdHistoryLength", NULL };
+ char *filter;
+
+ filter = talloc_asprintf(ac,
+ "(&(objectSid=%s)(|(|(objectClass=domain)(objectClass=builtinDomain))(objectClass=samba4LocalDomain)))",
+ ldap_encode_ndr_dom_sid(ac, ac->domain_sid));
+ if (filter == NULL) {
+ ldb_oom(ac->module->ldb);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ return ldb_build_search_req(&ac->dom_req, ac->module->ldb, ac,
+ ldb_get_default_basedn(ac->module->ldb),
+ LDB_SCOPE_SUBTREE,
+ filter, attrs,
+ NULL,
+ ac, get_domain_data_callback,
+ ac->req);
}
static int password_hash_add(struct ldb_module *module, struct ldb_request *req)
{
- struct ldb_handle *h;
struct ph_context *ac;
struct ldb_message_element *sambaAttr;
struct ldb_message_element *ntAttr;
return ldb_next_request(module, req);
}
- /* nobody must touch this fields */
+ /* nobody must touch these fields */
if (ldb_msg_find_element(req->op.add.message, "ntPwdHistory")) {
return LDB_ERR_UNWILLING_TO_PERFORM;
}
return LDB_ERR_CONSTRAINT_VIOLATION;
}
- h = ph_init_handle(req, module, PH_ADD);
- if (!h) {
+ ac = ph_init_context(module, req);
+ if (ac == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
- ac = talloc_get_type(h->private_data, struct ph_context);
/* get user domain data */
ac->domain_sid = samdb_result_sid_prefix(ac, req->op.add.message, "objectSid");
if (ac->domain_sid == NULL) {
- ldb_debug(module->ldb, LDB_DEBUG_ERROR, "can't handle entry with missing objectSid!\n");
+ ldb_debug(module->ldb, LDB_DEBUG_ERROR,
+ "can't handle entry with missing objectSid!\n");
return LDB_ERR_OPERATIONS_ERROR;
}
return ret;
}
- ac->step = PH_ADD_SEARCH_DOM;
-
- req->handle = h;
-
return ldb_next_request(module, ac->dom_req);
}
-static int password_hash_add_do_add(struct ldb_handle *h) {
+static int password_hash_add_do_add(struct ph_context *ac) {
- struct ph_context *ac;
- struct domain_data *domain;
+ struct ldb_request *down_req;
struct smb_krb5_context *smb_krb5_context;
struct ldb_message *msg;
struct setup_password_fields_io io;
int ret;
- ac = talloc_get_type(h->private_data, struct ph_context);
-
- domain = get_domain_data(ac->module, ac, ac->dom_res);
- if (domain == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- ac->down_req = talloc(ac, struct ldb_request);
- if (ac->down_req == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- *(ac->down_req) = *(ac->orig_req);
- ac->down_req->op.add.message = msg = ldb_msg_copy_shallow(ac->down_req, ac->orig_req->op.add.message);
- if (ac->down_req->op.add.message == NULL) {
+ msg = ldb_msg_copy_shallow(ac, ac->req->op.add.message);
+ if (msg == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
/* Some operations below require kerberos contexts */
- if (smb_krb5_init_context(ac->down_req,
- ldb_get_opaque(h->module->ldb, "EventContext"),
- (struct loadparm_context *)ldb_get_opaque(h->module->ldb, "loadparm"),
+ if (smb_krb5_init_context(ac,
+ ldb_get_event_context(ac->module->ldb),
+ (struct loadparm_context *)ldb_get_opaque(ac->module->ldb, "loadparm"),
&smb_krb5_context) != 0) {
return LDB_ERR_OPERATIONS_ERROR;
}
ZERO_STRUCT(io);
io.ac = ac;
- io.domain = domain;
+ io.domain = ac->domain;
io.smb_krb5_context = smb_krb5_context;
io.u.user_account_control = samdb_result_uint(msg, "userAccountControl", 0);
return ret;
}
- h->state = LDB_ASYNC_INIT;
- h->status = LDB_SUCCESS;
-
- ac->step = PH_ADD_DO_ADD;
-
- ldb_set_timeout_from_prev_req(ac->module->ldb, ac->orig_req, ac->down_req);
+ ret = ldb_build_add_req(&down_req, ac->module->ldb, ac,
+ msg,
+ ac->req->controls,
+ ac, ph_op_callback,
+ ac->req);
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
- /* perform the operation */
- return ldb_next_request(ac->module, ac->down_req);
+ return ldb_next_request(ac->module, down_req);
}
-static int password_hash_mod_search_self(struct ldb_handle *h);
-
static int password_hash_modify(struct ldb_module *module, struct ldb_request *req)
{
- struct ldb_handle *h;
struct ph_context *ac;
struct ldb_message_element *sambaAttr;
struct ldb_message_element *ntAttr;
struct ldb_message_element *lmAttr;
struct ldb_message *msg;
+ struct ldb_request *down_req;
+ int ret;
ldb_debug(module->ldb, LDB_DEBUG_TRACE, "password_hash_modify\n");
return LDB_ERR_CONSTRAINT_VIOLATION;
}
- h = ph_init_handle(req, module, PH_MOD);
- if (!h) {
+ ac = ph_init_context(module, req);
+ if (!ac) {
return LDB_ERR_OPERATIONS_ERROR;
}
- ac = talloc_get_type(h->private_data, struct ph_context);
- /* return or own handle to deal with this call */
- req->handle = h;
-
- /* prepare the first operation */
- ac->down_req = talloc_zero(ac, struct ldb_request);
- if (ac->down_req == NULL) {
- ldb_set_errstring(module->ldb, "Out of memory!");
+ /* use a new message structure so that we can modify it */
+ msg = ldb_msg_copy_shallow(ac, req->op.mod.message);
+ if (msg == NULL) {
+ ldb_oom(module->ldb);
return LDB_ERR_OPERATIONS_ERROR;
}
- *(ac->down_req) = *req; /* copy the request */
-
- /* use a new message structure so that we can modify it */
- ac->down_req->op.mod.message = msg = ldb_msg_copy_shallow(ac->down_req, req->op.mod.message);
-
- /* - remove any imodification to the password from the first commit
+ /* - remove any modification to the password from the first commit
* we will make the real modification later */
if (sambaAttr) ldb_msg_remove_attr(msg, "userPassword");
if (ntAttr) ldb_msg_remove_attr(msg, "unicodePwd");
if (lmAttr) ldb_msg_remove_attr(msg, "dBCSPwd");
- /* if there was nothing else to be modify skip to next step */
+ /* if there was nothing else to be modified skip to next step */
if (msg->num_elements == 0) {
- talloc_free(ac->down_req);
- ac->down_req = NULL;
- return password_hash_mod_search_self(h);
+ return password_hash_mod_search_self(ac);
}
-
- ac->down_req->context = NULL;
- ac->down_req->callback = NULL;
- ac->step = PH_MOD_DO_REQ;
+ ret = ldb_build_mod_req(&down_req, module->ldb, ac,
+ msg,
+ req->controls,
+ ac, ph_modify_callback,
+ req);
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
- ldb_set_timeout_from_prev_req(module->ldb, req, ac->down_req);
+ return ldb_next_request(module, down_req);
+}
- return ldb_next_request(module, ac->down_req);
+static int ph_modify_callback(struct ldb_request *req, struct ldb_reply *ares)
+{
+ struct ph_context *ac;
+ int ret;
+
+ ac = talloc_get_type(req->context, struct ph_context);
+
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
+
+ if (ares->type != LDB_REPLY_DONE) {
+ talloc_free(ares);
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+
+ ret = password_hash_mod_search_self(ac);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL, ret);
+ }
+
+ talloc_free(ares);
+ return LDB_SUCCESS;
}
-static int get_self_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
+static int ph_mod_search_callback(struct ldb_request *req, struct ldb_reply *ares)
{
struct ph_context *ac;
+ int ret;
+
+ ac = talloc_get_type(req->context, struct ph_context);
- ac = talloc_get_type(context, struct ph_context);
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
+
+ /* we are interested only in the single reply (base search) */
+ switch (ares->type) {
+ case LDB_REPLY_ENTRY:
- /* we are interested only in the single reply (base search) we receive here */
- if (ares->type == LDB_REPLY_ENTRY) {
if (ac->search_res != NULL) {
- ldb_set_errstring(ldb, "Too many results");
+ ldb_set_errstring(ac->module->ldb, "Too many results");
talloc_free(ares);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
/* if it is not an entry of type person this is an error */
- /* TODO: remove this when userPassword will be in schema */
+ /* TODO: remove this when sambaPassword will be in schema */
if (!ldb_msg_check_string_attribute(ares->message, "objectClass", "person")) {
- ldb_set_errstring(ldb, "Object class violation");
+ ldb_set_errstring(ac->module->ldb, "Object class violation");
talloc_free(ares);
- return LDB_ERR_OBJECT_CLASS_VIOLATION;
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OBJECT_CLASS_VIOLATION);
}
ac->search_res = talloc_steal(ac, ares);
- } else {
- talloc_free(ares);
+ return LDB_SUCCESS;
+
+ case LDB_REPLY_DONE:
+
+ /* get object domain sid */
+ ac->domain_sid = samdb_result_sid_prefix(ac,
+ ac->search_res->message,
+ "objectSid");
+ if (ac->domain_sid == NULL) {
+ ldb_debug(ac->module->ldb, LDB_DEBUG_ERROR,
+ "can't handle entry without objectSid!\n");
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+
+ /* get user domain data */
+ ret = build_domain_data_request(ac);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL,ret);
+ }
+
+ return ldb_next_request(ac->module, ac->dom_req);
+
+ case LDB_REPLY_REFERRAL:
+ /*ignore anything else for now */
+ break;
}
+ talloc_free(ares);
return LDB_SUCCESS;
}
-static int password_hash_mod_search_self(struct ldb_handle *h) {
+static int password_hash_mod_search_self(struct ph_context *ac) {
- struct ph_context *ac;
static const char * const attrs[] = { "userAccountControl", "lmPwdHistory",
"ntPwdHistory",
"objectSid", "msDS-KeyVersionNumber",
"dBCSPwd", "unicodePwd",
"supplementalCredentials",
NULL };
-
- ac = talloc_get_type(h->private_data, struct ph_context);
-
- /* prepare the search operation */
- ac->search_req = talloc_zero(ac, struct ldb_request);
- if (ac->search_req == NULL) {
- ldb_debug(ac->module->ldb, LDB_DEBUG_ERROR, "Out of Memory!\n");
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- ac->search_req->operation = LDB_SEARCH;
- ac->search_req->op.search.base = ac->orig_req->op.mod.message->dn;
- ac->search_req->op.search.scope = LDB_SCOPE_BASE;
- ac->search_req->op.search.tree = ldb_parse_tree(ac->search_req, NULL);
- if (ac->search_req->op.search.tree == NULL) {
- ldb_set_errstring(ac->module->ldb, "Invalid search filter");
- return LDB_ERR_OPERATIONS_ERROR;
- }
- ac->search_req->op.search.attrs = attrs;
- ac->search_req->controls = NULL;
- ac->search_req->context = ac;
- ac->search_req->callback = get_self_callback;
- ldb_set_timeout_from_prev_req(ac->module->ldb, ac->orig_req, ac->search_req);
-
- ac->step = PH_MOD_SEARCH_SELF;
-
- return ldb_next_request(ac->module, ac->search_req);
-}
-
-static int password_hash_mod_search_dom(struct ldb_handle *h) {
-
- struct ph_context *ac;
+ struct ldb_request *search_req;
int ret;
- ac = talloc_get_type(h->private_data, struct ph_context);
+ ret = ldb_build_search_req(&search_req, ac->module->ldb, ac,
+ ac->req->op.mod.message->dn,
+ LDB_SCOPE_BASE,
+ "(objectclass=*)",
+ attrs,
+ NULL,
+ ac, ph_mod_search_callback,
+ ac->req);
- /* get object domain sid */
- ac->domain_sid = samdb_result_sid_prefix(ac, ac->search_res->message, "objectSid");
- if (ac->domain_sid == NULL) {
- ldb_debug(ac->module->ldb, LDB_DEBUG_ERROR, "can't handle entry with missing objectSid!\n");
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- /* get user domain data */
- ret = build_domain_data_request(ac);
if (ret != LDB_SUCCESS) {
return ret;
}
- ac->step = PH_MOD_SEARCH_DOM;
-
- return ldb_next_request(ac->module, ac->dom_req);
+ return ldb_next_request(ac->module, search_req);
}
-static int password_hash_mod_do_mod(struct ldb_handle *h) {
+static int password_hash_mod_do_mod(struct ph_context *ac) {
- struct ph_context *ac;
- struct domain_data *domain;
+ struct ldb_request *mod_req;
struct smb_krb5_context *smb_krb5_context;
struct ldb_message *msg;
struct ldb_message *orig_msg;
struct setup_password_fields_io io;
int ret;
- ac = talloc_get_type(h->private_data, struct ph_context);
-
- domain = get_domain_data(ac->module, ac, ac->dom_res);
- if (domain == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- ac->mod_req = talloc(ac, struct ldb_request);
- if (ac->mod_req == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- *(ac->mod_req) = *(ac->orig_req);
-
/* use a new message structure so that we can modify it */
- ac->mod_req->op.mod.message = msg = ldb_msg_new(ac->mod_req);
+ msg = ldb_msg_new(ac);
if (msg == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
/* modify dn */
- msg->dn = ac->orig_req->op.mod.message->dn;
+ msg->dn = ac->req->op.mod.message->dn;
/* Some operations below require kerberos contexts */
- if (smb_krb5_init_context(ac->mod_req,
- ldb_get_opaque(h->module->ldb, "EventContext"),
- (struct loadparm_context *)ldb_get_opaque(h->module->ldb, "loadparm"),
+ if (smb_krb5_init_context(ac,
+ ldb_get_event_context(ac->module->ldb),
+ (struct loadparm_context *)ldb_get_opaque(ac->module->ldb, "loadparm"),
&smb_krb5_context) != 0) {
return LDB_ERR_OPERATIONS_ERROR;
}
- orig_msg = discard_const(ac->orig_req->op.mod.message);
+ orig_msg = discard_const(ac->req->op.mod.message);
searched_msg = ac->search_res->message;
ZERO_STRUCT(io);
io.ac = ac;
- io.domain = domain;
+ io.domain = ac->domain;
io.smb_krb5_context = smb_krb5_context;
io.u.user_account_control = samdb_result_uint(searched_msg, "userAccountControl", 0);
return ret;
}
- h->state = LDB_ASYNC_INIT;
- h->status = LDB_SUCCESS;
-
- ac->step = PH_MOD_DO_MOD;
-
- ldb_set_timeout_from_prev_req(ac->module->ldb, ac->orig_req, ac->mod_req);
-
- /* perform the search */
- return ldb_next_request(ac->module, ac->mod_req);
-}
-
-static int ph_wait(struct ldb_handle *handle) {
- struct ph_context *ac;
- int ret;
-
- if (!handle || !handle->private_data) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- if (handle->state == LDB_ASYNC_DONE) {
- return handle->status;
- }
-
- handle->state = LDB_ASYNC_PENDING;
- handle->status = LDB_SUCCESS;
-
- ac = talloc_get_type(handle->private_data, struct ph_context);
-
- switch (ac->step) {
- case PH_ADD_SEARCH_DOM:
- ret = ldb_wait(ac->dom_req->handle, LDB_WAIT_NONE);
-
- if (ret != LDB_SUCCESS) {
- handle->status = ret;
- goto done;
- }
- if (ac->dom_req->handle->status != LDB_SUCCESS) {
- handle->status = ac->dom_req->handle->status;
- goto done;
- }
-
- if (ac->dom_req->handle->state != LDB_ASYNC_DONE) {
- return LDB_SUCCESS;
- }
-
- /* domain search done, go on */
- return password_hash_add_do_add(handle);
-
- case PH_ADD_DO_ADD:
- ret = ldb_wait(ac->down_req->handle, LDB_WAIT_NONE);
-
- if (ret != LDB_SUCCESS) {
- handle->status = ret;
- goto done;
- }
- if (ac->down_req->handle->status != LDB_SUCCESS) {
- handle->status = ac->down_req->handle->status;
- goto done;
- }
-
- if (ac->down_req->handle->state != LDB_ASYNC_DONE) {
- return LDB_SUCCESS;
- }
-
- break;
-
- case PH_MOD_DO_REQ:
- ret = ldb_wait(ac->down_req->handle, LDB_WAIT_NONE);
-
- if (ret != LDB_SUCCESS) {
- handle->status = ret;
- goto done;
- }
- if (ac->down_req->handle->status != LDB_SUCCESS) {
- handle->status = ac->down_req->handle->status;
- goto done;
- }
-
- if (ac->down_req->handle->state != LDB_ASYNC_DONE) {
- return LDB_SUCCESS;
- }
-
- /* non-password mods done, go on */
- return password_hash_mod_search_self(handle);
-
- case PH_MOD_SEARCH_SELF:
- ret = ldb_wait(ac->search_req->handle, LDB_WAIT_NONE);
-
- if (ret != LDB_SUCCESS) {
- handle->status = ret;
- goto done;
- }
- if (ac->search_req->handle->status != LDB_SUCCESS) {
- handle->status = ac->search_req->handle->status;
- goto done;
- }
-
- if (ac->search_req->handle->state != LDB_ASYNC_DONE) {
- return LDB_SUCCESS;
- }
-
- if (ac->search_res == NULL) {
- return LDB_ERR_NO_SUCH_OBJECT;
- }
-
- /* self search done, go on */
- return password_hash_mod_search_dom(handle);
-
- case PH_MOD_SEARCH_DOM:
- ret = ldb_wait(ac->dom_req->handle, LDB_WAIT_NONE);
-
- if (ret != LDB_SUCCESS) {
- handle->status = ret;
- goto done;
- }
- if (ac->dom_req->handle->status != LDB_SUCCESS) {
- handle->status = ac->dom_req->handle->status;
- goto done;
- }
-
- if (ac->dom_req->handle->state != LDB_ASYNC_DONE) {
- return LDB_SUCCESS;
- }
-
- /* domain search done, go on */
- return password_hash_mod_do_mod(handle);
-
- case PH_MOD_DO_MOD:
- ret = ldb_wait(ac->mod_req->handle, LDB_WAIT_NONE);
-
- if (ret != LDB_SUCCESS) {
- handle->status = ret;
- goto done;
- }
- if (ac->mod_req->handle->status != LDB_SUCCESS) {
- handle->status = ac->mod_req->handle->status;
- goto done;
- }
-
- if (ac->mod_req->handle->state != LDB_ASYNC_DONE) {
- return LDB_SUCCESS;
- }
-
- break;
-
- default:
- ret = LDB_ERR_OPERATIONS_ERROR;
- goto done;
- }
-
- ret = LDB_SUCCESS;
-
-done:
- handle->state = LDB_ASYNC_DONE;
- return ret;
-}
-
-static int ph_wait_all(struct ldb_handle *handle) {
-
- int ret;
-
- while (handle->state != LDB_ASYNC_DONE) {
- ret = ph_wait(handle);
- if (ret != LDB_SUCCESS) {
- return ret;
- }
+ ret = ldb_build_mod_req(&mod_req, ac->module->ldb, ac,
+ msg,
+ ac->req->controls,
+ ac, ph_op_callback,
+ ac->req);
+ if (ret != LDB_SUCCESS) {
+ return ret;
}
- return handle->status;
-}
-
-static int password_hash_wait(struct ldb_handle *handle, enum ldb_wait_type type)
-{
- if (type == LDB_WAIT_ALL) {
- return ph_wait_all(handle);
- } else {
- return ph_wait(handle);
- }
+ return ldb_next_request(ac->module, mod_req);
}
_PUBLIC_ const struct ldb_module_ops ldb_password_hash_module_ops = {
.name = "password_hash",
.add = password_hash_add,
.modify = password_hash_modify,
- .wait = password_hash_wait
};
}
module->private_data = pdc_fsmo;
- ret = ldb_search(module->ldb, pdc_dn,
- LDB_SCOPE_BASE,
- NULL, pdc_attrs,
- &pdc_res);
+ ret = ldb_search(module->ldb, mem_ctx, &pdc_res,
+ pdc_dn, LDB_SCOPE_BASE,
+ pdc_attrs, NULL);
if (ret == LDB_ERR_NO_SUCH_OBJECT) {
ldb_debug(module->ldb, LDB_DEBUG_WARNING,
"pdc_fsmo_init: no domain object present: (skip loading of domain details)\n");
talloc_free(mem_ctx);
return ret;
}
- talloc_steal(mem_ctx, pdc_res);
if (pdc_res->count == 0) {
ldb_debug(module->ldb, LDB_DEBUG_WARNING,
"pdc_fsmo_init: no domain object present: (skip loading of domain details)\n");
const char **newstr;
};
+struct proxy_ctx {
+ struct ldb_module *module;
+ struct ldb_request *req;
+
+#ifdef DEBUG_PROXY
+ int count;
+#endif
+};
/*
load the @PROXYINFO record
int ret;
const char *olddn, *newdn, *url, *username, *password, *oldstr, *newstr;
struct cli_credentials *creds;
-
/* see if we have already loaded it */
if (proxy->upstream != NULL) {
if (dn == NULL) {
goto failed;
}
- ret = ldb_search(module->ldb, dn, LDB_SCOPE_BASE, NULL, NULL, &res);
+ ret = ldb_search(module->ldb, proxy, &res, dn, LDB_SCOPE_BASE, NULL, NULL);
talloc_free(dn);
if (ret != LDB_SUCCESS || res->count != 1) {
ldb_debug(module->ldb, LDB_DEBUG_FATAL, "Can't find @PROXYINFO\n");
goto failed;
}
- proxy->upstream = ldb_init(proxy);
+ proxy->upstream = ldb_init(proxy, ldb_get_event_context(ldb));
if (proxy->upstream == NULL) {
ldb_oom(module->ldb);
goto failed;
/*
convert a returned value
*/
-static void proxy_convert_value(struct ldb_module *module, struct ldb_message *msg, struct ldb_val *v)
+static void proxy_convert_value(struct proxy_data *proxy, struct ldb_message *msg, struct ldb_val *v)
{
- struct proxy_data *proxy = talloc_get_type(module->private_data, struct proxy_data);
int i;
+
for (i=0;proxy->oldstr[i];i++) {
char *p = strcasestr((char *)v->data, proxy->oldstr[i]);
if (p == NULL) continue;
/*
convert a returned value
*/
-static struct ldb_parse_tree *proxy_convert_tree(struct ldb_module *module,
+static struct ldb_parse_tree *proxy_convert_tree(TALLOC_CTX *mem_ctx,
+ struct proxy_data *proxy,
struct ldb_parse_tree *tree)
{
- struct proxy_data *proxy = talloc_get_type(module->private_data, struct proxy_data);
int i;
- char *expression = ldb_filter_from_tree(module, tree);
+ char *expression = ldb_filter_from_tree(mem_ctx, tree);
+
for (i=0;proxy->newstr[i];i++) {
struct ldb_val v;
char *p = strcasestr(expression, proxy->newstr[i]);
if (p == NULL) continue;
v.data = (uint8_t *)expression;
v.length = strlen(expression)+1;
- proxy_convert_blob(module, &v, proxy->newstr[i], proxy->oldstr[i]);
- return ldb_parse_tree(module, (const char *)v.data);
+ proxy_convert_blob(mem_ctx, &v, proxy->newstr[i], proxy->oldstr[i]);
+ return ldb_parse_tree(mem_ctx, (const char *)v.data);
}
return tree;
}
/*
convert a returned record
*/
-static void proxy_convert_record(struct ldb_module *module, struct ldb_message *msg)
+static void proxy_convert_record(struct ldb_context *ldb,
+ struct proxy_data *proxy,
+ struct ldb_message *msg)
{
- struct proxy_data *proxy = talloc_get_type(module->private_data, struct proxy_data);
int attr, v;
-
+
/* fix the message DN */
- if (ldb_dn_compare_base(module->ldb, proxy->olddn, msg->dn) == 0) {
+ if (ldb_dn_compare_base(proxy->olddn, msg->dn) == 0) {
ldb_dn_remove_base_components(msg->dn, ldb_dn_get_comp_num(proxy->olddn));
ldb_dn_add_base(msg->dn, proxy->newdn);
}
/* fix any attributes */
for (attr=0;attr<msg->num_elements;attr++) {
for (v=0;v<msg->elements[attr].num_values;v++) {
- proxy_convert_value(module, msg, &msg->elements[attr].values[v]);
+ proxy_convert_value(proxy, msg, &msg->elements[attr].values[v]);
}
}
/* fix any DN components */
for (attr=0;attr<msg->num_elements;attr++) {
for (v=0;v<msg->elements[attr].num_values;v++) {
- proxy_convert_value(module, msg, &msg->elements[attr].values[v]);
+ proxy_convert_value(proxy, msg, &msg->elements[attr].values[v]);
}
}
}
+static int proxy_search_callback(struct ldb_request *req,
+ struct ldb_reply *ares)
+{
+ struct proxy_data *proxy;
+ struct proxy_ctx *ac;
+ int ret;
+
+ ac = talloc_get_type(req->context, struct proxy_ctx);
+ proxy = talloc_get_type(ac->module->private_data, struct proxy_data);
+
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
+
+ /* Only entries are interesting, and we only want the olddn */
+ switch (ares->type) {
+ case LDB_REPLY_ENTRY:
+
+#ifdef DEBUG_PROXY
+ ac->count++;
+#endif
+ proxy_convert_record(ac->module->ldb, proxy, ares->message);
+ ret = ldb_module_send_entry(ac->req, ares->message);
+ break;
+
+ case LDB_REPLY_REFERRAL:
+
+ /* ignore remote referrals */
+ break;
+
+ case LDB_REPLY_DONE:
+
+#ifdef DEBUG_PROXY
+ printf("# record %d\n", ac->count+1);
+#endif
+
+ return ldb_module_done(ac->req, NULL, NULL, LDB_SUCCESS);
+ }
+
+ talloc_free(ares);
+ return ret;
+}
+
/* search */
static int proxy_search_bytree(struct ldb_module *module, struct ldb_request *req)
{
+ struct proxy_ctx *ac;
+ struct ldb_parse_tree *newtree;
struct proxy_data *proxy = talloc_get_type(module->private_data, struct proxy_data);
struct ldb_request *newreq;
struct ldb_dn *base;
}
if (load_proxy_info(module) != 0) {
- return -1;
+ return LDB_ERR_OPERATIONS_ERROR;
}
/* see if the dn is within olddn */
- if (ldb_dn_compare_base(module->ldb, proxy->newdn, req->op.search.base) != 0) {
+ if (ldb_dn_compare_base(proxy->newdn, req->op.search.base) != 0) {
goto passthru;
}
- newreq = talloc(module, struct ldb_request);
- if (newreq == NULL) {
- return -1;
+ ac = talloc(req, struct proxy_ctx);
+ if (ac == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
}
- newreq->op.search.tree = proxy_convert_tree(module, req->op.search.tree);
+ ac->module = module;
+ ac->req = req;
+#ifdef DEBUG_PROXY
+ ac->count = 0;
+#endif
+
+ newtree = proxy_convert_tree(ac, proxy, req->op.search.tree);
/* convert the basedn of this search */
- base = ldb_dn_copy(proxy, req->op.search.base);
+ base = ldb_dn_copy(ac, req->op.search.base);
if (base == NULL) {
- talloc_free(newreq);
goto failed;
}
ldb_dn_remove_base_components(base, ldb_dn_get_comp_num(proxy->newdn));
ldb_dn_add_base(base, proxy->olddn);
ldb_debug(module->ldb, LDB_DEBUG_FATAL, "proxying: '%s' with dn '%s' \n",
- ldb_filter_from_tree(proxy, newreq->op.search.tree), ldb_dn_get_linearized(newreq->op.search.base));
+ ldb_filter_from_tree(ac, newreq->op.search.tree), ldb_dn_get_linearized(newreq->op.search.base));
for (i = 0; req->op.search.attrs && req->op.search.attrs[i]; i++) {
ldb_debug(module->ldb, LDB_DEBUG_FATAL, "attr: '%s'\n", req->op.search.attrs[i]);
}
- newreq->op.search.base = base;
- newreq->op.search.scope = req->op.search.scope;
- newreq->op.search.attrs = req->op.search.attrs;
- newreq->op.search.res = req->op.search.res;
- newreq->controls = req->controls;
+ ret = ldb_build_search_req_ex(&newreq, module->ldb, ac,
+ base, req->op.search.scope,
+ newtree, req->op.search.attrs,
+ req->controls,
+ ac, proxy_search_callback,
+ req);
+
+ /* FIXME: warning, need a real event system hooked up for this to work properly,
+ * for now this makes the module *not* ASYNC */
ret = ldb_request(proxy->upstream, newreq);
if (ret != LDB_SUCCESS) {
ldb_set_errstring(module->ldb, ldb_errstring(proxy->upstream));
- talloc_free(newreq);
- return -1;
}
-
- for (i = 0; i < newreq->op.search.res->count; i++) {
- printf("# record %d\n", i+1);
-
- proxy_convert_record(module, newreq->op.search.res->msgs[i]);
+ ret = ldb_wait(newreq->handle, LDB_WAIT_ALL);
+ if (ret != LDB_SUCCESS) {
+ ldb_set_errstring(module->ldb, ldb_errstring(proxy->upstream));
}
-
- talloc_free(newreq);
return ret;
failed:
#include "ldb_includes.h"
struct rr_context {
- struct ldb_request *orig_req;
- struct ldb_request *down_req;
+ struct ldb_module *module;
+ struct ldb_request *req;
};
-static int rr_search_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
+static struct rr_context *rr_init_context(struct ldb_module *module,
+ struct ldb_request *req)
{
- struct rr_context *rr_context = talloc_get_type(context, struct rr_context);
- struct ldb_request *orig_req = rr_context->orig_req;
+ struct rr_context *ac;
+
+ ac = talloc_zero(req, struct rr_context);
+ if (ac == NULL) {
+ ldb_set_errstring(module->ldb, "Out of Memory");
+ return NULL;
+ }
+
+ ac->module = module;
+ ac->req = req;
+
+ return ac;
+}
+
+static int rr_search_callback(struct ldb_request *req, struct ldb_reply *ares)
+{
+ struct rr_context *ac;
int i, j;
-
- if (ares->type != LDB_REPLY_ENTRY) {
- return rr_context->orig_req->callback(ldb, rr_context->orig_req->context, ares);
+
+ ac = talloc_get_type(req->context, struct rr_context);
+
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
+
+ if (ares->type == LDB_REPLY_REFERRAL) {
+ return ldb_module_send_referral(ac->req, ares->referral);
}
+ if (ares->type == LDB_REPLY_DONE) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
+
+ /* LDB_REPLY_ENTRY */
+
/* Find those that are range requests from the attribute list */
- for (i = 0; orig_req->op.search.attrs[i]; i++) {
+ for (i = 0; ac->req->op.search.attrs[i]; i++) {
char *p, *new_attr;
const char *end_str;
unsigned int start, end, orig_num_values;
struct ldb_message_element *el;
struct ldb_val *orig_values;
- p = strchr(orig_req->op.search.attrs[i], ';');
+ p = strchr(ac->req->op.search.attrs[i], ';');
if (!p) {
continue;
}
if (strncasecmp(p, ";range=", strlen(";range=")) != 0) {
continue;
}
- if (sscanf(p, ";range=%u-%u", &start, &end) == 2) {
- } else if (sscanf(p, ";range=%u-*", &start) == 1) {
- end = (unsigned int)-1;
- } else {
- continue;
+ if (sscanf(p, ";range=%u-%u", &start, &end) != 2) {
+ if (sscanf(p, ";range=%u-*", &start) == 1) {
+ end = (unsigned int)-1;
+ } else {
+ continue;
+ }
}
- new_attr = talloc_strndup(orig_req,
- orig_req->op.search.attrs[i],
- (unsigned int)(p-orig_req->op.search.attrs[i]));
+ new_attr = talloc_strndup(ac->req,
+ ac->req->op.search.attrs[i],
+ (size_t)(p - ac->req->op.search.attrs[i]));
if (!new_attr) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ ldb_oom(ac->module->ldb);
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
el = ldb_msg_find_element(ares->message, new_attr);
talloc_free(new_attr);
if (!el) {
continue;
}
- if (start > end) {
- ldb_asprintf_errstring(ldb, "range request error: start must not be greater than end");
- return LDB_ERR_UNWILLING_TO_PERFORM;
- }
if (end >= (el->num_values - 1)) {
/* Need to leave the requested attribute in
* there (so add an empty one to match) */
} else {
end_str = talloc_asprintf(el, "%u", end);
if (!end_str) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ ldb_oom(ac->module->ldb);
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
}
- /* If start is greater then where we noe find the end to be */
+ /* If start is greater then where we are find the end to be */
if (start > end) {
el->num_values = 0;
el->values = NULL;
orig_num_values = el->num_values;
if ((start + end < start) || (start + end < end)) {
- ldb_asprintf_errstring(ldb, "range request error: start or end would overflow!");
- return LDB_ERR_UNWILLING_TO_PERFORM;
+ ldb_asprintf_errstring(ac->module->ldb,
+ "range request error: start or end would overflow!");
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_UNWILLING_TO_PERFORM);
}
el->num_values = 0;
el->values = talloc_array(el, struct ldb_val, (end - start) + 1);
if (!el->values) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ ldb_oom(ac->module->ldb);
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
for (j=start; j <= end; j++) {
el->values[el->num_values] = orig_values[j];
}
el->name = talloc_asprintf(el, "%s;range=%u-%s", el->name, start, end_str);
if (!el->name) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ ldb_oom(ac->module->ldb);
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
}
- return rr_context->orig_req->callback(ldb, rr_context->orig_req->context, ares);
-
+ return ldb_module_send_entry(ac->req, ares->message);
}
/* search */
int i;
unsigned int start, end;
const char **new_attrs = NULL;
- struct rr_context *context;
bool found_rr = false;
+ struct ldb_request *down_req;
+ struct rr_context *ac;
+ int ret;
/* Strip the range request from the attribute */
for (i = 0; req->op.search.attrs && req->op.search.attrs[i]; i++) {
new_attrs = talloc_realloc(req, new_attrs, const char *, i+2);
new_attrs[i] = req->op.search.attrs[i];
new_attrs[i+1] = NULL;
- p = strchr(req->op.search.attrs[i], ';');
+ p = strchr(new_attrs[i], ';');
if (!p) {
continue;
}
if (strncasecmp(p, ";range=", strlen(";range=")) != 0) {
continue;
}
- if (sscanf(p, ";range=%u-%u", &start, &end) == 2) {
- } else if (sscanf(p, ";range=%u-*", &start) == 1) {
- end = (unsigned int)-1;
- } else {
- ldb_asprintf_errstring(module->ldb, "range request error: range requst malformed");
- return LDB_ERR_UNWILLING_TO_PERFORM;
+ end = (unsigned int)-1;
+ if (sscanf(p, ";range=%u-*", &start) != 1) {
+ if (sscanf(p, ";range=%u-%u", &start, &end) != 2) {
+ ldb_asprintf_errstring(module->ldb,
+ "range request error: "
+ "range request malformed");
+ return LDB_ERR_UNWILLING_TO_PERFORM;
+ }
}
if (start > end) {
ldb_asprintf_errstring(module->ldb, "range request error: start must not be greater than end");
}
found_rr = true;
- new_attrs[i] = talloc_strndup(new_attrs,
- req->op.search.attrs[i],
- (unsigned int)(p-req->op.search.attrs[i]));
+ new_attrs[i] = talloc_strndup(new_attrs, new_attrs[i],
+ (size_t)(p - new_attrs[i]));
if (!new_attrs[i]) {
ldb_oom(module->ldb);
}
if (found_rr) {
- int ret;
- context = talloc(req, struct rr_context);
- context->orig_req = req;
- context->down_req = talloc(context, struct ldb_request);
- *context->down_req = *req;
-
- context->down_req->op.search.attrs = new_attrs;
-
- context->down_req->callback = rr_search_callback;
- context->down_req->context = context;
-
- ret = ldb_next_request(module, context->down_req);
-
- /* We don't need to implement our own 'wait' function, so pass the handle along */
- if (ret == LDB_SUCCESS) {
- req->handle = context->down_req->handle;
+ ac = rr_init_context(module, req);
+ if (!ac) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ ret = ldb_build_search_req_ex(&down_req, module->ldb, ac,
+ req->op.search.base,
+ req->op.search.scope,
+ req->op.search.tree,
+ new_attrs,
+ req->controls,
+ ac, rr_search_callback,
+ req);
+ if (ret != LDB_SUCCESS) {
+ return ret;
}
- return ret;
+ return ldb_next_request(module, down_req);
}
/* No change, just run the original request as if we were never here */
+ talloc_free(new_attrs);
return ldb_next_request(module, req);
}
/*
ldb database library
- Copyright (C) Simo Sorce 2004-2006
+ Copyright (C) Simo Sorce 2004-2008
Copyright (C) Andrew Bartlett <abartlet@samba.org> 2005
Copyright (C) Andrew Tridgell 2005
Copyright (C) Stefan Metzmacher <metze@samba.org> 2007
struct replmd_replicated_request {
struct ldb_module *module;
- struct ldb_handle *handle;
- struct ldb_request *orig_req;
+ struct ldb_request *req;
const struct dsdb_schema *schema;
struct dsdb_extended_replicated_objects *objs;
+ /* the controls we pass down */
+ struct ldb_control **controls;
+
uint32_t index_current;
- struct {
- TALLOC_CTX *mem_ctx;
- struct ldb_request *search_req;
- struct ldb_message *search_msg;
- int search_ret;
- struct ldb_request *change_req;
- int change_ret;
- } sub;
+ struct ldb_message *search_msg;
};
-static struct replmd_replicated_request *replmd_replicated_init_handle(struct ldb_module *module,
- struct ldb_request *req,
- struct dsdb_extended_replicated_objects *objs)
+static struct replmd_replicated_request *replmd_ctx_init(struct ldb_module *module,
+ struct ldb_request *req)
{
- struct replmd_replicated_request *ar;
- struct ldb_handle *h;
- const struct dsdb_schema *schema;
-
- schema = dsdb_get_schema(module->ldb);
- if (!schema) {
- ldb_debug_set(module->ldb, LDB_DEBUG_FATAL,
- "replmd_replicated_init_handle: no loaded schema found\n");
- return NULL;
- }
+ struct replmd_replicated_request *ac;
- h = talloc_zero(req, struct ldb_handle);
- if (h == NULL) {
- ldb_set_errstring(module->ldb, "Out of Memory");
- return NULL;
- }
-
- h->module = module;
- h->state = LDB_ASYNC_PENDING;
- h->status = LDB_SUCCESS;
-
- ar = talloc_zero(h, struct replmd_replicated_request);
- if (ar == NULL) {
- ldb_set_errstring(module->ldb, "Out of Memory");
- talloc_free(h);
+ ac = talloc_zero(req, struct replmd_replicated_request);
+ if (ac == NULL) {
+ ldb_oom(module->ldb);
return NULL;
}
- h->private_data = ar;
-
- ar->module = module;
- ar->handle = h;
- ar->orig_req = req;
- ar->schema = schema;
- ar->objs = objs;
-
- req->handle = h;
-
- return ar;
+ ac->module = module;
+ ac->req = req;
+ return ac;
}
/*
discard_const_p(void, schema), (ldb_qsort_cmp_fn_t)replmd_ldb_message_element_attid_sort);
}
-static int replmd_prepare_originating(struct ldb_module *module, struct ldb_request *req,
- struct ldb_dn *dn, const char *fn_name,
- int (*fn)(struct ldb_module *,
- struct ldb_request *,
- const struct dsdb_schema *))
+static int replmd_op_callback(struct ldb_request *req, struct ldb_reply *ares)
{
- const struct dsdb_schema *schema;
-
- /* do not manipulate our control entries */
- if (ldb_dn_is_special(dn)) {
- return ldb_next_request(module, req);
+ struct replmd_replicated_request *ac;
+
+ ac = talloc_get_type(req->context, struct replmd_replicated_request);
+
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
}
- schema = dsdb_get_schema(module->ldb);
- if (!schema) {
- ldb_debug_set(module->ldb, LDB_DEBUG_FATAL,
- "%s: no dsdb_schema loaded",
- fn_name);
- return LDB_ERR_CONSTRAINT_VIOLATION;
+ if (ares->type != LDB_REPLY_DONE) {
+ ldb_set_errstring(ac->module->ldb,
+ "invalid ldb_reply_type in callback");
+ talloc_free(ares);
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
- return fn(module, req, schema);
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, LDB_SUCCESS);
}
-static int replmd_add_originating(struct ldb_module *module,
- struct ldb_request *req,
- const struct dsdb_schema *schema)
+static int replmd_add(struct ldb_module *module, struct ldb_request *req)
{
+ struct replmd_replicated_request *ac;
+ const struct dsdb_schema *schema;
enum ndr_err_code ndr_err;
struct ldb_request *down_req;
struct ldb_message *msg;
int ret;
uint32_t i, ni=0;
- ldb_debug(module->ldb, LDB_DEBUG_TRACE, "replmd_add_originating\n");
+ /* do not manipulate our control entries */
+ if (ldb_dn_is_special(req->op.add.message->dn)) {
+ return ldb_next_request(module, req);
+ }
+
+ ldb_debug(module->ldb, LDB_DEBUG_TRACE, "replmd_add\n");
+
+ schema = dsdb_get_schema(module->ldb);
+ if (!schema) {
+ ldb_debug_set(module->ldb, LDB_DEBUG_FATAL,
+ "replmd_modify: no dsdb_schema loaded");
+ return LDB_ERR_CONSTRAINT_VIOLATION;
+ }
+
+ ac = replmd_ctx_init(module, req);
+ if (!ac) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ ac->schema = schema;
if (ldb_msg_find_element(req->op.add.message, "objectGUID")) {
ldb_debug_set(module->ldb, LDB_DEBUG_ERROR,
- "replmd_add_originating: it's not allowed to add an object with objectGUID\n");
+ "replmd_add: it's not allowed to add an object with objectGUID\n");
return LDB_ERR_UNWILLING_TO_PERFORM;
}
our_invocation_id = samdb_ntds_invocation_id(module->ldb);
if (!our_invocation_id) {
ldb_debug_set(module->ldb, LDB_DEBUG_ERROR,
- "replmd_add_originating: unable to find invocationId\n");
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- /* create a copy of the request */
- down_req = talloc(req, struct ldb_request);
- if (down_req == NULL) {
- ldb_oom(module->ldb);
+ "replmd_add: unable to find invocationId\n");
return LDB_ERR_OPERATIONS_ERROR;
}
- *down_req = *req;
/* we have to copy the message as the caller might have it as a const */
- down_req->op.add.message = msg = ldb_msg_copy_shallow(down_req, req->op.add.message);
+ msg = ldb_msg_copy_shallow(ac, req->op.add.message);
if (msg == NULL) {
- talloc_free(down_req);
ldb_oom(module->ldb);
return LDB_ERR_OPERATIONS_ERROR;
}
unix_to_nt_time(&now, t);
time_str = ldb_timestring(msg, t);
if (!time_str) {
- talloc_free(down_req);
return LDB_ERR_OPERATIONS_ERROR;
}
*/
ret = ldb_msg_add_string(msg, "whenCreated", time_str);
if (ret != LDB_SUCCESS) {
- talloc_free(down_req);
ldb_oom(module->ldb);
return LDB_ERR_OPERATIONS_ERROR;
}
struct replPropertyMetaData1,
nmd.ctr.ctr1.count);
if (!nmd.ctr.ctr1.array) {
- talloc_free(down_req);
ldb_oom(module->ldb);
return LDB_ERR_OPERATIONS_ERROR;
}
sa = dsdb_attribute_by_lDAPDisplayName(schema, e->name);
if (!sa) {
ldb_debug_set(module->ldb, LDB_DEBUG_ERROR,
- "replmd_add_originating: attribute '%s' not defined in schema\n",
+ "replmd_add: attribute '%s' not defined in schema\n",
e->name);
- talloc_free(down_req);
return LDB_ERR_NO_SUCH_ATTRIBUTE;
}
&nmd,
(ndr_push_flags_fn_t)ndr_push_replPropertyMetaDataBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
- talloc_free(down_req);
ldb_oom(module->ldb);
return LDB_ERR_OPERATIONS_ERROR;
}
*/
ret = ldb_msg_add_value(msg, "objectGUID", &guid_value, NULL);
if (ret != LDB_SUCCESS) {
- talloc_free(down_req);
ldb_oom(module->ldb);
return LDB_ERR_OPERATIONS_ERROR;
}
ret = ldb_msg_add_string(msg, "whenChanged", time_str);
if (ret != LDB_SUCCESS) {
- talloc_free(down_req);
ldb_oom(module->ldb);
return LDB_ERR_OPERATIONS_ERROR;
}
ret = samdb_msg_add_uint64(module->ldb, msg, msg, "uSNCreated", seq_num);
if (ret != LDB_SUCCESS) {
- talloc_free(down_req);
ldb_oom(module->ldb);
return LDB_ERR_OPERATIONS_ERROR;
}
ret = samdb_msg_add_uint64(module->ldb, msg, msg, "uSNChanged", seq_num);
if (ret != LDB_SUCCESS) {
- talloc_free(down_req);
ldb_oom(module->ldb);
return LDB_ERR_OPERATIONS_ERROR;
}
ret = ldb_msg_add_value(msg, "replPropertyMetaData", &nmd_value, NULL);
if (ret != LDB_SUCCESS) {
- talloc_free(down_req);
ldb_oom(module->ldb);
return LDB_ERR_OPERATIONS_ERROR;
}
*/
replmd_ldb_message_sort(msg, schema);
- ldb_set_timeout_from_prev_req(module->ldb, req, down_req);
-
- /* go on with the call chain */
- ret = ldb_next_request(module, down_req);
-
- /* do not free down_req as the call results may be linked to it,
- * it will be freed when the upper level request get freed */
- if (ret == LDB_SUCCESS) {
- req->handle = down_req->handle;
+ ret = ldb_build_add_req(&down_req, module->ldb, ac,
+ msg,
+ req->controls,
+ ac, replmd_op_callback,
+ req);
+ if (ret != LDB_SUCCESS) {
+ return ret;
}
- return ret;
-}
-
-static int replmd_add(struct ldb_module *module, struct ldb_request *req)
-{
- return replmd_prepare_originating(module, req, req->op.add.message->dn,
- "replmd_add", replmd_add_originating);
+ /* go on with the call chain */
+ return ldb_next_request(module, down_req);
}
-static int replmd_modify_originating(struct ldb_module *module,
- struct ldb_request *req,
- const struct dsdb_schema *schema)
+static int replmd_modify(struct ldb_module *module, struct ldb_request *req)
{
+ struct replmd_replicated_request *ac;
+ const struct dsdb_schema *schema;
struct ldb_request *down_req;
struct ldb_message *msg;
int ret;
time_t t = time(NULL);
uint64_t seq_num;
- ldb_debug(module->ldb, LDB_DEBUG_TRACE, "replmd_modify_originating\n");
+ /* do not manipulate our control entries */
+ if (ldb_dn_is_special(req->op.mod.message->dn)) {
+ return ldb_next_request(module, req);
+ }
+
+ ldb_debug(module->ldb, LDB_DEBUG_TRACE, "replmd_modify\n");
+
+ schema = dsdb_get_schema(module->ldb);
+ if (!schema) {
+ ldb_debug_set(module->ldb, LDB_DEBUG_FATAL,
+ "replmd_modify: no dsdb_schema loaded");
+ return LDB_ERR_CONSTRAINT_VIOLATION;
+ }
- down_req = talloc(req, struct ldb_request);
- if (down_req == NULL) {
+ ac = replmd_ctx_init(module, req);
+ if (!ac) {
return LDB_ERR_OPERATIONS_ERROR;
}
- *down_req = *req;
+ ac->schema = schema;
/* we have to copy the message as the caller might have it as a const */
- down_req->op.mod.message = msg = ldb_msg_copy_shallow(down_req, req->op.mod.message);
+ msg = ldb_msg_copy_shallow(ac, req->op.mod.message);
if (msg == NULL) {
- talloc_free(down_req);
+ talloc_free(ac);
return LDB_ERR_OPERATIONS_ERROR;
}
*/
if (add_time_element(msg, "whenChanged", t) != 0) {
- talloc_free(down_req);
+ talloc_free(ac);
return LDB_ERR_OPERATIONS_ERROR;
}
ret = ldb_sequence_number(module->ldb, LDB_SEQ_NEXT, &seq_num);
if (ret == LDB_SUCCESS) {
if (add_uint64_element(msg, "uSNChanged", seq_num) != 0) {
- talloc_free(down_req);
+ talloc_free(ac);
return LDB_ERR_OPERATIONS_ERROR;
}
}
* - replace the old object with the newly constructed one
*/
- ldb_set_timeout_from_prev_req(module->ldb, req, down_req);
-
- /* go on with the call chain */
- ret = ldb_next_request(module, down_req);
-
- /* do not free down_req as the call results may be linked to it,
- * it will be freed when the upper level request get freed */
- if (ret == LDB_SUCCESS) {
- req->handle = down_req->handle;
- }
-
- return ret;
-}
-
-static int replmd_modify(struct ldb_module *module, struct ldb_request *req)
-{
- return replmd_prepare_originating(module, req, req->op.mod.message->dn,
- "replmd_modify", replmd_modify_originating);
-}
-
-static int replmd_replicated_request_reply_helper(struct replmd_replicated_request *ar, int ret)
-{
- struct ldb_reply *ares = NULL;
-
- ar->handle->status = ret;
- ar->handle->state = LDB_ASYNC_DONE;
-
- if (!ar->orig_req->callback) {
- return LDB_SUCCESS;
- }
-
- /* we're done and need to report the success to the caller */
- ares = talloc_zero(ar, struct ldb_reply);
- if (!ares) {
- ar->handle->status = LDB_ERR_OPERATIONS_ERROR;
- ar->handle->state = LDB_ASYNC_DONE;
- return LDB_ERR_OPERATIONS_ERROR;
+ ret = ldb_build_mod_req(&down_req, module->ldb, ac,
+ msg,
+ req->controls,
+ ac, replmd_op_callback,
+ req);
+ if (ret != LDB_SUCCESS) {
+ return ret;
}
+ talloc_steal(down_req, msg);
- ares->type = LDB_REPLY_EXTENDED;
- ares->response = NULL;
-
- return ar->orig_req->callback(ar->module->ldb, ar->orig_req->context, ares);
-}
-
-static int replmd_replicated_request_done(struct replmd_replicated_request *ar)
-{
- return replmd_replicated_request_reply_helper(ar, LDB_SUCCESS);
+ /* go on with the call chain */
+ return ldb_next_request(module, down_req);
}
static int replmd_replicated_request_error(struct replmd_replicated_request *ar, int ret)
{
- return replmd_replicated_request_reply_helper(ar, ret);
+ return ret;
}
static int replmd_replicated_request_werror(struct replmd_replicated_request *ar, WERROR status)
{
int ret = LDB_ERR_OTHER;
/* TODO: do some error mapping */
- return replmd_replicated_request_reply_helper(ar, ret);
+ return ret;
}
static int replmd_replicated_apply_next(struct replmd_replicated_request *ar);
-static int replmd_replicated_apply_add_callback(struct ldb_context *ldb,
- void *private_data,
+static int replmd_replicated_apply_add_callback(struct ldb_request *req,
struct ldb_reply *ares)
{
-#ifdef REPLMD_FULL_ASYNC /* TODO: activate this code when ldb support full async code */
- struct replmd_replicated_request *ar = talloc_get_type(private_data,
+ struct replmd_replicated_request *ar = talloc_get_type(req->context,
struct replmd_replicated_request);
+ int ret;
- ar->sub.change_ret = ldb_wait(ar->sub.search_req->handle, LDB_WAIT_ALL);
- if (ar->sub.change_ret != LDB_SUCCESS) {
- return replmd_replicated_request_error(ar, ar->sub.change_ret);
+
+ if (!ares) {
+ return ldb_module_done(ar->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ar->req, ares->controls,
+ ares->response, ares->error);
}
- talloc_free(ar->sub.mem_ctx);
- ZERO_STRUCT(ar->sub);
+ if (ares->type != LDB_REPLY_DONE) {
+ ldb_set_errstring(ar->module->ldb, "Invalid reply type\n!");
+ return ldb_module_done(ar->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ talloc_free(ares);
ar->index_current++;
- return replmd_replicated_apply_next(ar);
-#else
+ ret = replmd_replicated_apply_next(ar);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ar->req, NULL, NULL, ret);
+ }
+
return LDB_SUCCESS;
-#endif
}
static int replmd_replicated_apply_add(struct replmd_replicated_request *ar)
{
+ struct ldb_request *change_req;
enum ndr_err_code ndr_err;
struct ldb_message *msg;
struct replPropertyMetaDataBlob *md;
replmd_ldb_message_sort(msg, ar->schema);
- ret = ldb_build_add_req(&ar->sub.change_req,
+ ret = ldb_build_add_req(&change_req,
ar->module->ldb,
- ar->sub.mem_ctx,
+ ar,
msg,
- NULL,
+ ar->controls,
ar,
- replmd_replicated_apply_add_callback);
+ replmd_replicated_apply_add_callback,
+ ar->req);
if (ret != LDB_SUCCESS) return replmd_replicated_request_error(ar, ret);
-#ifdef REPLMD_FULL_ASYNC /* TODO: activate this code when ldb support full async code */
- return ldb_next_request(ar->module, ar->sub.change_req);
-#else
- ret = ldb_next_request(ar->module, ar->sub.change_req);
- if (ret != LDB_SUCCESS) {
- ldb_asprintf_errstring(ar->module->ldb, "Failed to add replicated object %s: %s", ldb_dn_get_linearized(ar->sub.change_req->op.add.message->dn),
- ldb_errstring(ar->module->ldb));
- return replmd_replicated_request_error(ar, ret);
- }
-
- ar->sub.change_ret = ldb_wait(ar->sub.change_req->handle, LDB_WAIT_ALL);
- if (ar->sub.change_ret != LDB_SUCCESS) {
- ldb_asprintf_errstring(ar->module->ldb, "Failed while waiting on add replicated object %s: %s", ldb_dn_get_linearized(ar->sub.change_req->op.add.message->dn),
- ldb_errstring(ar->module->ldb));
- return replmd_replicated_request_error(ar, ar->sub.change_ret);
- }
-
- talloc_free(ar->sub.mem_ctx);
- ZERO_STRUCT(ar->sub);
-
- ar->index_current++;
-
- return LDB_SUCCESS;
-#endif
+ return ldb_next_request(ar->module, change_req);
}
static int replmd_replPropertyMetaData1_conflict_compare(struct replPropertyMetaData1 *m1,
return m1->originating_usn - m2->originating_usn;
}
-static int replmd_replicated_apply_merge_callback(struct ldb_context *ldb,
- void *private_data,
+static int replmd_replicated_apply_merge_callback(struct ldb_request *req,
struct ldb_reply *ares)
{
-#ifdef REPLMD_FULL_ASYNC /* TODO: activate this code when ldb support full async code */
- struct replmd_replicated_request *ar = talloc_get_type(private_data,
+ struct replmd_replicated_request *ar = talloc_get_type(req->context,
struct replmd_replicated_request);
+ int ret;
- ret = ldb_next_request(ar->module, ar->sub.change_req);
- if (ret != LDB_SUCCESS) return replmd_replicated_request_error(ar, ret);
-
- ar->sub.change_ret = ldb_wait(ar->sub.search_req->handle, LDB_WAIT_ALL);
- if (ar->sub.change_ret != LDB_SUCCESS) {
- return replmd_replicated_request_error(ar, ar->sub.change_ret);
+ if (!ares) {
+ return ldb_module_done(ar->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ar->req, ares->controls,
+ ares->response, ares->error);
}
- talloc_free(ar->sub.mem_ctx);
- ZERO_STRUCT(ar->sub);
+ if (ares->type != LDB_REPLY_DONE) {
+ ldb_set_errstring(ar->module->ldb, "Invalid reply type\n!");
+ return ldb_module_done(ar->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ talloc_free(ares);
ar->index_current++;
+ ret = replmd_replicated_apply_next(ar);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ar->req, NULL, NULL, ret);
+ }
+
return LDB_SUCCESS;
-#else
- return LDB_SUCCESS;
-#endif
}
static int replmd_replicated_apply_merge(struct replmd_replicated_request *ar)
{
+ struct ldb_request *change_req;
enum ndr_err_code ndr_err;
struct ldb_message *msg;
struct replPropertyMetaDataBlob *rmd;
/*
* TODO: add rename conflict handling
*/
- if (ldb_dn_compare(msg->dn, ar->sub.search_msg->dn) != 0) {
+ if (ldb_dn_compare(msg->dn, ar->search_msg->dn) != 0) {
ldb_debug_set(ar->module->ldb, LDB_DEBUG_FATAL, "replmd_replicated_apply_merge[%u]: rename not supported",
ar->index_current);
ldb_debug(ar->module->ldb, LDB_DEBUG_FATAL, "%s => %s\n",
- ldb_dn_get_linearized(ar->sub.search_msg->dn),
+ ldb_dn_get_linearized(ar->search_msg->dn),
ldb_dn_get_linearized(msg->dn));
return replmd_replicated_request_werror(ar, WERR_NOT_SUPPORTED);
}
}
/* find existing meta data */
- omd_value = ldb_msg_find_ldb_val(ar->sub.search_msg, "replPropertyMetaData");
+ omd_value = ldb_msg_find_ldb_val(ar->search_msg, "replPropertyMetaData");
if (omd_value) {
- ndr_err = ndr_pull_struct_blob(omd_value, ar->sub.mem_ctx,
+ ndr_err = ndr_pull_struct_blob(omd_value, ar,
lp_iconv_convenience(ldb_get_opaque(ar->module->ldb, "loadparm")), &omd,
(ndr_pull_flags_fn_t)ndr_pull_replPropertyMetaDataBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
ZERO_STRUCT(nmd);
nmd.version = 1;
nmd.ctr.ctr1.count = omd.ctr.ctr1.count + rmd->ctr.ctr1.count;
- nmd.ctr.ctr1.array = talloc_array(ar->sub.mem_ctx,
+ nmd.ctr.ctr1.array = talloc_array(ar,
struct replPropertyMetaData1,
nmd.ctr.ctr1.count);
if (!nmd.ctr.ctr1.array) return replmd_replicated_request_werror(ar, WERR_NOMEM);
if (msg->num_elements == 0) {
ldb_debug(ar->module->ldb, LDB_DEBUG_TRACE, "replmd_replicated_apply_merge[%u]: skip replace\n",
ar->index_current);
- goto next_object;
+
+ ar->index_current++;
+ return replmd_replicated_apply_next(ar);
}
ldb_debug(ar->module->ldb, LDB_DEBUG_TRACE, "replmd_replicated_apply_merge[%u]: replace %u attributes\n",
ar->index_current, msg->num_elements);
/*
- * when we now that we'll modify the record, add the whenChanged, uSNChanged
+ * when we know that we'll modify the record, add the whenChanged, uSNChanged
* and replPopertyMetaData attributes
*/
ret = ldb_msg_add_string(msg, "whenChanged", ar->objs->objects[ar->index_current].when_changed);
msg->elements[i].flags = LDB_FLAG_MOD_REPLACE;
}
- ret = ldb_build_mod_req(&ar->sub.change_req,
+ ret = ldb_build_mod_req(&change_req,
ar->module->ldb,
- ar->sub.mem_ctx,
+ ar,
msg,
- NULL,
+ ar->controls,
ar,
- replmd_replicated_apply_merge_callback);
- if (ret != LDB_SUCCESS) return replmd_replicated_request_error(ar, ret);
-
-#ifdef REPLMD_FULL_ASYNC /* TODO: activate this code when ldb support full async code */
- return ldb_next_request(ar->module, ar->sub.change_req);
-#else
- ret = ldb_next_request(ar->module, ar->sub.change_req);
+ replmd_replicated_apply_merge_callback,
+ ar->req);
if (ret != LDB_SUCCESS) return replmd_replicated_request_error(ar, ret);
- ar->sub.change_ret = ldb_wait(ar->sub.change_req->handle, LDB_WAIT_ALL);
- if (ar->sub.change_ret != LDB_SUCCESS) {
- return replmd_replicated_request_error(ar, ar->sub.change_ret);
- }
-
-next_object:
- talloc_free(ar->sub.mem_ctx);
- ZERO_STRUCT(ar->sub);
-
- ar->index_current++;
-
- return LDB_SUCCESS;
-#endif
+ return ldb_next_request(ar->module, change_req);
}
-static int replmd_replicated_apply_search_callback(struct ldb_context *ldb,
- void *private_data,
+static int replmd_replicated_apply_search_callback(struct ldb_request *req,
struct ldb_reply *ares)
{
- struct replmd_replicated_request *ar = talloc_get_type(private_data,
+ struct replmd_replicated_request *ar = talloc_get_type(req->context,
struct replmd_replicated_request);
- bool is_done = false;
+ int ret;
+
+ if (!ares) {
+ return ldb_module_done(ar->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS &&
+ ares->error != LDB_ERR_NO_SUCH_OBJECT) {
+ return ldb_module_done(ar->req, ares->controls,
+ ares->response, ares->error);
+ }
switch (ares->type) {
case LDB_REPLY_ENTRY:
- ar->sub.search_msg = talloc_steal(ar->sub.mem_ctx, ares->message);
+ ar->search_msg = talloc_steal(ar, ares->message);
break;
+
case LDB_REPLY_REFERRAL:
/* we ignore referrals */
break;
- case LDB_REPLY_EXTENDED:
- case LDB_REPLY_DONE:
- is_done = true;
- }
-
- talloc_free(ares);
-#ifdef REPLMD_FULL_ASYNC /* TODO: activate this code when ldb support full async code */
- if (is_done) {
- ar->sub.search_ret = ldb_wait(ar->sub.search_req->handle, LDB_WAIT_ALL);
- if (ar->sub.search_ret != LDB_SUCCESS) {
- return replmd_replicated_request_error(ar, ar->sub.search_ret);
+ case LDB_REPLY_DONE:
+ if (ar->search_msg != NULL) {
+ ret = replmd_replicated_apply_merge(ar);
+ } else {
+ ret = replmd_replicated_apply_add(ar);
}
- if (ar->sub.search_msg) {
- return replmd_replicated_apply_merge(ar);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ar->req, NULL, NULL, ret);
}
- return replmd_replicated_apply_add(ar);
}
-#endif
+
+ talloc_free(ares);
return LDB_SUCCESS;
}
-static int replmd_replicated_apply_search(struct replmd_replicated_request *ar)
+static int replmd_replicated_uptodate_vector(struct replmd_replicated_request *ar);
+
+static int replmd_replicated_apply_next(struct replmd_replicated_request *ar)
{
int ret;
char *tmp_str;
char *filter;
+ struct ldb_request *search_req;
+
+ if (ar->index_current >= ar->objs->num_objects) {
+ /* done with it, go to the last op */
+ return replmd_replicated_uptodate_vector(ar);
+ }
+
+ ar->search_msg = NULL;
- tmp_str = ldb_binary_encode(ar->sub.mem_ctx, ar->objs->objects[ar->index_current].guid_value);
+ tmp_str = ldb_binary_encode(ar, ar->objs->objects[ar->index_current].guid_value);
if (!tmp_str) return replmd_replicated_request_werror(ar, WERR_NOMEM);
- filter = talloc_asprintf(ar->sub.mem_ctx, "(objectGUID=%s)", tmp_str);
+ filter = talloc_asprintf(ar, "(objectGUID=%s)", tmp_str);
if (!filter) return replmd_replicated_request_werror(ar, WERR_NOMEM);
talloc_free(tmp_str);
- ret = ldb_build_search_req(&ar->sub.search_req,
+ ret = ldb_build_search_req(&search_req,
ar->module->ldb,
- ar->sub.mem_ctx,
+ ar,
ar->objs->partition_dn,
LDB_SCOPE_SUBTREE,
filter,
NULL,
NULL,
ar,
- replmd_replicated_apply_search_callback);
- if (ret != LDB_SUCCESS) return replmd_replicated_request_error(ar, ret);
-
-#ifdef REPLMD_FULL_ASYNC /* TODO: activate this code when ldb support full async code */
- return ldb_next_request(ar->module, ar->sub.search_req);
-#else
- ret = ldb_next_request(ar->module, ar->sub.search_req);
+ replmd_replicated_apply_search_callback,
+ ar->req);
if (ret != LDB_SUCCESS) return replmd_replicated_request_error(ar, ret);
- ar->sub.search_ret = ldb_wait(ar->sub.search_req->handle, LDB_WAIT_ALL);
- if (ar->sub.search_ret != LDB_SUCCESS && ar->sub.search_ret != LDB_ERR_NO_SUCH_OBJECT) {
- return replmd_replicated_request_error(ar, ar->sub.search_ret);
- }
- if (ar->sub.search_msg) {
- return replmd_replicated_apply_merge(ar);
- }
-
- return replmd_replicated_apply_add(ar);
-#endif
-}
-
-static int replmd_replicated_apply_next(struct replmd_replicated_request *ar)
-{
-#ifdef REPLMD_FULL_ASYNC /* TODO: activate this code when ldb support full async code */
- if (ar->index_current >= ar->objs->num_objects) {
- return replmd_replicated_uptodate_vector(ar);
- }
-#endif
-
- ar->sub.mem_ctx = talloc_new(ar);
- if (!ar->sub.mem_ctx) return replmd_replicated_request_werror(ar, WERR_NOMEM);
-
- return replmd_replicated_apply_search(ar);
+ return ldb_next_request(ar->module, search_req);
}
-static int replmd_replicated_uptodate_modify_callback(struct ldb_context *ldb,
- void *private_data,
+static int replmd_replicated_uptodate_modify_callback(struct ldb_request *req,
struct ldb_reply *ares)
{
-#ifdef REPLMD_FULL_ASYNC /* TODO: activate this code when ldb support full async code */
- struct replmd_replicated_request *ar = talloc_get_type(private_data,
+ struct replmd_replicated_request *ar = talloc_get_type(req->context,
struct replmd_replicated_request);
- ar->sub.change_ret = ldb_wait(ar->sub.search_req->handle, LDB_WAIT_ALL);
- if (ar->sub.change_ret != LDB_SUCCESS) {
- return replmd_replicated_request_error(ar, ar->sub.change_ret);
+ if (!ares) {
+ return ldb_module_done(ar->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ar->req, ares->controls,
+ ares->response, ares->error);
}
- talloc_free(ar->sub.mem_ctx);
- ZERO_STRUCT(ar->sub);
+ if (ares->type != LDB_REPLY_DONE) {
+ ldb_set_errstring(ar->module->ldb, "Invalid reply type\n!");
+ return ldb_module_done(ar->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
- return replmd_replicated_request_done(ar);
-#else
- return LDB_SUCCESS;
-#endif
+ talloc_free(ares);
+
+ return ldb_module_done(ar->req, NULL, NULL, LDB_SUCCESS);
}
static int replmd_drsuapi_DsReplicaCursor2_compare(const struct drsuapi_DsReplicaCursor2 *c1,
static int replmd_replicated_uptodate_modify(struct replmd_replicated_request *ar)
{
+ struct ldb_request *change_req;
enum ndr_err_code ndr_err;
struct ldb_message *msg;
struct replUpToDateVectorBlob ouv;
/*
* first create the new replUpToDateVector
*/
- ouv_value = ldb_msg_find_ldb_val(ar->sub.search_msg, "replUpToDateVector");
+ ouv_value = ldb_msg_find_ldb_val(ar->search_msg, "replUpToDateVector");
if (ouv_value) {
- ndr_err = ndr_pull_struct_blob(ouv_value, ar->sub.mem_ctx,
+ ndr_err = ndr_pull_struct_blob(ouv_value, ar,
lp_iconv_convenience(ldb_get_opaque(ar->module->ldb, "loadparm")), &ouv,
(ndr_pull_flags_fn_t)ndr_pull_replUpToDateVectorBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
*/
nuv.ctr.ctr2.count = 1 + ouv.ctr.ctr2.count;
if (ruv) nuv.ctr.ctr2.count += ruv->count;
- nuv.ctr.ctr2.cursors = talloc_array(ar->sub.mem_ctx,
+ nuv.ctr.ctr2.cursors = talloc_array(ar,
struct drsuapi_DsReplicaCursor2,
nuv.ctr.ctr2.count);
if (!nuv.ctr.ctr2.cursors) return replmd_replicated_request_werror(ar, WERR_NOMEM);
/*
* create the change ldb_message
*/
- msg = ldb_msg_new(ar->sub.mem_ctx);
+ msg = ldb_msg_new(ar);
if (!msg) return replmd_replicated_request_werror(ar, WERR_NOMEM);
- msg->dn = ar->sub.search_msg->dn;
+ msg->dn = ar->search_msg->dn;
ndr_err = ndr_push_struct_blob(&nuv_value, msg,
lp_iconv_convenience(ldb_get_opaque(ar->module->ldb, "loadparm")),
* first see if we already have a repsFrom value for the current source dsa
* if so we'll later replace this value
*/
- orf_el = ldb_msg_find_element(ar->sub.search_msg, "repsFrom");
+ orf_el = ldb_msg_find_element(ar->search_msg, "repsFrom");
if (orf_el) {
for (i=0; i < orf_el->num_values; i++) {
struct repsFromToBlob *trf;
- trf = talloc(ar->sub.mem_ctx, struct repsFromToBlob);
+ trf = talloc(ar, struct repsFromToBlob);
if (!trf) return replmd_replicated_request_werror(ar, WERR_NOMEM);
ndr_err = ndr_pull_struct_blob(&orf_el->values[i], trf, lp_iconv_convenience(ldb_get_opaque(ar->module->ldb, "loadparm")), trf,
nrf_el->flags = LDB_FLAG_MOD_REPLACE;
/* prepare the ldb_modify() request */
- ret = ldb_build_mod_req(&ar->sub.change_req,
+ ret = ldb_build_mod_req(&change_req,
ar->module->ldb,
- ar->sub.mem_ctx,
+ ar,
msg,
- NULL,
+ ar->controls,
ar,
- replmd_replicated_uptodate_modify_callback);
- if (ret != LDB_SUCCESS) return replmd_replicated_request_error(ar, ret);
-
-#ifdef REPLMD_FULL_ASYNC /* TODO: activate this code when ldb support full async code */
- return ldb_next_request(ar->module, ar->sub.change_req);
-#else
- ret = ldb_next_request(ar->module, ar->sub.change_req);
+ replmd_replicated_uptodate_modify_callback,
+ ar->req);
if (ret != LDB_SUCCESS) return replmd_replicated_request_error(ar, ret);
- ar->sub.change_ret = ldb_wait(ar->sub.search_req->handle, LDB_WAIT_ALL);
- if (ar->sub.change_ret != LDB_SUCCESS) {
- return replmd_replicated_request_error(ar, ar->sub.change_ret);
- }
-
- talloc_free(ar->sub.mem_ctx);
- ZERO_STRUCT(ar->sub);
-
- return replmd_replicated_request_done(ar);
-#endif
+ return ldb_next_request(ar->module, change_req);
}
-static int replmd_replicated_uptodate_search_callback(struct ldb_context *ldb,
- void *private_data,
+static int replmd_replicated_uptodate_search_callback(struct ldb_request *req,
struct ldb_reply *ares)
{
- struct replmd_replicated_request *ar = talloc_get_type(private_data,
+ struct replmd_replicated_request *ar = talloc_get_type(req->context,
struct replmd_replicated_request);
- bool is_done = false;
+ int ret;
+
+ if (!ares) {
+ return ldb_module_done(ar->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS &&
+ ares->error != LDB_ERR_NO_SUCH_OBJECT) {
+ return ldb_module_done(ar->req, ares->controls,
+ ares->response, ares->error);
+ }
switch (ares->type) {
case LDB_REPLY_ENTRY:
- ar->sub.search_msg = talloc_steal(ar->sub.mem_ctx, ares->message);
+ ar->search_msg = talloc_steal(ar, ares->message);
break;
+
case LDB_REPLY_REFERRAL:
/* we ignore referrals */
break;
- case LDB_REPLY_EXTENDED:
- case LDB_REPLY_DONE:
- is_done = true;
- }
-
- talloc_free(ares);
-#ifdef REPLMD_FULL_ASYNC /* TODO: activate this code when ldb support full async code */
- if (is_done) {
- ar->sub.search_ret = ldb_wait(ar->sub.search_req->handle, LDB_WAIT_ALL);
- if (ar->sub.search_ret != LDB_SUCCESS) {
- return replmd_replicated_request_error(ar, ar->sub.search_ret);
+ case LDB_REPLY_DONE:
+ if (ar->search_msg == NULL) {
+ ret = replmd_replicated_request_werror(ar, WERR_DS_DRA_INTERNAL_ERROR);
+ } else {
+ ret = replmd_replicated_uptodate_modify(ar);
}
- if (!ar->sub.search_msg) {
- return replmd_replicated_request_werror(ar, WERR_DS_DRA_INTERNAL_ERROR);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ar->req, NULL, NULL, ret);
}
-
- return replmd_replicated_uptodate_modify(ar);
}
-#endif
+
+ talloc_free(ares);
return LDB_SUCCESS;
}
-static int replmd_replicated_uptodate_search(struct replmd_replicated_request *ar)
+
+static int replmd_replicated_uptodate_vector(struct replmd_replicated_request *ar)
{
int ret;
static const char *attrs[] = {
"repsFrom",
NULL
};
+ struct ldb_request *search_req;
+
+ ar->search_msg = NULL;
- ret = ldb_build_search_req(&ar->sub.search_req,
+ ret = ldb_build_search_req(&search_req,
ar->module->ldb,
- ar->sub.mem_ctx,
+ ar,
ar->objs->partition_dn,
LDB_SCOPE_BASE,
"(objectClass=*)",
attrs,
NULL,
ar,
- replmd_replicated_uptodate_search_callback);
- if (ret != LDB_SUCCESS) return replmd_replicated_request_error(ar, ret);
-
-#ifdef REPLMD_FULL_ASYNC /* TODO: activate this code when ldb support full async code */
- return ldb_next_request(ar->module, ar->sub.search_req);
-#else
- ret = ldb_next_request(ar->module, ar->sub.search_req);
+ replmd_replicated_uptodate_search_callback,
+ ar->req);
if (ret != LDB_SUCCESS) return replmd_replicated_request_error(ar, ret);
- ar->sub.search_ret = ldb_wait(ar->sub.search_req->handle, LDB_WAIT_ALL);
- if (ar->sub.search_ret != LDB_SUCCESS) {
- return replmd_replicated_request_error(ar, ar->sub.search_ret);
- }
- if (!ar->sub.search_msg) {
- return replmd_replicated_request_werror(ar, WERR_DS_DRA_INTERNAL_ERROR);
- }
-
- return replmd_replicated_uptodate_modify(ar);
-#endif
-}
-
-static int replmd_replicated_uptodate_vector(struct replmd_replicated_request *ar)
-{
- ar->sub.mem_ctx = talloc_new(ar);
- if (!ar->sub.mem_ctx) return replmd_replicated_request_werror(ar, WERR_NOMEM);
-
- return replmd_replicated_uptodate_search(ar);
+ return ldb_next_request(ar->module, search_req);
}
static int replmd_extended_replicated_objects(struct ldb_module *module, struct ldb_request *req)
{
struct dsdb_extended_replicated_objects *objs;
struct replmd_replicated_request *ar;
+ struct ldb_control **ctrls;
+ int ret;
ldb_debug(module->ldb, LDB_DEBUG_TRACE, "replmd_extended_replicated_objects\n");
return LDB_ERR_PROTOCOL_ERROR;
}
- ar = replmd_replicated_init_handle(module, req, objs);
- if (!ar) {
+ ar = replmd_ctx_init(module, req);
+ if (!ar)
return LDB_ERR_OPERATIONS_ERROR;
+
+ ar->objs = objs;
+ ar->schema = dsdb_get_schema(module->ldb);
+ if (!ar->schema) {
+ ldb_debug_set(module->ldb, LDB_DEBUG_FATAL, "replmd_ctx_init: no loaded schema found\n");
+ talloc_free(ar);
+ return LDB_ERR_CONSTRAINT_VIOLATION;
}
-#ifdef REPLMD_FULL_ASYNC /* TODO: activate this code when ldb support full async code */
- return replmd_replicated_apply_next(ar);
-#else
- while (ar->index_current < ar->objs->num_objects &&
- req->handle->state != LDB_ASYNC_DONE) {
- replmd_replicated_apply_next(ar);
+ ctrls = req->controls;
+
+ if (req->controls) {
+ req->controls = talloc_memdup(ar, req->controls,
+ talloc_get_size(req->controls));
+ if (!req->controls) return replmd_replicated_request_werror(ar, WERR_NOMEM);
}
- if (req->handle->state != LDB_ASYNC_DONE) {
- replmd_replicated_uptodate_vector(ar);
+ ret = ldb_request_add_control(req, DSDB_CONTROL_REPLICATED_UPDATE_OID, false, NULL);
+ if (ret != LDB_SUCCESS) {
+ return ret;
}
- return LDB_SUCCESS;
-#endif
+ ar->controls = req->controls;
+ req->controls = ctrls;
+
+ return replmd_replicated_apply_next(ar);
}
static int replmd_extended(struct ldb_module *module, struct ldb_request *req)
return ldb_next_request(module, req);
}
-static int replmd_wait_none(struct ldb_handle *handle) {
- struct replmd_replicated_request *ar;
-
- if (!handle || !handle->private_data) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- ar = talloc_get_type(handle->private_data, struct replmd_replicated_request);
- if (!ar) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- /* we do only sync calls */
- if (handle->state != LDB_ASYNC_DONE) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- return handle->status;
-}
-
-static int replmd_wait_all(struct ldb_handle *handle) {
-
- int ret;
-
- while (handle->state != LDB_ASYNC_DONE) {
- ret = replmd_wait_none(handle);
- if (ret != LDB_SUCCESS) {
- return ret;
- }
- }
-
- return handle->status;
-}
-
-static int replmd_wait(struct ldb_handle *handle, enum ldb_wait_type type)
-{
- if (type == LDB_WAIT_ALL) {
- return replmd_wait_all(handle);
- } else {
- return replmd_wait_none(handle);
- }
-}
-
_PUBLIC_ const struct ldb_module_ops ldb_repl_meta_data_module_ops = {
.name = "repl_meta_data",
.add = replmd_add,
.modify = replmd_modify,
.extended = replmd_extended,
- .wait = replmd_wait
};
rootDSE ldb module
Copyright (C) Andrew Tridgell 2005
- Copyright (C) Simo Sorce 2005
+ Copyright (C) Simo Sorce 2005-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
struct rootdse_context {
struct ldb_module *module;
- void *up_context;
- int (*up_callback)(struct ldb_context *, void *, struct ldb_reply *);
-
- const char * const * attrs;
+ struct ldb_request *req;
};
-static int rootdse_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
+static struct rootdse_context *rootdse_init_context(struct ldb_module *module,
+ struct ldb_request *req)
+{
+ struct rootdse_context *ac;
+
+ ac = talloc_zero(req, struct rootdse_context);
+ if (ac == NULL) {
+ ldb_set_errstring(module->ldb, "Out of Memory");
+ return NULL;
+ }
+
+ ac->module = module;
+ ac->req = req;
+
+ return ac;
+}
+
+static int rootdse_callback(struct ldb_request *req, struct ldb_reply *ares)
{
struct rootdse_context *ac;
+ int ret;
+
+ ac = talloc_get_type(req->context, struct rootdse_context);
- ac = talloc_get_type(context, struct rootdse_context);
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
- if (ares->type == LDB_REPLY_ENTRY) {
+ switch (ares->type) {
+ case LDB_REPLY_ENTRY:
/*
* if the client explicit asks for the 'netlogon' attribute
* the reply_entry needs to be skipped
*/
- if (ac->attrs && ldb_attr_in_list(ac->attrs, "netlogon")) {
+ if (ac->req->op.search.attrs &&
+ ldb_attr_in_list(ac->req->op.search.attrs, "netlogon")) {
talloc_free(ares);
return LDB_SUCCESS;
}
/* for each record returned post-process to add any dynamic
attributes that have been asked for */
- if (rootdse_add_dynamic(ac->module, ares->message, ac->attrs) != LDB_SUCCESS) {
- goto error;
+ ret = rootdse_add_dynamic(ac->module, ares->message,
+ ac->req->op.search.attrs);
+ if (ret != LDB_SUCCESS) {
+ talloc_free(ares);
+ return ldb_module_done(ac->req, NULL, NULL, ret);
}
- }
- return ac->up_callback(ldb, ac->up_context, ares);
+ return ldb_module_send_entry(ac->req, ares->message);
+
+ case LDB_REPLY_REFERRAL:
+ /* should we allow the backend to return referrals in this case
+ * ?? */
+ break;
+
+ case LDB_REPLY_DONE:
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
-error:
talloc_free(ares);
- return LDB_ERR_OPERATIONS_ERROR;
+ return LDB_SUCCESS;
}
static int rootdse_search(struct ldb_module *module, struct ldb_request *req)
return ldb_next_request(module, req);
}
- ac = talloc(req, struct rootdse_context);
+ ac = rootdse_init_context(module, req);
if (ac == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
- ac->module = module;
- ac->up_context = req->context;
- ac->up_callback = req->callback;
- ac->attrs = req->op.search.attrs;
-
- down_req = talloc_zero(req, struct ldb_request);
- if (down_req == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- down_req->operation = req->operation;
/* in our db we store the rootDSE with a DN of @ROOTDSE */
- down_req->op.search.base = ldb_dn_new(down_req, module->ldb, "@ROOTDSE");
- down_req->op.search.scope = LDB_SCOPE_BASE;
- down_req->op.search.tree = ldb_parse_tree(down_req, NULL);
- if (down_req->op.search.base == NULL || down_req->op.search.tree == NULL) {
- ldb_oom(module->ldb);
- talloc_free(down_req);
- return LDB_ERR_OPERATIONS_ERROR;
- }
- down_req->op.search.attrs = req->op.search.attrs;
- down_req->controls = req->controls;
-
- down_req->context = ac;
- down_req->callback = rootdse_callback;
- ldb_set_timeout_from_prev_req(module->ldb, req, down_req);
-
- /* perform the search */
- ret = ldb_next_request(module, down_req);
-
- /* do not free down_req as the call results may be linked to it,
- * it will be freed when the upper level request get freed */
- if (ret == LDB_SUCCESS) {
- req->handle = down_req->handle;
+ ret = ldb_build_search_req(&down_req, module->ldb, ac,
+ ldb_dn_new(ac, module->ldb, "@ROOTDSE"),
+ LDB_SCOPE_BASE,
+ NULL,
+ req->op.search.attrs,
+ NULL,/* for now skip the controls from the client */
+ ac, rootdse_callback,
+ req);
+ if (ret != LDB_SUCCESS) {
+ return ret;
}
- return ret;
+ return ldb_next_request(module, down_req);
}
static int rootdse_register_control(struct ldb_module *module, struct ldb_request *req)
priv->num_controls += 1;
priv->controls = list;
- return LDB_SUCCESS;
+ return ldb_module_done(req, NULL, NULL, LDB_SUCCESS);
}
-
+
static int rootdse_register_partition(struct ldb_module *module, struct ldb_request *req)
{
struct private_data *priv = talloc_get_type(module->private_data, struct private_data);
priv->num_partitions += 1;
priv->partitions = list;
- return LDB_SUCCESS;
+ return ldb_module_done(req, NULL, NULL, LDB_SUCCESS);
}
-
+
static int rootdse_request(struct ldb_module *module, struct ldb_request *req)
{
-/*
+/*
SAM ldb module
- Copyright (C) Simo Sorce 2004
Copyright (C) Andrew Bartlett <abartlet@samba.org> 2005
+ Copyright (C) Simo Sorce 2004-2008
* NOTICE: this module is NOT released under the GNU LGPL license as
* other ldb code. This module is release under the GNU GPL v3 or
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 "lib/ldb/include/ldb_errors.h"
#include "lib/ldb/include/ldb.h"
#include "lib/ldb/include/ldb_private.h"
+#include "lib/events/events.h"
#include "dsdb/samdb/samdb.h"
#include "libcli/security/security.h"
#include "librpc/gen_ndr/ndr_security.h"
#include "util/util_ldb.h"
+#include "ldb_wrap.h"
+
+struct samldb_ctx;
+
+typedef int (*samldb_step_fn_t)(struct samldb_ctx *);
+
+struct samldb_step {
+ struct samldb_step *next;
+ samldb_step_fn_t fn;
+};
+
+struct samldb_ctx {
+ struct ldb_module *module;
+ struct ldb_request *req;
-int samldb_notice_sid(struct ldb_module *module,
- TALLOC_CTX *mem_ctx, const struct dom_sid *sid);
+ /* the resulting message */
+ struct ldb_message *msg;
+
+ /* used to apply templates */
+ const char *type;
+
+ /* used to find parent domain */
+ struct ldb_dn *check_dn;
+ struct ldb_dn *domain_dn;
+ struct dom_sid *domain_sid;
+ uint32_t next_rid;
+
+ /* generic storage, remember to zero it before use */
+ struct ldb_reply *ares;
+
+ /* holds the entry SID */
+ struct dom_sid *sid;
+
+ /* all the async steps necessary to complete the operation */
+ struct samldb_step *steps;
+ struct samldb_step *curstep;
+};
-static bool samldb_msg_add_sid(struct ldb_module *module, struct ldb_message *msg, const char *name, const struct dom_sid *sid)
+struct samldb_ctx *samldb_ctx_init(struct ldb_module *module,
+ struct ldb_request *req)
{
- struct ldb_val v;
- enum ndr_err_code ndr_err;
+ struct samldb_ctx *ac;
- ndr_err = ndr_push_struct_blob(&v, msg, NULL, sid,
- (ndr_push_flags_fn_t)ndr_push_dom_sid);
- if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
- return false;
+ ac = talloc_zero(req, struct samldb_ctx);
+ if (ac == NULL) {
+ ldb_oom(module->ldb);
+ return NULL;
}
- return (ldb_msg_add_value(msg, name, &v, NULL) == 0);
+
+ ac->module = module;
+ ac->req = req;
+
+ return ac;
}
-/*
- allocate a new id, attempting to do it atomically
- return 0 on failure, the id on success
-*/
-static int samldb_set_next_rid(struct ldb_context *ldb, TALLOC_CTX *mem_ctx,
- struct ldb_dn *dn, uint32_t old_id, uint32_t new_id)
+static int samldb_add_step(struct samldb_ctx *ac, samldb_step_fn_t fn)
{
- struct ldb_message msg;
- int ret;
- struct ldb_val vals[2];
- struct ldb_message_element els[2];
+ struct samldb_step *step;
- if (new_id == 0) {
- /* out of IDs ! */
- ldb_set_errstring(ldb, "Are we out of valid IDs ?\n");
+ step = talloc_zero(ac, struct samldb_step);
+ if (step == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
- /* we do a delete and add as a single operation. That prevents
- a race, in case we are not actually on a transaction db */
- ZERO_STRUCT(msg);
- msg.dn = ldb_dn_copy(mem_ctx, dn);
- if (!msg.dn) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ if (ac->steps == NULL) {
+ ac->steps = step;
+ ac->curstep = step;
+ } else {
+ ac->curstep->next = step;
+ ac->curstep = step;
}
- msg.num_elements = 2;
- 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(mem_ctx, "nextRid");
- if (!els[0].name) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
- }
+ step->fn = fn;
- els[1].num_values = 1;
- els[1].values = &vals[1];
- els[1].flags = LDB_FLAG_MOD_ADD;
- els[1].name = els[0].name;
+ return LDB_SUCCESS;
+}
- vals[0].data = (uint8_t *)talloc_asprintf(mem_ctx, "%u", old_id);
- if (!vals[0].data) {
- ldb_oom(ldb);
+static int samldb_first_step(struct samldb_ctx *ac)
+{
+ if (ac->steps == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
- vals[0].length = strlen((char *)vals[0].data);
- vals[1].data = (uint8_t *)talloc_asprintf(mem_ctx, "%u", new_id);
- if (!vals[1].data) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ ac->curstep = ac->steps;
+ return ac->curstep->fn(ac);
+}
+
+static int samldb_next_step(struct samldb_ctx *ac)
+{
+ if (ac->curstep->next) {
+ ac->curstep = ac->curstep->next;
+ return ac->curstep->fn(ac);
}
- vals[1].length = strlen((char *)vals[1].data);
- ret = ldb_modify(ldb, &msg);
- return ret;
+ /* it is an error if the last step does not properly
+ * return to the upper module by itself */
+ return LDB_ERR_OPERATIONS_ERROR;
}
-/*
- allocate a new id, attempting to do it atomically
- return 0 on failure, the id on success
-*/
-static int samldb_find_next_rid(struct ldb_module *module, TALLOC_CTX *mem_ctx,
- struct ldb_dn *dn, uint32_t *old_rid)
+static int samldb_search_template_callback(struct ldb_request *req,
+ struct ldb_reply *ares)
{
- const char * const attrs[2] = { "nextRid", NULL };
- struct ldb_result *res = NULL;
+ struct samldb_ctx *ac;
int ret;
- const char *str;
- ret = ldb_search(module->ldb, dn, LDB_SCOPE_BASE, "nextRid=*", attrs, &res);
- if (ret != LDB_SUCCESS) {
- return ret;
+ ac = talloc_get_type(req->context, struct samldb_ctx);
+
+ if (!ares) {
+ ret = LDB_ERR_OPERATIONS_ERROR;
+ goto done;
}
- if (res->count != 1) {
- talloc_free(res);
- return LDB_ERR_OPERATIONS_ERROR;
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
}
- str = ldb_msg_find_attr_as_string(res->msgs[0], "nextRid", NULL);
- if (str == NULL) {
- ldb_asprintf_errstring(module->ldb,
- "attribute nextRid not found in %s\n",
- ldb_dn_get_linearized(dn));
- talloc_free(res);
- return LDB_ERR_OPERATIONS_ERROR;
+ switch (ares->type) {
+ case LDB_REPLY_ENTRY:
+ /* save entry */
+ if (ac->ares != NULL) {
+ /* one too many! */
+ ldb_set_errstring(ac->module->ldb,
+ "Invalid number of results while searching "
+ "for template objects");
+ ret = LDB_ERR_OPERATIONS_ERROR;
+ goto done;
+ }
+
+ ac->ares = talloc_steal(ac, ares);
+ ret = LDB_SUCCESS;
+ break;
+
+ case LDB_REPLY_REFERRAL:
+ /* ignore */
+ talloc_free(ares);
+ ret = LDB_SUCCESS;
+ break;
+
+ case LDB_REPLY_DONE:
+
+ talloc_free(ares);
+ ret = samldb_next_step(ac);
+ break;
+ }
+
+done:
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL, ret);
}
- *old_rid = strtol(str, NULL, 0);
- talloc_free(res);
return LDB_SUCCESS;
}
-static int samldb_allocate_next_rid(struct ldb_module *module, TALLOC_CTX *mem_ctx,
- struct ldb_dn *dn, const struct dom_sid *dom_sid,
- struct dom_sid **new_sid)
+static int samldb_search_template(struct samldb_ctx *ac)
{
- struct dom_sid *obj_sid;
- uint32_t old_rid;
+ struct event_context *ev;
+ struct loadparm_context *lparm_ctx;
+ struct ldb_context *templates_ldb;
+ char *templates_ldb_path;
+ struct ldb_request *req;
+ struct ldb_dn *basedn;
+ void *opaque;
int ret;
-
- ret = samldb_find_next_rid(module, mem_ctx, dn, &old_rid);
- if (ret) {
- return ret;
+
+ opaque = ldb_get_opaque(ac->module->ldb, "loadparm");
+ lparm_ctx = talloc_get_type(opaque, struct loadparm_context);
+ if (lparm_ctx == NULL) {
+ ldb_set_errstring(ac->module->ldb,
+ "Unable to find loadparm context\n");
+ return LDB_ERR_OPERATIONS_ERROR;
}
-
- /* return the new object sid */
- obj_sid = dom_sid_add_rid(mem_ctx, dom_sid, old_rid);
-
- *new_sid = dom_sid_add_rid(mem_ctx, dom_sid, old_rid + 1);
- if (!*new_sid) {
+
+ opaque = ldb_get_opaque(ac->module->ldb, "templates_ldb");
+ templates_ldb = talloc_get_type(opaque, struct ldb_context);
+
+ /* make sure we have the templates ldb */
+ if (!templates_ldb) {
+ templates_ldb_path = samdb_relative_path(ac->module->ldb, ac,
+ "templates.ldb");
+ if (!templates_ldb_path) {
+ ldb_set_errstring(ac->module->ldb,
+ "samldb_init_template: ERROR: Failed "
+ "to contruct path for template db");
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ ev = ldb_get_event_context(ac->module->ldb);
+
+ templates_ldb = ldb_wrap_connect(ac->module->ldb, ev,
+ lparm_ctx, templates_ldb_path,
+ NULL, NULL, 0, NULL);
+ talloc_free(templates_ldb_path);
+
+ if (!templates_ldb) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ if (!talloc_reference(templates_ldb, ev)) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ ret = ldb_set_opaque(ac->module->ldb,
+ "templates_ldb", templates_ldb);
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
+ }
+
+ /* search template */
+ basedn = ldb_dn_new_fmt(ac, templates_ldb,
+ "cn=Template%s,cn=Templates", ac->type);
+ if (basedn == NULL) {
+ ldb_set_errstring(ac->module->ldb,
+ "samldb_init_template: ERROR: Failed "
+ "to contruct DN for template");
return LDB_ERR_OPERATIONS_ERROR;
}
- ret = samldb_notice_sid(module, mem_ctx, *new_sid);
- if (ret != 0) {
- /* gah, there are conflicting sids.
- * This is a critical situation it means that someone messed up with
- * the DB and nextRid is not returning free RIDs, report an error
- * and refuse to create any user until the problem is fixed */
- ldb_asprintf_errstring(module->ldb,
- "Critical Error: unconsistent DB, unable to retireve an unique RID to generate a new SID: %s",
- ldb_errstring(module->ldb));
+ /* pull the template record */
+ ret = ldb_build_search_req(&req, templates_ldb, ac,
+ basedn, LDB_SCOPE_BASE,
+ "(distinguishedName=*)", NULL,
+ NULL,
+ ac, samldb_search_template_callback,
+ ac->req);
+ if (ret != LDB_SUCCESS) {
return ret;
}
- return ret;
+
+ talloc_steal(req, basedn);
+ ac->ares = NULL;
+
+ return ldb_request(templates_ldb, req);
}
-/* search the domain related to the provided dn
- allocate a new RID for the domain
- return the new sid string
-*/
-static int samldb_get_new_sid(struct ldb_module *module,
- TALLOC_CTX *mem_ctx, struct ldb_dn *obj_dn,
- struct ldb_dn *dom_dn,
- struct dom_sid **sid)
+static int samldb_apply_template(struct samldb_ctx *ac)
+{
+ struct ldb_message_element *el;
+ struct ldb_message *msg;
+ int i, j;
+ int ret;
+
+ msg = ac->ares->message;
+
+ for (i = 0; i < msg->num_elements; i++) {
+ el = &msg->elements[i];
+ /* some elements should not be copied */
+ if (ldb_attr_cmp(el->name, "cn") == 0 ||
+ ldb_attr_cmp(el->name, "name") == 0 ||
+ ldb_attr_cmp(el->name, "objectClass") == 0 ||
+ ldb_attr_cmp(el->name, "sAMAccountName") == 0 ||
+ ldb_attr_cmp(el->name, "sAMAccountName") == 0 ||
+ ldb_attr_cmp(el->name, "distinguishedName") == 0 ||
+ ldb_attr_cmp(el->name, "objectGUID") == 0) {
+ continue;
+ }
+ for (j = 0; j < el->num_values; j++) {
+ ret = samdb_find_or_add_attribute(
+ ac->module->ldb, ac->msg, el->name,
+ (char *)el->values[j].data);
+ if (ret != LDB_SUCCESS) {
+ ldb_set_errstring(ac->module->ldb,
+ "Failed adding template attribute\n");
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ }
+ }
+
+ return samldb_next_step(ac);
+}
+
+static int samldb_get_parent_domain(struct samldb_ctx *ac);
+
+static int samldb_get_parent_domain_callback(struct ldb_request *req,
+ struct ldb_reply *ares)
{
- const char * const attrs[2] = { "objectSid", NULL };
- struct ldb_result *res = NULL;
+ struct samldb_ctx *ac;
+ const char *nextRid;
int ret;
- struct dom_sid *dom_sid;
- /* get the domain component part of the provided dn */
+ ac = talloc_get_type(req->context, struct samldb_ctx);
+
+ if (!ares) {
+ ret = LDB_ERR_OPERATIONS_ERROR;
+ goto done;
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
+
+ switch (ares->type) {
+ case LDB_REPLY_ENTRY:
+ /* save entry */
+ if (ac->domain_dn != NULL) {
+ /* one too many! */
+ ldb_set_errstring(ac->module->ldb,
+ "Invalid number of results while searching "
+ "for domain object");
+ ret = LDB_ERR_OPERATIONS_ERROR;
+ break;
+ }
+
+ nextRid = ldb_msg_find_attr_as_string(ares->message,
+ "nextRid", NULL);
+ if (nextRid == NULL) {
+ ldb_asprintf_errstring(ac->module->ldb,
+ "attribute nextRid not found in %s\n",
+ ldb_dn_get_linearized(ares->message->dn));
+ ret = LDB_ERR_OPERATIONS_ERROR;
+ break;;
+ }
+
+ ac->next_rid = strtol(nextRid, NULL, 0);
+
+ ac->domain_sid = samdb_result_dom_sid(ac, ares->message,
+ "objectSid");
+ if (ac->domain_sid == NULL) {
+ ldb_set_errstring(ac->module->ldb,
+ "error retrieving parent domain domain sid!\n");
+ ret = LDB_ERR_CONSTRAINT_VIOLATION;
+ break;
+ }
+ ac->domain_dn = talloc_steal(ac, ares->message->dn);
+
+ talloc_free(ares);
+ ret = LDB_SUCCESS;
+ break;
+
+ case LDB_REPLY_REFERRAL:
+ /* ignore */
+ talloc_free(ares);
+ ret = LDB_SUCCESS;
+ break;
- /* find the domain sid */
+ case LDB_REPLY_DONE:
- ret = ldb_search(module->ldb, dom_dn, LDB_SCOPE_BASE, "objectSid=*", attrs, &res);
+ talloc_free(ares);
+ if (ac->domain_dn == NULL) {
+ /* search again */
+ ret = samldb_get_parent_domain(ac);
+ } else {
+ /* found, go on */
+ ret = samldb_next_step(ac);
+ }
+ break;
+ }
+
+done:
if (ret != LDB_SUCCESS) {
- ldb_asprintf_errstring(module->ldb,
- "samldb_get_new_sid: error retrieving domain sid from %s: %s!\n",
- ldb_dn_get_linearized(dom_dn),
- ldb_errstring(module->ldb));
- talloc_free(res);
- return ret;
+ return ldb_module_done(ac->req, NULL, NULL, ret);
}
- if (res->count != 1) {
- ldb_asprintf_errstring(module->ldb,
- "samldb_get_new_sid: error retrieving domain sid from %s: not found!\n",
- ldb_dn_get_linearized(dom_dn));
- talloc_free(res);
- return LDB_ERR_CONSTRAINT_VIOLATION;
+ return LDB_SUCCESS;
+}
+
+/* Find a domain object in the parents of a particular DN. */
+static int samldb_get_parent_domain(struct samldb_ctx *ac)
+{
+ static const char * const attrs[3] = { "objectSid", "nextRid", NULL };
+ struct ldb_request *req;
+ struct ldb_dn *dn;
+ int ret;
+
+ if (ac->check_dn == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
}
- dom_sid = samdb_result_dom_sid(res, res->msgs[0], "objectSid");
- if (dom_sid == NULL) {
- ldb_set_errstring(module->ldb, "samldb_get_new_sid: error parsing domain sid!\n");
- talloc_free(res);
+ dn = ldb_dn_get_parent(ac, ac->check_dn);
+ if (dn == NULL) {
+ ldb_set_errstring(ac->module->ldb,
+ "Unable to find parent domain object");
return LDB_ERR_CONSTRAINT_VIOLATION;
}
- /* allocate a new Rid for the domain */
- ret = samldb_allocate_next_rid(module, mem_ctx, dom_dn, dom_sid, sid);
- if (ret != 0) {
- ldb_debug(module->ldb, LDB_DEBUG_FATAL, "Failed to increment nextRid of %s: %s\n", ldb_dn_get_linearized(dom_dn), ldb_errstring(module->ldb));
- talloc_free(res);
+ ac->check_dn = dn;
+
+ ret = ldb_build_search_req(&req, ac->module->ldb, ac,
+ dn, LDB_SCOPE_BASE,
+ "(|(objectClass=domain)"
+ "(objectClass=builtinDomain)"
+ "(objectClass=samba4LocalDomain))",
+ attrs,
+ NULL,
+ ac, samldb_get_parent_domain_callback,
+ ac->req);
+
+ if (ret != LDB_SUCCESS) {
return ret;
}
- talloc_free(res);
+ return ldb_next_request(ac->module, req);
+}
+
+static int samldb_generate_samAccountName(struct ldb_message *msg)
+{
+ char *name;
+
+ /* Format: $000000-000000000000 */
- return ret;
+ name = talloc_asprintf(msg, "$%.6X-%.6X%.6X",
+ (unsigned int)generate_random(),
+ (unsigned int)generate_random(),
+ (unsigned int)generate_random());
+ if (name == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ return ldb_msg_add_steal_string(msg, "samAccountName", name);
}
-/* If we are adding new users/groups, we need to update the nextRid
- * attribute to be 'above' all incoming users RIDs. This tries to
- * avoid clashes in future */
+static int samldb_check_samAccountName_callback(struct ldb_request *req,
+ struct ldb_reply *ares)
+{
+ struct samldb_ctx *ac;
+ int ret;
+
+ ac = talloc_get_type(req->context, struct samldb_ctx);
-int samldb_notice_sid(struct ldb_module *module,
- TALLOC_CTX *mem_ctx, const struct dom_sid *sid)
+ if (!ares) {
+ ret = LDB_ERR_OPERATIONS_ERROR;
+ goto done;
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
+
+ switch (ares->type) {
+ case LDB_REPLY_ENTRY:
+
+ /* if we get an entry it means this samAccountName
+ * already exists */
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_ENTRY_ALREADY_EXISTS);
+
+ case LDB_REPLY_REFERRAL:
+ /* ignore */
+ talloc_free(ares);
+ ret = LDB_SUCCESS;
+ break;
+
+ case LDB_REPLY_DONE:
+
+ /* not found, go on */
+ talloc_free(ares);
+ ret = samldb_next_step(ac);
+ break;
+ }
+
+done:
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL, ret);
+ }
+
+ return LDB_SUCCESS;
+}
+
+static int samldb_check_samAccountName(struct samldb_ctx *ac)
{
+ struct ldb_request *req;
+ const char *name;
+ char *filter;
int ret;
- struct ldb_dn *dom_dn;
- struct dom_sid *dom_sid;
- const char *attrs[] = { NULL };
- struct ldb_result *dom_res;
- struct ldb_result *res;
- uint32_t old_rid;
-
- /* find if this SID already exists */
- ret = ldb_search_exp_fmt(module->ldb, mem_ctx, &res,
- NULL, LDB_SCOPE_SUBTREE, attrs,
- "(objectSid=%s)", ldap_encode_ndr_dom_sid(mem_ctx, sid));
- if (ret == LDB_SUCCESS) {
- if (res->count > 0) {
- talloc_free(res);
- ldb_asprintf_errstring(module->ldb,
- "Attempt to add record with SID %s rejected,"
- " because this SID is already in the database",
- dom_sid_string(mem_ctx, sid));
- /* We have a duplicate SID, we must reject the add */
- return LDB_ERR_CONSTRAINT_VIOLATION;
+
+ if (ldb_msg_find_element(ac->msg, "samAccountName") == NULL) {
+ ret = samldb_generate_samAccountName(ac->msg);
+ if (ret != LDB_SUCCESS) {
+ return ret;
}
- talloc_free(res);
- } else {
- ldb_asprintf_errstring(module->ldb,
- "samldb_notice_sid: error searching to see if sid %s is in use: %s\n",
- dom_sid_string(mem_ctx, sid),
- ldb_errstring(module->ldb));
- return ret;
}
- dom_sid = dom_sid_dup(mem_ctx, sid);
- if (!dom_sid) {
+ name = ldb_msg_find_attr_as_string(ac->msg, "samAccountName", NULL);
+ if (name == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ filter = talloc_asprintf(ac, "samAccountName=%s", name);
+ if (filter == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
- /* get the domain component part of the provided SID */
- dom_sid->num_auths--;
-
- /* find the domain DN */
- ret = ldb_search_exp_fmt(module->ldb, mem_ctx, &dom_res,
- NULL, LDB_SCOPE_SUBTREE, attrs,
- "(&(objectSid=%s)(|(|(objectClass=domain)(objectClass=builtinDomain))(objectClass=samba4LocalDomain)))",
- ldap_encode_ndr_dom_sid(mem_ctx, dom_sid));
- if (ret == LDB_SUCCESS) {
- if (dom_res->count == 0) {
- talloc_free(dom_res);
- /* This isn't an operation on a domain we know about, so nothing to update */
- return LDB_SUCCESS;
- }
- if (dom_res->count > 1) {
- talloc_free(dom_res);
- ldb_asprintf_errstring(module->ldb,
- "samldb_notice_sid: error retrieving domain from sid: duplicate (found %d) domain: %s!\n",
- dom_res->count, dom_sid_string(dom_res, dom_sid));
- return LDB_ERR_OPERATIONS_ERROR;
- }
- } else {
- ldb_asprintf_errstring(module->ldb,
- "samldb_notice_sid: error retrieving domain from sid: %s: %s\n",
- dom_sid_string(dom_res, dom_sid),
- ldb_errstring(module->ldb));
+ ret = ldb_build_search_req(&req, ac->module->ldb, ac,
+ ac->domain_dn, LDB_SCOPE_SUBTREE,
+ filter, NULL,
+ NULL,
+ ac, samldb_check_samAccountName_callback,
+ ac->req);
+ talloc_free(filter);
+ if (ret != LDB_SUCCESS) {
return ret;
}
+ ac->ares = NULL;
+ return ldb_next_request(ac->module, req);
+}
- dom_dn = dom_res->msgs[0]->dn;
+static int samldb_check_samAccountType(struct samldb_ctx *ac)
+{
+ unsigned int account_type;
+ unsigned int group_type;
+ unsigned int uac;
+ int ret;
- ret = samldb_find_next_rid(module, mem_ctx,
- dom_dn, &old_rid);
- if (ret) {
- talloc_free(dom_res);
- return ret;
+ /* make sure sAMAccountType is not specified */
+ if (ldb_msg_find_element(ac->msg, "sAMAccountType") != NULL) {
+ ldb_asprintf_errstring(ac->module->ldb,
+ "sAMAccountType must not be specified");
+ return LDB_ERR_UNWILLING_TO_PERFORM;
}
- if (old_rid <= sid->sub_auths[sid->num_auths - 1]) {
- ret = samldb_set_next_rid(module->ldb, mem_ctx, dom_dn, old_rid,
- sid->sub_auths[sid->num_auths - 1] + 1);
+ if (strcmp("user", ac->type) == 0) {
+ uac = samdb_result_uint(ac->msg, "userAccountControl", 0);
+ if (uac == 0) {
+ ldb_asprintf_errstring(ac->module->ldb,
+ "userAccountControl invalid");
+ return LDB_ERR_UNWILLING_TO_PERFORM;
+ } else {
+ account_type = samdb_uf2atype(uac);
+ ret = samdb_msg_add_uint(ac->module->ldb,
+ ac->msg, ac->msg,
+ "sAMAccountType",
+ account_type);
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
+ }
+ } else
+ if (strcmp("group", ac->type) == 0) {
+
+ group_type = samdb_result_uint(ac->msg, "groupType", 0);
+ if (group_type == 0) {
+ ldb_asprintf_errstring(ac->module->ldb,
+ "groupType invalid");
+ return LDB_ERR_UNWILLING_TO_PERFORM;
+ } else {
+ account_type = samdb_gtype2atype(group_type);
+ ret = samdb_msg_add_uint(ac->module->ldb,
+ ac->msg, ac->msg,
+ "sAMAccountType",
+ account_type);
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
+ }
}
- talloc_free(dom_res);
- return ret;
+
+ return samldb_next_step(ac);
}
-static int samldb_handle_sid(struct ldb_module *module,
- TALLOC_CTX *mem_ctx, struct ldb_message *msg2,
- struct ldb_dn *parent_dn)
+static int samldb_get_sid_domain_callback(struct ldb_request *req,
+ struct ldb_reply *ares)
{
+ struct samldb_ctx *ac;
+ const char *nextRid;
int ret;
-
- struct dom_sid *sid = samdb_result_dom_sid(mem_ctx, msg2, "objectSid");
- if (sid == NULL) {
- ret = samldb_get_new_sid(module, msg2, msg2->dn, parent_dn, &sid);
- if (ret != 0) {
- return ret;
+
+ ac = talloc_get_type(req->context, struct samldb_ctx);
+
+ if (!ares) {
+ ret = LDB_ERR_OPERATIONS_ERROR;
+ goto done;
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
+
+ switch (ares->type) {
+ case LDB_REPLY_ENTRY:
+ /* save entry */
+ if (ac->next_rid != 0) {
+ /* one too many! */
+ ldb_set_errstring(ac->module->ldb,
+ "Invalid number of results while searching "
+ "for domain object");
+ ret = LDB_ERR_OPERATIONS_ERROR;
+ break;
}
- if ( ! samldb_msg_add_sid(module, msg2, "objectSid", sid)) {
- talloc_free(sid);
- return LDB_ERR_OPERATIONS_ERROR;
+ nextRid = ldb_msg_find_attr_as_string(ares->message,
+ "nextRid", NULL);
+ if (nextRid == NULL) {
+ ldb_asprintf_errstring(ac->module->ldb,
+ "attribute nextRid not found in %s\n",
+ ldb_dn_get_linearized(ares->message->dn));
+ ret = LDB_ERR_OPERATIONS_ERROR;
+ break;
}
- talloc_free(sid);
+
+ ac->next_rid = strtol(nextRid, NULL, 0);
+
+ ac->domain_dn = talloc_steal(ac, ares->message->dn);
+
+ talloc_free(ares);
ret = LDB_SUCCESS;
- } else {
- ret = samldb_notice_sid(module, msg2, sid);
+ break;
+
+ case LDB_REPLY_REFERRAL:
+ /* ignore */
+ talloc_free(ares);
+ ret = LDB_SUCCESS;
+ break;
+
+ case LDB_REPLY_DONE:
+
+ if (ac->next_rid == 0) {
+ ldb_asprintf_errstring(ac->module->ldb,
+ "Unable to get nextRid from domain entry\n");
+ ret = LDB_ERR_OPERATIONS_ERROR;
+ break;
+ }
+
+ /* found, go on */
+ ret = samldb_next_step(ac);
+ break;
+ }
+
+done:
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL, ret);
}
- return ret;
+
+ return LDB_SUCCESS;
}
-static int samldb_generate_samAccountName(struct ldb_module *module, TALLOC_CTX *mem_ctx,
- struct ldb_dn *dom_dn, char **name)
+/* Find a domain object in the parents of a particular DN. */
+static int samldb_get_sid_domain(struct samldb_ctx *ac)
{
- const char *attrs[] = { NULL };
- struct ldb_result *res;
+ static const char * const attrs[2] = { "nextRid", NULL };
+ struct ldb_request *req;
+ char *filter;
int ret;
-
- /* Format: $000000-000000000000 */
-
- do {
- *name = talloc_asprintf(mem_ctx, "$%.6X-%.6X%.6X", (unsigned int)generate_random(), (unsigned int)generate_random(), (unsigned int)generate_random());
- /* TODO: Figure out exactly what this is meant to conflict with */
- ret = ldb_search_exp_fmt(module->ldb,
- mem_ctx, &res, dom_dn, LDB_SCOPE_SUBTREE, attrs,
- "samAccountName=%s",
- ldb_binary_encode_string(mem_ctx, *name));
- if (ret != LDB_SUCCESS) {
- ldb_asprintf_errstring(module->ldb, "samldb: Failure searching to determine if samAccountName %s is unique: %s",
- *name, ldb_errstring(module->ldb));
- return ret;
- }
- if (res->count == 0) {
- talloc_free(res);
- /* Great. There are no conflicting users/groups/etc */
- return LDB_SUCCESS;
- } else {
- talloc_free(*name);
- /* gah, there is a conflicting name, lets move around the loop again... */
- }
- } while (1);
+ if (ac->sid == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ ac->domain_sid = dom_sid_dup(ac, ac->sid);
+ if (!ac->domain_sid) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ /* get the domain component part of the provided SID */
+ ac->domain_sid->num_auths--;
+
+ filter = talloc_asprintf(ac, "(&(objectSid=%s)"
+ "(|(objectClass=domain)"
+ "(objectClass=builtinDomain)"
+ "(objectClass=samba4LocalDomain)))",
+ ldap_encode_ndr_dom_sid(ac, ac->domain_sid));
+ if (filter == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ ret = ldb_build_search_req(&req, ac->module->ldb, ac,
+ ldb_get_default_basedn(ac->module->ldb),
+ LDB_SCOPE_SUBTREE,
+ filter, attrs,
+ NULL,
+ ac, samldb_get_sid_domain_callback,
+ ac->req);
+
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
+
+ ac->next_rid = 0;
+ return ldb_next_request(ac->module, req);
}
-static int samldb_fill_group_object(struct ldb_module *module, const struct ldb_message *msg,
- struct ldb_message **ret_msg)
+static bool samldb_msg_add_sid(struct ldb_message *msg,
+ const char *name,
+ const struct dom_sid *sid)
{
- int ret;
- unsigned int group_type;
- char *name;
- struct ldb_message *msg2;
- struct ldb_dn *dom_dn;
- const char *rdn_name;
- TALLOC_CTX *mem_ctx = talloc_new(msg);
- const char *errstr;
- if (!mem_ctx) {
+ struct ldb_val v;
+ enum ndr_err_code ndr_err;
+
+ ndr_err = ndr_push_struct_blob(&v, msg, NULL, sid,
+ (ndr_push_flags_fn_t)ndr_push_dom_sid);
+ if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+ return false;
+ }
+ return (ldb_msg_add_value(msg, name, &v, NULL) == 0);
+}
+
+static int samldb_new_sid(struct samldb_ctx *ac)
+{
+
+ if (ac->domain_sid == NULL || ac->next_rid == 0) {
return LDB_ERR_OPERATIONS_ERROR;
}
- /* build the new msg */
- msg2 = ldb_msg_copy(mem_ctx, msg);
- if (!msg2) {
- ldb_debug(module->ldb, LDB_DEBUG_FATAL, "samldb_fill_group_object: ldb_msg_copy failed!\n");
- talloc_free(mem_ctx);
+ ac->sid = dom_sid_add_rid(ac, ac->domain_sid, ac->next_rid + 1);
+ if (ac->sid == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
- ret = samdb_copy_template(module->ldb, msg2,
- "group",
- &errstr);
- if (ret != 0) {
-
- talloc_free(mem_ctx);
- return ret;
+ if ( ! samldb_msg_add_sid(ac->msg, "objectSid", ac->sid)) {
+ return LDB_ERR_OPERATIONS_ERROR;
}
- rdn_name = ldb_dn_get_rdn_name(msg2->dn);
+ return samldb_next_step(ac);
+}
- if (strcasecmp(rdn_name, "cn") != 0) {
- ldb_debug(module->ldb, LDB_DEBUG_FATAL, "samldb_fill_group_object: Bad RDN (%s) for group!\n", rdn_name);
- talloc_free(mem_ctx);
- return LDB_ERR_CONSTRAINT_VIOLATION;
+static int samldb_check_sid_callback(struct ldb_request *req,
+ struct ldb_reply *ares)
+{
+ struct samldb_ctx *ac;
+ int ret;
+
+ ac = talloc_get_type(req->context, struct samldb_ctx);
+
+ if (!ares) {
+ ret = LDB_ERR_OPERATIONS_ERROR;
+ goto done;
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
}
- ret = samdb_search_for_parent_domain(module->ldb, mem_ctx, msg2->dn, &dom_dn, &errstr);
+ switch (ares->type) {
+ case LDB_REPLY_ENTRY:
+
+ /* if we get an entry it means an object with the
+ * requested sid exists */
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_CONSTRAINT_VIOLATION);
+
+ case LDB_REPLY_REFERRAL:
+ /* ignore */
+ talloc_free(ares);
+ break;
+
+ case LDB_REPLY_DONE:
+
+ /* not found, go on */
+ talloc_free(ares);
+ ret = samldb_next_step(ac);
+ break;
+ }
+
+done:
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL, ret);
+ }
+
+ return LDB_SUCCESS;
+}
+
+static int samldb_check_sid(struct samldb_ctx *ac)
+{
+ const char *const attrs[2] = { "objectSid", NULL };
+ struct ldb_request *req;
+ char *filter;
+ int ret;
+
+ if (ac->sid == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ filter = talloc_asprintf(ac, "(objectSid=%s)",
+ ldap_encode_ndr_dom_sid(ac, ac->sid));
+ if (filter == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ ret = ldb_build_search_req(&req, ac->module->ldb, ac,
+ ldb_get_default_basedn(ac->module->ldb),
+ LDB_SCOPE_SUBTREE,
+ filter, attrs,
+ NULL,
+ ac, samldb_check_sid_callback,
+ ac->req);
+
if (ret != LDB_SUCCESS) {
- ldb_asprintf_errstring(module->ldb,
- "samldb_fill_group_object: %s", errstr);
return ret;
}
- /* Generate a random name, if no samAccountName was supplied */
- if (ldb_msg_find_element(msg2, "samAccountName") == NULL) {
- ret = samldb_generate_samAccountName(module, mem_ctx, dom_dn, &name);
- if (ret != LDB_SUCCESS) {
- talloc_free(mem_ctx);
- return ret;
- }
- ret = samdb_find_or_add_attribute(module->ldb, msg2, "sAMAccountName", name);
- if (ret) {
- talloc_free(mem_ctx);
- return ret;
- }
+ return ldb_next_request(ac->module, req);
+}
+
+static int samldb_notice_sid_callback(struct ldb_request *req,
+ struct ldb_reply *ares)
+{
+ struct samldb_ctx *ac;
+ int ret;
+
+ ac = talloc_get_type(req->context, struct samldb_ctx);
+
+ if (!ares) {
+ ret = LDB_ERR_OPERATIONS_ERROR;
+ goto done;
}
-
- if (ldb_msg_find_element(msg2, "sAMAccountType") != NULL) {
- ldb_asprintf_errstring(module->ldb, "sAMAccountType must not be specified");
- talloc_free(mem_ctx);
- return LDB_ERR_UNWILLING_TO_PERFORM;
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
}
- group_type = samdb_result_uint(msg2, "groupType", 0);
- if (group_type == 0) {
- ldb_asprintf_errstring(module->ldb, "groupType invalid");
- talloc_free(mem_ctx);
- return LDB_ERR_UNWILLING_TO_PERFORM;
- } else {
- unsigned int account_type = samdb_gtype2atype(group_type);
- ret = samdb_msg_add_uint(module->ldb, msg2, msg2,
- "sAMAccountType",
- account_type);
- if (ret != LDB_SUCCESS) {
- return ret;
- }
+ if (ares->type != LDB_REPLY_DONE) {
+ ldb_set_errstring(ac->module->ldb,
+ "Invalid reply type!\n");
+ ret = LDB_ERR_OPERATIONS_ERROR;
+ goto done;
}
- /* Manage SID allocation, conflicts etc */
- ret = samldb_handle_sid(module, mem_ctx, msg2, dom_dn);
+ ret = samldb_next_step(ac);
- if (ret == LDB_SUCCESS) {
- talloc_steal(msg, msg2);
- *ret_msg = msg2;
+done:
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL, ret);
}
- talloc_free(mem_ctx);
- return ret;
+
+ return LDB_SUCCESS;
}
-static int samldb_fill_user_or_computer_object(struct ldb_module *module, const struct ldb_message *msg, struct ldb_message **ret_msg)
+/* If we are adding new users/groups, we need to update the nextRid
+ * attribute to be 'above' the new/incoming RID. Attempt to do it
+ *atomically. */
+static int samldb_notice_sid(struct samldb_ctx *ac)
{
+ uint32_t old_id, new_id;
+ struct ldb_request *req;
+ struct ldb_message *msg;
+ struct ldb_message_element *els;
+ struct ldb_val *vals;
int ret;
- char *name;
- struct ldb_message *msg2;
- struct ldb_dn *dom_dn;
- const char *rdn_name;
- TALLOC_CTX *mem_ctx = talloc_new(msg);
- const char *errstr;
- unsigned int user_account_control;
- if (!mem_ctx) {
+
+ old_id = ac->next_rid;
+ new_id = ac->sid->sub_auths[ac->sid->num_auths - 1];
+
+ if (old_id >= new_id) {
+ /* no need to update the domain nextRid attribute */
+ return samldb_next_step(ac);
+ }
+
+ /* we do a delete and add as a single operation. That prevents
+ a race, in case we are not actually on a transaction db */
+ msg = talloc_zero(ac, struct ldb_message);
+ if (msg == NULL) {
+ ldb_oom(ac->module->ldb);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ els = talloc_array(msg, struct ldb_message_element, 2);
+ if (els == NULL) {
+ ldb_oom(ac->module->ldb);
return LDB_ERR_OPERATIONS_ERROR;
}
+ vals = talloc_array(msg, struct ldb_val, 2);
+ if (vals == NULL) {
+ ldb_oom(ac->module->ldb);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ msg->dn = ac->domain_dn;
+ msg->num_elements = 2;
+ msg->elements = els;
- /* build the new msg */
- msg2 = ldb_msg_copy(mem_ctx, msg);
- if (!msg2) {
- ldb_debug(module->ldb, LDB_DEBUG_FATAL, "samldb_fill_user_or_computer_object: ldb_msg_copy failed!\n");
- talloc_free(mem_ctx);
+ els[0].num_values = 1;
+ els[0].values = &vals[0];
+ els[0].flags = LDB_FLAG_MOD_DELETE;
+ els[0].name = talloc_strdup(msg, "nextRid");
+ if (!els[0].name) {
+ ldb_oom(ac->module->ldb);
return LDB_ERR_OPERATIONS_ERROR;
}
- ret = samdb_copy_template(module->ldb, msg2,
- "user",
- &errstr);
- if (ret) {
- ldb_asprintf_errstring(module->ldb,
- "samldb_fill_user_or_computer_object: Error copying user template: %s\n",
- errstr);
- talloc_free(mem_ctx);
+ 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 *)talloc_asprintf(vals, "%u", old_id);
+ if (!vals[0].data) {
+ ldb_oom(ac->module->ldb);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ vals[0].length = strlen((char *)vals[0].data);
+
+ vals[1].data = (uint8_t *)talloc_asprintf(vals, "%u", new_id);
+ if (!vals[1].data) {
+ ldb_oom(ac->module->ldb);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ vals[1].length = strlen((char *)vals[1].data);
+
+ ret = ldb_build_mod_req(&req, ac->module->ldb, ac,
+ msg, NULL,
+ ac, samldb_notice_sid_callback,
+ ac->req);
+ if (ret != LDB_SUCCESS) {
return ret;
}
- rdn_name = ldb_dn_get_rdn_name(msg2->dn);
+ return ldb_next_request(ac->module, req);
+}
- if (strcasecmp(rdn_name, "cn") != 0) {
- ldb_asprintf_errstring(module->ldb, "Bad RDN (%s=) for user/computer, should be CN=!\n", rdn_name);
- talloc_free(mem_ctx);
- return LDB_ERR_CONSTRAINT_VIOLATION;
+static int samldb_add_entry_callback(struct ldb_request *req,
+ struct ldb_reply *ares)
+{
+ struct samldb_ctx *ac;
+
+ ac = talloc_get_type(req->context, struct samldb_ctx);
+
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
+ if (ares->type != LDB_REPLY_DONE) {
+ ldb_set_errstring(ac->module->ldb,
+ "Invalid reply type!\n");
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
- ret = samdb_search_for_parent_domain(module->ldb, mem_ctx, msg2->dn, &dom_dn, &errstr);
+ /* we exit the samldb module here */
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, LDB_SUCCESS);
+}
+
+static int samldb_add_entry(struct samldb_ctx *ac)
+{
+ struct ldb_request *req;
+ int ret;
+
+ ret = ldb_build_add_req(&req, ac->module->ldb, ac,
+ ac->msg,
+ ac->req->controls,
+ ac, samldb_add_entry_callback,
+ ac->req);
if (ret != LDB_SUCCESS) {
- ldb_asprintf_errstring(module->ldb,
- "samldb_fill_user_or_computer_object: %s", errstr);
return ret;
}
- if (ldb_msg_find_element(msg2, "samAccountName") == NULL) {
- ret = samldb_generate_samAccountName(module, mem_ctx, dom_dn, &name);
- if (ret != LDB_SUCCESS) {
- talloc_free(mem_ctx);
- return ret;
- }
- ret = samdb_find_or_add_attribute(module->ldb, msg2, "sAMAccountName", name);
- if (ret) {
- talloc_free(mem_ctx);
- return ret;
- }
+ return ldb_next_request(ac->module, req);
+}
+
+static int samldb_fill_object(struct samldb_ctx *ac, const char *type)
+{
+ int ret;
+
+ /* first look for the template */
+ ac->type = type;
+ ret = samldb_add_step(ac, samldb_search_template);
+ if (ret != LDB_SUCCESS) return ret;
+
+ /* then apply it */
+ ret = samldb_add_step(ac, samldb_apply_template);
+ if (ret != LDB_SUCCESS) return ret;
+
+ /* search for a parent domain objet */
+ ac->check_dn = ac->req->op.add.message->dn;
+ ret = samldb_add_step(ac, samldb_get_parent_domain);
+ if (ret != LDB_SUCCESS) return ret;
+
+ /* check if we have a valid samAccountName */
+ ret = samldb_add_step(ac, samldb_check_samAccountName);
+ if (ret != LDB_SUCCESS) return ret;
+
+ /* check account_type/group_type */
+ ret = samldb_add_step(ac, samldb_check_samAccountType);
+ if (ret != LDB_SUCCESS) return ret;
+
+ /* check if we have a valid SID */
+ ac->sid = samdb_result_dom_sid(ac, ac->msg, "objectSid");
+ if ( ! ac->sid) {
+ ret = samldb_add_step(ac, samldb_new_sid);
+ if (ret != LDB_SUCCESS) return ret;
+ } else {
+ ret = samldb_add_step(ac, samldb_get_sid_domain);
+ if (ret != LDB_SUCCESS) return ret;
}
- if (ldb_msg_find_element(msg2, "sAMAccountType") != NULL) {
- ldb_asprintf_errstring(module->ldb, "sAMAccountType must not be specified");
- talloc_free(mem_ctx);
- return LDB_ERR_UNWILLING_TO_PERFORM;
+ ret = samldb_add_step(ac, samldb_check_sid);
+ if (ret != LDB_SUCCESS) return ret;
+
+ ret = samldb_add_step(ac, samldb_notice_sid);
+ if (ret != LDB_SUCCESS) return ret;
+
+ /* finally proceed with adding the entry */
+ ret = samldb_add_step(ac, samldb_add_entry);
+ if (ret != LDB_SUCCESS) return ret;
+
+ return samldb_first_step(ac);
+
+ /* TODO: userAccountControl, badPwdCount, codePage,
+ * countryCode, badPasswordTime, lastLogoff, lastLogon,
+ * pwdLastSet, primaryGroupID, accountExpires, logonCount */
+
+}
+
+static int samldb_foreign_notice_sid_callback(struct ldb_request *req,
+ struct ldb_reply *ares)
+{
+ struct samldb_ctx *ac;
+ const char *nextRid;
+ const char *name;
+ int ret;
+
+ ac = talloc_get_type(req->context, struct samldb_ctx);
+
+ if (!ares) {
+ ret = LDB_ERR_OPERATIONS_ERROR;
+ goto done;
}
- user_account_control = samdb_result_uint(msg2, "userAccountControl", 0);
- if (user_account_control == 0) {
- ldb_asprintf_errstring(module->ldb, "userAccountControl invalid");
- talloc_free(mem_ctx);
- return LDB_ERR_UNWILLING_TO_PERFORM;
- } else {
- unsigned int account_type = samdb_uf2atype(user_account_control);
- ret = samdb_msg_add_uint(module->ldb, msg2, msg2,
- "sAMAccountType",
- account_type);
- if (ret != LDB_SUCCESS) {
- return ret;
- }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
}
- /* Manage SID allocation, conflicts etc */
- ret = samldb_handle_sid(module, mem_ctx, msg2, dom_dn);
+ switch (ares->type) {
+ case LDB_REPLY_ENTRY:
+ /* save entry */
+ if (ac->next_rid != 0) {
+ /* one too many! */
+ ldb_set_errstring(ac->module->ldb,
+ "Invalid number of results while searching "
+ "for domain object");
+ ret = LDB_ERR_OPERATIONS_ERROR;
+ break;
+ }
- /* TODO: userAccountControl, badPwdCount, codePage, countryCode, badPasswordTime, lastLogoff, lastLogon, pwdLastSet, primaryGroupID, accountExpires, logonCount */
+ nextRid = ldb_msg_find_attr_as_string(ares->message,
+ "nextRid", NULL);
+ if (nextRid == NULL) {
+ ldb_asprintf_errstring(ac->module->ldb,
+ "attribute nextRid not found in %s\n",
+ ldb_dn_get_linearized(ares->message->dn));
+ ret = LDB_ERR_OPERATIONS_ERROR;
+ break;
+ }
+
+ ac->next_rid = strtol(nextRid, NULL, 0);
+
+ ac->domain_dn = talloc_steal(ac, ares->message->dn);
+
+ name = samdb_result_string(ares->message, "name", NULL);
+ ldb_debug(ac->module->ldb, LDB_DEBUG_TRACE,
+ "NOTE (strange but valid): Adding foreign SID "
+ "record with SID %s, but this domain (%s) is "
+ "not foreign in the database",
+ dom_sid_string(ares, ac->sid), name);
- if (ret == 0) {
- *ret_msg = msg2;
- talloc_steal(msg, msg2);
+ talloc_free(ares);
+ break;
+
+ case LDB_REPLY_REFERRAL:
+ /* ignore */
+ talloc_free(ares);
+ break;
+
+ case LDB_REPLY_DONE:
+
+ /* if this is a fake foreign SID, notice the SID */
+ if (ac->domain_dn) {
+ ret = samldb_notice_sid(ac);
+ break;
+ }
+
+ /* found, go on */
+ ret = samldb_next_step(ac);
+ break;
+ }
+
+done:
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL, ret);
}
- talloc_free(mem_ctx);
- return ret;
+
+ return LDB_SUCCESS;
}
-
-static int samldb_fill_foreignSecurityPrincipal_object(struct ldb_module *module, const struct ldb_message *msg,
- struct ldb_message **ret_msg)
+
+/* Find a domain object in the parents of a particular DN. */
+static int samldb_foreign_notice_sid(struct samldb_ctx *ac)
{
- struct ldb_message *msg2;
- const char *rdn_name;
- struct dom_sid *dom_sid;
- struct dom_sid *sid;
- const char *dom_attrs[] = { "name", NULL };
- struct ldb_message **dom_msgs;
- const char *errstr;
+ static const char * const attrs[3] = { "nextRid", "name", NULL };
+ struct ldb_request *req;
+ char *filter;
int ret;
- TALLOC_CTX *mem_ctx = talloc_new(msg);
- if (!mem_ctx) {
+ if (ac->sid == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
- /* build the new msg */
- msg2 = ldb_msg_copy(mem_ctx, msg);
- if (!msg2) {
- ldb_debug(module->ldb, LDB_DEBUG_FATAL, "samldb_fill_foreignSecurityPrincipal_object: ldb_msg_copy failed!\n");
- talloc_free(mem_ctx);
+ ac->domain_sid = dom_sid_dup(ac, ac->sid);
+ if (!ac->domain_sid) {
return LDB_ERR_OPERATIONS_ERROR;
}
+ /* get the domain component part of the provided SID */
+ ac->domain_sid->num_auths--;
- ret = samdb_copy_template(module->ldb, msg2,
- "ForeignSecurityPrincipal",
- &errstr);
- if (ret != 0) {
- ldb_asprintf_errstring(module->ldb,
- "samldb_fill_foreignSecurityPrincipal_object: "
- "Error copying template: %s",
- errstr);
- talloc_free(mem_ctx);
- return ret;
+ filter = talloc_asprintf(ac, "(&(objectSid=%s)(objectclass=domain))",
+ ldap_encode_ndr_dom_sid(ac, ac->domain_sid));
+ if (filter == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
}
- rdn_name = ldb_dn_get_rdn_name(msg2->dn);
+ ret = ldb_build_search_req(&req, ac->module->ldb, ac,
+ ldb_get_default_basedn(ac->module->ldb),
+ LDB_SCOPE_SUBTREE,
+ filter, attrs,
+ NULL,
+ ac, samldb_foreign_notice_sid_callback,
+ ac->req);
- if (strcasecmp(rdn_name, "cn") != 0) {
- ldb_asprintf_errstring(module->ldb, "Bad RDN (%s=) for ForeignSecurityPrincipal, should be CN=!", rdn_name);
- talloc_free(mem_ctx);
- return LDB_ERR_CONSTRAINT_VIOLATION;
+ if (ret != LDB_SUCCESS) {
+ return ret;
}
- sid = samdb_result_dom_sid(msg2, msg, "objectSid");
- if (!sid) {
- /* Slightly different for the foreign sids. We don't want
- * domain SIDs ending up there, it would cause all sorts of
- * pain */
-
- sid = dom_sid_parse_talloc(msg2, (const char *)ldb_dn_get_rdn_val(msg2->dn)->data);
- if (!sid) {
- ldb_set_errstring(module->ldb, "No valid found SID in ForeignSecurityPrincipal CN!");
- talloc_free(mem_ctx);
- return LDB_ERR_CONSTRAINT_VIOLATION;
- }
+ ac->next_rid = 0;
+ return ldb_next_request(ac->module, req);
+}
- if ( ! samldb_msg_add_sid(module, msg2, "objectSid", sid)) {
- talloc_free(sid);
- return LDB_ERR_OPERATIONS_ERROR;
- }
+static int samldb_fill_foreignSecurityPrincipal_object(struct samldb_ctx *ac)
+{
+ int ret;
- dom_sid = dom_sid_dup(mem_ctx, sid);
- if (!dom_sid) {
- talloc_free(mem_ctx);
- return LDB_ERR_OPERATIONS_ERROR;
+ ac->sid = samdb_result_dom_sid(ac->msg, ac->msg, "objectSid");
+ if (ac->sid == NULL) {
+ ac->sid = dom_sid_parse_talloc(ac->msg,
+ (const char *)ldb_dn_get_rdn_val(ac->msg->dn)->data);
+ if (!ac->sid) {
+ ldb_set_errstring(ac->module->ldb,
+ "No valid found SID in "
+ "ForeignSecurityPrincipal CN!");
+ talloc_free(ac);
+ return LDB_ERR_CONSTRAINT_VIOLATION;
}
- /* get the domain component part of the provided SID */
- dom_sid->num_auths--;
-
- /* find the domain DN */
-
- ret = gendb_search(module->ldb,
- mem_ctx, NULL, &dom_msgs, dom_attrs,
- "(&(objectSid=%s)(objectclass=domain))",
- ldap_encode_ndr_dom_sid(mem_ctx, dom_sid));
- if (ret >= 1) {
- /* We don't really like the idea of foreign sids that are not foreign, but it happens */
- const char *name = samdb_result_string(dom_msgs[0], "name", NULL);
- ldb_debug(module->ldb, LDB_DEBUG_TRACE, "NOTE (strange but valid): Adding foreign SID record with SID %s, but this domian (%s) is already in the database",
- dom_sid_string(mem_ctx, sid), name);
- } else if (ret == -1) {
- ldb_asprintf_errstring(module->ldb,
- "samldb_fill_foreignSecurityPrincipal_object: error searching for a domain with this sid: %s\n",
- dom_sid_string(mem_ctx, dom_sid));
- talloc_free(dom_msgs);
+ if ( ! samldb_msg_add_sid(ac->msg, "objectSid", ac->sid)) {
+ talloc_free(ac);
return LDB_ERR_OPERATIONS_ERROR;
}
}
- /* This isn't an operation on a domain we know about, so just
- * check for the SID, looking for duplicates via the common
- * code */
- ret = samldb_notice_sid(module, msg2, sid);
- if (ret == 0) {
- talloc_steal(msg, msg2);
- *ret_msg = msg2;
- }
-
- return ret;
+ /* first look for the template */
+ ac->type = "foreignSecurityPrincipal";
+ ret = samldb_add_step(ac, samldb_search_template);
+ if (ret != LDB_SUCCESS) return ret;
+
+ /* then apply it */
+ ret = samldb_add_step(ac, samldb_apply_template);
+ if (ret != LDB_SUCCESS) return ret;
+
+ /* check we do not already have this SID */
+ ret = samldb_add_step(ac, samldb_check_sid);
+ if (ret != LDB_SUCCESS) return ret;
+
+ /* check if we need to notice this SID */
+ ret = samldb_add_step(ac, samldb_foreign_notice_sid);
+ if (ret != LDB_SUCCESS) return ret;
+
+ /* finally proceed with adding the entry */
+ ret = samldb_add_step(ac, samldb_add_entry);
+ if (ret != LDB_SUCCESS) return ret;
+
+ return samldb_first_step(ac);
}
-/* add_record */
+static int samldb_check_rdn(struct ldb_module *module, struct ldb_dn *dn)
+{
+ const char *rdn_name;
-/*
- * FIXME
- *
- * Actually this module is not async at all as it does a number of sync searches
- * in the process. It still to be decided how to deal with it properly so it is
- * left SYNC for now until we think of a good solution.
- */
+ rdn_name = ldb_dn_get_rdn_name(dn);
+
+ if (strcasecmp(rdn_name, "cn") != 0) {
+ ldb_asprintf_errstring(module->ldb,
+ "Bad RDN (%s=) for samldb object, "
+ "should be CN=!\n", rdn_name);
+ return LDB_ERR_CONSTRAINT_VIOLATION;
+ }
+ return LDB_SUCCESS;
+}
+
+/* add_record */
static int samldb_add(struct ldb_module *module, struct ldb_request *req)
{
- const struct ldb_message *msg = req->op.add.message;
- struct ldb_message *msg2 = NULL;
- struct ldb_request *down_req;
+ struct samldb_ctx *ac;
int ret;
ldb_debug(module->ldb, LDB_DEBUG_TRACE, "samldb_add_record\n");
- if (ldb_dn_is_special(msg->dn)) { /* do not manipulate our control entries */
+ /* do not manipulate our control entries */
+ if (ldb_dn_is_special(req->op.add.message->dn)) {
return ldb_next_request(module, req);
}
- /* is user or computer? */
- if ((samdb_find_attribute(module->ldb, msg, "objectclass", "user") != NULL) ||
- (samdb_find_attribute(module->ldb, msg, "objectclass", "computer") != NULL)) {
- /* add all relevant missing objects */
- ret = samldb_fill_user_or_computer_object(module, msg, &msg2);
- if (ret) {
- return ret;
- }
+ ac = samldb_ctx_init(module, req);
+ if (ac == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
}
- /* is group? add all relevant missing objects */
- if ( ! msg2 ) {
- if (samdb_find_attribute(module->ldb, msg, "objectclass", "group") != NULL) {
- ret = samldb_fill_group_object(module, msg, &msg2);
- if (ret) {
- return ret;
- }
- }
+ /* build the new msg */
+ ac->msg = ldb_msg_copy(ac, ac->req->op.add.message);
+ if (!ac->msg) {
+ talloc_free(ac);
+ ldb_debug(ac->module->ldb, LDB_DEBUG_FATAL,
+ "samldb_add: ldb_msg_copy failed!\n");
+ return LDB_ERR_OPERATIONS_ERROR;
}
- /* perhaps a foreignSecurityPrincipal? */
- if ( ! msg2 ) {
- if (samdb_find_attribute(module->ldb, msg, "objectclass", "foreignSecurityPrincipal") != NULL) {
- ret = samldb_fill_foreignSecurityPrincipal_object(module, msg, &msg2);
- if (ret) {
- return ret;
- }
+ if (samdb_find_attribute(module->ldb, ac->msg,
+ "objectclass", "computer") != NULL) {
+
+ /* make sure the computer object also has the 'user'
+ * objectclass so it will be handled by the next call */
+ ret = samdb_find_or_add_value(module->ldb, ac->msg,
+ "objectclass", "user");
+ if (ret != LDB_SUCCESS) {
+ talloc_free(ac);
+ return ret;
}
}
- if (msg2 == NULL) {
- return ldb_next_request(module, req);
- }
+ if (samdb_find_attribute(module->ldb, ac->msg,
+ "objectclass", "user") != NULL) {
- down_req = talloc(req, struct ldb_request);
- if (down_req == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ ret = samldb_check_rdn(module, ac->req->op.add.message->dn);
+ if (ret != LDB_SUCCESS) {
+ talloc_free(ac);
+ return ret;
+ }
+
+ return samldb_fill_object(ac, "user");
}
- *down_req = *req;
-
- down_req->op.add.message = talloc_steal(down_req, msg2);
+ if (samdb_find_attribute(module->ldb, ac->msg,
+ "objectclass", "group") != NULL) {
+
+ ret = samldb_check_rdn(module, ac->req->op.add.message->dn);
+ if (ret != LDB_SUCCESS) {
+ talloc_free(ac);
+ return ret;
+ }
- ldb_set_timeout_from_prev_req(module->ldb, req, down_req);
+ return samldb_fill_object(ac, "group");
+ }
- /* go on with the call chain */
- ret = ldb_next_request(module, down_req);
+ /* perhaps a foreignSecurityPrincipal? */
+ if (samdb_find_attribute(module->ldb, ac->msg,
+ "objectclass",
+ "foreignSecurityPrincipal") != NULL) {
- /* do not free down_req as the call results may be linked to it,
- * it will be freed when the upper level request get freed */
- if (ret == LDB_SUCCESS) {
- req->handle = down_req->handle;
+ ret = samldb_check_rdn(module, ac->req->op.add.message->dn);
+ if (ret != LDB_SUCCESS) {
+ talloc_free(ac);
+ return ret;
+ }
+
+ return samldb_fill_foreignSecurityPrincipal_object(ac);
}
- return ret;
+ talloc_free(ac);
+
+ /* nothing matched, go on */
+ return ldb_next_request(module, req);
}
/* modify */
return LDB_ERR_UNWILLING_TO_PERFORM;
}
+ /* TODO: do not modify original request, create a new one */
+
el = ldb_msg_find_element(req->op.mod.message, "groupType");
if (el && el->flags & (LDB_FLAG_MOD_ADD|LDB_FLAG_MOD_REPLACE) && el->num_values == 1) {
req->op.mod.message = msg = ldb_msg_copy_shallow(req, req->op.mod.message);
};
struct schema_fsmo_search_data {
- struct schema_fsmo_private_data *module_context;
- struct ldb_request *orig_req;
+ struct ldb_module *module;
+ struct ldb_request *req;
+
+ const struct dsdb_schema *schema;
};
static int schema_fsmo_init(struct ldb_module *module)
uint32_t id32;
WERROR status;
+ /* special objects should always go through */
+ if (ldb_dn_is_special(req->op.add.message->dn)) {
+ return ldb_next_request(module, req);
+ }
+
+ /* replicated update should always go through */
+ if (ldb_request_get_control(req, DSDB_CONTROL_REPLICATED_UPDATE_OID)) {
+ return ldb_next_request(module, req);
+ }
+
schema = dsdb_get_schema(module->ldb);
if (!schema) {
return ldb_next_request(module, req);
/* Add objectClasses, attributeTypes and dITContentRules from the
schema object (they are not stored in the database)
*/
-static int schema_fsmo_search_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
+static int schema_fsmo_search_callback(struct ldb_request *req, struct ldb_reply *ares)
{
- const struct dsdb_schema *schema = dsdb_get_schema(ldb);
- struct schema_fsmo_search_data *search_data = talloc_get_type(context, struct schema_fsmo_search_data);
- struct ldb_request *orig_req = search_data->orig_req;
- TALLOC_CTX *mem_ctx;
+ struct schema_fsmo_search_data *ac;
+ struct schema_fsmo_private_data *mc;
int i, ret;
- /* Only entries are interesting, and we handle the case of the parent seperatly */
- if (ares->type != LDB_REPLY_ENTRY) {
- return orig_req->callback(ldb, orig_req->context, ares);
- }
+ ac = talloc_get_type(req->context, struct schema_fsmo_search_data);
+ mc = talloc_get_type(ac->module->private_data, struct schema_fsmo_private_data);
- if (ldb_dn_compare(ares->message->dn, search_data->module_context->aggregate_dn) != 0) {
- talloc_free(mem_ctx);
- return orig_req->callback(ldb, orig_req->context, ares);
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
-
- mem_ctx = talloc_new(ares);
- if (!mem_ctx) {
- ldb_oom(ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
}
+ /* Only entries are interesting, and we handle the case of the parent seperatly */
- for (i=0; i < ARRAY_SIZE(generated_attrs); i++) {
- if (ldb_attr_in_list(orig_req->op.search.attrs, generated_attrs[i].attr)) {
- ret = generated_attrs[i].fn(ldb, ares->message, schema);
- if (ret != LDB_SUCCESS) {
- return ret;
+ switch (ares->type) {
+ case LDB_REPLY_ENTRY:
+
+ if (ldb_dn_compare(ares->message->dn, mc->aggregate_dn) != 0) {
+ return ldb_module_send_entry(ac->req, ares->message);
+ }
+
+ for (i=0; i < ARRAY_SIZE(generated_attrs); i++) {
+ if (ldb_attr_in_list(ac->req->op.search.attrs, generated_attrs[i].attr)) {
+ ret = generated_attrs[i].fn(ac->module->ldb, ares->message, ac->schema);
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
}
}
+
+ return ldb_module_send_entry(ac->req, ares->message);
+
+ case LDB_REPLY_REFERRAL:
+
+ return ldb_module_send_referral(ac->req, ares->referral);
+
+ case LDB_REPLY_DONE:
+
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
}
- talloc_free(mem_ctx);
- return orig_req->callback(ldb, orig_req->context, ares);
+ return LDB_SUCCESS;
}
/* search */
ldb_oom(module->ldb);
return LDB_ERR_OPERATIONS_ERROR;
}
- down_req = talloc(req, struct ldb_request);
- if (!down_req) {
- ldb_oom(module->ldb);
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- *down_req = *req;
- search_context->orig_req = req;
- search_context->module_context = talloc_get_type(module->private_data, struct schema_fsmo_private_data);
- down_req->context = search_context;
- down_req->callback = schema_fsmo_search_callback;
+ search_context->module = module;
+ search_context->req = req;
+ search_context->schema = schema;
- ret = ldb_next_request(module, down_req);
-
- /* do not free down_req as the call results may be linked to it,
- * it will be freed when the upper level request get freed */
- if (ret == LDB_SUCCESS) {
- req->handle = down_req->handle;
+ ret = ldb_build_search_req_ex(&down_req, module->ldb, search_context,
+ req->op.search.base,
+ req->op.search.scope,
+ req->op.search.tree,
+ req->op.search.attrs,
+ req->controls,
+ search_context, schema_fsmo_search_callback,
+ req);
+ if (ret != LDB_SUCCESS) {
+ return LDB_ERR_OPERATIONS_ERROR;
}
- return ret;
+
+ return ldb_next_request(module, down_req);
}
*
* Component: ldb deleted objects control module
*
- * Description: this module hides deleted objects, and returns them if the control is there
+ * Description: this module hides deleted objects, and returns them if the right control is there
*
* Author: Stefan Metzmacher
*/
struct show_deleted_search_request {
struct ldb_module *module;
- void *up_context;
- int (*up_callback)(struct ldb_context *, void *, struct ldb_reply *);
-
- bool remove_from_msg;
+ struct ldb_request *req;
};
-static int show_deleted_search_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
+static int show_deleted_search_callback(struct ldb_request *req,
+ struct ldb_reply *ares)
{
struct show_deleted_search_request *ar;
- ar = talloc_get_type(context, struct show_deleted_search_request);
+ ar = talloc_get_type(req->context, struct show_deleted_search_request);
- if (ares->type == LDB_REPLY_ENTRY) {
- bool isDeleted;
+ if (!ares) {
+ return ldb_module_done(ar->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ar->req, ares->controls,
+ ares->response, ares->error);
+ }
- isDeleted = ldb_msg_find_attr_as_bool(ares->message, "isDeleted", false);
+ switch (ares->type) {
+ case LDB_REPLY_ENTRY:
- if (isDeleted) {
- goto skip_deleted;
- }
+ return ldb_module_send_entry(ar->req, ares->message);
- if (ar->remove_from_msg) {
- ldb_msg_remove_attr(ares->message, "isDeleted");
- }
- }
+ case LDB_REPLY_REFERRAL:
+ return ldb_module_send_referral(ar->req, ares->referral);
- return ar->up_callback(ldb, ar->up_context, ares);
+ case LDB_REPLY_DONE:
+ return ldb_module_done(ar->req, ares->controls,
+ ares->response, LDB_SUCCESS);
-skip_deleted:
- talloc_free(ares);
+ }
return LDB_SUCCESS;
}
struct ldb_control **saved_controls;
struct show_deleted_search_request *ar;
struct ldb_request *down_req;
- char **new_attrs;
- uint32_t num_attrs = 0;
- uint32_t i;
+ char *old_filter;
+ char *new_filter;
int ret;
- /* check if there's a show deleted control */
- control = ldb_request_get_control(req, LDB_CONTROL_SHOW_DELETED_OID);
-
- /* copy the request for modification */
- down_req = talloc(req, struct ldb_request);
- if (down_req == NULL) {
- ldb_oom(module->ldb);
+ ar = talloc_zero(req, struct show_deleted_search_request);
+ if (ar == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
+ ar->module = module;
+ ar->req = req;
- /* copy the request */
- *down_req = *req;
+ /* check if there's a show deleted control */
+ control = ldb_request_get_control(req, LDB_CONTROL_SHOW_DELETED_OID);
- /* if a control is there remove if from the modified request */
- if (control && !save_controls(control, down_req, &saved_controls)) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
+ if ( ! control) {
+ old_filter = ldb_filter_from_tree(ar, req->op.search.tree);
+ new_filter = talloc_asprintf(ar, "(&(!(isDeleted=TRUE))%s)",
+ old_filter);
- /* if we had a control, then just go on to the next request as we have nothing to hide */
- if (control) {
- goto next_request;
- }
+ ret = ldb_build_search_req(&down_req, module->ldb, ar,
+ req->op.search.base,
+ req->op.search.scope,
+ new_filter,
+ req->op.search.attrs,
+ req->controls,
+ ar, show_deleted_search_callback,
+ req);
- ar = talloc(down_req, struct show_deleted_search_request);
- if (ar == NULL) {
- ldb_oom(module->ldb);
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- ar->module = module;
- ar->up_context = req->context;
- ar->up_callback = req->callback;
- ar->remove_from_msg = true;
-
- /* check if attrs only is specified, in that case check wether we need to modify them */
- if (down_req->op.search.attrs) {
- for (i=0; (down_req->op.search.attrs && down_req->op.search.attrs[i]); i++) {
- num_attrs++;
- if (strcasecmp(down_req->op.search.attrs[i], "*") == 0) {
- ar->remove_from_msg = false;
- } else if (strcasecmp(down_req->op.search.attrs[i], "isDeleted") == 0) {
- ar->remove_from_msg = false;
- }
- }
} else {
- ar->remove_from_msg = false;
+ ret = ldb_build_search_req_ex(&down_req, module->ldb, ar,
+ req->op.search.base,
+ req->op.search.scope,
+ req->op.search.tree,
+ req->op.search.attrs,
+ req->controls,
+ ar, show_deleted_search_callback,
+ req);
}
-
- if (ar->remove_from_msg) {
- new_attrs = talloc_array(down_req, char *, num_attrs + 2);
- if (!new_attrs) {
- ldb_oom(module->ldb);
- return LDB_ERR_OPERATIONS_ERROR;
- }
- for (i=0; i < num_attrs; i++) {
- new_attrs[i] = discard_const_p(char, down_req->op.search.attrs[i]);
- }
- new_attrs[i] = talloc_strdup(new_attrs, "isDeleted");
- if (!new_attrs[i]) {
- ldb_oom(module->ldb);
- return LDB_ERR_OPERATIONS_ERROR;
- }
- new_attrs[i+1] = NULL;
- down_req->op.search.attrs = (const char * const *)new_attrs;
+ if (ret != LDB_SUCCESS) {
+ return ret;
}
- down_req->context = ar;
- down_req->callback = show_deleted_search_callback;
- ldb_set_timeout_from_prev_req(module->ldb, req, down_req);
-
-next_request:
- /* perform the search */
- ret = ldb_next_request(module, down_req);
-
- /* do not free down_req as the call results may be linked to it,
- * it will be freed when the upper level request get freed */
- if (ret == LDB_SUCCESS) {
- req->handle = down_req->handle;
+ /* if a control is there remove if from the modified request */
+ if (control && !save_controls(control, down_req, &saved_controls)) {
+ return LDB_ERR_OPERATIONS_ERROR;
}
- return ret;
+ /* perform the search */
+ return ldb_next_request(module, down_req);
}
static int show_deleted_init(struct ldb_module *module)
{
- struct ldb_request *req;
int ret;
- req = talloc(module, struct ldb_request);
- if (req == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- req->operation = LDB_REQ_REGISTER_CONTROL;
- req->op.reg_control.oid = LDB_CONTROL_SHOW_DELETED_OID;
- req->controls = NULL;
-
- ret = ldb_request(module->ldb, req);
+ ret = ldb_mod_register_control(module, LDB_CONTROL_SHOW_DELETED_OID);
if (ret != LDB_SUCCESS) {
- ldb_debug(module->ldb, LDB_DEBUG_ERROR, "show_deleted: Unable to register control with rootdse!\n");
- talloc_free(req);
+ ldb_debug(module->ldb, LDB_DEBUG_ERROR,
+ "extended_dn: Unable to register control with rootdse!\n");
return LDB_ERR_OPERATIONS_ERROR;
}
- talloc_free(req);
return ldb_next_init(module);
}
#include "librpc/ndr/libndr.h"
#include "dsdb/samdb/samdb.h"
+struct entryuuid_private {
+ struct ldb_context *ldb;
+ struct ldb_dn **base_dns;
+};
+
static struct ldb_val encode_guid(struct ldb_module *module, TALLOC_CTX *ctx, const struct ldb_val *val)
{
struct GUID guid;
return ldb_next_init(module);
}
-static int get_seq(struct ldb_context *ldb, void *context,
- struct ldb_reply *ares)
+static int get_seq(struct ldb_request *req,
+ struct ldb_reply *ares)
{
- unsigned long long *seq = (unsigned long long *)context;
+ unsigned long long *seq = (unsigned long long *)req->context;
if (ares->type == LDB_REPLY_ENTRY) {
struct ldb_message_element *el = ldb_msg_find_element(ares->message, "contextCSN");
if (el) {
}
}
+ if (ares->type == LDB_REPLY_DONE) {
+ return ldb_request_done(req, LDB_SUCCESS);
+ }
+
return LDB_SUCCESS;
}
partition_ctrl = ldb_request_get_control(req, DSDB_CONTROL_CURRENT_PARTITION_OID);
if (!partition_ctrl) {
ldb_debug_set(module->ldb, LDB_DEBUG_FATAL,
- "instancetype_add: no current partition control found");
+ "entryuuid_sequence_number: no current partition control found");
return LDB_ERR_CONSTRAINT_VIOLATION;
}
struct dsdb_control_current_partition);
SMB_ASSERT(partition && partition->version == DSDB_CONTROL_CURRENT_PARTITION_VERSION);
- search_req = talloc(req, struct ldb_request);
- if (search_req == NULL) {
- ldb_set_errstring(module->ldb, "Out of Memory");
- return LDB_ERR_OPERATIONS_ERROR;
+ ret = ldb_build_search_req(&search_req, module->ldb, req,
+ partition->dn, LDB_SCOPE_BASE,
+ NULL, contextCSN_attr, NULL,
+ &seq, get_seq,
+ NULL);
+ if (ret != LDB_SUCCESS) {
+ return ret;
}
-
- /* Finally, we have it. This saves searching over more
- * partitions than we expose to the client, such as a cn=samba
- * configuration partition */
- search_req->operation = LDB_SEARCH;
- search_req->op.search.base = partition->dn;
- search_req->op.search.scope = LDB_SCOPE_BASE;
-
- search_req->op.search.tree = ldb_parse_tree(search_req, "objectClass=*");
- if (search_req->op.search.tree == NULL) {
- ldb_set_errstring(module->ldb, "Unable to parse search expression");
- talloc_free(search_req);
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- search_req->op.search.attrs = contextCSN_attr;
- search_req->controls = NULL;
- search_req->context = &seq;
- search_req->callback = get_seq;
- ldb_set_timeout(module->ldb, search_req, 0); /* use default timeout */
-
ret = ldb_next_request(module, search_req);
-
+
if (ret == LDB_SUCCESS) {
ret = ldb_wait(search_req->handle, LDB_WAIT_ALL);
}
-
+
talloc_free(search_req);
if (ret != LDB_SUCCESS) {
return ret;
Copyright (C) Andrew Bartlett <abartlet@samba.org> 2006-2007
Copyright (C) Stefan Metzmacher <metze@samba.org> 2007
+ Copyright (C) Simo Sorce <idra@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
#include "ldb_includes.h"
struct subtree_delete_context {
- enum sd_step {SD_SEARCH, SD_DO_DEL} step;
-
struct ldb_module *module;
- struct ldb_handle *handle;
- struct ldb_request *orig_req;
-
- struct ldb_request *search_req;
- struct ldb_request *down_req;
+ struct ldb_request *req;
int num_children;
};
-static struct subtree_delete_context *subtree_delete_init_handle(struct ldb_request *req,
- struct ldb_module *module)
+static struct subtree_delete_context *subdel_ctx_init(struct ldb_module *module,
+ struct ldb_request *req)
{
struct subtree_delete_context *ac;
- struct ldb_handle *h;
-
- h = talloc_zero(req, struct ldb_handle);
- if (h == NULL) {
- ldb_set_errstring(module->ldb, "Out of Memory");
- return NULL;
- }
-
- h->module = module;
- ac = talloc_zero(h, struct subtree_delete_context);
+ ac = talloc_zero(req, struct subtree_delete_context);
if (ac == NULL) {
- ldb_set_errstring(module->ldb, "Out of Memory");
- talloc_free(h);
+ ldb_oom(module->ldb);
return NULL;
}
- h->private_data = ac;
-
ac->module = module;
- ac->handle = h;
- ac->orig_req = req;
-
- req->handle = h;
+ ac->req = req;
return ac;
}
-static int subtree_delete_check_for_children(struct subtree_delete_context *ac)
+static int subtree_delete_search_callback(struct ldb_request *req,
+ struct ldb_reply *ares)
{
- if (ac->num_children > 0) {
- ldb_asprintf_errstring(ac->module->ldb, "Cannot delete %s, not a leaf node (has %d children)\n",
- ldb_dn_get_linearized(ac->orig_req->op.del.dn), ac->num_children);
- return LDB_ERR_NOT_ALLOWED_ON_NON_LEAF;
- } else {
- struct ldb_request *req = talloc(ac, struct ldb_request);
- if (!req) {
- ldb_oom(ac->module->ldb);
- return LDB_ERR_OPERATIONS_ERROR;
- }
- *req = *ac->orig_req;
-
- /* Ensure any (io) errors during the search for
- * children don't propgate back in the error string */
- ldb_set_errstring(ac->module->ldb, NULL);
+ struct subtree_delete_context *ac;
+ int ret;
- ac->down_req = req;
- ac->step = SD_DO_DEL;
- return ldb_next_request(ac->module, req);
- }
-}
+ ac = talloc_get_type(req->context, struct subtree_delete_context);
-static int subtree_delete_search_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
-{
- struct subtree_delete_context *ac = talloc_get_type(context, struct subtree_delete_context);
- TALLOC_CTX *mem_ctx = talloc_new(ac);
-
- if (!mem_ctx) {
- ldb_oom(ac->module->ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
}
- /* OK, we have one of *many* search results here:
- We should also get the entry we tried to rename. This
- callback handles this and everything below it.
- */
+ switch (ares->type) {
+ case LDB_REPLY_ENTRY:
- /* Only entries are interesting, and we handle the case of the parent seperatly */
- if (ares->type == LDB_REPLY_ENTRY
- && ldb_dn_compare(ares->message->dn, ac->orig_req->op.del.dn) != 0) {
- /* And it is an actual entry: now object bitterly that we are not a leaf node */
+ talloc_free(ares);
ac->num_children++;
+ break;
+
+ case LDB_REPLY_REFERRAL:
+
+ /* ignore */
+ talloc_free(ares);
+ break;
+
+ case LDB_REPLY_DONE:
+
+ if (ac->num_children > 0) {
+ talloc_free(ares);
+ ldb_asprintf_errstring(ac->module->ldb,
+ "Cannot delete %s, not a leaf node "
+ "(has %d children)\n",
+ ldb_dn_get_linearized(ac->req->op.del.dn),
+ ac->num_children);
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_NOT_ALLOWED_ON_NON_LEAF);
+ }
+
+ /* ok no children, let the original request through */
+ ret = ldb_next_request(ac->module, ac->req);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL, ret);
+ }
+
+ /* free our own context we are not going to be called back */
+ talloc_free(ac);
}
- talloc_free(ares);
return LDB_SUCCESS;
}
-/* rename */
static int subtree_delete(struct ldb_module *module, struct ldb_request *req)
{
- const char *attrs[] = { NULL };
- struct ldb_request *new_req;
+ static const char * const attrs[2] = { "distinguishedName", NULL };
+ struct ldb_request *search_req;
struct subtree_delete_context *ac;
int ret;
if (ldb_dn_is_special(req->op.rename.olddn)) { /* do not manipulate our control entries */
- return an error if there are any
*/
- ac = subtree_delete_init_handle(req, module);
+ ac = subdel_ctx_init(module, req);
if (!ac) {
return LDB_ERR_OPERATIONS_ERROR;
}
- ret = ldb_build_search_req(&new_req, module->ldb, req,
- req->op.del.dn,
- LDB_SCOPE_SUBTREE,
- "(objectClass=*)",
- attrs,
+ /* we do not really need to find all descendents,
+ * if there is even one single direct child, that's
+ * enough to bail out */
+ ret = ldb_build_search_req(&search_req, module->ldb, ac,
+ req->op.del.dn, LDB_SCOPE_ONELEVEL,
+ "(objectClass=*)", attrs,
req->controls,
- ac,
- subtree_delete_search_callback);
-
+ ac, subtree_delete_search_callback,
+ req);
if (ret != LDB_SUCCESS) {
return ret;
}
- ret = ldb_set_timeout_from_prev_req(module->ldb, req, new_req);
-
- if (ret != LDB_SUCCESS) {
- return ret;
- }
-
- ac->search_req = new_req;
- if (req == NULL) {
- ldb_oom(ac->module->ldb);
- return LDB_ERR_OPERATIONS_ERROR;
- }
- return ldb_next_request(module, new_req);
-}
-
-
-static int subtree_delete_wait_none(struct ldb_handle *handle) {
- struct subtree_delete_context *ac;
- int ret = LDB_ERR_OPERATIONS_ERROR;
- if (!handle || !handle->private_data) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- if (handle->state == LDB_ASYNC_DONE) {
- return handle->status;
- }
-
- handle->state = LDB_ASYNC_PENDING;
- handle->status = LDB_SUCCESS;
-
- ac = talloc_get_type(handle->private_data, struct subtree_delete_context);
-
- switch (ac->step) {
- case SD_SEARCH:
- ret = ldb_wait(ac->search_req->handle, LDB_WAIT_NONE);
-
- if (ret != LDB_SUCCESS && ret != LDB_ERR_NO_SUCH_OBJECT) {
- handle->status = ret;
- goto done;
- }
- if (ac->search_req->handle->status != LDB_SUCCESS
- && ac->search_req->handle->status != LDB_ERR_NO_SUCH_OBJECT) {
- handle->status = ac->search_req->handle->status;
- goto done;
- }
-
- return subtree_delete_check_for_children(ac);
-
- case SD_DO_DEL:
- ret = ldb_wait(ac->down_req->handle, LDB_WAIT_NONE);
-
- if (ret != LDB_SUCCESS) {
- handle->status = ret;
- goto done;
- }
- if (ac->down_req->handle->status != LDB_SUCCESS) {
- handle->status = ac->down_req->handle->status;
- goto done;
- }
-
- if (ac->down_req->handle->state != LDB_ASYNC_DONE) {
- return LDB_SUCCESS;
- }
-
- break;
- }
-done:
- handle->state = LDB_ASYNC_DONE;
- return ret;
-}
-
-static int subtree_delete_wait_all(struct ldb_handle *handle) {
-
- int ret;
-
- while (handle->state != LDB_ASYNC_DONE) {
- ret = subtree_delete_wait_none(handle);
- if (ret != LDB_SUCCESS) {
- return ret;
- }
- }
-
- return handle->status;
-}
-
-static int subtree_delete_wait(struct ldb_handle *handle, enum ldb_wait_type type)
-{
- if (type == LDB_WAIT_ALL) {
- return subtree_delete_wait_all(handle);
- } else {
- return subtree_delete_wait_none(handle);
- }
+ return ldb_next_request(module, search_req);
}
const struct ldb_module_ops ldb_subtree_delete_module_ops = {
.name = "subtree_delete",
.del = subtree_delete,
- .wait = subtree_delete_wait,
};
#include "ldb_includes.h"
+struct subren_msg_store {
+ struct subren_msg_store *next;
+ struct ldb_dn *olddn;
+ struct ldb_dn *newdn;
+};
+
struct subtree_rename_context {
struct ldb_module *module;
- struct ldb_handle *handle;
- struct ldb_request *orig_req;
-
- struct ldb_request **down_req;
- int num_requests;
- int finished_requests;
+ struct ldb_request *req;
- int num_children;
+ struct subren_msg_store *list;
+ struct subren_msg_store *current;
};
-static struct subtree_rename_context *subtree_rename_init_handle(struct ldb_request *req,
- struct ldb_module *module)
+static struct subtree_rename_context *subren_ctx_init(struct ldb_module *module,
+ struct ldb_request *req)
{
struct subtree_rename_context *ac;
- struct ldb_handle *h;
- h = talloc_zero(req, struct ldb_handle);
- if (h == NULL) {
- ldb_set_errstring(module->ldb, "Out of Memory");
+ ac = talloc_zero(req, struct subtree_rename_context);
+ if (ac == NULL) {
+ ldb_oom(module->ldb);
return NULL;
}
- h->module = module;
+ ac->module = module;
+ ac->req = req;
- ac = talloc_zero(h, struct subtree_rename_context);
- if (ac == NULL) {
- ldb_set_errstring(module->ldb, "Out of Memory");
- talloc_free(h);
- return NULL;
+ return ac;
+}
+
+static int subtree_rename_next_request(struct subtree_rename_context *ac);
+
+static int subtree_rename_callback(struct ldb_request *req,
+ struct ldb_reply *ares)
+{
+ struct subtree_rename_context *ac;
+ int ret;
+
+ ac = talloc_get_type(req->context, struct subtree_rename_context);
+
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
- h->private_data = ac;
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
- ac->module = module;
- ac->handle = h;
- ac->orig_req = req;
+ if (ares->type != LDB_REPLY_DONE) {
+ ldb_set_errstring(ac->module->ldb, "Invalid reply type!\n");
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
- req->handle = h;
+ if (ac->current == NULL) {
+ /* this was the last one */
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, LDB_SUCCESS);
+ }
- return ac;
-}
+ ret = subtree_rename_next_request(ac);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL, ret);
+ }
+ talloc_free(ares);
+ return LDB_SUCCESS;
+}
-static int subtree_rename_search_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
+static int subtree_rename_next_request(struct subtree_rename_context *ac)
{
struct ldb_request *req;
- struct subtree_rename_context *ac = talloc_get_type(context, struct subtree_rename_context);
- TALLOC_CTX *mem_ctx = talloc_new(ac);
-
- if (!mem_ctx) {
- ldb_oom(ac->module->ldb);
+ int ret;
+
+ if (ac->current == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
- /* OK, we have one of *many* search results here:
-
- We should also get the entry we tried to rename. This
- callback handles this and everything below it.
- */
-
- /* Only entries are interesting, and we handle the case of the parent seperatly */
- if (ares->type == LDB_REPLY_ENTRY
- && ldb_dn_compare(ares->message->dn, ac->orig_req->op.rename.olddn) != 0) {
- /* And it is an actual entry: now create a rename from it */
- int ret;
-
- struct ldb_dn *newdn = ldb_dn_copy(mem_ctx, ares->message->dn);
- if (!newdn) {
- ldb_oom(ac->module->ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+
+ ret = ldb_build_rename_req(&req, ac->module->ldb, ac->current,
+ ac->current->olddn,
+ ac->current->newdn,
+ ac->req->controls,
+ ac, subtree_rename_callback,
+ ac->req);
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
+
+ ac->current = ac->current->next;
+
+ return ldb_next_request(ac->module, req);
+}
+
+static int subtree_rename_search_callback(struct ldb_request *req,
+ struct ldb_reply *ares)
+{
+ struct subren_msg_store *store;
+ struct subtree_rename_context *ac;
+ int ret;
+
+ ac = talloc_get_type(req->context, struct subtree_rename_context);
+
+ if (!ares || !ac->current) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
+
+ switch (ares->type) {
+ case LDB_REPLY_ENTRY:
+
+ if (ldb_dn_compare(ares->message->dn, ac->list->olddn) == 0) {
+ /* this was already stored by the
+ * subtree_rename_search() */
+ talloc_free(ares);
+ return LDB_SUCCESS;
}
-
- ldb_dn_remove_base_components(newdn, ldb_dn_get_comp_num(ac->orig_req->op.rename.olddn));
- if (!ldb_dn_add_base(newdn, ac->orig_req->op.rename.newdn)) {
- ldb_oom(ac->module->ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ store = talloc_zero(ac, struct subren_msg_store);
+ if (store == NULL) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
+ ac->current->next = store;
+ ac->current = store;
- ret = ldb_build_rename_req(&req, ldb, mem_ctx,
- ares->message->dn,
- newdn,
- NULL,
- NULL,
- NULL);
-
- if (ret != LDB_SUCCESS) {
- return ret;
+ /* the first list element contains the base for the rename */
+ store->olddn = talloc_steal(store, ares->message->dn);
+ store->newdn = ldb_dn_copy(store, store->olddn);
+
+ if ( ! ldb_dn_remove_base_components(store->newdn,
+ ldb_dn_get_comp_num(ac->list->olddn))) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
- ret = ldb_set_timeout_from_prev_req(ldb, ac->orig_req, req);
-
- if (ret != LDB_SUCCESS) {
- return ret;
+ if ( ! ldb_dn_add_base(store->newdn, ac->list->newdn)) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
- talloc_steal(req, newdn);
+ break;
- talloc_steal(req, ares->message->dn);
-
- talloc_free(ares);
-
- } else if (ares->type == LDB_REPLY_DONE) {
- req = talloc(mem_ctx, struct ldb_request);
- *req = *ac->orig_req;
- talloc_free(ares);
+ case LDB_REPLY_REFERRAL:
+ /* ignore */
+ break;
- } else {
- talloc_free(ares);
- return LDB_SUCCESS;
- }
-
- ac->down_req = talloc_realloc(ac, ac->down_req,
- struct ldb_request *, ac->num_requests + 1);
- if (!ac->down_req) {
- ldb_oom(ac->module->ldb);
- return LDB_ERR_OPERATIONS_ERROR;
+ case LDB_REPLY_DONE:
+
+ /* rewind ac->current */
+ ac->current = ac->list;
+
+ /* All dns set up, start with the first one */
+ ret = subtree_rename_next_request(ac);
+
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL, ret);
+ }
+ break;
}
- ac->down_req[ac->num_requests] = req;
- ac->num_requests++;
-
- return ldb_next_request(ac->module, req);
-
+
+ talloc_free(ares);
+ return LDB_SUCCESS;
}
/* rename */
static int subtree_rename(struct ldb_module *module, struct ldb_request *req)
{
- const char *attrs[] = { NULL };
- struct ldb_request *new_req;
+ static const char *attrs[2] = { "distinguishedName", NULL };
+ struct ldb_request *search_req;
struct subtree_rename_context *ac;
int ret;
if (ldb_dn_is_special(req->op.rename.olddn)) { /* do not manipulate our control entries */
- Regain our sainity
*/
- ac = subtree_rename_init_handle(req, module);
+ ac = subren_ctx_init(module, req);
if (!ac) {
return LDB_ERR_OPERATIONS_ERROR;
}
- ret = ldb_build_search_req(&new_req, module->ldb, req,
+ /* add this entry as the first to do */
+ ac->current = talloc_zero(ac, struct subren_msg_store);
+ if (ac->current == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ ac->current->olddn = req->op.rename.olddn;
+ ac->current->newdn = req->op.rename.newdn;
+ ac->list = ac->current;
+
+ ret = ldb_build_search_req(&search_req, module->ldb, ac,
req->op.rename.olddn,
LDB_SCOPE_SUBTREE,
"(objectClass=*)",
attrs,
- req->controls,
+ NULL,
ac,
- subtree_rename_search_callback);
-
- if (ret != LDB_SUCCESS) {
- return ret;
- }
-
- ret = ldb_set_timeout_from_prev_req(module->ldb, req, new_req);
-
+ subtree_rename_search_callback,
+ req);
if (ret != LDB_SUCCESS) {
return ret;
}
- ac->down_req = talloc_realloc(ac, ac->down_req,
- struct ldb_request *, ac->num_requests + 1);
- if (!ac->down_req) {
- ldb_oom(ac->module->ldb);
- return LDB_ERR_OPERATIONS_ERROR;
- }
- ac->down_req[ac->num_requests] = new_req;
- if (req == NULL) {
- ldb_oom(ac->module->ldb);
- return LDB_ERR_OPERATIONS_ERROR;
- }
- ac->num_requests++;
- return ldb_next_request(module, new_req);
-}
-
-
-static int subtree_rename_wait_none(struct ldb_handle *handle) {
- struct subtree_rename_context *ac;
- int i, ret = LDB_ERR_OPERATIONS_ERROR;
- if (!handle || !handle->private_data) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- if (handle->state == LDB_ASYNC_DONE) {
- return handle->status;
- }
-
- handle->state = LDB_ASYNC_PENDING;
- handle->status = LDB_SUCCESS;
-
- ac = talloc_get_type(handle->private_data, struct subtree_rename_context);
-
- for (i=0; i < ac->num_requests; i++) {
- ret = ldb_wait(ac->down_req[i]->handle, LDB_WAIT_NONE);
-
- if (ret != LDB_SUCCESS) {
- handle->status = ret;
- goto done;
- }
- if (ac->down_req[i]->handle->status != LDB_SUCCESS) {
- handle->status = ac->down_req[i]->handle->status;
- goto done;
- }
-
- if (ac->down_req[i]->handle->state != LDB_ASYNC_DONE) {
- return LDB_SUCCESS;
- }
- }
-
-done:
- handle->state = LDB_ASYNC_DONE;
- return ret;
-
-}
-
-static int subtree_rename_wait_all(struct ldb_handle *handle) {
-
- int ret;
-
- while (handle->state != LDB_ASYNC_DONE) {
- ret = subtree_rename_wait_none(handle);
- if (ret != LDB_SUCCESS) {
- return ret;
- }
- }
-
- return handle->status;
-}
-
-static int subtree_rename_wait(struct ldb_handle *handle, enum ldb_wait_type type)
-{
- if (type == LDB_WAIT_ALL) {
- return subtree_rename_wait_all(handle);
- } else {
- return subtree_rename_wait_none(handle);
- }
+ return ldb_next_request(module, search_req);
}
const struct ldb_module_ops ldb_subtree_rename_module_ops = {
.name = "subtree_rename",
.rename = subtree_rename,
- .wait = subtree_rename_wait,
};
#!/usr/bin/python
# Unix SMB/CIFS implementation.
-# Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2005-2007
+# Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2005-2008
# Copyright (C) Martin Kuehl <mkhl@samba.org> 2006
#
# This is a Python port of the original in testprogs/ejs/samba3sam.js
"""Tests for the samba3sam LDB module, which maps Samba3 LDAP to AD LDAP."""
import os
-import sys
-import samba
import ldb
from ldb import SCOPE_DEFAULT, SCOPE_BASE, SCOPE_SUBTREE
from samba import Ldb, substitute_var
-from samba.tests import LdbTestCase, TestCaseInTempDir
+from samba.tests import LdbTestCase, TestCaseInTempDir, cmdline_loadparm
+import samba.dcerpc.security
+import samba.security
+import samba.ndr
+
+datadir = os.path.join(os.path.dirname(__file__),
+ "../../../../../testdata/samba3")
+
+def read_datafile(filename):
+ return open(os.path.join(datadir, filename), 'r').read()
+
+def ldb_debug(l, text):
+ print text
-datadir = os.path.join(os.path.dirname(__file__), "../../../../../testdata/samba3")
class MapBaseTestCase(TestCaseInTempDir):
- def setup_data(self, obj, ldif):
- self.assertTrue(ldif is not None)
- obj.db.add_ldif(substitute_var(ldif, obj.substvars))
+ """Base test case for mapping tests."""
def setup_modules(self, ldb, s3, s4):
ldb.add({"dn": "@MAP=samba3sam",
"@LIST": "rootdse,paged_results,server_sort,extended_dn,asq,samldb,password_hash,operational,objectguid,rdn_name,samba3sam,partition"})
ldb.add({"dn": "@PARTITION",
- "partition": [s4.basedn + ":" + s4.url, s3.basedn + ":" + s3.url],
+ "partition": ["%s:%s" % (s4.basedn, s4.url),
+ "%s:%s" % (s3.basedn, s3.url)],
"replicateEntries": ["@ATTRIBUTES", "@INDEXLIST"]})
def setUp(self):
super(MapBaseTestCase, self).setUp()
def make_dn(basedn, rdn):
- return rdn + ",sambaDomainName=TESTS," + basedn
+ return "%s,sambaDomainName=TESTS,%s" % (rdn, basedn)
def make_s4dn(basedn, rdn):
- return rdn + "," + basedn
+ return "%s,%s" % (rdn, basedn)
self.ldbfile = os.path.join(self.tempdir, "test.ldb")
self.ldburl = "tdb://" + self.ldbfile
tempdir = self.tempdir
- print tempdir
class Target:
- """Simple helper class that contains data for a specific SAM connection."""
+ """Simple helper class that contains data for a specific SAM
+ connection."""
def __init__(self, file, basedn, dn):
self.file = os.path.join(tempdir, file)
self.url = "tdb://" + self.file
self.basedn = basedn
self.substvars = {"BASEDN": self.basedn}
- self.db = Ldb()
+ self.db = Ldb(lp=cmdline_loadparm)
self._dn = dn
def dn(self, rdn):
- return self._dn(rdn, self.basedn)
+ return self._dn(self.basedn, rdn)
def connect(self):
return self.db.connect(self.url)
+ def setup_data(self, path):
+ self.add_ldif(read_datafile(path))
+
+ def subst(self, text):
+ return substitute_var(text, self.substvars)
+
+ def add_ldif(self, ldif):
+ self.db.add_ldif(self.subst(ldif))
+
+ def modify_ldif(self, ldif):
+ self.db.modify_ldif(self.subst(ldif))
+
self.samba4 = Target("samba4.ldb", "dc=vernstok,dc=nl", make_s4dn)
self.samba3 = Target("samba3.ldb", "cn=Samba3Sam", make_dn)
self.templates = Target("templates.ldb", "cn=templates", None)
os.unlink(self.samba4.file)
super(MapBaseTestCase, self).tearDown()
+ def assertSidEquals(self, text, ndr_sid):
+ sid_obj1 = samba.ndr.ndr_unpack(samba.dcerpc.security.dom_sid,
+ str(ndr_sid[0]))
+ sid_obj2 = samba.security.Sid(text)
+ # For now, this is the only way we can compare these since the
+ # classes are in different places. Should reconcile that at some point.
+ self.assertEquals(sid_obj1.sid_rev_num, sid_obj2.sid_rev_num)
+ self.assertEquals(sid_obj1.num_auths, sid_obj2.num_auths)
+ # FIXME: self.assertEquals(sid_obj1.id_auth, sid_obj2.id_auth)
+ # FIXME: self.assertEquals(sid_obj1.sub_auths[:sid_obj1.num_auths],
+ # sid_obj2.sub_auths[:sid_obj2.num_auths])
+
class Samba3SamTestCase(MapBaseTestCase):
+
def setUp(self):
super(Samba3SamTestCase, self).setUp()
- ldb = Ldb(self.ldburl)
- self.setup_data(self.samba3, open(os.path.join(datadir, "samba3.ldif"), 'r').read())
- self.setup_data(self.templates, open(os.path.join(datadir, "provision_samba3sam_templates.ldif"), 'r').read())
- ldif = open(os.path.join(datadir, "provision_samba3sam.ldif"), 'r').read()
- ldb.add_ldif(substitute_var(ldif, self.samba4.substvars))
+ ldb = Ldb(self.ldburl, lp=cmdline_loadparm)
+ self.samba3.setup_data("samba3.ldif")
+ self.templates.setup_data("provision_samba3sam_templates.ldif")
+ ldif = read_datafile("provision_samba3sam.ldif")
+ ldb.add_ldif(self.samba4.subst(ldif))
self.setup_modules(ldb, self.samba3, self.samba4)
- self.ldb = Ldb(self.ldburl)
+ del ldb
+ self.ldb = Ldb(self.ldburl, lp=cmdline_loadparm)
- def test_s3sam_search(self):
- print "Looking up by non-mapped attribute"
+ def test_search_non_mapped(self):
+ """Looking up by non-mapped attribute"""
msg = self.ldb.search(expression="(cn=Administrator)")
self.assertEquals(len(msg), 1)
self.assertEquals(msg[0]["cn"], "Administrator")
- print "Looking up by mapped attribute"
+ def test_search_non_mapped(self):
+ """Looking up by mapped attribute"""
msg = self.ldb.search(expression="(name=Backup Operators)")
self.assertEquals(len(msg), 1)
self.assertEquals(msg[0]["name"], "Backup Operators")
- print "Looking up by old name of renamed attribute"
+ def test_old_name_of_renamed(self):
+ """Looking up by old name of renamed attribute"""
msg = self.ldb.search(expression="(displayName=Backup Operators)")
self.assertEquals(len(msg), 0)
- print "Looking up mapped entry containing SID"
+ def test_mapped_containing_sid(self):
+ """Looking up mapped entry containing SID"""
msg = self.ldb.search(expression="(cn=Replicator)")
self.assertEquals(len(msg), 1)
- print msg[0].dn
- self.assertEquals(str(msg[0].dn), "cn=Replicator,ou=Groups,dc=vernstok,dc=nl")
- self.assertEquals(msg[0]["objectSid"], "S-1-5-21-4231626423-2410014848-2360679739-552")
-
- print "Checking mapping of objectClass"
+ self.assertEquals(str(msg[0].dn),
+ "cn=Replicator,ou=Groups,dc=vernstok,dc=nl")
+ self.assertTrue("objectSid" in msg[0])
+ self.assertSidEquals("S-1-5-21-4231626423-2410014848-2360679739-552",
+ msg[0]["objectSid"])
oc = set(msg[0]["objectClass"])
- self.assertTrue(oc is not None)
- for i in oc:
- self.assertEquals(oc[i] == "posixGroup" or oc[i], "group")
+ self.assertEquals(oc, set(["group"]))
- print "Looking up by objectClass"
+ def test_search_by_objclass(self):
+ """Looking up by objectClass"""
msg = self.ldb.search(expression="(|(objectClass=user)(cn=Administrator))")
- self.assertEquals(len(msg), 2)
- for i in range(len(msg)):
- self.assertEquals((str(msg[i].dn), "unixName=Administrator,ou=Users,dc=vernstok,dc=nl") or
- (str(msg[i].dn) == "unixName=nobody,ou=Users,dc=vernstok,dc=nl"))
-
+ self.assertEquals(set([str(m.dn) for m in msg]),
+ set(["unixName=Administrator,ou=Users,dc=vernstok,dc=nl",
+ "unixName=nobody,ou=Users,dc=vernstok,dc=nl"]))
def test_s3sam_modify(self):
- print "Adding a record that will be fallbacked"
+ # Adding a record that will be fallbacked
self.ldb.add({"dn": "cn=Foo",
"foo": "bar",
"blah": "Blie",
"showInAdvancedViewOnly": "TRUE"}
)
- print "Checking for existence of record (local)"
- # TODO: This record must be searched in the local database, which is currently only supported for base searches
+ # Checking for existence of record (local)
+ # TODO: This record must be searched in the local database, which is
+ # currently only supported for base searches
# msg = ldb.search(expression="(cn=Foo)", ['foo','blah','cn','showInAdvancedViewOnly')]
# TODO: Actually, this version should work as well but doesn't...
#
#
- msg = self.ldb.search(expression="(cn=Foo)", base="cn=Foo", scope=SCOPE_BASE, attrs=['foo','blah','cn','showInAdvancedViewOnly'])
+ msg = self.ldb.search(expression="(cn=Foo)", base="cn=Foo",
+ scope=SCOPE_BASE,
+ attrs=['foo','blah','cn','showInAdvancedViewOnly'])
self.assertEquals(len(msg), 1)
self.assertEquals(msg[0]["showInAdvancedViewOnly"], "TRUE")
self.assertEquals(msg[0]["foo"], "bar")
self.assertEquals(msg[0]["blah"], "Blie")
- print "Adding record that will be mapped"
+ # Adding record that will be mapped
self.ldb.add({"dn": "cn=Niemand,cn=Users,dc=vernstok,dc=nl",
"objectClass": "user",
"unixName": "bin",
"sambaUnicodePwd": "geheim",
"cn": "Niemand"})
- print "Checking for existence of record (remote)"
+ # Checking for existence of record (remote)
msg = self.ldb.search(expression="(unixName=bin)",
attrs=['unixName','cn','dn', 'sambaUnicodePwd'])
self.assertEquals(len(msg), 1)
self.assertEquals(msg[0]["cn"], "Niemand")
self.assertEquals(msg[0]["sambaUnicodePwd"], "geheim")
- print "Checking for existence of record (local && remote)"
+ # Checking for existence of record (local && remote)
msg = self.ldb.search(expression="(&(unixName=bin)(sambaUnicodePwd=geheim))",
attrs=['unixName','cn','dn', 'sambaUnicodePwd'])
self.assertEquals(len(msg), 1) # TODO: should check with more records
self.assertEquals(msg[0]["unixName"], "bin")
self.assertEquals(msg[0]["sambaUnicodePwd"], "geheim")
- print "Checking for existence of record (local || remote)"
+ # Checking for existence of record (local || remote)
msg = self.ldb.search(expression="(|(unixName=bin)(sambaUnicodePwd=geheim))",
attrs=['unixName','cn','dn', 'sambaUnicodePwd'])
- print "got " + len(msg) + " replies"
+ #print "got %d replies" % len(msg)
self.assertEquals(len(msg), 1) # TODO: should check with more records
self.assertEquals(msg[0]["cn"], "Niemand")
- self.assertEquals(msg[0]["unixName"] == "bin" or msg[0]["sambaUnicodePwd"], "geheim")
+ self.assertEquals(msg[0]["unixName"], "bin")
+ self.assertEquals(msg[0]["sambaUnicodePwd"], "geheim")
- print "Checking for data in destination database"
- msg = s3.db.search("(cn=Niemand)")
+ # Checking for data in destination database
+ msg = self.samba3.db.search(expression="(cn=Niemand)")
self.assertTrue(len(msg) >= 1)
- self.assertEquals(msg[0]["sambaSID"], "S-1-5-21-4231626423-2410014848-2360679739-2001")
+ self.assertEquals(msg[0]["sambaSID"],
+ "S-1-5-21-4231626423-2410014848-2360679739-2001")
self.assertEquals(msg[0]["displayName"], "Niemand")
- print "Adding attribute..."
+ # Adding attribute...
self.ldb.modify_ldif("""
dn: cn=Niemand,cn=Users,dc=vernstok,dc=nl
changetype: modify
description: Blah
""")
- print "Checking whether changes are still there..."
+ # Checking whether changes are still there...
msg = self.ldb.search(expression="(cn=Niemand)")
self.assertTrue(len(msg) >= 1)
self.assertEquals(msg[0]["cn"], "Niemand")
self.assertEquals(msg[0]["description"], "Blah")
- print "Modifying attribute..."
+ # Modifying attribute...
self.ldb.modify_ldif("""
dn: cn=Niemand,cn=Users,dc=vernstok,dc=nl
changetype: modify
description: Blie
""")
- print "Checking whether changes are still there..."
+ # Checking whether changes are still there...
msg = self.ldb.search(expression="(cn=Niemand)")
self.assertTrue(len(msg) >= 1)
self.assertEquals(msg[0]["description"], "Blie")
- print "Deleting attribute..."
+ # Deleting attribute...
self.ldb.modify_ldif("""
dn: cn=Niemand,cn=Users,dc=vernstok,dc=nl
changetype: modify
delete: description
""")
- print "Checking whether changes are no longer there..."
+ # Checking whether changes are no longer there...
msg = self.ldb.search(expression="(cn=Niemand)")
self.assertTrue(len(msg) >= 1)
- self.assertTrue(not "description" in res[0])
+ self.assertTrue(not "description" in msg[0])
- print "Renaming record..."
- self.ldb.rename("cn=Niemand,cn=Users,dc=vernstok,dc=nl", "cn=Niemand2,cn=Users,dc=vernstok,dc=nl")
+ # Renaming record...
+ self.ldb.rename("cn=Niemand,cn=Users,dc=vernstok,dc=nl",
+ "cn=Niemand2,cn=Users,dc=vernstok,dc=nl")
- print "Checking whether DN has changed..."
+ # Checking whether DN has changed...
msg = self.ldb.search(expression="(cn=Niemand2)")
self.assertEquals(len(msg), 1)
- self.assertEquals(str(msg[0].dn), "cn=Niemand2,cn=Users,dc=vernstok,dc=nl")
+ self.assertEquals(str(msg[0].dn),
+ "cn=Niemand2,cn=Users,dc=vernstok,dc=nl")
- print "Deleting record..."
+ # Deleting record...
self.ldb.delete("cn=Niemand2,cn=Users,dc=vernstok,dc=nl")
- print "Checking whether record is gone..."
+ # Checking whether record is gone...
msg = self.ldb.search(expression="(cn=Niemand2)")
self.assertEquals(len(msg), 0)
-
class MapTestCase(MapBaseTestCase):
+
def setUp(self):
super(MapTestCase, self).setUp()
- ldb = Ldb(self.ldburl)
- self.setup_data(self.templates, open(os.path.join(datadir, "provision_samba3sam_templates.ldif"), 'r').read())
- ldif = open(os.path.join(datadir, "provision_samba3sam.ldif"), 'r').read()
- ldb.add_ldif(substitute_var(ldif, self.samba4.substvars))
+ ldb = Ldb(self.ldburl, lp=cmdline_loadparm)
+ self.templates.setup_data("provision_samba3sam_templates.ldif")
+ ldif = read_datafile("provision_samba3sam.ldif")
+ ldb.add_ldif(self.samba4.subst(ldif))
self.setup_modules(ldb, self.samba3, self.samba4)
- self.ldb = Ldb(self.ldburl)
+ del ldb
+ self.ldb = Ldb(self.ldburl, lp=cmdline_loadparm)
def test_map_search(self):
- print "Running search tests on mapped data"
- ldif = """
-dn: """ + "sambaDomainName=TESTS,""" + self.samba3.basedn + """
-objectclass: sambaDomain
-objectclass: top
-sambaSID: S-1-5-21-4231626423-2410014848-2360679739
-sambaNextRid: 2000
-sambaDomainName: TESTS"""
- self.samba3.db.add_ldif(substitute_var(ldif, self.samba3.substvars))
-
- print "Add a set of split records"
- ldif = """
-dn: """ + self.samba4.dn("cn=X") + """
+ """Running search tests on mapped data."""
+ self.samba3.db.add({
+ "dn": "sambaDomainName=TESTS," + self.samba3.basedn,
+ "objectclass": ["sambaDomain", "top"],
+ "sambaSID": "S-1-5-21-4231626423-2410014848-2360679739",
+ "sambaNextRid": "2000",
+ "sambaDomainName": "TESTS"
+ })
+
+ # Add a set of split records
+ self.ldb.add_ldif("""
+dn: """+ self.samba4.dn("cn=X") + """
objectClass: user
cn: X
codePage: x
objectSid: S-1-5-21-4231626423-2410014848-2360679739-552
primaryGroupID: 1-5-21-4231626423-2410014848-2360679739-512
-dn: """ + self.samba4.dn("cn=Y") + """
-objectClass: top
-cn: Y
-codePage: x
-revision: x
-dnsHostName: y
-nextRid: y
-lastLogon: y
-description: x
-
-dn: """ + self.samba4.dn("cn=Z") + """
-objectClass: top
-cn: Z
-codePage: x
-revision: y
-dnsHostName: z
-nextRid: y
-lastLogon: z
-description: y
-"""
-
- self.ldb.add_ldif(substitute_var(ldif, self.samba4.substvars))
-
- print "Add a set of remote records"
-
- ldif = """
-dn: """ + self.samba3.dn("cn=A") + """
-objectClass: posixAccount
-cn: A
-sambaNextRid: x
-sambaBadPasswordCount: x
-sambaLogonTime: x
-description: x
-sambaSID: S-1-5-21-4231626423-2410014848-2360679739-552
-sambaPrimaryGroupSID: S-1-5-21-4231626423-2410014848-2360679739-512
-
-dn: """ + self.samba3.dn("cn=B") + """
-objectClass: top
-cn:B
-sambaNextRid: x
-sambaBadPasswordCount: x
-sambaLogonTime: y
-description: x
+""")
-dn: """ + self.samba3.dn("cn=C") + """
-objectClass: top
-cn: C
-sambaNextRid: x
-sambaBadPasswordCount: y
-sambaLogonTime: z
-description: y
-"""
- self.samba3.add_ldif(substitute_var(ldif, self.samba3.substvars))
+ self.ldb.add({
+ "dn": self.samba4.dn("cn=Y"),
+ "objectClass": "top",
+ "cn": "Y",
+ "codePage": "x",
+ "revision": "x",
+ "dnsHostName": "y",
+ "nextRid": "y",
+ "lastLogon": "y",
+ "description": "x"})
- print "Testing search by DN"
+ self.ldb.add({
+ "dn": self.samba4.dn("cn=Z"),
+ "objectClass": "top",
+ "cn": "Z",
+ "codePage": "x",
+ "revision": "y",
+ "dnsHostName": "z",
+ "nextRid": "y",
+ "lastLogon": "z",
+ "description": "y"})
+
+ # Add a set of remote records
+
+ self.samba3.db.add({
+ "dn": self.samba3.dn("cn=A"),
+ "objectClass": "posixAccount",
+ "cn": "A",
+ "sambaNextRid": "x",
+ "sambaBadPasswordCount": "x",
+ "sambaLogonTime": "x",
+ "description": "x",
+ "sambaSID": "S-1-5-21-4231626423-2410014848-2360679739-552",
+ "sambaPrimaryGroupSID": "S-1-5-21-4231626423-2410014848-2360679739-512"})
+
+ self.samba3.db.add({
+ "dn": self.samba3.dn("cn=B"),
+ "objectClass": "top",
+ "cn": "B",
+ "sambaNextRid": "x",
+ "sambaBadPasswordCount": "x",
+ "sambaLogonTime": "y",
+ "description": "x"})
+
+ self.samba3.db.add({
+ "dn": self.samba3.dn("cn=C"),
+ "objectClass": "top",
+ "cn": "C",
+ "sambaNextRid": "x",
+ "sambaBadPasswordCount": "y",
+ "sambaLogonTime": "z",
+ "description": "y"})
+
+ # Testing search by DN
# Search remote record by local DN
dn = self.samba4.dn("cn=A")
- attrs = ["dnsHostName", "lastLogon"]
- res = self.ldb.search(dn, scope=SCOPE_BASE, attrs=attrs)
+ res = self.ldb.search(dn, scope=SCOPE_BASE,
+ attrs=["dnsHostName", "lastLogon"])
self.assertEquals(len(res), 1)
- self.assertEquals(str(str(res[0].dn)), dn)
+ self.assertEquals(str(res[0].dn), dn)
self.assertTrue(not "dnsHostName" in res[0])
self.assertEquals(res[0]["lastLogon"], "x")
# Search remote record by remote DN
dn = self.samba3.dn("cn=A")
- attrs = ["dnsHostName", "lastLogon", "sambaLogonTime"]
- res = self.samba3.db.search(dn, scope=SCOPE_BASE, attrs=attrs)
+ res = self.samba3.db.search(dn, scope=SCOPE_BASE,
+ attrs=["dnsHostName", "lastLogon", "sambaLogonTime"])
self.assertEquals(len(res), 1)
- self.assertEquals(str(str(res[0].dn)), dn)
+ self.assertEquals(str(res[0].dn), dn)
self.assertTrue(not "dnsHostName" in res[0])
self.assertTrue(not "lastLogon" in res[0])
self.assertEquals(res[0]["sambaLogonTime"], "x")
# Search split record by local DN
dn = self.samba4.dn("cn=X")
- attrs = ["dnsHostName", "lastLogon"]
- res = self.ldb.search(dn, scope=SCOPE_BASE, attrs=attrs)
+ res = self.ldb.search(dn, scope=SCOPE_BASE,
+ attrs=["dnsHostName", "lastLogon"])
self.assertEquals(len(res), 1)
- self.assertEquals(str(str(res[0].dn)), dn)
+ self.assertEquals(str(res[0].dn), dn)
self.assertEquals(res[0]["dnsHostName"], "x")
self.assertEquals(res[0]["lastLogon"], "x")
# Search split record by remote DN
dn = self.samba3.dn("cn=X")
- attrs = ["dnsHostName", "lastLogon", "sambaLogonTime"]
- res = self.samba3.db.search(dn, scope=SCOPE_BASE, attrs=attrs)
+ res = self.samba3.db.search(dn, scope=SCOPE_BASE,
+ attrs=["dnsHostName", "lastLogon", "sambaLogonTime"])
self.assertEquals(len(res), 1)
- self.assertEquals(str(str(res[0].dn)), dn)
+ self.assertEquals(str(res[0].dn), dn)
self.assertTrue(not "dnsHostName" in res[0])
self.assertTrue(not "lastLogon" in res[0])
self.assertEquals(res[0]["sambaLogonTime"], "x")
- print "Testing search by attribute"
+ # Testing search by attribute
# Search by ignored attribute
- attrs = ["dnsHostName", "lastLogon"]
- res = self.ldb.search(expression="(revision=x)", scope=SCOPE_DEFAULT, attrs=attrs)
+ res = self.ldb.search(expression="(revision=x)", scope=SCOPE_DEFAULT,
+ attrs=["dnsHostName", "lastLogon"])
self.assertEquals(len(res), 2)
- self.assertEquals(str(str(res[0].dn)), self.samba4.dn("cn=Y"))
+ self.assertEquals(str(res[0].dn), self.samba4.dn("cn=Y"))
self.assertEquals(res[0]["dnsHostName"], "y")
self.assertEquals(res[0]["lastLogon"], "y")
- self.assertEquals(str(str(res[1].dn)), self.samba4.dn("cn=X"))
+ self.assertEquals(str(res[1].dn), self.samba4.dn("cn=X"))
self.assertEquals(res[1]["dnsHostName"], "x")
self.assertEquals(res[1]["lastLogon"], "x")
# Search by kept attribute
- attrs = ["dnsHostName", "lastLogon"]
- res = self.ldb.search(expression="(description=y)", scope=SCOPE_DEFAULT, attrs=attrs)
+ res = self.ldb.search(expression="(description=y)",
+ scope=SCOPE_DEFAULT, attrs=["dnsHostName", "lastLogon"])
self.assertEquals(len(res), 2)
- self.assertEquals(str(str(res[0].dn)), self.samba4.dn("cn=Z"))
+ self.assertEquals(str(res[0].dn), self.samba4.dn("cn=Z"))
self.assertEquals(res[0]["dnsHostName"], "z")
self.assertEquals(res[0]["lastLogon"], "z")
- self.assertEquals(str(str(res[1].dn)), self.samba4.dn("cn=C"))
+ self.assertEquals(str(res[1].dn), self.samba4.dn("cn=C"))
self.assertTrue(not "dnsHostName" in res[1])
self.assertEquals(res[1]["lastLogon"], "z")
# Search by renamed attribute
- attrs = ["dnsHostName", "lastLogon"]
- res = self.ldb.search(expression="(badPwdCount=x)", scope=SCOPE_DEFAULT, attrs=attrs)
+ res = self.ldb.search(expression="(badPwdCount=x)", scope=SCOPE_DEFAULT,
+ attrs=["dnsHostName", "lastLogon"])
self.assertEquals(len(res), 2)
self.assertEquals(str(res[0].dn), self.samba4.dn("cn=B"))
self.assertTrue(not "dnsHostName" in res[0])
self.assertEquals(res[1]["lastLogon"], "x")
# Search by converted attribute
- attrs = ["dnsHostName", "lastLogon", "objectSid"]
# TODO:
# Using the SID directly in the parse tree leads to conversion
# errors, letting the search fail with no results.
#res = self.ldb.search("(objectSid=S-1-5-21-4231626423-2410014848-2360679739-552)", scope=SCOPE_DEFAULT, attrs)
- res = self.ldb.search(expression="(objectSid=*)", attrs=attrs)
+ res = self.ldb.search(expression="(objectSid=*)", base=None, scope=SCOPE_DEFAULT, attrs=["dnsHostName", "lastLogon", "objectSid"])
self.assertEquals(len(res), 3)
self.assertEquals(str(res[0].dn), self.samba4.dn("cn=X"))
self.assertEquals(res[0]["dnsHostName"], "x")
self.assertEquals(res[0]["lastLogon"], "x")
- self.assertEquals(res[0]["objectSid"], "S-1-5-21-4231626423-2410014848-2360679739-552")
+ self.assertSidEquals("S-1-5-21-4231626423-2410014848-2360679739-552",
+ res[0]["objectSid"])
+ self.assertTrue("objectSid" in res[0])
self.assertEquals(str(res[1].dn), self.samba4.dn("cn=A"))
self.assertTrue(not "dnsHostName" in res[1])
self.assertEquals(res[1]["lastLogon"], "x")
- self.assertEquals(res[1]["objectSid"], "S-1-5-21-4231626423-2410014848-2360679739-552")
+ self.assertSidEquals("S-1-5-21-4231626423-2410014848-2360679739-552",
+ res[1]["objectSid"])
+ self.assertTrue("objectSid" in res[1])
# Search by generated attribute
# In most cases, this even works when the mapping is missing
# a `convert_operator' by enumerating the remote db.
- attrs = ["dnsHostName", "lastLogon", "primaryGroupID"]
- res = self.ldb.search(expression="(primaryGroupID=512)", attrs=attrs)
+ res = self.ldb.search(expression="(primaryGroupID=512)",
+ attrs=["dnsHostName", "lastLogon", "primaryGroupID"])
self.assertEquals(len(res), 1)
self.assertEquals(str(res[0].dn), self.samba4.dn("cn=A"))
self.assertTrue(not "dnsHostName" in res[0])
#
# Search by remote name of renamed attribute */
- attrs = ["dnsHostName", "lastLogon"]
- res = self.ldb.search(expression="(sambaBadPasswordCount=*)", attrs=attrs)
+ res = self.ldb.search(expression="(sambaBadPasswordCount=*)",
+ attrs=["dnsHostName", "lastLogon"])
self.assertEquals(len(res), 0)
# Search by objectClass
self.assertEquals(str(res[0].dn), self.samba4.dn("cn=X"))
self.assertEquals(res[0]["dnsHostName"], "x")
self.assertEquals(res[0]["lastLogon"], "x")
- self.assertTrue(res[0]["objectClass"] is not None)
self.assertEquals(res[0]["objectClass"][0], "user")
self.assertEquals(str(res[1].dn), self.samba4.dn("cn=A"))
self.assertTrue(not "dnsHostName" in res[1])
self.assertEquals(res[1]["lastLogon"], "x")
- self.assertTrue(res[1]["objectClass"] is not None)
self.assertEquals(res[1]["objectClass"][0], "user")
# Prove that the objectClass is actually used for the search
- res = self.ldb.search(expression="(|(objectClass=user)(badPwdCount=x))", attrs=attrs)
+ res = self.ldb.search(expression="(|(objectClass=user)(badPwdCount=x))",
+ attrs=attrs)
self.assertEquals(len(res), 3)
self.assertEquals(str(res[0].dn), self.samba4.dn("cn=B"))
self.assertTrue(not "dnsHostName" in res[0])
self.assertEquals(res[0]["lastLogon"], "y")
- self.assertTrue(res[0]["objectClass"] is not None)
- for oc in set(res[0]["objectClass"]):
- self.assertEquals(oc, "user")
+ self.assertEquals(set(res[0]["objectClass"]), set(["top"]))
self.assertEquals(str(res[1].dn), self.samba4.dn("cn=X"))
self.assertEquals(res[1]["dnsHostName"], "x")
self.assertEquals(res[1]["lastLogon"], "x")
- self.assertTrue(res[1]["objectClass"] is not None)
self.assertEquals(res[1]["objectClass"][0], "user")
self.assertEquals(str(res[2].dn), self.samba4.dn("cn=A"))
self.assertTrue(not "dnsHostName" in res[2])
self.assertEquals(res[2]["lastLogon"], "x")
- self.assertTrue(res[2]["objectClass"] is not None)
self.assertEquals(res[2]["objectClass"][0], "user")
- print "Testing search by parse tree"
+ # Testing search by parse tree
# Search by conjunction of local attributes
- attrs = ["dnsHostName", "lastLogon"]
- res = self.ldb.search(expression="(&(codePage=x)(revision=x))", attrs=attrs)
+ res = self.ldb.search(expression="(&(codePage=x)(revision=x))",
+ attrs=["dnsHostName", "lastLogon"])
self.assertEquals(len(res), 2)
self.assertEquals(str(res[0].dn), self.samba4.dn("cn=Y"))
self.assertEquals(res[0]["dnsHostName"], "y")
self.assertEquals(res[1]["lastLogon"], "x")
# Search by conjunction of remote attributes
- attrs = ["dnsHostName", "lastLogon"]
- res = self.ldb.search(expression="(&(lastLogon=x)(description=x))", attrs=attrs)
+ res = self.ldb.search(expression="(&(lastLogon=x)(description=x))",
+ attrs=["dnsHostName", "lastLogon"])
self.assertEquals(len(res), 2)
self.assertEquals(str(res[0].dn), self.samba4.dn("cn=X"))
self.assertEquals(res[0]["dnsHostName"], "x")
self.assertEquals(res[1]["lastLogon"], "x")
# Search by conjunction of local and remote attribute
- attrs = ["dnsHostName", "lastLogon"]
- res = self.ldb.search(expression="(&(codePage=x)(description=x))", attrs=attrs)
+ res = self.ldb.search(expression="(&(codePage=x)(description=x))",
+ attrs=["dnsHostName", "lastLogon"])
self.assertEquals(len(res), 2)
self.assertEquals(str(res[0].dn), self.samba4.dn("cn=Y"))
self.assertEquals(res[0]["dnsHostName"], "y")
# Search by conjunction of local and remote attribute w/o match
attrs = ["dnsHostName", "lastLogon"]
- res = self.ldb.search(expression="(&(codePage=x)(nextRid=x))", attrs=attrs)
+ res = self.ldb.search(expression="(&(codePage=x)(nextRid=x))",
+ attrs=attrs)
self.assertEquals(len(res), 0)
- res = self.ldb.search(expression="(&(revision=x)(lastLogon=z))", attrs=attrs)
+ res = self.ldb.search(expression="(&(revision=x)(lastLogon=z))",
+ attrs=attrs)
self.assertEquals(len(res), 0)
# Search by disjunction of local attributes
- attrs = ["dnsHostName", "lastLogon"]
- res = self.ldb.search(expression="(|(revision=x)(dnsHostName=x))", attrs=attrs)
+ res = self.ldb.search(expression="(|(revision=x)(dnsHostName=x))",
+ attrs=["dnsHostName", "lastLogon"])
self.assertEquals(len(res), 2)
self.assertEquals(str(res[0].dn), self.samba4.dn("cn=Y"))
self.assertEquals(res[0]["dnsHostName"], "y")
self.assertEquals(res[1]["lastLogon"], "x")
# Search by disjunction of remote attributes
- attrs = ["dnsHostName", "lastLogon"]
- res = self.ldb.search(expression="(|(badPwdCount=x)(lastLogon=x))", attrs=attrs)
+ res = self.ldb.search(expression="(|(badPwdCount=x)(lastLogon=x))",
+ attrs=["dnsHostName", "lastLogon"])
self.assertEquals(len(res), 3)
self.assertEquals(str(res[0].dn), self.samba4.dn("cn=B"))
- self.assertTrue("dnsHostName" in res[0])
+ self.assertFalse("dnsHostName" in res[0])
self.assertEquals(res[0]["lastLogon"], "y")
self.assertEquals(str(res[1].dn), self.samba4.dn("cn=X"))
self.assertEquals(res[1]["dnsHostName"], "x")
self.assertEquals(res[1]["lastLogon"], "x")
self.assertEquals(str(res[2].dn), self.samba4.dn("cn=A"))
- self.assertTrue("dnsHostName" in res[2])
+ self.assertFalse("dnsHostName" in res[2])
self.assertEquals(res[2]["lastLogon"], "x")
# Search by disjunction of local and remote attribute
- attrs = ["dnsHostName", "lastLogon"]
- res = self.ldb.search(expression="(|(revision=x)(lastLogon=y))", attrs=attrs)
+ res = self.ldb.search(expression="(|(revision=x)(lastLogon=y))",
+ attrs=["dnsHostName", "lastLogon"])
self.assertEquals(len(res), 3)
self.assertEquals(str(res[0].dn), self.samba4.dn("cn=Y"))
self.assertEquals(res[0]["dnsHostName"], "y")
self.assertEquals(res[0]["lastLogon"], "y")
self.assertEquals(str(res[1].dn), self.samba4.dn("cn=B"))
- self.assertTrue("dnsHostName" in res[1])
+ self.assertFalse("dnsHostName" in res[1])
self.assertEquals(res[1]["lastLogon"], "y")
self.assertEquals(str(res[2].dn), self.samba4.dn("cn=X"))
self.assertEquals(res[2]["dnsHostName"], "x")
self.assertEquals(res[2]["lastLogon"], "x")
# Search by disjunction of local and remote attribute w/o match
- attrs = ["dnsHostName", "lastLogon"]
- res = self.ldb.search(expression="(|(codePage=y)(nextRid=z))", attrs=attrs)
+ res = self.ldb.search(expression="(|(codePage=y)(nextRid=z))",
+ attrs=["dnsHostName", "lastLogon"])
self.assertEquals(len(res), 0)
# Search by negated local attribute
- attrs = ["dnsHostName", "lastLogon"]
- res = self.ldb.search(expression="(!(revision=x))", attrs=attrs)
+ res = self.ldb.search(expression="(!(revision=x))",
+ attrs=["dnsHostName", "lastLogon"])
self.assertEquals(len(res), 5)
self.assertEquals(str(res[0].dn), self.samba4.dn("cn=B"))
self.assertTrue(not "dnsHostName" in res[0])
self.assertEquals(res[3]["lastLogon"], "z")
# Search by negated remote attribute
- attrs = ["dnsHostName", "lastLogon"]
- res = self.ldb.search(expression="(!(description=x))", attrs=attrs)
+ res = self.ldb.search(expression="(!(description=x))",
+ attrs=["dnsHostName", "lastLogon"])
self.assertEquals(len(res), 3)
self.assertEquals(str(res[0].dn), self.samba4.dn("cn=Z"))
self.assertEquals(res[0]["dnsHostName"], "z")
self.assertEquals(res[1]["lastLogon"], "z")
# Search by negated conjunction of local attributes
- attrs = ["dnsHostName", "lastLogon"]
- res = self.ldb.search(expression="(!(&(codePage=x)(revision=x)))", attrs=attrs)
+ res = self.ldb.search(expression="(!(&(codePage=x)(revision=x)))",
+ attrs=["dnsHostName", "lastLogon"])
self.assertEquals(len(res), 5)
self.assertEquals(str(res[0].dn), self.samba4.dn("cn=B"))
self.assertTrue(not "dnsHostName" in res[0])
self.assertEquals(res[3]["lastLogon"], "z")
# Search by negated conjunction of remote attributes
- attrs = ["dnsHostName", "lastLogon"]
- res = self.ldb.search(expression="(!(&(lastLogon=x)(description=x)))", attrs=attrs)
+ res = self.ldb.search(expression="(!(&(lastLogon=x)(description=x)))",
+ attrs=["dnsHostName", "lastLogon"])
self.assertEquals(len(res), 5)
self.assertEquals(str(res[0].dn), self.samba4.dn("cn=Y"))
self.assertEquals(res[0]["dnsHostName"], "y")
self.assertEquals(res[3]["lastLogon"], "z")
# Search by negated conjunction of local and remote attribute
- attrs = ["dnsHostName", "lastLogon"]
- res = self.ldb.search(expression="(!(&(codePage=x)(description=x)))", attrs=attrs)
+ res = self.ldb.search(expression="(!(&(codePage=x)(description=x)))",
+ attrs=["dnsHostName", "lastLogon"])
self.assertEquals(len(res), 5)
self.assertEquals(str(res[0].dn), self.samba4.dn("cn=B"))
self.assertTrue(not "dnsHostName" in res[0])
self.assertEquals(res[3]["lastLogon"], "z")
# Search by negated disjunction of local attributes
- attrs = ["dnsHostName", "lastLogon"]
- res = self.ldb.search(expression="(!(|(revision=x)(dnsHostName=x)))", attrs=attrs)
+ res = self.ldb.search(expression="(!(|(revision=x)(dnsHostName=x)))",
+ attrs=["dnsHostName", "lastLogon"])
self.assertEquals(str(res[0].dn), self.samba4.dn("cn=B"))
self.assertTrue(not "dnsHostName" in res[0])
self.assertEquals(res[0]["lastLogon"], "y")
self.assertEquals(res[3]["lastLogon"], "z")
# Search by negated disjunction of remote attributes
- attrs = ["dnsHostName", "lastLogon"]
- res = self.ldb.search(expression="(!(|(badPwdCount=x)(lastLogon=x)))", attrs=attrs)
+ res = self.ldb.search(expression="(!(|(badPwdCount=x)(lastLogon=x)))",
+ attrs=["dnsHostName", "lastLogon"])
self.assertEquals(len(res), 4)
self.assertEquals(str(res[0].dn), self.samba4.dn("cn=Y"))
self.assertEquals(res[0]["dnsHostName"], "y")
self.assertEquals(res[2]["lastLogon"], "z")
# Search by negated disjunction of local and remote attribute
- attrs = ["dnsHostName", "lastLogon"]
- res = self.ldb.search(expression="(!(|(revision=x)(lastLogon=y)))", attrs=attrs)
+ res = self.ldb.search(expression="(!(|(revision=x)(lastLogon=y)))",
+ attrs=["dnsHostName", "lastLogon"])
self.assertEquals(len(res), 4)
self.assertEquals(str(res[0].dn), self.samba4.dn("cn=A"))
self.assertTrue(not "dnsHostName" in res[0])
self.assertTrue(not "dnsHostName" in res[2])
self.assertEquals(res[2]["lastLogon"], "z")
- print "Search by complex parse tree"
- attrs = ["dnsHostName", "lastLogon"]
- res = self.ldb.search(expression="(|(&(revision=x)(dnsHostName=x))(!(&(description=x)(nextRid=y)))(badPwdCount=y))", attrs=attrs)
+ # Search by complex parse tree
+ res = self.ldb.search(expression="(|(&(revision=x)(dnsHostName=x))(!(&(description=x)(nextRid=y)))(badPwdCount=y))", attrs=["dnsHostName", "lastLogon"])
self.assertEquals(len(res), 6)
self.assertEquals(str(res[0].dn), self.samba4.dn("cn=B"))
self.assertTrue(not "dnsHostName" in res[0])
self.assertEquals(res[0]["revision"], "1")
self.assertEquals(res[0]["description"], "test")
# Check it's not in the local db
- res = self.samba4.db.search(expression="(cn=test)", scope=SCOPE_DEFAULT, attrs=attrs)
+ res = self.samba4.db.search(expression="(cn=test)",
+ scope=SCOPE_DEFAULT, attrs=attrs)
self.assertEquals(len(res), 0)
# Check it's not in the remote db
- res = self.samba3.db.search(expression="(cn=test)", scope=SCOPE_DEFAULT, attrs=attrs)
+ res = self.samba3.db.search(expression="(cn=test)",
+ scope=SCOPE_DEFAULT, attrs=attrs)
self.assertEquals(len(res), 0)
# Modify local record
"sambaBadPasswordCount": "3",
"sambaNextRid": "1001"})
# Check it's there
- attrs = ["description", "sambaBadPasswordCount", "sambaNextRid"]
- res = self.samba3.db.search(dn2, scope=SCOPE_BASE, attrs=attrs)
+ res = self.samba3.db.search(dn2, scope=SCOPE_BASE,
+ attrs=["description", "sambaBadPasswordCount", "sambaNextRid"])
self.assertEquals(len(res), 1)
self.assertEquals(str(res[0].dn), dn2)
self.assertEquals(res[0]["description"], "foo")
self.assertEquals(res[0]["sambaNextRid"], "1001")
# Check in mapped db
attrs = ["description", "badPwdCount", "nextRid"]
- res = self.ldb.search(dn, scope=SCOPE_BASE, attrs=attrs)
+ res = self.ldb.search(dn, scope=SCOPE_BASE, attrs=attrs, expression="")
self.assertEquals(len(res), 1)
self.assertEquals(str(res[0].dn), dn)
self.assertEquals(res[0]["description"], "foo")
"""
self.ldb.modify_ldif(ldif)
# Check in mapped db
- attrs = ["description", "badPwdCount", "nextRid"]
- res = self.ldb.search(dn, scope=SCOPE_BASE, attrs=attrs)
+ res = self.ldb.search(dn, scope=SCOPE_BASE,
+ attrs=["description", "badPwdCount", "nextRid"])
self.assertEquals(len(res), 1)
self.assertEquals(str(res[0].dn), dn)
self.assertEquals(res[0]["description"], "test")
self.assertEquals(res[0]["badPwdCount"], "4")
self.assertEquals(res[0]["nextRid"], "1001")
# Check in remote db
- attrs = ["description", "sambaBadPasswordCount", "sambaNextRid"]
- res = self.samba3.db.search(dn2, scope=SCOPE_BASE, attrs=attrs)
+ res = self.samba3.db.search(dn2, scope=SCOPE_BASE,
+ attrs=["description", "sambaBadPasswordCount", "sambaNextRid"])
self.assertEquals(len(res), 1)
self.assertEquals(str(res[0].dn), dn2)
self.assertEquals(res[0]["description"], "test")
self.ldb.rename(dn, dn2)
# Check in mapped db
dn = dn2
- attrs = ["description", "badPwdCount", "nextRid"]
- res = self.ldb.search(dn, scope=SCOPE_BASE, attrs=attrs)
+ res = self.ldb.search(dn, scope=SCOPE_BASE,
+ attrs=["description", "badPwdCount", "nextRid"])
self.assertEquals(len(res), 1)
self.assertEquals(str(res[0].dn), dn)
self.assertEquals(res[0]["description"], "test")
self.assertEquals(res[0]["nextRid"], "1001")
# Check in remote db
dn2 = self.samba3.dn("cn=toast")
- attrs = ["description", "sambaBadPasswordCount", "sambaNextRid"]
- res = self.samba3.db.search(dn2, scope=SCOPE_BASE, attrs=attrs)
+ res = self.samba3.db.search(dn2, scope=SCOPE_BASE,
+ attrs=["description", "sambaBadPasswordCount", "sambaNextRid"])
self.assertEquals(len(res), 1)
self.assertEquals(str(res[0].dn), dn2)
self.assertEquals(res[0]["description"], "test")
# Delete remote record
self.ldb.delete(dn)
- # Check in mapped db
+ # Check in mapped db that it's removed
res = self.ldb.search(dn, scope=SCOPE_BASE)
self.assertEquals(len(res), 0)
# Check in remote db
revision: 1
replace: description
description: test
+
"""
self.ldb.modify_ldif(ldif)
# Check in mapped db
self.assertTrue(not "nextRid" in res[0])
self.assertEquals(res[0]["revision"], "1")
# Check in remote db
- attrs = ["description", "sambaBadPasswordCount", "sambaNextRid", "revision"]
+ attrs = ["description", "sambaBadPasswordCount", "sambaNextRid",
+ "revision"]
res = self.samba3.db.search(dn2, scope=SCOPE_BASE, attrs=attrs)
self.assertEquals(len(res), 1)
self.assertEquals(str(res[0].dn), dn2)
self.assertTrue(not "nextRid" in res[0])
self.assertEquals(res[0]["revision"], "2")
# Check in remote db
- attrs = ["description", "sambaBadPasswordCount", "sambaNextRid", "revision"]
+ attrs = ["description", "sambaBadPasswordCount", "sambaNextRid",
+ "revision"]
res = self.samba3.db.search(dn2, scope=SCOPE_BASE, attrs=attrs)
self.assertEquals(len(res), 1)
self.assertEquals(str(res[0].dn), dn2)
self.assertEquals(res[0]["revision"], "2")
# Check in remote db
dn2 = self.samba3.dn("cn=toast")
- attrs = ["description", "sambaBadPasswordCount", "sambaNextRid", "revision"]
- res = self.samba3.db.search(dn2, scope=SCOPE_BASE, attrs=attrs)
+ res = self.samba3.db.search(dn2, scope=SCOPE_BASE,
+ attrs=["description", "sambaBadPasswordCount", "sambaNextRid",
+ "revision"])
self.assertEquals(len(res), 1)
self.assertEquals(str(res[0].dn), dn2)
self.assertEquals(res[0]["description"], "test")
struct dn_list *changed_dns;
};
+struct update_kt_ctx {
+ struct ldb_module *module;
+ struct ldb_request *req;
+
+ struct ldb_dn *dn;
+ bool delete;
+
+ struct ldb_reply *op_reply;
+ bool found;
+};
+
+struct update_kt_ctx *update_kt_ctx_init(struct ldb_module *module,
+ struct ldb_request *req)
+{
+ struct update_kt_ctx *ac;
+
+ ac = talloc_zero(req, struct update_kt_ctx);
+ if (ac == NULL) {
+ ldb_oom(module->ldb);
+ return NULL;
+ }
+
+ ac->module = module;
+ ac->req = req;
+
+ return ac;
+}
+
+/* FIXME: too many semi-async searches here for my taste, direct and indirect as
+ * cli_credentials_set_secrets() performs a sync ldb search.
+ * Just hope we are lucky and nothing breaks (using the tdb backend masks a lot
+ * of async issues). -SSS
+ */
static int add_modified(struct ldb_module *module, struct ldb_dn *dn, bool delete) {
struct update_kt_private *data = talloc_get_type(module->private_data, struct update_kt_private);
struct dn_list *item;
return LDB_ERR_OPERATIONS_ERROR;
}
- ret = ldb_search(module->ldb, dn, LDB_SCOPE_BASE,
- filter, attrs, &res);
+ ret = ldb_search(module->ldb, data, &res,
+ dn, LDB_SCOPE_BASE, attrs, "%s", filter);
if (ret != LDB_SUCCESS) {
talloc_free(filter);
return ret;
ldb_oom(module->ldb);
return LDB_ERR_OPERATIONS_ERROR;
}
-
+
item->creds = cli_credentials_init(item);
if (!item->creds) {
DEBUG(1, ("cli_credentials_init failed!"));
}
cli_credentials_set_conf(item->creds, ldb_get_opaque(module->ldb, "loadparm"));
- status = cli_credentials_set_secrets(item->creds, ldb_get_opaque(module->ldb, "EventContext"), ldb_get_opaque(module->ldb, "loadparm"), module->ldb, NULL, filter);
+ status = cli_credentials_set_secrets(item->creds, ldb_get_event_context(module->ldb), ldb_get_opaque(module->ldb, "loadparm"), module->ldb, NULL, filter);
talloc_free(filter);
if (NT_STATUS_IS_OK(status)) {
if (delete) {
return LDB_SUCCESS;
}
+static int ukt_search_modified(struct update_kt_ctx *ac);
+
+static int update_kt_op_callback(struct ldb_request *req,
+ struct ldb_reply *ares)
+{
+ struct update_kt_ctx *ac;
+ int ret;
+
+ ac = talloc_get_type(req->context, struct update_kt_ctx);
+
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
+
+ if (ares->type != LDB_REPLY_DONE) {
+ ldb_set_errstring(ac->module->ldb, "Invalid request type!\n");
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+
+ if (ac->delete) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, LDB_SUCCESS);
+ }
+
+ ac->op_reply = talloc_steal(ac, ares);
+
+ ret = ukt_search_modified(ac);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL, ret);
+ }
+
+ return LDB_SUCCESS;
+}
+
+static int ukt_del_op(struct update_kt_ctx *ac)
+{
+ struct ldb_request *down_req;
+ int ret;
+
+ ret = ldb_build_del_req(&down_req, ac->module->ldb, ac,
+ ac->dn,
+ ac->req->controls,
+ ac, update_kt_op_callback,
+ ac->req);
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
+ return ldb_next_request(ac->module, down_req);
+}
+
+static int ukt_search_modified_callback(struct ldb_request *req,
+ struct ldb_reply *ares)
+{
+ struct update_kt_ctx *ac;
+ int ret;
+
+ ac = talloc_get_type(req->context, struct update_kt_ctx);
+
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
+
+ switch (ares->type) {
+ case LDB_REPLY_ENTRY:
+
+ ac->found = true;
+ break;
+
+ case LDB_REPLY_REFERRAL:
+ /* ignore */
+ break;
+
+ case LDB_REPLY_DONE:
+
+ if (ac->found) {
+ /* do the dirty sync job here :/ */
+ ret = add_modified(ac->module, ac->dn, ac->delete);
+ }
+
+ if (ac->delete) {
+ ret = ukt_del_op(ac);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req,
+ NULL, NULL, ret);
+ }
+ break;
+ }
+
+ return ldb_module_done(ac->req, ac->op_reply->controls,
+ ac->op_reply->response, LDB_SUCCESS);
+ }
+
+ talloc_free(ares);
+ return LDB_SUCCESS;
+}
+
+static int ukt_search_modified(struct update_kt_ctx *ac)
+{
+ static const char * const attrs[] = { "distinguishedName", NULL };
+ struct ldb_request *search_req;
+ int ret;
+
+ ret = ldb_build_search_req(&search_req, ac->module->ldb, ac,
+ ac->dn, LDB_SCOPE_BASE,
+ "(&(objectClass=kerberosSecret)"
+ "(privateKeytab=*))", attrs,
+ NULL,
+ ac, ukt_search_modified_callback,
+ ac->req);
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
+ return ldb_next_request(ac->module, search_req);
+}
+
+
/* add */
static int update_kt_add(struct ldb_module *module, struct ldb_request *req)
{
+ struct update_kt_ctx *ac;
+ struct ldb_request *down_req;
int ret;
- ret = ldb_next_request(module, req);
+
+ ac = update_kt_ctx_init(module, req);
+ if (ac == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ ac->dn = req->op.add.message->dn;
+
+ ret = ldb_build_add_req(&down_req, module->ldb, ac,
+ req->op.add.message,
+ req->controls,
+ ac, update_kt_op_callback,
+ req);
if (ret != LDB_SUCCESS) {
return ret;
}
- return add_modified(module, req->op.add.message->dn, false);
+
+ return ldb_next_request(module, down_req);
}
/* modify */
static int update_kt_modify(struct ldb_module *module, struct ldb_request *req)
{
+ struct update_kt_ctx *ac;
+ struct ldb_request *down_req;
int ret;
- ret = ldb_next_request(module, req);
+
+ ac = update_kt_ctx_init(module, req);
+ if (ac == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ ac->dn = req->op.mod.message->dn;
+
+ ret = ldb_build_mod_req(&down_req, module->ldb, ac,
+ req->op.mod.message,
+ req->controls,
+ ac, update_kt_op_callback,
+ req);
if (ret != LDB_SUCCESS) {
return ret;
}
- return add_modified(module, req->op.mod.message->dn, false);
+
+ return ldb_next_request(module, down_req);
}
/* delete */
static int update_kt_delete(struct ldb_module *module, struct ldb_request *req)
{
- int ret;
- /* Before we delete it, record the details */
- ret = add_modified(module, req->op.del.dn, true);
- if (ret != LDB_SUCCESS) {
- return ret;
+ struct update_kt_ctx *ac;
+
+ ac = update_kt_ctx_init(module, req);
+ if (ac == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
}
- return ldb_next_request(module, req);
+
+ ac->dn = req->op.del.dn;
+ ac->delete = true;
+
+ return ukt_search_modified(ac);
}
/* rename */
static int update_kt_rename(struct ldb_module *module, struct ldb_request *req)
{
+ struct update_kt_ctx *ac;
+ struct ldb_request *down_req;
int ret;
- ret = ldb_next_request(module, req);
+
+ ac = update_kt_ctx_init(module, req);
+ if (ac == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ ac->dn = req->op.rename.newdn;
+
+ ret = ldb_build_rename_req(&down_req, module->ldb, ac,
+ req->op.rename.olddn,
+ req->op.rename.newdn,
+ req->controls,
+ ac, update_kt_op_callback,
+ req);
if (ret != LDB_SUCCESS) {
return ret;
}
- return add_modified(module, req->op.rename.newdn, false);
+
+ return ldb_next_request(module, down_req);
}
/* end a transaction */
static int update_kt_end_trans(struct ldb_module *module)
{
struct update_kt_private *data = talloc_get_type(module->private_data, struct update_kt_private);
-
struct dn_list *p;
+
for (p=data->changed_dns; p; p = p->next) {
int kret;
- kret = cli_credentials_update_keytab(p->creds, ldb_get_opaque(module->ldb, "EventContext"), ldb_get_opaque(module->ldb, "loadparm"));
+ kret = cli_credentials_update_keytab(p->creds, ldb_get_event_context(module->ldb), ldb_get_opaque(module->ldb, "loadparm"));
if (kret != 0) {
talloc_free(data->changed_dns);
data->changed_dns = NULL;
talloc_free(data->changed_dns);
data->changed_dns = NULL;
+
return ldb_next_end_trans(module);
}
static int update_kt_del_trans(struct ldb_module *module)
{
struct update_kt_private *data = talloc_get_type(module->private_data, struct update_kt_private);
-
+
talloc_free(data->changed_dns);
data->changed_dns = NULL;
}
/* pull the template record */
- ret = ldb_search(templates_ldb, basedn, LDB_SCOPE_BASE, "distinguishedName=*", NULL, &res);
+ ret = ldb_search(templates_ldb, msg, &res, basedn, LDB_SCOPE_BASE, NULL, "distinguishedName=*");
talloc_free(basedn);
if (ret != LDB_SUCCESS) {
*errstring = talloc_steal(msg, ldb_errstring(templates_ldb));
struct ldb_module *module;
};
+#define DSDB_CONTROL_REPLICATED_UPDATE_OID "1.3.6.1.4.1.7165.4.3.3"
+/* DSDB_CONTROL_REPLICATED_UPDATE_OID has NULL data */
+
#define DSDB_EXTENDED_REPLICATED_OBJECTS_OID "1.3.6.1.4.1.7165.4.4.1"
struct dsdb_extended_replicated_object {
struct ldb_message *msg;
const char *seperator,
const char *oid,
const char *name,
- const char *description,
const char *equality,
const char *substring,
const char *syntax,
"NAME '%s'%s", name, seperator);
IF_NULL_FAIL_RET(schema_entry);
- if (description) {
-#if 0
- /* Need a way to escape ' characters from the description */
- schema_entry = talloc_asprintf_append(schema_entry,
- "DESC '%s'%s", description, seperator);
- IF_NULL_FAIL_RET(schema_entry);
-#endif
- }
-
if (equality) {
schema_entry = talloc_asprintf_append(schema_entry,
"EQUALITY %s%s", equality, seperator);
" ",
attribute->attributeID_oid,
attribute->lDAPDisplayName,
- NULL, NULL, NULL, talloc_asprintf(tmp_ctx, "'%s'", syntax),
+ NULL, NULL, talloc_asprintf(tmp_ctx, "'%s'", syntax),
attribute->isSingleValued,
attribute->systemOnly);
talloc_free(tmp_ctx);
const char *oid,
const char *name,
const char **auxillary_classes,
- const char *description,
const char *subClassOf,
int objectClassCategory,
char **must,
"NAME '%s'%s", name, seperator);
IF_NULL_FAIL_RET(schema_entry);
- if (description) {
- schema_entry = talloc_asprintf_append(schema_entry,
- "DESC '%s'%s", description, seperator);
- IF_NULL_FAIL_RET(schema_entry);
- }
-
if (auxillary_classes) {
schema_entry = talloc_asprintf_append(schema_entry,
"AUX ( ");
" ",
class->governsID_oid,
class->lDAPDisplayName,
- NULL,
NULL,
class->subClassOf,
class->objectClassCategory,
class->governsID_oid,
class->lDAPDisplayName,
(const char **)aux_class_list,
- NULL,
- class->subClassOf,
+ NULL, /* Must not specify a
+ * SUP (subclass) in
+ * ditContentRules
+ * per MS-ADTS
+ * 3.1.1.3.1.1.1 */
-1, must_attr_list, may_attr_list);
talloc_free(tmp_ctx);
return schema_description;
return WERR_FOOBAR;
}
- ret = ldb_search(ldb, schema_dn, LDB_SCOPE_BASE,NULL, schema_attrs,&schema_res);
+ ret = ldb_search(ldb, mem_ctx, &schema_res, schema_dn, LDB_SCOPE_BASE, schema_attrs, NULL);
if (ret == LDB_ERR_NO_SUCH_OBJECT) {
DEBUG(0,("dsdb_read_prefixes_from_ldb: no prefix map present\n"));
+ talloc_free(schema_res);
return WERR_FOOBAR;
} else if (ret != LDB_SUCCESS) {
DEBUG(0,("dsdb_read_prefixes_from_ldb: failed to search the schema head\n"));
+ talloc_free(schema_res);
return WERR_FOOBAR;
}
prefix_val = ldb_msg_find_ldb_val(schema_res->msgs[0], "prefixMap");
if (!prefix_val) {
DEBUG(0,("dsdb_read_prefixes_from_ldb: no prefixMap attribute found\n"));
+ talloc_free(schema_res);
return WERR_FOOBAR;
}
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
DEBUG(0,("dsdb_read_prefixes_from_ldb: ndr_pull_struct_blob failed\n"));
talloc_free(blob);
+ talloc_free(schema_res);
return WERR_FOOBAR;
}
+ talloc_free(schema_res);
+
if (blob->version != PREFIX_MAP_VERSION_DSDB) {
DEBUG(0,("dsdb_read_prefixes_from_ldb: blob->version incorect\n"));
talloc_free(blob);
const char *name = ldb_msg_find_attr_as_string(search_from->msgs[i],
"lDAPDisplayname", NULL);
- ret = ldb_search_exp_fmt(ldb, mem_ctx, &res,
+ ret = ldb_search(ldb, mem_ctx, &res,
schemadn, LDB_SCOPE_SUBTREE, NULL,
"(&(&(objectClass=classSchema)(subClassOf=%s))(!(lDAPDisplayName=%s)))",
name, name);
}
/* Download 'top' */
- ret = ldb_search(ldb, schemadn, LDB_SCOPE_SUBTREE,
- "(&(objectClass=classSchema)(lDAPDisplayName=top))",
- NULL, &top_res);
+ ret = ldb_search(ldb, local_ctx, &top_res,
+ schemadn, LDB_SCOPE_SUBTREE, NULL,
+ "(&(objectClass=classSchema)(lDAPDisplayName=top))");
if (ret != LDB_SUCCESS) {
*error_string = talloc_asprintf(mem_ctx,
"dsdb_schema: failed to search for top classSchema object: %s",
return ret;
}
- talloc_steal(local_ctx, top_res);
-
if (top_res->count != 1) {
*error_string = talloc_asprintf(mem_ctx,
"dsdb_schema: failed to find top classSchema object");
/*
* setup the prefix mappings and schema info
*/
- ret = ldb_search(ldb, schema_dn,
- LDB_SCOPE_BASE,
- NULL, schema_attrs,
- &schema_res);
+ ret = ldb_search(ldb, tmp_ctx, &schema_res,
+ schema_dn, LDB_SCOPE_BASE, schema_attrs, NULL);
if (ret == LDB_ERR_NO_SUCH_OBJECT) {
talloc_free(tmp_ctx);
return ret;
talloc_free(tmp_ctx);
return ret;
}
- talloc_steal(tmp_ctx, schema_res);
if (schema_res->count != 1) {
*error_string_out = talloc_asprintf(mem_ctx,
"dsdb_schema: [%u] schema heads found on a base search",
/*
* load the attribute definitions
*/
- ret = ldb_search(ldb, schema_dn,
- LDB_SCOPE_ONELEVEL,
- "(objectClass=attributeSchema)", NULL,
- &a_res);
+ ret = ldb_search(ldb, tmp_ctx, &a_res,
+ schema_dn, LDB_SCOPE_ONELEVEL, NULL,
+ "(objectClass=attributeSchema)");
if (ret != LDB_SUCCESS) {
*error_string_out = talloc_asprintf(mem_ctx,
"dsdb_schema: failed to search attributeSchema objects: %s",
talloc_free(tmp_ctx);
return ret;
}
- talloc_steal(tmp_ctx, a_res);
/*
* load the objectClass definitions
/* Try to avoid churning the attributes too much - we only want to do this if they have changed */
- ret = ldb_search_exp_fmt(ldb, mem_ctx, &res, msg->dn, LDB_SCOPE_BASE, NULL, "dn=%s", ldb_dn_get_linearized(msg->dn));
+ ret = ldb_search(ldb, mem_ctx, &res, msg->dn, LDB_SCOPE_BASE, NULL, "dn=%s", ldb_dn_get_linearized(msg->dn));
if (ret == LDB_ERR_NO_SUCH_OBJECT) {
ret = ldb_add(ldb, msg);
} else if (ret != LDB_SUCCESS) {
/* Now write out the indexs, as found in the schema (if they have changed) */
- ret = ldb_search_exp_fmt(ldb, mem_ctx, &res_idx, msg_idx->dn, LDB_SCOPE_BASE, NULL, "dn=%s", ldb_dn_get_linearized(msg_idx->dn));
+ ret = ldb_search(ldb, mem_ctx, &res_idx, msg_idx->dn, LDB_SCOPE_BASE, NULL, "dn=%s", ldb_dn_get_linearized(msg_idx->dn));
if (ret == LDB_ERR_NO_SUCH_OBJECT) {
ret = ldb_add(ldb, msg_idx);
} else if (ret != LDB_SUCCESS) {
DYNCONFIG_OBJ_FILES = $(dynconfigsrcdir)/dynconfig.o
# set these to where to find various files
-# These can be overridden by command line switches (see smbd(8))
+# These can be overridden by command line switches (see samba(8))
# or in smb.conf (see smb.conf(5))
-CONFIGFILE = $(sysconfdir)/smb.conf
-PKGCONFIGDIR = $(libdir)/pkgconfig
-LMHOSTSFILE = $(sysconfdir)/lmhosts
+CONFIG4FILE = $(sysconfdir)/smb.conf
+pkgconfigdir = $(libdir)/pkgconfig
+LMHOSTSFILE4 = $(sysconfdir)/lmhosts
-$(dynconfigsrcdir)/dynconfig.o: CFLAGS+=-DCONFIGFILE=\"$(CONFIGFILE)\" -DBINDIR=\"$(bindir)\" \
- -DLMHOSTSFILE=\"$(LMHOSTSFILE)\" \
+$(dynconfigsrcdir)/dynconfig.o: CFLAGS+=-DCONFIGFILE=\"$(CONFIG4FILE)\" -DBINDIR=\"$(bindir)\" \
+ -DLMHOSTSFILE=\"$(LMHOSTSFILE4)\" \
-DLOCKDIR=\"$(lockdir)\" -DPIDDIR=\"$(piddir)\" -DDATADIR=\"$(datadir)\" \
-DLOGFILEBASE=\"$(logfilebase)\" \
- -DCONFIGDIR=\"$(sysconfdir)\" -DNCALRPCDIR=\"$(NCALRPCDIR)\" \
- -DSWATDIR=\"$(SWATDIR)\" \
+ -DCONFIGDIR=\"$(sysconfdir)\" -DNCALRPCDIR=\"$(ncalrpcdir)\" \
+ -DSWATDIR=\"$(swatdir)\" \
-DPRIVATE_DIR=\"$(privatedir)\" \
- -DMODULESDIR=\"$(modulesdir)\" -DJSDIR=\"$(JSDIR)\" \
- -DTORTUREDIR=\"$(TORTUREDIR)\" \
- -DSETUPDIR=\"$(SETUPDIR)\" \
+ -DMODULESDIR=\"$(modulesdir)\" \
+ -DTORTUREDIR=\"$(torturedir)\" \
+ -DSETUPDIR=\"$(setupdir)\" \
-DWINBINDD_PRIVILEGED_SOCKET_DIR=\"$(winbindd_privileged_socket_dir)\" \
-DWINBINDD_SOCKET_DIR=\"$(winbindd_socket_dir)\" \
-DNTP_SIGND_SOCKET_DIR=\"$(ntp_signd_socket_dir)\"
/** SETUP files (source files used by the provision) */
_PUBLIC_ const char *dyn_SETUPDIR = SETUPDIR;
-/** EJS Javascript library includes */
-_PUBLIC_ const char *dyn_JSDIR = JSDIR;
-
/** Where to find the winbindd socket */
_PUBLIC_ const char *dyn_WINBINDD_SOCKET_DIR = WINBINDD_SOCKET_DIR;
char opt_str[128];
int signedpath = 0;
+ Key *tkey;
+
memset(&sessionkey, 0, sizeof(sessionkey));
memset(&adtkt, 0, sizeof(adtkt));
krb5_data_zero(&rspac);
}
/* check PAC if not cross realm and if there is one */
- if (!cross_realm) {
- Key *tkey;
-
- ret = hdb_enctype2key(context, &krbtgt->entry,
- krbtgt_etype, &tkey);
- if(ret) {
- kdc_log(context, config, 0,
+ ret = hdb_enctype2key(context, &krbtgt->entry,
+ krbtgt_etype, &tkey);
+ if(ret) {
+ kdc_log(context, config, 0,
"Failed to find key for krbtgt PAC check");
- goto out;
- }
+ goto out;
+ }
- ret = check_PAC(context, config, cp,
- client, server, ekey, &tkey->key,
- tgt, &rspac, &signedpath);
- if (ret) {
- kdc_log(context, config, 0,
- "Verify PAC failed for %s (%s) from %s with %s",
- spn, cpn, from, krb5_get_err_text(context, ret));
- goto out;
- }
+ ret = check_PAC(context, config, cp,
+ client, server, ekey, &tkey->key,
+ tgt, &rspac, &signedpath);
+ if (ret) {
+ kdc_log(context, config, 0,
+ "Verify PAC failed for %s (%s) from %s with %s",
+ spn, cpn, from, krb5_get_err_text(context, ret));
+ goto out;
}
/* also check the krbtgt for signature */
* SUCH DAMAGE.
*/
+#include "krb5.h"
+#include "krb5_locl.h"
#include "hdb_locl.h"
-
RCSID("$Id$");
#ifdef HAVE_DLFCN_H
#include <dlfcn.h>
#endif
-struct hdb_method {
- const char *prefix;
- krb5_error_code (*create)(krb5_context, HDB **, const char *filename);
-};
-
static struct hdb_method methods[] = {
#if HAVE_DB1 || HAVE_DB3
- {"db:", hdb_db_create},
+ {HDB_INTERFACE_VERSION, "db:", hdb_db_create},
#endif
#if HAVE_NDBM
- {"ndbm:", hdb_ndbm_create},
+ {HDB_INTERFACE_VERSION, "ndbm:", hdb_ndbm_create},
#endif
#if defined(OPENLDAP) && !defined(OPENLDAP_MODULE)
- {"ldap:", hdb_ldap_create},
- {"ldapi:", hdb_ldapi_create},
-#endif
-#ifdef HAVE_LDB /* Used for integrated samba build */
- {"ldb:", hdb_ldb_create},
+ {HDB_INTERFACE_VERSION, "ldap:", hdb_ldap_create},
+ {HDB_INTERFACE_VERSION, "ldapi:", hdb_ldapi_create},
#endif
- {NULL, NULL}
+ {0, NULL, NULL}
};
#if HAVE_DB1 || HAVE_DB3
{
const struct hdb_method *h;
const char *residual;
+ krb5_error_code ret;
+ struct krb5_plugin *list = NULL, *e;
if(filename == NULL)
filename = HDB_DEFAULT_DB;
krb5_add_et_list(context, initialize_hdb_error_table_r);
h = find_method (filename, &residual);
+
+ if (h == NULL) {
+ ret = _krb5_plugin_find(context, PLUGIN_TYPE_DATA, "hdb", &list);
+ if(ret == 0 && list != NULL) {
+ for (e = list; e != NULL; e = _krb5_plugin_get_next(e)) {
+ h = _krb5_plugin_get_symbol(e);
+ if (strncmp (filename, h->prefix, strlen(h->prefix)) == 0
+ && h->interface_version == HDB_INTERFACE_VERSION) {
+ residual = filename + strlen(h->prefix);
+ break;
+ }
+ }
+ if (e == NULL) {
+ h = NULL;
+ _krb5_plugin_free(list);
+ }
+ }
+ }
+
#ifdef HAVE_DLOPEN
if (h == NULL)
h = find_dynamic_method (context, filename, &residual);
hdb_entry_ex*, void*);
extern krb5_kt_ops hdb_kt_ops;
+struct hdb_method {
+ int interface_version;
+ const char *prefix;
+ krb5_error_code (*create)(krb5_context, HDB **, const char *filename);
+};
+
#include <hdb-protos.h>
#endif /* __HDB_H__ */
# Start SUBSYSTEM KDC
[MODULE::KDC]
INIT_FUNCTION = server_service_kdc_init
-SUBSYSTEM = smbd
+SUBSYSTEM = samba
PRIVATE_DEPENDENCIES = \
- HEIMDAL_KDC HDB_LDB
+ HEIMDAL_KDC HDB_SAMBA4
# End SUBSYSTEM KDC
#######################
#######################
# Start SUBSYSTEM KDC
-[SUBSYSTEM::HDB_LDB]
+[SUBSYSTEM::HDB_SAMBA4]
CFLAGS = -Iheimdal/kdc -Iheimdal/lib/hdb
PRIVATE_DEPENDENCIES = \
LIBLDB auth_sam auth_sam_reply CREDENTIALS \
# End SUBSYSTEM KDC
#######################
-HDB_LDB_OBJ_FILES = $(addprefix $(kdcsrcdir)/, hdb-ldb.o pac-glue.o)
-$(eval $(call proto_header_template,$(kdcsrcdir)/pac_glue.h,$(HDB_LDB_OBJ_FILES:.o=.c)))
+HDB_SAMBA4_OBJ_FILES = $(addprefix $(kdcsrcdir)/, hdb-samba4.o pac-glue.o)
+$(eval $(call proto_header_template,$(kdcsrcdir)/pac_glue.h,$(HDB_SAMBA4_OBJ_FILES:.o=.c)))
#include "param/param.h"
#include "events/events.h"
#include "kdc/kdc.h"
-#include "lib/crypto/md4.h"
+#include "../lib/crypto/md4.h"
enum hdb_ldb_ent_type
-{ HDB_LDB_ENT_TYPE_CLIENT, HDB_LDB_ENT_TYPE_SERVER,
- HDB_LDB_ENT_TYPE_KRBTGT, HDB_LDB_ENT_TYPE_TRUST, HDB_LDB_ENT_TYPE_ANY };
+{ HDB_SAMBA4_ENT_TYPE_CLIENT, HDB_SAMBA4_ENT_TYPE_SERVER,
+ HDB_SAMBA4_ENT_TYPE_KRBTGT, HDB_SAMBA4_ENT_TYPE_TRUST, HDB_SAMBA4_ENT_TYPE_ANY };
enum trust_direction {
UNKNOWN = 0,
/* Account types - clear the invalid bit if it turns out to be valid */
if (userAccountControl & UF_NORMAL_ACCOUNT) {
- if (ent_type == HDB_LDB_ENT_TYPE_CLIENT || ent_type == HDB_LDB_ENT_TYPE_ANY) {
+ if (ent_type == HDB_SAMBA4_ENT_TYPE_CLIENT || ent_type == HDB_SAMBA4_ENT_TYPE_ANY) {
flags.client = 1;
}
flags.invalid = 0;
}
if (userAccountControl & UF_INTERDOMAIN_TRUST_ACCOUNT) {
- if (ent_type == HDB_LDB_ENT_TYPE_CLIENT || ent_type == HDB_LDB_ENT_TYPE_ANY) {
+ if (ent_type == HDB_SAMBA4_ENT_TYPE_CLIENT || ent_type == HDB_SAMBA4_ENT_TYPE_ANY) {
flags.client = 1;
}
flags.invalid = 0;
}
if (userAccountControl & UF_WORKSTATION_TRUST_ACCOUNT) {
- if (ent_type == HDB_LDB_ENT_TYPE_CLIENT || ent_type == HDB_LDB_ENT_TYPE_ANY) {
+ if (ent_type == HDB_SAMBA4_ENT_TYPE_CLIENT || ent_type == HDB_SAMBA4_ENT_TYPE_ANY) {
flags.client = 1;
}
flags.invalid = 0;
}
if (userAccountControl & UF_SERVER_TRUST_ACCOUNT) {
- if (ent_type == HDB_LDB_ENT_TYPE_CLIENT || ent_type == HDB_LDB_ENT_TYPE_ANY) {
+ if (ent_type == HDB_SAMBA4_ENT_TYPE_CLIENT || ent_type == HDB_SAMBA4_ENT_TYPE_ANY) {
flags.client = 1;
}
flags.invalid = 0;
return flags;
}
-static int hdb_ldb_destrutor(struct hdb_ldb_private *private)
+static int hdb_ldb_destructor(struct hdb_ldb_private *private)
{
hdb_entry_ex *entry_ex = private->entry_ex;
free_hdb_entry(&entry_ex->entry);
private->iconv_convenience = lp_iconv_convenience(lp_ctx);
private->netbios_name = lp_netbios_name(lp_ctx);
- talloc_set_destructor(private, hdb_ldb_destrutor);
+ talloc_set_destructor(private, hdb_ldb_destructor);
entry_ex->ctx = private;
entry_ex->free_entry = hdb_ldb_free_entry;
entry_ex->entry.principal = malloc(sizeof(*(entry_ex->entry.principal)));
- if (ent_type == HDB_LDB_ENT_TYPE_ANY && principal == NULL) {
+ if (ent_type == HDB_SAMBA4_ENT_TYPE_ANY && principal == NULL) {
const char *samAccountName = ldb_msg_find_attr_as_string(msg, "samAccountName", NULL);
if (!samAccountName) {
krb5_set_error_string(context, "LDB_message2entry: no samAccountName present");
entry_ex->entry.flags = uf2HDBFlags(context, userAccountControl, ent_type);
- if (ent_type == HDB_LDB_ENT_TYPE_KRBTGT) {
+ if (ent_type == HDB_SAMBA4_ENT_TYPE_KRBTGT) {
entry_ex->entry.flags.invalid = 0;
entry_ex->entry.flags.server = 1;
entry_ex->entry.flags.forwardable = 1;
*entry_ex->entry.valid_end = nt_time_to_unix(acct_expiry);
}
- if (ent_type != HDB_LDB_ENT_TYPE_KRBTGT) {
+ if (ent_type != HDB_SAMBA4_ENT_TYPE_KRBTGT) {
NTTIME must_change_time
= samdb_result_force_password_change((struct ldb_context *)db->hdb_db, mem_ctx,
domain_dn, msg);
private->iconv_convenience = lp_iconv_convenience(lp_ctx);
private->netbios_name = lp_netbios_name(lp_ctx);
- talloc_set_destructor(private, hdb_ldb_destrutor);
+ talloc_set_destructor(private, hdb_ldb_destructor);
entry_ex->ctx = private;
entry_ex->free_entry = hdb_ldb_free_entry;
goto out;
}
- ndr_err = ndr_pull_struct_blob_all(password_val, mem_ctx, private->iconv_convenience, &password_blob,
+ ndr_err = ndr_pull_struct_blob(password_val, mem_ctx, private->iconv_convenience, &password_blob,
(ndr_pull_flags_fn_t)ndr_pull_trustAuthInOutBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
ret = EINVAL;
goto out;
}
+ entry_ex->entry.kvno = -1;
+ for (i=0; i < password_blob.count; i++) {
+ if (password_blob.current->array[i].AuthType == TRUST_AUTH_TYPE_VERSION) {
+ entry_ex->entry.kvno = password_blob.current->array[i].AuthInfo.version.version;
+ }
+ }
+
for (i=0; i < password_blob.count; i++) {
if (password_blob.current->array[i].AuthType == TRUST_AUTH_TYPE_CLEAR) {
password_utf16 = data_blob_const(password_blob.current->array[i].AuthInfo.clear.password,
entry_ex->entry.keys.len++;
}
+ entry_ex->entry.principal = malloc(sizeof(*(entry_ex->entry.principal)));
+
ret = copy_Principal(principal, entry_ex->entry.principal);
if (ret) {
krb5_clear_error_string(context);
}
switch (ent_type) {
- case HDB_LDB_ENT_TYPE_CLIENT:
- case HDB_LDB_ENT_TYPE_TRUST:
- case HDB_LDB_ENT_TYPE_ANY:
+ case HDB_SAMBA4_ENT_TYPE_CLIENT:
+ case HDB_SAMBA4_ENT_TYPE_TRUST:
+ case HDB_SAMBA4_ENT_TYPE_ANY:
/* Can't happen */
return EINVAL;
- case HDB_LDB_ENT_TYPE_KRBTGT:
+ case HDB_SAMBA4_ENT_TYPE_KRBTGT:
filter = talloc_asprintf(mem_ctx, "(&(objectClass=user)(samAccountName=%s))",
KRB5_TGS_NAME);
break;
- case HDB_LDB_ENT_TYPE_SERVER:
+ case HDB_SAMBA4_ENT_TYPE_SERVER:
filter = talloc_asprintf(mem_ctx, "(&(objectClass=user)(samAccountName=%s))",
short_princ_talloc);
break;
return ENOMEM;
}
- lret = ldb_search(ldb_ctx, realm_dn, LDB_SCOPE_SUBTREE, filter, princ_attrs, &res);
-
+ lret = ldb_search(ldb_ctx, mem_ctx, &res, realm_dn,
+ LDB_SCOPE_SUBTREE, princ_attrs, "%s", filter);
if (lret != LDB_SUCCESS) {
DEBUG(3, ("Failed to search for %s: %s\n", filter, ldb_errstring(ldb_ctx)));
return HDB_ERR_NOENTRY;
return ENOMEM;
}
- lret = ldb_search(ldb_ctx, ldb_get_default_basedn(ldb_ctx), LDB_SCOPE_SUBTREE, filter, attrs, &res);
-
+ lret = ldb_search(ldb_ctx, mem_ctx, &res,
+ ldb_get_default_basedn(ldb_ctx),
+ LDB_SCOPE_SUBTREE, attrs, "%s", filter);
if (lret != LDB_SUCCESS) {
DEBUG(3, ("Failed to search for %s: %s\n", filter, ldb_errstring(ldb_ctx)));
return HDB_ERR_NOENTRY;
struct ldb_result *cross_ref_res;
struct ldb_dn *partitions_basedn = samdb_partitions_dn(ldb_ctx, mem_ctx);
- ret = ldb_search_exp_fmt(ldb_ctx, mem_ctx, &cross_ref_res,
+ ret = ldb_search(ldb_ctx, mem_ctx, &cross_ref_res,
partitions_basedn, LDB_SCOPE_SUBTREE, realm_ref_attrs,
"(&(&(|(&(dnsRoot=%s)(nETBIOSName=*))(nETBIOSName=%s))(objectclass=crossRef))(ncName=*))",
realm, realm);
}
ret = LDB_message2entry(context, db, mem_ctx,
- principal, HDB_LDB_ENT_TYPE_CLIENT,
+ principal, HDB_SAMBA4_ENT_TYPE_CLIENT,
msg[0], realm_ref_msg[0], entry_ex);
return ret;
}
ret = LDB_lookup_principal(context, (struct ldb_context *)db->hdb_db,
mem_ctx,
- principal, HDB_LDB_ENT_TYPE_KRBTGT, realm_dn, &msg);
+ principal, HDB_SAMBA4_ENT_TYPE_KRBTGT, realm_dn, &msg);
if (ret != 0) {
krb5_warnx(context, "LDB_fetch: could not find principal in DB");
}
ret = LDB_message2entry(context, db, mem_ctx,
- principal, HDB_LDB_ENT_TYPE_KRBTGT,
+ principal, HDB_SAMBA4_ENT_TYPE_KRBTGT,
msg[0], realm_ref_msg_1[0], entry_ex);
if (ret != 0) {
- krb5_warnx(context, "LDB_fetch: message2entry failed");
+ krb5_warnx(context, "LDB_fetch: self krbtgt message2entry failed");
}
return ret;
principal, direction,
msg[0], entry_ex);
if (ret != 0) {
- krb5_warnx(context, "LDB_fetch: message2entry failed");
+ krb5_warnx(context, "LDB_fetch: trust_message2entry failed");
}
return ret;
ret = LDB_lookup_principal(context, (struct ldb_context *)db->hdb_db,
mem_ctx,
- principal, HDB_LDB_ENT_TYPE_SERVER, realm_dn, &msg);
+ principal, HDB_SAMBA4_ENT_TYPE_SERVER, realm_dn, &msg);
if (ret != 0) {
return ret;
}
ret = LDB_message2entry(context, db, mem_ctx,
- principal, HDB_LDB_ENT_TYPE_SERVER,
+ principal, HDB_SAMBA4_ENT_TYPE_SERVER,
msg[0], realm_ref_msg[0], entry_ex);
if (ret != 0) {
krb5_warnx(context, "LDB_fetch: message2entry failed");
if (priv->index < priv->count) {
ret = LDB_message2entry(context, db, mem_ctx,
- NULL, HDB_LDB_ENT_TYPE_ANY,
+ NULL, HDB_SAMBA4_ENT_TYPE_ANY,
priv->msgs[priv->index++],
priv->realm_ref_msgs[0], entry);
} else {
priv->realm_ref_msgs = talloc_steal(priv, realm_ref_msgs);
- lret = ldb_search(ldb_ctx, realm_dn,
- LDB_SCOPE_SUBTREE, "(objectClass=user)",
- user_attrs, &res);
+ lret = ldb_search(ldb_ctx, priv, &res,
+ realm_dn, LDB_SCOPE_SUBTREE, user_attrs,
+ "(objectClass=user)");
if (lret != LDB_SUCCESS) {
talloc_free(priv);
* (hdb_ldb_create) from the kpasswdd -> krb5 -> keytab_hdb -> hdb
* code */
-NTSTATUS kdc_hdb_ldb_create(TALLOC_CTX *mem_ctx,
+NTSTATUS kdc_hdb_samba4_create(TALLOC_CTX *mem_ctx,
struct event_context *ev_ctx,
struct loadparm_context *lp_ctx,
krb5_context context, struct HDB **db, const char *arg)
return NT_STATUS_OK;
}
-krb5_error_code hdb_ldb_create(krb5_context context, struct HDB **db, const char *arg)
+krb5_error_code hdb_samba4_create(krb5_context context, struct HDB **db, const char *arg)
{
NTSTATUS nt_status;
/* The global kdc_mem_ctx and kdc_lp_ctx, Disgusting, ugly hack, but it means one less private hook */
- nt_status = kdc_hdb_ldb_create(kdc_mem_ctx, event_context_find(kdc_mem_ctx), kdc_lp_ctx,
- context, db, arg);
+ nt_status = kdc_hdb_samba4_create(kdc_mem_ctx, event_context_find(kdc_mem_ctx), kdc_lp_ctx,
+ context, db, arg);
if (NT_STATUS_IS_OK(nt_status)) {
return 0;
/* within the kdc task we want to be a single process, so
ask for the single process model ops and pass these to the
stream_setup_socket() call. */
- model_ops = process_model_byname("single");
+ model_ops = process_model_startup(kdc->task->event_ctx, "single");
if (!model_ops) {
DEBUG(0,("Can't find 'single' process model_ops\n"));
talloc_free(kdc_socket);
return NT_STATUS_INVALID_PARAMETER;
}
-#if 0
- /* Windows does not check this */
if (pac_validate.MessageType != 3) {
/* We don't implement any other message types - such as certificate validation - yet */
return NT_STATUS_INVALID_PARAMETER;
}
-#endif
+
if (pac_validate.ChecksumAndSignature.length != (pac_validate.ChecksumLength + pac_validate.SignatureLength)
|| pac_validate.ChecksumAndSignature.length < pac_validate.ChecksumLength
|| pac_validate.ChecksumAndSignature.length < pac_validate.SignatureLength ) {
NTSTATUS status;
krb5_error_code ret;
struct interface *ifaces;
+ struct hdb_method hdb_samba4 = {
+ .interface_version = HDB_INTERFACE_VERSION,
+ .prefix = "samba4:",
+ .create = hdb_samba4_create
+ };
switch (lp_server_role(task->lp_ctx)) {
case ROLE_STANDALONE:
}
kdc->config->num_db = 1;
- status = kdc_hdb_ldb_create(kdc, task->event_ctx, task->lp_ctx,
+ status = kdc_hdb_samba4_create(kdc, task->event_ctx, task->lp_ctx,
kdc->smb_krb5_context->krb5_context,
&kdc->config->db[0], NULL);
if (!NT_STATUS_IS_OK(status)) {
return;
}
+
+ /* Register hdb-samba4 hooks */
+ ret = krb5_plugin_register(kdc->smb_krb5_context->krb5_context,
+ PLUGIN_TYPE_DATA, "hdb",
+ &hdb_samba4);
+ if(ret) {
+ task_server_terminate(task, "kdc: failed to register hdb keytab");
+ return;
+ }
+
ret = krb5_kt_register(kdc->smb_krb5_context->krb5_context, &hdb_kt_ops);
if(ret) {
task_server_terminate(task, "kdc: failed to register hdb keytab");
# Start SUBSYSTEM LDAP
[MODULE::LDAP]
INIT_FUNCTION = server_service_ldap_init
-SUBSYSTEM = smbd
+SUBSYSTEM = samba
PRIVATE_DEPENDENCIES = CREDENTIALS \
LIBCLI_LDAP SAMDB \
process_model \
struct ldb_dn *basedn;
struct ldb_result *res = NULL;
struct ldb_request *lreq;
+ struct ldb_control *search_control;
+ struct ldb_search_options_control *search_options;
enum ldb_scope scope = LDB_SCOPE_DEFAULT;
const char **attrs = NULL;
const char *scope_str, *errstr = NULL;
DEBUG(5,("ldb_request %s dn=%s filter=%s\n",
scope_str, req->basedn, ldb_filter_from_tree(call, req->tree)));
- lreq = talloc(local_ctx, struct ldb_request);
- NT_STATUS_HAVE_NO_MEMORY(lreq);
+ res = talloc_zero(local_ctx, struct ldb_result);
+ NT_STATUS_HAVE_NO_MEMORY(res);
- lreq->operation = LDB_SEARCH;
- lreq->op.search.base = basedn;
- lreq->op.search.scope = scope;
- lreq->op.search.tree = req->tree;
- lreq->op.search.attrs = attrs;
+ ldb_ret = ldb_build_search_req_ex(&lreq, samdb, local_ctx,
+ basedn, scope,
+ req->tree, attrs,
+ call->request->controls,
+ res, ldb_search_default_callback,
+ NULL);
- lreq->controls = call->request->controls;
+ if (ldb_ret != LDB_SUCCESS) {
+ goto reply;
+ }
if (call->conn->global_catalog) {
- struct ldb_control *search_control = ldb_request_get_control(lreq, LDB_CONTROL_SEARCH_OPTIONS_OID);
-
- struct ldb_search_options_control *search_options = NULL;
+ search_control = ldb_request_get_control(lreq, LDB_CONTROL_SEARCH_OPTIONS_OID);
+
+ search_options = NULL;
if (search_control) {
search_options = talloc_get_type(search_control->data, struct ldb_search_options_control);
search_options->search_options |= LDB_SEARCH_OPTION_PHANTOM_ROOT;
ldb_request_add_control(lreq, LDB_CONTROL_SEARCH_OPTIONS_OID, false, search_options);
}
}
-
- res = talloc_zero(lreq, struct ldb_result);
- NT_STATUS_HAVE_NO_MEMORY(res);
-
- lreq->context = res;
- lreq->callback = ldb_search_default_callback;
-
- /* Copy the timeout from the incoming call */
ldb_set_timeout(samdb, lreq, req->timelimit);
ldb_ret = ldb_request(samdb, lreq);
NT_STATUS_HAVE_NO_MEMORY(compare_r);
if (result == LDAP_SUCCESS) {
- ldb_ret = ldb_search(samdb, dn, LDB_SCOPE_BASE, filter, attrs, &res);
- talloc_steal(local_ctx, res);
+ ldb_ret = ldb_search(samdb, local_ctx, &res,
+ dn, LDB_SCOPE_BASE, attrs, "%s", filter);
if (ldb_ret != LDB_SUCCESS) {
result = map_ldb_error(samdb, ldb_ret, &errstr);
DEBUG(10,("CompareRequest: error: %s\n", errstr));
input = *req->creds.SASL.secblob;
}
- resp->SASL.secblob = talloc(reply, DATA_BLOB);
- NT_STATUS_HAVE_NO_MEMORY(resp->SASL.secblob);
-
status = gensec_update(conn->gensec, reply,
input, &output);
} else {
ctx->conn = conn;
status = gensec_socket_init(conn->gensec,
+ conn->connection,
conn->connection->socket,
conn->connection->event.ctx,
stream_io_handler_callback,
goto failed;
}
- ret = ldb_search(conn->ldb, basedn, LDB_SCOPE_BASE, NULL, attrs, &res);
+ ret = ldb_search(conn->ldb, tmp_ctx, &res, basedn, LDB_SCOPE_BASE, attrs, NULL);
if (ret != LDB_SUCCESS) {
goto failed;
}
- talloc_steal(tmp_ctx, res);
-
if (res->count != 1) {
goto failed;
}
goto failed;
}
- ret = ldb_search(conn->ldb, policy_dn, LDB_SCOPE_BASE, NULL, attrs2, &res);
+ ret = ldb_search(conn->ldb, tmp_ctx, &res, policy_dn, LDB_SCOPE_BASE, attrs2, NULL);
if (ret != LDB_SUCCESS) {
goto failed;
}
- talloc_steal(tmp_ctx, res);
-
if (res->count != 1) {
goto failed;
}
task_server_set_title(task, "task[ldapsrv]");
/* run the ldap server as a single process */
- model_ops = process_model_byname("single");
+ model_ops = process_model_startup(task->event_ctx, "single");
if (!model_ops) goto failed;
ldap_service = talloc_zero(task, struct ldapsrv_service);
+++ /dev/null
-The lib/appweb directory is a partial import of the appweb ejs and esp
-code from http://www.appwebserver.org/
-
-Many thanks to the mbedthis people, and especially Michael O'Brien for
-his assistance in getting this code integrated into Samba4.
-
+++ /dev/null
-AC_CHECK_HEADERS(math.h)
+++ /dev/null
-#######################
-# Start SUBSYSTEM MPR
-[SUBSYSTEM::MPR]
-# End SUBSYSTEM MPR
-#######################
-
-MPR_OBJ_FILES = $(addprefix $(appwebsrcdir)/mpr/, miniMpr.o var.o)
-
-#######################
-# Start SUBSYSTEM EJS
-[SUBSYSTEM::EJS]
-PUBLIC_DEPENDENCIES = MPR
-# End SUBSYSTEM EJS
-#######################
-
-EJS_OBJ_FILES = $(addprefix $(appwebsrcdir)/ejs/, ejsLib.o ejsLex.o ejsParser.o ejsProcs.o)
-
-#######################
-# Start SUBSYSTEM ESP
-[SUBSYSTEM::ESP]
-PUBLIC_DEPENDENCIES = EJS
-# End SUBSYSTEM ESP
-#######################
-
-ESP_OBJ_FILES = $(addprefix $(appwebsrcdir)/esp/, esp.o espProcs.o)
+++ /dev/null
-#
-# .bashrc -- Login shell startup script for windows using Mbedthis winTools
-#
-# Copyright (c) Mbedthis Software, 2003-2005. All Rights Reserved.
-#
-
-TERM=ansi
-#
-# Set the desired .NET Framework
-#
-# FRAMEWORK=v1.0.3705
-FRAMEWORK=v1.1.4322
-# FRAMEWORK=v2.0.40607
-
-#
-# Set the desired Microsoft C Compiler version
-#
-# PREFERRED_CC=VS2005
-# PREFERRED_CC=VS2003
-# PREFERRED_CC=VS.NET
-PREFERRED_CC=VS6
-
-#
-# Set to 1 if VXWORKS support is required
-#
-# VXWORKS=1
-
-HOME=`pwd`
-if [ ! -x winTools -o ! -x winTools/cygpath.exe ]
-then
- echo "Can't find build tools. Install build tools in $HOME/winTools"
-fi
-
-ROOT=`winTools/cygpath -u $HOMEDRIVE`
-: ${ROOT:=C:/}
-APPWEB_PATH="${HOME}/bin/DEBUG:${HOME}/bin/RELEASE:${HOME}/bin:${HOME}/winTools"
-CDPATH=".:${HOME}:${HOME}/http:${HOME}/http/modules:${HOME}/packages"
-PS1="$ "
-
-export CDPATH INCLUDE LIB LIBPATH PATH PS1 TERM
-
-echo -e "\n\n###################################################"
-echo "Mbedthis AppWeb, Cygwin build tools."
-echo "Using compiler: $PREFERRED_CC, .NET framework: $FRAMEWORK"
-echo -e "###################################################"
-
-################################################################################
-
-#
-# Setup for Visual Studio and SDK
-#
-if [ $PREFERRED_CC == "VS2005" ]
-then
- #
- # Visual Studio .NET 2005 defines.
- #
- CYNET="${ROOT}/Program Files/Microsoft Visual Studio 8"
- DOSNET="C:/Program Files/Microsoft Visual Studio 8"
- PATH="$APPWEB_PATH:$CYNET/Common7/IDE:$CYNET/VC/BIN:$CYNET/VC/VCPackages:$CYNET/Common7/Tools:$CYNET/Common7/Tools/bin:$CYNET/SDK/v2.0/bin:`cygpath -W`/Microsoft.NET/Framework/v2.0.40607:$CYNET/SDK/v2.0/bin:$PATH"
- INCLUDE="$DOSNET/VC/ATLMFC/INCLUDE;$DOSNET/VC/INCLUDE;$DOSNET/VC/PlatformSDK/include;$DOSNET/SDK/v2.0/include;$INCLUDE"
- LIB="$DOSNET/VC/ATLMFC/LIB;$DOSNET/VC/LIB;$DOSNET/VC/PlatformSDK/lib;$DOSNET/SDK/v2.0/lib;$LIB"
- LIBPATH=c:/WINDOWS/Microsoft.NET/Framework/$FRAMEWORK
-fi
-
-if [ $PREFERRED_CC == "VS2003" ]
-then
- #
- # Visual Studio .NET 2003 defines.
- #
- CYNET="${ROOT}/Program Files/Microsoft Visual Studio .NET 2003"
- DOSNET="C:/Program Files/Microsoft Visual Studio .NET 2003"
- PATH="$APPWEB_PATH:$CYNET/Common7/IDE:$CYNET/VC7/BIN:$CYNET/Common7/Tools:$CYNET/Common7/Tools/bin/prerelease:$CYNET/Common7/Tools/bin:$CYNET/FrameworkSDK/bin:${ROOT}/WINDOWS/Microsoft.NET/Framework/$FRAMEWORK:$CYNET/SDK/v1.1/bin:$PATH"
- INCLUDE="$DOSNET/VC7/ATLMFC/INCLUDE;$DOSNET/VC7/INCLUDE;$DOSNET/VC7/PlatformSDK/include/prerelease;$DOSNET/VC7/PlatformSDK/include;$DOSNET/FrameworkSDK/include;$INCLUDE"
- LIB="$DOSNET/VC7/ATLMFC/LIB;$DOSNET/VC7/LIB;$DOSNET/VC7/PlatformSDK/lib/prerelease;$DOSNET/VC7/PlatformSDK/lib;$DOSNET/FrameworkSDK/lib;$LIB"
-fi
-
-
-if [ $PREFERRED_CC == "VS.NET" ]
-then
- #
- # Visual Studio .NET defines.
- #
- CYNET="${ROOT}/Program Files/Microsoft Visual Studio .NET"
- DOSNET="C:/Program Files/Microsoft Visual Studio .NET"
- PATH="$APPWEB_PATH:$CYNET/Common7/IDE:$CYNET/VC7/BIN:$CYNET/Common7/Tools:$CYNET/Common7/Tools/bin/prerelease:$CYNET/Common7/Tools/bin:$CYNET/FrameworkSDK/bin:${ROOT}/WINDOWS/Microsoft.NET/Framework/$FRAMEWORK:$CYNET/SDK/v1.0/bin:$PATH"
- INCLUDE="$DOSNET/VC7/ATLMFC/INCLUDE;$DOSNET/VC7/INCLUDE;$DOSNET/VC7/PlatformSDK/include/prerelease;$DOSNET/VC7/PlatformSDK/include;$DOSNET/FrameworkSDK/include;$INCLUDE"
- LIB="$DOSNET/VC7/ATLMFC/LIB;$DOSNET/VC7/LIB;$DOSNET/VC7/PlatformSDK/lib/prerelease;$DOSNET/VC7/PlatformSDK/lib;$DOSNET/FrameworkSDK/lib;$LIB"
-fi
-
-
-if [ $PREFERRED_CC == "VS6" ]
-then
- # Visual Studio 6 defines.
- #
- CYNET="${ROOT}/Program Files/Microsoft Visual Studio"
- DOSNET="C:/Program Files/Microsoft Visual Studio"
- PATH="$APPWEB_PATH:$CYNET/Common/MSDev98/bin:$CYNET/VC98/BIN:$CYNET/Common/IDE:$CYNET/Common/Tools/WinNT:$CYNET/Common/Tools:$PATH"
- INCLUDE="$DOSNET/VC98/ATLMFC/INCLUDE;$DOSNET/VC98/INCLUDE;$DOSNET/VC98/MFC/INCLUDE;$INCLUDE"
- LIB="$DOSNET/VC98/LIB;$DOSNET/VC98/MFC/LIB;$LIB"
-fi
-
-if [ $VXWORKS ]
-then
- #
- # Required by VxWorks
- #
- WIND_BASE=C:/tornado
- WIND_HOST_TYPE=x86-win32
- WIND_REGISTRY=coalsack
- WIND_LMHOST=coalsack
- BLD_VX_HOST=i386-wrs-vxworks
- VX_TOOLS=`cygpath $WIND_BASE`/host/$WIND_HOST_TYPE
- export WIND_BASE WIND_HOST_TYPE WIND_REGISTRY WIND_LMHOST BLD_VX_HOST
-
- #
- # Use cygwin make and tools by preference
- #
- PATH="$APPWEB_PATH:$VX_TOOLS/bin:$PATH"
-fi
-
-#
-# Make required directories for CYGWIN
-#
-if [ ! -x /bin/bash.exe ]
-then
- DIR=`cygpath -w "$HOME/winTools"`
- echo -e "\nCreating /bin"
- echo Mounting \"${DIR}\" as /bin\a
- mount -f -b "$DIR" /bin
-fi
-
-if [ ! -x /tmp ]
-then
- mkdir -p tmp
- DIR=`cygpath -w "$HOME/tmp"`
- echo -e "\nCreating /tmp"
- echo Mounting \"${DIR}\" as /tmp\a
- mount -f -b "$DIR" /tmp
-fi
-echo
-
-################################################################################
-#
-# Do a bit of validation
-#
-type cl 2>/dev/null >/dev/null
-if [ $? -ne 0 ]
-then
- echo "Can't find compiler: cl. Check WIN/bashrc settings for PATH"
-fi
-set -o vi
-
-################################################################################
+++ /dev/null
-set ts=4 sw=4
+++ /dev/null
-*.class
-*.dll
-*.exe
-*.exp
-*.jar
-*.lib
-*.lnk
-*.map
-*.new
-*.old
-*.pdb
-*.res
-*.sln
-*.suo
-*.sym
-*.tmp
-*.sav
-.ICEauthority
-.bash_history
-.changes
-.cvsignore
-.esd_auth
-.fonts.cache-1
-.viminfo
-make.dep
-thumbs.db
-vc70.pdb
-*.ncb
-*.opt
-*.idb
-*.pch
-*.dep
-*.aps
-all
-tmp
-make.vars
-sh.vars
-config.make
-config.h
-config.sh
-configure
-make.os
-.firstBuild
-.viminfo
-.ssh
-_viminfo
-buildConfig.h
-buildConfig.make
-buildConfig.sh
-.ccache
-appWeb.kdev*
-subversion
-.vimrc
-.subversion
-.ignore
-njs
-msvc
+++ /dev/null
-#
-# .loginrc -- Michael's login shell startup script (used only for Windows)
-#
-# NOTE: this should not be distributed with releases.
-#
-# Copyright (c) Mbedthis Software, 2003-2005. All Rights Reserved.
-#
-HOME=`pwd`
-
-TERM=ansi
-CYROOT=/cygdrive/c
-JDK="/cygdrive/c/program files/java/jdk1.5.0_07/bin"
-H=$CYROOT
-R=usr/svn/appWeb/main
-CDPATH=".:${H}/usr/svn/appWeb:${H}/${R}/http:${H}/${R}/http/modules:${H}/${R}:${H}/usr/svn/appWeb/releases:${H}/usr/svn/packages:${H}/usr/svn/bling/player/trunk:${H}/usr/svn/bling/player/trunk/src:${H}/usr/svn/bling/player/trunk/appdir:${H}/usr/svn:${H}:${H}/usr/svn:${H}/usr"
-APPWEB_PATH="${H}/${R}/bin/DEBUG:${H}/${R}/bin/RELEASE:${H}/${R}/bin:${H}/usr/bin"
-PATH="${H}/usr/bin:/usr/local/bin:/usr/bin:/bin:/usr/X11R6/bin:$PATH:${H}/tcl/bin:${JDK}"
-
-CLASSPATH="c:/usr/svn/j/ggperf"
-PS1='`cygpath -m $PWD`> '
-SVN_EDITOR=C:/cygwin/bin/vim.exe
-
-umask 022
-
-export TERM CDPATH INCLUDE LIB LIBPATH PATH PS1 SVN_EDITOR MSCL CLASSPATH
-
-################################################################################
-#
-# Set the dev environment PATH and other critical environment variables
-#
-
-# export BLD_ALTERNATE_CONFIG=WIN/buildConfig
-
-#
-# Desired .NET Framework
-#
-# FRAMEWORK=v1.0.3705
-# FRAMEWORK=v1.1.4322
-FRAMEWORK=v2.0.50727
-
-#
-# Desired C Compiler
-#
-# MSCL=VS2005
-# MSCL=VS2003
-# MSCL=VS.NET
-MSCL=VS6
-VXWORKS=1
-
-echo "Using compiler: $MSCL, .NET framework: $FRAMEWORK"
-
-#
-# Setup for Visual Studio and SDK
-#
-if [ $MSCL == "VS2005" ]
-then
- #
- # Visual Studio .NET 2005 defines.
- #
- CYNET="$H/Program Files/Microsoft Visual Studio 8"
- DOSNET="C:/Program Files/Microsoft Visual Studio 8"
- PATH="$APPWEB_PATH:$CYNET/Common7/IDE:$CYNET/VC/BIN:$CYNET/VC/VCPackages:$CYNET/Common7/Tools:$CYNET/Common7/Tools/bin:$CYNET/SDK/v2.0/bin:$CYROOT/WINDOWS/Microsoft.NET/Framework/v2.0.40607:$CYNET/SDK/v2.0/bin:$PATH"
- INCLUDE="$DOSNET/VC/ATLMFC/INCLUDE;$DOSNET/VC/INCLUDE;$DOSNET/VC/PlatformSDK/include;$DOSNET/SDK/v2.0/include;$INCLUDE"
- LIB="$DOSNET/VC/ATLMFC/LIB;$DOSNET/VC/LIB;$DOSNET/VC/PlatformSDK/lib;$DOSNET/SDK/v2.0/lib;$LIB"
- LIBPATH=c:/WINDOWS/Microsoft.NET/Framework/$FRAMEWORK
-
- # MOB -- old
- # PATH="$APPWEB_PATH:$CYNET/Common7/IDE:$CYNET/VC/BIN:$CYNET/Common7/Tools:$CYNET/Common7/Tools/bin/prerelease:$CYNET/Common7/Tools/bin:$CYNET/FrameworkSDK/bin:$H/WINDOWS/Microsoft.NET/Framework/$FRAMEWORK:$PATH"
- # INCLUDE="$DOSNET/VC/ATLMFC/INCLUDE;$DOSNET/VC/INCLUDE;$DOSNET/VC/PlatformSDK/include/prerelease;$DOSNET/VC/PlatformSDK/include;$DOSNET/FrameworkSDK/include;$INCLUDE"
- # LIB="$DOSNET/VC/ATLMFC/LIB;$DOSNET/VC/LIB;$DOSNET/VC/PlatformSDK/lib/prerelease;$DOSNET/VC/PlatformSDK/lib;$DOSNET/FrameworkSDK/lib;$LIB"
-fi
-
-if [ $MSCL == "VS2003" ]
-then
- #
- # Visual Studio .NET 2003 defines.
- #
- CYNET="$H/Program Files/Microsoft Visual Studio .NET 2003"
- DOSNET="C:/Program Files/Microsoft Visual Studio .NET 2003"
- PATH="$APPWEB_PATH:$CYNET/Common7/IDE:$CYNET/VC7/BIN:$CYNET/Common7/Tools:$CYNET/Common7/Tools/bin/prerelease:$CYNET/Common7/Tools/bin:$CYNET/FrameworkSDK/bin:$H/WINDOWS/Microsoft.NET/Framework/$FRAMEWORK:$CYNET/SDK/v1.1/bin:$PATH"
- INCLUDE="$DOSNET/VC7/ATLMFC/INCLUDE;$DOSNET/VC7/INCLUDE;$DOSNET/VC7/PlatformSDK/include/prerelease;$DOSNET/VC7/PlatformSDK/include;$DOSNET/FrameworkSDK/include;$INCLUDE"
- LIB="$DOSNET/VC7/ATLMFC/LIB;$DOSNET/VC7/LIB;$DOSNET/VC7/PlatformSDK/lib/prerelease;$DOSNET/VC7/PlatformSDK/lib;$DOSNET/FrameworkSDK/lib;$LIB"
-fi
-
-
-if [ $MSCL == "VS.NET" ]
-then
- #
- # Visual Studio .NET defines.
- #
- CYNET="$H/Program Files/Microsoft Visual Studio .NET"
- DOSNET="C:/Program Files/Microsoft Visual Studio .NET"
- PATH="$APPWEB_PATH:$CYNET/Common7/IDE:$CYNET/VC7/BIN:$CYNET/Common7/Tools:$CYNET/Common7/Tools/bin/prerelease:$CYNET/Common7/Tools/bin:$CYNET/FrameworkSDK/bin:$H/WINDOWS/Microsoft.NET/Framework/$FRAMEWORK:$CYNET/SDK/v1.0/bin:$PATH"
- INCLUDE="$DOSNET/VC7/ATLMFC/INCLUDE;$DOSNET/VC7/INCLUDE;$DOSNET/VC7/PlatformSDK/include/prerelease;$DOSNET/VC7/PlatformSDK/include;$DOSNET/FrameworkSDK/include;$INCLUDE"
- LIB="$DOSNET/VC7/ATLMFC/LIB;$DOSNET/VC7/LIB;$DOSNET/VC7/PlatformSDK/lib/prerelease;$DOSNET/VC7/PlatformSDK/lib;$DOSNET/FrameworkSDK/lib;$LIB"
-fi
-
-
-if [ $MSCL == "VS6" ]
-then
- # Visual Studio 6 defines.
- #
- CYNET="$H/Program Files/Microsoft Visual Studio"
- DOSNET="C:/Program Files/Microsoft Visual Studio"
- PATH="$APPWEB_PATH:$CYNET/Common/MSDev98/bin:$CYNET/VC98/BIN:$CYNET/Common/IDE:$CYNET/Common/Tools/WinNT:$CYNET/Common/Tools:$PATH"
- # OLD PATH="$APPWEB_PATH:$CYNET/Common/IDE:$CYNET/VC98/BIN:$CYNET/Common/MSDev98/bin:$CYNET/Common/Tools:$CYNET/Common/Tools/bin/prerelease:$CYNET/Common/Tools/bin:$CYNET/FrameworkSDK/bin:$H/WINDOWS/Microsoft.NET/Framework/$FRAMEWORK:$PATH"
- INCLUDE="$DOSNET/VC98/ATLMFC/INCLUDE;$DOSNET/VC98/INCLUDE;$DOSNET/VC98/MFC/INCLUDE;$INCLUDE"
- LIB="$DOSNET/VC98/LIB;$DOSNET/VC98/MFC/LIB;$LIB"
-fi
-
-if [ $VXWORKS ]
-then
- #
- # Required by VxWorks
- #
- WIND_BASE=C:/tornado
- WIND_HOST_TYPE=x86-win32
- WIND_REGISTRY=coalsack
- WIND_LMHOST=coalsack
- BLD_VX_HOST=i386-wrs-vxworks
- export WIND_BASE WIND_HOST_TYPE WIND_REGISTRY WIND_LMHOST BLD_VX_HOST
-
- VX_TOOLS=`cygpath $WIND_BASE`/host/$WIND_HOST_TYPE
- #
- # Use cygwin make and tools by preference
- #
- PATH="$APPWEB_PATH:$PATH:$VX_TOOLS/bin"
-fi
-
-#
-# Make required directories for CYGWIN
-#
-if [ ! -x /bin/bash.exe ]
-then
- DIR=`cygpath -w "$HOME/winTools"`
- echo -e "\nCreating /bin"
- echo Mounting \"${DIR}\" as /bin\a
- mount -f -b "$DIR" /bin
-fi
-
-if [ ! -x /tmp ]
-then
- mkdir -p tmp
- DIR=`cygpath -w "$HOME/tmp"`
- echo -e "\nCreating /tmp"
- echo Mounting \"${DIR}\" as /tmp\a
- mount -f -b "$DIR" /tmp
-fi
-echo
-
-
-################################################################################
-#
-# Do a bit of validation (MOB -- extend)
-#
-type cl 2>/dev/null >/dev/null
-if [ $? -ne 0 ]
-then
- echo "Can't find compiler: cl. Check WIN/bashrc settings for PATH"
-fi
-
-################################################################################
-#
-# Some convenient functions
-#
-pvi () {
-
- pattern=$1
- shift
- files=$*
- if [ -z "${files}" ]
- then
- files='*.c *.cpp *.h Makefile *.html *.aspx *.cs'
- fi
- vi -c "/${pattern}" $(grep -l "${pattern}" ${files})
-}
-
-################################################################################
-
-g() {
- pattern=$1
- shift
- files=$*
- if [ -z "${files}" ]
- then
- files=`echo *.c *.cpp *.h Makefile *.html *.aspx *.cs`
- fi
- eval grep "${pattern}" ${files}
-}
-
-################################################################################
-
-usedvi() {
- pvi $1 $HOME/mr/*.c $HOME/mr/*.h $HOME/mr/WIN/*.c $HOME/lib/*/*.c
-}
-
-################################################################################
-
-alias ls='ls -CF $*'
-alias lc='ls -CF $*'
-alias lr='ls -R $*'
-alias xwin='startxwin.sh'
-alias htmlview='"C:/Program Files/Internet Explorer/iexplore.exe" $*'
-set -o vi
-
-if [ `uname -o` = "Cygwin" ]
-then
- alias vim='"C:/Program Files/vim/vim64/vim.exe" $*'
- alias gvim='"C:/Program Files/vim/vim64/gvim.exe" $*'
-fi
-
-brew() {
- "C:/Program Files/BREW SDK v2.1.3/Bin/BREW_Emulator.exe"
-}
-
-js() {
- cscript /nologo $*
-}
+++ /dev/null
-ejs
-future
+++ /dev/null
-#
-# Makefile for Embedded Javascript (EJS)
-#
-# Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
-#
-
-#
-# Ejs may be linked into shared handlers so we must build the objects both
-# shared and static if --shared was specified to configure.
-#
-COMPILE := *.c
-EXPORT_OBJECTS := yes
-PRE_DIRS := classes system db
-MAKE_IFLAGS := -I../mpr -I../exml
-
-include make.dep
-
-ifeq ($(BLD_PRODUCT),ejs)
-POST_DIRS := package
-endif
-
-ifeq ($(BLD_FEATURE_TEST),1)
-POST_DIRS += test
-endif
-
-ifeq ($(BLD_FEATURE_EJS_DB),1)
-LIBS += sqlite
-endif
-
-TARGETS += $(BLD_BIN_DIR)/libejs$(BLD_LIB)
-TARGETS += $(BLD_BIN_DIR)/ejs$(BLD_EXE)
-
-ifeq ($(BLD_FEATURE_EJS),1)
-compileExtra: $(TARGETS)
-endif
-
-$(BLD_BIN_DIR)/libejs$(BLD_LIB): files \
- $(shell BLD_OBJ=$(BLD_OBJ) \; BLD_OBJ_DIR=$(BLD_OBJ_DIR) \; \
- eval echo `cat files`)
- @bld --library $(BLD_BIN_DIR)/libejs \
- --objectsDir $(BLD_OBJ_DIR) --objectList files \
- --libs "exml mpr $(LIBS)"
-
-$(BLD_BIN_DIR)/ejs$(BLD_EXE): $(BLD_BIN_DIR)/libejs$(BLD_LIB) \
- $(BLD_BIN_DIR)/libmpr$(BLD_LIB) \
- $(BLD_BIN_DIR)/libejs$(BLD_LIB) $(FILES)
- @bld --executable $(BLD_BIN_DIR)/ejs$(BLD_EXE) \
- --rpath "$(BLD_PREFIX)/bin" \
- --preferStatic --smartLibs "ejs exml mpr $(LIBS)" \
- --objectsDir $(BLD_OBJ_DIR) \
- --objects "$(BLD_OBJ_DIR)/ejsCmd$(BLD_OBJ)"
-
-cleanExtra:
- @echo "rm -f $(TARGETS)" | $(BLDOUT)
- @rm -f $(TARGETS)
- @rm -f $(BLD_BIN_DIR)/libejs.*
-
-## Local variables:
-## tab-width: 4
-## End:
-## vim: tw=78 sw=4 ts=4
+++ /dev/null
-#
-# Makefile to build the EJS Classes
-#
-# Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
-#
-
-COMPILE := *.c
-EXPORT_OBJECTS := yes
-MAKE_IFLAGS := -I.. -I../../mpr -I../../exml
-
-include make.dep
-
-compileExtra: .updated
-
-.updated: $(FILES)
- @touch .updated
-
-## Local variables:
-## tab-width: 4
-## End:
-## vim: tw=78 sw=4 ts=4
+++ /dev/null
-/*
- * @file ejsArray.c
- * @brief Array class
- */
-/********************************* Copyright **********************************/
-/*
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- * Copyright (c) Michael O'Brien, 1994-1995. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-/********************************** Includes **********************************/
-
-#include "ejs.h"
-
-#if BLD_FEATURE_EJS
-
-/************************************ Code ************************************/
-
-int ejsDefineArrayClass(Ejs *ep)
-{
- if (ejsDefineClass(ep, "Array", "Object", ejsArrayConstructor) == 0) {
- return MPR_ERR_CANT_INITIALIZE;
- }
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Routine to create the base array type
- */
-
-EjsVar *ejsCreateArrayInternal(EJS_LOC_DEC(ep, loc), int size)
-{
- EjsProperty *pp;
- EjsVar *obj, *vp;
-
- /* MOB -- need to supply hash size -- max(size, 503)); */
-
- obj = ejsCreateSimpleObjInternal(EJS_LOC_PASS(ep, loc), "Array");
- if (obj == 0) {
- mprAssert(0);
- return obj;
- }
- obj->isArray = 1;
-
- /* MOB -- call constructor here and replace this code */
-
- pp = ejsSetPropertyToInteger(ep, obj, "length", size);
- ejsMakePropertyEnumerable(pp, 0);
-
- vp = ejsGetVarPtr(pp);
- vp->isArrayLength = 1;
-
- return obj;
-}
-
-/******************************************************************************/
-
-EjsVar *ejsAddArrayElt(Ejs *ep, EjsVar *op, EjsVar *element,
- EjsCopyDepth copyDepth)
-{
- EjsProperty *pp;
- EjsVar *vp;
- char idx[16];
- int length;
-
- mprAssert(op->isArray);
-
- length = ejsGetPropertyAsInteger(ep, op, "length");
-
- mprItoa(idx, sizeof(idx), length);
- pp = ejsCreateProperty(ep, op, idx);
- vp = ejsGetVarPtr(pp);
-
- ejsWriteVar(ep, vp, element, copyDepth);
-
- ejsSetPropertyToInteger(ep, op, "length", length + 1);
-
- return vp;
-}
-
-/******************************************************************************/
-/*
- * Constructor
- */
-
-int ejsArrayConstructor(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- EjsProperty *pp;
- EjsVar *vp;
- char idx[16];
- int i, max;
-
- thisObj->isArray = 1;
- max = 0;
-
- if (argc > 0) {
- if (argc == 1 && ejsVarIsNumber(argv[0])) {
- /*
- * x = new Array(size);
- */
- max = (int) ejsVarToInteger(argv[0]);
-
- } else {
- /*
- * x = new Array(element0, element1, ..., elementN):
- */
- max = argc;
- for (i = 0; i < max; i++) {
- mprItoa(idx, sizeof(idx), i);
- pp = ejsCreateSimpleProperty(ep, thisObj, idx);
- vp = ejsGetVarPtr(pp);
- ejsWriteVar(ep, vp, argv[i], EJS_SHALLOW_COPY);
- }
- }
- }
-
- pp = ejsCreateSimpleProperty(ep, thisObj, "length");
- ejsMakePropertyEnumerable(pp, 0);
- vp = ejsGetVarPtr(pp);
- ejsWriteVarAsInteger(ep, vp, max);
- vp->isArrayLength = 1;
-
- return 0;
-}
-
-/******************************************************************************/
-
-#else
-void ejsArrayDummy() {}
-
-/******************************************************************************/
-#endif /* BLD_FEATURE_EJS */
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- * @file ejsStndClasses.c
- * @brief EJS support methods
- */
-/********************************* Copyright **********************************/
-/*
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- * Copyright (c) Michael O'Brien, 1994-1995. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-/********************************** Includes **********************************/
-
-#include "ejs.h"
-
-#if BLD_FEATURE_EJS && 0
-
-/******************************************************************************/
-/*
- * Date constructor
-
- *
- * Date();
- * Date(milliseconds);
- * Date(dateString);
- * Date(year, month, date);
- * Date(year, month, date, hour, minute, second);
- */
-
-int ejsDateConstructor(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- return 0;
-}
-
-/******************************************************************************/
-
-static int load(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- const char *fileName;
- XmlState *parser;
- Exml *xp;
- MprFile *file;
-
- if (argc != 1 || !ejsVarIsString(argv[0])) {
- ejsError(ep, EJS_ARG_ERROR, "Bad args. Usage: load(fileName);");
- return -1;
- }
- fileName = argv[0]->string;
-
- /* FUTURE -- not romable
- Need rom code in MPR not MprServices
- */
- file = mprOpen(ep, fileName, O_RDONLY, 0664);
- if (file == 0) {
- ejsError(ep, EJS_IO_ERROR, "Can't open: %s", fileName);
- return -1;
- }
-
- xp = initParser(ep, thisObj, fileName);
- parser = exmlGetParseArg(xp);
-
- exmlSetInputStream(xp, readFileData, (void*) file);
-
- if (exmlParse(xp) < 0) {
- if (! ejsGotException(ep)) {
- ejsError(ep, EJS_IO_ERROR, "Can't parse XML file: %s\nDetails %s",
- fileName, exmlGetErrorMsg(xp));
- }
- termParser(xp);
- mprClose(file);
- return -1;
- }
-
- ejsSetReturnValue(ep, parser->nodeStack[0].obj);
-
- termParser(xp);
- mprClose(file);
-
- return 0;
-}
-
-/******************************************************************************/
-
-int ejsDefineDateClass(Ejs *ep)
-{
- EjsVar *dateClass;
-
- dateClass = ejsDefineClass(ep, "Date", "Object", ejsDateConstructor);
- if (dateClass == 0) {
- return MPR_ERR_CANT_INITIALIZE;
- }
-
- ejsDefineCMethod(ep, dateClass, "getDate", xxxProc, EJS_NO_LOCAL);
-
- /* Returns "Friday" or 4 ? */
- ejsDefineCMethod(ep, dateClass, "getDay", xxxProc, EJS_NO_LOCAL);
-
- ejsDefineCMethod(ep, dateClass, "getMonth", xxxProc, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, dateClass, "getFullYear", xxxProc, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, dateClass, "getYear", xxxProc, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, dateClass, "getHours", xxxProc, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, dateClass, "getMinutes", xxxProc, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, dateClass, "getSeconds", xxxProc, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, dateClass, "getMilliseconds", xxxProc, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, dateClass, "getTime", xxxProc, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, dateClass, "getTimeZoneOffset", xxxProc, EJS_NO_LOCAL);
-
- ejsDefineCMethod(ep, dateClass, "parse", xxxProc, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, dateClass, "setDate", xxxProc, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, dateClass, "setMonth", xxxProc, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, dateClass, "setFullYear", xxxProc, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, dateClass, "setYear", xxxProc, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, dateClass, "setMinutes", xxxProc, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, dateClass, "setSeconds", xxxProc, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, dateClass, "setMilliseconds", xxxProc, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, dateClass, "setTime", xxxProc, EJS_NO_LOCAL);
-
- ejsDefineCMethod(ep, dateClass, "toString", xxxProc, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, dateClass, "toGMTString", xxxProc, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, dateClass, "toUTCString", xxxProc, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, dateClass, "toLocaleString", xxxProc, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, dateClass, "UTC", xxxProc, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, dateClass, "valueOf", xxxProc, EJS_NO_LOCAL);
- /*
- UTC: getUTCDate, getUTCDay, getUTCMonth, getUTCFullYear, getUTCHours,
- getUTCMinutes, getUTCSeconds, getUTCMilliseconds
- setUTCDate, setUTCDay, setUTCMonth, setUTCFullYear, setUTCHours,
- setUTCMinutes, setUTCSeconds, setUTCMilliseconds
- */
-
- return ejsObjHasErrors(dateClass) ? MPR_ERR_CANT_INITIALIZE : 0;
-}
-
-/******************************************************************************/
-/*
- Time is since 1970/01/01 GMT
-
- Normal: Fri Feb 10 2006 05:06:44 GMT-0800 (Pacific Standard Time)
- UTC: Sat, 11 Feb 2006 05:06:44 GMT
-
- // Using without New
-
- println(Date());
-
- var myDate = new Date();
- myDate.setFullYear(2010, 0, 14);
-
- var today = new Date();
-
- if (myDate > today) {
- } else {
- }
-
-
- X=Date() should be equivalent to X=(new Date()).toString()
-
- */
-/******************************************************************************/
-
-#else
-void ejsStndClassesDummy() {}
-
-/******************************************************************************/
-#endif /* BLD_FEATURE_EJS */
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- * @file ejsError.c
- * @brief Error class
- */
-/********************************* Copyright **********************************/
-/*
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- * Copyright (c) Michael O'Brien, 1994-1995. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-/********************************** Includes **********************************/
-
-#include "ejs.h"
-
-#if BLD_FEATURE_EJS
-
-/************************************ Code ************************************/
-/*
- * Parse the args and return the message. Convert non-string args using
- * .toString.
- */
-
-static char *getMessage(Ejs *ep, int argc, EjsVar **argv)
-{
- if (argc == 0) {
- return "";
-
- } else if (argc == 1) {
- if (! ejsVarIsString(argv[0])) {
- if (ejsRunMethod(ep, argv[0], "toString", 0) < 0) {
- return 0;
- }
- return ep->result->string;
-
- } else {
- return argv[0]->string;
- }
-
- } else {
- /* Don't call ejsError here or it will go recursive. */
- return 0;
- }
-}
-
-
-/******************************************************************************/
-/*
- * Error Constructor and also used for constructor for sub classes.
- *
- * Usage: new Error([message])
- */
-
-int ejsErrorCons(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- char *msg, *stack;
-
- msg = getMessage(ep, argc, argv);
- if (msg == 0) {
- return -1;
- }
-
- ejsSetPropertyToString(ep, thisObj, "name", ejsGetBaseClassName(thisObj));
- ejsSetPropertyToString(ep, thisObj, "message", msg);
-
- ejsSetPropertyToUndefined(ep, thisObj, "stack");
-
- stack = ejsFormatStack(ep);
- if (stack) {
- ejsSetPropertyToString(ep, thisObj, "stack", stack);
- mprFree(stack);
- }
-
- if (ejsObjHasErrors(thisObj)) {
- return -1;
- }
-
- return 0;
-}
-
-/******************************************************************************/
-
-int ejsDefineErrorClasses(Ejs *ep)
-{
- if (ejsDefineClass(ep, "Error", "Object", ejsErrorCons) == 0 ||
- ejsDefineClass(ep, "AssertError", "Error", ejsErrorCons) == 0 ||
- ejsDefineClass(ep, "EvalError", "Error", ejsErrorCons) == 0 ||
- ejsDefineClass(ep, "InternalError", "Error", ejsErrorCons) == 0 ||
- ejsDefineClass(ep, "IOError", "Error", ejsErrorCons) == 0 ||
- ejsDefineClass(ep, "MemoryError", "Error", ejsErrorCons) == 0 ||
- ejsDefineClass(ep, "RangeError", "Error", ejsErrorCons) == 0 ||
- ejsDefineClass(ep, "ReferenceError", "Error", ejsErrorCons) == 0 ||
- ejsDefineClass(ep, "SyntaxError", "Error", ejsErrorCons) == 0 ||
- ejsDefineClass(ep, "TypeError", "Error", ejsErrorCons) == 0) {
-
- return MPR_ERR_CANT_INITIALIZE;
- }
- return 0;
-}
-
-/******************************************************************************/
-
-#else
-void ejsErrorDummy() {}
-
-/******************************************************************************/
-#endif /* BLD_FEATURE_EJS */
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- * @file ejsObject.c
- * @brief Object class
- */
-/********************************* Copyright **********************************/
-/*
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- * Copyright (c) Michael O'Brien, 1994-1995. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-/********************************** Includes **********************************/
-
-#include "ejs.h"
-
-#if BLD_FEATURE_EJS
-
-/****************************** Forward Declarations **************************/
-/*
- * Support routines
- */
-
-static void formatVar(Ejs *ep, MprBuf *bp, EjsVar *vp);
-
-/******************************************************************************/
-/*
- * Routine to create an object of the desired class. Class name may
- * contain "."
- *
- * The created object will be a stand-alone class NOT entered into the
- * properties of any other object. Callers must do this if required. ClassName
- * may contain "." and is interpreted relative to "obj" if supplied.
- *
- * Note: this does not call the constructors for the various objects and base
- * classes.
- */
-
-EjsVar *ejsCreateSimpleObjInternal(EJS_LOC_DEC(ep, loc), const char *className)
-{
- EjsVar *baseClass;
-
- if (className && *className) {
- baseClass = ejsGetClass(ep, 0, className);
- if (baseClass == 0) {
- mprError(ep, MPR_LOC, "Can't find base class %s", className);
- return 0;
- }
- } else {
- baseClass = 0;
- }
-
- return ejsCreateSimpleObjUsingClassInt(EJS_LOC_PASS(ep, loc),
- baseClass);
-}
-
-/******************************************************************************/
-/*
- * Create an object based upon the specified base class object. It will be a
- * stand-alone class not entered into the properties of any other object.
- * Callers must do this if required.
- *
- * Note: this does not call the constructors for the various objects and base
- * classes.
- */
-
-EjsVar *ejsCreateSimpleObjUsingClassInt(EJS_LOC_DEC(ep, loc),
- EjsVar *baseClass)
-{
- EjsVar *vp;
-
- mprAssert(baseClass);
-
- if (baseClass == 0) {
- mprError(ep, MPR_LOC, "Missing base class\n");
- return 0;
- }
-
- vp = ejsCreateObjVarInternal(EJS_LOC_PASS(ep, loc));
- if (vp == 0) {
- return vp;
- }
-
- ejsSetBaseClass(vp, baseClass);
-
- /*
- * This makes all internal method accesses faster
- * NOTE: this code is duplicated in ejsCreateSimpleClass
- */
- mprAssert(vp->objectState);
- vp->objectState->methods = baseClass->objectState->methods;
-
- return vp;
-}
-
-/******************************************************************************/
-
-void ejsSetMethods(Ejs *ep, EjsVar *op)
-{
- op->objectState->methods = ep->global->objectState->methods;
-}
-
-/******************************************************************************/
-/******************************** Internal Methods ****************************/
-/******************************************************************************/
-
-static EjsVar *createObjProperty(Ejs *ep, EjsVar *obj, const char *property)
-{
- return ejsGetVarPtr(ejsCreateSimpleProperty(ep, obj, property));
-}
-
-/******************************************************************************/
-
-static int deleteObjProperty(Ejs *ep, EjsVar *obj, const char *property)
-{
- return ejsDeleteProperty(ep, obj, property);
-}
-
-/******************************************************************************/
-
-static EjsVar *getObjProperty(Ejs *ep, EjsVar *obj, const char *property)
-{
- return ejsGetVarPtr(ejsGetSimpleProperty(ep, obj, property));
-}
-
-/******************************************************************************/
-/*
- * Set the value of a property. Create if it does not exist
- */
-
-static EjsVar *setObjProperty(Ejs *ep, EjsVar *obj, const char *property,
- const EjsVar *value)
-{
- EjsProperty *pp;
- EjsVar *vp;
-
- pp = ejsCreateSimpleProperty(ep, obj, property);
- if (pp == 0) {
- mprAssert(pp);
- return 0;
- }
- vp = ejsGetVarPtr(pp);
- if (ejsWriteVar(ep, vp, value, EJS_SHALLOW_COPY) < 0) {
- mprAssert(0);
- return 0;
- }
- return ejsGetVarPtr(pp);
-}
-
-/******************************************************************************/
-/*********************************** Constructors *****************************/
-/******************************************************************************/
-#if UNUSED
-/*
- * Object constructor. We don't use this for speed. Think very carefully if
- * you add an object constructor.
- */
-
-int ejsObjectConstructor(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- return 0;
-}
-
-#endif
-/******************************************************************************/
-/******************************** Visible Methods *****************************/
-/******************************************************************************/
-
-static int cloneMethod(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- int copyDepth;
-
- copyDepth = EJS_DEEP_COPY;
-
- if (argc == 1 && ejsVarToBoolean(argv[0])) {
- copyDepth = EJS_RECURSIVE_DEEP_COPY;
- }
-
- ejsWriteVar(ep, ep->result, thisObj, copyDepth);
-
- return 0;
-}
-
-/******************************************************************************/
-
-static int toStringMethod(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- MprBuf *bp;
- int saveMaxDepth, saveDepth, saveFlags;
-
- saveMaxDepth = ep->maxDepth;
-
- if (argc >= 1) {
- ep->maxDepth = ejsVarToInteger(argv[0]);
- } else if (ep->maxDepth == 0) {
- ep->maxDepth = MAXINT;
- }
-
- saveFlags = ep->flags;
- if (argc >= 2) {
- if (ejsVarToBoolean(argv[1])) {
- ep->flags |= EJS_FLAGS_ENUM_HIDDEN;
- }
- }
- if (argc == 3) {
- if (ejsVarToBoolean(argv[2])) {
- ep->flags |= EJS_FLAGS_ENUM_BASE;
- }
- }
-
- bp = mprCreateBuf(ep, 0, 0);
-
- saveDepth = ep->depth;
-
- formatVar(ep, bp, thisObj);
-
- ep->depth = saveDepth;
- ep->maxDepth = saveMaxDepth;
-
- mprAddNullToBuf(bp);
-
- ejsWriteVarAsString(ep, ep->result, mprGetBufStart(bp));
- mprFree(bp);
-
- ep->flags = saveFlags;
-
- return 0;
-}
-
-/******************************************************************************/
-
-static int valueOfMethod(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- if (argc != 0) {
- mprAssert(0);
- return -1;
- }
-
- switch (thisObj->type) {
- default:
- case EJS_TYPE_UNDEFINED:
- case EJS_TYPE_NULL:
- case EJS_TYPE_CMETHOD:
- case EJS_TYPE_OBJECT:
- case EJS_TYPE_METHOD:
- case EJS_TYPE_STRING_CMETHOD:
- ejsWriteVar(ep, ep->result, thisObj, EJS_SHALLOW_COPY);
- break;
-
- case EJS_TYPE_STRING:
- ejsWriteVarAsInteger(ep, ep->result, atoi(thisObj->string));
- break;
-
- case EJS_TYPE_BOOL:
- case EJS_TYPE_INT:
-#if BLD_FEATURE_INT64
- case EJS_TYPE_INT64:
-#endif
-#if BLD_FEATURE_FLOATING_POINT
- case EJS_TYPE_FLOAT:
-#endif
- ejsWriteVar(ep, ep->result, thisObj, EJS_SHALLOW_COPY);
- break;
- }
- return 0;
-}
-
-/******************************************************************************/
-
-static int hashGetAccessor(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- ejsSetReturnValueToInteger(ejs, (int) thisObj->objectState);
- return 0;
-}
-
-/******************************************************************************/
-
-static int classGetAccessor(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- if (thisObj->objectState == 0 || thisObj->objectState->baseClass == 0) {
- ejsSetReturnValueToString(ejs, "object");
- } else {
- ejsSetReturnValueToString(ejs,
- thisObj->objectState->baseClass->objectState->className);
- }
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Format an object. Called recursively to format properties and contained
- * objects.
- */
-
-static void formatVar(Ejs *ep, MprBuf *bp, EjsVar *vp)
-{
- EjsProperty *pp, *first;
- EjsVar *propVar, *baseClass;
- char *buf, *value;
- int i;
-
- if (vp->type == EJS_TYPE_OBJECT) {
- if (!vp->objectState->visited) {
-
- mprPutStringToBuf(bp, vp->isArray ? "[\n" : "{\n");
-
- ep->depth++;
- vp->objectState->visited = 1;
-
- if (ep->depth <= ep->maxDepth) {
- first = ejsGetFirstProperty(vp, EJS_ENUM_ALL);
-
- if (ep->flags & EJS_FLAGS_ENUM_BASE) {
- baseClass = vp->objectState->baseClass;
- if (baseClass) {
- for (i = 0; i < ep->depth; i++) {
- mprPutStringToBuf(bp, " ");
- }
- mprPutStringToBuf(bp, baseClass->objectState->objName);
- mprPutStringToBuf(bp, ": /* Base Class */ ");
- if (baseClass->objectState == vp->objectState) {
- value = "this";
- } else if (ejsRunMethodCmd(ep, baseClass, "toString",
- "%d", ep->maxDepth) < 0) {
- value = "[object Object]";
- } else {
- mprAssert(ejsVarIsString(ep->result));
- value = ep->result->string;
- }
- mprPutStringToBuf(bp, value);
- if (first) {
- mprPutStringToBuf(bp, ",\n");
- }
- }
- }
-
- pp = first;
- while (pp) {
- if (! pp->dontEnumerate ||
- ep->flags & EJS_FLAGS_ENUM_HIDDEN) {
- for (i = 0; i < ep->depth; i++) {
- mprPutStringToBuf(bp, " ");
- }
-
- if (! vp->isArray) {
- mprPutStringToBuf(bp, pp->name);
- mprPutStringToBuf(bp, ": ");
- }
-
- propVar = ejsGetVarPtr(pp);
- if (propVar->type == EJS_TYPE_OBJECT) {
- if (pp->var.objectState == vp->objectState) {
- value = "this";
- } else if (ejsRunMethodCmd(ep, propVar,
- "toString", "%d", ep->maxDepth) < 0) {
- value = "[object Object]";
- } else {
- mprAssert(ejsVarIsString(ep->result));
- value = ep->result->string;
- }
- mprPutStringToBuf(bp, value);
-
- } else {
- formatVar(ep, bp, &pp->var);
- }
-
- pp = ejsGetNextProperty(pp, EJS_ENUM_ALL);
- if (pp) {
- mprPutStringToBuf(bp, ",\n");
- }
- } else {
- pp = ejsGetNextProperty(pp, EJS_ENUM_ALL);
- }
- }
- }
- vp->objectState->visited = 0;
-
- mprPutCharToBuf(bp, '\n');
-
- ep->depth--;
- for (i = 0; i < ep->depth; i++) {
- mprPutStringToBuf(bp, " ");
- }
- mprPutCharToBuf(bp, vp->isArray ? ']' : '}');
- }
-
- } else if (vp->type == EJS_TYPE_METHOD) {
-
- mprPutStringToBuf(bp, "function (");
- for (i = 0; i < vp->method.args->length; i++) {
- mprPutStringToBuf(bp, vp->method.args->items[i]);
- if ((i + 1) < vp->method.args->length) {
- mprPutStringToBuf(bp, ", ");
- }
- }
- mprPutStringToBuf(bp, ") {");
- mprPutStringToBuf(bp, vp->method.body);
- for (i = 0; i < ep->depth; i++) {
- mprPutStringToBuf(bp, " ");
- }
- mprPutStringToBuf(bp, "}");
-
- } else {
-
- if (vp->type == EJS_TYPE_STRING) {
- mprPutCharToBuf(bp, '\"');
- }
-
- /*
- * We don't use ejsVarToString for arrays, objects and strings.
- * This is because ejsVarToString does not call "obj.toString"
- * and it is not required for strings.
- * MOB - rc
- */
- buf = ejsVarToString(ep, vp);
- mprPutStringToBuf(bp, buf);
-
- if (vp->type == EJS_TYPE_STRING) {
- mprPutCharToBuf(bp, '\"');
- }
- }
-}
-
-/******************************************************************************/
-/*
- * mixin code. Blends code at the "thisObj" level.
- */
-
-static int mixinMethod(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- EjsProperty *pp;
- char *buf;
- int fid, i, rc;
-
- mprAssert(argv);
-
- /*
- * Create a variable scope block set to the current object
- */
- rc = 0;
- fid = ejsSetBlock(ep, thisObj);
-
- for (i = 0; i < argc; i++) {
-
- if (ejsVarIsString(argv[i])) {
- rc = ejsEvalScript(ep, argv[i]->string, 0);
-
- } else if (ejsVarIsObject(argv[i])) {
-
- /* MOB -- OPT. When we have proper scope chains, we should just
- refer to the module and not copy */
- pp = ejsGetFirstProperty(argv[i], EJS_ENUM_ALL);
- while (pp) {
- ejsSetProperty(ep, thisObj, pp->name, ejsGetVarPtr(pp));
- pp = ejsGetNextProperty(pp, EJS_ENUM_ALL);
- }
-
- } else {
- /* MOB - rc */
- buf = ejsVarToString(ep, argv[i]);
- rc = ejsEvalScript(ep, buf, 0);
-
- }
- if (rc < 0) {
- ejsCloseBlock(ep, fid);
- return -1;
- }
- }
- ejsCloseBlock(ep, fid);
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Create the object class
- */
-
-int ejsDefineObjectClass(Ejs *ep)
-{
- EjsMethods *methods;
- EjsProperty *objectProp, *protoProp;
- EjsVar *op, *globalClass;
-
- /*
- * Must specially hand-craft the object class as it is the base class
- * of all objects.
- */
- op = ejsCreateObjVar(ep);
- if (op == 0) {
- return MPR_ERR_CANT_CREATE;
- }
- ejsSetClassName(ep, op, "Object");
-
- /*
- * Don't use a constructor for objects for speed
- */
- ejsMakeClassNoConstructor(op);
-
- /*
- * MOB -- should mark properties as public / private and class or instance.
- */
- ejsDefineCMethod(ep, op, "clone", cloneMethod, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, op, "toString", toStringMethod, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, op, "valueOf", valueOfMethod, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, op, "mixin", mixinMethod, EJS_NO_LOCAL);
-
- ejsDefineCAccessors(ep, op, "hash", hashGetAccessor, 0, EJS_NO_LOCAL);
- ejsDefineCAccessors(ep, op, "baseClass", classGetAccessor, 0, EJS_NO_LOCAL);
-
- /*
- * MOB -- make this an accessor
- */
- protoProp = ejsSetProperty(ep, op, "prototype", op);
- if (protoProp == 0) {
- ejsFreeVar(ep, op);
- return MPR_ERR_CANT_CREATE;
- }
-
- /*
- * Setup the internal methods. Most classes will never override these.
- * The XML class will. We rely on talloc to free internal. Use "ep" as
- * the parent as we need "methods" to live while the interpreter lives.
- */
- methods = mprAllocTypeZeroed(ep, EjsMethods);
- op->objectState->methods = methods;
-
- methods->createProperty = createObjProperty;
- methods->deleteProperty = deleteObjProperty;
- methods->getProperty = getObjProperty;
- methods->setProperty = setObjProperty;
-
- objectProp = ejsSetPropertyAndFree(ep, ep->global, "Object", op);
-
- /*
- * Change the global class to use Object's methods
- */
- globalClass = ep->service->globalClass;
- globalClass->objectState->methods = methods;
- globalClass->objectState->baseClass = ejsGetVarPtr(protoProp);
-
- ep->objectClass = ejsGetVarPtr(objectProp);
-
- if (ejsObjHasErrors(ejsGetVarPtr(objectProp))) {
- ejsFreeVar(ep, op);
- return MPR_ERR_CANT_CREATE;
- }
- return 0;
-}
-
-/******************************************************************************/
-
-#else
-void ejsObjectDummy() {}
-
-/******************************************************************************/
-#endif /* BLD_FEATURE_EJS */
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- * @file ejsStndClasses.c
- * @brief EJS support methods
- */
-/********************************* Copyright **********************************/
-/*
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- * Copyright (c) Michael O'Brien, 1994-1995. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-/********************************** Includes **********************************/
-
-#include "ejs.h"
-
-#if BLD_FEATURE_EJS
-
-/******************************************************************************/
-/******************************* Function Class *******************************/
-/******************************************************************************/
-
-int ejsDefineFunctionClass(Ejs *ep)
-{
- if (ejsDefineClass(ep, "Function", "Object", ejsFunctionConstructor) == 0) {
- return MPR_ERR_CANT_INITIALIZE;
- }
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Function constructor
- */
-
-int ejsFunctionConstructor(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- int rc;
-
- if (argc != 1 || !ejsVarIsString(argv[0])) {
- ejsArgError(ep, "Usage: Function(\"function (arg) { script };\");");
- }
-
- rc = ejsEvalScript(ep, argv[0]->string, 0);
-
- /*
- * Note: this will convert the object into a method. It will cease to be
- * an object.
- */
- if (rc == 0 && ejsVarIsMethod(ep->result)) {
- /*
- * Must make thisObj collectable.
- */
- ejsMakeObjPermanent(thisObj, 0);
- ejsMakeObjLive(thisObj, 1);
- mprAssert(ejsObjIsCollectable(thisObj));
- ejsWriteVar(ep, thisObj, ep->result, EJS_SHALLOW_COPY);
- }
- return rc;
-}
-
-/******************************************************************************/
-/******************************* Boolean Class ********************************/
-/******************************************************************************/
-
-int ejsDefineBooleanClass(Ejs *ep)
-{
- if (ejsDefineClass(ep, "Boolean", "Object", ejsBooleanConstructor) == 0){
- return MPR_ERR_CANT_INITIALIZE;
- }
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Boolean constructor
- */
-
-int ejsBooleanConstructor(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- return 0;
-}
-
-/******************************************************************************/
-/******************************** Number Class ********************************/
-/******************************************************************************/
-
-int ejsDefineNumberClass(Ejs *ep)
-{
- if (ejsDefineClass(ep, "Number", "Object", ejsNumberConstructor) == 0) {
- return MPR_ERR_CANT_INITIALIZE;
- }
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Number constructor
- */
-
-int ejsNumberConstructor(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- return 0;
-}
-
-/******************************************************************************/
-
-#else
-void ejsStndClassesDummy() {}
-
-/******************************************************************************/
-#endif /* BLD_FEATURE_EJS */
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- * @file ejsString.c
- * @brief EJScript string class
- */
-/********************************* Copyright **********************************/
-/*
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- * Copyright (c) Michael O'Brien, 1994-1995. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-/********************************** Includes **********************************/
-
-#include "ejs.h"
-
-#if BLD_FEATURE_EJS
-/******************************************************************************/
-/*********************************** Constructors *****************************/
-/******************************************************************************/
-/*
- * String constructor.
- */
-
-int ejsStringConstructor(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- char *str;
-
- if (argc == 0) {
- ejsSetReturnValueToString(ejs, "");
-
- } else if (argc == 1) {
- /* MOB -- rc */
- str = ejsVarToString(ejs, argv[0]);
- ejsSetReturnValueToString(ejs, str);
-
- } else {
- ejsArgError(ejs, "usage: String([var])");
- return -1;
- }
-
- return 0;
-}
-
-/******************************************************************************/
-/******************************** Visible Methods *****************************/
-/******************************************************************************/
-/*
- * Return a string containing the character at a given index
- *
- * String string.charAt(Number)
- */
-
-static int charAt(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- EjsNum num;
- char buf[2];
-
- if (argc != 1) {
- ejsArgError(ejs, "usage: charAt(integer)");
- return -1;
- }
-
- num = ejsVarToNumber(argv[0]);
- if (num < 0 || num >= thisObj->length) {
- ejsError(ejs, EJS_RANGE_ERROR, "Bad index");
- return -1;
- }
-
- mprAssert(ejsVarIsString(thisObj));
-
- buf[0] = argv[0]->string[num];
- buf[1] = '\0';
- ejsSetReturnValueToString(ejs, buf);
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Return an integer containing the character at a given index
- *
- * Number string.charCodeAt(Number)
- */
-
-static EjsNum charCodeAt(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- EjsNum num;
-
- if (argc != 1) {
- ejsArgError(ejs, "usage: charCodeAt(integer)");
- return -1;
- }
-
- num = ejsVarToNumber(argv[0]);
- if (num < 0 || num >= thisObj->length) {
- ejsError(ejs, EJS_RANGE_ERROR, "Bad index");
- return -1;
- }
- ejsSetReturnValueToNumber(ejs, (EjsNum) argv[0]->string[num]);
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Catenate
- *
- * String string.catenate(var, ...)
- */
-
-static int concat(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- int i;
-
- if (argc == 0) {
- ejsArgError(ejs, "usage: concat(String, ...)");
- return -1;
- }
-
- mprAssert(ejsVarIsString(thisObj));
-
- for (i = 0; i < argc; i++) {
- if (ejsStrcat(ejs, thisObj, argv[i]) < 0) {
- ejsMemoryError(ejs);
- return -1;
- }
- }
- ejsSetReturnValue(ejs, thisObj);
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Return the position of the first occurance of a substring
- *
- * Number string.indexOf(String subString [, Number start])
- */
-
-static int indexOf(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- char *pat, *s1, *s2, *origin;
- int start, i;
-
- if (argc == 0 || argc > 2) {
- ejsArgError(ejs, "usage: indexOf(String [, Number])");
- return -1;
- }
-
- pat = ejsVarToString(ejs, argv[0]);
-
- if (argc == 2) {
- start = ejsVarToNumber(argv[1]);
- if (start > thisObj->length) {
- start = thisObj->length;
- }
- } else {
- start = 0;
- }
-
- i = start;
- for (origin = &thisObj->string[i]; i < thisObj->length; i++, origin++) {
- s1 = origin;
- for (s2 = pat; *s1 && *s2; s1++, s2++) {
- if (*s1 != *s2) {
- break;
- }
- }
- if (*s2 == '\0') {
- ejsSetReturnValueToNumber(ejs, (EjsNum) (origin - thisObj->string));
- }
- }
-
- ejsSetReturnValueToNumber(ejs, (EjsNum) -1);
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Return the position of the last occurance of a substring
- *
- * Number string.lastIndexOf(String subString [, Number start])
- */
-
-static int lastIndexOf(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- char *pat, *s1, *s2, *origin;
- int start;
-
- if (argc == 0 || argc > 2) {
- ejsArgError(ejs, "usage: indexOf(String [, Number])");
- return -1;
- }
-
- pat = ejsVarToString(ejs, argv[0]);
-
- if (argc == 2) {
- start = ejsVarToNumber(argv[1]);
- if (start > thisObj->length) {
- start = thisObj->length;
- }
- } else {
- start = 0;
- }
-
- origin = &thisObj->string[thisObj->length - 1];
- for (; origin >= &thisObj->string[start]; origin--) {
-
- s1 = origin;
- for (s2 = pat; *s1 && *s2; s1++, s2++) {
- if (*s1 != *s2) {
- break;
- }
- }
- if (*s2 == '\0') {
- ejsSetReturnValueToNumber(ejs, (EjsNum) (origin - thisObj->string));
- }
- }
-
- ejsSetReturnValueToNumber(ejs, (EjsNum) -1);
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Return a substring
- *
- * Number string.slice(Number start, Number end)
- */
-
-static int slice(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- EjsNum start, end;
-
- if (argc != 2) {
- ejsArgError(ejs, "usage: slice(Number, Number)");
- return -1;
- }
-
- start = ejsVarToNumber(argv[0]);
- end = ejsVarToNumber(argv[1]);
- if (start < 0 || start >= thisObj->length) {
- ejsError(ejs, EJS_RANGE_ERROR, "Bad start index");
- return-1;
- }
- if (end < 0 || end >= thisObj->length) {
- ejsError(ejs, EJS_RANGE_ERROR, "Bad end index");
- return -1;
- }
-
- mprAssert(ejsVarIsString(thisObj));
-
- ejsSetReturnValueToBinaryString(ejs, (uchar*) &thisObj->string[start],
- end - start);
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Split a string
- *
- * Number string.split(String delimiter [, Number limit])
- */
-
-static int split(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- EjsVar *array, *vp;
- char *delim, *last, *cp;
- int len, limit, alloc;
-
- if (argc == 0 || argc > 2) {
- ejsArgError(ejs, "usage: split(String [, Number])");
- return -1;
- }
-
- delim = ejsVarToStringEx(ejs, argv[0], &alloc);
-
- limit = ejsVarToNumber(argv[1]);
-
- array = ejsCreateArray(ejs, 0);
-
- len = strlen(delim);
-
- last = thisObj->string;
- for (cp = last; *cp; cp++) {
- if (*cp == *delim && strncmp(cp, delim, len) == 0) {
- if (cp > last) {
- vp = ejsCreateBinaryStringVar(ejs, (uchar*) last, (cp - last));
- ejsAddArrayElt(ejs, array, vp, EJS_SHALLOW_COPY);
- ejsFreeVar(ejs, vp);
- }
- }
- }
-
- ejsSetReturnValue(ejs, array);
- ejsFreeVar(ejs, array);
-
- if (alloc) {
- mprFree(delim);
- }
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Create the object class
- */
-
-int ejsDefineStringClass(Ejs *ejs)
-{
- EjsVar *sc;
-
- sc = ejsDefineClass(ejs, "String", "Object", ejsStringConstructor);
- if (sc == 0) {
- return MPR_ERR_CANT_INITIALIZE;
- }
-
- ejsDefineCMethod(ejs, sc, "charAt", charAt, EJS_NO_LOCAL);
- ejsDefineCMethod(ejs, sc, "charCodeAt", charCodeAt, EJS_NO_LOCAL);
- ejsDefineCMethod(ejs, sc, "concat", concat, EJS_NO_LOCAL);
- ejsDefineCMethod(ejs, sc, "indexOf", indexOf, EJS_NO_LOCAL);
- ejsDefineCMethod(ejs, sc, "lastIndexOf", lastIndexOf, EJS_NO_LOCAL);
- ejsDefineCMethod(ejs, sc, "slice", slice, EJS_NO_LOCAL);
- ejsDefineCMethod(ejs, sc, "split", split, EJS_NO_LOCAL);
-#if UNUSED
- ejsDefineCMethod(ejs, sc, "match", match, EJS_NO_LOCAL);
- ejsDefineCMethod(ejs, sc, "replace", replace, EJS_NO_LOCAL);
- ejsDefineCMethod(ejs, sc, "search", search, EJS_NO_LOCAL);
- ejsDefineCMethod(ejs, sc, "substring", substring, EJS_NO_LOCAL);
- // MOB bad name
- ejsDefineCMethod(ejs, sc, "substr", substr, EJS_NO_LOCAL);
- ejsDefineCMethod(ejs, sc, "toLowerCase", toLowerCase, EJS_NO_LOCAL);
- ejsDefineCMethod(ejs, sc, "toUpperCase", toUpperCase, EJS_NO_LOCAL);
-
- // Static method
- ejsDefineCMethod(ejs, sc, "fromCharCode", fromCharCode, 0, EJS_NO_LOCAL);
-#endif
-
- if (ejsObjHasErrors(sc)) {
- ejsFreeVar(ejs, sc);
- return MPR_ERR_CANT_CREATE;
- }
- return 0;
-}
-
-/******************************************************************************/
-#endif /* BLD_FEATURE_EJS */
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- * @file ejsXml.c
- * @brief E4X XML support
- */
-/********************************* Copyright **********************************/
-/*
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- * Copyright (c) Michael O'Brien, 1994-1995. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-/************************************ Doc *************************************/
-/*
- * Javascript class definition
- *
- * class XML {
- * public XML();
- * public XML(string xmlString); // "<tag... "
- * public XML(string file); // "file"
- *
- * public void load(string file);
- * public void save(string file);
- * public Array children();
- * public Array attributes();
- * }
- *
- [[Internal Properties / Methods]]
- - prototype - Ptr to class prototype (base class)
- - class - Type of class
- Object.prototype.toString
- - Value -
- - Get(name) - Returns the value
- - Put(name, value) - Sets the value
- - HasProperty(name) - Bool if property exists
- - Delete(name) - Delete property
- - DefaultValue(hint) - Return default primitive (not obj) value
- toString, if result is obj, then call valueOf
- if hint is number, then call valueOf, then toString
- - Construct(arg list) - Constructor
- - Call(arg list) - Function call
- - HasInstance(value) - ??
- - Scope - Frame scope chain
- - Match(string, index) - Regexp match
-
- - Example:
- XML attribute @name
- @*
- *
- var node = new XML("<order/>");
- Operators:
- var prices = order..price;
- var urgentItems = order.item(@level == "rush");
- var itemAttrs = order.item[0].@*; # @ for attributes
- XML Literals
- order.customer.address =
- <address>.....
- <zip>{zipCode}</zip> Where {var} is a JS var
- <tag attribute={prefix}> ... Also for attributes
- </address>
- Omit namespaces
- Example:
- var html = <html/>;
- html.head.title = "My title";
- head.body@bgcolor = "#e4e4e4";
-*/
-
-/********************************** Includes **********************************/
-
-#include "ejs.h"
-#include "exml.h"
-
-/************************************ Data ************************************/
-#if BLD_FEATURE_EJS_E4X
-
-/*
- * Per tag state
- */
-typedef struct XmlTagState {
- EjsVar *obj;
- EjsVar *attributes;
- EjsVar *comments;
-} XmlTagState;
-
-/*
- * Parser state
- */
-typedef struct XmlState {
- Ejs *ep;
- EjsVar *xmlClass;
- EjsVar *xmlListClass;
- XmlTagState nodeStack[E4X_MAX_NODE_DEPTH];
- int topOfStack;
- long inputSize;
- long inputPos;
- const char *inputBuf;
- const char *fileName;
-} XmlState;
-
-/****************************** Forward Declarations **************************/
-/*
- * XML methods
- */
-static int text(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv);
-static int name(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv);
-static int load(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv);
-static int save(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv);
-static int toString(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv);
-static int valueOf(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv);
-
-/* MOB -- temp */
-static int getList(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv);
-static int setText(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv);
-
-#if FUTURE
-static int length(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv);
-static int toXmlString(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv);
-
-static int appendChild(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv);
-static int attributes(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv);
-static int child(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv);
-static int children(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv);
-static int comments(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv);
-static int decendants(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv);
-static int elements(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv);
-static int insertChildAfter(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv);
-static int insertChildBefore(Ejs *ep, EjsVar *thisObj, int argc,
- EjsVar **argv);
-static int replace(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv);
-static int setName(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv);
-static int text(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv);
-#endif
-
-/*
- * Internal methods
- */
-static EjsVar *createXmlProperty(Ejs *ep, EjsVar *obj, const char *property);
-static int deleteXmlProperty(Ejs *ep, EjsVar *obj, const char *property);
-static EjsVar *getXmlProperty(Ejs *ep, EjsVar *obj, const char *property);
-static EjsVar *setXmlProperty(Ejs *ep, EjsVar *obj, const char *property,
- const EjsVar *value);
-static int loadXmlString(Ejs *ep, EjsVar *thisObj, const char *xmlString);
-
-/*
- * XMLList methods
- */
-static EjsVar *createXmlListProperty(Ejs *ep, EjsVar *obj,
- const char *property);
-static int deleteXmlListProperty(Ejs *ep, EjsVar *obj,
- const char *property);
-static EjsVar *getXmlListProperty(Ejs *ep, EjsVar *obj, const char *property);
-static EjsVar *setXmlListProperty(Ejs *ep, EjsVar *obj, const char *property,
- const EjsVar *value);
-
-/*
- * Misc
- */
-static int readFileData(Exml *xp, void *data, char *buf, int size);
-static int readStringData(Exml *xp, void *data, char *buf, int size);
-static int parserHandler(Exml *xp, int state, const char *tagName,
- const char *attName, const char *value);
-static void termParser(Exml *xp);
-static Exml *initParser(Ejs *ep, EjsVar *thisObj, const char *fileName);
-static int getNumElements(EjsVar *obj);
-static int getText(MprBuf *buf, EjsVar *obj);
-static int xmlToString(Ejs *ep, MprBuf *buf, EjsVar *obj, int indentLevel);
-static void indent(MprBuf *bp, int level);
-static char *cleanTagName(char *name);
-
-/******************************************************************************/
-/*
- * Define the E4X classes (XML, XMLList)
- */
-
-int ejsDefineXmlClasses(Ejs *ep)
-{
- EjsMethods *methods;
- EjsVar *xmlClass, *xmlListClass;
-
- /*
- * Create the XML class
- */
- xmlClass = ejsDefineClass(ep, "XML", "Object", ejsXmlConstructor);
- if (xmlClass == 0) {
- return MPR_ERR_CANT_INITIALIZE;
- }
-
- /*
- * Define the XML class methods
- */
- ejsDefineCMethod(ep, xmlClass, "text", text, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, xmlClass, "name", name, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, xmlClass, "load", load, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, xmlClass, "save", save, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, xmlClass, "toString", toString, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, xmlClass, "valueOf", valueOf, EJS_NO_LOCAL);
-
-/* MOB -- temporary only */
- ejsDefineCMethod(ep, xmlClass, "getList", getList, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, xmlClass, "setText", setText, EJS_NO_LOCAL);
-
- /*
- * Setup the XML internal methods.
- */
- methods = mprAllocTypeZeroed(ep, EjsMethods);
- xmlClass->objectState->methods = methods;
-
- methods->createProperty = createXmlProperty;
- methods->deleteProperty = deleteXmlProperty;
- methods->getProperty = getXmlProperty;
- methods->setProperty = setXmlProperty;
-
- /*
- * Create the XMLList class
- */
- xmlListClass = ejsDefineClass(ep, "XMLList", "Array",
- ejsXmlListConstructor);
-
- /*
- * Define the XMLList class methods
- */
-
- /*
- * Setup the XML internal methods.
- */
- methods = mprAllocTypeZeroed(ep, EjsMethods);
- xmlListClass->objectState->methods = methods;
-
- methods->createProperty = createXmlListProperty;
- methods->deleteProperty = deleteXmlListProperty;
- methods->getProperty = getXmlListProperty;
- methods->setProperty = setXmlListProperty;
-
- /* MOB -- need to complete xmlListClass */
-
- return (ejsObjHasErrors(xmlClass) || ejsObjHasErrors(xmlListClass))
- ? MPR_ERR_CANT_INITIALIZE : 0;
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Routine to create an XML object using a default constructor
- */
-
-EjsVar *ejsCreateXml(Ejs *ep)
-{
- EjsVar *op;
-
- op = ejsCreateSimpleObj(ep, "XML");
- if (op == 0) {
- mprAssert(op);
- return op;
- }
- ejsSetVarName(ep, op, "xmlNode");
-
- /*
- * Invoke class constructors manually (for speed and space)
- */
- if (ejsXmlConstructor(ep, op, 0, 0) < 0) {
- mprFree(op);
- mprAssert(0);
- return 0;
- }
- return op;
-}
-
-/******************************************************************************/
-/*
- * XML constructor
- */
-
-int ejsXmlConstructor(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- EjsVar *vp;
- const char *str;
-
- ejsSetVarFlags(thisObj, EJS_XML_FLAGS_ELEMENT);
-
- if (argc == 1) {
- vp = argv[0];
-
- if (ejsVarIsObject(vp)) {
- /* Convert DOM to XML. Not implemented */;
-
- } else if (ejsVarIsString(vp)) {
- str = vp->string;
- if (str == 0) {
- return 0;
- }
- if (*str == '<') {
- /* XML Literal */
- return loadXmlString(ep, thisObj, str);
-
- } else {
- /* Load from file */
- return load(ep, thisObj, argc, argv);
- }
- } else {
- ejsError(ep, EJS_TYPE_ERROR, "Bad type passed to XML constructor");
- return -1;
- }
- }
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Routine to create an XMLList object
- */
-
-EjsVar *ejsCreateXmlList(Ejs *ep)
-{
- EjsVar *op;
-
- /* Sanity limit for size of hash table */
-
- op = ejsCreateSimpleObj(ep, "XMLList");
- if (op == 0) {
- mprAssert(0);
- return op;
- }
- if (ejsArrayConstructor(ep, op, 0, 0) < 0 ||
- ejsXmlConstructor(ep, op, 0, 0) < 0) {
- mprFree(op);
- mprAssert(0);
- return 0;
- }
- return op;
-}
-
-/******************************************************************************/
-/*
- * XMLList constructor
- */
-
-int ejsXmlListConstructor(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- // ejsSetVarFlags(vp, EJS_XML_FLAGS_ELEMENT);
- return 0;
-}
-
-/******************************************************************************/
-/******************************** Internal Methods ****************************/
-/******************************************************************************/
-
-static EjsVar *createXmlProperty(Ejs *ep, EjsVar *obj, const char *property)
-{
- return ejsGetVarPtr(ejsCreateSimpleProperty(ep, obj, property));
-}
-
-/******************************************************************************/
-
-static int deleteXmlProperty(Ejs *ep, EjsVar *obj, const char *property)
-{
- return ejsDeleteProperty(ep, obj, property);
-}
-
-/******************************************************************************/
-/* MOB -- need ep as an arg */
-static EjsVar *getXmlProperty(Ejs *ep, EjsVar *obj, const char *property)
-{
-#if NEW
- EjsVar *lp;
-
- lp = ejsCreateXmlList(ep);
- if (isdigit(*property)) {
- /* MOB -- where do we store these. Do we need them ? */
- lp->targetObject = obj
- lp->targetProperty = property
- return getXmlListProperty(lp, property);
- }
-
- /* What about a simple elment. Should it not return the text */
-
- if (*property == '@') {
- ap = ejsGetFirstProperty(obj, EJS_ENUM_ALL);
- while (ap) {
- vp = ejsGetVarPtr(ap);
- /* MOB -- are attributes unique ? */
- if (vp->flags & EJS_XML_FLAGS_ATTRIBUTE &&
- strcmp(property, ap->name) == 0) {
- ejsAppendXml(lp, vp);
- }
- ap = ejsGetNexttProperty(ap, EJS_ENUM_ALL);
- }
- } else {
- while (ap) {
- vp = ejsGetVarPtr(ap);
- /* MOB -- are attributes unique ? */
- if (vp->flags & EJS_XML_FLAGS_ELEMENT &&
- strcmp(property, ap->name) == 0) {
- ejsAppendXml(lp, vp);
- }
- ap = ejsGetNexttProperty(ap, EJS_ENUM_ALL);
- }
- }
- return l;
-
- // Must always return XML or XMLList event for comments and attributes
-#endif
- return ejsGetVarPtr(ejsGetSimpleProperty(ep, obj, property));
-}
-
-/******************************************************************************/
-
-static EjsVar *setXmlProperty(Ejs *ep, EjsVar *obj, const char *property,
- const EjsVar *value)
-{
- EjsProperty *pp;
- EjsVar *vp;
-
- pp = ejsCreateSimpleProperty(ep, obj, property);
- if (pp == 0) {
- /* Should never happen */
- mprAssert(pp);
- return 0;
- }
- vp = ejsGetVarPtr(pp);
- if (ejsWriteVar(ep, vp, value, EJS_SHALLOW_COPY) < 0) {
- return 0;
- }
- return ejsGetVarPtr(pp);
-}
-
-/******************************************************************************/
-/*
- NEW
-
-static EjsVar *setXmlProperty(Ejs *ep, EjsVar *op, const char *property,
- EjsVar *value)
-{
-
- if ((value->objectState->baseClass != XML &&
- value->objectState->baseClass != XMLList) ||
- value->string[0] != '<') {
- ejsVarToString(luevalue.toString();
- ejsRunMethod(ep, value, "toString", 0);
- value = ejsDupVar(ep->result);
-
- } else {
- value = ejsDupVar(value);
- }
-
- if (isdigit(*property)) {
- // ERROR -- reserved for future versions
- return 0;
- }
-
- if (*property == '@') {
- if (op->objectState->baseClass == XMLList) {
- if (op->obj.LENGTH_PROPERTY == 0) {
- c = "";
- } else {
- // Catenate all result of toString on all elts in list
- }
- } else {
- c = c.toString();
- }
- // Replace existing attribute of same name or insert
- return;
- }
- for (i = op->obj.LENGTH - 1; i >= 0; i--) {
- // Delete item of same name
- }
- if (not Found) {
- Append new Xml object
- - set [[name]], [[class]] == "element"
- }
-
- mprFree(value);
-}
-
- */
-/******************************************************************************/
-/************************************ Methods *********************************/
-/******************************************************************************/
-
-static int load(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- const char *fileName;
- XmlState *parser;
- Exml *xp;
- MprFile *file;
-
- if (argc != 1 || !ejsVarIsString(argv[0])) {
- ejsError(ep, EJS_ARG_ERROR, "Bad args. Usage: load(fileName);");
- return -1;
- }
- fileName = argv[0]->string;
-
- /* MOB -- not romable
- Need rom code in MPR not MprServices
- */
- file = mprOpen(ep, fileName, O_RDONLY, 0664);
- if (file == 0) {
- ejsError(ep, EJS_IO_ERROR, "Can't open: %s", fileName);
- return -1;
- }
-
- /* MOB -- should we empty thisObj of all existing properties ? */
-
- xp = initParser(ep, thisObj, fileName);
- parser = exmlGetParseArg(xp);
-
- exmlSetInputStream(xp, readFileData, (void*) file);
-
- if (exmlParse(xp) < 0) {
- if (! ejsGotException(ep)) {
- ejsError(ep, EJS_IO_ERROR, "Can't parse XML file: %s\nDetails %s",
- fileName, exmlGetErrorMsg(xp));
- }
- termParser(xp);
- mprClose(file);
- return -1;
- }
-
- ejsSetReturnValue(ep, parser->nodeStack[0].obj);
-
- termParser(xp);
- mprClose(file);
-
- return 0;
-}
-
-/******************************************************************************/
-
-static int loadXmlString(Ejs *ep, EjsVar *thisObj, const char *xmlString)
-{
- XmlState *parser;
- Exml *xp;
-
- xp = initParser(ep, thisObj, "string");
- parser = exmlGetParseArg(xp);
-
- parser->inputBuf = xmlString;
- parser->inputSize = strlen(xmlString);
-
- exmlSetInputStream(xp, readStringData, (void*) 0);
-
- if (exmlParse(xp) < 0) {
- if (! ejsGotException(ep)) {
- ejsError(ep, EJS_IO_ERROR, "Can't parse XML string\nError %s",
- exmlGetErrorMsg(xp));
- }
- termParser(xp);
- return -1;
- }
-
- ejsSetReturnValue(ep, parser->nodeStack[0].obj);
-
- termParser(xp);
-
- return 0;
-}
-
-/******************************************************************************/
-
-static int text(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- EjsVar *vp;
-
- vp = ejsGetVarPtr(ejsGetSimpleProperty(ep, thisObj, E4X_TEXT_PROPERTY));
- if (vp == 0) {
- ejsSetReturnValueToString(ep, "");
- return 0;
- }
- ejsSetReturnValue(ep, vp);
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Return the tag name
- */
-
-static int name(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- EjsVar *vp;
-
- vp = ejsGetVarPtr(ejsGetSimpleProperty(ep, thisObj, E4X_TAG_NAME_PROPERTY));
- if (vp == 0) {
- ejsSetReturnValueToString(ep, "");
- return 0;
- }
- ejsSetReturnValue(ep, vp);
-#if UNDEFINED
- char *name;
- /* MOB -- not ideal as we can't guarantee thisObj is a property */
- name = ejsGetPropertyPtr(thisObj)->name;
- if (name == 0) {
- name = "";
- }
- ejsSetReturnValueToString(ep, name);
-#endif
- return 0;
-}
-
-/******************************************************************************/
-/* MOB -- temporary only */
-
-static int setText(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- if (argc != 1) {
- ejsArgError(ep, "usage: setText(string)");
- }
-
- ejsSetProperty(ep, thisObj, E4X_TEXT_PROPERTY, argv[0]);
- ejsSetReturnValue(ep, argv[0]);
- return 0;
-}
-
-/******************************************************************************/
-
-static Exml *initParser(Ejs *ep, EjsVar *thisObj, const char *fileName)
-{
- XmlState *parser;
- Exml *xp;
-
- xp = exmlOpen(ep, 512, E4X_BUF_MAX);
- mprAssert(xp);
-
- /*
- * Create the parser stack
- */
- parser = mprAllocTypeZeroed(ep, XmlState);
- parser->ep = ep;
- parser->nodeStack[0].obj = thisObj;
- parser->xmlClass = ejsGetClass(ep, 0, "XML");
- parser->xmlListClass = ejsGetClass(ep, 0, "XMLList");
- parser->fileName = fileName;
-
- exmlSetParseArg(xp, parser);
- exmlSetParserHandler(xp, parserHandler);
-
- return xp;
-}
-
-/******************************************************************************/
-
-static void termParser(Exml *xp)
-{
- mprFree(exmlGetParseArg(xp));
- exmlClose(xp);
-}
-
-/******************************************************************************/
-/*
- * XML parsing callback. Called for each elt and attribute/value pair.
- * For speed, we handcraft the object model here rather than calling
- * putXmlProperty.
- *
- * "<!-- txt -->" parseHandler(efd, , EXML_COMMENT);
- * "<elt" parseHandler(efd, , EXML_NEW_ELT);
- * "...att=value" parseHandler(efd, , EXML_NEW_ATT);
- * "<elt ...>" parseHandler(efd, , EXML_ELT_DEFINED);
- * "<elt/>" parseHandler(efd, , EXML_SOLO_ELT_DEFINED);
- * "<elt> ...<" parseHandler(efd, , EXML_ELT_DATA);
- * "...</elt>" parseHandler(efd, , EXML_END_ELT);
- *
- * Note: we recurse on every new nested elt.
- */
-
-static int parserHandler(Exml *xp, int state, const char *tagName,
- const char *attName, const char *value)
-{
- XmlState *parser;
- XmlTagState *tos;
- EjsVar *currentNode, *vp, *tagNode, *parent, *vpx;
- EjsProperty *pp;
- Ejs *ep;
- char *name;
-
- parser = (XmlState*) xp->parseArg;
- ep = parser->ep;
- tos = &parser->nodeStack[parser->topOfStack];
- currentNode = tos->obj;
-
- mprAssert(state >= 0);
- mprAssert(tagName && *tagName);
-
- switch (state) {
- case EXML_PI:
- /*
- * By using a property name with a leading space, we can store
- * non-user-visible processing instructions as regular properties.
- */
- pp = ejsCreateSimpleNonUniqueProperty(ep, currentNode, E4X_PI_PROPERTY);
- ejsMakePropertyEnumerable(pp, 1);
- vp = ejsGetVarPtr(pp);
- ejsWriteVarAsString(ep, vp, value);
- ejsSetVarFlags(vp, EJS_XML_FLAGS_PI);
- break;
-
- case EXML_COMMENT:
- /*
- * By using a property name with a leading space, we can store
- * non- user-visible comments as regular properties.
- */
- pp = ejsCreateSimpleNonUniqueProperty(ep, currentNode,
- E4X_COMMENT_PROPERTY);
- ejsMakePropertyEnumerable(pp, 1);
- vp = ejsGetVarPtr(pp);
- ejsWriteVarAsString(ep, vp, value);
- ejsSetVarFlags(vp, EJS_XML_FLAGS_COMMENT);
- break;
-
- case EXML_NEW_ELT:
- if (parser->topOfStack > E4X_MAX_NODE_DEPTH) {
- ejsError(ep, EJS_IO_ERROR,
- "XML nodes nested too deeply in %s at line %d",
- parser->fileName, exmlGetLineNumber(xp));
- return MPR_ERR_BAD_SYNTAX;
- }
-
- name = mprStrdup(xp, tagName);
- if (name == 0) {
- return MPR_ERR_MEMORY;
- }
-
- if (cleanTagName(name) < 0) {
- ejsError(ep, EJS_TYPE_ERROR, "Bad XML tag name in %s at %d",
- parser->fileName, exmlGetLineNumber(xp));
- mprFree(name);
- return MPR_ERR_BAD_SYNTAX;
- }
-
- pp = ejsCreateSimpleNonUniqueProperty(ep, currentNode, name);
- ejsMakePropertyEnumerable(pp, 1);
-
- tagNode = ejsGetVarPtr(pp);
-
- /* MOB -- OPT */
- vpx = ejsCreateXml(ep);
- vp = ejsWriteVar(ep, tagNode, vpx, EJS_SHALLOW_COPY);
- ejsMakeObjLive(vp, 1);
- ejsFreeVar(ep, vpx);
-
- /* MOB -- return code */
- pp = ejsSetPropertyToString(ep, vp, E4X_TAG_NAME_PROPERTY, name);
- ejsMakePropertyEnumerable(pp, 0);
-
- ejsSetVarFlags(vp, EJS_XML_FLAGS_ELEMENT);
- ejsMakePropertyEnumerable(ejsGetPropertyPtr(vp), 1);
-
- tos = &parser->nodeStack[++(parser->topOfStack)];
- currentNode = tos->obj = vp;
- tos->attributes = 0;
- tos->comments = 0;
- mprFree(name);
- break;
-
- case EXML_NEW_ATT:
- if (mprAllocSprintf(MPR_LOC_ARGS(xp), &name, 0, "@%s", attName) < 0) {
- return MPR_ERR_MEMORY;
- }
- pp = ejsCreateProperty(ep, currentNode, name);
- ejsMakePropertyEnumerable(pp, 1);
-
- vp = ejsGetVarPtr(pp);
- ejsWriteVarAsString(ep, vp, value);
- ejsSetVarFlags(vp, EJS_XML_FLAGS_ATTRIBUTE);
- mprFree(name);
- break;
-
- case EXML_SOLO_ELT_DEFINED:
- parser->topOfStack--;
- mprAssert(parser->topOfStack >= 0);
- tos = &parser->nodeStack[parser->topOfStack];
- break;
-
- case EXML_ELT_DEFINED:
- if (parser->topOfStack > 0) {
- parent = parser->nodeStack[parser->topOfStack - 1].obj;
- ejsSetProperty(ep, currentNode, E4X_PARENT_PROPERTY, parent);
- }
- break;
-
- case EXML_ELT_DATA:
- case EXML_CDATA:
- pp = ejsCreateSimpleNonUniqueProperty(ep, currentNode,
- E4X_TEXT_PROPERTY);
- ejsMakePropertyEnumerable(pp, 1);
- vp = ejsGetVarPtr(pp);
- ejsWriteVarAsString(ep, vp, value);
- ejsSetVarFlags(vp, EJS_XML_FLAGS_TEXT);
- break;
-
- case EXML_END_ELT:
- /*
- * This is the closing element in a pair "<x>...</x>".
- * Pop the stack frame off the elt stack
- */
- parser->topOfStack--;
- mprAssert(parser->topOfStack >= 0);
- tos = &parser->nodeStack[parser->topOfStack];
- break;
-
- default:
- ejsError(ep, EJS_IO_ERROR, "XML error in %s at %d\nDetails %s",
- parser->fileName, exmlGetLineNumber(xp), exmlGetErrorMsg(xp));
- mprAssert(0);
- return MPR_ERR_BAD_SYNTAX;
- }
- return 0;
-}
-
-/******************************************************************************/
-
-static char *cleanTagName(char *name)
-{
- char *cp;
-
- for (cp = name; *cp; cp++) {
- if (*cp == ':') {
- *cp = '_';
- } else if (!isalnum(*cp) && *cp != '_' && *cp != '$' && *cp != '@') {
- return 0;
- }
- }
- return name;
-}
-
-/******************************************************************************/
-
-static int readFileData(Exml *xp, void *data, char *buf, int size)
-{
- mprAssert(xp);
- mprAssert(data);
- mprAssert(buf);
- mprAssert(size > 0);
-
- return mprRead((MprFile*) data, buf, size);
-}
-
-/******************************************************************************/
-
-static int readStringData(Exml *xp, void *data, char *buf, int size)
-{
- XmlState *parser;
- int rc, len;
-
- mprAssert(xp);
- mprAssert(buf);
- mprAssert(size > 0);
-
- parser = (XmlState*) xp->parseArg;
-
- if (parser->inputPos < parser->inputSize) {
- len = min(size, (parser->inputSize - parser->inputPos));
- rc = mprMemcpy(buf, size, &parser->inputBuf[parser->inputPos], len);
- parser->inputPos += len;
- return rc;
- }
- return 0;
-}
-
-/******************************************************************************/
-
-static int save(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- const char *fileName;
- MprBuf *buf;
- MprFile *file;
- int bytes, len;
-
- if (argc != 1 || !ejsVarIsString(argv[0])) {
- ejsError(ep, EJS_ARG_ERROR, "Bad args. Usage: save(fileName);");
- return -1;
- }
- fileName = argv[0]->string;
-
- /* MOB -- not romable
- Need rom code in MPR not MprServices
- */
-
- /*
- * Convert to a string
- */
- buf = mprCreateBuf(ep, E4X_BUF_SIZE, E4X_BUF_MAX);
- if (xmlToString(ep, buf, thisObj, -1) < 0) {
- mprFree(buf);
- return -1;
- }
-
- file = mprOpen(ep, fileName,
- O_CREAT | O_TRUNC | O_WRONLY | O_TEXT, 0664);
- if (file == 0) {
- ejsError(ep, EJS_IO_ERROR, "Can't open: %s, %d", fileName,
- mprGetOsError());
- return -1;
- }
-
- len = mprGetBufLength(buf);
- bytes = mprWrite(file, buf->start, len);
- if (bytes != len) {
- ejsError(ep, EJS_IO_ERROR, "Can't write to: %s", fileName);
- mprClose(file);
- return -1;
- }
- mprWrite(file, "\n", 1);
- mprFree(buf);
-
- mprClose(file);
-
- return 0;
-}
-
-/******************************************************************************/
-
-static int toString(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- MprBuf *buf;
-
- buf = mprCreateBuf(ep, E4X_BUF_SIZE, E4X_BUF_MAX);
-
- if (xmlToString(ep, buf, thisObj, -1) < 0) {
- mprFree(buf);
- return -1;
- }
- ejsWriteVarAsString(ep, ep->result, (char*) buf->start);
-
- mprFree(buf);
-
- return 0;
-}
-
-/******************************************************************************/
-/* MOB -- need to support XMLList */
-
-static int xmlToString(Ejs *ep, MprBuf *buf, EjsVar *obj, int indentLevel)
-{
- EjsProperty *pp;
- EjsVar *vp;
- char *varBuf;
- int endTag, sawElements;
-
- if (indentLevel < 0) {
- mprPutStringToBuf(buf, "<?xml version=\"1.0\"?>");
- }
-
- switch (obj->type) {
- case EJS_TYPE_STRING:
- if (obj->flags & EJS_XML_FLAGS_ATTRIBUTE) {
- mprPutFmtStringToBuf(buf, " %s=\"%s\"",
- &ejsGetPropertyPtr(obj)->name[1], obj->string);
- /* No new line */
-
- } else if (obj->flags & EJS_XML_FLAGS_COMMENT) {
- mprPutCharToBuf(buf, '\n');
- indent(buf, indentLevel);
- mprPutFmtStringToBuf(buf, "<!-- %s -->", obj->string);
-
- } else if (obj->flags & EJS_XML_FLAGS_TEXT) {
- mprPutStringToBuf(buf, obj->string);
-
- } else {
-// indent(buf, indentLevel);
- mprPutStringToBuf(buf, obj->string);
-// mprPutCharToBuf(buf, '\n');
- }
- break;
-
- default:
- /* Primitive types come here */
- indent(buf, indentLevel);
- /* MOB -- rc */
- varBuf = ejsVarToString(ep, obj);
- mprPutStringToBuf(buf, varBuf);
- break;
-
- case EJS_TYPE_OBJECT:
- if (obj->objectState->baseClass == ejsGetClass(ep, 0, "XML")) {
- if (!obj->objectState->visited) {
- obj->objectState->visited = 1;
-
- /* MOB -- opt. Flags would be quicker */
- if (strcmp(ejsGetPropertyPtr(obj)->name,
- E4X_PARENT_PROPERTY) == 0) {
- return 0;
- }
- /*
- * MOB -- short term fix for tags with no body but with
- * attributes
- */
- if (getNumElements(obj) == 0 && 0) {
- /*
- * XML element is simple with no elements, so return just
- * the text.
- */
- if (getText(buf, obj) < 0) {
- ejsError(ep, EJS_IO_ERROR,
- "XML is to big to convert to a string");
- obj->objectState->visited = 0;
- return -1;
- }
-
- } else if (obj->flags & (EJS_XML_FLAGS_ELEMENT)) {
- /*
- * XML object is complex (has elements) so return full XML
- * content.
- */
- mprPutCharToBuf(buf, '\n');
- indent(buf, indentLevel);
-
- /*
- * When called from toString, obj is not a property
- */
- if (indentLevel >= 0) {
- mprPutFmtStringToBuf(buf, "<%s",
- ejsGetPropertyPtr(obj)->name);
- endTag = 0;
-
- } else {
- endTag = 1;
- }
-
- sawElements = 0;
- pp = ejsGetFirstProperty(obj, 0);
- while (pp) {
- vp = ejsGetVarPtr(pp);
-
- if (! (vp->flags & EJS_XML_FLAGS_ATTRIBUTE)) {
- if (endTag == 0) {
- endTag++;
- mprPutStringToBuf(buf, ">");
- }
- }
- if (vp->flags & EJS_XML_FLAGS_ELEMENT) {
- if (strcmp(ejsGetPropertyPtr(vp)->name,
- E4X_PARENT_PROPERTY) != 0) {
- sawElements++;
- }
- }
-
- if (xmlToString(ep, buf, ejsGetVarPtr(pp),
- indentLevel + 1) < 0){
- return -1;
- }
-
- pp = ejsGetNextProperty(pp, 0);
- }
- if (indentLevel >= 0) {
- if (sawElements) {
- mprPutCharToBuf(buf, '\n');
- indent(buf, indentLevel);
- }
- mprPutFmtStringToBuf(buf, "</%s>",
- ejsGetPropertyPtr(obj)->name);
- }
- }
- obj->objectState->visited = 0;
- }
- return 0;
- }
-
- if (obj->objectState->baseClass == ejsGetClass(ep, 0, "XMLList")) {
- indent(buf, indentLevel);
- /* MOB -- TBD */
- return 0;
- }
-
- /*
- * All other objects. Allow other objects to override toString
- */
- if (ejsRunMethod(ep, obj->objectState->baseClass, "toString",
- 0) < 0) {
- return -1;
- }
- if (ejsVarIsString(ep->result)) {
- indent(buf, indentLevel);
- mprPutStringToBuf(buf, obj->string);
- }
- break;
- }
- return 0;
-}
-
-/******************************************************************************/
-
-static void indent(MprBuf *bp, int level)
-{
- int i;
-
- for (i = 0; i < level; i++) {
- mprPutCharToBuf(bp, '\t');
- }
-}
-
-/******************************************************************************/
-
-static int valueOf(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- if (argc != 0) {
- mprAssert(0);
- return -1;
- }
-
- switch (thisObj->type) {
- default:
- case EJS_TYPE_UNDEFINED:
- case EJS_TYPE_NULL:
- case EJS_TYPE_CMETHOD:
- case EJS_TYPE_OBJECT:
- case EJS_TYPE_METHOD:
- case EJS_TYPE_STRING_CMETHOD:
- ejsWriteVar(ep, ep->result, thisObj, EJS_SHALLOW_COPY);
- break;
-
- case EJS_TYPE_STRING:
- ejsWriteVarAsInteger(ep, ep->result, atoi(thisObj->string));
- break;
-
- case EJS_TYPE_BOOL:
- case EJS_TYPE_INT:
-#if BLD_FEATURE_INT64
- case EJS_TYPE_INT64:
-#endif
-#if BLD_FEATURE_FLOATING_POINT
- case EJS_TYPE_FLOAT:
-#endif
- ejsWriteVar(ep, ep->result, thisObj, EJS_SHALLOW_COPY);
- break;
- }
- return 0;
-}
-
-/******************************************************************************/
-
-static int getList(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- const char *nodeName;
- EjsProperty *pp;
- EjsVar *list, *vp;
-
- if (argc != 1) {
- nodeName = 0;
- } else {
- nodeName = argv[0]->string;
- }
-
- list = ejsCreateArray(ep, 0);
-
- pp = ejsGetFirstProperty(thisObj, EJS_ENUM_ALL);
- while (pp) {
- vp = ejsGetVarPtr(pp);
- if (vp->type == EJS_TYPE_OBJECT) {
- if (strcmp(ejsGetPropertyPtr(vp)->name, E4X_PARENT_PROPERTY) != 0) {
- if (vp->flags & EJS_XML_FLAGS_ELEMENT &&
- (nodeName == 0 || strcmp(nodeName, pp->name) == 0)) {
- ejsAddArrayElt(ep, list, vp, EJS_SHALLOW_COPY);
- }
- }
- }
- pp = ejsGetNextProperty(pp, EJS_ENUM_ALL);
- }
-
- ejsSetReturnValueAndFree(ep, list);
- return 0;
-}
-
-/******************************************************************************/
-
-static int getNumElements(EjsVar *obj)
-{
- EjsProperty *pp;
- int count;
-
- count = 0;
- pp = ejsGetFirstProperty(obj, EJS_ENUM_ALL);
- while (pp) {
- if (ejsGetVarPtr(pp)->flags & EJS_XML_FLAGS_ELEMENT) {
- count++;
- }
- pp = ejsGetNextProperty(pp, EJS_ENUM_ALL);
- }
- return count;
-}
-
-/******************************************************************************/
-/* MOB - This needs to be a public method */
-
-static int getText(MprBuf *buf, EjsVar *obj)
-{
- EjsProperty *pp;
- EjsVar *vp;
-
- pp = ejsGetFirstProperty(obj, EJS_ENUM_ALL);
- while (pp) {
- vp = ejsGetVarPtr(pp);
- if (vp->flags & EJS_XML_FLAGS_TEXT) {
- /* MOB -- should test for overflow */
- mprPutStringToBuf(buf, vp->string);
- }
- pp = ejsGetNextProperty(pp, EJS_ENUM_ALL);
- }
- return 0;
-}
-
-/******************************************************************************/
-/******************************************************************************/
-/******************************** Internal Methods ****************************/
-/******************************************************************************/
-
-static EjsVar *createXmlListProperty(Ejs *ep, EjsVar *obj, const char *property)
-{
- return ejsGetVarPtr(ejsCreateProperty(ep, obj, property));
-}
-
-/******************************************************************************/
-
-static int deleteXmlListProperty(Ejs *ep, EjsVar *obj, const char *property)
-{
- return ejsDeleteProperty(ep, obj, property);
-}
-
-/******************************************************************************/
-
-static EjsVar *getXmlListProperty(Ejs *ep, EjsVar *obj, const char *property)
-{
- // Must always return XML or XMLList event for comments and attributes
- return ejsGetVarPtr(ejsGetSimpleProperty(ep, obj, property));
-}
-
-/******************************************************************************/
-
-static EjsVar *setXmlListProperty(Ejs *ep, EjsVar *obj, const char *property,
- const EjsVar *value)
-{
- EjsProperty *pp;
- EjsVar *vp;
-
- pp = ejsGetSimpleProperty(ep, obj, property);
- if (pp == 0) {
- mprAssert(pp);
- return 0;
- }
- vp = ejsGetVarPtr(pp);
- if (ejsWriteVar(ep, vp, value, EJS_SHALLOW_COPY) < 0){
- mprAssert(0);
- return 0;
- }
- return ejsGetVarPtr(pp);
-}
-
-/******************************************************************************/
-/*
- NEW
-
-static EjsVar *putXmlListProperty(EjsVar *op, const char *property,
- EjsVar *value)
-{
-
- if ((value->objectState->baseClass != XML &&
- value->objectState->baseClass != XMLList) ||
- value->string[0] != '<') {
- c = value.toString();
- } else {
- value = ejsDupVar(value);
- ??
- }
- if (isdigit(*property)) {
- // ERROR
- return 0;
- }
- if (*property == '@') {
- if (op->objectState->baseClass == XMLList) {
- if (op->obj.LENGTH_PROPERTY == 0) {
- c = "";
- } else {
- // Catenate all result of toString on all elts in list
- }
- } else {
- c = c.toString();
- }
- // Replace existing attribute of same name or insert
- return;
- }
- for (i = op->obj.LENGTH - 1; i >= 0; i--) {
- // Delete item of same name
- }
- if (not Found) {
- Append new Xml object
- - set [[name]], [[class]] == "element"
- }
-}
-
- */
-
-/******************************************************************************/
-#else
-void ejs4xDummy() {}
-
-/******************************************************************************/
-#endif /* BLD_FEATURE_EJS_E4X */
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- * @file ejs.c
- * @brief Embedded JavaScript (EJS)
- * @overview Main module interface logic.
- * @remarks The initialization code must be run single-threaded. Includes:
- * ejsOpen, ejsClose.
- */
-/********************************* Copyright **********************************/
-/*
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-/********************************** Includes **********************************/
-
-#include "ejs.h"
-
-#if BLD_FEATURE_EJS
-
-/************************************* Code ***********************************/
-/*
- * Initialize the EJS subsystem
- */
-
-EjsService *ejsOpenService(MprCtx ctx)
-{
- EjsService *service;
- Ejs *interp;
-
- service = mprAllocTypeZeroed(ctx, EjsService);
- if (service == 0) {
- mprError(ctx, MPR_LOC, "Can't allocate service memory");
- return 0;
- }
-
- interp = ejsCreateInterp(service, 0, 0, 0, 1);
- if (interp == 0) {
- mprError(ctx, MPR_LOC, "Can't create master interpreter");
- mprFree(service);
- return 0;
- }
- service->master = interp;
-
- /*
- * Restore the default GC settings for the master interpreter.
- * ejsCreateInterp will have initialized them.
- */
- ejsGCInit(interp, EJS_DEFAULT_OBJ_INC, EJS_DEFAULT_PROP_INC,
- EJS_DEFAULT_VAR_INC, EJS_DEFAULT_STR_INC);
-
- /*
- * Save the default interpreter and global class for all to access
- * MOB -- don't store these. Store the service
- */
- mprSetKeyValue(interp, "ejsMaster", interp);
- mprSetKeyValue(interp, "ejsGlobalClass", interp->global);
-
- /*
- * Once the Object class is created, this routine will also make the
- * Global class a subclass of Object.
- */
- if (ejsDefineObjectClass(interp) < 0) {
- mprError(ctx, MPR_LOC, "Can't define EJS object class");
- mprFree(service);
- return 0;
- }
-
- /*
- * Create all the standard classes
- */
- if (ejsDefineStandardClasses(interp) < 0) {
- mprError(ctx, MPR_LOC, "Can't define EJS standard classes");
- mprFree(service);
- return 0;
- }
-
- if (ejsDefineSystemClasses(interp) < 0) {
- mprError(ctx, MPR_LOC, "Can't define EJS system classes");
- mprFree(service);
- return 0;
- }
-
- if (ejsCreateObjectModel(interp) < 0) {
- mprError(ctx, MPR_LOC, "Can't create EJS object model");
- mprFree(service);
- return 0;
- }
-
-#if UNUSED && BLD_FEATURE_ALLOC_STATS
-{
- EjsVar v;
- mprLog(ctx, 0, "Obj %d, Var %d, Prop %d\n", sizeof(EjsObj), sizeof(EjsVar),
- sizeof(EjsProperty));
- mprLog(ctx, 0, "GCLink %d\n", sizeof(EjsGCLink));
- mprLog(ctx, 0, "objectState %d\n", (uint) &v.objectState - (uint) &v);
-}
-#endif
-
- return service;
-}
-
-/******************************************************************************/
-/*
- * Close down the EJS Service
- */
-
-void ejsCloseService(EjsService *sp, bool doStats)
-{
- Ejs *ep;
-
- mprAssert(sp);
-
- ep = sp->master;
- mprAssert(ep);
-
- ejsTermSystemClasses(ep);
-
- if (ep) {
- ejsFreeVar(ep, sp->globalClass);
-
-#if BLD_FEATURE_ALLOC_STATS
- if (doStats) {
- mprLog(sp, 0, "GC Statistics for the Global Interpreter");
- }
-#endif
- ejsDestroyInterp(ep, doStats);
- }
-
- mprRemoveKeyValue(sp, "ejsMaster");
- mprRemoveKeyValue(sp, "ejsGlobalClass");
-
- mprFree(sp);
-}
-
-/******************************************************************************/
-
-Ejs *ejsGetMasterInterp(EjsService *sp)
-{
- return sp->master;
-}
-
-/******************************************************************************/
-#if BLD_FEATURE_MULTITHREAD
-
-int ejsSetServiceLocks(EjsService *sp, EjsLockFn lock, EjsUnlockFn unlock,
- void *data)
-{
- mprAssert(sp);
-
- sp->lock = lock;
- sp->unlock = unlock;
- sp->lockData = data;
- return 0;
-}
-
-#endif
-/******************************************************************************/
-/*
- * Create and initialize an EJS interpreter. Interpreters have a global object
- * that has the service global class set as a base class. This way, it
- * inherits all the desired global properties, methods and classes.
- *
- * The primary and alternate handles are provided to C methods depending on
- * the flags provided when the C methods are defined. The global variable
- * (optionally) defines a predefined global variable space.
- */
-
-Ejs *ejsCreateInterp(EjsService *sp, void *primaryHandle, void *altHandle,
- EjsVar *global, bool useOwnSlab)
-{
- EjsProperty *pp;
- EjsVar *baseClass;
- Ejs *ep;
-
- ep = mprAllocTypeZeroed(sp, Ejs);
- if (ep == 0) {
- mprAssert(0);
- return ep;
- }
-
- ep->stkPtr = &ep->stack[EJS_MAX_STACK];
-
- ep->service = sp;
- ep->primaryHandle = primaryHandle;
- ep->altHandle = altHandle;
-
- if (sp->master) {
- ep->objectClass = sp->master->objectClass;
- }
-
- if (useOwnSlab) {
- ep->slabs = (EjsSlab*) mprAllocZeroed(ep, sizeof(EjsSlab) *
- EJS_SLAB_MAX);
- ep->slabAllocContext = ep;
-
- } else {
- ep->slabs = sp->master->slabs;
- ep->slabAllocContext = sp->master;
- ep->flags |= EJS_FLAGS_SHARED_SLAB;
- }
-
- ep->frames = mprCreateItemArray(ep, EJS_INC_FRAMES, EJS_MAX_FRAMES);
- if (ep->frames == 0) {
- mprFree(ep);
- return 0;
- }
-
- ejsGCInit(ep, EJS_OBJ_INC, EJS_PROP_INC, EJS_VAR_INC, EJS_STR_INC);
-
- if (sp->globalClass == 0) {
- /*
- * Only do this for the Global interpreter. Create a global class
- * (prototype) object. This is base class from which all global
- * spaces will inherit.
- */
- sp->globalClass = ejsCreateObjVar(ep);
- if (sp->globalClass == 0) {
- mprFree(ep);
- return 0;
- }
- ejsSetClassName(ep, sp->globalClass, "Global");
- global = sp->globalClass;
- }
-
- if (global) {
- /*
- * The default interpreter uses the Global class as its global
- * space.
- */
- ep->global = ejsDupVar(ep, global, EJS_SHALLOW_COPY);
- if (ep->global == 0) {
- mprFree(ep);
- return 0;
- }
- if (ep->global->objectState != sp->globalClass->objectState) {
- ejsSetBaseClass(ep->global, sp->globalClass);
- }
-
- } else {
- /*
- * Use the global class as our global so we can find the object class
- */
- baseClass = ejsGetClass(ep, sp->globalClass, "Object");
- if (baseClass) {
- ep->global = ejsCreateSimpleObjUsingClass(ep, baseClass);
- if (ep->global == 0) {
- mprFree(ep);
- return 0;
- }
-
- /*
- * Override the base class and set to the master Global class
- */
- ejsSetBaseClass(ep->global, sp->globalClass);
-
- } else {
- ep->global = ejsCreateObjVar(ep);
- }
- }
-
- /*
- * The "global" variable points to the global space
- */
- pp = ejsSetProperty(ep, ep->global, "global", ep->global);
- if (pp == 0) {
- mprFree(ep);
- return 0;
- }
- ejsMakePropertyEnumerable(pp, 0);
-
- /*
- * The "Global" variable points to the Global class
- */
- pp = ejsSetProperty(ep, ep->global, "Global", sp->globalClass);
- if (pp == 0) {
- mprFree(ep);
- return 0;
- }
- ejsMakePropertyEnumerable(pp, 0);
-
- ep->local = ejsDupVar(ep, ep->global, EJS_SHALLOW_COPY);
- if (ep->frames == 0 || ep->global == 0 || ep->local == 0) {
- mprFree(ep);
- return 0;
- }
- ejsSetVarName(ep, ep->local, "topLevelLocal");
-
- if (mprAddItem(ep->frames, ep->global) < 0 ||
- mprAddItem(ep->frames, ep->local) < 0) {
- mprFree(ep);
- return 0;
- }
-
- ep->result = ejsCreateUndefinedVar(ep);
- if (ep->result == 0) {
- mprFree(ep);
- return 0;
- }
-
- return ep;
-}
-
-/******************************************************************************/
-/*
- * Close an EJS interpreter
- */
-
-void ejsDestroyInterp(Ejs *ep, bool doStats)
-{
- ejsCleanInterp(ep, doStats);
-
- mprFree(ep);
-}
-
-/******************************************************************************/
-/*
- * Clean an EJS interpreter of all allocated variables, but DONT destroy.
- * We use this rather than DestroyInterp so we delay freeing the Ejs struct
- * until after the service is closed.
- */
-
-void ejsCleanInterp(Ejs *ep, bool doStats)
-{
- int i;
-
- if (ep->global) {
- ejsDeleteProperty(ep, ep->local, "global");
- ejsDeleteProperty(ep, ep->global, "global");
- ep->global = 0;
- }
- if (ep->local) {
- ejsFreeVar(ep, ep->local);
- ep->local = 0;
- }
- if (ep->global) {
- ejsFreeVar(ep, ep->global);
- ep->global = 0;
- }
- if (ep->result) {
- ejsFreeVar(ep, ep->result);
- ep->result = 0;
- }
- if (ep->castAlloc && ep->castTemp) {
- mprFree(ep->castTemp);
- ep->castTemp = 0;
- }
- if (ep->frames) {
- for (i = ep->frames->length - 1; i >= 0; i--) {
- mprRemoveItemByIndex(ep->frames, i);
- }
- mprFree(ep->frames);
- ep->frames = 0;
- }
-
- if (doStats) {
-
-#if BLD_FEATURE_ALLOC_STATS
- mprLog(ep, 0, " ");
- mprLog(ep, 0, "GC Statistics for Interpreter (0x%X)", (uint) ep);
-#endif
-
- /*
- * Cleanup before printing the alloc report
- */
- ejsSetGCDebugLevel(ep, 3);
- ejsCollectGarbage(ep, -1);
-
-#if BLD_DEBUG
- /*
- * If we are the master, dump objects
- */
- if (ep->service->master == ep) {
- ejsDumpObjects(ep);
- }
-#endif
-
-#if BLD_FEATURE_ALLOC_STATS
- /*
- * Print an alloc report. 1 == do leak report
- */
- ejsPrintAllocReport(ep, 1);
-#endif
-
- } else {
- /*
- * Must collect garbage here incase sharing interpreters with the
- * master. If we don't, the mprFree later in DestroyInterp will free
- * all memory and when the master does GC --> crash.
- */
- ejsCollectGarbage(ep, -1);
- }
-}
-
-/******************************************************************************/
-/*
- * Evaluate an EJS script file. This will evaluate the script at the current
- * context. Ie. if inside a function, declarations will be local.
- */
-
-int ejsEvalFile(Ejs *ep, const char *path, EjsVar *result)
-{
- MprFile *file;
- MprFileInfo info;
- char *script;
- char *saveFileName;
- int rc;
-
- mprAssert(path && *path);
-
- if ((file = mprOpen(ep, path, O_RDONLY | O_BINARY, 0666)) == 0) {
- ejsError(ep, EJS_IO_ERROR, "Can't open %s", path);
- return -1;
- }
-
- if (mprGetFileInfo(ep, path, &info) < 0) {
- ejsError(ep, EJS_IO_ERROR, "Can't get file info for %s", path);
- goto error;
- }
-
- if ((script = (char*) mprAlloc(ep, info.size + 1)) == NULL) {
- ejsError(ep, "MemoryError", "Cant malloc %d", (int) info.size);
- goto error;
- }
-
- if (mprRead(file, script, info.size) != (int) info.size) {
- mprFree(script);
- ejsError(ep, EJS_IO_ERROR, "Error reading %s", path);
- goto error;
- }
- mprClose(file);
- script[info.size] = '\0';
-
- saveFileName = ep->fileName;
- ep->fileName = mprStrdup(ep, path);
-
- rc = ejsEvalScript(ep, script, result);
- mprFree(script);
-
- mprFree(ep->fileName);
- ep->fileName = saveFileName;
-
- return rc;
-
-/*
- * Error return
- */
-error:
- mprClose(file);
- return -1;
-}
-
-/******************************************************************************/
-/*
- * Create a new variable scope block. This pushes the old local frame down
- * the stack and creates a new local variables frame.
- */
-
-int ejsOpenBlock(Ejs *ep)
-{
- EjsProperty *pp;
- int fid;
-
- ep->local = ejsCreateSimpleObj(ep, "Object");
- ejsSetVarName(ep, ep->local, "local");
-
- if (ep->local == 0) {
- ejsMemoryError(ep);
- return -1;
- }
-
- if (ep->frames->length > EJS_MAX_FRAMES && !ep->gotException) {
- ejsError(ep, EJS_RANGE_ERROR, "Recursion too deep: Max depth %d",
- EJS_MAX_FRAMES);
- return -1;
- }
-
- /*
- * Must add to frames before ejsSetProperty which will make the object live
- */
- fid = mprAddItem(ep->frames, ep->local);
- if (fid < 0) {
- ejsMemoryError(ep);
- return -1;
- }
-
- /* Self reference */
- pp = ejsSetProperty(ep, ep->local, "local", ep->local);
- ejsMakePropertyEnumerable(pp, 0);
-
- return fid;
-}
-
-/******************************************************************************/
-/*
- * Set a new variable scope block. This pushes the old local frame down
- * the stack and creates a new local variables frame.
- */
-
-int ejsSetBlock(Ejs *ep, EjsVar *local)
-{
- ep->local = ejsDupVar(ep, local, EJS_SHALLOW_COPY);
- ejsMakeObjPermanent(ep->local, 1);
- return mprAddItem(ep->frames, ep->local);
-}
-
-/******************************************************************************/
-/*
- * Close a variable scope block opened via ejsOpenBlock. Pop back the old
- * local variables frame.
- */
-
-int ejsCloseBlock(Ejs *ep, int fid)
-{
- mprAssert(ep->local >= 0);
- mprAssert(fid >= 0);
-
- mprAssert(ep->local == (EjsVar*) mprGetItem(ep->frames, fid));
-
- if (ep->local) {
- /* Allow GC */
- ejsMakeObjPermanent(ep->local, 0);
- ejsFreeVar(ep, ep->local);
- }
-
- mprRemoveItemByIndex(ep->frames, fid);
-
- ep->local = (EjsVar*) mprGetItem(ep->frames,
- mprGetItemCount(ep->frames) - 1);
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Create a new variable scope block and evaluate a script. All frames
- * created during this context will be automatically deleted when complete.
- * vp is optional. i.e. created local variables will be discarded
- * when this routine returns.
- */
-
-int ejsEvalBlock(Ejs *ep, char *script, EjsVar *vp)
-{
- int rc, fid;
-
- mprAssert(script);
-
- fid = ejsOpenBlock(ep);
- if (fid < 0) {
- return fid;
- }
-
- rc = ejsEvalScript(ep, script, vp);
-
- ejsCloseBlock(ep, fid);
-
- return rc;
-}
-
-/******************************************************************************/
-/*
- * Parse and evaluate a EJS. The script is evaluated at the current context.
- * Return the result in *vp. The result is "owned" by EJ and the caller
- * must not free it. Returns -1 on errors and zero for success.
- */
-
-int ejsEvalScript(Ejs *ep, const char *script, EjsVar *vp)
-{
- int state;
-
- ejsClearVar(ep, ep->result);
- ep->gotException = 0;
-
- if (script == 0) {
- return 0;
- }
-
- /*
- * Allocate a new evaluation block, and save the old one
- */
- if (ejsLexOpenScript(ep, script) < 0) {
- return MPR_ERR_MEMORY;
- }
-
- /*
- * Do the actual parsing and evaluation
- */
- ep->scriptStatus = 0;
-
- do {
- state = ejsParse(ep, EJS_STATE_BEGIN, EJS_FLAGS_EXE);
-
- if (state == EJS_STATE_RET) {
- state = EJS_STATE_EOF;
- }
- } while (state != EJS_STATE_EOF && state != EJS_STATE_ERR);
-
- ejsLexCloseScript(ep);
-
- if (state == EJS_STATE_ERR) {
- return -1;
- }
-
- if (vp) {
- /* Caller must not free. */
- *vp = *ep->result;
- }
-
- return ep->scriptStatus;
-}
-
-/******************************************************************************/
-
-void ejsSetFileName(Ejs *ep, const char *fileName)
-{
- mprFree(ep->fileName);
- ep->fileName = mprStrdup(ep, fileName);
-}
-
-/******************************************************************************/
-/*
- * Format the stack backtrace
- */
-
-char *ejsFormatStack(Ejs* ep)
-{
- EjsInput *ip;
- char *errbuf;
- int frame, len;
-
- mprAssert(ep);
-
- ip = ep->input;
-
- errbuf = 0;
-
- len = 0;
- frame = 0;
- while (ip && frame < EJS_MAX_BACKTRACE) {
- char *traceLine, *newErrbuf, *line;
- for (line = ip->line; *line && isspace(*line); line++) {
- ;
- }
- mprAllocSprintf(MPR_LOC_ARGS(ep), &traceLine, MPR_MAX_STRING,
- " [%02d] %s, %s, line %d -> %s\n",
- frame++,
- ip->fileName ? ip->fileName : "script",
- ip->procName ? ip->procName: "global",
- ip->lineNumber, line);
- if (traceLine == 0) {
- break;
- }
- newErrbuf = mprRealloc(ep, errbuf, len + strlen(traceLine) + 1);
- if (newErrbuf == NULL) {
- break;
- }
- errbuf = newErrbuf;
- memcpy(&errbuf[len], traceLine, strlen(traceLine) + 1);
- len += strlen(traceLine);
- mprFree(traceLine);
- ip = ip->next;
- }
- return errbuf;
-}
-
-/******************************************************************************/
-/*
- * Internal use method to set the error message
- *
- * Error, ArgError, AssertError, IOError, MemoryError, RangeError,
- * ReferenceError, SyntaxError, TypeError, MemoryError
- */
-
-void ejsError(Ejs* ep, const char *errorType, const char* fmt, ...)
-{
- va_list fmtArgs;
- EjsVar *error;
- char *msg, *stack;
-
- va_start(fmtArgs, fmt);
- mprAllocVsprintf(MPR_LOC_ARGS(ep), &msg, MPR_MAX_STRING, fmt, fmtArgs);
- va_end(fmtArgs);
-
- /*
- * Create a new Error exception object. If bad error type, default to
- * "Error"
- */
- if (ejsGetClass(ep, 0, errorType) == 0) {
- errorType = "Error";
- }
- ep->gotException = 1;
-
- error = ejsCreateObj(ep, 0, errorType, msg);
- if (error == 0) {
- return;
- }
- mprFree(msg);
-
- stack = ejsFormatStack(ep);
- ejsSetPropertyToString(ep, error, "stack", stack);
- mprFree(stack);
-
- ejsWriteVar(ep, ep->result, error, EJS_SHALLOW_COPY);
- ejsFreeVar(ep, error);
-}
-
-/******************************************************************************/
-
-void ejsSyntaxError(Ejs *ep, const char *msg)
-{
- if (msg == 0) {
- msg = " ";
- }
- ejsError(ep, EJS_SYNTAX_ERROR, msg);
-}
-
-/******************************************************************************/
-
-void ejsMemoryError(Ejs *ep)
-{
- ejsError(ep, EJS_MEMORY_ERROR, "Memory allocation error");
-}
-
-/******************************************************************************/
-
-void ejsArgError(Ejs *ep, const char *msg)
-{
- mprAssert(msg && *msg);
-
- ejsError(ep, EJS_ARG_ERROR, msg);
-}
-
-/******************************************************************************/
-
-void ejsInternalError(Ejs *ep, const char *msg)
-{
- mprAssert(msg && *msg);
-
- ejsError(ep, EJS_INTERNAL_ERROR, msg);
-}
-
-/******************************************************************************/
-/*
- * Public routine to set the error message. Caller MUST NOT free.
- */
-
-char *ejsGetErrorMsg(Ejs *ep)
-{
- EjsVar *error;
- const char *message, *stack, *name;
- char *buf;
-
- error = ep->result;
-
- if (! ejsVarIsObject(error)) {
- name = message = stack = 0;
- } else {
- name = ejsGetPropertyAsString(ep, error, "name");
- message = ejsGetPropertyAsString(ep, error, "message");
- stack = ejsGetPropertyAsString(ep, error, "stack");
- }
- if (name == 0 || message == 0) {
- buf = mprStrdup(ep, "Unspecified execution error\n");
- } else {
- mprAllocSprintf(MPR_LOC_ARGS(ep), &buf, 0,
- "%s Exception: %s\nStack:\n%s\n",
- name, message, stack ? stack : " " );
- }
- mprFree(ep->errorMsg);
- ep->errorMsg = buf;
- return buf;
-}
-
-/******************************************************************************/
-/*
- * Get the current line number
- */
-
-int ejsGetLineNumber(Ejs *ep)
-{
- if (ep->input == 0) {
- return -1;
- }
- return ep->input->lineNumber;
-}
-
-/******************************************************************************/
-/*
- * Return the local object
- */
-
-EjsVar *ejsGetLocalObj(Ejs *ep)
-{
- return ep->local;
-}
-
-/******************************************************************************/
-/*
- * Return the global object
- */
-
-EjsVar *ejsGetGlobalObj(Ejs *ep)
-{
- return ep->global;
-}
-
-/******************************************************************************/
-/*
- * Set the expression return value
- */
-
-void ejsSetReturnValue(Ejs *ep, EjsVar *vp)
-{
- mprAssert(ep);
- mprAssert(vp);
-
- if (vp == 0) {
- return;
- }
- ejsWriteVar(ep, ep->result, vp, EJS_SHALLOW_COPY);
-}
-
-/******************************************************************************/
-/*
- * Set the expression return value and free the arg.
- */
-
-void ejsSetReturnValueAndFree(Ejs *ep, EjsVar *vp)
-{
- mprAssert(ep);
- mprAssert(vp);
-
- ejsWriteVar(ep, ep->result, vp, EJS_SHALLOW_COPY);
- ejsFreeVar(ep, vp);
-}
-
-/******************************************************************************/
-/*
- * Set the expression return value to a string value.
- */
-
-void ejsSetReturnValueToString(Ejs *ep, const char *value)
-{
- mprAssert(ep);
- mprAssert(value);
-
- ejsWriteVarAsString(ep, ep->result, value);
-}
-
-/******************************************************************************/
-/*
- * Set the expression return value to a binary string value.
- */
-
-void ejsSetReturnValueToBinaryString(Ejs *ep, const uchar *value, int len)
-{
- mprAssert(ep);
- mprAssert(value);
-
- ejsWriteVarAsBinaryString(ep, ep->result, value, len);
-}
-
-/******************************************************************************/
-/*
- * Set the expression return value to a integer value.
- */
-
-void ejsSetReturnValueToInteger(Ejs *ep, int value)
-{
- mprAssert(ep);
-
- ejsWriteVarAsInteger(ep, ep->result, value);
-}
-
-/******************************************************************************/
-/*
- * Set the expression return value to an EjsNum value.
- */
-
-void ejsSetReturnValueToNumber(Ejs *ep, EjsNum value)
-{
- mprAssert(ep);
-
- ejsWriteVarAsNumber(ep, ep->result, value);
-}
-
-/******************************************************************************/
-/*
- * Set the expression return value to a boolean value.
- */
-
-void ejsSetReturnValueToBoolean(Ejs *ep, int value)
-{
- mprAssert(ep);
-
- ejsWriteVarAsBoolean(ep, ep->result, value);
-}
-
-/******************************************************************************/
-/*
- * Set the expression return value to a boolean value.
- */
-
-void ejsSetReturnValueToUndefined(Ejs *ep)
-{
- mprAssert(ep);
-
- ejsWriteVarAsUndefined(ep, ep->result);
-}
-
-/******************************************************************************/
-/*
- * Get the expression return value
- */
-
-EjsVar *ejsGetReturnValue(Ejs *ep)
-{
- mprAssert(ep);
-
- return ep->result;
-}
-
-/******************************************************************************/
-
-void *ejsGetUserData(Ejs *ep)
-{
- mprAssert(ep);
-
- return ep->userData;
-}
-
-/******************************************************************************/
-/*
- * Get a variable given a full variable spec possibly containing "." or "[]".
- */
-
-EjsVar *ejsGetVar(Ejs *ep, const char *fullName)
-{
- mprAssert(ep);
- mprAssert(fullName && *fullName);
-
- return ejsFindProperty(ep, 0, 0, ep->global, ep->local, fullName, 0);
-}
-
-/******************************************************************************/
-/*
- * Get a string var given a full variable spec possibly containing "." or "[]".
- */
-
-const char *ejsGetStr(Ejs *ep, const char *fullName, const char *defaultValue)
-{
- EjsVar *vp;
-
- mprAssert(fullName && *fullName);
-
- vp = ejsFindProperty(ep, 0, 0, ep->global, ep->local, fullName, 0);
- if (vp == 0 || !ejsVarIsString(vp)) {
- return defaultValue;
- }
- /* MOB -- what about VarToStr */
- return vp->string;
-}
-
-/******************************************************************************/
-/*
- * Get an int var given a full variable spec possibly containing "." or "[]".
- */
-
-int ejsGetInt(Ejs *ep, const char *fullName, int defaultValue)
-{
- EjsVar *vp;
-
- mprAssert(ep);
- mprAssert(fullName && *fullName);
-
- vp = ejsFindProperty(ep, 0, 0, ep->global, ep->local, fullName, 0);
- if (vp == 0 || !ejsVarIsInteger(vp)) {
- return defaultValue;
- }
- /* MOB -- should use VarToInt */
- return vp->integer;
-}
-
-/******************************************************************************/
-/*
- * Get an bool var given a full variable spec possibly containing "." or "[]".
- */
-
-int ejsGetBool(Ejs *ep, const char *fullName, int defaultValue)
-{
- EjsVar *vp;
-
- mprAssert(ep);
- mprAssert(fullName && *fullName);
-
- vp = ejsFindProperty(ep, 0, 0, ep->global, ep->local, fullName, 0);
- if (vp == 0 || !ejsVarIsBoolean(vp)) {
- return defaultValue;
- }
- /* MOB -- should use VarToBool */
- return vp->boolean;
-}
-
-/******************************************************************************/
-/*
- * Set a variable that may be an arbitrarily complex object or array reference.
- * Will always define in the top most variable frame.
- */
-
-int ejsSetVar(Ejs *ep, const char *fullName, const EjsVar *value)
-{
- EjsVar *vp;
-
- mprAssert(fullName && *fullName);
-
- vp = ejsFindProperty(ep, 0, 0, ep->global, ep->local, fullName, 1);
- if (vp == 0) {
- return MPR_ERR_CANT_CREATE;
- }
-
- if (ejsWriteVar(ep, vp, value, EJS_SHALLOW_COPY) == 0) {
- return MPR_ERR_CANT_WRITE;
- }
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Set a variable that may be an arbitrarily complex object or array reference.
- * Will always define in the top most variable frame.
- */
-
-int ejsSetStr(Ejs *ep, const char *fullName, const char *value)
-{
- EjsVar *vp;
-
- mprAssert(fullName && *fullName);
-
- vp = ejsFindProperty(ep, 0, 0, ep->global, ep->local, fullName, 1);
- if (vp == 0) {
- return MPR_ERR_CANT_CREATE;
- }
-
- if (ejsWriteVarAsString(ep, vp, value) == 0) {
- return MPR_ERR_CANT_WRITE;
- }
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Set a variable that may be an arbitrarily complex object or array reference.
- * Will always define in the top most variable frame.
- */
-
-int ejsSetInt(Ejs *ep, const char *fullName, int value)
-{
- EjsVar *vp;
-
- mprAssert(fullName && *fullName);
-
- vp = ejsFindProperty(ep, 0, 0, ep->global, ep->local, fullName, 1);
- if (vp == 0) {
- return MPR_ERR_CANT_CREATE;
- }
-
- /* Can't fail */
- ejsWriteVarAsInteger(ep, vp, value);
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Set a variable that may be an arbitrarily complex object or array reference.
- * Will always define in the top most variable frame.
- */
-
-int ejsSetBool(Ejs *ep, const char *fullName, bool value)
-{
- EjsVar *vp;
-
- mprAssert(fullName && *fullName);
-
- vp = ejsFindProperty(ep, 0, 0, ep->global, ep->local, fullName, 1);
- if (vp == 0) {
- return MPR_ERR_CANT_CREATE;
- }
-
- /* Can't fail */
- ejsWriteVarAsBoolean(ep, vp, value);
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Set a variable that may be an arbitrarily complex object or array reference.
- * Will always define in the top most variable frame. Free the value passed in.
- */
-
-int ejsSetVarAndFree(Ejs *ep, const char *fullName, EjsVar *value)
-{
- EjsVar *vp;
-
- mprAssert(fullName && *fullName);
-
- vp = ejsFindProperty(ep, 0, 0, ep->global, ep->local, fullName, 1);
- if (vp == 0) {
- return MPR_ERR_CANT_CREATE;
- }
-
- if (ejsWriteVar(ep, vp, value, EJS_SHALLOW_COPY) == 0) {
- ejsFreeVar(ep, value);
- return MPR_ERR_CANT_WRITE;
- }
-
- ejsFreeVar(ep, value);
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Delete a variable
- */
-
-int ejsDeleteVar(Ejs *ep, const char *fullName)
-{
- EjsVar *vp;
- EjsVar *obj;
- char *propertyName;
-
- vp = ejsFindProperty(ep, &obj, &propertyName, ep->global, ep->local,
- fullName, 0);
- if (vp == 0) {
- return -1;
- }
-
- mprAssert(propertyName);
- mprAssert(propertyName);
-
- return ejsDeleteProperty(ep, obj, propertyName);
-}
-
-/******************************************************************************/
-/*
- * Utility routine to crack JavaScript arguments. Return the number of args
- * seen. This routine only supports %s and %d type args.
- *
- * Typical usage:
- *
- * if (ejsParseArgs(argc, argv, "%s %d", &name, &age) < 2) {
- * // Insufficient args
- * return -1;
- * }
- */
-
-int ejsParseArgs(int argc, char **argv, const char *fmt, ...)
-{
- va_list vargs;
- const char *cp;
- char **sp, *s;
- int *bp, *ip, argn;
-
- va_start(vargs, fmt);
-
- if (argv == 0) {
- return 0;
- }
-
- for (argn = 0, cp = fmt; cp && *cp && argn < argc && argv[argn]; ) {
- if (*cp++ != '%') {
- continue;
- }
-
- s = argv[argn];
- switch (*cp) {
- case 'b':
- bp = va_arg(vargs, int*);
- if (bp) {
- if (strcmp(s, "true") == 0 || s[0] == '1') {
- *bp = 1;
- } else {
- *bp = 0;
- }
- } else {
- *bp = 0;
- }
- break;
-
- case 'd':
- ip = va_arg(vargs, int*);
- *ip = atoi(s);
- break;
-
- case 's':
- sp = va_arg(vargs, char**);
- *sp = s;
- break;
-
- default:
- mprAssert(0);
- }
- argn++;
- }
-
- va_end(vargs);
- return argn;
-}
-
-/******************************************************************************/
-/*
- * Define the standard classes
- */
-
-int ejsDefineStandardClasses(Ejs *master)
-{
- if (ejsDefineArrayClass(master) != 0 ||
- ejsDefineBooleanClass(master) != 0 ||
- ejsDefineErrorClasses(master) != 0 ||
- ejsDefineFunctionClass(master) != 0 ||
- ejsDefineNumberClass(master) != 0 ||
-#if FUTURE
- ejsDefineDateClass(master) != 0 ||
-#endif
-#if BLD_FEATURE_EJS_E4X
- ejsDefineXmlClasses(master) != 0 ||
-#endif
-#if BLD_FEATURE_EJS_DB && NOT_HERE
- ejsDefineDbClasses(master) != 0 ||
-#endif
- ejsDefineStringClass(master) != 0) {
- return MPR_ERR_MEMORY;
- }
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Define the EJS System Object Model
- */
-
-int ejsDefineSystemClasses(Ejs *master)
-{
- if (ejsDefineSystemClass(master) != 0 ||
- ejsDefineAppClass(master) != 0 ||
- ejsDefineMemoryClass(master) != 0 ||
- ejsDefineLogClass(master) != 0 ||
- ejsDefineDebugClass(master) != 0 ||
- ejsDefineGCClass(master) != 0 ||
- ejsDefineFileSystemClass(master) != 0 ||
-#if BREW
- ejsDefineFileClass(master) != 0 ||
- ejsDefineHTTPClass(master) != 0 ||
-#endif
- ejsDefineGlobalProperties(master) != 0) {
- return MPR_ERR_MEMORY;
- }
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Terminate the system object model and classes
- */
-
-int ejsTermSystemClasses(Ejs *master)
-{
-#if BREW
- ejsTermHTTPClass(master);
-#endif
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Define the EJS object model
- */
-
-int ejsCreateObjectModel(Ejs *ejs)
-{
- EjsProperty *pp;
-
- pp = ejsSetPropertyToNewObj(ejs, ejs->global, "system", "System", 0);
- if (pp == 0) {
- return MPR_ERR_MEMORY;
- }
-
- if (ejsSetPropertyToNewObj(ejs, ejsGetVarPtr(pp), "app", "System.App",
- 0) == 0) {
- return MPR_ERR_MEMORY;
- }
- return 0;
-}
-
-/******************************************************************************/
-
-void ejsTrace(Ejs *ep, const char *fmt, ...)
-{
- va_list args;
- char buf[MPR_MAX_LOG_STRING];
- int len;
-
- va_start(args, fmt);
- len = mprVsprintf(buf, sizeof(buf) - 1, fmt, args);
- va_end(args);
-
- mprLog(ep, 0, buf, len);
-
- va_end(args);
-}
-
-/******************************************************************************/
-
-bool ejsGotException(Ejs *ep)
-{
- return (bool) ep->gotException;
-}
-
-/******************************************************************************/
-
-void ejsSetPrimaryHandle(Ejs *ep, void *primaryHandle)
-{
- mprAssert(ep);
-
- ep->primaryHandle = primaryHandle;
-}
-
-/******************************************************************************/
-
-void ejsSetAlternateHandle(Ejs *ep, void *alternateHandle)
-{
- mprAssert(ep);
-
- ep->altHandle = alternateHandle;
-}
-
-/******************************************************************************/
-
-#else
-void ejsDummy() {}
-
-#endif /* BLD_FEATURE_EJS */
-
-/******************************************************************************/
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- * ejs.h - EJScript Language (ECMAScript) header.
- */
-
-/********************************* Copyright **********************************/
-/*
- * @copy default.g
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- * Copyright (c) Michael O'Brien, 1994-1995. All Rights Reserved.
- * Portions Copyright (c) GoAhead Software, 1995-2000. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-/********************************** Includes **********************************/
-
-#ifndef _h_EJS
-#define _h_EJS 1
-
-#include "mpr.h"
-#include "ejsVar.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/********************************* Prototypes *********************************/
-/*
- * Constants
- */
-#if BLD_FEATURE_SQUEEZE
- #define EJS_GC_WORK_QUOTA 160 /* Allocations required before
- garbage colllection */
-
- #define EJS_PARSE_INCR 256 /* Growth factor */
- #define EJS_MAX_RECURSE 25 /* Sanity for maximum recursion */
- #define EJS_SMALL_OBJ_HASH_SIZE 11 /* Small object hash size */
- #define EJS_LIST_INCR 8 /* Growth increment for lists */
- #define EJS_MAX_BACKTRACE 10 /* Recursion limit for assert */
-
-#else
- #define EJS_GC_WORK_QUOTA 500
-
- #define EJS_PARSE_INCR 1024
- #define EJS_MAX_RECURSE 100
- #define EJS_SMALL_OBJ_HASH_SIZE 11
- #define EJS_LIST_INCR 16
- #define EJS_MAX_BACKTRACE 25
-
-#endif
-
-/*
- * Allocation increments for the default interpreter
- */
-#define EJS_DEFAULT_VAR_INC 8 /* Var allocation increment */
-#define EJS_DEFAULT_PROP_INC 96 /* Property allocation increment */
-#define EJS_DEFAULT_OBJ_INC 24 /* Object allocation increment */
-#define EJS_DEFAULT_STR_INC 64 /* Object allocation increment */
-
-#define EJS_MIN_TIME_FOR_GC 300 /**< Need 1/3 sec for GC */
-#define EJS_GC_MIN_WORK_QUOTA 50 /**< Min to stop thrashing */
-
-/*
- * Allocation increments for all non-default interpreters
- */
-#define EJS_VAR_INC 32
-#define EJS_PROP_INC 64
-#define EJS_OBJ_INC 64
-#define EJS_STR_INC 64
-
-#define EJS_INC_FRAMES 8 /* Frame stack increment */
-#define EJS_MAX_FRAMES 64 /* Max frame stack */
-
-/*
- * Lexical analyser tokens
- */
-#define EJS_TOK_ERR -1 /* Any error */
-#define EJS_TOK_LPAREN 1 /* ( */
-#define EJS_TOK_RPAREN 2 /* ) */
-#define EJS_TOK_IF 3 /* if */
-#define EJS_TOK_ELSE 4 /* else */
-#define EJS_TOK_LBRACE 5 /* { */
-#define EJS_TOK_RBRACE 6 /* } */
-#define EJS_TOK_LOGICAL 7 /* ||, &&, ! */
-#define EJS_TOK_EXPR 8 /* +, -, /, % */
-#define EJS_TOK_SEMI 9 /* ; */
-#define EJS_TOK_LITERAL 10 /* literal string */
-#define EJS_TOK_METHOD_NAME 11 /* methodName( */
-#define EJS_TOK_NEWLINE 12 /* newline white space */
-#define EJS_TOK_ID 13 /* Identifier */
-#define EJS_TOK_EOF 14 /* End of script */
-#define EJS_TOK_COMMA 15 /* Comma */
-#define EJS_TOK_VAR 16 /* var */
-#define EJS_TOK_ASSIGNMENT 17 /* = */
-#define EJS_TOK_FOR 18 /* for */
-#define EJS_TOK_INC_DEC 19 /* ++, -- */
-#define EJS_TOK_RETURN 20 /* return */
-#define EJS_TOK_PERIOD 21 /* . */
-#define EJS_TOK_LBRACKET 22 /* [ */
-#define EJS_TOK_RBRACKET 23 /* ] */
-#define EJS_TOK_NEW 24 /* new */
-#define EJS_TOK_DELETE 25 /* delete */
-#define EJS_TOK_IN 26 /* in */
-#define EJS_TOK_FUNCTION 27 /* function */
-#define EJS_TOK_NUMBER 28 /* Number */
-#define EJS_TOK_CLASS 29 /* class */
-#define EJS_TOK_EXTENDS 30 /* extends */
-#define EJS_TOK_PUBLIC 31 /* public */
-#define EJS_TOK_PRIVATE 32 /* private */
-#define EJS_TOK_PROTECTED 33 /* private */
-#define EJS_TOK_TRY 34 /* try */
-#define EJS_TOK_CATCH 35 /* catch */
-#define EJS_TOK_FINALLY 36 /* finally */
-#define EJS_TOK_THROW 37 /* throw */
-#define EJS_TOK_COLON 38 /* : */
-#define EJS_TOK_GET 39 /* get */
-#define EJS_TOK_SET 40 /* set */
-#define EJS_TOK_MODULE 41 /* module */
-#define EJS_TOK_EACH 42 /* each */
-
-/*
- * Expression operators
- */
-#define EJS_EXPR_LESS 1 /* < */
-#define EJS_EXPR_LESSEQ 2 /* <= */
-#define EJS_EXPR_GREATER 3 /* > */
-#define EJS_EXPR_GREATEREQ 4 /* >= */
-#define EJS_EXPR_EQ 5 /* == */
-#define EJS_EXPR_NOTEQ 6 /* != */
-#define EJS_EXPR_PLUS 7 /* + */
-#define EJS_EXPR_MINUS 8 /* - */
-#define EJS_EXPR_DIV 9 /* / */
-#define EJS_EXPR_MOD 10 /* % */
-#define EJS_EXPR_LSHIFT 11 /* << */
-#define EJS_EXPR_RSHIFT 12 /* >> */
-#define EJS_EXPR_MUL 13 /* * */
-#define EJS_EXPR_ASSIGNMENT 14 /* = */
-#define EJS_EXPR_INC 15 /* ++ */
-#define EJS_EXPR_DEC 16 /* -- */
-#define EJS_EXPR_BOOL_COMP 17 /* ! */
-
-/*
- * Conditional operators
- */
-#define EJS_COND_AND 1 /* && */
-#define EJS_COND_OR 2 /* || */
-#define EJS_COND_NOT 3 /* ! */
-
-/**
- * EJ Parsing States. Error and Return are be negative.
- */
-#define EJS_STATE_ERR -1 /**< Error state */
-#define EJS_STATE_RET -2 /**< Return statement */
-#define EJS_STATE_EOF -3 /**< End of file */
-#define EJS_STATE_COND 2 /* Parsing a conditional stmt */
-#define EJS_STATE_COND_DONE 3
-#define EJS_STATE_RELEXP 4 /* Parsing a relational expr */
-#define EJS_STATE_RELEXP_DONE 5
-#define EJS_STATE_EXPR 6 /* Parsing an expression */
-#define EJS_STATE_EXPR_DONE 7
-#define EJS_STATE_STMT 8 /* Parsing General statement */
-#define EJS_STATE_STMT_DONE 9
-#define EJS_STATE_STMT_BLOCK_DONE 10 /* End of block "}" */
-#define EJS_STATE_ARG_LIST 11 /* Method arg list */
-#define EJS_STATE_ARG_LIST_DONE 12
-#define EJS_STATE_DEC_LIST 16 /* Declaration list */
-#define EJS_STATE_DEC_LIST_DONE 17
-#define EJS_STATE_DEC 18 /* Declaration statement */
-#define EJS_STATE_DEC_DONE 19
-
-#define EJS_STATE_BEGIN EJS_STATE_STMT
-
-/*
- * General parsing flags.
- */
-#define EJS_FLAGS_EXE 0x1 /* Execute statements */
-#define EJS_FLAGS_LOCAL 0x2 /* Get local vars only */
-#define EJS_FLAGS_GLOBAL 0x4 /* Get global vars only */
-#define EJS_FLAGS_CREATE 0x8 /* Create var */
-#define EJS_FLAGS_ASSIGNMENT 0x10 /* In assignment stmt */
-#define EJS_FLAGS_DELETE 0x20 /* Deleting a variable */
-#define EJS_FLAGS_NEW 0x80 /* In a new stmt() */
-#define EJS_FLAGS_EXIT 0x100 /* Must exit */
-#define EJS_FLAGS_LHS 0x200 /* Left-hand-side of assignment */
-#define EJS_FLAGS_FORIN 0x400 /* In "for (v in ..." */
-#define EJS_FLAGS_CLASS_DEC 0x800 /* "class name [extends] name " */
-#define EJS_FLAGS_TRY 0x2000 /* In a try {} block */
-#define EJS_FLAGS_CATCH 0x4000 /* "catch (variable)" */
-#define EJS_FLAGS_DONT_GC 0x8000 /* Don't garbage collect */
-#define EJS_FLAGS_NO_ARGS 0x10000 /* Accessors don't use args */
-#define EJS_FLAGS_ENUM_HIDDEN 0x20000 /* Enumerate hidden fields */
-#define EJS_FLAGS_ENUM_BASE 0x40000 /* Enumerate base classes */
-#define EJS_FLAGS_TRACE_ARGS 0x80000 /* Support for printv */
-#define EJS_FLAGS_SHARED_SLAB 0x100000/* Using a shared slab */
-
-/*
- * Exceptions
- */
-#define EJS_ARG_ERROR "ArgError" /**< Method argument error */
-#define EJS_ASSERT_ERROR "AssertError" /**< Assertion error */
-#define EJS_EVAL_ERROR "EvalError" /**< General evalation error */
-#define EJS_INTERNAL_ERROR "InternalError" /**< Internal error */
-#define EJS_IO_ERROR "IOError" /**< IO or data error */
-#define EJS_MEMORY_ERROR "MemoryError" /**< Memory allocation error */
-#define EJS_RANGE_ERROR "RangeError" /**< Data out of range (div by 0) */
-#define EJS_REFERENCE_ERROR "ReferenceError"/**< Object or property reference */
-#define EJS_SYNTAX_ERROR "SyntaxError" /**< Javascript syntax error */
-#define EJS_TYPE_ERROR "TypeError" /**< Wrong type supplied */
-
-/*
- * E4X
- */
-#if BLD_FEATURE_EJS_E4X
-#if BLD_FEATURE_SQUEEZE
-#define E4X_BUF_SIZE 512 /* Initial buffer size for tokens */
-#define E4X_BUF_MAX (32 * 1024) /* Max size for tokens */
-#define E4X_MAX_NODE_DEPTH 24 /* Max nesting of tags */
-#else
-#define E4X_BUF_SIZE 4096
-#define E4X_BUF_MAX (128 * 1024)
-#define E4X_MAX_NODE_DEPTH 128
-#endif
-
-#define E4X_MAX_ELT_SIZE (E4X_BUF_MAX-1)
-#define E4X_TEXT_PROPERTY "-txt"
-#define E4X_TAG_NAME_PROPERTY "-tag"
-#define E4X_COMMENT_PROPERTY "-com"
-#define E4X_ATTRIBUTES_PROPERTY "-att"
-#define E4X_PI_PROPERTY "-pi"
-#define E4X_PARENT_PROPERTY "-parent"
-#endif
-
-#if BLD_FEATURE_MULTITHREAD
-/**
- * Multithreaded lock function
- */
-typedef void (*EjsLockFn)(void *lockData);
-/**
- * Multithreaded unlock function
- */
-typedef void (*EjsUnlockFn)(void *lockData);
-#endif
-
-/*
- * Token limits
- */
-#define EJS_MAX_LINE 128 /* Maximum input line buffer */
-#define EJS_MAX_TOKEN 640 /* Max input parse token */
-#define EJS_TOKEN_STACK 3 /* Put back token stack */
-
-/*
- * Putback token
- */
-
-typedef struct EjsToken {
- char tokbuf[EJS_MAX_TOKEN];
- int tid; /* Token ID */
-} EjsToken;
-
-/*
- * EJ evaluation block structure
- */
-typedef struct EjsInput {
- EjsToken putBack[EJS_TOKEN_STACK]; /* Put back token stack */
- int putBackIndex; /* Top of stack index */
- char line[EJS_MAX_LINE]; /* Current line */
- char *fileName; /* File or script name */
- int lineLength; /* Current line length */
- int lineNumber; /* Parse line number */
- int lineColumn; /* Column in line */
- struct EjsInput *next; /* Used for backtraces */
- const char *procName; /* Gives name in backtrace */
- const char *script; /* Input script for parsing */
- char *scriptServp; /* Next token in the script */
- int scriptSize; /* Length of script */
- char tokbuf[EJS_MAX_TOKEN]; /* Current token */
- int tid; /* Token ID */
- char *tokEndp; /* Pointer past end of token */
- char *tokServp; /* Pointer to next token char */
- struct EjsInput *nextInput; /* Free list of input structs */
-} EjsInput;
-
-/*
- * Method call structure
- */
-typedef struct EjsProc {
- MprArray *args; /* Args for method */
- EjsVar *fn; /* Method definition */
- char *procName; /* Method name */
-} EjsProc;
-
-
-/**
- * @overview EJScript Service structure
- * @description The EJScript service manages the overall language runtime. It
- * is the factory that creates interpreter instances via ejsCreateInterp.
- * The EJScript service creates a master interpreter that holds the
- * standard language classes and properties. When user interpreters are
- * created, they reference (without copying) the master interpreter to
- * gain access to the standard classes and types.
- * @stability Prototype.
- * @library libejs.
- * @see ejsOpenService, ejsCloseService, ejsCreateInterp, ejsDestoryInterp
- */
-typedef struct EjsService {
- EjsVar *globalClass; /* Global class */
- struct Ejs *master; /* Master Interp inherited by all */
-#if BLD_FEATURE_MULTITHREAD
- EjsLockFn lock;
- EjsUnlockFn unlock;
- void *lockData;
-#endif
-} EjsService;
-
-
-/*
- * Memory statistics
- */
-typedef struct EjsMemStats {
- uint maxMem;
- uint usedMem;
-} EjsMemStats;
-
-
-/*
- * Garbage collection block alignment
- */
-#define EJS_ALLOC_ALIGN(ptr) \
- (((ptr) + sizeof(void*) - 1) & ~(sizeof(void*) - 1))
-
-/*
- * Default GC tune factors
- */
-#define EJS_GC_START_THRESHOLD (32 * 1024)
-
-/*
- * The Garbage collector is a generational collector. It ages blocks and
- * optimizes the mark / sweep algorithm to focus on new and recent blocks
- */
-typedef enum EjsGeneration {
- EJS_GEN_NEW = 0,
- EJS_GEN_RECENT_1 = 1,
- EJS_GEN_RECENT_2 = 2,
- EJS_GEN_OLD = 3,
- EJS_GEN_PERMANENT = 4,
- EJS_GEN_MAX = 5,
-} EjsGeneration;
-
-/*
- * Garbage collector control
- */
-typedef struct EjsGC {
- bool enable;
- bool enableDemandCollect;
- bool enableIdleCollect;
- /*
- * maxMemory should be set to be 95% of the real max memory limit
- */
- uint maxMemory; /* Above this, Throw Memory exception. */
- int workQuota; /* Quota of work before GC */
- int workDone; /* Count of allocations */
- int degraded; /* Have exceeded maxMemory */
-
- /*
- * Debug Levels 0-N (increases verbosity)
- * 1 -- Sweep and collection count
- * 2 -- Trace objects deleted
- * 3 -- Trace objects marked
- * 4 -- Print alloc report when needing a demand allocation
- *
- */
- int debugLevel; /* In debug mode */
- int collecting; /* Running garbage collection */
- uint collectionCount; /* Number of times GC ran */
-#if BLD_DEBUG
- int gcIndent; /* Indent formatting */
- int objectsInUse; /* Objects currently reachable */
- int propertiesInUse; /* Properties currently reachable */
-#endif
-} EjsGC;
-
-/*
- * Slab memory allocation
- */
-typedef struct EjsSlab {
- uint allocIncrement; /* Growth increment in slab */
- uint size; /* Size of allocations */
- EjsGCLink freeList; /* Free list (only next ptr is used) */
- EjsObj *lastRecentBlock; /* Saved for GC age generations phase */
- EjsGCLink allocList[EJS_GEN_MAX]; /* Allocated block list */
-
-#if BLD_FEATURE_ALLOC_STATS
- uint totalAlloc; /* Total count of allocation calls */
- uint freeCount; /* Number of blocks on the slab freelist */
- uint allocCount; /* Number of allocated blocks */
- uint peakAllocated; /* Peak allocated */
- uint peakFree; /* Peak on the free list */
- uint totalReclaimed; /* Total blocks reclaimed on sweeps */
- uint totalSweeps; /* Total sweeps */
-#endif
-} EjsSlab;
-
-
-/**
- * @overview EJ interpreter control structure.
- * @description EJ allocates one control structure per active interpreter.
- * The \ref ejsCreateInterp routine creates the Ejs structure and returns
- * a reference to be used in subsequent EJ API calls.
- * @stability Prototype.
- * @library libejs.
- * @see ejsCreateInterp, ejsDestroyInterp, ejsOpenService
- */
-struct Ejs {
- void *altHandle; /* Alternate callback handle */
- bool castAlloc; /* True if castTemp is allocated */
- char *castTemp; /* Temporary string for casting */
- char *currentClass; /* Current class name */
- EjsVar *currentObj; /* Ptr to current object */
- EjsVar *thisObject; /* Ptr to current "this" */
- EjsProperty *currentProperty; /* Ptr to current property */
- EjsGC gc; /* Garbage collector control */
- char *errorMsg; /* Error message */
- char *fileName; /* File or script name */
- int lineNumber; /* File line number */
- int scriptStatus; /* Status to exit() */
- int flags; /* Flags */
- MprArray *frames; /* List of variable frames */
- EjsVar *global; /* Global object */
- EjsVar *objectClass; /* Object class */
- int gotException; /* Exception thrown */
- EjsInput *input; /* Input evaluation block */
- int depth; /* Recursion depth */
- EjsVar *local; /* Local object */
- int maxDepth; /* Maximum depth for formatting */
- void *primaryHandle; /* primary callback handle */
- EjsProc *proc; /* Current method */
- int recurseCount; /* Recursion counter */
- EjsVar *result; /* Variable result */
- int tid; /* Current token id */
- char *token; /* Pointer to token string */
- EjsVar tokenNumber; /* Parsed number */
- EjsService *service; /* Service object */
- void *userData; /* Method user data */
-
- EjsSlab *slabs; /* Memory allocation slabs */
- MprCtx slabAllocContext; /* Allocation context */
- EjsInput *inputList; /* Free list of input structs */
-
-#if BLD_FEATURE_MULTITHREAD
- EjsLockFn lock; /* Lock method */
- EjsUnlockFn unlock; /* Unlock method */
- void *lockData; /* Lock data argument */
-#endif
-#define EJS_MAX_STACK (10 * 1024)
- char stack[EJS_MAX_STACK]; /* Local variable stack */
- char *stkPtr; /* Local variable stack ptr */
- void *inputMarker; /* Recurse protection */
-};
-
-
-typedef struct EjsModule
-{
- int dummy;
-} EjsModule;
-
-
-/*
- * Method callback when using Alternate handles. GaCompat uses these and
- * passes the web server request structure via the altHandle.
- */
-typedef void *EjsHandle;
-typedef int (*EjsAltCMethod)(Ejs *ejs, EjsHandle altHandle,
- EjsVar *thisObj, int argc, EjsVar **argv);
-typedef int (*EjsAltStringCMethod)(Ejs *ejs, EjsHandle altHandle,
- EjsVar *thisObj, int argc, char **argv);
-
-
-/*
- * API Constants
- */
-#define EJS_USE_OWN_SLAB 1
-
-/******************************** Internal API ********************************/
-/*
- * Ejs Lex
- */
-extern int ejsLexOpenScript(Ejs *ejs, const char *script);
-extern void ejsLexCloseScript(Ejs *ejs);
-extern int ejsInitInputState(EjsInput *ip);
-extern void ejsLexSaveInputState(Ejs *ejs, EjsInput* state);
-extern void ejsLexFreeInputState(Ejs *ejs, EjsInput* state);
-extern void ejsLexRestoreInputState(Ejs *ejs, EjsInput* state);
-extern int ejsLexGetToken(Ejs *ejs, int state);
-extern void ejsLexPutbackToken(Ejs *ejs, int tid, char *string);
-
-/*
- * Parsing
- */
-extern int ejsParse(Ejs *ejs, int state, int flags);
-extern int ejsGetFlags(Ejs *ejs);
-
-/*
- * Create variable scope blocks
- */
-extern int ejsOpenBlock(Ejs *ejs);
-extern int ejsSetBlock(Ejs *ejs, EjsVar *local);
-extern int ejsCloseBlock(Ejs *ejs, int vid);
-extern int ejsEvalBlock(Ejs *ejs, char *script, EjsVar *vp);
-extern void ejsSetFileName(Ejs *ejs, const char *fileName);
-
-/*
- * Class definitions
- */
-extern EjsVar *ejsCreateSimpleClass(Ejs *ejs, EjsVar *baseClass,
- const char *className);
-extern int ejsDefineObjectClass(Ejs *ejs);
-extern int ejsDefineArrayClass(Ejs *ejs);
-extern int ejsDefineBooleanClass(Ejs *ejs);
-extern int ejsDefineErrorClasses(Ejs *ejs);
-extern int ejsDefineFileClass(Ejs *ejs);
-extern int ejsDefineFileSystemClass(Ejs *ejs);
-extern int ejsDefineHTTPClass(Ejs *ejs);
-extern int ejsDefineFunctionClass(Ejs *ejs);
-extern int ejsDefineNumberClass(Ejs *ejs);
-extern int ejsDefineStringClass(Ejs *ejs);
-extern int ejsDefineDateClass(Ejs *ejs);
-extern int ejsDefineStandardClasses(Ejs *ejs);
-
-#if BLD_FEATURE_EJS_E4X
-extern int ejsDefineXmlClasses(Ejs *ejs);
-extern EjsVar *ejsCreateXml(Ejs *ejs);
-#endif
-
-#if BLD_FEATURE_EJS_DB
-extern int ejsDefineDbClasses(Ejs *ejs);
-#endif
-
-/*
- * System class definitions
- */
-extern int ejsDefineSystemClasses(Ejs *ejs);
-extern int ejsDefineSystemClass(Ejs *ejs);
-extern int ejsDefineAppClass(Ejs *ejs);
-extern int ejsDefineDebugClass(Ejs *ejs);
-extern int ejsDefineLogClass(Ejs *ejs);
-extern int ejsDefineMemoryClass(Ejs *ejs);
-extern int ejsDefineGCClass(Ejs *ejs);
-extern int ejsDefineGlobalProperties(Ejs *ejs);
-
-extern int ejsTermSystemClasses(Ejs *ejs);
-extern void ejsTermHTTPClass(Ejs *ejs);
-
-extern int ejsCreateObjectModel(Ejs *ejs);
-
-/*
- * Class constructors
- */
-extern int ejsArrayConstructor(Ejs *ejs, EjsVar *thisObj, int argc,
- EjsVar **argv);
-extern int ejsXmlConstructor(Ejs *ejs, EjsVar *thisObj, int argc,
- EjsVar **argv);
-extern int ejsXmlListConstructor(Ejs *ejs, EjsVar *thisObj, int argc,
- EjsVar **argv);
-extern int ejsBooleanConstructor(Ejs *ejs, EjsVar *thisObj, int argc,
- EjsVar **agv);
-extern int ejsFunctionConstructor(Ejs *ejs, EjsVar *thisObj, int argc,
- EjsVar **agv);
-extern int ejsNumberConstructor(Ejs *ejs, EjsVar *thisObj, int argc,
- EjsVar **argv);
-extern int ejsStringConstructor(Ejs *ejs, EjsVar *thisObj, int argc,
- EjsVar **argv);
-extern int ejsDateConstructor(Ejs *ejs, EjsVar *thisObj,
- int argc, EjsVar **argv);
-
-/*
- * Garbage collection
- */
-extern void ejsGCInit(Ejs *ejs, int objInc, int propInc, int varInc,
- int strInc);
-extern int ejsIsTimeForGC(Ejs *ep, int timeTillNextEvent);
-
-extern bool ejsSetGCDebugLevel(Ejs *ep, int debugLevel);
-extern void ejsSweepAll(Ejs *ep);
-
-extern EjsObj *ejsAllocObj(EJS_LOC_DEC(ejs, loc));
-extern EjsProperty *ejsAllocProperty(EJS_LOC_DEC(ejs, loc));
-extern EjsVar *ejsAllocVar(EJS_LOC_DEC(ejs, loc));
-extern void ejsFree(Ejs *ejs, void *ptr, int slabIndex);
-
-extern int ejsCollectGarbage(Ejs *ejs, int slabIndex);
-extern int ejsIncrementalCollectGarbage(Ejs *ejs);
-
-#if BLD_DEBUG
-extern void ejsDumpObjects(Ejs *ejs);
-#endif
-
-#if BLD_FEATURE_ALLOC_STATS
-extern void ejsPrintAllocReport(Ejs *ejs, bool printLeakReport);
-#endif
-
-extern void ejsCleanInterp(Ejs *ejs, bool doStats);
-extern void ejsSetInternalMethods(Ejs *ejs, EjsVar *op);
-extern void ejsSetPrimaryHandle(Ejs *ep, void *primaryHandle);
-extern void ejsSetAlternateHandle(Ejs *ep, void *alternateHandle);
-extern void *ejsGetUserData(Ejs *ejs);
-
-/*
- * Could possibly make these routines public
- */
-
-extern int ejsSetGCMaxMemory(Ejs *ep, uint maxMemory);
-extern uint ejsGetUsedMemory(Ejs *ejs);
-extern uint ejsGetAllocatedMemory(Ejs *ejs);
-extern uint ejsGetAvailableMemory(Ejs *ejs);
-extern char *ejsFormatStack(Ejs* ep);;
-
-/********************************* Prototypes *********************************/
-#if BLD_FEATURE_MULTITHREAD
-extern int ejsSetServiceLocks(EjsService *sp, EjsLockFn lock,
- EjsUnlockFn unlock, void *data);
-#endif
-
-/*
- * Ejs service and interpreter management
- */
-extern EjsService *ejsOpenService(MprCtx ctx);
-extern void ejsCloseService(EjsService *sp, bool doStats);
-
-extern Ejs *ejsCreateInterp(EjsService *sp, void *primaryHandle,
- void *altHandle, EjsVar *global, bool useOwnSlab);
-extern void ejsDestroyInterp(Ejs *ejs, bool doStats);
-
-extern Ejs *ejsGetMasterInterp(EjsService *sp);
-extern EjsVar *ejsGetGlobalClass(Ejs *ejs);
-
-/*
- * Module support
- */
-extern EjsModule *ejsCreateModule(const char *name, const char *version,
- int (*start)(EjsModule*), int (*stop)(EjsModule*));
-
-/*
- * Native Objects
- */
-
-void ejsSetNativeData(EjsVar *obj, void *data);
-void ejsSetNativeHelpers(Ejs *ejs, EjsVar *nativeClass,
- int (*createInstance)(Ejs *ejs, EjsVar *thisObj, int argc,
- EjsVar **argv),
- void (*disposeInstance)(Ejs *ejs, EjsVar *thisObj),
- bool (*hasProperty)(Ejs *ejs, EjsVar *thisObj, const char *prop),
- int (*deleteProperty)(Ejs *ejs, EjsVar *thisObj, const char *prop),
- int (*getProperty)(Ejs *ejs, EjsVar *thisObj, const char *prop,
- EjsVar *dest),
- int (*setProperty)(Ejs *ejs, EjsVar *thisObj, const char *prop,
- EjsVar *value),
- int (*doOperator)(Ejs *ejs, EjsVar *thisObj, EjsOp *op, EjsVar
- *result, EjsVar *lhs, EjsVar *rhs, int *code)
- );
-
-/*
- * Evaluation methods
- */
-extern int ejsEvalFile(Ejs *ejs, const char *path, EjsVar *result);
-extern int ejsEvalScript(Ejs *ejs, const char *script, EjsVar *result);
-extern int ejsRunMethod(Ejs *ejs, EjsVar *obj,
- const char *methodName, MprArray *args);
-extern int ejsRunMethodCmd(Ejs *ejs, EjsVar *obj,
- const char *methodName, const char *cmdFmt, ...);
-extern EjsVar *ejsGetReturnValue(Ejs *ejs);
-
-extern EjsVar *ejsGetLocalObj(Ejs *ejs);
-extern EjsVar *ejsGetGlobalObj(Ejs *ejs);
-
-/*
- * Define a class in the specified interpreter. If used with the default
- * interpeter, then the class is defined for all interpreters.
- */
-extern EjsVar *ejsDefineClass(Ejs *ejs, const char *className,
- const char *extends, EjsCMethod constructor);
-extern EjsVar *ejsGetClass(Ejs *ejs, EjsVar *parentClass,
- const char *className);
-
-extern const char *ejsGetClassName(EjsVar *obj);
-extern const char *ejsGetBaseClassName(EjsVar *obj);
-
-extern bool ejsIsSubClass(EjsVar *target, EjsVar *baseClass);
-extern EjsVar *ejsGetBaseClass(EjsVar *obj);
-extern void ejsSetBaseClass(EjsVar *obj, EjsVar *baseClass);
-
-
-#define ejsCreateSimpleObj(ejs, className) \
- ejsCreateSimpleObjInternal(EJS_LOC_ARGS(ejs), className)
-extern EjsVar *ejsCreateSimpleObjInternal(EJS_LOC_DEC(ejs, loc),
- const char *className);
-
-#define ejsCreateSimpleObjUsingClass(ejs, baseClass) \
- ejsCreateSimpleObjUsingClassInt(EJS_LOC_ARGS(ejs), \
- baseClass)
-extern EjsVar *ejsCreateSimpleObjUsingClassInt(EJS_LOC_DEC(ejs, loc),
- EjsVar *baseClass);
-
-/*
- * This will create an object and call all required constructors
- */
-extern EjsVar *ejsCreateObj(Ejs *ejs, EjsVar *obj,
- const char *className, const char *constructorArgs);
-
-#define ejsCreateObjUsingArgv(ejs, obj, className, args) \
- ejsCreateObjUsingArgvInternal(EJS_LOC_ARGS(ejs), obj, \
- className, args)
-extern EjsVar *ejsCreateObjUsingArgvInternal(EJS_LOC_DEC(ejs, loc),
- EjsVar *obj, const char *className, MprArray *args);
-
-#define ejsCreateArray(ejs, size) \
- ejsCreateArrayInternal(EJS_LOC_ARGS(ejs), size)
-extern EjsVar *ejsCreateArrayInternal(EJS_LOC_DEC(ejs, loc),
- int size);
-
-/*
- * Array methods. MOB -- need other array methods
- */
-/* MOB -- spell out element */
-extern EjsVar *ejsAddArrayElt(Ejs *ejs, EjsVar *op, EjsVar *element,
- EjsCopyDepth copyDepth);
-/*
- * Required: Array methods
- *
- array = obj.getMethods();
- array = obj.getProperties();
-
- array.property.isPublic();
- array.property.isPrivate();
- array.property.isMethod();
- array.property.isEnumerable();
- array.property.isReadOnly();
- array.property.allowsNonUnique();
- array.property.getParent();
-*/
-
-/* MOB -- should we have an API that takes a EjsCopyDepth */
-extern void ejsSetReturnValue(Ejs *ejs, EjsVar *vp);
-extern void ejsSetReturnValueAndFree(Ejs *ejs, EjsVar *vp);
-extern void ejsSetReturnValueToBoolean(Ejs *ejs, bool value);
-extern void ejsSetReturnValueToBinaryString(Ejs *ejs,
- const uchar *value, int len);
-extern void ejsSetReturnValueToInteger(Ejs *ejs, int value);
-extern void ejsSetReturnValueToNumber(Ejs *ejs, EjsNum value);
-extern void ejsSetReturnValueToString(Ejs *ejs, const char *value);
-extern void ejsSetReturnValueToUndefined(Ejs *ejs);
-
-/*
- * Variable access and control. The fullName arg can contain "[]" and "."
- */
-extern bool ejsGetBool(Ejs *ejs, const char *fullName, bool defaultValue);
-extern int ejsGetInt(Ejs *ejs, const char *fullName, int defaultValue);
-extern const char *ejsGetStr(Ejs *ejs, const char *fullName,
- const char *defaultValue);
-extern EjsVar *ejsGetVar(Ejs *ejs, const char *fullName);
-
-extern int ejsSetBool(Ejs *ejs, const char *fullName, bool value);
-extern int ejsSetInt(Ejs *ejs, const char *fullName, int value);
-extern int ejsSetStr(Ejs *ejs, const char *fullName, const char *value);
-extern int ejsSetVar(Ejs *ejs, const char *fullName, const EjsVar *value);
-extern int ejsSetVarAndFree(Ejs *ejs, const char *fullName, EjsVar *value);
-
-extern int ejsDeleteVar(Ejs *ejs, const char *fullName);
-
-/*
- * Error handling
- */
-extern void ejsError(Ejs *ejs, const char *errorType, const char *fmt,
- ...) PRINTF_ATTRIBUTE(3,4);
-/* MOB -- this should take no arguments */
-extern void ejsArgError(Ejs *ejs, const char *msg);
-extern void ejsInternalError(Ejs *ejs, const char *msg);
-extern void ejsMemoryError(Ejs *ejs);
-extern void ejsSyntaxError(Ejs *ejs, const char *msg);
-
-/*
- * Utility methods
- */
-extern int ejsParseArgs(int argc, char **argv, const char *fmt, ...);
-
-extern void ejsExit(Ejs *ejs, int status);
-extern bool ejsIsExiting(Ejs *ejs);
-extern void ejsClearExiting(Ejs *ejs);
-
-extern bool ejsGotException(Ejs *ejs);
-
-/* MOB -- rename Method to Function */
-extern void ejsFreeMethodArgs(Ejs *ep, MprArray *args);
-extern int ejsStrcat(Ejs *ep, EjsVar *dest, EjsVar *src);
-
-/*
- * Debugging routines
- */
-extern char *ejsGetErrorMsg(Ejs *ejs);
-extern int ejsGetLineNumber(Ejs *ejs);
-extern void ejsTrace(Ejs *ejs, const char *fmt, ...);
-
-/*
- * Multithreaded lock routines
- */
-#if BLD_FEATURE_MULTITHREAD
-#define ejsLock(sp) if (sp->lock) { (sp->lock)(sp->lockData); } else
-#define ejsUnlock(sp) if (sp->unlock) { (sp->unlock)(sp->lockData); } else
-#else
-#define ejsLock(sp)
-#define ejsUnlock(sp)
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* _h_EJS */
-
-/*****************************************************************************/
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- * @file ejsClass.c
- * @brief EJS class support
- */
-/********************************* Copyright **********************************/
-/*
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- * Copyright (c) Michael O'Brien, 1994-1995. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-/********************************* Includes ***********************************/
-
-#include "ejs.h"
-
-#if BLD_FEATURE_EJS
-
-/************************************ Code ************************************/
-/*
- * Internal API
- *
- * Routine to create a simple class object. This routine will create a
- * stand-alone class object. Callers must insert this into the relevant
- * "global" object for name resolution. From these class objects, instance
- * objects may be created via the javascript "new" command.
- *
- * Users should use ejsDefineClass
- */
-
-EjsVar *ejsCreateSimpleClass(Ejs *ep, EjsVar *baseClass, const char *className)
-{
- EjsProperty *pp;
- EjsVar *classObj;
-
- /*
- * Create an instance of an Object to act as the static class object
- */
- classObj = ejsCreateSimpleObjUsingClass(ep, baseClass);
- if (classObj == 0) {
- mprAssert(classObj);
- return 0;
- }
- ejsSetClassName(ep, classObj, className);
-
- /*
- * Set the propotype property to point to this class.
- * Note: this is a self reference so the alive bit will not be turned on.
- */
- pp = ejsSetProperty(ep, classObj, "prototype", classObj);
- ejsMakePropertyEnumerable(pp, 0);
-
- return classObj;
-}
-
-/******************************************************************************/
-/*
- * Define a class in the given interpreter. If parentClass is specified, the
- * class is defined in the parent. Otherwise, the class will be defined
- * locally/globally. ClassName and extends are full variable specs
- * (may contain ".")
- */
-
-EjsVar *ejsDefineClass(Ejs *ep, const char *className, const char *extends,
- EjsCMethod constructor)
-{
- EjsVar *parentClass, *classObj, *baseClass, *vp;
- char *name;
- char *cp;
-
- /*
- * If the className is a qualified name (with "."), then get the
- * parent class name.
- */
- name = mprStrdup(ep, className);
- cp = strrchr(name, '.');
- if (cp != 0) {
- *cp++ = '\0';
- className = cp;
- parentClass = ejsFindProperty(ep, 0, 0, ep->global, ep->local, name, 0);
- if (parentClass == 0 || parentClass->type != EJS_TYPE_OBJECT) {
- mprError(ep, MPR_LOC, "Can't find class's parent class %s", name);
- mprFree(name);
- return 0;
- }
-
- } else {
- /*
- * Simple class name without a "." so create the class locally
- * if a local scope exists, otherwise globally.
- */
- parentClass = (ep->local) ? ep->local : ep->global;
- }
-
- if (parentClass == 0) {
- mprError(ep, MPR_LOC, "Can't find parent class");
- mprFree(name);
- return 0;
- }
-
- /* OPT should use function that doesn't parse [] . */
- baseClass = ejsGetClass(ep, 0, extends);
- if (baseClass == 0) {
- mprAssert(baseClass);
- mprFree(name);
- return 0;
- }
-
- classObj = ejsCreateSimpleClass(ep, baseClass, className);
- if (classObj == 0) {
- mprAssert(classObj);
- mprFree(name);
- return 0;
- }
-
- if (constructor) {
- ejsDefineCMethod(ep, classObj, className, constructor, 0);
- }
-
- ejsSetPropertyAndFree(ep, parentClass, className, classObj);
-
- vp = ejsGetPropertyAsVar(ep, parentClass, className);
- mprFree(name);
-
- return vp;
-}
-
-/******************************************************************************/
-/*
- * Find a class and return the property defining the class. ClassName may
- * contain "." and is interpreted relative to obj. Obj is typically some
- * parent object, ep->local or ep->global. If obj is null, then the global
- * space is used.
- */
-
-EjsVar *ejsGetClass(Ejs *ep, EjsVar *obj, const char *className)
-{
- EjsVar *vp;
-
- mprAssert(ep);
-
- /*
- * Search first for a constructor of the name of class
- * global may not be defined yet.
- */
- if (obj) {
- vp = ejsFindProperty(ep, 0, 0, obj, 0, className, 0);
-
- } else {
- mprAssert(ep->global);
- vp = ejsFindProperty(ep, 0, 0, ep->global, ep->local, className, 0);
- }
- if (vp == 0 || vp->type != EJS_TYPE_OBJECT) {
- return 0;
- }
-
- /*
- * Return a reference to the prototype (self) reference. This
- * ensures that even if "obj" is deleted, this reference will remain
- * usable.
- */
- return ejsGetPropertyAsVar(ep, vp, "prototype");
-}
-
-/******************************************************************************/
-/*
- * Return the class name of a class or object
- */
-
-const char *ejsGetClassName(EjsVar *vp)
-{
- EjsObj *obj;
-
- mprAssert(vp);
- mprAssert(vp->type == EJS_TYPE_OBJECT);
- mprAssert(vp->objectState->baseClass);
-
- if (vp == 0 || !ejsVarIsObject(vp)) {
- return 0;
- }
- obj = vp->objectState;
-
- return obj->className;
-}
-
-/******************************************************************************/
-/*
- * Return the class name of an objects underlying class
- * If called on an object, it returns the base class.
- * If called on a class, it returns the base class for the class.
- */
-
-const char *ejsGetBaseClassName(EjsVar *vp)
-{
- EjsObj *obj;
-
- mprAssert(vp);
- mprAssert(vp->type == EJS_TYPE_OBJECT);
- mprAssert(vp->objectState->baseClass);
-
- if (vp == 0 || !ejsVarIsObject(vp)) {
- return 0;
- }
- obj = vp->objectState;
- if (obj->baseClass == 0) {
- return 0;
- }
- mprAssert(obj->baseClass->objectState);
-
- return obj->baseClass->objectState->className;
-}
-
-/******************************************************************************/
-
-EjsVar *ejsGetBaseClass(EjsVar *vp)
-{
- if (vp == 0 || !ejsVarIsObject(vp) || vp->objectState == 0) {
- mprAssert(0);
- return 0;
- }
- return vp->objectState->baseClass;
-}
-
-/******************************************************************************/
-
-void ejsSetBaseClass(EjsVar *vp, EjsVar *baseClass)
-{
- if (vp == 0 || !ejsVarIsObject(vp) || vp->objectState == 0) {
- mprAssert(0);
- return;
- }
- vp->objectState->baseClass = baseClass;
-}
-
-/******************************************************************************/
-
-#else
-void ejsProcsDummy() {}
-
-/******************************************************************************/
-#endif /* BLD_FEATURE_EJS */
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- * @file ejsCmd.c
- * @brief Embedded JavaScript (EJS) command line program.
- * @overview
- */
-/********************************* Copyright **********************************/
-/*
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- * Copyright (c) Michael O'Brien, 1994-1995. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-/********************************** Includes **********************************/
-
-#include "ejs.h"
-
-#if BLD_FEATURE_EJS && !BREW
-
-/************************************ Defines *********************************/
-
-#define EJS_MAX_CMD_LINE (16 * 1024)
-#define EJS_MAX_SCRIPT (4 * 1024 * 1024)
-#define EJS_MAX_RESULT_SIZE (4 * 1024 * 1024)
-#define EJS_PROMPT "ejs> "
-
-/****************************** Forward Declarations **************************/
-
-static int parseFile(EjsService *ejsService, Ejs *ejs, const char *fileName,
- const char *testName, MprFile *testLogFile);
-static int ifConsole();
-
-static int interactiveUse(MprApp *app, Ejs *ejs, FILE *input,
- char *fileName);
-static char *readCmd(MprApp *app, FILE *input);
-
-static int memoryFailure(MprApp *app, uint size, uint total, bool granted);
-
-static int isConsole = 0;
-static int traceCmds = 0;
-static int stats = 0;
-static int verbose = 0;
-
-/************************************ Main ************************************/
-
-int main(int argc, char *argv[])
-{
- MprApp *app;
- const char *programName;
- MprFile *testLogFile;
- EjsService *ejsService;
- Ejs *ejs;
- char *commandLine;
- const char *testName;
- char *argp, *cmd, *testLog;
- int i, rc, nextArg, err, len, firstArg, iterations, debugLevel;
-
- app = mprInit(memoryFailure);
-
- isConsole = ifConsole();
- programName = mprGetBaseName(argv[0]);
- debugLevel = 0;
-
- ejsService = ejsOpenService(app);
- if (ejsService == 0) {
- mprError(app, MPR_LOC, "Can't initialize the EJS service.");
- return -1;
- }
-
- err = 0;
- iterations = 1;
- stats = 0;
- testLog = getenv("TEST_LOG");
- testLogFile = 0;
- testName = 0;
-
- for (nextArg = 1; nextArg < argc; nextArg++) {
- argp = argv[nextArg];
- if (*argp != '-') {
- break;
- }
- if (strcmp(argp, "--debug") == 0) {
- if (nextArg >= argc) {
- err++;
- } else {
- debugLevel = atoi(argv[++nextArg]);
- }
-
- } else if (strcmp(argp, "--stats") == 0) {
- stats++;
-
- } else if (strcmp(argp, "--trace") == 0) {
- traceCmds++;
-
- } else if (strcmp(argp, "--iterations") == 0) {
- if (nextArg >= argc) {
- err++;
- } else {
- iterations = atoi(argv[++nextArg]);
- }
-
- } else if (strcmp(argp, "--log") == 0) {
- /* Get file to log test results to when using ejs as a test shell */
- if (nextArg >= argc) {
- err++;
- } else {
- testLog = argv[++nextArg];
- }
-
- } else if (strcmp(argp, "--testName") == 0) {
- if (nextArg >= argc) {
- err++;
- } else {
- testName = argv[++nextArg];
- }
-
- } else if (strcmp(argp, "-v") == 0) {
- verbose++;
-
- } else if (strcmp(argp, "-vv") == 0) {
- verbose += 2;
-
- } else if (strcmp(argp, "--verbose") == 0) {
- verbose += 2;
-
- } else {
- err++;
- break;
- }
- if (err) {
- mprErrorPrintf(app,
- "Usage: %s [options] files... or\n"
- " %s < file or\n"
- " %s or\n"
- " Switches:\n"
- " --iterations num # Number of iterations to eval file\n"
- " --stats # Output stats on exit\n"
- " --testName name # Set the test name",
- programName, programName, programName);
- return -1;
- }
- }
-
- if (testName) {
- i = 0;
- commandLine = 0;
- len = mprAllocStrcat(MPR_LOC_ARGS(app), &commandLine, 0, " ",
- mprGetBaseName(argv[i++]), NULL);
- for (; i < argc; i++) {
- len = mprReallocStrcat(MPR_LOC_ARGS(app), &commandLine, 0, len,
- " ", argv[i], NULL);
- }
- mprPrintf(app, " %s\n", commandLine);
- }
- if (testLog) {
- testLogFile = mprOpen(app, testLog,
- O_CREAT | O_APPEND | O_WRONLY | O_TEXT, 0664);
- if (testLogFile == 0) {
- mprError(app, MPR_LOC, "Can't open %s", testLog);
- return MPR_ERR_CANT_OPEN;
- }
- mprFprintf(testLogFile, "\n %s\n", commandLine);
- }
-
- ejs = ejsCreateInterp(ejsService, 0, 0, 0, 0);
- if (ejs == 0) {
- mprError(app, MPR_LOC, "Can't create EJS interpreter");
- ejsCloseService(ejsService, stats);
- if (testLogFile) {
- mprClose(testLogFile);
- }
- mprTerm(app, stats);
- exit(-1);
- }
-
- if (debugLevel > 0) {
- ejsSetGCDebugLevel(ejs, debugLevel);
- }
-
- rc = 0;
-
- if (nextArg < argc) {
- /*
- * Process files supplied on the command line
- */
- firstArg = nextArg;
- for (i = 0; i < iterations; i++) {
- for (nextArg = firstArg; nextArg < argc; nextArg++) {
- rc = parseFile(ejsService, ejs, argv[nextArg], testName,
- testLogFile);
- if (rc < 0) {
- return rc;
- }
- }
- }
- if (testName) {
- if (verbose == 1) {
- mprPrintf(app, "\n");
- }
- if (verbose <= 1) {
- mprPrintf(app, " # PASSED all tests for \"%s\"\n", testName);
- }
- }
-
- } else if (! isConsole) {
- /*
- * Read a script from stdin
- */
- cmd = readCmd(app, stdin);
-
- ejsSetFileName(ejs, "stdin");
-
- rc = ejsEvalScript(ejs, cmd, 0);
- if (rc < 0) {
- mprPrintf(app, "ejs: Error: %s\n", ejsGetErrorMsg(ejs));
- }
- mprFree(cmd);
-
- } else {
- /*
- * Interactive use. Read commands from the command line.
- */
- rc = interactiveUse(app, ejs, stdin, "stdin");
- }
-
- /*
- * Cleanup. Do stats if required.
- */
- if (ejs) {
- ejsCleanInterp(ejs, 0);
- ejsCleanInterp(ejs->service->master, 0);
- ejsDestroyInterp(ejs, 0);
- }
-
- ejsCloseService(ejsService, stats);
-
- if (testLogFile) {
- mprClose(testLogFile);
- }
-
- mprTerm(app, stats);
- return rc;
-}
-
-/******************************************************************************/
-
-static int parseFile(EjsService *ejsService, Ejs *ejs, const char *fileName,
- const char *testName, MprFile *testLogFile)
-{
- int rc;
-
- if (testName && verbose == 1) {
- mprPrintf(ejs, ".");
- }
- if (verbose > 1) {
- mprPrintf(ejs, "File: %s\n", fileName);
- }
-
- rc = ejsEvalFile(ejs, fileName, 0);
-
- if (testName) {
- char fileBuf[MPR_MAX_FNAME], *cp;
- mprStrcpy(fileBuf, sizeof(fileBuf), fileName);
- if ((cp = strstr(fileBuf, ".ejs")) != 0) {
- *cp = '\0';
- }
- if (rc == 0) {
- if (verbose > 1) {
- mprPrintf(ejs, " # PASSED test \"%s.%s\"\n", testName,
- fileBuf);
- }
- if (testLogFile) {
- mprFprintf(testLogFile, " # PASSED test \"%s.%s\"\n",
- testName, fileBuf);
- }
-
- } else {
-
- mprPrintf(ejs, "FAILED test \"%s.%s\"\nDetails: %s\n",
- testName, fileBuf, ejsGetErrorMsg(ejs));
-
- if (testLogFile) {
- mprFprintf(testLogFile,
- "FAILED test \"%s.%s\"\nDetails: %s\n",
- testName, fileBuf, ejsGetErrorMsg(ejs));
- }
- }
- } else if (rc < 0) {
- mprPrintf(ejs, "ejs: %sIn file \"%s\"\n",
- ejsGetErrorMsg(ejs), fileName);
- }
- return rc;
-}
-
-/******************************************************************************/
-
-static char *readCmd(MprApp *app, FILE *input)
-{
- char line[EJS_MAX_CMD_LINE];
- char *cmd;
- int len, cmdLen;
-
- cmd = 0;
- cmdLen = 0;
-
- line[sizeof(line) - 1] = '\0';
-
- while (1) {
-
- if (fgets(line, sizeof(line) - 1, input) == NULL) {
- break;
- }
-
- len = strlen(line);
-
- if (line[len - 1] == '\\') {
- line[len - 1] = '\0';
- }
- cmdLen = mprReallocStrcat(MPR_LOC_ARGS(app), &cmd, EJS_MAX_SCRIPT,
- cmdLen, 0, line, NULL);
- }
- return cmd;
-}
-
-/******************************************************************************/
-
-static int interactiveUse(MprApp *app, Ejs *ejs, FILE *input, char *fileName)
-{
- EjsVar result;
- char line[EJS_MAX_CMD_LINE];
- char *cmd, *buf;
- int len, cmdLen, rc;
-
- cmd = 0;
- cmdLen = 0;
-
- line[sizeof(line) - 1] = '\0';
-
- ejsSetFileName(ejs, "console");
-
- while (! ejsIsExiting(ejs)) {
-
- if (isConsole) {
- write(1, EJS_PROMPT, strlen(EJS_PROMPT));
- }
-
- if (fgets(line, sizeof(line) - 1, input) == NULL) {
- break;
- }
-
- len = strlen(line);
- while (len > 0 &&
- (line[len - 1] == '\n' || line[len - 1] == '\r')) {
- len--;
- line[len] = '\0';
- }
-
- if (line[len - 1] == '\\') {
- line[len - 1] = '\0';
- cmdLen = mprReallocStrcat(MPR_LOC_ARGS(app), &cmd, EJS_MAX_SCRIPT,
- cmdLen, 0, line, NULL);
-
- } else {
-
- cmdLen = mprReallocStrcat(MPR_LOC_ARGS(app), &cmd, EJS_MAX_SCRIPT,
- cmdLen, 0, line, NULL);
-
-
- if (traceCmds) {
- mprPrintf(ejs, "# %s\n", cmd);
- }
-
- if (cmd[0] == 0x4 || cmd[0] == 0x26 || strcmp(cmd, "quit") == 0) {
- ejsExit(ejs, 0);
-
- } else if ((rc = ejsEvalScript(ejs, cmd, &result)) < 0) {
-
- mprPrintf(app, "ejs: Error: %s\n", ejsGetErrorMsg(ejs));
-
- if (! isConsole) {
- return rc;
- }
-
- } else {
- if (isConsole || traceCmds) {
- buf = ejsVarToString(ejs, &result);
- mprPrintf(ejs, "%s\n", buf);
- }
- }
- mprFree(cmd);
- cmd = 0;
- cmdLen = 0;
- }
- }
- return 0;
-}
-
-/******************************************************************************/
-
-static int ifConsole()
-{
-#if WIN
- INPUT_RECORD irec[1];
- int records = 0;
-
- if (PeekConsoleInput(GetStdHandle(STD_INPUT_HANDLE), irec, 1,
- &records) != 0) {
- return 1;
- }
-#else
- return isatty(0);
-#endif
- return 0;
-}
-
-/******************************************************************************/
-
-static int memoryFailure(MprApp *app, uint size, uint total, bool granted)
-{
- if (!granted) {
- mprPrintf(app, "Can't allocate memory block of size %d\n", size);
- mprPrintf(app, "Total memory used %d\n", total);
- exit(255);
- }
- mprPrintf(app, "Memory request for %d bytes exceeds memory red-line\n",
- size);
- mprPrintf(app, "Total memory used %d\n", total);
- return 0;
-}
-
-/******************************************************************************/
-
-#else
-void ejsCmdLineDummy() {}
-
-/******************************************************************************/
-#endif /* BLD_FEATURE_EJS */
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- * @file ejsGarbage.c
- * @brief EJS Garbage collector.
- * @overview This implements a generational mark and sweep collection scheme.
- */
-/********************************* Copyright **********************************/
-/*
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-/********************************** Includes **********************************/
-
-#include "ejs.h"
-
-#if BLD_FEATURE_EJS
-
-/****************************** Forward Declarations **************************/
-
-static void mark(Ejs *ep);
-static void markObjByVar(Ejs *ep, EjsVar *op);
-static void markObj(EjsObj *obj);
-static void markPerm(Ejs *ep, uint gen);
-static int sweep(Ejs *ep, uint gen);
-static EjsGCLink *ejsAlloc(EJS_LOC_DEC(ep, loc), int slabIndex);
-static void ejsGracefulDegrade(Ejs *ep);
-static void resetMarks(Ejs *ep, EjsSlab *slab);
-
-#if FUTURE
-static void ageGenerations(Ejs *ep);
-#endif
-
-#if BLD_DEBUG && (!BREW || BREW_SIMULATOR)
-uint breakAddr;
-#endif
-
-/************************************* Code ***********************************/
-
-void ejsGCInit(Ejs *ep, int objInc, int propInc, int varInc, int strInc)
-{
- EjsSlab *slab;
-
- if (ep->service && ep->service->globalClass) {
- ep->service->globalClass->objectState->gcMarked = 1;
- }
-
- slab = &ep->slabs[EJS_SLAB_OBJ];
- slab->allocIncrement = objInc;
- slab->size = EJS_ALLOC_ALIGN(sizeof(EjsObj));
-
- slab = &ep->slabs[EJS_SLAB_PROPERTY];
- slab->allocIncrement = propInc;
- slab->size = EJS_ALLOC_ALIGN(sizeof(EjsProperty));
-
- slab = &ep->slabs[EJS_SLAB_VAR];
- slab->allocIncrement = varInc;
- slab->size = EJS_ALLOC_ALIGN(sizeof(EjsVar));
-
- /*
- * Initialize GC.
- * Enable GC both idle and demand collections.
- * Set no limits and garbage collect if the slabs are
- * empty and we have used more than the THRESHOLD of ram.
- */
- ep->gc.debugLevel = 0;
- ep->gc.enable = 1;
- ep->gc.enableIdleCollect = 1;
- ep->gc.enableDemandCollect = 1;
- ep->gc.workQuota = EJS_GC_WORK_QUOTA;
- ep->gc.maxMemory = 0;
-}
-
-
-/******************************************************************************/
-#if BLD_FEATURE_ALLOC_STATS
-
-void ejsPrintAllocReport(Ejs *ep, bool printLeakReport)
-{
- EjsSlab *slab;
- char *name;
- int slabIndex, isObj;
-
- for (slabIndex = 0; slabIndex < EJS_SLAB_MAX; slabIndex++) {
- slab = &ep->slabs[slabIndex];
- if (slabIndex == EJS_SLAB_VAR) {
- name = "var";
- } else if (slabIndex == EJS_SLAB_PROPERTY) {
- name = "prop";
- } else {
- name = "obj";
- }
- mprLog(ep, 0, " ");
- mprLog(ep, 0, " GC \"%s\" local slab", name);
- mprLog(ep, 0, " Total blocks %14d",
- slab->allocCount + slab->freeCount);
- mprLog(ep, 0, " Block size %14d", slab->size);
- mprLog(ep, 0, " Slab RAM allocated %14d",
- (slab->allocCount + slab->freeCount) * slab->size);
- mprLog(ep, 0, " Slab RAM in use %14d",
- slab->allocCount * slab->size);
- mprLog(ep, 0, " Blocks in use %14d", slab->allocCount);
- mprLog(ep, 0, " Free blocks %14d", slab->freeCount);
- mprLog(ep, 0, " Peak allocated %14d", slab->peakAllocated);
- mprLog(ep, 0, " Peak free %14d", slab->peakFree);
- mprLog(ep, 0, " Total allocations %14d", slab->totalAlloc);
- mprLog(ep, 0, " Total blocks reclaimed %14d", slab->totalReclaimed);
- mprLog(ep, 0, " Total sweeps %14d", slab->totalSweeps);
- mprLog(ep, 0, " Allocation inc %14d", slab->allocIncrement);
- }
-
- mprLog(ep, 0, " ");
- mprLog(ep, 0, " Total EJS memory in use %10d", ejsGetUsedMemory(ep));
- mprLog(ep, 0, " Total EJS memory allocated %10d",
- ejsGetAllocatedMemory(ep));
-
- if (printLeakReport) {
- mprLog(ep, 0, " ");
- for (slabIndex = 0; slabIndex < EJS_SLAB_MAX; slabIndex++) {
- int size;
-
- slab = &ep->slabs[slabIndex];
-
- isObj = 0;
- mprLog(ep, 0, " ");
- if (slabIndex == EJS_SLAB_VAR) {
- name = "var";
- size = sizeof(EjsVar);
- } else if (slabIndex == EJS_SLAB_PROPERTY) {
- name = "prop";
- size = sizeof(EjsProperty);
- } else {
- name = "obj";
- size = sizeof(EjsObj);
- isObj++;
- }
-#if BLD_FEATURE_ALLOC_LEAK_TRACK
-{
- EjsGCLink *lp;
- EjsObj *obj;
- int count;
-
- mprLog(ep, 0, "EJS Leak Report for \"%s\"", name);
- count = 0;
-
- for (lp = slab->allocList[0].next; lp; lp = lp->next) {
- mprLog(ep, 0, " %-20s %10d", lp->allocatedBy, size);
- if (isObj) {
- obj = (EjsObj*) lp;
- mprLog(ep, 0, " %-20s %10d %s %s",
- lp->allocatedBy, size,
- obj->permanent ? "permanent" : "",
- obj->alive ? "alive" : ""
- );
- } else {
- mprLog(ep, 0, " %-20s %10d", lp->allocatedBy,
- size);
- }
- count++;
- }
- mprLog(ep, 0, " Total blocks %14d", count);
-}
-#endif
- }
- mprLog(ep, 0, " ");
- }
-}
-
-#endif
-/******************************************************************************/
-/*
- * Slab allocator
- */
-
-static EjsGCLink *ejsAlloc(EJS_LOC_DEC(ep, loc), int slabIndex)
-{
- EjsSlab *slab;
- EjsGCLink *block;
- EjsGC *gc;
- uint allocatedMemory;
- int i;
-
- mprStackCheck(ep);
-
- if (slabIndex < 0 || slabIndex >= EJS_SLAB_MAX) {
- mprAssert(0);
- return 0;
- }
-
- /*
- * See if the slab has some free blocks
- */
- slab = &ep->slabs[slabIndex];
- if ((block = slab->freeList.next) == 0) {
-
- allocatedMemory = ejsGetAllocatedMemory(ep);
- gc = &ep->gc;
-
- /*
- * No blocks available. If demand collection is enabled, try
- * to garbage collect first. We collect if we have done a good
- * work quota or we are over the max memory limit.
- */
- if (slabIndex != EJS_SLAB_VAR &&
- ep->gc.enable && ep->gc.enableDemandCollect) {
- if ((ep->gc.workDone > ep->gc.workQuota) ||
- (gc->maxMemory > 0 && allocatedMemory > gc->maxMemory)) {
-
-#if DEBUG_USE_ONLY
- if (ep->gc.debugLevel > 0) {
- mprLog(ep, 0, "Need GC, EJS RAM %d, MPR RAM %d\n",
- allocatedMemory, mprGetAllocatedMemory(ep));
- if (ep->gc.debugLevel > 4) {
- ejsPrintAllocReport(ep, 0);
- }
- }
-#endif
- if (ejsCollectGarbage(ep, slabIndex) == 0) {
- block = slab->freeList.next;
- }
- }
- }
-
- if (block == 0) {
- if (gc->maxMemory > 0 && allocatedMemory > gc->maxMemory) {
- /*
- * We are above the max memory limit. We will fail this
- * memory allocation, but allow subsequent allocations to
- * permit error recovery. We gracefully degrade by setting
- * slab chunk sizes to 1. This minimizes real memory
- * consumption. This allows us to create
- * an exception block to be created by upper layers.
- */
- if (! gc->degraded) {
- ejsGracefulDegrade(ep);
- return 0;
- }
- }
-
- /*
- * Still non available, so allocate more memory for a set of blocks
- * OPT -- should bypass mprAlloc. Need mprMalloc.
- */
- block = mprAlloc(ep->slabAllocContext,
- slab->size * slab->allocIncrement);
- if (block == 0) {
- /*
- * Now we're in trouble. We should really never get here
- * as the graceful degrade will have signaled a memory
- * allocation failure.
- */
- mprAssert(block != 0);
- return 0;
- }
-
- /*
- * Chain all the blocks together onto the slab free list
- */
- for (i = slab->allocIncrement - 1; i >= 0; i--) {
- block->next = slab->freeList.next;
-#if BLD_DEBUG
- block->magic = EJS_MAGIC_FREE;
-#endif
- slab->freeList.next = block;
- block = (EjsGCLink*) ((char*) block + slab->size);
- }
-
- block = slab->freeList.next;
-
-#if BLD_FEATURE_ALLOC_STATS
- slab->freeCount += slab->allocIncrement;
- if (slab->freeCount > slab->peakFree) {
- slab->peakFree = slab->freeCount;
- }
-#endif
- }
- }
-
- /*
- * We use block to point to the user data in the block. We only
- * store the magic number (if debug). No other data is stored in the
- * user block.
- */
-#if BLD_DEBUG
- mprAssert(block->magic == EJS_MAGIC_FREE);
-#endif
-
- /*
- * Remove from the free list
- */
- slab->freeList.next = block->next;
-
- /*
- * Zero block
- */
- memset(block, 0, slab->size);
-
-#if BLD_DEBUG
- block->magic = EJS_MAGIC;
-#endif
-
-#if BLD_FEATURE_ALLOC_STATS
- slab->totalAlloc++;
- if (++slab->allocCount > slab->peakAllocated) {
- slab->peakAllocated = slab->allocCount;
- }
- slab->freeCount--;
-#endif
-
-#if BLD_DEBUG && (!BREW || BREW_SIMULATOR)
- if ((uint) block == breakAddr) {
- mprBreakpoint(MPR_LOC, "Watched Block");
- }
-#endif
- return block;
-}
-
-
-/******************************************************************************/
-
-EjsObj *ejsAllocObj(EJS_LOC_DEC(ep, loc))
-{
- EjsObj *obj;
- EjsSlab *slab;
-
- obj = (EjsObj*) ejsAlloc(EJS_LOC_PASS(ep, loc), EJS_SLAB_OBJ);
-
- /*
- * Add to the allocated block list for the New generation.
- */
- if (obj) {
- slab = &ep->slabs[EJS_SLAB_OBJ];
- obj->gc.next = slab->allocList[EJS_GEN_NEW].next;
-
-#if BLD_FEATURE_ALLOC_LEAK_TRACK
- obj->gc.allocatedBy = loc;
-#endif
-
- obj->ejs = ep;
- slab->allocList[EJS_GEN_NEW].next = (EjsGCLink*) obj;
-
- ep->gc.workDone++;
- }
-
- return obj;
-}
-
-
-/******************************************************************************/
-
-EjsProperty *ejsAllocProperty(EJS_LOC_DEC(ep, loc))
-{
- EjsProperty *prop;
-
- prop = (EjsProperty*) ejsAlloc(EJS_LOC_PASS(ep, loc), EJS_SLAB_PROPERTY);
- mprAssert(prop);
-
- if (prop) {
- prop->var.type = EJS_TYPE_NULL;
- prop->var.isProperty = 1;
-#if BLD_FEATURE_ALLOC_LEAK_TRACK
- prop->var.gc.allocatedBy = loc;
-#endif
- }
- return prop;
-}
-
-
-/******************************************************************************/
-
-EjsVar *ejsAllocVar(EJS_LOC_DEC(ep, loc))
-{
- EjsVar *vp;
-
- vp = (EjsVar*) ejsAlloc(EJS_LOC_PASS(ep, loc), EJS_SLAB_VAR);
- mprAssert(vp);
-
- if (vp) {
-#if BLD_FEATURE_ALLOC_LEAK_TRACK
- EjsSlab *slab;
- vp->gc.allocatedBy = loc;
- slab = &ep->slabs[EJS_SLAB_VAR];
- vp->gc.next = slab->allocList[EJS_GEN_NEW].next;
- slab->allocList[EJS_GEN_NEW].next = (EjsGCLink*) vp;
-#endif
-#if BLD_DEBUG
- vp->propertyName = 0;
-#endif
- }
- return vp;
-}
-
-
-/******************************************************************************/
-/*
- * Return the block back to the relevant slab
- */
-
-void ejsFree(Ejs *ep, void *ptr, int slabIndex)
-{
- EjsSlab *slab;
- EjsGCLink *block;
-
- mprAssert(ep);
- mprAssert(ptr);
-
- if (slabIndex < 0 || slabIndex >= EJS_SLAB_MAX) {
- mprAssert(slabIndex >= 0 && slabIndex < EJS_SLAB_MAX);
- return;
- }
- slab = &ep->slabs[slabIndex];
-
-#if BLD_FEATURE_ALLOC_LEAK_TRACK
- if (slabIndex == EJS_SLAB_VAR) {
- EjsVar *vp, *np, *prev;
-
- /*
- * Remove the block rom the alloc list. WARNING: this is slow
- * and should not be used in production code.
- */
- vp = (EjsVar*) ptr;
- prev = 0;
- for (np = (EjsVar*) slab->allocList[0].next; np;
- np = (EjsVar*) np->gc.next) {
- if (vp == np) {
- if (prev) {
- prev->gc.next = (EjsGCLink*) np->gc.next;
- } else {
- slab->allocList[0].next = (EjsGCLink*) np->gc.next;
- }
- break;
- }
- prev = np;
- }
- if (np == 0) {
- mprAssert(0);
- }
- }
-#endif
-
- /*
- * Insert into the free list. Only use the next ptr
- */
- block = (EjsGCLink*) ptr;
-
-#if BLD_DEBUG
-#if !BREW || BREW_SIMULATOR
- if ((uint) block == breakAddr) {
- mprBreakpoint(MPR_LOC, "Watched Block");
- }
-#endif
- mprAssert(block->magic == EJS_MAGIC);
- block->magic = EJS_MAGIC_FREE;
-#endif
-
- block->next = slab->freeList.next;
- slab->freeList.next = block;
-
-#if BLD_FEATURE_ALLOC_STATS
- slab->allocCount--;
- if (++slab->freeCount >= slab->peakFree) {
- slab->peakFree = slab->freeCount;
- }
- slab->totalReclaimed++;
- if (slabIndex != 2) {
- slabIndex = slabIndex;
- }
-#endif
-}
-
-/******************************************************************************/
-/*
- * Mark an object as being in-use. Traverse all properties for referenced
- * objects and base classes.
- */
-
-static void markObjByVar(Ejs *ep, EjsVar *obj)
-{
- EjsProperty *pp;
- EjsVar *vp, *baseClass;
-
- mprAssert(ep);
- mprAssert(obj);
-
- obj->objectState->gcMarked = 1;
-
-#if BLD_DEBUG
- if (ep->gc.debugLevel >= 3) {
- int indent = min(ep->gc.gcIndent * 2, 32);
- mprLog(ep, 0, "%.*s %-24s %.*s 0x%08X",
- indent, " ",
- obj->propertyName,
- 32 - indent, "................................ ",
- (uint) obj->objectState);
- ep->gc.gcIndent++;
- }
- ep->gc.objectsInUse++;
-#endif
-
- /*
- * Traverse all referenced objects
- * OPT -- optimize by directly accessing the object links and not using
- * ejsGetFirst/NextProperty. Then just examine objects
- * OPT -- first property in global is global. Should optimize this.
- */
- pp = ejsGetFirstProperty(obj, EJS_ENUM_ALL);
- while (pp) {
- vp = ejsGetVarPtr(pp);
- if (vp->type == EJS_TYPE_OBJECT) {
- if (!vp->objectState->gcMarked) {
-#if FUTURE
- /*
- * OPT -- we can use the dirty bit on objects to avoid
- * visiting permanent objects that are clean. If so, don't
- * forget the else case below.
- */
- obj = vp->objectState;
- if ((!obj->alive && !obj->permanent) || obj->dirty)
-#endif
- markObjByVar(ep, vp);
- }
-
- } else {
-#if BLD_DEBUG
- if (ep->gc.debugLevel >= 3) {
- int indent = min(ep->gc.gcIndent * 2, 32);
- mprLog(ep, 0, "%.*s %-24s %.*s %s",
- indent, " ",
- vp->propertyName,
- 32 - indent, "................................ ",
- ejsGetVarTypeAsString(vp));
- }
- ep->gc.propertiesInUse++;
-#endif
- }
- pp = ejsGetNextProperty(pp, EJS_ENUM_ALL);
- }
-
- /*
- * Traverse the base class
- */
- baseClass = obj->objectState->baseClass;
- if (baseClass) {
- mprAssert(baseClass->type == EJS_TYPE_OBJECT);
- mprAssert(baseClass->objectState);
- if (baseClass->objectState) {
- if (! baseClass->objectState->gcMarked) {
- markObjByVar(ep, baseClass);
- }
- }
- }
-#if BLD_DEBUG
- if (ep->gc.debugLevel >= 3) {
- ep->gc.gcIndent--;
- }
-#endif
-}
-
-
-/******************************************************************************/
-/*
- * Mark phase. Examine all variable frames and the return result.
- */
-
-static void mark(Ejs *ep)
-{
- EjsVar *vp;
- int i;
-
-#if BLD_DEBUG
- if (ep->gc.debugLevel >= 3) {
- mprLog(ep, 0, " ");
- mprLog(ep, 0, "GC: Marked Blocks:");
- }
-#endif
-
- if (ep->frames) {
- for (i = 0; i < mprGetItemCount(ep->frames); i++) {
-
- vp = (EjsVar*) mprGetItem(ep->frames, i);
- mprAssert(vp->type == EJS_TYPE_OBJECT);
-
- if (! vp->objectState->gcMarked) {
- markObjByVar(ep, vp);
- }
- }
- }
-
- vp = ep->result;
- if (vp && vp->type == EJS_TYPE_OBJECT && ! vp->objectState->gcMarked) {
- markObjByVar(ep, vp);
- }
-
- vp = ep->currentObj;
- if (vp && vp->type == EJS_TYPE_OBJECT && ! vp->objectState->gcMarked) {
- markObjByVar(ep, vp);
- }
-
- vp = ejsGetVarPtr(ep->currentProperty);
- if (vp && vp->type == EJS_TYPE_OBJECT && ! vp->objectState->gcMarked) {
- markObjByVar(ep, vp);
- }
-
- /*
- * OPT -- we could mark master as "mark permanent" somehow and
- * then we would not need to walk the master objects.
- */
- if (ep->slabAllocContext == ep->service->master) {
- if (ep->service->master->global) {
- markObjByVar(ep, ep->service->master->global);
- }
- }
-
-#if BLD_DEBUG
- if (ep->gc.debugLevel >= 3) {
- mprLog(ep, 0, " ");
- }
-#endif
-}
-
-
-/******************************************************************************/
-#if UNUSED
-
-static void resetMark(EjsVar *obj)
-{
- EjsProperty *pp;
- EjsVar *vp, *baseClass;
-
- obj->objectState->gcMarked = 0;
- obj->objectState->visited = 1;
-
- pp = ejsGetFirstProperty(obj, EJS_ENUM_ALL);
- while (pp) {
- vp = ejsGetVarPtr(pp);
- if (vp->type == EJS_TYPE_OBJECT && !vp->objectState->visited) {
- resetMark(vp);
- }
- pp = ejsGetNextProperty(pp, EJS_ENUM_ALL);
- }
-
- baseClass = obj->objectState->baseClass;
- if (baseClass) {
- mprAssert(baseClass->type == EJS_TYPE_OBJECT);
- mprAssert(baseClass->objectState);
- if (baseClass->objectState) {
- if (! baseClass->objectState->visited) {
- resetMark(baseClass);
- }
- }
- }
- obj->objectState->visited = 0;
-}
-
-/******************************************************************************/
-/*
- * Mark phase. Examine all variable frames and the return result.
- */
-
-static void resetAllMarks(Ejs *ep)
-{
- EjsVar *vp;
- int i;
-
- for (i = 0; i < mprGetItemCount(ep->frames); i++) {
- vp = (EjsVar*) mprGetItem(ep->frames, i);
- resetMark(vp);
- }
-
- if (ep->result && ep->result->type == EJS_TYPE_OBJECT &&
- ! ep->result->objectState->gcMarked) {
- resetMark(ep->result);
- }
-}
-
-#endif
-/******************************************************************************/
-/*
- * Sweep up the garbage
- */
-
-static void resetMarks(Ejs *ep, EjsSlab *slab)
-{
- EjsVar *vp;
- EjsObj *obj;
- int gen, i;
-
- for (gen = EJS_GEN_NEW; gen < EJS_GEN_MAX; gen++) {
- obj = (EjsObj*) slab->allocList[gen].next;
- for (; obj; obj = (EjsObj*) obj->gc.next) {
- obj->gcMarked = 0;
- obj->visited = 0;
- }
- }
-
- if (ep->frames) {
- for (i = 0; i < mprGetItemCount(ep->frames); i++) {
-
- vp = (EjsVar*) mprGetItem(ep->frames, i);
- mprAssert(vp->type == EJS_TYPE_OBJECT);
-
- vp->objectState->gcMarked = 0;
- vp->objectState->visited = 0;
- }
- }
-
- if (ep->result && ep->result->type == EJS_TYPE_OBJECT) {
- ep->result->objectState->gcMarked = 0;
- }
-}
-
-/******************************************************************************/
-/*
- * Mark all permanent and non-alive objects
- */
-
-static void markPerm(Ejs *ep, uint gen)
-{
- EjsSlab *slab;
- EjsObj *obj;
-
- slab = &ep->slabs[EJS_SLAB_OBJ];
-
- for (obj = (EjsObj*) slab->allocList[gen].next; obj; ) {
-
- if (! obj->gcMarked) {
- if (!obj->alive || obj->permanent) {
- markObj(obj);
- }
- }
- obj = (EjsObj*) obj->gc.next;
-
- }
-}
-
-/******************************************************************************/
-
-static void markObj(EjsObj *obj)
-{
- EjsProperty *pp;
- EjsPropLink *lp, *head;
- EjsObj *op;
-
- mprAssert(obj);
-
- obj->gcMarked = 1;
-
- head = &obj->link;
- for (lp = head->next; lp != head; lp = lp->next) {
-
- pp = ejsGetPropertyFromLink(lp);
-
- if (pp->var.type == EJS_TYPE_OBJECT) {
- op = pp->var.objectState;
- if (op != 0 && !op->gcMarked) {
- markObj(op);
- }
- }
- }
-}
-
-/******************************************************************************/
-/*
- * Sweep up the garbage. Return the number of objects freed.
- */
-
-static int sweep(Ejs *ep, uint gen)
-{
- EjsSlab *slab;
- EjsObj *obj, *next, *prev;
- int count;
-
- slab = &ep->slabs[EJS_SLAB_OBJ];
-
- /*
- * Examine allocated objects in the specified generation (only).
- * NOTE: we only sweep object allocated to this interpreter and so
- * we do not sweep any permanent objects in the default interpreter.
- */
- prev = 0;
- count = 0;
- for (obj = (EjsObj*) slab->allocList[gen].next; obj; obj = next) {
-
- next = (EjsObj*) obj->gc.next;
-
-#if BLD_DEBUG && (!BREW || BREW_SIMULATOR)
- if ((uint) obj == breakAddr) {
- mprBreakpoint(MPR_LOC, "Watched Block");
- }
-#endif
-
- /*
- * If object has not been marked inuse and is not a permanent
- * object, then free it.
- */
- if (! obj->gcMarked && obj->alive && !obj->permanent) {
-
-#if BLD_DEBUG
- if (ep->gc.debugLevel >= 2) {
- if (obj->objName) {
- mprLog(ep, 0, "GC: destroy %-18s %10d, %8X",
- obj->objName, (uint) obj, (uint) obj);
- } else {
- mprLog(ep, 0, "GC: destroy UNKNOWN %x", (uint) obj);
- }
- }
-#endif
- if (ejsDestroyObj(ep, obj) < 0) {
- prev = obj;
- obj->gcMarked = 0;
- continue;
- }
-
- if (prev) {
- prev->gc.next = (EjsGCLink*) next;
- } else {
- slab->allocList[gen].next = (EjsGCLink*) next;
- }
- count++;
-
- } else {
- prev = obj;
- /* Reset for next time */
- obj->gcMarked = 0;
- }
- }
-
- if (gen == (EJS_GEN_OLD - 1)) {
- slab->lastRecentBlock = prev;
- }
-#if BLD_FEATURE_ALLOC_STATS
- slab->totalSweeps++;
-#endif
-#if BLD_DEBUG
- if (ep->gc.debugLevel > 0) {
- mprLog(ep, 0, "GC: Sweep freed %d objects", count);
- }
-#endif
- return count;
-}
-
-/******************************************************************************/
-/*
- * Sweep all variables
- */
-
-void ejsSweepAll(Ejs *ep)
-{
- EjsSlab *slab;
- EjsObj *obj, *next, *prev;
- int gen;
-
- slab = &ep->slabs[EJS_SLAB_OBJ];
-
- for (gen = EJS_GEN_NEW; gen < EJS_GEN_MAX; gen++) {
- prev = 0;
- for (obj = (EjsObj*) slab->allocList[gen].next; obj; obj = next) {
- next = (EjsObj*) obj->gc.next;
- ejsDestroyObj(ep, obj);
- }
- break;
- }
-}
-
-/******************************************************************************/
-
-bool ejsObjIsCollectable(EjsVar *vp)
-{
- if (vp == 0 || !ejsVarIsObject(vp)) {
- return 0;
- }
- return (vp->objectState->alive && !vp->objectState->permanent);
-}
-
-/******************************************************************************/
-#if FUTURE
-
-static void ageGenerations(Ejs *ep)
-{
- EjsSlab *slab;
- EjsGCLink *oldList;
- int gen;
-
- slab = &ep->slabs[EJS_SLAB_OBJ];
-
- /*
- * Age all blocks. First append all (old - 1) blocks onto the old
- * alloc list
- */
- oldList = &slab->allocList[EJS_GEN_OLD];
-
- if (slab->lastRecentBlock) {
- slab->lastRecentBlock->gc.next = oldList->next;
- oldList->next = (EjsGCLink*) slab->lastRecentBlock;
- }
-
- /*
- * Now simply copy all allocation lists up one generation
- */
- for (gen = EJS_GEN_OLD - 1; gen > 0; gen--) {
- slab->allocList[gen] = slab->allocList[gen - 1];
- }
- slab->allocList[0].next = 0;
-}
-
-#endif
-/******************************************************************************/
-/*
- * Collect the garbage. This is a mark and sweep over all possible objects.
- * If an object is not referenced, it and all contained properties will be
- * freed. If a slabIndex is provided, the collection halts when a block is
- * available for allocation on that slab.
- *
- * Return 0 if memory is now available after collecting garbage. Otherwise,
- * return MPR_ERR_MEMORY.
- */
-
-int ejsCollectGarbage(Ejs *ep, int slabIndex)
-{
- EjsGeneration gen;
-
- if (ep->flags & EJS_FLAGS_DONT_GC) {
- return -1;
- }
-
- /*
- * Prevent destructors invoking the garbage collector
- */
- if (ep->gc.collecting) {
- return 0;
- }
- ep->gc.collecting = 1;
-
- resetMarks(ep, &ep->slabs[EJS_SLAB_OBJ]);
-
- /*
- * Examine each generation of objects starting with the most recent
- * generation. Stop scanning when we have a free block to use.
- */
- for (gen = EJS_GEN_NEW; gen < EJS_GEN_MAX; gen++) {
-
- if (slabIndex >= 0 && ep->slabs[slabIndex].freeList.next) {
- break;
- }
-
- /*
- * FUTURE OPT. Should mark objects in new generation and those
- * with a dirty bit set in older generations. Don't need to mark
- * entire heap. But how to keep list of dirty objects.
- */
- mark(ep);
- markPerm(ep, gen);
- sweep(ep, gen);
-
- /* FUTURE - not using generations yet */
- break;
- }
-
- /*
- * FUTURE -- not using generations yet.
- *
- * ageGenerations(ep);
- */
-
- ep->gc.workDone = 0;
- ep->gc.collecting = 0;
-
- return (gen < EJS_GEN_MAX) ? 0 : MPR_ERR_MEMORY;
-}
-
-
-/******************************************************************************/
-/*
- * Should be called when the app has been idle for a little while and when it
- * is likely to be idle a bit longer. Call ejsIsTimeForGC to see if this is
- * true. Return the count of objects collected .
- */
-
-int ejsIncrementalCollectGarbage(Ejs *ep)
-{
- int count;
-
- if (ep->gc.collecting) {
- return 0;
- }
-
- ep->gc.collecting = 1;
-
- resetMarks(ep, &ep->slabs[EJS_SLAB_OBJ]);
- mark(ep);
-
- /* Not generational yet */
- count = sweep(ep, EJS_GEN_NEW);
-
- ep->gc.collecting = 0;
- ep->gc.workDone = 0;
-
- return count;
-}
-
-/******************************************************************************/
-#if BLD_DEBUG
-
-void ejsDumpObjects(Ejs *ep)
-{
- int oldDebugLevel;
-
- mprLog(ep, 0, "Dump of objects in use\n");
-
- oldDebugLevel = ep->gc.debugLevel;
-
- ep->gc.debugLevel = 3;
- ep->gc.objectsInUse = 0;
- ep->gc.propertiesInUse = 0;
- ep->gc.collecting = 1;
-
- resetMarks(ep, &ep->slabs[EJS_SLAB_OBJ]);
- mark(ep);
-
- ep->gc.collecting = 0;
- ep->gc.debugLevel = oldDebugLevel;
-
- mprLog(ep, 0, "%d objects and %d properties in use",
- ep->gc.objectsInUse, ep->gc.propertiesInUse);
- mprLog(ep, 0, "%d object bytes, %d property bytes and %d total",
- (int) (ep->gc.objectsInUse * sizeof(EjsObj)),
- (int) (ep->gc.propertiesInUse * sizeof(EjsProperty)),
- (int) ((ep->gc.objectsInUse * sizeof(EjsObj) +
- ep->gc.propertiesInUse * sizeof(EjsProperty))));
-}
-
-#endif
-/******************************************************************************/
-/*
- * Return true if there is time to do a garbage collection and if we will
- * benefit from it.
- */
-
-int ejsIsTimeForGC(Ejs *ep, int timeTillNextEvent)
-{
- EjsGC *gc;
-
- if (timeTillNextEvent < EJS_MIN_TIME_FOR_GC) {
- /*
- * Not enough time to complete a collection
- */
- return 0;
- }
-
- gc = &ep->gc;
-
- /*
- * Return if we haven't done enough work to warrant a collection
- * Trigger a little short of the work quota to try to run GC before
- * a demand allocation requires it.
- */
- if (!gc->enable || !gc->enableIdleCollect ||
- (gc->workDone < (gc->workQuota - EJS_GC_MIN_WORK_QUOTA))) {
- return 0;
- }
-
-#if UNUSED
- mprLog(ep, 0, "Time for GC. Work done %d, time till next event %d",
- gc->workDone, timeTillNextEvent);
-#endif
- return 1;
-}
-
-/******************************************************************************/
-/*
- * Return the amount of memory in use by EJS
- */
-
-uint ejsGetUsedMemory(Ejs *ep)
-{
-#if BLD_FEATURE_ALLOC_STATS
- EjsSlab *slab;
- int i, totalMemory, slabMemory;
-
- totalMemory = 0;
- for (i = 0; i < EJS_SLAB_MAX; i++) {
- slab = &ep->slabs[i];
- slabMemory = slab->allocCount * slab->size;
- totalMemory += slabMemory;
- }
- return totalMemory;
-#else
- return 0;
-#endif
-}
-
-/******************************************************************************/
-/*
- * Return the amount of memory allocated by EJS
- */
-
-uint ejsGetAllocatedMemory(Ejs *ep)
-{
-#if BLD_FEATURE_ALLOC_STATS
- EjsSlab *slab;
- int i, totalMemory, slabMemory;
-
- totalMemory = 0;
- for (i = 0; i < EJS_SLAB_MAX; i++) {
- slab = &ep->slabs[i];
- slabMemory = (slab->allocCount + slab->freeCount) * slab->size;
- totalMemory += slabMemory;
- }
- return totalMemory;
-#else
- return 0;
-#endif
-}
-
-/******************************************************************************/
-/*
- * On a memory allocation failure, go into graceful degrade mode. Set all
- * slab allocation chunk increments to 1 so we can create an exception block
- * to throw.
- */
-
-static void ejsGracefulDegrade(Ejs *ep)
-{
- EjsSlab *slab;
- int i;
-
- mprLog(ep, 1, "WARNING: Memory almost depleted. In graceful degrade mode");
- for (i = 0; i < EJS_SLAB_MAX; i++) {
- slab = &ep->slabs[i];
- slab->allocIncrement = 8;
- }
- ep->gc.degraded = 1;
-}
-
-/******************************************************************************/
-
-int ejsSetGCDebugLevel(Ejs *ep, int debugLevel)
-{
- int old;
-
- old = ep->gc.debugLevel;
- ep->gc.debugLevel = debugLevel;
- return old;
-}
-
-/******************************************************************************/
-
-int ejsSetGCMaxMemory(Ejs *ep, uint maxMemory)
-{
- int old;
-
- old = ep->gc.maxMemory;
- ep->gc.maxMemory = maxMemory;
-
- return old;
-}
-
-/******************************************************************************/
-
-bool ejsBlockInUseInt(EjsVar *vp)
-{
- if (vp) {
-#if BLD_DEBUG
- if (vp->gc.magic != EJS_MAGIC) {
- return 0;
- }
- if (vp->type == EJS_TYPE_OBJECT && vp->objectState &&
- vp->objectState->gc.magic != EJS_MAGIC) {
- return 0;
- }
-#endif
- return 1;
- }
- return 1;
-}
-
-/******************************************************************************/
-#else
-void ejsGarbageDummy() {}
-
-#endif /* BLD_FEATURE_EJS */
-
-/******************************************************************************/
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- * @file ejsLex.c
- * @brief EJS Lexical Analyser
- * @overview EJS lexical analyser. This implementes a lexical analyser
- * for a subset of the JavaScript language.
- */
-/********************************* Copyright **********************************/
-/*
- * @copy default.g
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- * Portions Copyright (c) GoAhead Software, 1995-2000. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-/********************************** Includes **********************************/
-
-#include "ejs.h"
-
-#if BLD_FEATURE_EJS
-
-/****************************** Forward Declarations **************************/
-
-static int getLexicalToken(Ejs *ep, int state);
-static int tokenAddChar(Ejs *ep, int c);
-static int inputGetc(Ejs *ep);
-static void inputPutback(Ejs *ep, int c);
-static int charConvert(Ejs *ep, int base, int maxDig);
-static void parseNumber(Ejs *ep, EjsType type);
-
-/************************************* Code ***********************************/
-/*
- * Open a new input script
- */
-
-int ejsLexOpenScript(Ejs *ep, const char *script)
-{
- EjsInput *ip;
-
- mprAssert(ep);
- mprAssert(script);
-
- if ((ip = mprAllocTypeZeroed(ep, EjsInput)) == NULL) {
- return MPR_ERR_MEMORY;
- }
- ip->next = ep->input;
- ep->input = ip;
- ip->procName = ep->proc ? ep->proc->procName : NULL;
- ip->fileName = ep->fileName ? ep->fileName : NULL;
-
-/*
- * Create the parse token buffer and script buffer
- */
- ip->tokServp = ip->tokbuf;
- ip->tokEndp = ip->tokbuf;
-
- ip->script = script;
- ip->scriptSize = strlen(script);
- ip->scriptServp = (char*) ip->script;
-
- ip->lineNumber = 1;
- ip->lineColumn = 0;
-
- ip->putBackIndex = -1;
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Close the input script
- */
-
-void ejsLexCloseScript(Ejs *ep)
-{
- EjsInput *ip;
-
- mprAssert(ep);
-
- ip = ep->input;
- mprAssert(ip);
- ep->input = ip->next;
-
- mprFree(ip);
-}
-
-/******************************************************************************/
-/*
- * Initialize an input state structure
- */
-
-int ejsInitInputState(EjsInput *ip)
-{
- mprAssert(ip);
-
- memset(ip, 0, sizeof(*ip));
- ip->putBackIndex = -1;
-
- return 0;
-}
-/******************************************************************************/
-/*
- * Save the input state
- */
-
-void ejsLexSaveInputState(Ejs *ep, EjsInput *state)
-{
- EjsInput *ip;
- int i;
-
- mprAssert(ep);
-
- ip = ep->input;
- mprAssert(ip);
-
- *state = *ip;
-
- for (i = 0; i <= ip->putBackIndex; i++) {
- mprStrcpy(state->putBack[i].tokbuf, EJS_MAX_TOKEN,
- ip->putBack[i].tokbuf);
- state->putBack[i].tid = ip->putBack[i].tid;
- }
-
- mprStrcpy(state->line, sizeof(state->line), ip->line);
-
- state->lineColumn = ip->lineColumn;
- state->lineNumber = ip->lineNumber;
-}
-
-/******************************************************************************/
-/*
- * Restore the input state
- */
-
-void ejsLexRestoreInputState(Ejs *ep, EjsInput *state)
-{
- EjsInput *ip;
- EjsToken *tp;
- int i;
-
- mprAssert(ep);
- mprAssert(state);
-
- ip = ep->input;
- mprAssert(ip);
-
- mprStrcpy(ip->tokbuf, sizeof(ip->tokbuf), state->tokbuf);
- ip->tokServp = state->tokServp;
- ip->tokEndp = state->tokEndp;
-
- ip->script = state->script;
- ip->scriptServp = state->scriptServp;
- ip->scriptSize = state->scriptSize;
-
- ip->putBackIndex = state->putBackIndex;
- for (i = 0; i <= ip->putBackIndex; i++) {
- tp = &ip->putBack[i];
- tp->tid = state->putBack[i].tid;
- mprStrcpy(tp->tokbuf, sizeof(tp->tokbuf), state->putBack[i].tokbuf);
- }
-
- mprStrcpy(ip->line, sizeof(ip->line), state->line);
-
- ip->lineColumn = state->lineColumn;
- ip->lineNumber = state->lineNumber;
-}
-
-/******************************************************************************/
-/*
- * Free a saved input state
- */
-
-void ejsLexFreeInputState(Ejs *ep, EjsInput *state)
-{
- mprAssert(ep);
- mprAssert(state);
-
- state->putBackIndex = -1;
- state->lineColumn = 0;
-}
-
-/******************************************************************************/
-/*
- * Get the next EJS token
- */
-
-int ejsLexGetToken(Ejs *ep, int state)
-{
- mprAssert(ep);
-
- ep->tid = getLexicalToken(ep, state);
- return ep->tid;
-}
-
-/******************************************************************************/
-
-/*
- * Check for reserved words "if", "else", "var", "for", "delete", "function",
- * "class", "extends", "public", "private", "protected", "try", "catch",
- * "finally", "throw", "return", "get", "set", "this", "module", "each"
- *
- * The "new" and "in" reserved words are handled below. The "true", "false",
- * "null" "typeof" and "undefined" reserved words are handled as global
- * objects.
- *
- * Other reserved words not supported:
- * "break", "case", "continue", "default", "do",
- * "instanceof", "switch", "while", "with"
- *
- * ECMA extensions reserved words (not supported):
- * "abstract", "boolean", "byte", "char", "const",
- * "debugger", "double", "enum", "export",
- * "final", "float", "goto", "implements", "import", "int",
- * "interface", "long", "native", "package",
- * "short", "static", "super", "synchronized", "transient", "volatile"
- *
- * FUTURE -- use a hash lookup
- */
-
-static int checkReservedWord(Ejs *ep, int state, int c, int tid)
-{
- /* FUTURE -- probably should return for all tokens != EJS_TOK_ID */
- /* FUTURE -- Should have a hash for this. MUCH faster. */
-
- if (!isalpha(ep->token[0]) || tid == EJS_TOK_LITERAL) {
- return tid;
- }
- if (state == EJS_STATE_STMT) {
- /* FUTURE OPT -- convert to hash lookup */
- if (strcmp(ep->token, "if") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_IF;
- } else if (strcmp(ep->token, "else") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_ELSE;
- } else if (strcmp(ep->token, "var") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_VAR;
- } else if (strcmp(ep->token, "new") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_NEW;
- } else if (strcmp(ep->token, "for") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_FOR;
- } else if (strcmp(ep->token, "delete") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_DELETE;
- } else if (strcmp(ep->token, "function") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_FUNCTION;
- } else if (strcmp(ep->token, "class") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_CLASS;
- } else if (strcmp(ep->token, "module") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_MODULE;
- } else if (strcmp(ep->token, "extends") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_EXTENDS;
- } else if (strcmp(ep->token, "try") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_TRY;
- } else if (strcmp(ep->token, "catch") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_CATCH;
- } else if (strcmp(ep->token, "finally") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_FINALLY;
- } else if (strcmp(ep->token, "throw") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_THROW;
- } else if (strcmp(ep->token, "public") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_PUBLIC;
- } else if (strcmp(ep->token, "protected") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_PROTECTED;
- } else if (strcmp(ep->token, "private") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_PRIVATE;
- } else if (strcmp(ep->token, "get") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_GET;
- } else if (strcmp(ep->token, "set") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_SET;
- } else if (strcmp(ep->token, "extends") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_EXTENDS;
- } else if (strcmp(ep->token, "try") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_TRY;
- } else if (strcmp(ep->token, "catch") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_CATCH;
- } else if (strcmp(ep->token, "finally") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_FINALLY;
- } else if (strcmp(ep->token, "throw") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_THROW;
- } else if (strcmp(ep->token, "public") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_PUBLIC;
- } else if (strcmp(ep->token, "protected") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_PROTECTED;
- } else if (strcmp(ep->token, "private") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_PRIVATE;
- } else if (strcmp(ep->token, "get") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_GET;
- } else if (strcmp(ep->token, "set") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_SET;
- } else if (strcmp(ep->token, "each") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_EACH;
- } else if (strcmp(ep->token, "return") == 0) {
- if ((c == ';') || (c == '(')) {
- inputPutback(ep, c);
- }
- return EJS_TOK_RETURN;
- }
-
- } else if (state == EJS_STATE_EXPR) {
- if (strcmp(ep->token, "new") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_NEW;
- } else if (strcmp(ep->token, "in") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_IN;
- } else if (strcmp(ep->token, "function") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_FUNCTION;
- }
-
- } else if (state == EJS_STATE_DEC) {
- if (strcmp(ep->token, "extends") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_EXTENDS;
- }
- }
- return tid;
-}
-
-/******************************************************************************/
-/*
- * Get the next EJS token
- */
-
-static int getLexicalToken(Ejs *ep, int state)
-{
- EjsType type;
- EjsInput *ip;
- int done, tid, c, quote, style, idx, isHex;
-
- mprAssert(ep);
- ip = ep->input;
- mprAssert(ip);
-
- ep->tid = -1;
- tid = -1;
- type = BLD_FEATURE_NUM_TYPE_ID;
- isHex = 0;
-
- /*
- * Use a putback tokens first. Don't free strings as caller needs access.
- */
- if (ip->putBackIndex >= 0) {
- idx = ip->putBackIndex;
- tid = ip->putBack[idx].tid;
- ep->token = (char*) ip->putBack[idx].tokbuf;
- tid = checkReservedWord(ep, state, 0, tid);
- ip->putBackIndex--;
- return tid;
- }
- ep->token = ip->tokServp = ip->tokEndp = ip->tokbuf;
- *ip->tokServp = '\0';
-
- if ((c = inputGetc(ep)) < 0) {
- return EJS_TOK_EOF;
- }
-
- /*
- * Main lexical analyser
- */
- for (done = 0; !done; ) {
- switch (c) {
- case -1:
- return EJS_TOK_EOF;
-
- case ' ':
- case '\t':
- case '\r':
- do {
- if ((c = inputGetc(ep)) < 0)
- break;
- } while (c == ' ' || c == '\t' || c == '\r');
- break;
-
- case '\n':
- return EJS_TOK_NEWLINE;
-
- case '(':
- tokenAddChar(ep, c);
- return EJS_TOK_LPAREN;
-
- case ')':
- tokenAddChar(ep, c);
- return EJS_TOK_RPAREN;
-
- case '[':
- tokenAddChar(ep, c);
- return EJS_TOK_LBRACKET;
-
- case ']':
- tokenAddChar(ep, c);
- return EJS_TOK_RBRACKET;
-
- case '.':
- tokenAddChar(ep, c);
- return EJS_TOK_PERIOD;
-
- case '{':
- tokenAddChar(ep, c);
- return EJS_TOK_LBRACE;
-
- case '}':
- tokenAddChar(ep, c);
- return EJS_TOK_RBRACE;
-
- case '+':
- if ((c = inputGetc(ep)) < 0) {
- ejsSyntaxError(ep, 0);
- return EJS_TOK_ERR;
- }
- if (c != '+' ) {
- inputPutback(ep, c);
- tokenAddChar(ep, EJS_EXPR_PLUS);
- return EJS_TOK_EXPR;
- }
- tokenAddChar(ep, EJS_EXPR_INC);
- return EJS_TOK_INC_DEC;
-
- case '-':
- if ((c = inputGetc(ep)) < 0) {
- ejsSyntaxError(ep, 0);
- return EJS_TOK_ERR;
- }
- if (c != '-' ) {
- inputPutback(ep, c);
- tokenAddChar(ep, EJS_EXPR_MINUS);
- return EJS_TOK_EXPR;
- }
- tokenAddChar(ep, EJS_EXPR_DEC);
- return EJS_TOK_INC_DEC;
-
- case '*':
- tokenAddChar(ep, EJS_EXPR_MUL);
- return EJS_TOK_EXPR;
-
- case '%':
- tokenAddChar(ep, EJS_EXPR_MOD);
- return EJS_TOK_EXPR;
-
- case '/':
- /*
- * Handle the division operator and comments
- */
- if ((c = inputGetc(ep)) < 0) {
- ejsSyntaxError(ep, 0);
- return EJS_TOK_ERR;
- }
- if (c != '*' && c != '/') {
- inputPutback(ep, c);
- tokenAddChar(ep, EJS_EXPR_DIV);
- return EJS_TOK_EXPR;
- }
- style = c;
- /*
- * Eat comments. Both C and C++ comment styles are supported.
- */
- while (1) {
- if ((c = inputGetc(ep)) < 0) {
- if (style == '/') {
- return EJS_TOK_EOF;
- }
- ejsSyntaxError(ep, 0);
- return EJS_TOK_ERR;
- }
- if (c == '\n' && style == '/') {
- break;
- } else if (c == '*') {
- c = inputGetc(ep);
- if (style == '/') {
- if (c == '\n') {
- break;
- }
- } else {
- if (c == '/') {
- break;
- }
- }
- }
- }
- /*
- * Continue looking for a token, so get the next character
- */
- if ((c = inputGetc(ep)) < 0) {
- return EJS_TOK_EOF;
- }
- break;
-
- case '<': /* < and <= */
- if ((c = inputGetc(ep)) < 0) {
- ejsSyntaxError(ep, 0);
- return EJS_TOK_ERR;
- }
- if (c == '<') {
- tokenAddChar(ep, EJS_EXPR_LSHIFT);
- return EJS_TOK_EXPR;
- } else if (c == '=') {
- tokenAddChar(ep, EJS_EXPR_LESSEQ);
- return EJS_TOK_EXPR;
- }
- tokenAddChar(ep, EJS_EXPR_LESS);
- inputPutback(ep, c);
- return EJS_TOK_EXPR;
-
- case '>': /* > and >= */
- if ((c = inputGetc(ep)) < 0) {
- ejsSyntaxError(ep, 0);
- return EJS_TOK_ERR;
- }
- if (c == '>') {
- tokenAddChar(ep, EJS_EXPR_RSHIFT);
- return EJS_TOK_EXPR;
- } else if (c == '=') {
- tokenAddChar(ep, EJS_EXPR_GREATEREQ);
- return EJS_TOK_EXPR;
- }
- tokenAddChar(ep, EJS_EXPR_GREATER);
- inputPutback(ep, c);
- return EJS_TOK_EXPR;
-
- case '=': /* "==" */
- if ((c = inputGetc(ep)) < 0) {
- ejsSyntaxError(ep, 0);
- return EJS_TOK_ERR;
- }
- if (c == '=') {
- tokenAddChar(ep, EJS_EXPR_EQ);
- return EJS_TOK_EXPR;
- }
- inputPutback(ep, c);
- return EJS_TOK_ASSIGNMENT;
-
- case '!': /* "!=" or "!"*/
- if ((c = inputGetc(ep)) < 0) {
- ejsSyntaxError(ep, 0);
- return EJS_TOK_ERR;
- }
- if (c == '=') {
- tokenAddChar(ep, EJS_EXPR_NOTEQ);
- return EJS_TOK_EXPR;
- }
- inputPutback(ep, c);
- tokenAddChar(ep, EJS_EXPR_BOOL_COMP);
- return EJS_TOK_EXPR;
-
- case ';':
- tokenAddChar(ep, c);
- return EJS_TOK_SEMI;
-
- case ',':
- tokenAddChar(ep, c);
- return EJS_TOK_COMMA;
-
- case ':':
- tokenAddChar(ep, c);
- return EJS_TOK_COLON;
-
- case '|': /* "||" */
- if ((c = inputGetc(ep)) < 0 || c != '|') {
- ejsSyntaxError(ep, 0);
- return EJS_TOK_ERR;
- }
- tokenAddChar(ep, EJS_COND_OR);
- return EJS_TOK_LOGICAL;
-
- case '&': /* "&&" */
- if ((c = inputGetc(ep)) < 0 || c != '&') {
- ejsSyntaxError(ep, 0);
- return EJS_TOK_ERR;
- }
- tokenAddChar(ep, EJS_COND_AND);
- return EJS_TOK_LOGICAL;
-
- case '\"': /* String quote */
- case '\'':
- quote = c;
- if ((c = inputGetc(ep)) < 0) {
- ejsSyntaxError(ep, 0);
- return EJS_TOK_ERR;
- }
-
- while (c != quote) {
- /*
- * Check for escape sequence characters
- */
- if (c == '\\') {
- c = inputGetc(ep);
-
- if (isdigit(c)) {
- /*
- * Octal support, \101 maps to 65 = 'A'. Put first
- * char back so converter will work properly.
- */
- inputPutback(ep, c);
- c = charConvert(ep, 8, 3);
-
- } else {
- switch (c) {
- case 'n':
- c = '\n'; break;
- case 'b':
- c = '\b'; break;
- case 'f':
- c = '\f'; break;
- case 'r':
- c = '\r'; break;
- case 't':
- c = '\t'; break;
- case 'x':
- /*
- * Hex support, \x41 maps to 65 = 'A'
- */
- c = charConvert(ep, 16, 2);
- break;
- case 'u':
- /*
- * Unicode support, \x0401 maps to 65 = 'A'
- */
- c = charConvert(ep, 16, 2);
- c = c*16 + charConvert(ep, 16, 2);
-
- break;
- case '\'':
- case '\"':
- case '\\':
- break;
- default:
- if (tokenAddChar(ep, '\\') < 0) {
- return EJS_TOK_ERR;
- }
- }
- }
- if (tokenAddChar(ep, c) < 0) {
- return EJS_TOK_ERR;
- }
- } else {
- if (tokenAddChar(ep, c) < 0) {
- return EJS_TOK_ERR;
- }
- }
- if ((c = inputGetc(ep)) < 0) {
- ejsSyntaxError(ep, "Unmatched Quote");
- return EJS_TOK_ERR;
- }
- }
- return EJS_TOK_LITERAL;
-
- case '0':
- if (tokenAddChar(ep, c) < 0) {
- return EJS_TOK_ERR;
- }
- if ((c = inputGetc(ep)) < 0) {
- break;
- }
- if (tolower(c) == 'x') {
- if (tokenAddChar(ep, c) < 0) {
- return EJS_TOK_ERR;
- }
- if ((c = inputGetc(ep)) < 0) {
- break;
- }
- isHex = 1;
- if (! isxdigit(c)) {
- parseNumber(ep, type);
- inputPutback(ep, c);
- return EJS_TOK_NUMBER;
- }
- } else if (! isdigit(c)) {
-#if BLD_FEATURE_FLOATING_POINT
- if (c == '.' || tolower(c) == 'e' || c == '+' || c == '-') {
- /* Fall through */
- type = EJS_TYPE_FLOAT;
- } else
-#endif
- {
- parseNumber(ep, type);
- inputPutback(ep, c);
- return EJS_TOK_NUMBER;
- }
- }
- /* Fall through to get more digits */
-
- case '1': case '2': case '3': case '4':
- case '5': case '6': case '7': case '8': case '9':
- if (isHex) {
- do {
- if (tokenAddChar(ep, c) < 0) {
- return EJS_TOK_ERR;
- }
- if ((c = inputGetc(ep)) < 0) {
- break;
- }
- } while (isxdigit(c));
-
- } else {
-#if BLD_FEATURE_FLOATING_POINT
- do {
- if (tokenAddChar(ep, c) < 0) {
- return EJS_TOK_ERR;
- }
- if ((c = inputGetc(ep)) < 0) {
- break;
- }
- c = tolower(c);
- if (c == '.' || c == 'e' || c == 'f') {
- type = EJS_TYPE_FLOAT;
- }
- } while (isdigit(c) || c == '.' || c == 'e' ||
- c == 'f' ||
- ((type == EJS_TYPE_FLOAT) && (c == '+' || c == '-')));
-#else
- do {
- if (tokenAddChar(ep, c) < 0) {
- return EJS_TOK_ERR;
- }
- if ((c = inputGetc(ep)) < 0) {
- break;
- }
- } while (isdigit(c));
-#endif
- }
-
- parseNumber(ep, type);
- inputPutback(ep, c);
- return EJS_TOK_NUMBER;
-
- default:
- /*
- * Identifiers or a function names
- */
- while (1) {
- if (c == '\\') {
- if ((c = inputGetc(ep)) < 0) {
- break;
- }
- if (c == '\n' || c == '\r') {
- break;
- }
- } else if (tokenAddChar(ep, c) < 0) {
- break;
- }
- if ((c = inputGetc(ep)) < 0) {
- break;
- }
- if (!isalnum(c) && c != '$' && c != '_' &&
- c != '\\' && c != '@') {
- break;
- }
- }
- if (*ep->token == '\0') {
- c = inputGetc(ep);
- break;
- }
-
- if (! isalpha((int) *ep->token) && *ep->token != '$' &&
- *ep->token != '_' && *ep->token != '@') {
- ejsError(ep, EJS_SYNTAX_ERROR, "Invalid identifier %s",
- ep->token);
- return EJS_TOK_ERR;
- }
-
- tid = checkReservedWord(ep, state, c, EJS_TOK_ID);
- if (tid != EJS_TOK_ID) {
- return tid;
- }
-
- /*
- * Skip white space after token to find out whether this is
- * a function or not.
- */
- while (c == ' ' || c == '\t' || c == '\r' || c == '\n') {
- if ((c = inputGetc(ep)) < 0)
- break;
- }
-
- tid = EJS_TOK_ID;
- if ((strlen(ep->token) + 1) >= EJS_MAX_ID) {
- ejsError(ep, EJS_SYNTAX_ERROR,
- "Identifier too big. Max is %d letters.", EJS_MAX_ID);
- return EJS_TOK_ERR;
- }
- done++;
- }
- }
-
- /*
- * Putback the last extra character for next time
- */
- inputPutback(ep, c);
- return tid;
-}
-
-/******************************************************************************/
-
-static void parseNumber(Ejs *ep, EjsType type)
-{
- switch (type) {
- case EJS_TYPE_INT:
- ep->tokenNumber.integer = ejsParseInteger(ep->token);
- ep->tokenNumber.type = type;
- break;
-
-#if BLD_FEATURE_FLOATING_POINT
- case EJS_TYPE_FLOAT:
- ep->tokenNumber.floating = atof(ep->token);
- ep->tokenNumber.type = type;
- break;
-#endif
-
-#if BLD_FEATURE_INT64
- case EJS_TYPE_INT64:
- ep->tokenNumber.integer64 = ejsParseInteger64(ep->token);
- ep->tokenNumber.type = type;
- break;
-#endif
- }
-}
-
-/******************************************************************************/
-/*
- * Convert a hex or octal character back to binary, return original char if
- * not a hex digit
- */
-
-static int charConvert(Ejs *ep, int base, int maxDig)
-{
- int i, c, lval, convChar;
-
- lval = 0;
- for (i = 0; i < maxDig; i++) {
- if ((c = inputGetc(ep)) < 0) {
- break;
- }
- /*
- * Initialize to out of range value
- */
- convChar = base;
- if (isdigit(c)) {
- convChar = c - '0';
- } else if (c >= 'a' && c <= 'f') {
- convChar = c - 'a' + 10;
- } else if (c >= 'A' && c <= 'F') {
- convChar = c - 'A' + 10;
- }
- /*
- * If unexpected character then return it to buffer.
- */
- if (convChar >= base) {
- inputPutback(ep, c);
- break;
- }
- lval = (lval * base) + convChar;
- }
- return lval;
-}
-
-/******************************************************************************/
-/*
- * Putback the last token read. Accept at most one push back token.
- */
-
-void ejsLexPutbackToken(Ejs *ep, int tid, char *string)
-{
- EjsInput *ip;
- EjsToken *tp;
- int idx;
-
- mprAssert(ep);
- ip = ep->input;
- mprAssert(ip);
-
- ip->putBackIndex += 1;
-
- mprAssert(ip->putBackIndex < EJS_TOKEN_STACK);
- idx = ip->putBackIndex;
-
- tp = &ip->putBack[idx];
- tp->tid = tid;
-
- mprStrcpy(tp->tokbuf, sizeof(tp->tokbuf), string);
-}
-
-/******************************************************************************/
-/*
- * Add a character to the token buffer
- */
-
-static int tokenAddChar(Ejs *ep, int c)
-{
- EjsInput *ip;
-
- mprAssert(ep);
- ip = ep->input;
- mprAssert(ip);
-
- if (ip->tokEndp >= &ip->tokbuf[sizeof(ip->tokbuf) - 1]) {
- ejsSyntaxError(ep, "Token too big");
- return -1;
- }
- *ip->tokEndp++ = c;
- *ip->tokEndp = '\0';
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Get another input character
- */
-
-static int inputGetc(Ejs *ep)
-{
- EjsInput *ip;
- int c;
-
- mprAssert(ep);
- ip = ep->input;
-
- if (ip->scriptSize <= 0) {
- return -1;
- }
-
- c = (uchar) (*ip->scriptServp++);
- ip->scriptSize--;
-
- /*
- * For debugging, accumulate the line number and the currenly parsed line
- */
- if (c == '\n') {
-#if 0 && BLD_DEBUG
- if (ip->lineColumn > 0) {
- printf("PARSED: %s\n", ip->line);
- }
-#endif
- ip->lineNumber++;
- ip->lineColumn = 0;
- } else if ((ip->lineColumn + 2) < sizeof(ip->line)) {
- ip->line[ip->lineColumn++] = c;
- ip->line[ip->lineColumn] = '\0';
- }
- return c;
-}
-
-/******************************************************************************/
-/*
- * Putback a character onto the input queue
- */
-
-static void inputPutback(Ejs *ep, int c)
-{
- EjsInput *ip;
-
- mprAssert(ep);
-
- if (c > 0) {
- ip = ep->input;
- *--ip->scriptServp = c;
- ip->scriptSize++;
- if (--(ip->lineColumn) < 0) {
- ip->lineColumn = 0;
- }
- mprAssert(ip->line);
- mprAssert(ip->lineColumn >= 0);
- mprAssert(ip->lineColumn < sizeof(ip->line));
- ip->line[ip->lineColumn] = '\0';
- }
-}
-
-/******************************************************************************/
-
-#else
-void ejsLexDummy() {}
-
-/******************************************************************************/
-#endif /* BLD_FEATURE_EJS */
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- * @file ejsParser.c
- * @brief EJS Parser and Execution
- */
-/********************************* Copyright **********************************/
-/*
- * @copy default.g
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- * Portions Copyright (c) GoAhead Software, 1995-2000. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-
-/********************************** Includes **********************************/
-
-#include "ejs.h"
-
-#if BLD_FEATURE_EJS
-
-/****************************** Forward Declarations **************************/
-
-static int createClass(Ejs *ep, EjsVar *parentClass,
- const char *className, EjsVar *baseClass);
-static int createProperty(Ejs *ep, EjsVar **obj, const char *id,
- int state);
-static int evalCond(Ejs *ep, EjsVar *lhs, int rel, EjsVar *rhs);
-static int evalExpr(Ejs *ep, EjsVar *lhs, int rel, EjsVar *rhs);
-#if BLD_FEATURE_FLOATING_POINT
-static int evalFloatExpr(Ejs *ep, double l, int rel, double r);
-#endif
-static int evalBoolExpr(Ejs *ep, int l, int rel, int r);
-static int evalNumericExpr(Ejs *ep, EjsNum l, int rel, EjsNum r);
-static int evalObjExpr(Ejs *ep, EjsVar *lhs, int rel, EjsVar *rhs) ;
-static int evalStringExpr(Ejs *ep, EjsVar *lhs, int rel, EjsVar *rhs);
-static int evalMethod(Ejs *ep, EjsVar *obj, EjsProc *proc, int flags);
-static EjsProperty *findProperty(Ejs *ep, EjsVar *op, const char *property,
- int flags);
-static EjsVar *pickSpace(Ejs *ep, int state, const char *property, int flags);
-static void freeProc(Ejs *ep, EjsProc *proc);
-static int parseArgs(Ejs *ep, int state, int flags);
-static int parseArrayLiteral(Ejs *ep, int state, int flags, char *id);
-static int parseAssignment(Ejs *ep, int state, int flags, char *id);
-static int parseClass(Ejs *ep, int state, int flags);
-static int parseForInner(Ejs *ep, int state, int flags,
- EjsInput *condScript, EjsInput *incrScript,
- EjsInput *bodyScript, EjsInput *endScript);
-static int parseCond(Ejs *ep, int state, int flags);
-static int parseDeclaration(Ejs *ep, int state, int flags);
-static int parseExpr(Ejs *ep, int state, int flags);
-static int parseFor(Ejs *ep, int state, int flags);
-static int parseRegFor(Ejs *ep, int state, int flags);
-static int parseForIn(Ejs *ep, int state, int flags, int each);
-static int parseId(Ejs *ep, int state, int flags, char **id, int *done);
-static int parseInc(Ejs *ep, int state, int flags);
-static int parseIf(Ejs *ep, int state, int flags, int *done);
-static int parseFunction(Ejs *ep, int state, int flags);
-static int parseMethod(Ejs *ep, int state, int flags, char *id);
-static int parseObjectLiteral(Ejs *ep, int state, int flags, char *id);
-static int parseStmt(Ejs *ep, int state, int flags);
-static int parseThrow(Ejs *ep, int state, int flags);
-static int parseTry(Ejs *ep, int state, int flags);
-static void removeNewlines(Ejs *ep, int state);
-static EjsProperty *searchSpacesForProperty(Ejs *ep, int state, EjsVar *obj,
- char *property, int flags);
-static int assignPropertyValue(Ejs *ep, char *id, int state, EjsVar *value,
- int flags);
-static int updateProperty(Ejs *ep, EjsVar *obj, const char *id, int state,
- EjsVar *value);
-static void updateResult(Ejs *ep, int state, int flags, EjsVar *vp);
-static int getNextNonSpaceToken(Ejs *ep, int state);
-
-static int callConstructor(Ejs *ep, EjsVar *thisObj, EjsVar *baseClass,
- MprArray *args);
-static int callCMethod(Ejs *ep, EjsVar *obj, EjsProc *proc,
- EjsVar *prototype);
-static int callStringCMethod(Ejs *ep, EjsVar *obj, EjsProc *proc,
- EjsVar *prototype);
-static int callMethod(Ejs *ep, EjsVar *obj, EjsProc *proc,
- EjsVar *prototype);
-static int runMethod(Ejs *ep, EjsVar *thisObj, EjsVar *method,
- const char *methodName, MprArray *args);
-
-static EjsInput *getInputStruct(Ejs *ep);
-static void freeInputStruct(Ejs *ep, EjsInput *input);
-
-static void *pushFrame(Ejs *ep, int size);
-static void *popFrame(Ejs *ep, int size);
-
-/************************************* Code ***********************************/
-/*
- * Recursive descent parser for EJS
- */
-
-int ejsParse(Ejs *ep, int state, int flags)
-{
- mprAssert(ep);
-
-#if MOB
- if (mprStackCheck(ep)) {
- char *stack;
- stack = ejsFormatStack(ep);
- mprLog(ep, 0, "\nStack grew : MAX %d\n", mprStackSize(ep));
- mprLog(ep, 0, "Stack\n %s\n", stack);
- mprFree(stack);
- }
-#endif
-
- if (ep->flags & EJS_FLAGS_EXIT) {
- return EJS_STATE_RET;
- }
-
- ep->inputMarker = ep->input->scriptServp;
-
- switch (state) {
- /*
- * Any statement, method arguments or conditional expressions
- */
- case EJS_STATE_STMT:
- state = parseStmt(ep, state, flags);
- if (state != EJS_STATE_STMT_BLOCK_DONE && state != EJS_STATE_STMT_DONE){
- goto err;
- }
- break;
-
- case EJS_STATE_DEC:
- state = parseStmt(ep, state, flags);
- if (state != EJS_STATE_DEC_DONE) {
- goto err;
- }
- break;
-
- case EJS_STATE_EXPR:
- state = parseStmt(ep, state, flags);
- if (state != EJS_STATE_EXPR_DONE) {
- goto err;
- }
- break;
-
- /*
- * Variable declaration list
- */
- case EJS_STATE_DEC_LIST:
- state = parseDeclaration(ep, state, flags);
- if (state != EJS_STATE_DEC_LIST_DONE) {
- goto err;
- }
- break;
-
- /*
- * Method argument string
- */
- case EJS_STATE_ARG_LIST:
- state = parseArgs(ep, state, flags);
- if (state != EJS_STATE_ARG_LIST_DONE) {
- goto err;
- }
- break;
-
- /*
- * Logical condition list (relational operations separated by &&, ||)
- */
- case EJS_STATE_COND:
- state = parseCond(ep, state, flags);
- if (state != EJS_STATE_COND_DONE) {
- goto err;
- }
- break;
-
- /*
- * Expression list
- */
- case EJS_STATE_RELEXP:
- state = parseExpr(ep, state, flags);
- if (state != EJS_STATE_RELEXP_DONE) {
- goto err;
- }
- break;
- }
-
- /*
- * Recursion protection
- */
- if (ep->input->scriptServp == ep->inputMarker) {
- if (ep->recurseCount++ > 20) {
- ejsSyntaxError(ep, "Input syntax error");
- state = EJS_STATE_ERR;
- }
- } else {
- ep->recurseCount = 0;
- }
-
- if (state == EJS_STATE_RET || state == EJS_STATE_EOF) {
- return state;
- }
-
-done:
- return state;
-
-err:
- if (state == EJS_STATE_RET || state == EJS_STATE_EOF) {
- goto done;
- }
- if (state != EJS_STATE_ERR) {
- ejsSyntaxError(ep, 0);
- }
- state = EJS_STATE_ERR;
- goto done;
-}
-
-/******************************************************************************/
-/*
- * Local vars
- */
-
-typedef struct ParseStmt {
- EjsProc *saveProc;
- EjsProperty *pp;
- EjsVar *saveObj, *exception;
- char *str, *id;
- int done, tid, rs, saveObjPerm, expectEndOfStmt;
-} ParseStmt;
-
-/*
- * Parse expression (leftHandSide operator rightHandSide)
- */
-
-
-static int parseStmt(Ejs *ep, int state, int flags)
-{
- ParseStmt *sp;
-
- mprAssert(ep);
-
- if ((sp = pushFrame(ep, sizeof(ParseStmt))) == 0) {
- return EJS_STATE_ERR;
- }
-
- sp->id = 0;
- sp->expectEndOfStmt = 0;
- sp->saveProc = NULL;
-
- ep->currentObj = 0;
- ep->currentProperty = 0;
-
- for (sp->done = 0; !sp->done && state != EJS_STATE_ERR; ) {
- sp->tid = ejsLexGetToken(ep, state);
-
-#if (WIN || BREW_SIMULATOR) && BLD_DEBUG && DISABLED
- /* MOB -- make cross platform */
- _CrtCheckMemory();
-#endif
-
- switch (sp->tid) {
- default:
- ejsLexPutbackToken(ep, sp->tid, ep->token);
- goto done;
-
- case EJS_TOK_EXPR:
- if (state == EJS_STATE_EXPR) {
- ejsLexPutbackToken(ep, EJS_TOK_EXPR, ep->token);
- }
- goto done;
-
- case EJS_TOK_LOGICAL:
- ejsLexPutbackToken(ep, sp->tid, ep->token);
- goto done;
-
- case EJS_TOK_ERR:
- if (state != EJS_STATE_ERR && !ep->gotException) {
- ejsSyntaxError(ep, 0);
- }
- state = EJS_STATE_ERR;
- goto done;
-
- case EJS_TOK_EOF:
- state = EJS_STATE_EOF;
- goto done;
-
- case EJS_TOK_NEWLINE:
- break;
-
- case EJS_TOK_SEMI:
- /*
- * This case is when we discover no statement and just a lone ';'
- */
- if (state != EJS_STATE_STMT) {
- ejsLexPutbackToken(ep, sp->tid, ep->token);
- }
- goto done;
-
- case EJS_TOK_LBRACKET:
- if (flags & EJS_FLAGS_EXE) {
- ep->currentObj = &ep->currentProperty->var;
- if (ep->currentObj != 0 && ep->currentObj->type !=
- EJS_TYPE_OBJECT) {
- ejsError(ep, EJS_REFERENCE_ERROR,
- "Property reference to a non-object type \"%s\"\n",
- sp->id);
- goto err;
- }
- }
-
- sp->saveObj = ep->currentObj;
- sp->saveObjPerm = ejsMakeObjPermanent(sp->saveObj, 1);
-
- sp->rs = ejsParse(ep, EJS_STATE_RELEXP, flags);
-
- ejsMakeObjPermanent(sp->saveObj, sp->saveObjPerm);
- ep->currentObj = sp->saveObj;
-
- if (sp->rs < 0) {
- state = sp->rs;
- goto done;
- }
-
- mprFree(sp->id);
- /* MOB rc */
- sp->str = ejsVarToString(ep, ep->result);
- sp->id = mprStrdup(ep, sp->str);
-
- if (sp->id[0] == '\0') {
- if (flags & EJS_FLAGS_EXE) {
- ejsError(ep, EJS_RANGE_ERROR,
- "[] expression evaluates to the empty string\n");
- goto err;
- }
- } else {
- sp->pp = searchSpacesForProperty(ep, state, ep->currentObj,
- sp->id, flags);
- ep->currentProperty = sp->pp;
- updateResult(ep, state, flags, ejsGetVarPtr(sp->pp));
- }
-
- if ((sp->tid = ejsLexGetToken(ep, state)) != EJS_TOK_RBRACKET) {
- ejsSyntaxError(ep, "Missing ']'");
- goto err;
- }
- break;
-
- case EJS_TOK_PERIOD:
- if (flags & EJS_FLAGS_EXE) {
- if (ep->currentProperty == 0) {
- ejsError(ep, EJS_REFERENCE_ERROR,
- "Undefined object \"%s\"", sp->id);
- goto err;
- }
- }
- ep->currentObj = &ep->currentProperty->var;
- if (flags & EJS_FLAGS_EXE) {
- if (ep->currentObj != 0 && ep->currentObj->type !=
- EJS_TYPE_OBJECT) {
- ejsError(ep, EJS_REFERENCE_ERROR,
- "Property reference to a non-object type \"%s\"\n",
- sp->id);
- goto err;
- }
- }
- if ((sp->tid = ejsLexGetToken(ep, state)) != EJS_TOK_ID) {
- ejsError(ep, EJS_REFERENCE_ERROR, "Bad property after '.': %s",
- ep->token);
- goto err;
- }
- /* Fall through */
-
- case EJS_TOK_ID:
- state = parseId(ep, state, flags, &sp->id, &sp->done);
- if (sp->done && state == EJS_STATE_STMT) {
- sp->expectEndOfStmt = 1;
- }
- break;
-
- case EJS_TOK_ASSIGNMENT:
- sp->tid = ejsLexGetToken(ep, state);
- if (sp->tid == EJS_TOK_LBRACE) {
- /*
- * var = { name: value, name: value, ... }
- */
- if (parseObjectLiteral(ep, state, flags, sp->id) < 0) {
- ejsSyntaxError(ep, "Bad object literal");
- goto err;
- }
-
- } else if (sp->tid == EJS_TOK_LBRACKET) {
- /*
- * var = [ array elements ]
- */
- if (parseArrayLiteral(ep, state, flags, sp->id) < 0) {
- ejsSyntaxError(ep, "Bad array literal");
- goto err;
- }
-
- } else if (sp->tid == EJS_TOK_EXPR &&
- (int) *ep->token == EJS_EXPR_LESS) {
- /*
- * var = <xmlTag> .../</xmlTag>
- */
- ejsSyntaxError(ep, "XML literals are not yet supported");
- goto err;
-
- } else {
- /*
- * var = expression
- */
- ejsLexPutbackToken(ep, sp->tid, ep->token);
- state = parseAssignment(ep, state, flags, sp->id);
- if (state == EJS_STATE_ERR) {
- if (ep->flags & EJS_FLAGS_EXIT) {
- state = EJS_STATE_RET;
- goto done;
- }
- if (!ep->gotException) {
- ejsSyntaxError(ep, 0);
- }
- goto err;
- }
- }
-
- if (flags & EJS_FLAGS_EXE) {
- if (assignPropertyValue(ep, sp->id, state, ep->result,
- flags) < 0) {
- if (ep->gotException == 0) {
- ejsError(ep, EJS_EVAL_ERROR, "Can't set property %s",
- sp->id);
- }
- goto err;
- }
- }
-
- if (state == EJS_STATE_STMT) {
- sp->expectEndOfStmt = 1;
- goto done;
- }
- break;
-
- case EJS_TOK_INC_DEC:
- state = parseInc(ep, state, flags);
- if (state == EJS_STATE_STMT) {
- sp->expectEndOfStmt = 1;
- }
- break;
-
- case EJS_TOK_NEW:
- /* MOB -- could we remove rs and just use state */
- sp->rs = ejsParse(ep, EJS_STATE_EXPR, flags | EJS_FLAGS_NEW);
- if (sp->rs < 0) {
- state = sp->rs;
- goto done;
- }
- break;
-
- case EJS_TOK_DELETE:
- sp->rs = ejsParse(ep, EJS_STATE_EXPR, flags | EJS_FLAGS_DELETE);
- if (sp->rs < 0) {
- state = sp->rs;
- goto done;
- }
- if (flags & EJS_FLAGS_EXE) {
- /* Single place where properties are deleted */
- if (ep->currentObj == 0 || ep->currentProperty == 0) {
- ejsError(ep, EJS_EVAL_ERROR,
- "Can't find property to delete");
- goto err;
- }
- if (ep->currentObj->isArray) {
- ejsSetArrayLength(ep, ep->currentObj, 0,
- ep->currentProperty->name, 0);
- }
- ejsDeleteProperty(ep, ep->currentObj,
- ep->currentProperty->name);
- ep->currentProperty = 0;
- }
- goto done;
-
- case EJS_TOK_FUNCTION:
- /*
- * Parse a function declaration
- */
- state = parseFunction(ep, state, flags);
- goto done;
-
- case EJS_TOK_THROW:
- state = parseThrow(ep, state, flags);
- goto done;
-
- case EJS_TOK_TRY:
- state = parseTry(ep, state, flags);
- goto done;
-
- case EJS_TOK_CLASS:
- case EJS_TOK_MODULE:
- state = parseClass(ep, state, flags);
- goto done;
-
- case EJS_TOK_LITERAL:
- /*
- * Set the result to the string literal
- */
- if (flags & EJS_FLAGS_EXE) {
- ejsWriteVarAsString(ep, ep->result, ep->token);
- ejsSetVarName(ep, ep->result, "");
- }
- if (state == EJS_STATE_STMT) {
- sp->expectEndOfStmt = 1;
- }
- goto done;
-
- case EJS_TOK_NUMBER:
- /*
- * Set the result to the parsed number
- */
- if (flags & EJS_FLAGS_EXE) {
- ejsWriteVar(ep, ep->result, &ep->tokenNumber, 0);
- }
- if (state == EJS_STATE_STMT) {
- sp->expectEndOfStmt = 1;
- }
- goto done;
-
- case EJS_TOK_METHOD_NAME:
- /*
- * parse a method() invocation
- */
- mprAssert(ep->currentObj);
- state = parseMethod(ep, state, flags, sp->id);
- if (state == EJS_STATE_STMT) {
- sp->expectEndOfStmt = 1;
- }
- if (ep->flags & EJS_FLAGS_EXIT) {
- state = EJS_STATE_RET;
- }
- goto done;
-
- case EJS_TOK_IF:
- state = parseIf(ep, state, flags, &sp->done);
- if (state < 0) {
- goto done;
- }
- break;
-
- case EJS_TOK_FOR:
- state = parseFor(ep, state, flags);
- goto done;
-
- case EJS_TOK_VAR:
- if ((sp->rs = ejsParse(ep, EJS_STATE_DEC_LIST, flags)) < 0) {
- state = sp->rs;
- goto done;
- }
- goto done;
-
- case EJS_TOK_COMMA:
- ejsLexPutbackToken(ep, sp->tid, ep->token);
- goto done;
-
- case EJS_TOK_LPAREN:
- if (state == EJS_STATE_EXPR) {
- if ((sp->rs = ejsParse(ep, EJS_STATE_RELEXP, flags)) < 0) {
- state = sp->rs;
- goto done;
- }
- if (ejsLexGetToken(ep, state) != EJS_TOK_RPAREN) {
- ejsSyntaxError(ep, 0);
- goto err;
- }
- goto done;
-
- } else if (state == EJS_STATE_STMT) {
- ejsLexPutbackToken(ep, EJS_TOK_METHOD_NAME, ep->token);
- }
- break;
-
- case EJS_TOK_RPAREN:
- ejsLexPutbackToken(ep, sp->tid, ep->token);
- goto done;
-
- case EJS_TOK_EXTENDS:
- if (! (flags & EJS_FLAGS_CLASS_DEC)) {
- ejsSyntaxError(ep, 0);
- goto err;
- }
- sp->saveObj = ep->currentObj;
- sp->saveObjPerm = ejsMakeObjPermanent(sp->saveObj, 1);
-
- sp->rs = ejsParse(ep, EJS_STATE_STMT, flags);
- ejsMakeObjPermanent(sp->saveObj, sp->saveObjPerm);
-
- if (sp->rs < 0) {
- state = sp->rs;
- goto done;
- }
-
- if (flags & EJS_FLAGS_EXE) {
- if (createClass(ep, sp->saveObj, sp->id,
- ejsGetVarPtr(ep->currentProperty)) < 0) {
- goto err;
- }
- }
- if (ejsLexGetToken(ep, state) != EJS_TOK_LBRACE) {
- ejsSyntaxError(ep, 0);
- goto err;
- }
- ejsLexPutbackToken(ep, ep->tid, ep->token);
- goto done;
-
- case EJS_TOK_LBRACE:
- if (flags & EJS_FLAGS_CLASS_DEC) {
- if (state == EJS_STATE_DEC) {
- if (flags & EJS_FLAGS_EXE) {
- if (createClass(ep, ep->currentObj, sp->id, 0) < 0) {
- goto err;
- }
- }
- ejsLexPutbackToken(ep, sp->tid, ep->token);
-
- } else if (state == EJS_STATE_STMT) {
- ejsLexPutbackToken(ep, sp->tid, ep->token);
- }
- goto done;
- }
-
- /*
- * This handles any code in braces except "if () {} else {}"
- */
- if (state != EJS_STATE_STMT) {
- ejsSyntaxError(ep, 0);
- goto err;
- }
-
- /*
- * Parse will return EJS_STATE_STMT_BLOCK_DONE when the RBRACE
- * is seen.
- */
- sp->exception = 0;
- do {
- state = ejsParse(ep, EJS_STATE_STMT, flags);
- if (state == EJS_STATE_ERR) {
- /*
- * We need to keep parsing to get to the end of the block
- */
- if (sp->exception == 0) {
- sp->exception = ejsDupVar(ep, ep->result,
- EJS_SHALLOW_COPY);
- if (sp->exception == 0) {
- ejsMemoryError(ep);
- goto err;
- }
- if (sp->exception->type == EJS_TYPE_OBJECT) {
- ejsMakeObjLive(sp->exception, 0);
- mprAssert(sp->exception->objectState->alive == 0);
- }
-
- /*
- * If we're in a try block, we need to keep parsing
- * so we can find the end of the block and the start
- * of the catch block. Otherwise, we are done.
- */
- if (!(flags & EJS_FLAGS_TRY)) {
- break;
- }
- }
- flags &= ~EJS_FLAGS_EXE;
- if (ep->recurseCount > 20) {
- break;
- }
- state = EJS_STATE_STMT_DONE;
- ep->gotException = 0;
- }
-
- } while (state == EJS_STATE_STMT_DONE);
-
- if (sp->exception) {
- ep->gotException = 1;
- ejsWriteVar(ep, ep->result, sp->exception, EJS_SHALLOW_COPY);
-
- /* Eat the closing brace */
- ejsLexGetToken(ep, state);
- ejsFreeVar(ep, sp->exception);
-
- goto err;
- }
- ejsFreeVar(ep, sp->exception);
-
- if (state < 0) {
- goto done;
- }
-
- if (ejsLexGetToken(ep, state) != EJS_TOK_RBRACE) {
- ejsSyntaxError(ep, 0);
- goto err;
- }
- state = EJS_STATE_STMT_DONE;
- goto done;
-
- case EJS_TOK_RBRACE:
- if (state == EJS_STATE_STMT) {
- ejsLexPutbackToken(ep, sp->tid, ep->token);
- state = EJS_STATE_STMT_BLOCK_DONE;
-
- } else if (state == EJS_STATE_EXPR) {
- ejsLexPutbackToken(ep, sp->tid, ep->token);
- state = EJS_STATE_EXPR;
-
- } else {
- ejsSyntaxError(ep, 0);
- state = EJS_STATE_ERR;
- }
- goto done;
-
- case EJS_TOK_RETURN:
- if ((sp->rs = ejsParse(ep, EJS_STATE_RELEXP, flags)) < 0) {
- state = sp->rs;
- goto done;
- }
- if (flags & EJS_FLAGS_EXE) {
- state = EJS_STATE_RET;
- goto done;
- }
- break;
- }
- }
-done:
- mprFree(sp->id);
-
- if (sp->expectEndOfStmt && state >= 0) {
- sp->tid = ejsLexGetToken(ep, state);
- if (sp->tid == EJS_TOK_RBRACE) {
- ejsLexPutbackToken(ep, EJS_TOK_RBRACE, ep->token);
-
- } else if (sp->tid != EJS_TOK_SEMI && sp->tid != EJS_TOK_NEWLINE &&
- sp->tid != EJS_TOK_EOF) {
- ejsSyntaxError(ep, 0);
- state = EJS_STATE_ERR;
-
- } else {
- /*
- * Skip newlines after semi-colon
- */
- removeNewlines(ep, state);
- }
- }
-
- /*
- * Advance the state
- */
- switch (state) {
- case EJS_STATE_STMT:
- case EJS_STATE_STMT_DONE:
- state = EJS_STATE_STMT_DONE;
- break;
-
- case EJS_STATE_DEC:
- case EJS_STATE_DEC_DONE:
- state = EJS_STATE_DEC_DONE;
- break;
-
- case EJS_STATE_EXPR:
- case EJS_STATE_EXPR_DONE:
- state = EJS_STATE_EXPR_DONE;
- break;
-
- case EJS_STATE_STMT_BLOCK_DONE:
- case EJS_STATE_EOF:
- case EJS_STATE_RET:
- break;
-
- default:
- if (state != EJS_STATE_ERR) {
- ejsSyntaxError(ep, 0);
- }
- state = EJS_STATE_ERR;
- }
- popFrame(ep, sizeof(ParseStmt));
- return state;
-
-err:
- state = EJS_STATE_ERR;
- goto done;
-}
-
-/******************************************************************************/
-/*
- * Local vars
- */
-
-typedef struct ParseFor {
- char *initToken;
- int tid, foundVar, initId, each;
-} ParseFor;
-
-/*
- * Parse method arguments
- */
-
-static int parseFor(Ejs *ep, int state, int flags)
-{
- ParseFor *sp;
-
- if ((sp = pushFrame(ep, sizeof(ParseFor))) == 0) {
- return EJS_STATE_ERR;
- }
-
- mprAssert(ep);
-
- if (state != EJS_STATE_STMT) {
- ejsSyntaxError(ep, 0);
- goto err;
- }
-
- if ((sp->tid = ejsLexGetToken(ep, state)) == EJS_TOK_EACH) {
- sp->each = 1;
- sp->tid = ejsLexGetToken(ep, state);
-
- } else {
- sp->each = 0;
- }
-
- if (sp->tid != EJS_TOK_LPAREN) {
- ejsSyntaxError(ep, 0);
- goto err;
- }
-
- /*
- * Need to peek 2-3 tokens ahead and see if this is a
- * for [each] ([var] x in set)
- * or
- * for (init ; whileCond; incr)
- */
- sp->initId = ejsLexGetToken(ep, EJS_STATE_EXPR);
- sp->foundVar = 0;
- if (sp->initId == EJS_TOK_ID && strcmp(ep->token, "var") == 0) {
- sp->foundVar = 1;
- sp->initId = ejsLexGetToken(ep, EJS_STATE_EXPR);
- }
- sp->initToken = mprStrdup(ep, ep->token);
-
- sp->tid = ejsLexGetToken(ep, EJS_STATE_EXPR);
-
- ejsLexPutbackToken(ep, sp->tid, ep->token);
- ejsLexPutbackToken(ep, sp->initId, sp->initToken);
- mprFree(sp->initToken);
-
- if (sp->foundVar) {
- ejsLexPutbackToken(ep, EJS_TOK_ID, "var");
- }
-
- if (sp->tid == EJS_TOK_IN) {
- state = parseForIn(ep, state, flags, sp->each);
-
- } else {
- state = parseRegFor(ep, state, flags);
- }
-
-done:
- popFrame(ep, sizeof(ParseFor));
- return state;
-
-err:
- state = EJS_STATE_ERR;
- goto done;
-}
-
-/******************************************************************************/
-/*
- * Parse method arguments
- */
-
-static int parseArgs(Ejs *ep, int state, int flags)
-{
- EjsVar *vp;
- int tid;
-
- mprAssert(ep);
-
- do {
- /*
- * Peek and see if there are no args
- */
- tid = ejsLexGetToken(ep, state);
- ejsLexPutbackToken(ep, tid, ep->token);
- if (tid == EJS_TOK_RPAREN) {
- break;
- }
-
- /*
- * If this is part of a constructor, must run methods in args normally
- */
- flags &= ~EJS_FLAGS_NEW;
-
- state = ejsParse(ep, EJS_STATE_RELEXP, flags);
- if (state < 0) {
- return state;
- }
- if (flags & EJS_FLAGS_EXE) {
- mprAssert(ep->proc->args);
- vp = ejsDupVar(ep, ep->result, EJS_SHALLOW_COPY);
- if (vp == 0) {
- ejsMemoryError(ep);
- return EJS_STATE_ERR;
- }
- /* MOB */
- if (vp->type == EJS_TYPE_OBJECT) {
- ejsMakeObjLive(vp, 0);
- mprAssert(vp->objectState->alive == 0);
- }
-
- /*
- * Propagate the name
- */
- ejsSetVarName(ep, vp, ep->result->propertyName);
-
- mprAddItem(ep->proc->args, vp);
-
- }
- /*
- * Peek at the next token, continue if more args (ie. comma seen)
- */
- tid = ejsLexGetToken(ep, state);
- if (tid != EJS_TOK_COMMA) {
- ejsLexPutbackToken(ep, tid, ep->token);
- }
- } while (tid == EJS_TOK_COMMA);
-
- if (tid != EJS_TOK_RPAREN && state != EJS_STATE_RELEXP_DONE) {
- ejsSyntaxError(ep, 0);
- return EJS_STATE_ERR;
- }
- return EJS_STATE_ARG_LIST_DONE;
-}
-
-/******************************************************************************/
-/*
- * Local vars
- */
-
-typedef struct ParseAssign {
- EjsProperty *saveProperty;
- EjsVar *saveObj;
- int saveObjPerm, savePropPerm, rc;
-} ParseAssign;
-
-/*
- * Parse an assignment statement
- */
-
-static int parseAssignment(Ejs *ep, int state, int flags, char *id)
-{
- ParseAssign *sp;
-
-
- if (id == 0) {
- if (!ep->gotException) {
- ejsSyntaxError(ep, 0);
- }
- return EJS_STATE_ERR;
- }
-
- if ((sp = pushFrame(ep, sizeof(ParseAssign))) == 0) {
- return EJS_STATE_ERR;
- }
-
- mprAssert(ep->currentObj);
-
- /*
- * Parse the right hand side of the "="
- */
- sp->saveObj = ep->currentObj;
- sp->saveProperty = ep->currentProperty;
-
- sp->saveObjPerm = ejsMakeObjPermanent(sp->saveObj, 1);
- sp->savePropPerm = ejsMakeObjPermanent(ejsGetVarPtr(sp->saveProperty), 1);
-
- sp->rc = ejsParse(ep, EJS_STATE_RELEXP, flags | EJS_FLAGS_ASSIGNMENT);
-
- ejsMakeObjPermanent(sp->saveObj, sp->saveObjPerm);
- ejsMakeObjPermanent(ejsGetVarPtr(sp->saveProperty), sp->savePropPerm);
-
- if (sp->rc < 0) {
- state = EJS_STATE_ERR;
- }
-
- ep->currentObj = sp->saveObj;
- ep->currentProperty = sp->saveProperty;
-
- popFrame(ep, sizeof(ParseAssign));
-
- if (! (flags & EJS_FLAGS_EXE)) {
- return state;
- }
-
- return state;
-}
-
-/******************************************************************************/
-
-static int assignPropertyValue(Ejs *ep, char *id, int state, EjsVar *value,
- int flags)
-{
- EjsProperty *saveProperty;
- EjsVar *saveObj, *obj, *vp;
- char *procName;
- int saveObjPerm, savePropPerm, rc;
-
- mprAssert(flags & EJS_FLAGS_EXE);
-
- if (ep->currentProperty &&
- !ep->currentProperty->var.flags & EJS_GET_ACCESSOR) {
- obj = ep->currentObj;
-
- } else {
- /*
- * Handle any set accessors.
- * FUTURE OPT -- could be faster
- * FUTURE OPT -- coming here even when doing just a set "x = value";
- */
- procName = 0;
- if (mprAllocStrcat(MPR_LOC_ARGS(ep), &procName, EJS_MAX_ID + 5, 0,
- "-set-", id, 0) > 0) {
-
- MprArray *args;
-
- ep->currentProperty = searchSpacesForProperty(ep, state,
- ep->currentObj, procName, flags);
-
- if (ep->currentProperty) {
- args = mprCreateItemArray(ep, EJS_INC_ARGS, EJS_MAX_ARGS);
-
- vp = ejsDupVar(ep, value, EJS_SHALLOW_COPY);
- mprAddItem(args, vp);
- mprAssert(! ejsObjIsCollectable(vp));
-
- saveObj = ep->currentObj;
- saveProperty = ep->currentProperty;
-
- saveObjPerm = ejsMakeObjPermanent(saveObj, 1);
- savePropPerm = ejsMakeObjPermanent(ejsGetVarPtr(saveProperty),
- 1);
-
- /*
- * Invoke the set accessor
- */
- rc = ejsRunMethod(ep, ep->currentObj, procName, args);
- mprFree(procName);
- ejsFreeMethodArgs(ep, args);
-
- ejsMakeObjPermanent(saveObj, saveObjPerm);
- ejsMakeObjPermanent(ejsGetVarPtr(saveProperty), savePropPerm);
-
- ep->currentObj = saveObj;
- ep->currentProperty = saveProperty;
-
- if (rc < 0) {
- return EJS_STATE_ERR;
- }
- return state;
- }
- mprFree(procName);
- }
-
- if (ep->currentProperty == 0) {
- /*
- * MOB -- can we omit this as updateProperty below will create
- */
- if (createProperty(ep, &obj, id, state) < 0) {
- return EJS_STATE_ERR;
- }
- }
- }
-
- if (updateProperty(ep, obj, id, state, value) < 0) {
- return EJS_STATE_ERR;
- }
-
- vp = ejsGetVarPtr(ep->currentProperty);
- if (vp->type == EJS_TYPE_OBJECT) {
- ejsMakeObjLive(vp, 1);
- }
-
- return state;
-}
-
-/******************************************************************************/
-
-static int parseObjectLiteral(Ejs *ep, int state, int flags, char *id)
-{
- EjsProperty *saveProperty;
- EjsVar *saveObj;
- EjsVar *obj;
- char *name;
- int saveObjPerm, savePropPerm, tid;
-
- name = 0;
-
- saveObj = ep->currentObj;
- saveProperty = ep->currentProperty;
-
- saveObjPerm = ejsMakeObjPermanent(saveObj, 1);
- savePropPerm = ejsMakeObjPermanent(ejsGetVarPtr(saveProperty), 1);
-
- if (flags & EJS_FLAGS_EXE) {
- obj = ejsCreateSimpleObj(ep, "Object");
- if (obj == 0) {
- ejsMemoryError(ep);
- goto err;
- }
- mprAssert(! ejsObjIsCollectable(obj));
-
- } else {
- obj = 0;
- }
-
- do {
- tid = getNextNonSpaceToken(ep, state);
- if (tid != EJS_TOK_ID) {
- ejsSyntaxError(ep, 0);
- goto err;
- }
- name = mprStrdup(ep, ep->token);
-
- tid = getNextNonSpaceToken(ep, state);
- if (tid != EJS_TOK_COLON) {
- ejsSyntaxError(ep, 0);
- goto err;
- }
-
- if (flags & EJS_FLAGS_EXE) {
- /* FUTURE OPT -- can we optimize this. We are double accessing id
- with the Put below. Should we be using this or ejsSetProperty
- */
- if (ejsCreatePropertyMethod(ep, obj, name) == 0) {
- ejsMemoryError(ep);
- goto err;
- }
- }
-
- if (ejsParse(ep, EJS_STATE_RELEXP, flags) < 0) {
- goto err;
- }
- if (flags & EJS_FLAGS_EXE) {
- if (ejsSetPropertyMethod(ep, obj, name, ep->result) == 0) {
- ejsMemoryError(ep);
- goto err;
- }
- }
- mprFree(name);
- name = 0;
-
- tid = getNextNonSpaceToken(ep, state);
-
- } while (tid == EJS_TOK_COMMA);
-
- if (tid != EJS_TOK_RBRACE) {
- ejsSyntaxError(ep, 0);
- goto err;
- }
-
- if (flags & EJS_FLAGS_EXE) {
- ejsMakeObjLive(obj, 1);
- ejsWriteVar(ep, ep->result, obj, EJS_SHALLOW_COPY);
- }
-
-done:
- ejsMakeObjPermanent(saveObj, saveObjPerm);
- ejsMakeObjPermanent(ejsGetVarPtr(saveProperty), savePropPerm);
-
- ep->currentObj = saveObj;
- ep->currentProperty = saveProperty;
-
- if (obj) {
- ejsFreeVar(ep, obj);
- }
- return state;
-
-err:
- mprFree(name);
- state = EJS_STATE_ERR;
- goto done;
-}
-
-/******************************************************************************/
-
-static int parseArrayLiteral(Ejs *ep, int state, int flags, char *id)
-{
- EjsProperty *saveProperty;
- EjsVar *saveObj;
- EjsVar *obj;
- int saveObjPerm, savePropPerm, tid;
-
- saveObj = ep->currentObj;
- saveProperty = ep->currentProperty;
-
- saveObjPerm = ejsMakeObjPermanent(saveObj, 1);
- savePropPerm = ejsMakeObjPermanent(ejsGetVarPtr(saveProperty), 1);
-
- if (flags & EJS_FLAGS_EXE) {
- obj = ejsCreateArray(ep, 0);
- if (obj == 0) {
- ejsMemoryError(ep);
- goto err;
- }
- mprAssert(! ejsObjIsCollectable(obj));
-
- } else {
- obj = 0;
- }
-
- do {
- if (ejsParse(ep, EJS_STATE_RELEXP, flags) < 0) {
- goto err;
- }
- if (flags & EJS_FLAGS_EXE) {
- /* MOB _- should this be put[array.length] */
- if (ejsAddArrayElt(ep, obj, ep->result, EJS_SHALLOW_COPY) == 0) {
- goto err;
- }
- }
-
- tid = getNextNonSpaceToken(ep, state);
-
- } while (tid == EJS_TOK_COMMA);
-
- if (tid != EJS_TOK_RBRACKET) {
- ejsSyntaxError(ep, "Missing right bracket");
- goto err;
- }
-
- if (flags & EJS_FLAGS_EXE) {
- ejsMakeObjLive(obj, 1);
- ejsWriteVar(ep, ep->result, obj, EJS_SHALLOW_COPY);
- }
-
-done:
- ejsMakeObjPermanent(saveObj, saveObjPerm);
- ejsMakeObjPermanent(ejsGetVarPtr(saveProperty), savePropPerm);
-
- ep->currentObj = saveObj;
- ep->currentProperty = saveProperty;
-
- ejsFreeVar(ep, obj);
- return state;
-
-err:
- state = EJS_STATE_ERR;
- goto done;
-}
-
-/******************************************************************************/
-/*
- * Create a property.
- */
-
-/*
-MOB -- simplify this. Enforce ep->currentObj to be always set.
-Then we can delete this and just call
-
- ejsCreatePropertyMethod(ep->currentObj, id);
-*/
-//XX
-static int createProperty(Ejs *ep, EjsVar **objp, const char *id, int state)
-{
- EjsVar *obj, *vp;
-
- mprAssert(id && *id);
- mprAssert(objp);
-
- /*
- * Determine the variable scope to use for the property.
- * Standard says: "var x" means declare locally.
- * "x = 2" means declare globally if x is undefined.
- */
- if (ep->currentObj) {
- if (ep->currentObj->type != EJS_TYPE_OBJECT) {
- ejsSyntaxError(ep, "Reference is not an object");
- return EJS_STATE_ERR;
- }
- obj = ep->currentObj;
-
- } else {
- /* MOB -- we should never be doing this here. ep->currentObj should
- always be set already */
- obj = (state == EJS_STATE_DEC) ? ep->local : ep->global;
- }
- mprAssert(obj);
-
- vp = ejsCreatePropertyMethod(ep, obj, id);
- if (vp == 0) {
- if (!ep->gotException) {
- ejsMemoryError(ep);
- }
- return EJS_STATE_ERR;
- }
-
- *objp = obj;
- return state;
-}
-
-/******************************************************************************/
-/*
- * Update a property.
- *
- * Return with ep->currentProperty updated to point to the property.
- */
-
-static int updateProperty(Ejs *ep, EjsVar *obj, const char *id, int state,
- EjsVar *value)
-{
- EjsVar *vp;
-
- /*
- * MOB -- do ready-only check here
- */
- vp = ejsSetPropertyMethod(ep, obj, id, value);
- if (vp == 0) {
- ejsMemoryError(ep);
- return EJS_STATE_ERR;
- }
- ep->currentProperty = ejsGetPropertyPtr(vp);
-
- obj->objectState->dirty = 1;
-
- return state;
-}
-
-/******************************************************************************/
-/*
- * Local vars
- */
-
-typedef struct ParseCond {
- EjsVar lhs, rhs;
- int tid, operator;
-} ParseCond;
-
-/*
- * Parse conditional expression (relational ops separated by ||, &&)
- */
-
-static int parseCond(Ejs *ep, int state, int flags)
-{
- ParseCond *sp;
-
- if ((sp = pushFrame(ep, sizeof(ParseCond))) == 0) {
- return EJS_STATE_ERR;
- }
-
- mprAssert(ep);
-
- if (flags & EJS_FLAGS_EXE) {
- ejsClearVar(ep, ep->result);
- }
-
- sp->lhs.type = sp->rhs.type = EJS_TYPE_UNDEFINED;
- sp->lhs.objectState = sp->rhs.objectState = 0;
- sp->lhs.allocatedData = sp->rhs.allocatedData = 0;
-
- ejsSetVarName(ep, &sp->lhs, "lhs");
- ejsSetVarName(ep, &sp->rhs, "rhs");
-
- sp->operator = 0;
-
- do {
- /*
- * Recurse to handle one side of a conditional. Accumulate the
- * left hand side and the final result in ep->result.
- */
- state = ejsParse(ep, EJS_STATE_RELEXP, flags);
- if (state < 0) {
- break;
- }
-
- if (flags & EJS_FLAGS_EXE) {
- if (sp->operator > 0) {
- /*
- * FUTURE -- does not do precedence
- */
- ejsWriteVar(ep, &sp->rhs, ep->result, EJS_SHALLOW_COPY);
- if (evalCond(ep, &sp->lhs, sp->operator, &sp->rhs) < 0) {
- state = EJS_STATE_ERR;
- break;
- }
- /* Result left in ep->result */
- /* MOB */
- if (sp->lhs.type == EJS_TYPE_OBJECT) {
- mprAssert(sp->lhs.objectState->alive == 0);
- }
- if (sp->rhs.type == EJS_TYPE_OBJECT) {
- mprAssert(sp->rhs.objectState->alive == 0);
- }
- }
- }
-
- sp->tid = ejsLexGetToken(ep, state);
- if (sp->tid == EJS_TOK_LOGICAL) {
- sp->operator = (int) *ep->token;
-
- } else if (sp->tid == EJS_TOK_RPAREN || sp->tid == EJS_TOK_SEMI) {
- ejsLexPutbackToken(ep, sp->tid, ep->token);
- state = EJS_STATE_COND_DONE;
- break;
-
- } else {
- ejsLexPutbackToken(ep, sp->tid, ep->token);
- }
-
- if (flags & EJS_FLAGS_EXE) {
- ejsWriteVar(ep, &sp->lhs, ep->result, EJS_SHALLOW_COPY);
- }
-
- } while (state == EJS_STATE_RELEXP_DONE);
-
- ejsClearVar(ep, &sp->lhs);
- ejsClearVar(ep, &sp->rhs);
-
- popFrame(ep, sizeof(ParseCond));
-
- return state;
-}
-
-/******************************************************************************/
-/*
- * Parse variable declaration list. Declarations can be of the following forms:
- * var x;
- * var x, y, z;
- * var x = 1 + 2 / 3, y = 2 + 4;
- * var x = { property: value, property: value ... };
- * var x = [ property: value, property: value ... ];
- *
- * We set the variable to NULL if there is no associated assignment.
- */
-
-static int parseDeclaration(Ejs *ep, int state, int flags)
-{
- int tid;
-
- mprAssert(ep);
-
- do {
- if ((tid = ejsLexGetToken(ep, state)) != EJS_TOK_ID) {
- ejsSyntaxError(ep, 0);
- return EJS_STATE_ERR;
- }
- ejsLexPutbackToken(ep, tid, ep->token);
-
- /*
- * Parse the entire assignment or simple identifier declaration
- */
- if (ejsParse(ep, EJS_STATE_DEC, flags) != EJS_STATE_DEC_DONE) {
- return EJS_STATE_ERR;
- }
-
- /*
- * Peek at the next token, continue if comma seen
- * Stop on ";" or "in" which is used in a "for (var x in ..."
- */
- tid = ejsLexGetToken(ep, state);
-
- if (tid == EJS_TOK_SEMI) {
- return EJS_STATE_DEC_LIST_DONE;
-
- } else if (tid == EJS_TOK_IN) {
- ejsLexPutbackToken(ep, tid, ep->token);
- return EJS_STATE_DEC_LIST_DONE;
-
- } else if (flags & EJS_FLAGS_CLASS_DEC &&
- (tid == EJS_TOK_LBRACE || tid == EJS_TOK_EXTENDS)) {
- ejsLexPutbackToken(ep, tid, ep->token);
- return EJS_STATE_DEC_LIST_DONE;
-
- } else if (tid == EJS_TOK_RPAREN && flags & EJS_FLAGS_CATCH) {
- ejsLexPutbackToken(ep, tid, ep->token);
- return EJS_STATE_DEC_LIST_DONE;
-
- } else if (tid != EJS_TOK_COMMA) {
- ejsSyntaxError(ep, 0);
- return EJS_STATE_ERR;
- }
-
- } while (tid == EJS_TOK_COMMA);
-
- if (tid != EJS_TOK_SEMI) {
- ejsSyntaxError(ep, 0);
- return EJS_STATE_ERR;
- }
- return EJS_STATE_DEC_LIST_DONE;
-}
-
-/******************************************************************************/
-/*
- * Local vars
- */
-
-typedef struct ParseExpr {
- EjsVar lhs, rhs;
- int rel, tid, unaryMinus;
-} ParseExpr;
-
-/*
- * Parse expression (leftHandSide operator rightHandSide)
- */
-
-static int parseExpr(Ejs *ep, int state, int flags)
-{
- ParseExpr *sp;
-
- mprAssert(ep);
-
- if ((sp = pushFrame(ep, sizeof(ParseExpr))) == 0) {
- return EJS_STATE_ERR;
- }
-
- if (flags & EJS_FLAGS_EXE) {
- ejsClearVar(ep, ep->result);
- }
-
- sp->lhs.type = sp->rhs.type = EJS_TYPE_UNDEFINED;
- sp->lhs.objectState = sp->rhs.objectState = 0;
- sp->lhs.allocatedData = sp->rhs.allocatedData = 0;
-
- ejsSetVarName(ep, &sp->lhs, "lhs");
- ejsSetVarName(ep, &sp->rhs, "rhs");
-
- sp->rel = 0;
- sp->tid = 0;
- sp->unaryMinus = 0;
-
- do {
- /*
- * This loop will handle an entire expression list. We call parse
- * to evalutate each term which returns the result in ep->result.
- */
- if (sp->tid == EJS_TOK_LOGICAL) {
- state = ejsParse(ep, EJS_STATE_RELEXP, flags);
- if (state < 0) {
- break;
- }
- } else {
- sp->tid = ejsLexGetToken(ep, state);
- if (sp->tid == EJS_TOK_EXPR && (int) *ep->token == EJS_EXPR_MINUS) {
- sp->unaryMinus = 1;
-
- } else {
- ejsLexPutbackToken(ep, sp->tid, ep->token);
- }
-
- state = ejsParse(ep, EJS_STATE_EXPR, flags);
- if (state < 0) {
- break;
- }
- }
-
- if (flags & EJS_FLAGS_EXE) {
- if (sp->unaryMinus) {
- switch (ep->result->type) {
- default:
- case EJS_TYPE_UNDEFINED:
- case EJS_TYPE_NULL:
- case EJS_TYPE_STRING_CMETHOD:
- case EJS_TYPE_CMETHOD:
- case EJS_TYPE_METHOD:
- case EJS_TYPE_PTR:
- case EJS_TYPE_OBJECT:
- case EJS_TYPE_STRING:
- case EJS_TYPE_BOOL:
- ejsError(ep, EJS_SYNTAX_ERROR, "Invalid unary minus");
- state = EJS_STATE_ERR;
- break;
-
-#if BLD_FEATURE_FLOATING_POINT
- case EJS_TYPE_FLOAT:
- ep->result->floating = - ep->result->floating;
- break;
-#endif
-
- case EJS_TYPE_INT:
- ep->result->integer = - ep->result->integer;
- break;
-
-#if BLD_FEATURE_INT64
- case EJS_TYPE_INT64:
- ep->result->integer64 = - ep->result->integer64;
- break;
-#endif
- }
- }
- sp->unaryMinus = 0;
-
- if (sp->rel > 0) {
- ejsWriteVar(ep, &sp->rhs, ep->result, EJS_SHALLOW_COPY);
- if (sp->tid == EJS_TOK_LOGICAL) {
- if (evalCond(ep, &sp->lhs, sp->rel, &sp->rhs) < 0) {
- state = EJS_STATE_ERR;
- break;
- }
- } else {
- if (evalExpr(ep, &sp->lhs, sp->rel, &sp->rhs) < 0) {
- state = EJS_STATE_ERR;
- break;
- }
- }
- }
- /* MOB */
- if (sp->lhs.type == EJS_TYPE_OBJECT) {
- ejsMakeObjLive(&sp->lhs, 0);
- mprAssert(sp->lhs.objectState->alive == 0);
- }
- if (sp->rhs.type == EJS_TYPE_OBJECT) {
- ejsMakeObjLive(&sp->rhs, 0);
- mprAssert(sp->rhs.objectState->alive == 0);
- }
- }
-
- if ((sp->tid = ejsLexGetToken(ep, state)) == EJS_TOK_EXPR ||
- sp->tid == EJS_TOK_INC_DEC || sp->tid == EJS_TOK_LOGICAL) {
- sp->rel = (int) *ep->token;
- ejsWriteVar(ep, &sp->lhs, ep->result, EJS_SHALLOW_COPY);
-
- } else {
- ejsLexPutbackToken(ep, sp->tid, ep->token);
- state = EJS_STATE_RELEXP_DONE;
- }
-
- } while (state == EJS_STATE_EXPR_DONE);
-
- ejsClearVar(ep, &sp->lhs);
- ejsClearVar(ep, &sp->rhs);
-
- popFrame(ep, sizeof(ParseExpr));
-
- return state;
-}
-
-/******************************************************************************/
-/*
- * Local vars
- */
-
-typedef struct ParseForIn {
- EjsInput *endScript, *bodyScript;
- EjsProperty *pp, *nextp;
- EjsVar *iteratorVar, *setVar, *vp;
- int forFlags, tid;
-} ParseForIn;
-
-/*
- * Parse the "for ... in" statement. Format for the statement is:
- *
- * for [each] (var varName in expression) {
- * body;
- * }
- */
-
-static int parseForIn(Ejs *ep, int state, int flags, int each)
-{
- ParseForIn *sp;
-
- mprAssert(ep);
-
- if ((sp = pushFrame(ep, sizeof(ParseForIn))) == 0) {
- return EJS_STATE_ERR;
- }
-
- sp->setVar = 0;
- sp->iteratorVar = 0;
- sp->bodyScript = 0;
- sp->endScript = 0;
-
- sp->tid = ejsLexGetToken(ep, state);
- if (sp->tid != EJS_TOK_ID && sp->tid != EJS_TOK_VAR) {
- ejsSyntaxError(ep, 0);
- goto err;
- }
- ejsLexPutbackToken(ep, sp->tid, ep->token);
-
- state = ejsParse(ep, EJS_STATE_EXPR, EJS_FLAGS_FORIN | flags);
- if (state < 0) {
- goto done;
- }
- if (flags & EJS_FLAGS_EXE) {
- if (ep->currentProperty == 0) {
- ejsSyntaxError(ep, 0);
- goto err;
- }
- sp->iteratorVar = &ep->currentProperty->var;
- } else {
- sp->iteratorVar = 0;
- }
-
- if (ejsLexGetToken(ep, state) != EJS_TOK_IN) {
- ejsSyntaxError(ep, 0);
- goto err;
- }
-
- /*
- * Get the set
- */
- sp->tid = ejsLexGetToken(ep, state);
- if (sp->tid != EJS_TOK_ID) {
- ejsSyntaxError(ep, 0);
- goto err;
- }
- ejsLexPutbackToken(ep, sp->tid, ep->token);
-
- state = ejsParse(ep, EJS_STATE_EXPR, flags);
- if (state < 0) {
- goto done;
- }
-
- if ((flags & EJS_FLAGS_EXE) &&
- (ep->result == 0 || ep->result->type == EJS_TYPE_UNDEFINED)) {
- ejsError(ep, EJS_REFERENCE_ERROR, "Can't access array or object");
- goto err;
- }
-
- if (ejsLexGetToken(ep, state) != EJS_TOK_RPAREN) {
- ejsSyntaxError(ep, 0);
- goto err;
- }
-
- sp->setVar = ejsDupVar(ep, ep->result, EJS_SHALLOW_COPY);
-
- sp->bodyScript = getInputStruct(ep);
-
- /*
- * Parse the body and remember the end of the body script
- */
- sp->forFlags = flags & ~EJS_FLAGS_EXE;
- ejsLexSaveInputState(ep, sp->bodyScript);
-
- state = ejsParse(ep, EJS_STATE_STMT, sp->forFlags);
- if (state < 0) {
- goto done;
- }
-
- sp->endScript = getInputStruct(ep);
- ejsInitInputState(sp->endScript);
- ejsLexSaveInputState(ep, sp->endScript);
-
- /*
- * Enumerate the properties
- */
- if (flags & EJS_FLAGS_EXE) {
- if (sp->setVar->type == EJS_TYPE_OBJECT) {
-
- sp->setVar->objectState->preventDeleteProp = 1;
-
- sp->pp = ejsGetFirstProperty(sp->setVar, 0);
- while (sp->pp) {
- sp->nextp = ejsGetNextProperty(sp->pp, 0);
- if (! sp->pp->dontEnumerate && !sp->pp->delayedDelete) {
- if (each) {
- sp->vp = ejsWriteVar(ep, sp->iteratorVar,
- ejsGetVarPtr(sp->pp), EJS_SHALLOW_COPY);
- } else {
- sp->vp = ejsWriteVarAsString(ep, sp->iteratorVar,
- sp->pp->name);
- }
- if (sp->vp == 0) {
- ejsError(ep, EJS_MEMORY_ERROR,
- "Can't write to variable");
- goto err;
- }
-
- ejsLexRestoreInputState(ep, sp->bodyScript);
-
- state = ejsParse(ep, EJS_STATE_STMT, flags);
-
- if (state < 0) {
- if (sp->setVar->objectState) {
- sp->setVar->objectState->preventDeleteProp = 0;
- }
- goto done;
- }
- }
- sp->pp = sp->nextp;
- }
-
- /*
- * Process delayed deletes
- */
- if (sp->setVar->objectState) {
- sp->setVar->objectState->preventDeleteProp = 0;
- if (sp->setVar->objectState->delayedDeleteProp) {
- sp->pp = ejsGetFirstProperty(sp->setVar, 0);
- while (sp->pp) {
- sp->nextp = ejsGetNextProperty(sp->pp, 0);
- if (sp->pp->delayedDelete) {
- ejsDeleteProperty(ep, sp->setVar, sp->pp->name);
- }
- sp->pp = sp->nextp;
- }
- sp->setVar->objectState->delayedDeleteProp = 0;
- }
- }
-
- } else {
- ejsError(ep, EJS_REFERENCE_ERROR,
- "Variable to iterate over is not an array or object");
- goto err;
- }
- }
-
- ejsLexRestoreInputState(ep, sp->endScript);
-
-done:
- if (sp->endScript) {
- ejsLexFreeInputState(ep, sp->endScript);
- ejsLexFreeInputState(ep, sp->bodyScript);
- }
-
- if (sp->bodyScript) {
- freeInputStruct(ep, sp->bodyScript);
- }
- if (sp->endScript) {
- freeInputStruct(ep, sp->endScript);
- }
-
- if (sp->setVar) {
- ejsFreeVar(ep, sp->setVar);
- }
-
- popFrame(ep, sizeof(ParseForIn));
-
- return state;
-
-err:
- state = EJS_STATE_ERR;
- goto done;
-}
-
-/******************************************************************************/
-/*
- * Parse the for statement. Format for the expression is:
- *
- * for (initial; condition; incr) {
- * body;
- * }
- */
-
-static int parseRegFor(Ejs *ep, int state, int flags)
-{
- EjsInput *condScript, *endScript, *bodyScript, *incrScript;
-
- endScript = getInputStruct(ep);
- bodyScript = getInputStruct(ep);
- incrScript = getInputStruct(ep);
- condScript = getInputStruct(ep);
-
- ejsInitInputState(endScript);
- ejsInitInputState(bodyScript);
- ejsInitInputState(incrScript);
- ejsInitInputState(condScript);
-
- state = parseForInner(ep, state, flags,
- condScript, incrScript, bodyScript, endScript);
-
- ejsLexFreeInputState(ep, condScript);
- ejsLexFreeInputState(ep, incrScript);
- ejsLexFreeInputState(ep, endScript);
- ejsLexFreeInputState(ep, bodyScript);
-
- freeInputStruct(ep, condScript);
- freeInputStruct(ep, incrScript);
- freeInputStruct(ep, endScript);
- freeInputStruct(ep, bodyScript);
-
- return state;
-}
-
-/******************************************************************************/
-
-static int parseForInner(Ejs *ep, int state, int flags, EjsInput *condScript,
- EjsInput *incrScript, EjsInput *bodyScript, EjsInput *endScript)
-{
- int forFlags, cond, rs;
-
- mprAssert(ep);
-
- /*
- * Evaluate the for loop initialization statement
- */
- if ((state = ejsParse(ep, EJS_STATE_STMT, flags)) < 0) {
- return state;
- }
-
- /*
- * The first time through, we save the current input context just prior
- * to each step: prior to the conditional, the loop increment and
- * the loop body.
- */
- ejsLexSaveInputState(ep, condScript);
- if ((rs = ejsParse(ep, EJS_STATE_COND, flags)) < 0) {
- return rs;
- }
-
- cond = (ep->result->boolean != 0);
-
- if (ejsLexGetToken(ep, state) != EJS_TOK_SEMI) {
- ejsSyntaxError(ep, 0);
- return EJS_STATE_ERR;
- }
-
- /*
- * Don't execute the loop increment statement or the body
- * first time.
- */
- forFlags = flags & ~EJS_FLAGS_EXE;
- ejsLexSaveInputState(ep, incrScript);
- if ((rs = ejsParse(ep, EJS_STATE_EXPR, forFlags)) < 0) {
- return rs;
- }
-
- if (ejsLexGetToken(ep, state) != EJS_TOK_RPAREN) {
- ejsSyntaxError(ep, 0);
- return EJS_STATE_ERR;
- }
-
- /*
- * Parse the body and remember the end of the body script
- */
- ejsLexSaveInputState(ep, bodyScript);
- if ((rs = ejsParse(ep, EJS_STATE_STMT, forFlags)) < 0) {
- return rs;
- }
- ejsLexSaveInputState(ep, endScript);
-
- /*
- * Now actually do the for loop. Note loop has been rotated
- */
- while (cond && (flags & EJS_FLAGS_EXE)) {
- /*
- * Evaluate the body
- */
- ejsLexRestoreInputState(ep, bodyScript);
-
- if ((rs = ejsParse(ep, EJS_STATE_STMT, flags)) < 0) {
- return rs;
- }
-
- /*
- * Evaluate the increment script
- */
- ejsLexRestoreInputState(ep, incrScript);
- if ((rs = ejsParse(ep, EJS_STATE_EXPR, flags)) < 0) {
- return rs;
- }
- /*
- * Evaluate the condition
- */
- ejsLexRestoreInputState(ep, condScript);
- if ((rs = ejsParse(ep, EJS_STATE_COND, flags)) < 0) {
- return 0;
- }
- mprAssert(ep->result->type == EJS_TYPE_BOOL);
- cond = (ep->result->boolean != 0);
- }
-
- ejsLexRestoreInputState(ep, endScript);
-
- return state;
-}
-
-/******************************************************************************/
-/*
- * Create the bare class object
- */
-
-static int createClass(Ejs *ep, EjsVar *obj, const char *className,
- EjsVar *baseClass)
-{
- EjsVar *classObj, *existingClass;
-
- existingClass = ejsGetClass(ep, obj, className);
- if (existingClass) {
- /*
- * We allow partial clases and method redefinition
- * FUTURE -- should prevent this if the class is sealed.
- * DISABLED Error message and return OK.
- */
- /* ejsError(ep, EJS_EVAL_ERROR, "Can't create class %s", className); */
- return 0;
- }
-
- if (baseClass == 0) {
- baseClass = ejsGetClass(ep, ep->service->globalClass, "Object");
- mprAssert(baseClass);
- }
-
- classObj = ejsCreateSimpleClass(ep, baseClass, className);
- if (classObj == 0) {
- ejsMemoryError(ep);
- return -1;
- }
- mprAssert(! ejsObjIsCollectable(classObj));
-
- ep->currentProperty = ejsSetPropertyAndFree(ep, obj, className, classObj);
- mprAssert(ep->currentProperty);
-
- if (ep->currentProperty == 0) {
- return -1;
- }
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Local vars for parseTry
- */
-
-typedef struct ParseTry {
- EjsVar *exception;
- int tid, caught, rs, catchFlags;
-} ParseTry;
-
-/*
- * Parse try block
- *
- * try {}
- */
-
-static int parseTry(Ejs *ep, int state, int flags)
-{
- ParseTry *sp;
-
- if ((sp = pushFrame(ep, sizeof(ParseTry))) == 0) {
- return EJS_STATE_ERR;
- }
-
- mprAssert(ep);
-
- sp->caught = 0;
- sp->exception = 0;
- sp->catchFlags = flags;
-
- /*
- * Execute the code in the try block
- */
- sp->rs = ejsParse(ep, EJS_STATE_STMT, flags | EJS_FLAGS_TRY);
- if (sp->rs < 0) {
- if (sp->rs == EJS_STATE_ERR) {
- sp->exception = ejsDupVar(ep, ep->result, EJS_SHALLOW_COPY);
- if (sp->exception == 0) {
- ejsMemoryError(ep);
- goto err;
- }
- } else {
- state = sp->rs;
- goto done;
- }
-
- } else {
- sp->catchFlags = flags & ~EJS_FLAGS_EXE;
- }
-
- /*
- * On success path or when an exception is caught, we must parse all
- * catch and finally blocks.
- */
- sp->tid = getNextNonSpaceToken(ep, state);
-
- if (sp->tid == EJS_TOK_CATCH) {
-
- ep->gotException = 0;
-
- sp->tid = getNextNonSpaceToken(ep, state);
-
- if (sp->tid == EJS_TOK_LBRACE) {
- /*
- * Unqualified "catch "
- */
- ejsLexPutbackToken(ep, sp->tid, ep->token);
- if (ejsParse(ep, EJS_STATE_STMT, sp->catchFlags) >= 0) {
- sp->caught++;
- }
-
- } else if (sp->tid == EJS_TOK_LPAREN) {
-
- /*
- * Qualified "catch (variable) "
- */
- if ((sp->rs = ejsParse(ep, EJS_STATE_DEC_LIST,
- sp->catchFlags | EJS_FLAGS_CATCH)) < 0) {
- ejsSyntaxError(ep, "Bad catch statement");
- state = sp->rs;
- goto done;
- }
-
- sp->tid = getNextNonSpaceToken(ep, state);
- if (sp->tid != EJS_TOK_RPAREN) {
- ejsSyntaxError(ep, 0);
- goto err;
- }
-
- if (sp->catchFlags & EJS_FLAGS_EXE) {
- if (ep->currentProperty == 0) {
- ejsError(ep, EJS_EVAL_ERROR, "Can't define catch variable");
- goto err;
- }
-
- /*
- * Set the catch variable
- */
- if (ejsWriteVar(ep,
- ejsGetVarPtr(ep->currentProperty), sp->exception,
- EJS_SHALLOW_COPY) == 0) {
- ejsError(ep, EJS_EVAL_ERROR, "Can't update catch variable");
- goto err;
- }
- }
-
- /*
- * Parse the catch block
- */
- if ((sp->rs = ejsParse(ep, EJS_STATE_STMT, sp->catchFlags)) < 0) {
- state = sp->rs;
- goto done;
- }
- sp->caught++;
- ep->gotException = 0;
- }
- sp->tid = getNextNonSpaceToken(ep, state);
- }
-
- /*
- * Parse the finally block
- */
- if (sp->tid == EJS_TOK_FINALLY) {
- if (ejsParse(ep, EJS_STATE_STMT, flags) < 0) {
- goto err;
- }
- } else {
- ejsLexPutbackToken(ep, sp->tid, ep->token);
- }
-
- /*
- * Set the exception value
- */
- if (sp->exception && !sp->caught) {
- ejsWriteVar(ep, ep->result, sp->exception, EJS_SHALLOW_COPY);
- goto err;
- }
-
- state = EJS_STATE_STMT_DONE;
-
-done:
- if (sp->exception) {
- ejsFreeVar(ep, sp->exception);
- }
-
- popFrame(ep, sizeof(ParseTry));
- return state;
-
-
-err:
- state = EJS_STATE_ERR;
- goto done;
-}
-
-/******************************************************************************/
-/*
- * Parse throw statement
- *
- * throw expression
- */
-
-static int parseThrow(Ejs *ep, int state, int flags)
-{
- int rc;
-
- mprAssert(ep);
-
- if ((rc = ejsParse(ep, EJS_STATE_EXPR, flags)) < 0) {
- return rc;
- }
-
-
- if (flags & EJS_FLAGS_EXE) {
- /*
- * We have thrown the exception so set the state to ERR
- */
- ep->gotException = 1;
- return EJS_STATE_ERR;
- }
- return state;
-}
-
-/******************************************************************************/
-/*
- * Parse a class and module declaration
- *
- * class <name> [extends baseClass] {
- * [public | private | ... ] var declarations ...
- * [constructor] function declarations ...
- * }
- *
- * Modules are identical except declared with a "module" instead of
- * "class". Modules cannot be instantiated and are used for mixins.
- *
- */
-
-static int parseClass(Ejs *ep, int state, int flags)
-{
- int originalToken, tid, fid;
-
- mprAssert(ep);
-
- originalToken = ep->tid;
-
- /*
- * Parse "class Name [extends BaseClass]"
- */
- if (ejsParse(ep, EJS_STATE_DEC_LIST, flags | EJS_FLAGS_CLASS_DEC) < 0) {
- return EJS_STATE_ERR;
- }
-
- tid = getNextNonSpaceToken(ep, state);
-
- if (tid != EJS_TOK_LBRACE) {
- return EJS_STATE_ERR;
- }
-
- /*
- * After parsing the class body, ep->local will contain the actual
- * class/module object. So, we save ep->local by creating a new block.
- */
- if (flags & EJS_FLAGS_EXE) {
- fid = ejsSetBlock(ep, ejsGetVarPtr(ep->currentProperty));
- ejsSetVarName(ep, ep->local, ep->currentProperty->name);
-
- } else {
- fid = -1;
- }
-
- /* FUTURE -- should prevent modules from being instantiated */
-
- /*
- * Parse class body
- */
- do {
- state = ejsParse(ep, EJS_STATE_STMT, flags);
- if (state < 0) {
- if (fid >= 0) {
- ejsCloseBlock(ep, fid);
- }
- return state;
- }
- tid = getNextNonSpaceToken(ep, state);
- if (tid == EJS_TOK_RBRACE) {
- break;
- }
- ejsLexPutbackToken(ep, tid, ep->token);
-
- } while (state >= 0);
-
- if (fid >= 0) {
- ejsCloseBlock(ep, fid);
- }
-
- if (tid != EJS_TOK_RBRACE) {
- ejsSyntaxError(ep, 0);
- state = EJS_STATE_ERR;
- }
-
- return state;
-}
-
-/******************************************************************************/
-/*
- * Parse a function declaration
- */
-
-static int parseFunction(Ejs *ep, int state, int flags)
-{
- EjsInput *endScript, *bodyScript;
- EjsProperty *pp;
- EjsVar *func, *funcProp, *currentObj, *vp, *baseClass;
- char *procName;
- int varFlags, len, tid, bodyFlags, innerState;
-
- mprAssert(ep);
-
- func = 0;
- varFlags = 0;
-
- /*
- * method <name>(arg, arg, arg) { body };
- * method name(arg, arg, arg) { body };
- */
-
- tid = ejsLexGetToken(ep, state);
-
- if (tid == EJS_TOK_GET) {
- varFlags |= EJS_GET_ACCESSOR;
- tid = ejsLexGetToken(ep, state);
-
- } else if (tid == EJS_TOK_SET) {
- varFlags |= EJS_SET_ACCESSOR;
- tid = ejsLexGetToken(ep, state);
- }
-
- if (tid == EJS_TOK_ID) {
- if (varFlags & EJS_SET_ACCESSOR) {
-
- if (mprAllocStrcat(MPR_LOC_ARGS(ep), &procName, EJS_MAX_ID + 5,
- 0, "-set-", ep->token, 0) < 0) {
- ejsError(ep, EJS_SYNTAX_ERROR,
- "Name %s is too long", ep->token);
- return EJS_STATE_ERR;
- }
-
- } else {
- procName = mprStrdup(ep, ep->token);
- }
-
- tid = ejsLexGetToken(ep, state);
-
- } else {
- procName = 0;
- }
-
- if (tid != EJS_TOK_LPAREN) {
- mprFree(procName);
- ejsSyntaxError(ep, 0);
- return EJS_STATE_ERR;
- }
-
- /*
- * Hand craft the method value structure.
- */
- if (flags & EJS_FLAGS_EXE) {
- func = ejsCreateMethodVar(ep, 0, 0, 0);
- if (func == 0) {
- mprFree(procName);
- ejsMemoryError(ep);
- return EJS_STATE_ERR;
- }
- func->flags = varFlags;
- }
-
- tid = ejsLexGetToken(ep, state);
- while (tid == EJS_TOK_ID) {
- if (flags & EJS_FLAGS_EXE) {
- mprAddItem(func->method.args,
- mprStrdup(func->method.args, ep->token));
- }
- tid = ejsLexGetToken(ep, state);
- if (tid == EJS_TOK_RPAREN || tid != EJS_TOK_COMMA) {
- break;
- }
- tid = ejsLexGetToken(ep, state);
- }
- if (tid != EJS_TOK_RPAREN) {
- mprFree(procName);
- ejsFreeVar(ep, func);
- ejsSyntaxError(ep, 0);
- return EJS_STATE_ERR;
- }
-
- /* Allow new lines before opening brace */
- do {
- tid = ejsLexGetToken(ep, state);
- } while (tid == EJS_TOK_NEWLINE);
-
- if (tid != EJS_TOK_LBRACE) {
- mprFree(procName);
- ejsFreeVar(ep, func);
- ejsSyntaxError(ep, 0);
- return EJS_STATE_ERR;
- }
-
- /*
- * Register the method name early to allow for recursive
- * method calls (see note in ECMA standard, page 71)
- */
- funcProp = 0;
- if (flags & EJS_FLAGS_EXE && procName) {
- currentObj = pickSpace(ep, 0, procName, flags | EJS_FLAGS_LOCAL);
- pp = ejsSetProperty(ep, currentObj, procName, func);
- if (pp == 0) {
- ejsFreeVar(ep, func);
- ejsMemoryError(ep);
- return EJS_STATE_ERR;
- }
- funcProp = ejsGetVarPtr(pp);
- }
-
-
- bodyScript = getInputStruct(ep);
-
- /*
- * Parse the method body. Turn execute off.
- */
- bodyFlags = flags & ~EJS_FLAGS_EXE;
- ejsLexSaveInputState(ep, bodyScript);
-
- do {
- innerState = ejsParse(ep, EJS_STATE_STMT, bodyFlags);
- } while (innerState == EJS_STATE_STMT_DONE);
-
- tid = ejsLexGetToken(ep, state);
-
- if (innerState != EJS_STATE_STMT_BLOCK_DONE || tid != EJS_TOK_RBRACE) {
- mprFree(procName);
- ejsFreeVar(ep, func);
- ejsLexFreeInputState(ep, bodyScript);
- if (innerState != EJS_STATE_ERR) {
- ejsSyntaxError(ep, 0);
- }
- freeInputStruct(ep, bodyScript);
- return EJS_STATE_ERR;
- }
-
- if (flags & EJS_FLAGS_EXE) {
- endScript = getInputStruct(ep);
- ejsLexSaveInputState(ep, endScript);
-
- /*
- * Save the method body between the starting and ending parse
- * positions. Overwrite the trailing '}' with a null.
- */
- len = endScript->scriptServp - bodyScript->scriptServp;
- func->method.body = mprAlloc(ep, len + 1);
- memcpy(func->method.body, bodyScript->scriptServp, len);
-
- if (len <= 0) {
- func->method.body[0] = '\0';
- } else {
- func->method.body[len - 1] = '\0';
- }
- ejsLexFreeInputState(ep, bodyScript);
- ejsLexFreeInputState(ep, endScript);
- freeInputStruct(ep, endScript);
-
- /*
- * If we are in an assignment, don't register the method name, rather
- * return the method structure in the parser result.
- */
- if (procName) {
- currentObj = pickSpace(ep, 0, procName, flags | EJS_FLAGS_LOCAL);
- pp = ejsSetProperty(ep, currentObj, procName, func);
- if (pp == 0) {
- ejsFreeVar(ep, func);
- ejsMemoryError(ep);
- return EJS_STATE_ERR;
- }
-
- if (currentObj->objectState->className &&
- strcmp(currentObj->objectState->className, procName) == 0) {
- baseClass = currentObj->objectState->baseClass;
- if (baseClass) {
- if (strstr(func->method.body, "super(") != 0) {
- funcProp->callsSuper = 1;
- /*
- * Define super() to point to the baseClass constructor
- */
- vp = ejsGetPropertyAsVar(ep, baseClass,
- baseClass->objectState->className);
- if (vp) {
- mprAssert(vp);
- if (ejsSetProperty(ep, currentObj, "super",
- vp) == 0) {
- ejsFreeVar(ep, func);
- ejsMemoryError(ep);
- return EJS_STATE_ERR;
- }
- }
- }
- }
- }
- }
- /*
- * Always return the function. Try for all stmts to be expressions.
- */
- /* MOB - rc */
- ejsWriteVar(ep, ep->result, func, EJS_SHALLOW_COPY);
- }
- freeInputStruct(ep, bodyScript);
-
- mprFree(procName);
- ejsFreeVar(ep, func);
-
- return state;
-}
-
-/******************************************************************************/
-/*
- * Local vars
- */
-
-typedef struct ParseMethod {
- EjsProc proc, *saveProc;
- EjsVar *saveObj, *newObj;
- int saveObjPerm, rc;
-
-} ParseMethod;
-
-/*
- * Parse a method name and invoke the method. See parseFunction for
- * function declarations.
- */
-
-static int parseMethod(Ejs *ep, int state, int flags, char *id)
-{
- ParseMethod *sp;
-
- if ((sp = pushFrame(ep, sizeof(ParseMethod))) == 0) {
- return EJS_STATE_ERR;
- }
-
- /*
- * Must save any current ep->proc value for the current stack frame
- * to allow for recursive method calls.
- */
- sp->saveProc = (ep->proc) ? ep->proc: 0;
-
- memset(&sp->proc, 0, sizeof(EjsProc));
- sp->proc.procName = mprStrdup(ep, id);
- sp->proc.fn = &ep->currentProperty->var;
- sp->proc.args = mprCreateItemArray(ep, EJS_INC_ARGS, EJS_MAX_ARGS);
- ep->proc = &sp->proc;
-
-#if BLD_DEBUG
- if (strcmp(sp->proc.procName, "printv") == 0) {
- flags |= EJS_FLAGS_TRACE_ARGS;
- }
-#endif
-
- if (flags & EJS_FLAGS_EXE) {
- ejsClearVar(ep, ep->result);
- }
-
- if (! (flags & EJS_FLAGS_NO_ARGS)) {
- sp->saveObj = ep->currentObj;
- sp->saveObjPerm = ejsMakeObjPermanent(sp->saveObj, 1);
- sp->rc = ejsParse(ep, EJS_STATE_ARG_LIST, flags);
- ejsMakeObjPermanent(sp->saveObj, sp->saveObjPerm);
- if (sp->rc < 0) {
- goto err;
- }
- ep->currentObj = sp->saveObj;
- }
-
-#if BLD_DEBUG
- flags &= ~EJS_FLAGS_TRACE_ARGS;
-#endif
-
- /*
- * Evaluate the method if required
- */
- if (flags & EJS_FLAGS_EXE) {
- if (flags & EJS_FLAGS_NEW) {
- sp->newObj = ejsCreateObjUsingArgv(ep, ep->currentObj,
- sp->proc.procName, sp->proc.args);
-
- if (sp->newObj == 0) {
- state = EJS_STATE_ERR;
-
- } else {
- mprAssert(! ejsObjIsCollectable(sp->newObj));
-
- /*
- * Return the newly created object as the result of the
- * command. NOTE: newObj may not be an object!
- */
- /* MOB - rc */
- ejsWriteVar(ep, ep->result, sp->newObj, EJS_SHALLOW_COPY);
- if (ejsVarIsObject(sp->newObj)) {
- ejsMakeObjLive(sp->newObj, 1);
- mprAssert(ejsObjIsCollectable(sp->newObj));
- mprAssert(ejsBlockInUse(sp->newObj));
- }
- ejsFreeVar(ep, sp->newObj);
- }
-
- } else {
-
- if (evalMethod(ep, ep->currentObj, &sp->proc, flags) < 0) {
- /* Methods must call ejsError to set exceptions */
- state = EJS_STATE_ERR;
- }
- }
- }
-
- if (! (flags & EJS_FLAGS_NO_ARGS)) {
- if (ejsLexGetToken(ep, state) != EJS_TOK_RPAREN) {
- if (state != EJS_STATE_ERR) {
- ejsSyntaxError(ep, 0);
- }
- state = EJS_STATE_ERR;
- }
- }
-
-done:
- freeProc(ep, &sp->proc);
- ep->proc = sp->saveProc;
-
- popFrame(ep, sizeof(ParseMethod));
- return state;
-
-err:
- state = EJS_STATE_ERR;
- goto done;
-}
-
-/******************************************************************************/
-/*
- * Parse an identifier. This is a segment of a fully qualified variable.
- * May come here for an initial identifier or for property names
- * after a "." or "[...]".
- */
-
-static int parseId(Ejs *ep, int state, int flags, char **id, int *done)
-{
- EjsVar *null;
- int tid;
-
- mprFree(*id);
- *id = mprStrdup(ep, ep->token);
-
- if (ep->currentObj == 0) {
- /* First identifier segement */
- ep->currentObj = pickSpace(ep, state, *id, flags);
- }
-
- tid = ejsLexGetToken(ep, state);
- if (tid == EJS_TOK_ASSIGNMENT) {
- flags |= EJS_FLAGS_LHS;
- }
-
- /*
- * Find the referenced variable and store it in currentProperty.
- */
- if (flags & EJS_FLAGS_EXE) {
- ep->currentProperty = searchSpacesForProperty(ep, state,
- ep->currentObj, *id, flags);
-
- /*
- * Handle properties that have been deleted inside an enumeration
- */
- if (ep->currentProperty && ep->currentProperty->delayedDelete) {
- ep->currentProperty = 0;
- }
-
- if (ep->currentProperty &&
- ejsVarIsMethod(&ep->currentProperty->var) &&
- tid != EJS_TOK_LPAREN) {
- if (ep->currentProperty->var.flags & EJS_GET_ACCESSOR) {
- ejsLexPutbackToken(ep, tid, ep->token);
- state = parseMethod(ep, state, flags | EJS_FLAGS_NO_ARGS, *id);
- if (ep->flags & EJS_FLAGS_EXIT) {
- state = EJS_STATE_RET;
- }
- if (state >= 0) {
- ejsSetVarName(ep, ep->result, ep->currentProperty->name);
- }
- return state;
- }
- }
- /*
- * OPT. We should not have to do this always
- */
- updateResult(ep, state, flags, ejsGetVarPtr(ep->currentProperty));
- }
-
- flags &= ~EJS_FLAGS_LHS;
-
- if (tid == EJS_TOK_LPAREN) {
- if (ep->currentProperty == 0 && (flags & EJS_FLAGS_EXE)) {
- ejsError(ep, EJS_REFERENCE_ERROR,
- "Method name not defined \"%s\"", *id);
- return EJS_STATE_ERR;
- }
- ejsLexPutbackToken(ep, EJS_TOK_METHOD_NAME, ep->token);
- return state;
- }
-
- if (tid == EJS_TOK_PERIOD || tid == EJS_TOK_LBRACKET ||
- tid == EJS_TOK_ASSIGNMENT || tid == EJS_TOK_INC_DEC) {
- ejsLexPutbackToken(ep, tid, ep->token);
- return state;
- }
-
- if (flags & EJS_FLAGS_CLASS_DEC) {
- if (tid == EJS_TOK_LBRACE || tid == EJS_TOK_EXTENDS) {
- ejsLexPutbackToken(ep, tid, ep->token);
- return state;
- }
- }
-
- if (flags & EJS_FLAGS_DELETE) {
- if (tid == EJS_TOK_RBRACE) {
- ejsLexPutbackToken(ep, tid, ep->token);
- }
- }
-
- /*
- * Only come here for variable access and declarations.
- * Assignment handled elsewhere.
- */
- if (flags & EJS_FLAGS_EXE) {
- if (state == EJS_STATE_DEC) {
- /*
- * Declare a variable. Standard allows: var x ; var x ;
- */
-#if DISABLED
- if (ep->currentProperty != 0) {
- ejsError(ep, EJS_REFERENCE_ERROR,
- "Variable already defined \"%s\"", *id);
- return EJS_STATE_ERR;
- }
-#endif
- /*
- * Create or overwrite if it already exists
- * Set newly declared variables to the null value.
- */
- null = ejsCreateNullVar(ep);
- ep->currentProperty = ejsSetPropertyAndFree(ep, ep->currentObj,
- *id, null);
- ejsClearVar(ep, ep->result);
-
- } else if (flags & EJS_FLAGS_FORIN) {
- /*
- * This allows "for (x" when x has not yet been defined
- */
- if (ep->currentProperty == 0) {
- /* MOB -- return code */
- ep->currentProperty = ejsCreateProperty(ep,
- ep->currentObj, *id);
- }
-
- } else if (ep->currentProperty == 0) {
-
- if (ep->currentObj && ((ep->currentObj == ep->global ||
- (ep->currentObj == ep->local)))) {
- /*
- * Test against currentObj and not currentObj->objectState
- * as we must allow "i = global.x" and not allow
- * "i = x" where x does not exist.
- */
- ejsError(ep, EJS_REFERENCE_ERROR,
- "Undefined variable \"%s\"", *id);
- return EJS_STATE_ERR;
- }
-
- if (flags & EJS_FLAGS_DELETE) {
- ejsError(ep, EJS_REFERENCE_ERROR,
- "Undefined variable \"%s\"", *id);
- return EJS_STATE_ERR;
- }
- }
- }
- ejsLexPutbackToken(ep, tid, ep->token);
- if (tid == EJS_TOK_RBRACKET || tid == EJS_TOK_COMMA ||
- tid == EJS_TOK_IN) {
- *done = 1;
- }
- return state;
-}
-
-/******************************************************************************/
-/*
- * Local vars
- */
-
-typedef struct ParseIf {
- int ifResult, thenFlags, elseFlags, tid, rs;
-} ParseIf;
-
-/*
- * Parse an "if" statement
- */
-
-static int parseIf(Ejs *ep, int state, int flags, int *done)
-{
- ParseIf *sp;
-
- if ((sp = pushFrame(ep, sizeof(ParseIf))) == 0) {
- return EJS_STATE_ERR;
- }
-
- if (state != EJS_STATE_STMT) {
- goto err;
- }
- if (ejsLexGetToken(ep, state) != EJS_TOK_LPAREN) {
- goto err;
- }
-
- /*
- * Evaluate the entire condition list "(condition)"
- */
- if (ejsParse(ep, EJS_STATE_COND, flags) < 0) {
- goto err;
- }
- if (ejsLexGetToken(ep, state) != EJS_TOK_RPAREN) {
- goto err;
- }
-
- /*
- * This is the "then" case. We need to always parse both cases and
- * execute only the relevant case.
- */
- sp->ifResult = ejsVarToBoolean(ep->result);
- if (sp->ifResult) {
- sp->thenFlags = flags;
- sp->elseFlags = flags & ~EJS_FLAGS_EXE;
- } else {
- sp->thenFlags = flags & ~EJS_FLAGS_EXE;
- sp->elseFlags = flags;
- }
-
- /*
- * Process the "then" case.
- */
- if ((sp->rs = ejsParse(ep, EJS_STATE_STMT, sp->thenFlags)) < 0) {
- if (! ep->gotException) {
- state = sp->rs;
- goto done;
- }
- }
-
- /*
- * Check to see if there is an "else" case
- */
- removeNewlines(ep, state);
- sp->tid = ejsLexGetToken(ep, state);
- if (sp->tid != EJS_TOK_ELSE) {
- ejsLexPutbackToken(ep, sp->tid, ep->token);
- *done = 1;
- if (ep->gotException) {
- goto err;
- }
- goto done;
- }
-
- /*
- * Process the "else" case.
- */
- state = ejsParse(ep, EJS_STATE_STMT, sp->elseFlags);
-
-done:
- *done = 1;
- if (ep->gotException) {
- state = EJS_STATE_ERR;
- }
- popFrame(ep, sizeof(ParseIf));
- return state;
-
-
-err:
- state = EJS_STATE_ERR;
- goto done;
-}
-
-/******************************************************************************/
-/*
- * Parse a postix "++" or "--" statement
- */
-
-static int parseInc(Ejs *ep, int state, int flags)
-{
- EjsVar *one;
-
- if (! (flags & EJS_FLAGS_EXE)) {
- return state;
- }
-
- if (ep->currentProperty == 0) {
- ejsError(ep, EJS_REFERENCE_ERROR,
- "Undefined variable \"%s\"", ep->token);
- return EJS_STATE_ERR;
- }
- one = ejsCreateIntegerVar(ep, 1);
- if (evalExpr(ep, &ep->currentProperty->var, (int) *ep->token, one) < 0) {
- ejsFreeVar(ep, one);
- return EJS_STATE_ERR;
- }
- if (ejsWriteVar(ep, &ep->currentProperty->var, ep->result,
- EJS_SHALLOW_COPY) < 0) {
- ejsError(ep, EJS_IO_ERROR, "Can't write to variable");
- ejsFreeVar(ep, one);
- return EJS_STATE_ERR;
- }
- ejsFreeVar(ep, one);
- return state;
-}
-
-/******************************************************************************/
-/*
- * Evaluate a condition. Implements &&, ||, !. Returns with a boolean result
- * in ep->result. Returns EJS_STATE_ERR on errors, zero if successful.
- */
-
-static int evalCond(Ejs *ep, EjsVar *lhs, int rel, EjsVar *rhs)
-{
- int l, r, lval;
-
- mprAssert(rel > 0);
-
- l = ejsVarToBoolean(lhs);
- r = ejsVarToBoolean(rhs);
-
- switch (rel) {
- case EJS_COND_AND:
- lval = l && r;
- break;
- case EJS_COND_OR:
- lval = l || r;
- break;
- default:
- ejsError(ep, EJS_SYNTAX_ERROR, "Bad operator %d", rel);
- return -1;
- }
-
- /* MOB - rc */
- ejsWriteVarAsBoolean(ep, ep->result, lval);
- return 0;
-}
-
-
-/******************************************************************************/
-/*
- * return true if this string is a valid number
- */
-
-static int stringIsNumber(const char *s)
-{
- char *endptr = NULL;
-
- if (s == NULL || *s == 0) {
- return 0;
- }
- /* MOB -- not ideal */
-#if BREW
- /* MOB this should check all digits and not just the first. */
- /* Does not support floating point - easy */
-
- if (isdigit(*s) || (*s == '-' && isdigit(s[1]))) {
- return 1;
- }
-#else
- strtod(s, &endptr);
-#endif
- if (endptr != NULL && *endptr == 0) {
- return 1;
- }
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Evaluate an operation. Returns with the result in ep->result. Returns -1
- * on errors, otherwise zero is returned.
- */
-
-static int evalExpr(Ejs *ep, EjsVar *lhs, int rel, EjsVar *rhs)
-{
- EjsNum lval;
- char *str;
- int rc;
-
- mprAssert(rel > 0);
- str = 0;
- lval = 0;
-
- /*
- * Type conversion. This is tricky and must be according to the standard.
- * Only numbers (including floats) and strings can be compared. All other
- * types are first converted to numbers by preference and if that fails,
- * to strings.
- *
- * MOB -- should we do "valueOf" here also.
- */
- if (lhs->type == EJS_TYPE_OBJECT &&
- (rhs->type != EJS_TYPE_OBJECT &&
- (rhs->type != EJS_TYPE_UNDEFINED && rhs->type != EJS_TYPE_NULL))) {
- if (ejsVarIsNumber(rhs)) {
- if (ejsRunMethod(ep, lhs, "toValue", 0) == 0) {
- /* MOB - rc */
- ejsWriteVar(ep, lhs, ep->result, EJS_SHALLOW_COPY);
- } else {
- if (ejsRunMethod(ep, lhs, "toString", 0) == 0) {
- /* MOB - rc */
- ejsWriteVar(ep, lhs, ep->result, EJS_SHALLOW_COPY);
- }
- }
-
- } else {
- if (ejsRunMethod(ep, lhs, "toString", 0) == 0) {
- /* MOB - rc */
- ejsWriteVar(ep, lhs, ep->result, EJS_SHALLOW_COPY);
- } else {
- if (ejsRunMethod(ep, lhs, "toValue", 0) == 0) {
- /* MOB - rc */
- ejsWriteVar(ep, lhs, ep->result, EJS_SHALLOW_COPY);
- }
- }
- }
- /* Nothing more can be done */
- }
-
- if (rhs->type == EJS_TYPE_OBJECT &&
- (lhs->type != EJS_TYPE_OBJECT &&
- (lhs->type != EJS_TYPE_UNDEFINED && lhs->type != EJS_TYPE_NULL))) {
- if (ejsVarIsNumber(lhs)) {
- /* If LHS is number, then convert to a value first */
- if (ejsRunMethod(ep, rhs, "toValue", 0) == 0) {
- /* MOB - rc */
- ejsWriteVar(ep, rhs, ep->result, EJS_SHALLOW_COPY);
- } else {
- if (ejsRunMethod(ep, rhs, "toString", 0) == 0) {
- /* MOB - rc */
- ejsWriteVar(ep, rhs, ep->result, EJS_SHALLOW_COPY);
- }
- }
-
- } else {
- /* If LHS is not a number, then convert to a string first */
- if (ejsRunMethod(ep, rhs, "toString", 0) == 0) {
- /* MOB - rc */
- ejsWriteVar(ep, rhs, ep->result, EJS_SHALLOW_COPY);
-
- } else {
- if (ejsRunMethod(ep, rhs, "toValue", 0) == 0) {
- /* MOB - rc */
- ejsWriteVar(ep, rhs, ep->result, EJS_SHALLOW_COPY);
- }
- }
- }
- /* Nothing more can be done */
- }
-
- /*
- * undefined and null are special, in that they don't get promoted when
- * comparing.
- */
- if (rel == EJS_EXPR_EQ || rel == EJS_EXPR_NOTEQ) {
- if (lhs->type == EJS_TYPE_UNDEFINED ||
- rhs->type == EJS_TYPE_UNDEFINED) {
- return evalBoolExpr(ep,
- lhs->type == EJS_TYPE_UNDEFINED,
- rel,
- rhs->type == EJS_TYPE_UNDEFINED);
- }
-
- if (lhs->type == EJS_TYPE_NULL || rhs->type == EJS_TYPE_NULL) {
- return evalBoolExpr(ep,
- lhs->type == EJS_TYPE_NULL,
- rel,
- rhs->type == EJS_TYPE_NULL);
- }
- }
-
- /*
- * From here on, lhs and rhs may contain allocated data (strings), so
- * we must always destroy before overwriting.
- */
-
- /*
- * Only allow a few bool operations. Otherwise convert to number.
- */
- if (lhs->type == EJS_TYPE_BOOL && rhs->type == EJS_TYPE_BOOL &&
- (rel != EJS_EXPR_EQ && rel != EJS_EXPR_NOTEQ &&
- rel != EJS_EXPR_BOOL_COMP)) {
- ejsWriteVarAsNumber(ep, lhs, ejsVarToNumber(lhs));
- }
-
- /*
- * Types do not match, so try to coerce the right operand to match the left
- * But first, try to convert a left operand that is a numeric stored as a
- * string, into a numeric.
- */
- if (lhs->type != rhs->type) {
- if (lhs->type == EJS_TYPE_STRING) {
- if (stringIsNumber(lhs->string)) {
- ejsWriteVarAsNumber(ep, lhs, ejsVarToNumber(lhs));
-
- /* Examine further below */
-
- } else {
- /*
- * Convert the RHS to a string
- * MOB rc
- */
- str = ejsVarToString(ep, rhs);
- ejsWriteVarAsString(ep, rhs, str);
- }
-
-#if BLD_FEATURE_FLOATING_POINT
- } else if (lhs->type == EJS_TYPE_FLOAT) {
- /*
- * Convert rhs to floating
- */
- ejsWriteVarAsFloat(ep, rhs, ejsVarToFloat(rhs));
-
-#endif
-#if BLD_FEATURE_INT64
- } else if (lhs->type == EJS_TYPE_INT64) {
- /*
- * Convert the rhs to 64 bit
- */
- ejsWriteVarAsInteger64(ep, rhs, ejsVarToInteger64(rhs));
-#endif
- } else if (lhs->type == EJS_TYPE_BOOL || lhs->type == EJS_TYPE_INT) {
-
- if (rhs->type == EJS_TYPE_STRING) {
- if (stringIsNumber(rhs->string)) {
- ejsWriteVarAsNumber(ep, rhs, ejsVarToNumber(rhs));
- } else {
- /*
- * Convert to lhs to a string
- */
- str = ejsVarToString(ep, lhs);
- /* MOB -- rc */
- if (str) {
- ejsWriteVarAsString(ep, lhs, str);
- }
- }
-
-#if BLD_FEATURE_FLOATING_POINT
- } else if (rhs->type == EJS_TYPE_FLOAT) {
- /*
- * Convert lhs to floating
- */
- ejsWriteVarAsFloat(ep, lhs, ejsVarToFloat(lhs));
-#endif
-
- } else {
- /*
- * Forcibly convert both operands to numbers
- */
- ejsWriteVarAsNumber(ep, lhs, ejsVarToNumber(lhs));
- ejsWriteVarAsNumber(ep, rhs, ejsVarToNumber(rhs));
- }
- }
- }
-
- /*
- * We have failed to coerce the types to be the same. Special case here
- * for undefined and null. We need to allow comparisions against these
- * special values.
- */
- if (lhs->type == EJS_TYPE_UNDEFINED || lhs->type == EJS_TYPE_NULL) {
- switch (rel) {
- case EJS_EXPR_EQ:
- lval = lhs->type == rhs->type;
- break;
- case EJS_EXPR_NOTEQ:
- lval = lhs->type != rhs->type;
- break;
- case EJS_EXPR_BOOL_COMP:
- lval = ! ejsVarToBoolean(rhs);
- break;
- default:
- ejsWriteVar(ep, ep->result, rhs, EJS_SHALLOW_COPY);
- return 0;
- }
- ejsWriteVarAsBoolean(ep, ep->result, lval);
- return 0;
- }
-
- /*
- * Types are the same here
- */
- switch (lhs->type) {
- default:
- case EJS_TYPE_UNDEFINED:
- case EJS_TYPE_NULL:
- /* Should be handled above */
- mprAssert(0);
- return 0;
-
- case EJS_TYPE_STRING_CMETHOD:
- case EJS_TYPE_CMETHOD:
- case EJS_TYPE_METHOD:
- case EJS_TYPE_PTR:
- ejsWriteVarAsBoolean(ep, ep->result, 0);
- return 0;
-
- case EJS_TYPE_OBJECT:
- rc = evalObjExpr(ep, lhs, rel, rhs);
- break;
-
- case EJS_TYPE_BOOL:
- rc = evalBoolExpr(ep, lhs->boolean, rel, rhs->boolean);
- break;
-
-#if BLD_FEATURE_FLOATING_POINT
- case EJS_TYPE_FLOAT:
- rc = evalFloatExpr(ep, lhs->floating, rel, rhs->floating);
- break;
-#endif
-
- case EJS_TYPE_INT:
- rc = evalNumericExpr(ep, (EjsNum) lhs->integer, rel,
- (EjsNum) rhs->integer);
- break;
-
-#if BLD_FEATURE_INT64
- case EJS_TYPE_INT64:
- rc = evalNumericExpr(ep, (EjsNum) lhs->integer64, rel,
- (EjsNum) rhs->integer64);
- break;
-#endif
-
- case EJS_TYPE_STRING:
- rc = evalStringExpr(ep, lhs, rel, rhs);
- }
-
- /* MOB */
- if (lhs->type == EJS_TYPE_OBJECT) {
- ejsMakeObjLive(lhs, 0);
- mprAssert(lhs->objectState->alive == 0);
- }
- if (rhs->type == EJS_TYPE_OBJECT) {
- ejsMakeObjLive(rhs, 0);
- mprAssert(rhs->objectState->alive == 0);
- }
-
- return rc;
-}
-
-/******************************************************************************/
-#if BLD_FEATURE_FLOATING_POINT
-/*
- * Expressions with floating operands
- */
-
-static int evalFloatExpr(Ejs *ep, double l, int rel, double r)
-{
- double lval;
- int logical;
-
- lval = 0;
- logical = 0;
-
- switch (rel) {
- case EJS_EXPR_PLUS:
- lval = l + r;
- break;
- case EJS_EXPR_INC:
- lval = l + 1;
- break;
- case EJS_EXPR_MINUS:
- lval = l - r;
- break;
- case EJS_EXPR_DEC:
- lval = l - 1;
- break;
- case EJS_EXPR_MUL:
- lval = l * r;
- break;
- case EJS_EXPR_DIV:
- lval = l / r;
- break;
- default:
- logical++;
- break;
- }
-
- /*
- * Logical operators
- */
- if (logical) {
-
- switch (rel) {
- case EJS_EXPR_EQ:
- lval = l == r;
- break;
- case EJS_EXPR_NOTEQ:
- lval = l != r;
- break;
- case EJS_EXPR_LESS:
- lval = (l < r) ? 1 : 0;
- break;
- case EJS_EXPR_LESSEQ:
- lval = (l <= r) ? 1 : 0;
- break;
- case EJS_EXPR_GREATER:
- lval = (l > r) ? 1 : 0;
- break;
- case EJS_EXPR_GREATEREQ:
- lval = (l >= r) ? 1 : 0;
- break;
- case EJS_EXPR_BOOL_COMP:
- lval = (r == 0) ? 1 : 0;
- break;
- default:
- ejsError(ep, EJS_SYNTAX_ERROR, "Bad operator %d", rel);
- return -1;
- }
- ejsWriteVarAsBoolean(ep, ep->result, lval != 0);
-
- } else {
- ejsWriteVarAsFloat(ep, ep->result, lval);
- }
- return 0;
-}
-
-#endif /* BLD_FEATURE_FLOATING_POINT */
-/******************************************************************************/
-/*
- * Expressions with object operands
- */
-
-static int evalObjExpr(Ejs *ep, EjsVar *lhs, int rel, EjsVar *rhs)
-{
- int lval;
-
- switch (rel) {
- case EJS_EXPR_EQ:
- lval = lhs->objectState == rhs->objectState;
- break;
- case EJS_EXPR_NOTEQ:
- lval = lhs->objectState != rhs->objectState;
- break;
- default:
- ejsError(ep, EJS_SYNTAX_ERROR, "Bad operator %d", rel);
- return -1;
- }
- ejsWriteVarAsBoolean(ep, ep->result, lval);
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Expressions with boolean operands
- */
-
-static int evalBoolExpr(Ejs *ep, int l, int rel, int r)
-{
- int lval;
-
- switch (rel) {
- case EJS_EXPR_EQ:
- lval = l == r;
- break;
- case EJS_EXPR_NOTEQ:
- lval = l != r;
- break;
- case EJS_EXPR_BOOL_COMP:
- lval = (r == 0) ? 1 : 0;
- break;
- default:
- ejsError(ep, EJS_SYNTAX_ERROR, "Bad operator %d", rel);
- return -1;
- }
- ejsWriteVarAsBoolean(ep, ep->result, lval);
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Expressions with numeric operands
- */
-
-static int evalNumericExpr(Ejs *ep, EjsNum l, int rel, EjsNum r)
-{
- EjsNum lval;
- int logical;
-
- lval = 0;
- logical = 0;
-
- switch (rel) {
- case EJS_EXPR_PLUS:
- lval = l + r;
- break;
- case EJS_EXPR_INC:
- lval = l + 1;
- break;
- case EJS_EXPR_MINUS:
- lval = l - r;
- break;
- case EJS_EXPR_DEC:
- lval = l - 1;
- break;
- case EJS_EXPR_MUL:
- lval = l * r;
- break;
- case EJS_EXPR_DIV:
- if (r != 0) {
- lval = l / r;
- } else {
- ejsError(ep, EJS_RANGE_ERROR, "Divide by zero");
- return -1;
- }
- break;
- case EJS_EXPR_MOD:
- if (r != 0) {
- lval = l % r;
- } else {
- ejsError(ep, EJS_RANGE_ERROR, "Modulo zero");
- return -1;
- }
- break;
- case EJS_EXPR_LSHIFT:
- lval = l << r;
- break;
- case EJS_EXPR_RSHIFT:
- lval = l >> r;
- break;
-
- default:
- logical++;
- break;
- }
-
- /*
- * Logical operators
- */
- if (logical) {
-
- switch (rel) {
- case EJS_EXPR_EQ:
- lval = l == r;
- break;
- case EJS_EXPR_NOTEQ:
- lval = l != r;
- break;
- case EJS_EXPR_LESS:
- lval = (l < r) ? 1 : 0;
- break;
- case EJS_EXPR_LESSEQ:
- lval = (l <= r) ? 1 : 0;
- break;
- case EJS_EXPR_GREATER:
- lval = (l > r) ? 1 : 0;
- break;
- case EJS_EXPR_GREATEREQ:
- lval = (l >= r) ? 1 : 0;
- break;
- case EJS_EXPR_BOOL_COMP:
- lval = (r == 0) ? 1 : 0;
- break;
- default:
- ejsError(ep, EJS_SYNTAX_ERROR, "Bad operator %d", rel);
- return -1;
- }
- ejsWriteVarAsBoolean(ep, ep->result, lval != 0);
-
- } else {
- ejsWriteVarAsNumber(ep, ep->result, lval);
- }
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Expressions with string operands
- */
-
-static int evalStringExpr(Ejs *ep, EjsVar *lhs, int rel, EjsVar *rhs)
-{
- int lval;
-
- mprAssert(ep);
- mprAssert(lhs);
- mprAssert(rhs);
-
- switch (rel) {
- case EJS_EXPR_LESS:
- lval = strcmp(lhs->string, rhs->string) < 0;
- break;
- case EJS_EXPR_LESSEQ:
- lval = strcmp(lhs->string, rhs->string) <= 0;
- break;
- case EJS_EXPR_GREATER:
- lval = strcmp(lhs->string, rhs->string) > 0;
- break;
- case EJS_EXPR_GREATEREQ:
- lval = strcmp(lhs->string, rhs->string) >= 0;
- break;
- case EJS_EXPR_EQ:
- lval = strcmp(lhs->string, rhs->string) == 0;
- break;
- case EJS_EXPR_NOTEQ:
- lval = strcmp(lhs->string, rhs->string) != 0;
- break;
- case EJS_EXPR_PLUS:
- /*
- * This differs from all the above operations. We append rhs to lhs.
- */
- ejsClearVar(ep, ep->result);
- ejsStrcat(ep, ep->result, lhs);
- ejsStrcat(ep, ep->result, rhs);
- return 0;
-
- case EJS_EXPR_INC:
- case EJS_EXPR_DEC:
- case EJS_EXPR_MINUS:
- case EJS_EXPR_DIV:
- case EJS_EXPR_MOD:
- case EJS_EXPR_LSHIFT:
- case EJS_EXPR_RSHIFT:
- default:
- ejsSyntaxError(ep, "Bad operator");
- return -1;
- }
-
- ejsWriteVarAsBoolean(ep, ep->result, lval);
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Evaluate a method. obj is set to the current object if a method is being
- * run.
- */
-
-static int evalMethod(Ejs *ep, EjsVar *obj, EjsProc *proc, int flags)
-{
- EjsProperty *pp;
- EjsVar *saveThis, *prototype;
- int saveThisPerm, rc, fid;
-
- mprAssert(ep);
-
- rc = 0;
- fid = -1;
- saveThis = 0;
- saveThisPerm = 0;
- prototype = proc->fn;
-
- if (prototype == 0) {
- ejsError(ep, EJS_EVAL_ERROR, "Undefined method");
- return EJS_STATE_ERR;
- }
-
- if (prototype->type == EJS_TYPE_OBJECT) {
- prototype = ejsGetPropertyAsVar(ep, prototype, proc->procName);
- }
-
- if (prototype) {
- /*
- * Create a new variable stack frame. ie. new local variables.
- * Some C methods (eg. include) don't create a new local context.
- */
- if (! (prototype->flags & EJS_NO_LOCAL)) {
- fid = ejsOpenBlock(ep);
- if (fid < 0) {
- return EJS_STATE_ERR;
- }
- mprAssert(ejsBlockInUse(ep->local));
-
- pp = ejsSetProperty(ep, ep->local, "this", obj);
- ejsMakePropertyEnumerable(pp, 0);
-
- /*
- * Optimization. Save "this" during this block.
- */
- saveThis = ep->thisObject;
- ep->thisObject = ejsGetVarPtr(pp);
- saveThisPerm = ejsMakeObjPermanent(saveThis, 1);
- }
-
- switch (prototype->type) {
- default:
- mprAssert(0);
- break;
-
- case EJS_TYPE_STRING_CMETHOD:
- rc = callStringCMethod(ep, obj, proc, prototype);
- break;
-
- case EJS_TYPE_CMETHOD:
- rc = callCMethod(ep, obj, proc, prototype);
- break;
-
- case EJS_TYPE_METHOD:
- rc = callMethod(ep, obj, proc, prototype);
- break;
- }
-
- if (fid >= 0) {
- ejsMakeObjPermanent(saveThis, saveThisPerm);
- ep->thisObject = saveThis;
- mprAssert(ejsBlockInUse(ep->local));
- mprAssert(ejsBlockInUse(ep->thisObject));
- ejsCloseBlock(ep, fid);
- }
- }
-
- return rc;
-}
-
-/******************************************************************************/
-/*
- * Create a new object and call all required constructors.
- * obj may be null in which case we look globally for className.
- */
-
-EjsVar *ejsCreateObjUsingArgvInternal(EJS_LOC_DEC(ep, loc), EjsVar *obj,
- const char *className, MprArray *args)
-{
- EjsVar *baseClass, *objectClass, *thisObj;
- int rc;
-
- mprAssert(className && *className);
-
- /*
- * Create a new object of the required class and pass it into the
- * constructor as the "this" local variable.
- */
- baseClass = ejsGetClass(ep, obj, className);
- if (baseClass == 0) {
-
- if (obj && obj->objectState->className &&
- strcmp(obj->objectState->className, className) == 0) {
- /*
- * Handle case where we are calling the constructor inside
- * the class. In this case, obj == baseClass.
- */
- thisObj = ejsCreateSimpleObjUsingClassInt(EJS_LOC_PASS(ep, loc),
- obj);
-
- } else {
-
- /*
- * If the baseClass does not exist, try to create an Object
- * We do this for compatibility with JS 1.5 style new Function.
- * MOB -- but this masks an error if we really need className.
- */
- objectClass = ejsGetClass(ep, 0, "Object");
- thisObj = ejsCreateSimpleObjUsingClassInt(EJS_LOC_PASS(ep, loc),
- objectClass);
- }
-
- } else {
- thisObj = ejsCreateSimpleObjUsingClassInt(EJS_LOC_PASS(ep, loc),
- baseClass);
- }
-
- if (thisObj == 0) {
- ejsMemoryError(ep);
- return 0;
- }
-
- /*
- * Make the object permanent. While currently not alive, the constructor
- * below may make the object alive.
- */
- ejsMakeObjPermanent(thisObj, 1);
- mprAssert(! ejsObjIsCollectable(thisObj));
-
- rc = 0;
- if (baseClass) {
- if (! baseClass->objectState->noConstructor) {
- rc = callConstructor(ep, thisObj, baseClass, args);
- }
- } else {
- /*
- * className is the function name when calling new on functions
- */
- rc = ejsRunMethod(ep, thisObj, className, args);
- }
-
- /*
- * Constructor may change the type to a non-object.
- * Function() does this. Ensure object is not collectable yet.
- */
- if (ejsVarIsObject(thisObj)) {
- ejsMakeObjPermanent(thisObj, 0);
- ejsMakeObjLive(thisObj, 0);
- }
-
- if (rc < 0) {
- if (rc == MPR_ERR_NOT_FOUND) {
- /* No constructor (default) */
- return thisObj;
- }
- if (! (ep->flags & EJS_FLAGS_EXIT)) {
- if (! ep->gotException) {
- ejsMemoryError(ep);
- }
- }
- ejsFreeVar(ep, thisObj);
- return 0;
- }
-
- mprAssert(ejsBlockInUse(thisObj));
-
- return thisObj;
-}
-
-/******************************************************************************/
-/*
- * Local vars
- */
-
-typedef struct CallCons {
- EjsVar *subClassConstructor, *subClass, *method;
-} CallCons;
-
-/*
- * Create a new object and call all required constructors.
- */
-
-static int callConstructor(Ejs *ep, EjsVar *thisObj, EjsVar *baseClass,
- MprArray *args)
-{
- CallCons *sp;
- int state;
-
- if ((sp = pushFrame(ep, sizeof(CallCons))) == 0) {
- return EJS_STATE_ERR;
- }
-
- mprAssert(baseClass);
- mprAssert(baseClass->objectState);
-
- state = 0;
-
- /*
- * method will be null if there is no constructor for this class
- */
- sp->method = ejsGetPropertyAsVar(ep, baseClass,
- baseClass->objectState->className);
-
- if (sp->method == 0 || !ejsVarIsMethod(sp->method) ||
- !sp->method->callsSuper) {
- /*
- * Invoke base class constructors in reverse order (RECURSIVE)
- */
- sp->subClass = baseClass->objectState->baseClass;
- if (sp->subClass) {
-
- /*
- * Note that the Object class does not have a constructor for
- * speed. Construction for the base Object is done via
- * ejsCreateObj above. The code below will invoke constructors
- * in the right order (bottom up) via recursion. MOB -- need to
- * scan for super() MOB -- Bug. Fails poorly if no constructor.
- * Should allows this and invoke a default constructor.
- */
- sp->subClassConstructor = ejsGetPropertyAsVar(ep, sp->subClass,
- sp->subClass->objectState->className);
-
- if (sp->subClassConstructor) {
-
- if (callConstructor(ep, thisObj, sp->subClass, 0) < 0) {
- if (! ep->gotException) {
- ejsMemoryError(ep);
- }
- goto err;
- }
- }
- }
- }
-
- if (sp->method) {
- /*
- * Finally, invoke the constructor for this class itself.
- */
- state = runMethod(ep, thisObj, sp->method,
- baseClass->objectState->className, args);
- }
-
-done:
- popFrame(ep, sizeof(CallCons));
- return state;
-
-err:
- state = EJS_STATE_ERR;
- goto done;
-}
-
-/******************************************************************************/
-/*
- * Create a new object and call all required constructors using string args.
- * MOB -- would be good to parse constructorArgs for "," and break into
- * separate args.
- * Returned object is not yet collectable. Will have alive bit cleared.
- */
-
-EjsVar *ejsCreateObj(Ejs *ep, EjsVar *obj, const char *className,
- const char *constructorArgs)
-{
- MprArray *args;
- EjsVar *newp, *vp;
-
- args = mprCreateItemArray(ep, 0, 0);
- if (args == 0) {
- return 0;
- }
-
- if (constructorArgs && *constructorArgs) {
- vp = ejsCreateStringVarInternal(EJS_LOC_ARGS(ep), constructorArgs);
-
- if (mprAddItem(args, vp) < 0) {
- mprFree(args);
- return 0;
- }
- }
-
- newp = ejsCreateObjUsingArgv(ep, obj, className, args);
-
- ejsFreeMethodArgs(ep, args);
-
- mprAssert(! ejsObjIsCollectable(newp));
- mprAssert(ejsBlockInUse(newp));
-
- return newp;
-}
-
-/******************************************************************************/
-
-static int callStringCMethod(Ejs *ep, EjsVar *obj, EjsProc *proc,
- EjsVar *prototype)
-{
- EjsVar **argValues;
- MprArray *actualArgs;
- char **argBuf, *str;
- int i, rc;
-
- actualArgs = proc->args;
- argValues = (EjsVar**) actualArgs->items;
-
- if (actualArgs->length > 0) {
- argBuf = mprAlloc(ep, actualArgs->length * sizeof(char*));
- for (i = 0; i < actualArgs->length; i++) {
- str = ejsVarToString(ep, argValues[i]);
- /* MOB rc */
- argBuf[i] = mprStrdup(ep, str);
- }
- } else {
- argBuf = 0;
- }
-
- /*
- * Call the method depending on the various handle flags
- */
- ep->userData = prototype->cMethodWithStrings.userData;
- if (prototype->flags & EJS_ALT_HANDLE) {
- /*
- * Used by the AppWeb GaCompat module. The alt handle is set to the
- * web server request struct
- */
- rc = ((EjsAltStringCMethod)
- prototype->cMethodWithStrings.fn)
- (ep, ep->altHandle, obj, actualArgs->length, argBuf);
-
- } else if (prototype->flags & EJS_PRIMARY_HANDLE) {
- /*
- * Used by ESP. The primary handle is set to the esp struct
- */
- rc = (prototype->cMethodWithStrings.fn)(ep->primaryHandle,
- obj, actualArgs->length, argBuf);
-
- } else {
- /*
- * Used EJS for the standard procs
- */
- rc = (prototype->cMethodWithStrings.fn)(ep, obj, actualArgs->length,
- argBuf);
- }
-
- if (actualArgs->length > 0) {
- for (i = 0; i < actualArgs->length; i++) {
- mprFree(argBuf[i]);
- }
- mprFree(argBuf);
- }
- ep->userData = 0;
-
- return rc;
-}
-
-/******************************************************************************/
-
-static int callCMethod(Ejs *ep, EjsVar *obj, EjsProc *proc, EjsVar *prototype)
-{
- EjsVar **argValues;
- MprArray *actualArgs;
- int rc;
-
- actualArgs = proc->args;
- argValues = (EjsVar**) actualArgs->items;
-
- ep->userData = prototype->cMethod.userData;
-
- /*
- * Call the method depending on the various handle flags
- * Sometimes cMethod.fn is NULL if there is no constructor for
- * an object.
- */
- if (prototype->flags & EJS_ALT_HANDLE) {
- /*
- * Use by the GaCompat module. The alt handle is set to the
- * web server request struct
- */
- rc = ((EjsAltCMethod) prototype->cMethod.fn)
- (ep, ep->altHandle, obj, actualArgs->length, argValues);
-
- } else if (prototype->flags & EJS_PRIMARY_HANDLE) {
- /*
- * Used by ESP. The primary handle is set to the esp struct
- */
- rc = (prototype->cMethod.fn)
- (ep->primaryHandle, obj, actualArgs->length, argValues);
-
- } else {
- /*
- * Used EJS for the standard procs
- */
- rc = (prototype->cMethod.fn)(ep, obj, actualArgs->length, argValues);
- }
-
- ep->userData = 0;
-
- return rc;
-}
-
-/******************************************************************************/
-/*
- * Local vars
- */
-
-typedef struct CallMethod {
- MprArray *formalArgs, *actualArgs;
- EjsVar *arguments, *callee, **argValues;
- char **argNames, buf[16];
- int i, argumentsObj;
-} CallMethod;
-
-
-static int callMethod(Ejs *ep, EjsVar *obj, EjsProc *proc, EjsVar *prototype)
-{
- CallMethod *sp;
- int i;
-
- if ((sp = pushFrame(ep, sizeof(CallMethod))) == 0) {
- return EJS_STATE_ERR;
- }
-
- sp->arguments = 0;
- sp->callee = 0;
-
- sp->actualArgs = proc->args;
- sp->argValues = (EjsVar**) sp->actualArgs->items;
- sp->formalArgs = prototype->method.args;
- sp->argNames = (char**) sp->formalArgs->items;
-
- /*
- * Only create arguments and callee if the function actually uses them
- */
- sp->argumentsObj = 0;
- if (strstr(prototype->method.body, "arguments") != 0) {
- sp->argumentsObj++;
-
- /*
- * Create the arguments and callee variables
- * MOB -- should we make real arrays here ? YES
- */
- sp->arguments = ejsCreateSimpleObj(ep, "Object");
- ejsSetVarName(ep, sp->arguments, "arguments");
- mprAssert(! ejsObjIsCollectable(sp->arguments));
-
- sp->callee = ejsCreateSimpleObj(ep, "Object");
- ejsSetVarName(ep, sp->callee, "callee");
- mprAssert(! ejsObjIsCollectable(sp->callee));
-
- /*
- * Overwrite the length property
- */
- ejsSetPropertyToInteger(ep, sp->arguments, "length",
- sp->actualArgs->length);
- ejsSetPropertyToInteger(ep, sp->callee, "length",
- sp->formalArgs->length);
- }
-
- /*
- * Define all the agruments to be set to the actual parameters
- */
- for (i = 0; i < sp->formalArgs->length; i++) {
- if (i >= sp->actualArgs->length) {
- /* MOB -- return code */
- ejsCreateProperty(ep, ep->local, sp->argNames[i]);
-
- } else {
- /* MOB -- return code */
- ejsSetProperty(ep, ep->local, sp->argNames[i], sp->argValues[i]);
- }
- }
-
- if (sp->argumentsObj) {
- for (i = 0; i < sp->actualArgs->length; i++) {
- mprItoa(sp->buf, sizeof(sp->buf), i);
- ejsSetProperty(ep, sp->arguments, sp->buf, sp->argValues[i]);
- }
-
- ejsSetPropertyAndFree(ep, sp->arguments, "callee", sp->callee);
- ejsSetPropertyAndFree(ep, ep->local, "arguments", sp->arguments);
- }
-
- /*
- * Actually run the method
- */
-
- i = ejsEvalScript(ep, prototype->method.body, 0);
-
- popFrame(ep, sizeof(CallMethod));
- return i;
-}
-
-/******************************************************************************/
-/*
- * Run a method. Obj is set to "this" object. MethodName must exist in it
- * or in a sub class.
- */
-
-int ejsRunMethod(Ejs *ep, EjsVar *obj, const char *methodName, MprArray *args)
-{
- EjsProperty *pp;
- EjsProc proc, *saveProc;
- int rc;
-
- mprAssert(obj);
- mprAssert(methodName && *methodName);
-
- pp = ejsGetProperty(ep, obj, methodName);
- if (pp == 0) {
- /* MOB -- this should be all in some common accessor routine */
- pp = ejsGetProperty(ep, ep->local, methodName);
- if (pp == 0) {
- pp = ejsGetProperty(ep, ep->global, methodName);
- if (pp == 0) {
- ejsError(ep, EJS_REFERENCE_ERROR,
- "Undefined method \"%s\"", methodName);
- return MPR_ERR_NOT_FOUND;
- }
- }
- }
-
- saveProc = ep->proc;
- ep->proc = &proc;
-
- memset(&proc, 0, sizeof(EjsProc));
-
- ejsClearVar(ep, ep->result);
-
- /* MOB -- if closures are going to work, we need to have proc be an
- Object and let the GC look after it */
-
- proc.fn = &pp->var;
- if (proc.fn == 0 || proc.fn->type == EJS_TYPE_UNDEFINED) {
- ep->proc = saveProc;
- return MPR_ERR_NOT_FOUND;
- }
-
- proc.procName = mprStrdup(ep, methodName);
- if (args == 0) {
- proc.args = mprCreateItemArray(ep, EJS_INC_ARGS, EJS_MAX_ARGS);
- } else {
- proc.args = args;
- }
-
- rc = evalMethod(ep, obj, &proc, 0);
-
- if (args) {
- proc.args = 0;
- }
- freeProc(ep, &proc);
-
- ep->proc = saveProc;
-
- return rc;
-}
-
-/******************************************************************************/
-/*
- * Run a method. Obj is set to "this" object. MethodName must exist in it
- * or in a sub class.
- */
-
-int ejsRunMethodCmd(Ejs *ep, EjsVar *obj, const char *methodName,
- const char *cmdFmt, ...)
-{
- MprArray *args;
- va_list cmdArgs;
- char *buf, *arg, *cp;
- int rc;
-
- mprAssert(methodName && *methodName);
- mprAssert(cmdFmt && *cmdFmt);
-
- va_start(cmdArgs, cmdFmt);
- mprAllocVsprintf(MPR_LOC_ARGS(ep), &buf, 0, cmdFmt, cmdArgs);
- va_end(cmdArgs);
-
- args = mprCreateItemArray(ep, EJS_INC_ARGS, EJS_MAX_ARGS);
-
- for (arg = cp = buf; cp && *cp; cp++) {
- if (*cp == ',') {
- *cp = 0;
- mprAddItem(args, ejsParseVar(ep, arg, 0));
- arg = cp + 1;
- }
- }
- if (cp > arg) {
- mprAddItem(args, ejsParseVar(ep, arg, 0));
- }
-
- rc = ejsRunMethod(ep, obj, methodName, args);
-
- ejsFreeMethodArgs(ep, args);
- mprFree(buf);
-
- return rc;
-}
-
-/******************************************************************************/
-/*
- * Run a method. Obj is set to "this" object.
- */
-
-static int runMethod(Ejs *ep, EjsVar *thisObj, EjsVar *method,
- const char *methodName, MprArray *args)
-{
- EjsProc proc, *saveProc;
- int rc;
-
- mprAssert(thisObj);
- mprAssert(method);
-
- saveProc = ep->proc;
- ep->proc = &proc;
-
- memset(&proc, 0, sizeof(EjsProc));
-
- ejsClearVar(ep, ep->result);
-
- /* MOB -- if closures are going to work, we need to have proc be an
- Object and let the GC look after it */
-
- proc.fn = method;
- if (proc.fn == 0 || proc.fn->type == EJS_TYPE_UNDEFINED) {
- ep->proc = saveProc;
- return MPR_ERR_NOT_FOUND;
- }
-
- proc.procName = mprStrdup(ep, methodName);
- if (args == 0) {
- proc.args = mprCreateItemArray(ep, EJS_INC_ARGS, EJS_MAX_ARGS);
- } else {
- proc.args = args;
- }
-
- rc = evalMethod(ep, thisObj, &proc, 0);
-
- if (args) {
- proc.args = 0;
- }
- freeProc(ep, &proc);
-
- ep->proc = saveProc;
-
- return rc;
-}
-
-/******************************************************************************/
-/*
- * Find which object contains the property given the current context.
- * We call this when there is no explicit object and the object must be
- * determined by the context.
- */
-
-static EjsVar *pickSpace(Ejs *ep, int state, const char *property, int flags)
-{
- EjsVar *obj;
-
- mprAssert(ep);
- mprAssert(property && *property);
-
- /* MOB - this is ugly and the logic is confused */
-
- if (flags & EJS_FLAGS_GLOBAL) {
- obj = ep->global;
-
- } else if (state == EJS_STATE_DEC || flags & EJS_FLAGS_LOCAL) {
- obj = ep->local;
-
- } else {
- /* First look local, then this and finally global */
-
- if (ejsGetSimpleProperty(ep, ep->local, property)) {
- obj = ep->local;
-
- } else if (ep->thisObject &&
- findProperty(ep, ep->thisObject, property, flags)) {
- obj = ep->thisObject;
-
- } else {
-#if EJS_ECMA_STND
- obj = ep->global;
-#else
- if (flags & EJS_FLAGS_EXE &&
- !findProperty(ep, ep->global, property, flags)) {
- obj = ep->local;
- } else {
- obj = ep->global;
- }
-#endif
- }
- }
- return obj;
-}
-
-/******************************************************************************/
-/*
- * Find an object property given a object and a property name. We
- * intelligently look in the local and global namespaces depending on
- * our state. If not found in local or global, try base classes for method
- * names only. Returns the property or NULL.
- * MOB -- need to rework this API.
- */
-
-static EjsProperty *searchSpacesForProperty(Ejs *ep, int state, EjsVar *obj,
- char *property, int flags)
-{
- EjsProperty *pp;
-
- if (obj) {
- return findProperty(ep, obj, property, flags);
- }
-
- /* MOB -- really should have a search stack */
-
- pp = findProperty(ep, ep->local, property, flags);
- if (pp == 0 && state != EJS_STATE_DEC) {
-
- if (ep->thisObject) {
- pp = findProperty(ep, ep->thisObject, property, flags);
- }
- if (pp == 0) {
- pp = findProperty(ep, ep->global, property, flags);
- }
- }
- return pp;
-}
-
-/******************************************************************************/
-/*
- * Search an object and its base classes to find an object given an object
- * an a property name. If not an assignment (LHS), then follow base classes.
- * Otherwise, just look in the specified object.
- */
-
-static EjsProperty *findProperty(Ejs *ep, EjsVar *op, const char *property,
- int flags)
-{
- /* MOB -- NEW. Remove when EXE fixes are in. */
- if (! (flags & EJS_FLAGS_EXE) && op->type == EJS_TYPE_UNDEFINED) {
- return 0;
- }
-
- if (flags & EJS_FLAGS_LHS) {
- return ejsGetPropertyPtr(ejsGetSimpleProperty(ep, op, property));
-
- } else {
- /*
- * Follow base classes
- */
- return ejsGetPropertyPtr(ejsGetProperty(ep, op, property));
- }
-}
-
-/******************************************************************************/
-/*
- * Update result
- */
-
-static void updateResult(Ejs *ep, int state, int flags, EjsVar *vp)
-{
- if (flags & EJS_FLAGS_EXE && state != EJS_STATE_DEC) {
- ejsClearVar(ep, ep->result);
- if (vp) {
- ejsWriteVar(ep, ep->result, vp, EJS_SHALLOW_COPY);
- ejsSetVarName(ep, ep->result, vp->propertyName);
- }
- }
-}
-
-/******************************************************************************/
-/*
- * Append to the pointer value
- */
-
-int ejsStrcat(Ejs *ep, EjsVar *dest, EjsVar *src)
-{
- char *oldBuf, *buf, *str;
- int oldLen, newLen, len;
-
- mprAssert(dest);
- mprAssert(ejsVarIsString(src));
-
- if (ejsVarIsValid(dest)) {
-
- if (! ejsVarIsString(dest)) {
- /* Bad type for dest */
- return -1;
- }
-
- if (! ejsVarIsString(src)) {
- str = ejsVarToString(ep, src);
- if (str == 0) {
- return -1;
- }
- len = strlen(str);
-
- } else {
- str = src->string;
- len = src->length;
- }
-
- oldBuf = dest->string;
- oldLen = dest->length;
- newLen = oldLen + len + 1;
-
- if (newLen < MPR_SLAB_STR_MAX) {
- buf = oldBuf;
- } else {
- buf = mprRealloc(ep, oldBuf, newLen);
- if (buf == 0) {
- return -1;
- }
- dest->string = buf;
- }
- memcpy(&buf[oldLen], str, len);
- dest->length += len;
-
- } else {
- ejsWriteVarAsString(ep, dest, src->string);
- }
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Exit the script
- */
-
-void ejsExit(Ejs *ep, int status)
-{
- ep->scriptStatus = status;
- ep->flags |= EJS_FLAGS_EXIT;
-}
-
-/******************************************************************************/
-/*
- * Free an argument list
- */
-
-static void freeProc(Ejs *ep, EjsProc *proc)
-{
- if (proc->args) {
- ejsFreeMethodArgs(ep, proc->args);
- }
-
- if (proc->procName) {
- mprFree(proc->procName);
- proc->procName = NULL;
- }
-}
-
-/******************************************************************************/
-
-void ejsFreeMethodArgs(Ejs *ep, MprArray *args)
-{
- int i;
-
- for (i = args->length - 1; i >= 0; i--) {
- ejsFreeVar(ep, args->items[i]);
- mprRemoveItemByIndex(args, i);
- }
- mprFree(args);
-}
-
-/******************************************************************************/
-/*
- * This method removes any new lines. Used for else cases, etc.
- */
-
-static void removeNewlines(Ejs *ep, int state)
-{
- int tid;
-
- do {
- tid = ejsLexGetToken(ep, state);
- } while (tid == EJS_TOK_NEWLINE);
-
- ejsLexPutbackToken(ep, tid, ep->token);
-}
-
-/******************************************************************************/
-
-static int getNextNonSpaceToken(Ejs *ep, int state)
-{
- int tid;
-
- do {
- tid = ejsLexGetToken(ep, state);
- } while (tid == EJS_TOK_NEWLINE);
- return tid;
-}
-
-/******************************************************************************/
-
-int ejsGetFlags(Ejs *ep)
-{
- return ep->flags;
-}
-
-/******************************************************************************/
-
-bool ejsIsExiting(Ejs *ep)
-{
- return (ep->flags & EJS_FLAGS_EXIT) ? 1: 0;
-}
-
-/******************************************************************************/
-
-void ejsClearExiting(Ejs *ep)
-{
- ep->flags &= ~EJS_FLAGS_EXIT;
-}
-
-/******************************************************************************/
-
-static EjsInput *getInputStruct(Ejs *ep)
-{
- EjsInput *input;
-
- if (ep->inputList) {
- input = ep->inputList;
- ep->inputList = input->nextInput;
-
- } else {
- input = mprAlloc(ep, sizeof(EjsInput));
- }
- return input;
-}
-
-/******************************************************************************/
-
-static void freeInputStruct(Ejs *ep, EjsInput *input)
-{
- input->nextInput = ep->inputList;
- ep->inputList = input;
-}
-
-/******************************************************************************/
-
-static void *pushFrame(Ejs *ep, int size)
-{
- /*
- * Grow down stack
- */
- ep->stkPtr -= size;
- if (ep->stkPtr < ep->stack) {
- mprError(ep, MPR_LOC, "Exceeded parse stack");
- return 0;
- }
- return ep->stkPtr;
-}
-
-/******************************************************************************/
-
-static void *popFrame(Ejs *ep, int size)
-{
- ep->stkPtr += size;
- if (ep->stkPtr > &ep->stack[EJS_MAX_STACK]) {
- mprError(ep, MPR_LOC, "Over poped parse stack");
- return 0;
- }
- return ep->stkPtr;
-}
-
-/******************************************************************************/
-#else
-void ejsParserDummy() {}
-
-/******************************************************************************/
-#endif /* BLD_FEATURE_EJS */
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/**
- * @file ejsVar.c
- * @brief Mbedthis Portable Runtime Universal Variable Type
- */
-
-/*
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- * Copyright (c) Michael O'Brien, 1994-1995. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-
-/******************************* Documentation ********************************/
-
-/*
- * This module is NOT multithreaded.
- *
- * Properties are variables that are stored in an object type variable.
- * Properties can be primitive data types, other objects or methods.
- * Properties are indexed by a character name.
- */
-
-/********************************** Includes **********************************/
-
-#include "ejs.h"
-
-/***************************** Forward Declarations ***************************/
-
-static EjsProperty *allocProperty(Ejs *ep, EjsVar *op, const char *property,
- int propertyIndex, EjsProperty *last);
-static EjsVar *copyVar(EJS_LOC_DEC(ep, loc), EjsVar *dest,
- const EjsVar *src, EjsCopyDepth copyDepth);
-static EjsObj *createObj(EJS_LOC_DEC(ep, loc));
-static char *getNextVarToken(char **next, char *tokBuf, int tokBufLen);
-static int hash(const char *property);
-static void unlinkProperty(EjsObj *obj, EjsPropLink *propLink);
-static void linkPropertyBefore(EjsObj *obj, EjsPropLink *at,
- EjsPropLink *propLink);
-static int sortAllProperties(Ejs *ep, EjsProperty *p1,
- EjsProperty *p2, const char *propertyName, int order);
-static int sortByProperty(Ejs *ep, EjsProperty *p1, EjsProperty *p2,
- const char *propertyName, int order);
-static int dupString(MPR_LOC_DEC(ctx, loc), uchar **dest,
- const void *src, int nbytes);
-#if UNUSED && KEEP
-static void linkPropertyAfter(EjsObj *obj, EjsPropLink *at,
- EjsPropLink *propLink);
-#endif
-
-static EjsProperty *hashLookup(EjsObj *obj, const char *property,
- int *propertyIndex, EjsProperty **hashTail);
-
-/******************************************************************************/
-/********************************** Var Routines ******************************/
-/******************************************************************************/
-
-EjsType ejsGetVarType(EjsVar *vp)
-{
- mprAssert(vp);
-
- return vp->type;
-}
-
-/******************************************************************************/
-
-void ejsFreeVar(Ejs *ep, EjsVar *vp)
-{
- if (vp) {
- ejsClearVar(ep, vp);
- ejsFree(ep, vp, EJS_SLAB_VAR);
- }
-}
-
-/******************************************************************************/
-#if UNUSED
-/*
- * Clear the value by freeing any allocated data. This will release objects
- * so that later garbage collection can reclaim storage if there are no other
- * object references.
- */
-
-void ejsZeroVar(Ejs *ep, EjsVar *vp)
-{
- vp->type = EJS_TYPE_UNDEFINED;
- vp->objectState = 0;
- vp->method.body = 0;
- vp->method.args = 0;
- vp->callsSuper = 0;
- vp->ptr.destructor = 0;
- vp->allocatedData = 0;
-}
-
-#endif
-/******************************************************************************/
-/*
- * Clear the value by freeing any allocated data. This will release objects
- * so that later garbage collection can reclaim storage if there are no other
- * object references.
- */
-
-void ejsClearVar(Ejs *ep, EjsVar *vp)
-{
- MprArray *argList;
- int i;
-
- mprAssert(vp);
- mprAssert(ep);
-
- if (! vp->allocatedData) {
- vp->type = EJS_TYPE_UNDEFINED;
- return;
- }
- if (vp->type == EJS_TYPE_UNDEFINED) {
- return;
- }
-
- switch (vp->type) {
- default:
- break;
-
- case EJS_TYPE_STRING:
- mprFree(vp->string);
- vp->string = 0;
- break;
-
- case EJS_TYPE_OBJECT:
- /*
- * Set the "alive" bit so that the GC will cleanup if no
- * other references.
- */
- if (vp->objectState) {
- vp->objectState->alive = 1;
- }
- vp->objectState = 0;
- break;
-
- case EJS_TYPE_METHOD:
- argList = vp->method.args;
- /*
- * MOB OPT -- should be able to do just one mprFree(vp->method.args)
- */
- mprFree(vp->method.body);
- if (argList) {
- for (i = 0; i < argList->length; i++) {
- mprFree(argList->items[i]);
- }
- mprFree(vp->method.args);
- }
- vp->method.args = 0;
- vp->method.body = 0;
- vp->callsSuper = 0;
- break;
-
- case EJS_TYPE_PTR:
- if (vp->ptr.destructor) {
- (vp->ptr.destructor)(ep, vp);
- }
- break;
- }
-
- vp->type = EJS_TYPE_UNDEFINED;
- vp->allocatedData = 0;
-}
-
-/******************************************************************************/
-/*
- * Initialize an undefined value.
- */
-
-EjsVar *ejsCreateUndefinedVar(Ejs *ep)
-{
- EjsVar *vp;
-
- mprAssert(ep);
-
- vp = ejsAllocVar(EJS_LOC_ARGS(ep));
- if (vp) {
- vp->type = EJS_TYPE_UNDEFINED;
- }
- return vp;
-}
-
-/******************************************************************************/
-/*
- * Initialize an null value.
- */
-
-EjsVar *ejsCreateNullVar(Ejs *ep)
-{
- EjsVar *vp;
-
- mprAssert(ep);
-
- vp = ejsAllocVar(EJS_LOC_ARGS(ep));
- if (vp) {
- vp->type = EJS_TYPE_NULL;
- }
- return vp;
-}
-
-/******************************************************************************/
-
-EjsVar *ejsCreateBoolVar(Ejs *ep, int value)
-{
- EjsVar *vp;
-
- mprAssert(ep);
-
- vp = ejsAllocVar(EJS_LOC_ARGS(ep));
- if (vp) {
- vp->type = EJS_TYPE_BOOL;
- vp->boolean = value;
- }
- return vp;
-}
-
-/******************************************************************************/
-/*
- * Initialize a C method.
- */
-
-EjsVar *ejsCreateCMethodVar(Ejs *ep, EjsCMethod fn, void *userData, int flags)
-{
- EjsVar *vp;
-
- mprAssert(ep);
-
- vp = ejsAllocVar(EJS_LOC_ARGS(ep));
- if (vp) {
- vp->type = EJS_TYPE_CMETHOD;
- vp->cMethod.fn = fn;
- vp->cMethod.userData = userData;
- vp->flags = flags;
- }
- return vp;
-}
-
-/******************************************************************************/
-/*
- * Initialize a C method.
- */
-
-EjsVar *ejsCreateStringCMethodVar(Ejs *ep, EjsStringCMethod fn,
- void *userData, int flags)
-{
- EjsVar *vp;
-
- mprAssert(ep);
- mprAssert(fn);
-
- vp = ejsAllocVar(EJS_LOC_ARGS(ep));
- if (vp) {
- vp->type = EJS_TYPE_STRING_CMETHOD;
- vp->cMethodWithStrings.fn = fn;
- vp->cMethodWithStrings.userData = userData;
- vp->flags = flags;
- }
- return vp;
-}
-
-/******************************************************************************/
-/*
- * Initialize an opaque pointer.
- */
-
-EjsVar *ejsCreatePtrVar(Ejs *ep, void *ptr, EjsDestructor destructor)
-{
- EjsVar *vp;
-
- mprAssert(ep);
- mprAssert(ptr);
-
- vp = ejsAllocVar(EJS_LOC_ARGS(ep));
- if (vp) {
- vp->type = EJS_TYPE_PTR;
- vp->ptr.userPtr = ptr;
- vp->ptr.destructor = destructor;
- vp->allocatedData = 1;
- }
- return vp;
-}
-
-/******************************************************************************/
-#if BLD_FEATURE_FLOATING_POINT
-/*
- * Initialize a floating value.
- */
-
-EjsVar *ejsCreateFloatVar(Ejs *ep, double value)
-{
- EjsVar *vp;
-
- mprAssert(ep);
-
- vp = ejsAllocVar(EJS_LOC_ARGS(ep));
- if (vp) {
- vp->type = EJS_TYPE_FLOAT;
- vp->floating = value;
- }
- return vp;
-}
-
-#endif
-/******************************************************************************/
-/*
- * Initialize an integer value.
- */
-
-EjsVar *ejsCreateIntegerVar(Ejs *ep, int value)
-{
- EjsVar *vp;
-
- mprAssert(ep);
-
- vp = ejsAllocVar(EJS_LOC_ARGS(ep));
- if (vp) {
- vp->type = EJS_TYPE_INT;
- vp->integer = value;
- }
- return vp;
-}
-
-/******************************************************************************/
-#if BLD_FEATURE_INT64
-/*
- * Initialize a 64-bit integer value.
- */
-
-EjsVar *ejsCreateInteger64Var(Ejs *ep, int64 value)
-{
- EjsVar *vp;
-
- mprAssert(ep);
-
- vp = ejsAllocVar(EJS_LOC_ARGS(ep));
- if (vp) {
- vp->type = EJS_TYPE_INT64;
- vp->integer64 = value;
- }
- return vp;
-}
-
-#endif /* BLD_FEATURE_INT64 */
-/******************************************************************************/
-/*
- * Initialize an number variable. Type is defined by configure.
- */
-
-EjsVar *ejsCreateNumberVar(Ejs *ep, EjsNum value)
-{
- EjsVar *vp;
-
- mprAssert(ep);
-
- vp = ejsAllocVar(EJS_LOC_ARGS(ep));
- mprAssert(vp);
-
- if (vp) {
- vp->type = BLD_FEATURE_NUM_TYPE_ID;
-#if BLD_FEATURE_NUM_TYPE_ID == EJS_TYPE_INT64
- vp->integer64 = value;
-#elif BLD_FEATURE_NUM_TYPE_ID == EJS_TYPE_FLOAT
- vp->float = value;
-#else
- vp->integer = value;
-#endif
- }
- return vp;
-}
-
-/******************************************************************************/
-/*
- * Initialize a (bare) JavaScript method. args and body can be null.
- */
-
-EjsVar *ejsCreateMethodVar(Ejs *ep, const char *body, MprArray *args, int flags)
-{
- EjsVar *vp;
- int i;
-
- mprAssert(ep);
-
- vp = ejsAllocVar(EJS_LOC_ARGS(ep));
- mprAssert(vp);
-
- if (vp == 0) {
- return 0;
- }
-
- vp->type = EJS_TYPE_METHOD;
-
- vp->allocatedData = 1;
-
- vp->method.args = mprCreateItemArray(ep, EJS_INC_ARGS, EJS_MAX_ARGS);
- if (vp->method.args == 0) {
- mprAssert(vp->method.args);
- ejsFreeVar(ep, vp);
- return 0;
- }
-
- if (args) {
- for (i = 0; i < args->length; i++) {
- mprAddItem(vp->method.args,
- mprStrdup(vp->method.args, mprGetItem(args, i)));
- }
- }
- vp->method.body = mprStrdup(vp->method.args, body);
-
- if (vp->method.body == 0) {
- ejsFreeVar(ep, vp);
- return 0;
- }
- vp->flags = flags;
-
- return vp;
-}
-
-/******************************************************************************/
-/*
- * Initialize an object variable.
- */
-
-EjsVar *ejsCreateObjVarInternal(EJS_LOC_DEC(ep, loc))
-{
- EjsVar *vp;
-
- mprAssert(ep);
-
- vp = ejsAllocVar(EJS_LOC_PASS(ep, loc));
- mprAssert(vp);
-
- if (vp) {
- vp->type = EJS_TYPE_OBJECT;
- vp->objectState = createObj(EJS_LOC_PASS(ep, loc));
- if (vp->objectState == 0) {
- ejsFreeVar(ep, vp);
- return 0;
- }
- vp->allocatedData = 1;
- }
- return vp;
-}
-
-/******************************************************************************/
-/*
- * Initialize a string value.
- */
-
-EjsVar *ejsCreateStringVarInternal(EJS_LOC_DEC(ep, loc), const char *value)
-{
- EjsVar *vp;
-
- mprAssert(ep);
-
- vp = ejsAllocVar(EJS_LOC_PASS(ep, loc));
- mprAssert(vp);
-
- if (vp) {
- vp->type = EJS_TYPE_STRING;
- vp->string = mprStrdupInternal(EJS_LOC_PASS(ep, loc), value);
- if (vp->string == 0) {
- ejsFreeVar(ep, vp);
- return 0;
- }
- vp->length = strlen(vp->string);
- vp->allocatedData = 1;
- }
- return vp;
-}
-
-/******************************************************************************/
-/*
- * Initialize a binary string value.
- */
-
-EjsVar *ejsCreateBinaryStringVar(Ejs *ep, const uchar *value, int len)
-{
- EjsVar *vp;
-
- mprAssert(ep);
-
- vp = ejsAllocVar(EJS_LOC_ARGS(ep));
- if (vp) {
- vp->type = EJS_TYPE_STRING;
- vp->length = dupString(MPR_LOC_ARGS(ep), &vp->ustring, value, len);
- if (vp->length < 0) {
- ejsFreeVar(ep, vp);
- return 0;
- }
- vp->allocatedData = 1;
- }
- return vp;
-}
-
-/******************************************************************************/
-
-void ejsSetClassName(Ejs *ep, EjsVar *vp, const char *name)
-{
- EjsObj *obj;
-
- if (vp == 0 || !ejsVarIsObject(vp) || vp->objectState == 0) {
- mprAssert(0);
- return;
- }
- obj = vp->objectState;
-
- if (obj->className) {
- mprFree(obj->className);
- }
- obj->className = mprStrdup(ep, name);
-}
-
-/******************************************************************************/
-
-EjsVar *ejsDupVarInternal(EJS_LOC_DEC(ep, loc), EjsVar *src,
- EjsCopyDepth copyDepth)
-{
- EjsVar *vp;
-
- vp = ejsAllocVar(EJS_LOC_PASS(ep, loc));
- if (vp == 0) {
- return 0;
- }
-
- vp->type = EJS_TYPE_UNDEFINED;
-
- return copyVar(EJS_LOC_PASS(ep, loc), vp, src, copyDepth);
-}
-
-/******************************************************************************/
-/*
- * Set a var to a new value
- */
-
-EjsVar *ejsWriteVarInternal(EJS_LOC_DEC(ep, loc), EjsVar *dest,
- const EjsVar *src, EjsCopyDepth copyDepth)
-{
- mprAssert(dest);
- mprAssert(src);
-
- return copyVar(EJS_LOC_PASS(ep, loc), dest, src, copyDepth);
-}
-
-/******************************************************************************/
-/*
- * Set a var using a new bool value
- */
-
-EjsVar *ejsWriteVarAsBoolean(Ejs *ep, EjsVar *dest, int value)
-{
- mprAssert(dest);
-
- if (dest->type != EJS_TYPE_UNDEFINED) {
- ejsClearVar(ep, dest);
- }
-
- dest->type = EJS_TYPE_BOOL;
- dest->boolean = value;
- dest->allocatedData = 0;
- dest->flags = 0;
-
- return dest;
-}
-
-/******************************************************************************/
-/*
- * Set a var using a new C Method
- */
-
-EjsVar *ejsWriteVarAsCMethod(Ejs *ep, EjsVar *dest, EjsCMethod fn,
- void *userData, int flags)
-{
- mprAssert(dest);
-
- if (dest->type != EJS_TYPE_UNDEFINED) {
- ejsClearVar(ep, dest);
- }
-
- dest->type = EJS_TYPE_CMETHOD;
- dest->cMethod.fn = fn;
- dest->cMethod.userData = userData;
- dest->flags = flags;
- dest->allocatedData = 0;
-
- return dest;
-}
-
-/******************************************************************************/
-#if BLD_FEATURE_FLOATING_POINT
-/*
- * Set a var using a new float value
- */
-
-EjsVar *ejsWriteVarAsFloat(Ejs *ep, EjsVar *dest, double value)
-{
- mprAssert(dest);
-
- if (dest->type != EJS_TYPE_UNDEFINED) {
- ejsClearVar(ep, dest);
- }
-
- dest->type = EJS_TYPE_FLOAT;
- dest->floating = value;
- dest->allocatedData = 0;
- dest->flags = 0;
-
- return dest;
-}
-
-#endif
-/******************************************************************************/
-/*
- * Set a var using a new integer value
- */
-
-EjsVar *ejsWriteVarAsInteger(Ejs *ep, EjsVar *dest, int value)
-{
- mprAssert(dest);
-
- if (dest->type != EJS_TYPE_UNDEFINED) {
- ejsClearVar(ep, dest);
- }
-
- dest->type = EJS_TYPE_INT;
- dest->integer = value;
- dest->allocatedData = 0;
- dest->flags = 0;
-
- return dest;
-}
-
-/******************************************************************************/
-#if BLD_FEATURE_INT64
-/*
- * Set a var using a new integer value
- */
-
-EjsVar *ejsWriteVarAsInteger64(Ejs *ep, EjsVar *dest, int64 value)
-{
- mprAssert(dest);
-
- if (dest->type != EJS_TYPE_UNDEFINED) {
- ejsClearVar(ep, dest);
- }
-
- dest->type = EJS_TYPE_INT64;
- dest->integer64 = value;
- dest->allocatedData = 0;
- dest->flags = 0;
-
- return dest;
-}
-
-#endif
-/******************************************************************************/
-/*
- * Set a var using a new Method
- */
-
-EjsVar *ejsWriteVarAsMethod(Ejs *ep, EjsVar *dest, const char *body,
- MprArray *args)
-{
- EjsVar **srcArgs, *arg;
- int i;
-
- mprAssert(ep);
- mprAssert(dest);
- mprAssert(body);
-
- if (dest->type != EJS_TYPE_UNDEFINED) {
- ejsClearVar(ep, dest);
- }
-
- dest->method.args = mprCreateItemArray(ep, EJS_INC_ARGS, EJS_MAX_ARGS);
- if (dest->method.args == 0) {
- return 0;
- }
-
- dest->type = EJS_TYPE_METHOD;
-
- if (args) {
- srcArgs = (EjsVar**) args->items;
- for (i = 0; i < args->length; i++) {
- arg = ejsDupVar(ep, srcArgs[i], EJS_SHALLOW_COPY);
- if (arg == 0) {
- return 0;
- }
- if (mprAddItem(dest->method.args, arg) < 0) {
- return 0;
- }
- }
- }
-
- dest->method.body = mprStrdup(dest->method.args, body);
- if (dest->method.body == 0) {
- return 0;
- }
-
- dest->allocatedData = 1;
- dest->flags = 0;
-
- return dest;
-}
-
-/******************************************************************************/
-/*
- * Set a var to null
- */
-
-EjsVar *ejsWriteVarAsNull(Ejs *ep, EjsVar *dest)
-{
- mprAssert(dest);
-
- if (dest->type != EJS_TYPE_UNDEFINED) {
- ejsClearVar(ep, dest);
- }
-
- dest->type = EJS_TYPE_NULL;
- dest->allocatedData = 0;
- dest->flags = 0;
-
- return dest;
-}
-
-/******************************************************************************/
-/*
- * Set a var using a new number value
- */
-
-EjsVar *ejsWriteVarAsNumber(Ejs *ep, EjsVar *dest, EjsNum value)
-{
- mprAssert(dest);
-
- if (dest->type != EJS_TYPE_UNDEFINED) {
- ejsClearVar(ep, dest);
- }
-
- dest->type = EJS_NUM_VAR;
- dest->ejsNumber = value;
- dest->allocatedData = 0;
- dest->flags = 0;
-
- return dest;
-}
-
-/******************************************************************************/
-/*
- * Set a var using a new C Method
- */
-
-EjsVar *ejsWriteVarAsStringCMethod(Ejs *ep, EjsVar *dest, EjsStringCMethod fn,
- void *userData, int flags)
-{
- mprAssert(dest);
-
- if (dest->type != EJS_TYPE_UNDEFINED) {
- ejsClearVar(ep, dest);
- }
-
- dest->type = EJS_TYPE_CMETHOD;
- dest->cMethodWithStrings.fn = fn;
- dest->cMethodWithStrings.userData = userData;
- dest->flags = flags;
- dest->allocatedData = 0;
-
- return dest;
-}
-
-/******************************************************************************/
-/*
- * Set a var using a new string value
- */
-
-EjsVar *ejsWriteVarAsStringInternal(EJS_LOC_DEC(ep, loc), EjsVar *dest,
- const char *value)
-{
- mprAssert(dest);
- mprAssert(value);
-
- if (dest->type != EJS_TYPE_UNDEFINED) {
- ejsClearVar(ep, dest);
- }
-
- dest->string = mprStrdupInternal(EJS_LOC_PASS(ep, loc), value);
- if (dest->string == 0) {
- return 0;
- }
-
- dest->length = strlen(dest->string);
-
- dest->type = EJS_TYPE_STRING;
- dest->allocatedData = 1;
- dest->flags = 0;
-
- return dest;
-}
-
-/******************************************************************************/
-/*
- * Set a var using a new string value
- */
-
-EjsVar *ejsWriteVarAsBinaryString(Ejs *ep, EjsVar *dest, const uchar *value,
- int len)
-{
- mprAssert(dest);
- mprAssert(value);
-
- ejsClearVar(ep, dest);
-
- if (dest->type != EJS_TYPE_UNDEFINED) {
- ejsClearVar(ep, dest);
- }
-
- dest->length = dupString(MPR_LOC_ARGS(ep), &dest->ustring, value, len);
- if (dest->length < 0) {
- return 0;
- }
-
- dest->type = EJS_TYPE_STRING;
- dest->allocatedData = 1;
- dest->flags = 0;
-
- return dest;
-}
-
-/******************************************************************************/
-/*
- * Set a var to undefined
- */
-
-EjsVar *ejsWriteVarAsUndefined(Ejs *ep, EjsVar *dest)
-{
- mprAssert(dest);
-
- if (dest->type != EJS_TYPE_UNDEFINED) {
- ejsClearVar(ep, dest);
- }
-
- dest->type = EJS_TYPE_UNDEFINED;
- dest->allocatedData = 0;
- dest->flags = 0;
-
- return dest;
-}
-
-/******************************************************************************/
-/*
- * Convert a value to a text based representation of its value
- * If you provide a format, you MUST ensure you know the type.
- * Caller must free the result.
- */
-
-char *ejsFormatVar(Ejs *ep, const char *fmt, EjsVar *vp)
-{
- char *buf, *src, *value, *allocValue;
- uchar *ubuf;
- int len;
-
- buf = 0;
- allocValue = 0;
- value = 0;
-
- switch (vp->type) {
- case EJS_TYPE_UNDEFINED:
- value = "undefined";
- break;
-
- case EJS_TYPE_NULL:
- value = "null";
- break;
-
- case EJS_TYPE_PTR:
- if (fmt == NULL || *fmt == '\0') {
- len = mprAllocSprintf(MPR_LOC_ARGS(ep), &buf, 0,
- "[Opaque Pointer %p]", vp->ptr.userPtr);
- } else {
- len = mprAllocSprintf(MPR_LOC_ARGS(ep), &buf, 0, fmt, vp->ptr);
- }
- goto done;
-
- case EJS_TYPE_BOOL:
- value = (vp->boolean) ? "true" : "false";
- break;
-
-#if BLD_FEATURE_FLOATING_POINT
- case EJS_TYPE_FLOAT:
- if (fmt == NULL || *fmt == '\0') {
- fmt = "%f";
- }
- len = mprAllocSprintf(MPR_LOC_ARGS(ep), &buf, 0, fmt, vp->floating);
- goto done;
-#endif
-
- case EJS_TYPE_INT:
- if (fmt == NULL || *fmt == '\0') {
- fmt = "%d";
- }
- mprAllocSprintf(MPR_LOC_ARGS(ep), &buf, 0, fmt, vp->integer);
- goto done;
-
-#if BLD_FEATURE_INT64
- case EJS_TYPE_INT64:
- if (fmt == NULL || *fmt == '\0') {
- fmt = "%Ld";
- }
- mprAllocSprintf(MPR_LOC_ARGS(ep), &buf, 0, fmt, vp->integer64);
- goto done;
-#endif
-
- case EJS_TYPE_CMETHOD:
- value = "[C Method]";
- break;
-
- case EJS_TYPE_STRING_CMETHOD:
- value = "[C StringMethod]";
- break;
-
- case EJS_TYPE_METHOD:
- value = ejsVarToString(ep, vp);
- break;
-
- case EJS_TYPE_OBJECT:
- value = ejsVarToString(ep, vp);
- break;
-
- case EJS_TYPE_STRING:
- src = vp->string;
- mprAssert(src);
-
- if (fmt && *fmt && src) {
- mprAllocSprintf(MPR_LOC_ARGS(ep), &buf, 0, fmt, src);
-
- } else if (src == NULL) {
- buf = mprStrdup(ep, "null");
-
- } else {
- ubuf = (uchar*) buf;
- if (dupString(MPR_LOC_ARGS(ep), &ubuf, src, vp->length) < 0) {
- return mprStrdup(ep, "");
- }
- buf = (char*) ubuf;
- }
- break;
-
- default:
- mprAssert(0);
- }
-
- if (fmt == NULL || *fmt == '\0') {
- len = mprAllocSprintf(MPR_LOC_ARGS(ep), &buf, 0, "%s", value);
- } else {
- len = mprAllocSprintf(MPR_LOC_ARGS(ep), &buf, 0, fmt, value);
- }
-
-done:
- if (allocValue) {
- mprFree(allocValue);
- }
- return buf;
-}
-
-/******************************************************************************/
-/*
- * Convert the variable to a boolean. Only for primitive types.
- */
-
-int ejsVarToBoolean(EjsVar *vp)
-{
- mprAssert(vp);
-
- switch (vp->type) {
- case EJS_TYPE_UNDEFINED:
- case EJS_TYPE_NULL:
- case EJS_TYPE_STRING_CMETHOD:
- case EJS_TYPE_CMETHOD:
- case EJS_TYPE_METHOD:
- return 0;
-
- case EJS_TYPE_OBJECT:
- return (vp->objectState != NULL);
-
- case EJS_TYPE_PTR:
- return (vp->ptr.userPtr != NULL);
-
- case EJS_TYPE_BOOL:
- return vp->boolean;
-
-#if BLD_FEATURE_FLOATING_POINT
- case EJS_TYPE_FLOAT:
- return (vp->floating != 0 && !ejsIsNan(vp->floating));
-#endif
-
- case EJS_TYPE_INT:
- return (vp->integer != 0);
-
-#if BLD_FEATURE_INT64
- case EJS_TYPE_INT64:
- return (vp->integer64 != 0);
-#endif
-
- case EJS_TYPE_STRING:
- return (vp->length > 0);
-#if UNUSED
- if (strcmp(vp->string, "true") == 0 ||
- strcmp(vp->string, "TRUE") == 0) {
- return 1;
-
- } else if (strcmp(vp->string, "false") == 0 ||
- strcmp(vp->string, "FALSE") == 0) {
- return 0;
-
- } else {
- return atoi(vp->string);
- }
-#endif
- }
-
- /* Not reached */
- return 0;
-}
-
-/******************************************************************************/
-#if BLD_FEATURE_FLOATING_POINT
-/*
- * Convert the variable to a floating point number. Only for primitive types.
- */
-
-double ejsVarToFloat(EjsVar *vp)
-{
- mprAssert(vp);
-
- switch (vp->type) {
- case EJS_TYPE_UNDEFINED:
- case EJS_TYPE_NULL:
- case EJS_TYPE_STRING_CMETHOD:
- case EJS_TYPE_CMETHOD:
- case EJS_TYPE_METHOD:
- case EJS_TYPE_OBJECT:
- case EJS_TYPE_PTR:
- return 0;
-
- case EJS_TYPE_BOOL:
- return (vp->boolean) ? 1.0 : 0.0;
-
- case EJS_TYPE_FLOAT:
- return vp->floating;
-
- case EJS_TYPE_INT:
- return (double) vp->integer;
-
-#if BLD_FEATURE_INT64
- case EJS_TYPE_INT64:
- return (double) vp->integer64;
-#endif
-
- case EJS_TYPE_STRING:
- if (vp->length == 0) {
- return 0.0;
- } else {
- return atof(vp->string);
- }
- }
-
- /* Not reached */
- return 0;
-}
-
-#endif
-/******************************************************************************/
-/*
- * Convert the variable to an Integer type. Only works for primitive types.
- */
-
-int ejsVarToInteger(EjsVar *vp)
-{
- mprAssert(vp);
-
- switch (vp->type) {
- case EJS_TYPE_UNDEFINED:
- case EJS_TYPE_NULL:
- case EJS_TYPE_STRING_CMETHOD:
- case EJS_TYPE_CMETHOD:
- case EJS_TYPE_METHOD:
- case EJS_TYPE_OBJECT:
- return 0;
-
- case EJS_TYPE_BOOL:
- return (vp->boolean) ? 1 : 0;
-
-#if BLD_FEATURE_FLOATING_POINT
- case EJS_TYPE_FLOAT:
- if (ejsIsNan(vp->floating)) {
- return 0;
- }
- return (int) vp->floating;
-#endif
-
- case EJS_TYPE_INT:
- return vp->integer;
-
-#if BLD_FEATURE_INT64
- case EJS_TYPE_INT64:
- return (int) vp->integer64;
-#endif
-
- case EJS_TYPE_STRING:
- if (vp->length == 0) {
- return 0;
- } else {
- return ejsParseInteger(vp->string);
- }
- }
-
- /* Not reached */
- return 0;
-}
-
-/******************************************************************************/
-#if BLD_FEATURE_INT64
-/*
- * Convert the variable to an Integer64 type. Only works for primitive types.
- */
-
-int64 ejsVarToInteger64(EjsVar *vp)
-{
- mprAssert(vp);
-
- switch (vp->type) {
- case EJS_TYPE_UNDEFINED:
- case EJS_TYPE_NULL:
- case EJS_TYPE_STRING_CMETHOD:
- case EJS_TYPE_CMETHOD:
- case EJS_TYPE_METHOD:
- case EJS_TYPE_OBJECT:
- case EJS_TYPE_PTR:
- return 0;
-
- case EJS_TYPE_BOOL:
- return (vp->boolean) ? 1 : 0;
-
-#if BLD_FEATURE_FLOATING_POINT
- case EJS_TYPE_FLOAT:
- if (ejsIsNan(vp->floating)) {
- return 0;
- }
- return (int64) vp->floating;
-#endif
-
- case EJS_TYPE_INT:
- return vp->integer;
-
- case EJS_TYPE_INT64:
- return vp->integer64;
-
- case EJS_TYPE_STRING:
- if (vp->length == 0) {
- return 0;
- } else {
- return ejsParseInteger64(vp->string);
- }
- }
-
- /* Not reached */
- return 0;
-}
-
-#endif /* BLD_FEATURE_INT64 */
-/******************************************************************************/
-/*
- * Convert the variable to a number type. Only works for primitive types.
- */
-
-EjsNum ejsVarToNumber(EjsVar *vp)
-{
-#if BLD_FEATURE_NUM_TYPE_ID == EJS_TYPE_INT64
- return ejsVarToInteger64(vp);
-#elif BLD_FEATURE_NUM_TYPE_ID == EJS_TYPE_FLOAT
- return ejsVarToFloat(vp);
-#else
- return ejsVarToInteger(vp);
-#endif
-}
-
-/******************************************************************************/
-/*
- * Convert a var to a string. Store the result in ep->castTemp. If allocated
- * set ep->castAlloc to TRUE. Caller must NOT free the result.
- */
-
-char *ejsVarToString(Ejs *ep, EjsVar *vp)
-{
- MprBuf *bp;
- char numBuf[16];
- int len, i;
-
- if (ep->castAlloc) {
- mprFree(ep->castTemp);
- }
- ep->castTemp = 0;
- ep->castAlloc = 0;
-
- switch (vp->type) {
- case EJS_TYPE_UNDEFINED:
- ep->castTemp = "undefined";
- break;
-
- case EJS_TYPE_NULL:
- ep->castTemp = "null";
- break;
-
- case EJS_TYPE_PTR:
- len = mprAllocSprintf(MPR_LOC_ARGS(ep), &ep->castTemp, 0,
- "[Opaque Pointer %p]", vp->ptr.userPtr);
- ep->castAlloc = 1;
- break;
-
- case EJS_TYPE_BOOL:
- if (vp->boolean) {
- ep->castTemp = "true";
- } else {
- ep->castTemp = "false";
- }
- break;
-
-#if BLD_FEATURE_FLOATING_POINT
- case EJS_TYPE_FLOAT:
- len = mprAllocSprintf(MPR_LOC_ARGS(ep), &ep->castTemp, 0,
- "%f", vp->floating);
- ep->castAlloc = 1;
- break;
-#endif
-
- case EJS_TYPE_INT:
- mprItoa(numBuf, sizeof(numBuf), vp->integer);
- ep->castTemp = mprStrdup(ep, numBuf);
- ep->castAlloc = 1;
- break;
-
-#if BLD_FEATURE_INT64
- case EJS_TYPE_INT64:
- mprAllocSprintf(MPR_LOC_ARGS(ep), &ep->castTemp, 0,
- "%Ld", vp->integer64);
- ep->castAlloc = 1;
- break;
-#endif
-
- case EJS_TYPE_CMETHOD:
- ep->castTemp = "[C Method]";
- break;
-
- case EJS_TYPE_STRING_CMETHOD:
- ep->castTemp = "[C StringMethod]";
- break;
-
- case EJS_TYPE_METHOD:
- bp = mprCreateBuf(ep, 0, 0);
- mprPutStringToBuf(bp, "function (");
- for (i = 0; i < vp->method.args->length; i++) {
- mprPutStringToBuf(bp, vp->method.args->items[i]);
- if ((i + 1) < vp->method.args->length) {
- mprPutStringToBuf(bp, ", ");
- }
- }
- mprPutStringToBuf(bp, ") {");
- mprPutStringToBuf(bp, vp->method.body);
- mprPutStringToBuf(bp, "}");
- mprAddNullToBuf(bp);
- ep->castTemp = mprStealBuf(ep, bp);
- ep->castAlloc = 1;
- mprFree(bp);
- break;
-
- case EJS_TYPE_OBJECT:
- if (ejsRunMethod(ep, vp, "toString", 0) < 0) {
- return mprStrdup(ep, "[object Object]");
- }
- ep->castTemp = mprStrdup(ep, ep->result->string);
- ep->castAlloc = 1;
- break;
-
- case EJS_TYPE_STRING:
- if (vp->string == 0) {
- ep->castTemp = "null";
- } else {
- ep->castTemp = vp->string;
- }
- break;
-
- default:
- mprAssert(0);
- }
-
- mprAssert(ep->castTemp);
- return ep->castTemp;
-}
-
-/******************************************************************************/
-
-char *ejsVarToStringEx(Ejs *ep, EjsVar *vp, bool *alloc)
-{
- char *str;
-
- mprAssert(alloc);
-
- str = ejsVarToString(ep, vp);
- *alloc = ep->castAlloc;
- ep->castAlloc = 0;
- ep->castTemp = 0;
- return str;
-}
-
-/******************************************************************************/
-/*
- * Parse a string based on formatting instructions and intelligently
- * create a variable.
- *
- * Float format: [+|-]DIGITS][DIGITS][(e|E)[+|-]DIGITS]
- */
-
-EjsVar *ejsParseVar(Ejs *ep, const char *buf, EjsType preferredType)
-{
- EjsType type;
- const char *cp;
- int isHex;
-
- mprAssert(buf);
-
- type = preferredType;
-
- if (preferredType == EJS_TYPE_UNDEFINED) {
- isHex = 0;
- if (*buf == '-' || *buf == '+') {
- type = EJS_NUM_VAR;
-
- } else if (!isdigit((int) *buf)) {
- if (strcmp(buf, "true") == 0 || strcmp(buf, "false") == 0) {
- type = EJS_TYPE_BOOL;
- } else {
- type = EJS_TYPE_STRING;
- }
-
- } else if (isdigit((int) *buf)) {
- type = EJS_NUM_VAR;
- cp = buf;
- if (*cp && tolower(cp[1]) == 'x') {
- cp = &cp[2];
- isHex = 1;
- for (cp = buf; *cp; cp++) {
- if (! isxdigit((int) *cp)) {
- break;
- }
- }
- } else {
-#if BLD_FEATURE_FLOATING_POINT
- /* Could be integer or float */
- for (cp = buf; *cp; cp++) {
- if (! isdigit((int) *cp)) {
- int c = tolower(*cp);
- if (c == '.' || c == 'e' || c == 'f') {
- type = EJS_TYPE_FLOAT;
- break;
- }
- }
- }
-#endif
- }
- }
- }
-
- switch (type) {
- case EJS_TYPE_OBJECT:
- case EJS_TYPE_UNDEFINED:
- case EJS_TYPE_NULL:
- case EJS_TYPE_PTR:
- default:
- break;
-
- case EJS_TYPE_BOOL:
- return ejsCreateBoolVar(ep, ejsParseBoolean(buf));
-
- case EJS_TYPE_INT:
- return ejsCreateIntegerVar(ep, ejsParseInteger(buf));
-
-#if BLD_FEATURE_INT64
- case EJS_TYPE_INT64:
- return ejsCreateInteger64Var(ep, ejsParseInteger64(buf));
-#endif
-
- case EJS_TYPE_STRING:
- if (strcmp(buf, "null") == 0) {
- return ejsCreateNullVar(ep);
-
- } else if (strcmp(buf, "undefined") == 0) {
- return ejsCreateUndefinedVar(ep);
- }
-
- return ejsCreateStringVar(ep, buf);
-
-#if BLD_FEATURE_FLOATING_POINT
- case EJS_TYPE_FLOAT:
- return ejsCreateFloatVar(ep, atof(buf));
-#endif
-
- }
- return ejsCreateUndefinedVar(ep);
-}
-
-/******************************************************************************/
-/*
- * Convert the variable to a number type. Only works for primitive types.
- */
-
-bool ejsParseBoolean(const char *s)
-{
- if (s == 0 || *s == '\0') {
- return 0;
- }
- if (strcmp(s, "false") == 0 || strcmp(s, "FALSE") == 0) {
- return 0;
- }
- return 1;
-}
-
-/******************************************************************************/
-/*
- * Convert the variable to a number type. Only works for primitive types.
- */
-
-EjsNum ejsParseNumber(const char *s)
-{
-#if BLD_FEATURE_NUM_TYPE_ID == EJS_TYPE_INT64
- return ejsParseInteger64(s);
-#elif BLD_FEATURE_NUM_TYPE_ID == EJS_TYPE_FLOAT
- return ejsParseFloat(s);
-#else
- return ejsParseInteger(s);
-#endif
-}
-
-/******************************************************************************/
-#if BLD_FEATURE_INT64
-/*
- * Convert the string buffer to an Integer64.
- */
-
-int64 ejsParseInteger64(const char *str)
-{
- const char *cp;
- int64 num64;
- int radix, c, negative;
-
- mprAssert(str);
-
- cp = str;
- num64 = 0;
- negative = 0;
-
- if (*cp == '-') {
- cp++;
- negative = 1;
- } else if (*cp == '+') {
- cp++;
- }
-
- /*
- * Parse a number. Observe hex and octal prefixes (0x, 0)
- */
- if (*cp != '0') {
- /*
- * Normal numbers (Radix 10)
- */
- while (isdigit((int) *cp)) {
- num64 = (*cp - '0') + (num64 * 10);
- cp++;
- }
- } else {
- cp++;
- if (tolower(*cp) == 'x') {
- cp++;
- radix = 16;
- while (*cp) {
- c = tolower(*cp);
- if (isdigit(c)) {
- num64 = (c - '0') + (num64 * radix);
- } else if (c >= 'a' && c <= 'f') {
- num64 = (c - 'a' + 10) + (num64 * radix);
- } else {
- break;
- }
- cp++;
- }
-
- } else{
- radix = 8;
- while (*cp) {
- c = tolower(*cp);
- if (isdigit(c) && c < '8') {
- num64 = (c - '0') + (num64 * radix);
- } else {
- break;
- }
- cp++;
- }
- }
- }
-
- if (negative) {
- return 0 - num64;
- }
- return num64;
-}
-
-#endif /* BLD_FEATURE_INT64 */
-/******************************************************************************/
-/*
- * Convert the string buffer to an Integer.
- */
-
-int ejsParseInteger(const char *str)
-{
- const char *cp;
- int num;
- int radix, c, negative;
-
- mprAssert(str);
-
- cp = str;
- num = 0;
- negative = 0;
-
- if (*cp == '-') {
- cp++;
- negative = 1;
- } else if (*cp == '+') {
- cp++;
- }
-
- /*
- * Parse a number. Observe hex and octal prefixes (0x, 0)
- */
- if (*cp != '0') {
- /*
- * Normal numbers (Radix 10)
- */
- while (isdigit((int) *cp)) {
- num = (*cp - '0') + (num * 10);
- cp++;
- }
- } else {
- cp++;
- if (tolower(*cp) == 'x') {
- cp++;
- radix = 16;
- while (*cp) {
- c = tolower(*cp);
- if (isdigit(c)) {
- num = (c - '0') + (num * radix);
- } else if (c >= 'a' && c <= 'f') {
- num = (c - 'a' + 10) + (num * radix);
- } else {
- break;
- }
- cp++;
- }
-
- } else{
- radix = 8;
- while (*cp) {
- c = tolower(*cp);
- if (isdigit(c) && c < '8') {
- num = (c - '0') + (num * radix);
- } else {
- break;
- }
- cp++;
- }
- }
- }
-
- if (negative) {
- return 0 - num;
- }
- return num;
-}
-
-/******************************************************************************/
-#if BLD_FEATURE_FLOATING_POINT
-/*
- * Convert the string buffer to an Floating.
- */
-
-double ejsParseFloat(const char *str)
-{
- return atof(str);
-}
-
-/******************************************************************************/
-
-int ejsIsNan(double f)
-{
-#if WIN
- return _isnan(f);
-#elif VXWORKS
- /* FUTURE */
- return (0);
-#else
- return (f == FP_NAN);
-#endif
-}
-/******************************************************************************/
-
-int ejsIsInfinite(double f)
-{
-#if WIN
- return !_finite(f);
-#elif VXWORKS
- /* FUTURE */
- return (0);
-#else
- return (f == FP_INFINITE);
-#endif
-}
-
-#endif /* BLD_FEATURE_FLOATING_POINT */
-
-/******************************************************************************/
-/*
- * Single point of control for all assignment to properties.
- *
- * Copy an objects core value (only). This preserves the destination object's
- * name. This implements copy by reference for objects and copy by value for
- * strings and other types. Caller must free dest prior to calling.
- */
-
-static EjsVar *copyVar(EJS_LOC_DEC(ep, loc), EjsVar *dest, const EjsVar *src,
- EjsCopyDepth copyDepth)
-{
- Ejs *ejsContext;
- EjsObj *srcObj;
- EjsProperty *destp;
- const char **srcArgs;
- char *str;
- int i;
-
- mprAssert(dest);
- mprAssert(src);
-
- if (dest == src) {
- return dest;
- }
-
- if (dest->type != EJS_TYPE_UNDEFINED) {
- ejsClearVar(ep, dest);
- }
-
- dest->allocatedData = 0;
-
- switch (src->type) {
- default:
- case EJS_TYPE_UNDEFINED:
- case EJS_TYPE_NULL:
- break;
-
- case EJS_TYPE_BOOL:
- dest->boolean = src->boolean;
- break;
-
- case EJS_TYPE_PTR:
- dest->ptr = src->ptr;
- if (dest->ptr.destructor) {
- dest->allocatedData = 1;
- }
- break;
-
- case EJS_TYPE_STRING_CMETHOD:
- dest->cMethodWithStrings = src->cMethodWithStrings;
- break;
-
- case EJS_TYPE_CMETHOD:
- dest->cMethod = src->cMethod;
- break;
-
-#if BLD_FEATURE_FLOATING_POINT
- case EJS_TYPE_FLOAT:
- dest->floating = src->floating;
- break;
-#endif
-
- case EJS_TYPE_INT:
- dest->integer = src->integer;
- break;
-
-#if BLD_FEATURE_INT64
- case EJS_TYPE_INT64:
- dest->integer64 = src->integer64;
- break;
-#endif
-
- case EJS_TYPE_OBJECT:
- if (copyDepth == EJS_SHALLOW_COPY) {
-
- /*
- * If doing a shallow copy and the src object is from the same
- * interpreter, or we are copying from the master interpreter, or
- * we are using a shared slab, then we can do a shallow copy.
- * Otherwise, we must do a deep copy.
- */
- srcObj = src->objectState;
- if (srcObj->ejs == ep || srcObj->ejs == ep->service->master ||
- (ep->flags & EJS_FLAGS_SHARED_SLAB)) {
- dest->objectState = src->objectState;
- dest->allocatedData = 1;
- break;
- }
- }
-
- /*
- * Doing a deep or recursive deep. Can get here if doing a shallow
- * copy and the object is from another non-master interpeter and not
- * using a shared slab.
- *
- * We must make sure the data is allocated using the right memory
- * context. It must be the same as the destination parent object.
- * Otherwise, when we free the property memory, the parent may
- * have a dangling pointer.
- */
- if (dest->isProperty) {
- destp = ejsGetPropertyPtr(dest);
- if (destp->parentObj == 0) {
- ejsContext = ep;
-
- } else {
- mprAssert(destp->parentObj);
- ejsContext = destp->parentObj->ejs;
- mprAssert(ejsContext);
- }
-
- } else {
- ejsContext = ep;
- }
-
- dest->objectState = createObj(EJS_LOC_PASS(ejsContext, loc));
- if (dest->objectState == 0) {
- /* Memory Error */
- return 0;
- }
-
- dest->objectState->baseClass = src->objectState->baseClass;
- dest->objectState->methods = src->objectState->methods;
- dest->objectState->noConstructor = src->objectState->noConstructor;
- dest->objectState->objName =
- mprStrdup(ejsContext, src->objectState->objName);
-
- if (dest->objectState->objName == 0) {
- return 0;
- }
-
- if (ejsCopyProperties(ep, dest, src, copyDepth) == 0) {
- return 0;
- }
- dest->allocatedData = 1;
- break;
-
- case EJS_TYPE_METHOD:
- dest->method.args = mprCreateItemArray(ep, EJS_INC_ARGS,
- EJS_MAX_ARGS);
- if (dest->method.args == 0) {
- return 0;
- }
- dest->allocatedData = 1;
- if (src->method.args) {
- srcArgs = (const char**) src->method.args->items;
- for (i = 0; i < src->method.args->length; i++) {
- str = mprStrdupInternal(EJS_LOC_PASS(dest->method.args,
- loc), srcArgs[i]);
- if (str == 0) {
- mprFree(dest->method.args);
- dest->method.args = 0;
- return 0;
- }
- if (mprAddItem(dest->method.args, str) < 0) {
- mprFree(dest->method.args);
- dest->method.args = 0;
- return 0;
- }
- }
- }
- dest->method.body = mprStrdup(dest->method.args, src->method.body);
- if (dest->method.body == 0) {
- mprFree(dest->method.args);
- dest->method.args = 0;
- return 0;
- }
- dest->callsSuper = src->callsSuper;
- break;
-
- case EJS_TYPE_STRING:
- dest->length = src->length;
- if (src->string) {
- /* Shallow, deep or recursive deep */
- dest->length = dupString(MPR_LOC_PASS(ep, loc), &dest->ustring,
- src->ustring, src->length);
- if (dest->length < 0) {
- return 0;
- }
- dest->allocatedData = 1;
-
- } else {
- dest->string = src->string;
- dest->allocatedData = 0;
- }
- break;
- }
-
- dest->type = src->type;
- dest->flags = src->flags;
- dest->isArray = src->isArray;
-
- return dest;
-}
-
-/******************************************************************************/
-/*
- * Copy all properies in an object. Must preserve property order
- */
-
-EjsVar *ejsCopyProperties(Ejs *ep, EjsVar *dest, const EjsVar *src,
- EjsCopyDepth copyDepth)
-{
- EjsProperty *srcProp, *destProp, *last, *next;
- int propertyIndex;
-
- srcProp = ejsGetFirstProperty(src, EJS_ENUM_ALL);
- while (srcProp) {
- next = ejsGetNextProperty(srcProp, EJS_ENUM_ALL);
- if (srcProp->visited) {
- srcProp = next;
- continue;
- }
-
- /*
- * This finds the last variable in the hash chain
- * FUTURE OPT. This is slow. If used double link, we could locate the
- * tail more easily.
- */
- destProp = hashLookup(dest->objectState, srcProp->name,
- &propertyIndex, &last);
- mprAssert(destProp == 0);
-
- destProp = allocProperty(ep, dest, srcProp->name, propertyIndex, last);
- if (destProp == 0) {
- mprAssert(destProp);
- return 0;
- }
-
- /*
- * Recursively copy the object. If DEEP_COPY, then we
- * will do a shallow copy of the object contents. If
- * RECURSIVE_DEEP, then we do a deep copy at all levels.
- */
- srcProp->visited = 1;
-
- if (copyVar(EJS_LOC_ARGS(ep), ejsGetVarPtr(destProp),
- ejsGetVarPtr(srcProp),
- (copyDepth == EJS_DEEP_COPY) ? EJS_SHALLOW_COPY : copyDepth)
- == 0) {
- return 0;
- }
- srcProp->visited = 0;
-
- srcProp = next;
- }
- return dest;
-}
-
-/******************************************************************************/
-/********************************** Properties ********************************/
-/******************************************************************************/
-/*
- * Create a property in an object and return a pointer to it. If the property
- * already exists then just return a pointer to it (no error).
- * To test for existance of a property, use GetProperty
- */
-
-static EjsProperty *hashLookup(EjsObj *obj, const char *property,
- int *propertyIndex, EjsProperty **hashTail)
-{
- EjsProperty *prop, *last;
- int index;
-
- mprAssert(obj);
- mprAssert(property);
-
- if (obj == 0 || property == 0 || *property == '\0') {
- mprAssert(0);
- return 0;
- }
-
- /*
- * Find the property in the hash chain if it exists
- */
- index = hash(property);
- prop = obj->propertyHash[index];
- for (last = 0; prop != 0; last = prop, prop = prop->hashNext) {
- if (prop->name[0] == property[0] &&
- strcmp(prop->name, property) == 0) {
- break;
- }
- }
- if (propertyIndex) {
- *propertyIndex = index;
- }
- if (hashTail) {
- *hashTail = last;
- }
-
- return prop;
-}
-
-/******************************************************************************/
-/*
- * Create a property in an object and return a pointer to it. If the property
- * already exists then just return a pointer to it (no error). If the property
- * does not exist, create an undefined variable. To test for existance of a
- * property, use GetProperty.
- */
-
-EjsProperty *ejsCreateSimpleProperty(Ejs *ep, EjsVar *op, const char *property)
-{
- EjsProperty *prop, *last;
- int propertyIndex;
-
- if (op == 0 || op->type != EJS_TYPE_OBJECT || property == 0 ||
- *property == '\0') {
- mprAssert(0);
- return 0;
- }
-
- /*
- * Find the property in the hash chain if it exists
- */
- prop = hashLookup(op->objectState, property, &propertyIndex, &last);
-
- if (prop == 0) {
- /*
- * Create a new property
- */
- prop = allocProperty(ep, op, property, propertyIndex, last);
- if (prop == 0) {
- mprAssert(prop == 0);
- return 0;
- }
- }
- return prop;
-}
-
-/******************************************************************************/
-/*
- * Create a property in an object and return a pointer to it. If the property
- * already exists then just return a pointer to it (no error).
- * To test for existance of a property, use GetProperty
- */
-
-EjsProperty *ejsCreateSimpleNonUniqueProperty(Ejs *ep, EjsVar *op,
- const char *property)
-{
- EjsProperty *prop, *last;
- int propertyIndex;
-
- if (op == 0 || op->type != EJS_TYPE_OBJECT || property == 0 ||
- *property == '\0') {
- mprAssert(0);
- return 0;
- }
-
- /*
- * Find end of chain
- */
- propertyIndex = hash(property);
- prop = op->objectState->propertyHash[propertyIndex];
- for (last = 0; prop != 0; last = prop, prop = prop->hashNext) {
- ;
- }
-
- return allocProperty(ep, op, property, propertyIndex, last);
-}
-
-/******************************************************************************/
-/*
- * Find a property in an object and return a pointer to it.
- * This does NOT traverse base classes.
- */
-
-EjsProperty *ejsGetSimpleProperty(Ejs *ep, EjsVar *op, const char *property)
-{
- mprAssert(op);
- mprAssert(op->type == EJS_TYPE_OBJECT);
- mprAssert(property && *property);
-
- /*
- * This is an internal API. It has very little checking.
- */
- return hashLookup(op->objectState, property, 0, 0);
-}
-
-/******************************************************************************/
-
-/*
- * NOTE: There is no ejsSetSimpleProperty as all the ejsSetProperty routines
- * operate only on the instance and don't follow base classes. ie. there is
- * no simple version required. However, there is a ejsSetBaseProperty routine
- * that will follow base classes and is used to set static properties in base
- * classes
- */
-
-/******************************************************************************/
-/******************************* Property Access ******************************/
-/******************************************************************************/
-/*
- * The property get routines follow base classes and utilize the propery
- * method access routines. The property set routines do not follow base
- * classes. The property ejsSetBase... routines do follow base classes.
- */
-
-/*
- * Find a property in an object and return a pointer to it.
- * This follows base classes.
- */
-
-EjsProperty *ejsGetProperty(Ejs *ep, EjsVar *op, const char *property)
-{
- EjsVar *vp, *newOp;
- int maxBaseClasses = 50;
-
- do {
- if (op->type != EJS_TYPE_OBJECT) {
- mprAssert(op->type == EJS_TYPE_OBJECT);
- return 0;
- }
- mprAssert(op->objectState);
-
- vp = ejsGetPropertyMethod(ep, op, property);
- if (vp != 0) {
- /*
- * Found
- */
- break;
- }
-
- newOp = op->objectState->baseClass;
- if (newOp == 0) {
- if (op->objectState != ep->objectClass->objectState) {
- newOp = ep->objectClass;
- }
- }
- op = newOp;
-
- /*
- * A little bit of sanity checking
- */
- if (--maxBaseClasses <= 0) {
- mprAssert(maxBaseClasses > 0);
- break;
- }
-
- } while (op);
-
- return ejsGetPropertyPtr(vp);
-}
-
-/******************************************************************************/
-/*
- * Get the property's variable. Optionally create if it does not exist.
- */
-
-EjsVar *ejsGetPropertyAsVar(Ejs *ep, EjsVar *vp, const char *property)
-{
- return ejsGetVarPtr(ejsGetProperty(ep, vp, property));
-}
-
-/******************************************************************************/
-/*
- * Get the property's value as a binary string.
- */
-
-const uchar *ejsGetPropertyAsBinaryString(Ejs *ep, EjsVar *obj,
- const char *property, int *length)
-{
- EjsVar *vp;
-
- vp = ejsGetVarPtr(ejsGetProperty(ep, obj, property));
- if (vp == 0 || ejsVarIsUndefined(vp)) {
- return 0;
- }
-
- if (vp->type == EJS_TYPE_STRING) {
- if (length) {
- *length = vp->length;
- }
- return vp->ustring;
- }
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Get the property's value as a string.
- */
-
-const char *ejsGetPropertyAsString(Ejs *ep, EjsVar *obj, const char *property)
-{
- EjsVar *vp;
-
- vp = ejsGetVarPtr(ejsGetProperty(ep, obj, property));
- if (vp == 0 || ejsVarIsUndefined(vp)) {
- return 0;
- }
-
- if (vp->type == EJS_TYPE_STRING) {
- return vp->string;
- }
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Get the property's value as a number.
- */
-
-BLD_FEATURE_NUM_TYPE ejsGetPropertyAsNumber(Ejs *ep, EjsVar *obj,
- const char *property)
-{
- EjsVar *vp;
-
- vp = ejsGetVarPtr(ejsGetProperty(ep, obj, property));
- if (vp == 0 || ejsVarIsUndefined(vp)) {
- return 0;
- }
-
- return ejsVarToNumber(vp);
-}
-
-/******************************************************************************/
-/*
- * Get the property's value as a integer.
- */
-
-int ejsGetPropertyAsInteger(Ejs *ep, EjsVar *obj, const char *property)
-{
- EjsVar *vp;
-
- vp = ejsGetVarPtr(ejsGetProperty(ep, obj, property));
- if (vp == 0 || ejsVarIsUndefined(vp)) {
- return 0;
- }
-
- return ejsVarToInteger(vp);
-}
-
-/******************************************************************************/
-/*
- * Get the property's value as a boolean.
- */
-
-bool ejsGetPropertyAsBoolean(Ejs *ep, EjsVar *obj, const char *property)
-{
- EjsVar *vp;
-
- vp = ejsGetVarPtr(ejsGetProperty(ep, obj, property));
- if (vp == 0 || ejsVarIsUndefined(vp)) {
- return 0;
- }
-
- return ejsVarToBoolean(vp);
-}
-
-/******************************************************************************/
-/*
- * Get the property's value as a pointer.
- */
-
-void *ejsGetPropertyAsPtr(Ejs *ep, EjsVar *obj, const char *property)
-{
- EjsVar *vp;
-
- vp = ejsGetVarPtr(ejsGetProperty(ep, obj, property));
- if (vp == 0 || ejsVarIsUndefined(vp)) {
- return 0;
- }
- if (vp->type == EJS_TYPE_PTR) {
- return vp->ptr.userPtr;
- }
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Create a property in the object. This will override any base class
- * properties.
- *
- * MOB -- need to spell out the difference between ejsSetProperty and
- * ejsCreateProperty.
- */
-
-EjsProperty *ejsCreateProperty(Ejs *ep, EjsVar *obj, const char *property)
-{
- EjsVar *vp;
-
- vp = ejsCreatePropertyMethod(ep, obj, property);
- return ejsGetPropertyPtr(vp);
-}
-
-/******************************************************************************/
-/*
- * Set a property's variable value. Create the property if it does not exist.
- * This routine DOES follow base classes.
- */
-
-EjsProperty *ejsSetBaseProperty(Ejs *ep, EjsVar *op, const char *property,
- const EjsVar *value)
-{
- EjsVar *vp, *newOp;
- int maxBaseClasses = 50;
-
- do {
- if (op->type != EJS_TYPE_OBJECT) {
- mprAssert(op->type == EJS_TYPE_OBJECT);
- return 0;
- }
- mprAssert(op->objectState);
-
- vp = ejsGetPropertyMethod(ep, op, property);
- if (vp != 0) {
- /*
- * Found
- */
- vp = ejsSetPropertyMethod(ep, op, property, value);
- break;
- }
-
- newOp = op->objectState->baseClass;
- if (newOp == 0) {
- if (op->objectState != ep->objectClass->objectState) {
- newOp = ep->objectClass;
- }
- }
- op = newOp;
-
- /*
- * A little bit of sanity checking
- */
- if (--maxBaseClasses <= 0) {
- mprAssert(maxBaseClasses > 0);
- break;
- }
-
- } while (op);
-
- return ejsGetPropertyPtr(vp);
-}
-
-/******************************************************************************/
-/*
- * Set a property's variable value. Create the property if it does not exist.
- * This does NOT follow base classes. Okay when updating instance properties,
- * but not for class (static) properties. This does a shallow copy which
- * will copy references.
- */
-
-EjsProperty *ejsSetProperty(Ejs *ep, EjsVar *obj, const char *property,
- const EjsVar *value)
-{
- EjsVar *vp;
-
- vp = ejsSetPropertyMethod(ep, obj, property, value);
-
- return ejsGetPropertyPtr(vp);
-}
-
-/******************************************************************************/
-/*
- * Set a property's variable value by assigning the given value. The caller
- * must NOT free value as it is assigned directly into the property's value.
- */
-
-EjsProperty *ejsSetPropertyAndFree(Ejs *ep, EjsVar *obj,
- const char *property, EjsVar *value)
-{
- EjsVar *vp;
-
- vp = ejsSetPropertyMethod(ep, obj, property, value);
-
- ejsFree(ep, value, EJS_SLAB_VAR);
-
- return ejsGetPropertyPtr(vp);
-}
-
-/******************************************************************************/
-
-EjsProperty *ejsSetPropertyToCMethod(Ejs *ep, EjsVar *vp, const char *prop,
- EjsCMethod fn, void *userData, int flags)
-{
- EjsVar v;
-
- ejsInitVar(&v, EJS_TYPE_CMETHOD);
- v.cMethod.fn = fn;
- v.cMethod.userData = userData;
- v.flags = flags;
-
- return ejsSetProperty(ep, vp, prop, &v);
-}
-
-/******************************************************************************/
-
-EjsProperty *ejsSetPropertyToBoolean(Ejs *ep, EjsVar *vp, const char *prop,
- int value)
-{
- EjsVar v;
-
- ejsInitVar(&v, EJS_TYPE_BOOL);
- v.boolean = value;
-
- return ejsSetProperty(ep, vp, prop, &v);
-}
-
-/******************************************************************************/
-#if BLD_FEATURE_FLOATING_POINT
-
-EjsProperty *ejsSetPropertyToFloat(Ejs *ep, EjsVar *vp, const char *prop,
- double value)
-{
- EjsVar v;
-
- ejsInitVar(&v, EJS_TYPE_FLOAT);
- v.floating = value;
-
- return ejsSetProperty(ep, vp, prop, &v);
-}
-
-#endif
-/******************************************************************************/
-
-EjsProperty *ejsSetPropertyToInteger(Ejs *ep, EjsVar *vp, const char *prop,
- int value)
-{
- EjsVar v;
-
- ejsInitVar(&v, EJS_TYPE_INT);
- v.integer = value;
-
- return ejsSetProperty(ep, vp, prop, &v);
-}
-
-/******************************************************************************/
-#if BLD_FEATURE_INT64
-
-EjsProperty *ejsSetPropertyToInteger64(Ejs *ep, EjsVar *vp, const char *prop,
- int64 value)
-{
- EjsVar v;
-
- ejsInitVar(&v, EJS_TYPE_INT64);
- v.integer64 = value;
-
- return ejsSetProperty(ep, vp, prop, &v);
-}
-
-#endif
-/******************************************************************************/
-
-EjsProperty *ejsSetPropertyToNull(Ejs *ep, EjsVar *vp, const char *prop)
-{
- EjsVar v;
-
- ejsInitVar(&v, EJS_TYPE_NULL);
-
- return ejsSetProperty(ep, vp, prop, &v);
-}
-
-/******************************************************************************/
-
-EjsProperty *ejsSetPropertyToMethod(Ejs *ep, EjsVar *vp, const char *prop,
- const char *body, MprArray *args, int flags)
-{
- return ejsSetPropertyAndFree(ep, vp, prop,
- ejsCreateMethodVar(ep, body, args, flags));
-}
-
-/******************************************************************************/
-
-EjsProperty *ejsSetPropertyToNumber(Ejs *ep, EjsVar *vp, const char *prop,
- EjsNum value)
-{
- return ejsSetPropertyAndFree(ep, vp, prop, ejsCreateNumberVar(ep, value));
-}
-
-/******************************************************************************/
-
-EjsProperty *ejsSetPropertyToStringCMethod(Ejs *ep, EjsVar *vp,
- const char *prop, EjsStringCMethod fn, void *userData, int flags)
-{
- EjsVar v;
-
- ejsInitVar(&v, EJS_TYPE_STRING_CMETHOD);
- v.cMethodWithStrings.fn = fn;
- v.cMethodWithStrings.userData = userData;
- v.flags = flags;
-
- return ejsSetProperty(ep, vp, prop, &v);
-}
-
-/******************************************************************************/
-
-EjsProperty *ejsSetPropertyToString(Ejs *ep, EjsVar *vp, const char *prop,
- const char *value)
-{
- EjsProperty *pp;
- EjsVar v;
-
- ejsInitVar(&v, EJS_TYPE_STRING);
-
- /* FUTURE OPT */
- v.string = mprStrdupInternal(EJS_LOC_ARGS(ep), value);
- if (v.string == 0) {
- return 0;
- }
- v.length = strlen(v.string);
- v.allocatedData = 1;
-
- pp = ejsSetProperty(ep, vp, prop, &v);
-
- mprFree(v.string);
-
- return pp;
-}
-
-/******************************************************************************/
-
-EjsProperty *ejsSetPropertyToBinaryString(Ejs *ep, EjsVar *vp,
- const char *prop, const uchar *value, int len)
-{
- EjsProperty *pp;
- EjsVar v;
-
- ejsInitVar(&v, EJS_TYPE_STRING);
-
- /* FUTURE OPT */
- v.length = dupString(MPR_LOC_ARGS(ep), &v.ustring, value, len);
- if (v.length < 0) {
- return 0;
- }
- v.allocatedData = 1;
-
- pp = ejsSetProperty(ep, vp, prop, &v);
-
- mprFree(v.ustring);
-
- return pp;
-}
-
-/******************************************************************************/
-
-EjsProperty *ejsSetPropertyToUndefined(Ejs *ep, EjsVar *vp, const char *prop)
-{
- EjsVar v;
-
- ejsInitVar(&v, EJS_TYPE_UNDEFINED);
-
- return ejsSetProperty(ep, vp, prop, &v);
-}
-
-/******************************************************************************/
-
-EjsProperty *ejsSetPropertyToPtr(Ejs *ep, EjsVar *vp, const char *prop,
- void *ptr, EjsDestructor destructor)
-{
- EjsVar v;
-
- ejsInitVar(&v, EJS_TYPE_PTR);
- v.ptr.userPtr = ptr;
- v.ptr.destructor = destructor;
- v.allocatedData = 1;
-
- return ejsSetProperty(ep, vp, prop, &v);
-}
-
-/******************************************************************************/
-
-EjsProperty *ejsSetPropertyToNewObj(Ejs *ep, EjsVar *vp, const char *prop,
- const char *className, MprArray *args)
-{
- return ejsSetPropertyAndFree(ep, vp, prop,
- ejsCreateObjUsingArgv(ep, 0, className, args));
-}
-
-/******************************************************************************/
-
-EjsProperty *ejsSetPropertyToObj(Ejs *ep, EjsVar *op, const char *prop)
-{
- return ejsSetPropertyAndFree(ep, op, prop, ejsCreateObjVar(ep));
-}
-
-/******************************************************************************/
-/*
- * Convenience routines
- */
-
-EjsVar *ejsSetPropertyToObjAsVar(Ejs *ep, EjsVar *op, const char *prop)
-{
- return ejsGetVarPtr(ejsSetPropertyToObj(ep, op, prop));
-}
-
-/******************************************************************************/
-/******************************************************************************/
-/******************************************************************************/
-/******************************************************************************/
-/*
- * Create a script method
- */
-
-EjsProperty *ejsDefineMethod(Ejs *ep, EjsVar *vp, const char *prop,
- const char *body, MprArray *args)
-{
- if (vp == 0) {
- vp = ejsGetGlobalObj(ep);
- }
- return ejsSetPropertyToMethod(ep, vp, prop, body, args, 0);
-}
-
-/******************************************************************************/
-/*
- * Create a C language method
- */
-
-EjsProperty *ejsDefineCMethod(Ejs *ep, EjsVar *vp, const char *prop,
- EjsCMethod fn, int flags)
-{
- if (vp == 0) {
- vp = ejsGetGlobalObj(ep);
- }
- return ejsSetPropertyToCMethod(ep, vp, prop, fn, 0, flags);
-}
-
-/******************************************************************************/
-/*
- * Define accessors
- */
-
-EjsProperty *ejsDefineAccessors(Ejs *ep, EjsVar *vp, const char *prop,
- const char *getBody, const char *setBody)
-{
- EjsProperty *pp;
- MprArray *args;
- char *propName;
-
- if (vp == 0) {
- vp = ejsGetGlobalObj(ep);
- }
-
- if (ejsSetPropertyToMethod(ep, vp, prop, getBody, 0, EJS_GET_ACCESSOR) < 0){
- ejsMemoryError(ep);
- return 0;
- }
-
- /* MOB -- OPT to use SLAB */
- /* MOB -- need to encapsulate this logic */
-
- if (mprAllocStrcat(MPR_LOC_ARGS(ep), &propName, EJS_MAX_ID+5, 0,
- "-set-", prop, NULL) < 0) {
- ejsMemoryError(ep);
- return 0;
- }
-
- args = mprCreateItemArray(ep, EJS_INC_ARGS, EJS_MAX_ARGS);
- mprAddItem(args, mprStrdup(args, "value"));
-
- pp = ejsSetPropertyToMethod(ep, vp, propName, setBody, args,
- EJS_SET_ACCESSOR);
- mprFree(propName);
-
- if (pp == 0) {
- ejsMemoryError(ep);
- return 0;
- }
-
- return pp;
-}
-
-/******************************************************************************/
-/*
- * Define C accessors
- */
-
-EjsProperty *ejsDefineCAccessors(Ejs *ep, EjsVar *vp, const char *prop,
- EjsCMethod getFn, EjsCMethod setFn, int flags)
-{
- EjsProperty *pp;
- char *propName;
-
- if (vp == 0) {
- vp = ejsGetGlobalObj(ep);
- }
- pp = ejsSetPropertyToCMethod(ep, vp, prop, getFn, 0,
- flags | EJS_GET_ACCESSOR);
- if (pp == 0) {
- ejsMemoryError(ep);
- return 0;
- }
-
- /* MOB -- OPT to use SLAB */
- if (mprAllocStrcat(MPR_LOC_ARGS(ep), &propName, EJS_MAX_ID + 5, 0,
- "-set-", prop, NULL) < 0) {
- ejsMemoryError(ep);
- return 0;
- }
- pp = ejsSetPropertyToCMethod(ep, vp, propName, setFn, 0,
- flags | EJS_SET_ACCESSOR);
- mprFree(propName);
-
- if (pp == 0) {
- ejsMemoryError(ep);
- return 0;
- }
- return pp;
-}
-
-/******************************************************************************/
-/*
- * Create a C language method with string arguments
- */
-
-EjsProperty *ejsDefineStringCMethod(Ejs *ep, EjsVar *vp, const char *prop,
- EjsStringCMethod fn, int flags)
-{
- if (vp == 0) {
- vp = ejsGetGlobalObj(ep);
- }
- return ejsSetPropertyToStringCMethod(ep, vp, prop, fn, 0, flags);
-}
-
-/******************************************************************************/
-
-void ejsSetCMethodUserData(EjsVar *obj, void *userData)
-{
- /*
- * This is a little dirty. We rely on the userData being in the same
- * place in the var structure.
- */
- obj->cMethod.userData = userData;
-}
-
-/******************************************************************************/
-
-void ejsSetVarFlags(EjsVar *obj, int flags)
-{
- obj->flags = flags;
-}
-
-/******************************************************************************/
-
-void *ejsGetCMethodUserData(EjsVar *obj)
-{
- return obj->cMethod.userData;
-}
-
-/******************************************************************************/
-
-int ejsGetVarFlags(EjsVar *obj)
-{
- return obj->flags;
-}
-
-/******************************************************************************/
-
-void ejsSetObjDestructor(Ejs *ep, EjsVar *obj, EjsDestructor destructor)
-{
- obj->objectState->destructor = destructor;
-}
-
-/******************************************************************************/
-
-void ejsClearObjDestructor(Ejs *ep, EjsVar *obj)
-{
- obj->objectState->destructor = 0;
-}
-
-/******************************************************************************/
-/*
- * Create a new property
- */
-
-static EjsProperty *allocProperty(Ejs *ep, EjsVar *op, const char *property,
- int propertyIndex, EjsProperty *last)
-{
- EjsProperty *prop;
- EjsObj *obj;
-
- obj = op->objectState;
-
- /*
- * Allocate the property using the memory context of the owning object
- */
- prop = ejsAllocProperty(EJS_LOC_ARGS(obj->ejs));
- if (prop == 0) {
- return 0;
- }
- if (mprStrcpy(prop->name, sizeof(prop->name), property) < 0) {
- ejsError(ep, EJS_REFERENCE_ERROR,
- "Property name %s is too long. Max is %d letters.",
- prop->name, EJS_MAX_ID);
- return 0;
- }
-
- ejsSetVarName(ep, ejsGetVarPtr(prop), &prop->name[0]);
-
- /*
- * Do hash linkage
- */
- if (last) {
- last->hashNext = prop;
- } else {
- obj->propertyHash[propertyIndex] = prop;
- }
-
-#if BLD_DEBUG
- prop->link.propertyName = prop->name;
- prop->link.property = prop;
- prop->link.head = &obj->link;
-#endif
-
- /*
- * Inserting before the dummy head will append to the end
- */
- linkPropertyBefore(obj, &obj->link, &prop->link);
-
- obj->numProperties++;
- prop->parentObj = obj;
- mprAssert(obj->ejs);
-
- return prop;
-}
-
-/******************************************************************************/
-/*
- * Delete a property from this object
- */
-
-int ejsDeleteProperty(Ejs *ep, EjsVar *vp, const char *property)
-{
- EjsProperty *prop, *last;
- EjsObj *obj;
- int propertyIndex;
-
- mprAssert(vp);
- mprAssert(property && *property);
- mprAssert(vp->type == EJS_TYPE_OBJECT);
-
- if (vp->type != EJS_TYPE_OBJECT) {
- mprAssert(vp->type == EJS_TYPE_OBJECT);
- return MPR_ERR_BAD_ARGS;
- }
-
- prop = hashLookup(vp->objectState, property, &propertyIndex, &last);
- if (prop == (EjsProperty*) 0) {
- return MPR_ERR_NOT_FOUND;
- }
- obj = vp->objectState;
-
-#if FUTURE
- if (prop->readonly) {
- mprAssert(! prop->readonly);
- return MPR_ERR_READ_ONLY;
- }
-#endif
-
- /*
- * If doing enumerations, then the object will mark preventDelete to
- * prevent any properties being deleted and thus disturbing the
- * traversal.
- */
- if (obj->preventDeleteProp) {
- obj->delayedDeleteProp = 1;
- prop->delayedDelete = 1;
- return 0;
- }
-
- /*
- * Remove from hash
- */
- if (last) {
- last->hashNext = prop->hashNext;
- } else {
- obj->propertyHash[propertyIndex] = prop->hashNext;
- }
-
- unlinkProperty(obj, &prop->link);
- obj->numProperties--;
-
- /*
- * Free any property data and return to the slab
- */
- if (prop->var.type != EJS_TYPE_OBJECT) {
- ejsClearVar(ep, ejsGetVarPtr(prop));
- }
- ejsFree(ep, prop, EJS_SLAB_PROPERTY);
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Remove a property's value from this object. The property is set to
- * undefined.
- */
-
-EjsVar *ejsClearProperty(Ejs *ep, EjsVar *vp, const char *property)
-{
- EjsProperty *prop;
-
- mprAssert(vp);
- mprAssert(property && *property);
- mprAssert(vp->type == EJS_TYPE_OBJECT);
-
- if (vp->type != EJS_TYPE_OBJECT) {
- mprAssert(vp->type == EJS_TYPE_OBJECT);
- return 0;
- }
-
- prop = hashLookup(vp->objectState, property, 0, 0);
- if (prop == (EjsProperty*) 0) {
- return 0;
- }
-#if FUTURE
- if (prop->readonly) {
- mprAssert(! prop->readonly);
- return 0;
- }
-#endif
-
- ejsClearVar(ep, &prop->var);
- return &prop->var;
-}
-
-/******************************************************************************/
-/*
- * Unlink a property from the ordered list of properties
- */
-
-static void unlinkProperty(EjsObj *obj, EjsPropLink *propLink)
-{
- propLink->prev->next = propLink->next;
- propLink->next->prev = propLink->prev;
-}
-
-/******************************************************************************/
-#if UNUSED && KEEP
-/*
- * Insert a link after a specified link.
- */
-
-static void linkPropertyAfter(EjsObj *obj, EjsPropLink *at,
- EjsPropLink *propLink)
-{
- propLink->next = at->next;
- propLink->prev = at;
-
- at->next->prev = propLink;
- at->next = propLink;
-}
-
-#endif
-/******************************************************************************/
-/*
- * Insert a link before a specified link.
- */
-
-static void linkPropertyBefore(EjsObj *obj, EjsPropLink *at,
- EjsPropLink *propLink)
-{
- propLink->prev = at->prev;
- propLink->next = at;
-
- at->prev->next = propLink;
- at->prev = propLink;
-}
-
-/******************************************************************************/
-/*
- * This routine will sort properties in an object. If propertyName is not
- * null, then the properties in op must be objects with a property of the
- * name propertyName. If propertyName is null, then the properties of op
- * are directly sorted. If order is 1, they are sorted in ascending order.
- * If -1, they are sorted in descending order.
- *
- * NOTE: arrays keep their original index values.
- */
-
-void ejsSortProperties(Ejs *ep, EjsVar *op, EjsSortFn fn,
- const char *propertyName, int order)
-{
- EjsProperty *p1, *p2, *tmp;
- EjsPropLink *l1, *l2, *oldL1Spot;
- EjsObj *obj;
-
- obj = op->objectState;
-
- p1 = ejsGetFirstProperty(op, 0);
- while (p1) {
- if (p1->dontEnumerate) {
- p1 = ejsGetNextProperty(p1, 0);
- continue;
- }
-
- p2 = ejsGetFirstProperty(op, 0);
- while (p2 && p2 != p1) {
-
- if (p2->dontEnumerate) {
- p2 = ejsGetNextProperty(p2, 0);
- continue;
- }
-
- if (fn == 0) {
- if (propertyName) {
- fn = sortByProperty;
- } else {
- fn = sortAllProperties;
- }
- }
-
- if (fn(ep, p1, p2, propertyName, order) < 0) {
-
- l1 = &p1->link;
- l2 = &p2->link;
-
- /*
- * Swap the properties without disturbing the hash chains.
- * l1 is always after l2 in the list. Unlink l1 and remember
- * the one after l1.
- */
- oldL1Spot = l1->next;
- unlinkProperty(obj, l1);
-
- /*
- * Manually reinsert l1 by replacing l2 with l1. l2 is out of
- * the chain.
- */
- l2->prev->next = l1;
- l2->next->prev = l1;
- l1->prev = l2->prev;
- l1->next = l2->next;
-
- /*
- * Reinsert l2 before the spot where l1 was.
- */
- linkPropertyBefore(obj, oldL1Spot, l2);
-
- /*
- * Swap the pointers so we continue to traverse correctly
- */
- tmp = p1;
- p1 = p2;
- p2 = tmp;
- }
- p2 = ejsGetNextProperty(p2, 0);
- }
- p1 = ejsGetNextProperty(p1, 0);
- }
-}
-
-/******************************************************************************/
-/*
- * Sort properties. Strings are sorted in ascending ASCII collating sequence
- * Numbers are sorted in increasing numerical order.
- */
-static int sortAllProperties(Ejs *ep, EjsProperty *p1, EjsProperty *p2,
- const char *propertyName, int order)
-{
- EjsVar *v1, *v2;
- char *buf1, *buf2;
- int rc, buf1Alloc;
-
- v1 = ejsGetVarPtr(p1);
- v2 = ejsGetVarPtr(p2);
-
- if (v1->type == v2->type) {
- /* MOB -- should support Numbers */
- if (v1->type == EJS_TYPE_INT) {
- if (v1->integer < v2->integer) {
- return - order;
-
- } else if (v1->integer == v2->integer) {
- return 0;
- }
- return order;
-
-#if BLD_FEATURE_FLOATING_POINT
- } else if (v1->type == EJS_TYPE_FLOAT) {
- if (v1->floating < v2->floating) {
- return - order;
-
- } else if (v1->floating == v2->floating) {
- return 0;
- }
- return order;
-
-#endif
- } else if (v1->type == EJS_TYPE_STRING) {
- /* MOB -- need binary support ? */
- return strcmp(v1->string, v2->string) * order;
-
- } else {
-
- buf1 = ejsVarToStringEx(ep, v1, &buf1Alloc);
- buf2 = ejsVarToString(ep, v2);
-
- rc = strcmp(buf1, buf2);
-
- if (buf1Alloc) {
- mprFree(buf1);
- }
-
- return rc * order;
- }
-
- } else {
- /* Type mismatch in array */
- return 0;
- }
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Sort an object by a given property.
- */
-static int sortByProperty(Ejs *ep, EjsProperty *p1, EjsProperty *p2,
- const char *propertyName, int order)
-{
- EjsVar *o1, *o2, *v1, *v2;
- char *buf1, *buf2;
- int rc, buf1Alloc;
-
- o1 = ejsGetVarPtr(p1);
- o2 = ejsGetVarPtr(p2);
-
- if (!ejsVarIsObject(o1) || !ejsVarIsObject(o2)) {
- mprAssert(ejsVarIsObject(o1));
- mprAssert(ejsVarIsObject(o2));
- return 0;
- }
-
- v1 = ejsGetPropertyAsVar(ep, o1, propertyName);
- v2 = ejsGetPropertyAsVar(ep, o2, propertyName);
-
- if (v1 == 0 || v2 == 0) {
- /* Property name not found */
- return 0;
- }
-
- if (v1->type != v2->type) {
- mprAssert(v1->type == v2->type);
- return 0;
- }
-
- if (v1->type == v2->type) {
- /* MOB -- should support Numbers */
- if (v1->type == EJS_TYPE_INT) {
- if (v1->integer < v2->integer) {
- return -order;
-
- } else if (v1->integer == v2->integer) {
- return 0;
- }
- return order;
-
-#if BLD_FEATURE_FLOATING_POINT
- } else if (v1->type == EJS_TYPE_FLOAT) {
- if (v1->floating < v2->floating) {
- return -order;
-
- } else if (v1->floating == v2->floating) {
- return 0;
- }
- return order;
-
-#endif
- } else if (v1->type == EJS_TYPE_STRING) {
- /* MOB -- need binary support ? */
- return strcmp(v1->string, v2->string) * order;
-
- } else {
- buf1 = ejsVarToStringEx(ep, v1, &buf1Alloc);
-
- buf2 = ejsVarToString(ep, v2);
-
- rc = strcmp(buf1, buf2);
-
- if (buf1Alloc) {
- mprFree(buf1);
- }
-
- return rc * order;
- }
-
- } else {
- /* Type mismatch in array */
- return 0;
- }
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Set a property's name
- */
-
-void ejsSetPropertyName(EjsProperty *pp, const char *property)
-{
- mprStrcpy(pp->name, sizeof(pp->name), property);
-}
-
-/******************************************************************************/
-
-int ejsMakePropertyEnumerable(EjsProperty *prop, int enumerate)
-{
- int oldValue;
-
- oldValue = prop->dontEnumerate;
- prop->dontEnumerate = !enumerate;
- return oldValue;
-}
-
-/******************************************************************************/
-
-void ejsMakePropertyPrivate(EjsProperty *prop, int isPrivate)
-{
- prop->isPrivate = isPrivate;
-}
-
-/******************************************************************************/
-/*
- * Make a variable read only. Can still be deleted.
- */
-
-void ejsMakePropertyReadOnly(EjsProperty *prop, int readonly)
-{
- prop->readonly = readonly;
-}
-
-/******************************************************************************/
-
-int ejsMakeObjPermanent(EjsVar *vp, int permanent)
-{
- int oldValue;
-
- if (vp && vp->type == EJS_TYPE_OBJECT) {
- oldValue = vp->objectState->permanent;
- vp->objectState->permanent = permanent;
- } else {
- oldValue = 0;
- }
- return oldValue;
-}
-
-/******************************************************************************/
-
-int ejsMakeObjLive(EjsVar *vp, bool alive)
-{
- int oldValue;
-
- oldValue = 0;
- if (vp && vp->type == EJS_TYPE_OBJECT) {
- oldValue = vp->objectState->alive;
- vp->objectState->alive = alive;
- } else {
- oldValue = 0;
- }
- return oldValue;
-}
-
-/******************************************************************************/
-
-void ejsMakeClassNoConstructor(EjsVar *vp)
-{
- mprAssert(vp->type == EJS_TYPE_OBJECT);
-
- if (vp->type == EJS_TYPE_OBJECT) {
- vp->objectState->noConstructor = 1;
- }
-}
-
-/******************************************************************************/
-/*
- * Get the count of properties.
- */
-
-int ejsGetPropertyCount(EjsVar *vp)
-{
- EjsProperty *pp;
- EjsPropLink *lp, *head;
- int count;
-
- mprAssert(vp);
-
- if (vp->type != EJS_TYPE_OBJECT) {
- return 0;
- }
-
- count = 0;
-
- head = &vp->objectState->link;
- for (lp = head->next; lp != head; lp = lp->next) {
- pp = ejsGetPropertyFromLink(lp);
- if (! pp->dontEnumerate) {
- count++;
- }
- }
- return count;
-}
-
-/******************************************************************************/
-/*
- * Get the first property in an object. Used for walking all properties in an
- * object. This will only enumerate properties in this class and not in base
- * classes.
- */
-
-EjsProperty *ejsGetFirstProperty(const EjsVar *op, int flags)
-{
- EjsProperty *pp;
- EjsObj *obj;
- EjsPropLink *head, *lp;
-
- mprAssert(op);
- mprAssert(op->type == EJS_TYPE_OBJECT);
-
- if (op->type != EJS_TYPE_OBJECT) {
- mprAssert(op->type == EJS_TYPE_OBJECT);
- return 0;
- }
- pp = 0;
-
- do {
- obj = op->objectState;
-
- head = &obj->link;
- lp = head->next;
-
- while (lp != head) {
- pp = ejsGetPropertyFromLink(lp);
- if (! pp->dontEnumerate || (flags & EJS_ENUM_HIDDEN)) {
- break;
- }
- lp = lp->next;
- }
- if (lp != head || op->type != EJS_TYPE_OBJECT ||
- !(flags & EJS_ENUM_CLASSES)) {
- break;
- }
-
- op = obj->baseClass;
-
- } while (lp == 0 && op);
-
- return pp;
-}
-
-/******************************************************************************/
-/*
- * Get the next property in sequence. This will only enumerate properties in
- * this class and not in base classes.
- */
-
-EjsProperty *ejsGetNextProperty(EjsProperty *last, int flags)
-{
- EjsProperty *pp;
- EjsObj *obj;
- EjsPropLink *lp, *head;
-
- obj = last->parentObj;
-
- lp = last->link.next;
- head = &obj->link;
- pp = 0;
-
- while (obj) {
- while (lp != head) {
- pp = ejsGetPropertyFromLink(lp);
- if (! pp->dontEnumerate || (flags & EJS_ENUM_HIDDEN)) {
- break;
- }
- lp = lp->next;
- }
- if (lp != head || !(flags & EJS_ENUM_CLASSES)) {
- break;
- }
-
- /*
- * Now iterate over properties in base classes (down the chain)
- */
- if (obj->baseClass == 0) {
- break;
- }
-
- obj = obj->baseClass->objectState;
- if (obj == 0) {
- break;
- }
- }
- return pp;
-}
-
-/******************************************************************************/
-/*
- * Find a variable given a variable name and return the parent object and
- * the variable itself. This routine supports literal variable and property
- * names that may be objects or arrays but may NOT have expressions.
- * Returns -1 on errors or if the variable is not found.
- * FUTURE -- Needs OPT
- */
-
-EjsVar *ejsFindProperty(Ejs *ep, EjsVar **obj, char **property, EjsVar *global,
- EjsVar *local, const char *fullName, int create)
-{
- EjsProperty *currentProp;
- EjsVar *currentObj;
- /* MOB -- WARNING BIG */
- char tokBuf[EJS_MAX_ID], propertyName[EJS_MAX_ID];
- char *token, *next, *cp, *endp;
-
- mprAssert(fullName && *fullName);
-
- currentProp = 0;
- currentObj = 0;
-
- if (global == 0) {
- global = ep->global;
- }
-
- if (obj) {
- *obj = 0;
- }
- if (property) {
- *property = 0;
- }
-
- if (fullName == 0) {
- return 0;
- }
-
- next = (char*) fullName;
- token = getNextVarToken(&next, tokBuf, sizeof(tokBuf));
- mprStrcpy(propertyName, sizeof(propertyName), token);
-
- if (local) {
- currentProp = ejsGetProperty(ep, local, token);
- currentObj = local;
- }
- if (currentProp == 0) {
- currentProp = ejsGetProperty(ep, global, token);
- currentObj = global;
- }
-
- token = getNextVarToken(&next, tokBuf, sizeof(tokBuf));
-
- while (currentObj != 0 && token != 0 && *token) {
-
- if (currentProp == 0) {
- return 0;
- }
- currentObj = ¤tProp->var;
- currentProp = 0;
-
- if (*token == '[') {
- token = getNextVarToken(&next, tokBuf, sizeof(tokBuf));
-
- mprStrcpy(propertyName, sizeof(propertyName), token);
- cp = propertyName;
- if (*cp == '\"') {
- cp++;
- if ((endp = strchr(cp, '\"')) != 0) {
- *endp = '\0';
- }
- } else if (*cp == '\'') {
- cp++;
- if ((endp = strchr(cp, '\'')) != 0) {
- *endp = '\0';
- }
- }
-
- currentProp = ejsGetProperty(ep, currentObj, propertyName);
-
- token = getNextVarToken(&next, tokBuf, sizeof(tokBuf));
- if (*token != ']') {
- return 0;
- }
-
- } else if (*token == '.') {
- token = getNextVarToken(&next, tokBuf, sizeof(tokBuf));
- if (!isalpha((int) token[0]) &&
- token[0] != '_' && token[0] != '$') {
- return 0;
- }
-
- mprStrcpy(propertyName, sizeof(propertyName), token);
- currentProp = ejsGetProperty(ep, currentObj, token);
-
- } else {
- currentProp = ejsGetProperty(ep, currentObj, token);
- }
-
- if (next == 0 || *next == '\0') {
- break;
- }
- token = getNextVarToken(&next, tokBuf, sizeof(tokBuf));
- }
-
- if (obj) {
- *obj = currentObj;
- }
-
-
- if (currentProp == 0 && currentObj >= 0 && create) {
- currentProp = ejsCreateSimpleProperty(ep, currentObj, propertyName);
- }
-
- if (property) {
- *property = currentProp->name;
- }
- return ejsGetVarPtr(currentProp);
-}
-
-/******************************************************************************/
-/*
- * Get the next token as part of a variable specification. This will return
- * a pointer to the next token and will return a pointer to the next token
- * (after this one) in "next". The tokBuf holds the parsed token.
- */
-
-static char *getNextVarToken(char **next, char *tokBuf, int tokBufLen)
-{
- char *start, *cp;
- int len;
-
- start = *next;
- while (isspace((int) *start) || *start == '\n' || *start == '\r') {
- start++;
- }
- cp = start;
-
- if (*cp == '.' || *cp == '[' || *cp == ']') {
- cp++;
- } else {
- while (*cp && *cp != '.' && *cp != '[' && *cp != ']' &&
- !isspace((int) *cp) && *cp != '\n' && *cp != '\r') {
- cp++;
- }
- }
- len = mprMemcpy(tokBuf, tokBufLen - 1, start, cp - start);
- tokBuf[len] = '\0';
-
- *next = cp;
- return tokBuf;
-}
-
-/******************************************************************************/
-
-EjsVar *ejsGetGlobalClass(Ejs *ep)
-{
- return ep->global;
-}
-
-/******************************************************************************/
-/*************************** Property Access Methods **************************/
-/******************************************************************************/
-/*
- * Create an undefined property. This routine calls the object method hooks.
- */
-
-/* MOB -- better suffix than "Method" */
-EjsVar *ejsCreatePropertyMethod(Ejs *ep, EjsVar *op, const char *property)
-{
- EjsVar *vp;
-
- mprAssert(ep);
- mprAssert(op);
- mprAssert(property && *property);
-
- if (op == 0) {
- return 0;
- }
-
- mprAssert(op->type == EJS_TYPE_OBJECT);
- mprAssert(op->objectState);
-
- if (op->objectState == 0) {
- return 0;
- }
-
- if (op->objectState->methods == 0) {
- vp = ejsGetVarPtr(ejsCreateSimpleProperty(ep, op, property));
- } else {
- vp = (op->objectState->methods->createProperty)(ep, op, property);
- }
-
- if (vp == 0) {
- mprAssert(vp);
- op->objectState->hasErrors = 1;
- return 0;
- }
-
- /*
- * FUTURE - find a better way.
- */
- if (op->isArray) {
- ejsSetArrayLength(ep, op, property, 0, 0);
- }
- return vp;
-}
-
-/******************************************************************************/
-
-int ejsDeletePropertyMethod(Ejs *ep, EjsVar *op, const char *property)
-{
- int rc;
-
- mprAssert(ep);
- mprAssert(op);
- mprAssert(property && *property);
-
- if (op == 0) {
- return -1;
- }
-
- mprAssert(op->type == EJS_TYPE_OBJECT);
- mprAssert(op->objectState);
-
- if (op->objectState == 0) {
- return -1;
- }
-
- if (op->objectState->methods == 0) {
- rc = ejsDeleteProperty(ep, op, property);
- } else {
- rc = (op->objectState->methods->deleteProperty)(ep, op, property);
- }
-
- if (rc < 0) {
- op->objectState->hasErrors = 1;
- }
-
- op->objectState->dirty = 1;
-
- return rc;
-}
-
-/******************************************************************************/
-/*
- * Set the value of a property. Create if it does not exist
- * If the object has property accessor methods defined, use those.
- */
-
-EjsVar *ejsSetPropertyMethod(Ejs *ep, EjsVar *op, const char *property,
- const EjsVar *value)
-{
- EjsVar *vp;
-
- mprAssert(ep);
- mprAssert(op);
- mprAssert(property && *property);
- mprAssert(value);
-
- if (op == 0) {
- return 0;
- }
-
- mprAssert(op->type == EJS_TYPE_OBJECT);
- mprAssert(op->objectState);
-
- if (op->objectState == 0) {
- return 0;
- }
-
- if (op->objectState->methods == 0) {
- vp = ejsGetVarPtr(ejsCreateSimpleProperty(ep, op, property));
- if (vp && ejsWriteVar(ep, vp, (EjsVar*) value, EJS_SHALLOW_COPY) < 0) {
- mprAssert(0);
- op->objectState->hasErrors = 1;
- return 0;
- }
-
- } else {
- vp = (op->objectState->methods->setProperty)(ep, op, property, value);
- }
-
- if (vp == 0) {
- mprAssert(vp);
- op->objectState->hasErrors = 1;
- return 0;
- }
-
- if (vp->type == EJS_TYPE_OBJECT) {
- /*
- * We make an object alive (and subject to garbage collection) when
- * it is referenced in some other object. If this is undesirable, the
- * caller should make the object permanent while calling this routine
- * and then afterward clear the alive bit by calling ejsMakeObjLive().
- */
- if (op->objectState != vp->objectState) {
- vp->objectState->alive = 1;
- }
-#if BLD_DEBUG
- {
- EjsProperty *pp = ejsGetPropertyPtr(vp);
- ejsSetVarName(ep, vp, &pp->name[0]);
- if (value->propertyName == 0) {
- ejsSetVarName(ep, (EjsVar*) value, &pp->name[0]);
- }
- }
-#endif
- }
-
- /*
- * Trap assignments to array.length. MOB - find a better way.
- */
- if (vp->isArrayLength) {
- ejsSetArrayLength(ep, op, 0, 0, value);
- }
-
- op->objectState->dirty = 1;
-
- return vp;
-}
-
-/******************************************************************************/
-
-EjsVar *ejsGetPropertyMethod(Ejs *ep, EjsVar *op, const char *property)
-{
- mprAssert(ep);
- mprAssert(op);
- mprAssert(property && *property);
-
- if (op == 0) {
- return 0;
- }
-
- mprAssert(op->type == EJS_TYPE_OBJECT);
- mprAssert(op->objectState);
-
- if (op->objectState == 0) {
- return 0;
- }
-
- if (op->objectState->methods == 0) {
- return ejsGetVarPtr(ejsGetSimpleProperty(ep, op, property));
- } else {
- return (op->objectState->methods->getProperty)(ep, op, property);
- }
-}
-
-/******************************************************************************/
-/*************************** Advisory Locking Support *************************/
-/******************************************************************************/
-#if BLD_FEATURE_MULTITHREAD
-
-void ejsLockObj(EjsVar *vp)
-{
- mprAssert(vp);
- mprAssert(vp->type == EJS_TYPE_OBJECT);
- mprAssert(vp->objectState);
-
- if (vp->objectState->mutex == 0) {
- vp->objectState->mutex = mprCreateLock(vp->objectState->ejs);
- }
- mprLock(vp->objectState->mutex);
-}
-
-/******************************************************************************/
-
-void ejsUnlockObj(EjsVar *vp)
-{
- mprAssert(vp);
- mprAssert(vp->type == EJS_TYPE_OBJECT);
- mprAssert(vp->objectState);
-
- if (vp->objectState->mutex) {
- mprUnlock(vp->objectState->mutex);
- }
-}
-
-#endif
-/******************************************************************************/
-/************************** Internal Support Routines *************************/
-/******************************************************************************/
-/*
- * Create an object.
- */
-
-static EjsObj *createObj(EJS_LOC_DEC(ep, loc))
-{
- EjsObj *op;
- EjsPropLink *lp;
-
- op = (EjsObj*) ejsAllocObj(EJS_LOC_PASS(ep, loc));
- if (op == NULL) {
- return 0;
- }
-
- /*
- * The objectState holds the dummy head for the ordered list of properties
- */
- lp = &op->link;
- lp->next = lp->prev = lp;
-
-#if BLD_DEBUG
- /*
- * This makes it much easier to debug the list
- */
- lp->head = lp;
- lp->propertyName = "dummyHead";
-#endif
-
- return op;
-}
-
-/******************************************************************************/
-/*
- * Destroy an object. Called by the garbage collector if there are no more
- * references to an object.
- */
-
-int ejsDestroyObj(Ejs *ep, EjsObj *obj)
-{
- EjsProperty *pp;
- EjsPropLink *lp, *head, *nextLink;
-
- mprAssert(obj);
-
- if (obj->destructor) {
- EjsVar v;
- memset(&v, 0, sizeof(v));
- v.type = EJS_TYPE_OBJECT;
- v.objectState = obj;
- ejsSetVarName(ep, &v, "destructor");
-
-#if BLD_FEATURE_ALLOC_LEAK_TRACK
- v.gc.allocatedBy = "static";
-#endif
-
- if ((obj->destructor)(ep, &v) < 0) {
- return -1;
- }
- }
- mprFree(obj->objName);
- obj->objName = 0;
-
- /*
- * Just for safety. An object may be marked by a GC on the default
- * interpreter. After destroying, it won't be on the free list and so
- * won't be reset.
- */
- obj->gcMarked = 0;
- obj->visited = 0;
-
- head = &obj->link;
- for (lp = head->next; lp != head; lp = nextLink) {
-
- pp = ejsGetPropertyFromLink(lp);
- nextLink = lp->next;
-
- /*
- * We don't unlink as we are destroying all properties.
- * If an object, we don't need to clear either.
- */
- if (pp->var.type != EJS_TYPE_OBJECT) {
- ejsClearVar(ep, ejsGetVarPtr(pp));
- }
- ejsFree(ep, pp, EJS_SLAB_PROPERTY);
- }
-
-#if BLD_FEATURE_MULTITHREAD
- if (obj->mutex) {
- mprDestroyLock(obj->mutex);
- }
-#endif
-
- ejsFree(ep, obj, EJS_SLAB_OBJ);
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Fast hash. The history of this algorithm is part of lost computer science
- * folk lore.
- */
-
-static int hash(const char *property)
-{
- uint sum;
-
- mprAssert(property);
-
- sum = 0;
- while (*property) {
- sum += (sum * 33) + *property++;
- }
-
- return sum % EJS_OBJ_HASH_SIZE;
-}
-
-/******************************************************************************/
-/*
- * Set a new length for an array. If create is non-null, then it is the name
- * of a new array index. If delete is set, it is the name of an index being
- * deleted. If setLength is set to a variable, it counts the new length for the
- * array. Note that create and delete are ignored if they are non-integer
- * array indexes (eg. normal properties).
- */
-
-void ejsSetArrayLength(Ejs *ep, EjsVar *obj, const char *create,
- const char *delete, const EjsVar *setLength)
-{
- EjsVar *vp;
- char idx[16];
- int oldSize, newSize, i;
-
- vp = ejsGetPropertyAsVar(ep, obj, "length");
- oldSize = vp->integer;
- newSize = oldSize;
-
- if (create) {
- if (isdigit(*create)) {
- i = atoi(create);
- newSize = max(i + 1, oldSize);
- }
- } else if (delete) {
- if (isdigit(*delete)) {
- i = atoi(delete);
- newSize = (i == (oldSize - 1) ? oldSize - 1 : oldSize);
- }
- } else {
- newSize = setLength->integer;
- }
-
- for (i = newSize; i < oldSize; i++) {
- mprItoa(idx, sizeof(idx), i);
- ejsDeleteProperty(ep, obj, idx);
- }
-
- if (ejsWriteVarAsInteger(ep, vp, newSize) == 0) {
- mprAssert(0);
- }
-}
-
-/******************************************************************************/
-
-void ejsClearObjErrors(EjsVar *vp)
-{
- if (vp == 0 || vp->type != EJS_TYPE_OBJECT || vp->objectState == 0) {
- mprAssert(0);
- return;
- }
- vp->objectState->hasErrors = 0;
-}
-
-/******************************************************************************/
-
-int ejsObjHasErrors(EjsVar *vp)
-{
- if (vp == 0 || vp->type != EJS_TYPE_OBJECT || vp->objectState == 0) {
- mprAssert(0);
- return -1;
- }
- return vp->objectState->hasErrors;
-}
-
-/******************************************************************************/
-
-bool ejsIsObjDirty(EjsVar *vp)
-{
- mprAssert(vp->type == EJS_TYPE_OBJECT && vp->objectState);
-
- if (vp->type == EJS_TYPE_OBJECT && vp->objectState) {
- return vp->objectState->dirty;
- }
- return 0;
-}
-
-/******************************************************************************/
-
-void ejsResetObjDirtyBit(EjsVar *vp)
-{
- mprAssert(vp->type == EJS_TYPE_OBJECT && vp->objectState);
-
- if (vp->type == EJS_TYPE_OBJECT && vp->objectState) {
- vp->objectState->dirty = 0;
- }
-}
-
-/******************************************************************************/
-/*
- * Copy a string. Always null terminate.
- */
-
-static int dupString(MPR_LOC_DEC(ctx, loc), uchar **dest, const void *src,
- int nbytes)
-{
- mprAssert(dest);
- mprAssert(src);
-
- if (nbytes > 0) {
- *dest = mprMemdupInternal(MPR_LOC_PASS(ctx, loc), src, nbytes + 1);
- if (*dest == 0) {
- return MPR_ERR_MEMORY;
- }
-
- } else {
- *dest = (uchar*) mprAlloc(ctx, 1);
- nbytes = 0;
- }
-
- (*dest)[nbytes] = '\0';
-
- return nbytes;
-}
-
-/******************************************************************************/
-
-const char *ejsGetVarTypeAsString(EjsVar *vp)
-{
- switch (vp->type) {
- default:
- case EJS_TYPE_UNDEFINED:
- return "undefined";
- case EJS_TYPE_NULL:
- return "null";
- case EJS_TYPE_BOOL:
- return "bool";
- case EJS_TYPE_CMETHOD:
- return "cmethod";
- case EJS_TYPE_FLOAT:
- return "float";
- case EJS_TYPE_INT:
- return "int";
- case EJS_TYPE_INT64:
- return "int64";
- case EJS_TYPE_OBJECT:
- return "object";
- case EJS_TYPE_METHOD:
- return "method";
- case EJS_TYPE_STRING:
- return "string";
- case EJS_TYPE_STRING_CMETHOD:
- return "string method";
- case EJS_TYPE_PTR:
- return "ptr";
- }
-}
-
-/******************************************************************************/
-
-void *ejsGetVarUserPtr(EjsVar *vp)
-{
- mprAssert(vp);
- mprAssert(vp->type == EJS_TYPE_PTR);
-
- if (!ejsVarIsPtr(vp)) {
- return 0;
- }
- return vp->ptr.userPtr;
-}
-
-/******************************************************************************/
-
-void ejsSetVarUserPtr(EjsVar *vp, void *data)
-{
- mprAssert(vp);
- mprAssert(vp->type == EJS_TYPE_PTR);
-
- vp->ptr.userPtr = data;
-}
-
-/******************************************************************************/
-/*
- * Return TRUE if target is a subclass (or the same class) as baseClass.
- */
-
-bool ejsIsSubClass(EjsVar *target, EjsVar *baseClass)
-{
- do {
- if (target->objectState == baseClass->objectState) {
- return 1;
- }
- target = target->objectState->baseClass;
- } while (target);
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- * ejsVar.h -- EJS Universal Variable Type
- */
-
-/*
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- * Copyright (c) Michael O'Brien, 1994-1995. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-
-/*
- * Variables can efficiently store primitive types and can hold references to
- * objects. Objects can store properties which are themselves variables.
- * Properties can be primitive data types, other objects or methods.
- * Properties are indexed by a character name. A variable may store one of
- * the following types:
- *
- * string, integer, integer-64bit, C method, C method with string args,
- * Javascript method, Floating point number, boolean value, Undefined
- * value and the Null value.
- *
- * Variables have names while objects may be referenced by multiple variables.
- * Objects use reference counting for garbage collection.
- *
- * This module is not thread safe for performance and compactness. It relies
- * on upper modules to provide thread synchronization as required. The API
- * provides primitives to get variable/object references or to get copies of
- * variables which will help minimize required lock times.
- */
-
-#ifndef _h_EJS_VAR
-#define _h_EJS_VAR 1
-
-/********************************* Includes ***********************************/
-
-#include "mpr.h"
-
-/********************************** Defines ***********************************/
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*
- * Defined in ejs.h
- */
-typedef struct Ejs Ejs;
-
-/*
- * Constants
- */
-#if BLD_FEATURE_SQUEEZE
- /**
- * Maximum property or variable name size
- */
- #define EJS_MAX_ID 64
-
- /*
- * EJS_VAR_HASH_SIZE must be less than the size of the bit field
- * propertyIndex in EjsProperty.
- */
- #define EJS_OBJ_HASH_SIZE 13
-
- /**
- * Maximum number of arguments per function call
- */
- #define EJS_MAX_ARGS 32
- #define EJS_INC_ARGS 8 /* Frame stack increment */
-
-#else
- #define EJS_MAX_ID 256
- #define EJS_OBJ_HASH_SIZE 29
- #define EJS_MAX_ARGS 64
- #define EJS_INC_ARGS 8
-#endif
-
-#define EJS_VAR_MAX_RECURSE 5 /* Max object loops */
-
-#if !DOXYGEN
-/*
- * Forward declare types
- */
-struct Ejs;
-struct EjsObj;
-struct EjsProperty;
-struct EjsVar;
-#endif
-
-/**
- * @overview EJ primitive variable type
- * @description EJ primitive variable values are stored in EjsVar structures.
- * The type of the primitive data is described by an EjsType field.
- * EjsVar variable types.
- * @stability Prototype.
- * @library libejs.
- * @see EJS_TYPE_UNDEFINED, EJS_TYPE_NULL, EJS_TYPE_BOOL, EJS_TYPE_CMETHOD,
- * EJS_TYPE_FLOAT, EJS_TYPE_INT, EJS_TYPE_INT64, EJS_TYPE_OBJECT,
- * EJS_TYPE_METHOD, EJS_TYPE_STRING, EJS_TYPE_STRING_CMETHOD, EJS_TYPE_PTR,
- */
-typedef uint EjsType;
-#define EJS_TYPE_UNDEFINED 0 /**< Undefined. No value has been set */
-#define EJS_TYPE_NULL 1 /**< Value defined to be null. */
-#define EJS_TYPE_BOOL 2 /**< Boolean type. */
-#define EJS_TYPE_CMETHOD 3 /**< C method */
-#define EJS_TYPE_FLOAT 4 /**< Floating point number */
-#define EJS_TYPE_INT 5 /**< Integer number */
-#define EJS_TYPE_INT64 6 /**< 64-bit Integer number */
-#define EJS_TYPE_OBJECT 7 /**< Object reference */
-#define EJS_TYPE_METHOD 8 /**< JavaScript method */
-#define EJS_TYPE_STRING 9 /**< String (immutable) */
-#define EJS_TYPE_STRING_CMETHOD 10 /**< C method with string args */
-#define EJS_TYPE_PTR 11 /**< Opaque pointer */
-
-/*
- * Create a type for the default number type
- * Config.h will define the default number type. For example:
- *
- * BLD_FEATURE_NUM_TYPE=int
- * BLD_FEATURE_NUM_TYPE_ID=EJS_TYPE_INT
- */
-
-/**
- * Set to the type used for EJS numeric variables. Will equate to int, int64
- * or double.
- */
-typedef BLD_FEATURE_NUM_TYPE EjsNum;
-
-/**
- * Set to the EJS_TYPE used for EJS numeric variables. Will equate to
- * EJS_TYPE_INT, EJS_TYPE_INT64 or EJS_TYPE_FLOAT.
- */
-#define EJS_NUM_VAR BLD_FEATURE_NUM_TYPE_ID
-#define EJS_TYPE_NUM BLD_FEATURE_NUM_TYPE_ID
-
-/*
- * Return TRUE if a variable is a method type
- */
-#define ejsVarIsMethod(vp) \
- ((vp)->type == EJS_TYPE_METHOD || (vp)->type == EJS_TYPE_STRING_CMETHOD || \
- (vp)->type == EJS_TYPE_CMETHOD)
-
-/*
- * Return TRUE if a variable is a numeric type
- */
-#define ejsVarIsNumber(vp) \
- ((vp)->type == EJS_TYPE_INT || (vp)->type == EJS_TYPE_INT64 || \
- (vp)->type == EJS_TYPE_FLOAT)
-
-/*
- * Return TRUE if a variable is a boolean
- */
-#define ejsVarIsBoolean(vp) \
- ((vp)->type == EJS_TYPE_BOOL)
-
-/*
- * Return TRUE if a variable is an integer type
- */
-#define ejsVarIsInteger(vp) ((vp)->type == EJS_TYPE_INT)
-
-/*
- * Return TRUE if a variable is a string
- */
-#define ejsVarIsString(vp) \
- ((vp)->type == EJS_TYPE_STRING)
-
-/*
- * Return TRUE if a variable is an object
- */
-#define ejsVarIsObject(vp) \
- ((vp)->type == EJS_TYPE_OBJECT)
-
-/*
- * Return TRUE if a variable is a floating number
- */
-#define ejsVarIsFloating(vp) \
- ((vp)->type == EJS_TYPE_FLOAT)
-
-/*
- * Return TRUE if a variable is undefined
- */
-#define ejsVarIsUndefined(var) \
- ((var)->type == EJS_TYPE_UNDEFINED)
-
-/*
- * Return TRUE if a variable is null
- */
-#define ejsVarIsNull(var) \
- ((var)->type == EJS_TYPE_NULL)
-
-/*
- * Return TRUE if a variable is a valid type (not null or undefined)
- */
-#define ejsVarIsValid(var) \
- (((var)->type != EJS_TYPE_NULL) && ((var)->type != EJS_TYPE_UNDEFINED))
-
-/*
- * Return TRUE if a variable is a ptr type
- */
-#define ejsVarIsPtr(vp) \
- ((vp)->type == EJS_TYPE_PTR)
-
-/* MOB -- convert all ep to ejs */
-/**
- * @overview C Method signature
- * @description This is the calling signature for C Methods.
- * @param ejs Ejs reference returned from ejsCreateInterp
- * @param thisObj Reference to the "this" object. (The object containing the
- * method).
- * @param argc Number of arguments.
- * @param argv Array of arguments. Each argument is held in an EjsVar type.
- * @stability Prototype.
- * @library libejs.
- * @see ejsCreateCMethodVar
- */
-typedef int (*EjsCMethod)(struct Ejs *ejs, struct EjsVar *thisObj,
- int argc, struct EjsVar **argv);
-
-/**
- * C Method with string arguments signature
- * @overview C Method with string arguments signature
- * @description This is the calling signature for C Methods.
- * @param ejs Ejs reference returned from ejsCreateInterp
- * @param thisObj Reference to the "this" object (object containing the
- * method.
- * @param argc Number of arguments.
- * @param argv Array of arguments. Each argument is held in an C string
- * pointer.
- * @stability Prototype.
- * @library libejs.
- * @see ejsCreateStringCMethodVar
- */
-typedef int (*EjsStringCMethod)(struct Ejs *ep, struct EjsVar *thisObj,
- int argc, char **argv);
-
-/**
- * Flags for types: EJS_TYPE_CMETHOD, EJS_TYPE_STRING_CMETHOD
- * NOTE: flags == 0 means to use the EJS handle on method callbacks
- */
-/* Use the primary handle on method callbacks */
-#define EJS_PRIMARY_HANDLE 0x1
-
-/* Use the alternate handle on method callbacks */
-#define EJS_ALT_HANDLE 0x2
-
-/** Method should not create a new local variable block */
-#define EJS_NO_LOCAL 0x4
-
-/* Method is a get accessor */
-#define EJS_GET_ACCESSOR 0x8
-
-/* Method is a set accessor */
-#define EJS_SET_ACCESSOR 0x10
-
-/*
- * Flags for E4X (Xml type)
- */
-/* Node is a text node */
-#define EJS_XML_FLAGS_TEXT 0x1
-
-/* Node is a processing instruction */
-#define EJS_XML_FLAGS_PI 0x2
-
-/* Node is a comment */
-#define EJS_XML_FLAGS_COMMENT 0x4
-
-/* Node is an attribute */
-#define EJS_XML_FLAGS_ATTRIBUTE 0x8
-
-/* Node is an element */
-#define EJS_XML_FLAGS_ELEMENT 0x10
-
-/**
- * Copy depth
- * @overview Specifies how an object should be copied
- * @description The EjsCopyDepth type specifies how an object's properties
- * should be copied. Several routines take EjsCopyDepth parameters to
- * control how the properties of an object should be copied. It provides
- * three copy options:
- * @see ejsWriteVar
- */
-typedef enum EjsCopyDepth {
- /**
- * During an object copy, object property references will be copied so
- * that the original object and the copy will share the same reference to
- * a property object. Properties containing primitive types including
- * strings will have their values copied and will not share references.
- */
- EJS_SHALLOW_COPY, /** Copy strings. Copy object references. */
- /*
- * During an object copy, object properties will be replicated so that
- * the original object and the copy will not share references to the same
- * object properties. If the original object's properties are themselves
- * objects, their properties will not be copied. Only their references
- * will be copied. i.e. the deep copy is one level deep.
- */
- EJS_DEEP_COPY, /** Copy strings and copy object contents. */
- /*
- * During an object copy, all object properties will be replicated so that
- * the original object and the copy will not share references to the same
- * object properties. If the original object's properties are themselves
- * objects, their properties will be copied. i.e. the copy is of infinite
- * depth.
- */
- EJS_RECURSIVE_DEEP_COPY /** Copy strings and copy object contents
- recursively (complete copy). */
-} EjsCopyDepth;
-
-
-/*
- * Enumeration flags
- */
-/** Enumerate data properties */
-#define EJS_ENUM_DATA 0x0
-
-/** Enumerate sub classes */
-#define EJS_ENUM_CLASSES 0x1
-
-/** Enumerate non-enumerable properties */
-#define EJS_ENUM_HIDDEN 0x2
-
-/** Enumerate all properties */
-#define EJS_ENUM_ALL (0x3)
-
-/** Magic number when allocated */
-#define EJS_MAGIC 0xe801e2ec
-#define EJS_MAGIC_FREE 0xe701e3ea
-
-
-/*
- * Garbage Collection Linkage. Free list only uses the next pointers.
- */
-typedef struct EjsGCLink {
-#if BLD_DEBUG
- uint magic; /* Magic number */
-#endif
-#if BLD_FEATURE_ALLOC_LEAK_TRACK
- const char *allocatedBy; /* Who allocated this */
-#endif
- struct EjsGCLink *next; /* Next property */
-} EjsGCLink;
-
-
-/**
- * @overview EJS Variable Type
- * @description The EJ language supports an extensive set of primitive types.
- * These variable types can efficiently store primitive data types such as
- * integers, strings, binary string, booleans, floating point numbers,
- * pointer references, and objects. EjsVars are the universal type used by
- * EJ to hold objects, classes and properties.
- * \n\n
- * An EjsVar may store one of the following types:
- * @li Boolean
- * @li Floating point (if supported in this build)
- * @li Integer
- * @li 64 bit integer (if supported in this build)
- * @li String
- * @li Binary string
- * @li C function or C++ method
- * @li C function with string args
- * @li Javascript method
- * @li Object
- * @li Null value.
- * @li Undefined value
- * \n\n
- * Objects can hold object properties which are themselves EJS variables.
- * Properties are hash indexed by the property name and are stored in
- * an ordered sequence. i.e. Order of properties is maintained. Objects may
- * be referenced by multiple variables and they use garbage collection to
- * reclaim memory no longer in use by objects and properties.
- *
- * @warning This module is @e not thread safe for performance and
- * compactness. It relies on upper modules to provide thread
- * synchronization as required. The API provides primitives to get
- * variable/object references or to get copies of variables which should
- * help minimize required lock times.
- * @stability Prototype.
- * @library libejs
- * @see Ejs, EjsProperty, ejsCreateStringVar, ejsFreeVar
- */
-
-typedef struct EjsVar { /* Size 12 bytes */
- /*
- * GC must be first
- */
-#if BLD_DEBUG || BLD_FEATURE_ALLOC_LEAK_TRACK
- EjsGCLink gc; /* Garbage collection links */
-#endif
-
-#if BLD_DEBUG
- const char *propertyName; /* Ptr to property name */
-#endif
-
- /*
- * Union of primitive types. When debugging on Linux, don't use unions
- * as the gdb debugger can't display them.
- */
-#if (!BLD_DEBUG && !VXWORKS) || WIN || BREW_SIMULATOR
- union {
-#endif
- /*
- * For debugging, we order the common types first
- */
- struct EjsObj *objectState; /* Object state information */
- int integer;
- bool boolean;
-
-#if BLD_FEATURE_FLOATING_POINT
- double floating;
-#endif
-#if BLD_FEATURE_INT64
- int64 integer64;
-#endif
-
- struct {
- int length; /* String length (sans null) */
- /*
- * All strings always have a trailing null allocated
- */
- union {
- char *string; /* String */
- uchar *ustring; /* Binary string */
- };
- };
-
- struct { /* Javascript methods */
- MprArray *args; /* Null terminated */
- char *body;
- } method;
-
- struct { /* Method with EjsVar args */
- EjsCMethod fn; /* Method pointer */
- void *userData; /* User data for method */
- } cMethod;
-
- struct { /* Method with string args */
- EjsStringCMethod fn; /* Method pointer */
- void *userData; /* User data for method */
- } cMethodWithStrings;
-
- struct {
- void *userPtr; /* Opaque pointer */
- int (*destructor)(Ejs *ejs, struct EjsVar *vp);
- } ptr;
-
-#if (!BLD_DEBUG && !VXWORKS) || WIN || BREW_SIMULATOR
- };
-#endif
-
- /*
- * Packed bit field (32 bits)
- */
- uint flags : 8; /* Type specific flags */
- EjsType type : 4; /* Selector into union */
- uint stringLen : 4; /* Length of string if inline */
- uint allocatedData : 1; /* Node needs freeing */
- uint isArray : 1; /* Var is an array */
- uint isArrayLength : 1; /* Var is array.length */
- uint callsSuper : 1; /* Method calls super() */
- uint isProperty : 1; /* Part of a property */
- uint reserved : 11; /* Unused */
-
-} EjsVar;
-
-
-/*
- * Linkage for the ordered list of properties
- */
-typedef struct EjsPropLink {
- struct EjsPropLink *next; /* Next property */
- struct EjsPropLink *prev; /* Previous property */
-
- /*
- * To make debugging easier
- */
-#if BLD_DEBUG
- const char *propertyName; /* Pointer to name */
- struct EjsProperty *property; /* Pointer to property */
- struct EjsPropLink *head; /* Dummy head of list */
-#endif
-} EjsPropLink;
-
-
-/**
- * @overview Object Property Type
- * @description The EjsProperty type is used to store all object properties.
- * It contains the property name, property linkage, propery attributes
- * such as public/private, enumerable and readonly settings. It also
- * contains an EjsVar to store the property data value.
- * @stability Prototype.
- * @library libejs
- * @see Ejs, EjsVar
- */
-typedef struct EjsProperty { /* Size 96 bytes in squeeze */
- /*
- * EjsVar must be first. We often take the address of "var" and take
- * advantage of if an EjsProperty is null, then &prop->var will be null
- * also. Be WARNED. External users should use ejsGetVarPtr and
- * ejsGetPropertyPtr to convert between the two.
- */
- EjsVar var; /* Property value */
-
- /* OPT change this to a pointer to the base class property */
- char name[EJS_MAX_ID]; /* Name */
-
- uint visited : 1; /* Has been traversed */
- uint isPrivate : 1; /* Property is private */
- uint isProtected : 1; /* Property is protected */
- uint dontEnumerate : 1; /* Not enumerable */
- uint dontDelete : 1; /* Prevent delete */
- uint readonly : 1; /* Unmodifiable */
- uint allowNonUnique : 1; /* Multiple of same name ok */
- uint delayedDelete : 1;
- uint reserved : 24;
-
- EjsPropLink link; /* Ordered linked list */
- struct EjsProperty *hashNext; /* Hash table linkage */
-
- /* MOB -- is this really required */
- struct EjsObj *parentObj; /* Pointer to parent object */
-
-} EjsProperty;
-
-
-#define EJS_OP_DOT 0x1
-#define EJS_OP_INDEX 0x2
-#define EJS_OP_PLUS 0x3
-#define EJS_OP_MINUS 0x4
-#define EJS_OP_MULTIPLY 0x5
-#define EJS_OP_DIVIDE 0x6
-#define EJS_OP_CALL 0x7
-
-typedef struct EjsOp {
- int opType;
-
-} EjsOp;
-
-/*
- * Propety Access Methods. Used per class.
- * MOB -- rename EjsHelpers
- */
-typedef struct EjsMethods {
-#if FUTURE
- int (*create)(Ejs *ep, EjsVar *thisObj);
- int (*deleteProperty)(Ejs *ep, EjsVar *thisObj, const char *prop);
- EjsVar *(*getProperty)(Ejs *ep, EjsVar *thisObj, const char *prop);
- EjsVar *(*setProperty)(Ejs *ep, EjsVar *thisObj, const char *prop);
- int (*hasProperty)(Ejs *ep, EjsVar *thisObj, const char *prop);
- int (*hasInstance)(Ejs *ep, EjsVar *thisObj, const char *prop);
- int (*operate)(Ejs *ep, EjsVar *thisObj, EjsOp op, EjsVar *result,
- EjsVar *lhs, EjsVar *rhs, int *code);
-#else
-
- EjsVar *(*createProperty)(Ejs *ep, EjsVar *obj, const char *property);
- int (*deleteProperty)(Ejs *ep, EjsVar *obj, const char *property);
- EjsVar *(*getProperty)(Ejs *ep, EjsVar *obj, const char *property);
- EjsVar *(*setProperty)(Ejs *ep, EjsVar *obj, const char *property,
- const EjsVar *value);
- /*
- * Other implemented internal properties in ECMA-262 are:
- *
- * [[Construct]] implemented via EjsVar methods
- * [[Prototype]] implemented via EjsObj->baseClass
- * [[Class]] implemented via EjsObj->baseClass->name
- * [[Value]] Implemented via EjsProperty + EjsVar + EjsObj
- */
-
- /*
- * FUTURE -- not implemented
- */
- int (*canPut)(Ejs *ep, EjsVar *obj, const char *property);
- int (*defaultValue)(Ejs *ep, EjsVar *obj, const char *property,
- const char *hint);
- int (*hasProperty)(Ejs *ep, EjsVar *obj, const char *property);
- EjsVar *(*call)(Ejs *ep, EjsVar *obj, const char *property,
- EjsVar *args);
- int (*hasInstance)(Ejs *ep, EjsVar *obj, const char *property);
- int (*scope)(Ejs *ep, EjsVar *obj, const char *property);
- int (*match)(Ejs *ep, EjsVar *obj, const char *property,
- const char *string, int index);
-#endif
-} EjsMethods;
-
-
-/*
- * Ejs Object Type
- */
-typedef struct EjsObj {
- /*
- * GC must be first
- */
- EjsGCLink gc; /* Garbage collection links */
-
- union {
- char *objName; /* Object name */
- char *className; /* Class name */
- };
-
- struct EjsVar *baseClass; /* Pointer to base class object */
-
- EjsPropLink link; /* Ordered list of properties */
-
- /* OPT -- dynamically allocate this only if required */
- EjsProperty *propertyHash[EJS_OBJ_HASH_SIZE]; /* Hash chains */
-
- /* OPT -- could save this and store off baseClass only */
- EjsMethods *methods; /* Property access methods */
- void *nativeData; /* Native object data */
-
- int (*destructor)(Ejs *ejs, struct EjsVar *vp);
-
- uint numProperties : 16; /* Total count of items */
- uint visited : 1; /* Has been traversed */
- uint gcMarked : 1; /* Node marked in-use by GC */
- uint permanent : 1; /* Permanent object, dont GC */
- uint alive : 1; /* Only GC if alive */
- uint noConstructor : 1; /* Object has no constructor */
- uint dirty : 1; /* Object has been modified */
- uint hasErrors : 1; /* Update error */
- uint preventDeleteProp : 1; /* Don't allow prop deletion */
- uint delayedDeleteProp : 1; /* Delayed delete of props */
- uint reserved : 7; /* Unused */
-
- Ejs *ejs; /* Owning interp */
-
-#if BLD_FEATURE_MULTITHREAD
- MprLock *mutex; /* Advisory mutex lock */
-#endif
-} EjsObj;
-
-
-/*
- * Define a field macro so code an use numbers in a "generic" fashion.
- */
-#if EJS_NUM_VAR == EJS_TYPE_INT || DOXYGEN
-/*
- * Default numeric type
- */
-#define ejsNumber integer
-#endif
-#if EJS_NUM_VAR == EJS_TYPE_INT64
-/* Default numeric type */
-#define ejsNumber integer64
-#endif
-#if EJS_NUM_VAR == EJS_TYPE_FLOAT
-/* Default numeric type */
-#define ejsNumber floating
-#endif
-
-typedef BLD_FEATURE_NUM_TYPE EjsNumber;
-
-/*
- * Memory allocation slabs
- */
-#define EJS_SLAB_OBJ 0
-#define EJS_SLAB_PROPERTY 1
-#define EJS_SLAB_VAR 2
-#define EJS_SLAB_MAX 3
-
-/**
- * Object and pointer property destructory type
- */
-typedef int (*EjsDestructor)(Ejs *ejs, EjsVar *vp);
-
-#if BLD_FEATURE_ALLOC_LEAK_TRACK || DOXYGEN
-/*
- * Line number information args and declarations for ejsAlloc.
- * Use EJS_LOC_ARGS in normal user code.
- * Use EJS_LOC_DEC in declarations.
- * Use EJS_LOC_PASS in layered APIs to pass original line info down.
- */
-#define EJS_LOC_ARGS(ejs) ejs, MPR_LOC
-#define EJS_LOC_DEC(ejs, loc) Ejs *ejs, const char *loc
-#define EJS_LOC_PASS(ejs, loc) ejs, loc
-#else
-#define EJS_LOC_ARGS(ejs) ejs
-#define EJS_LOC_DEC(ejs, loc) Ejs *ejs
-#define EJS_LOC_PASS(ejs, loc) ejs
-#endif
-
-/******************************* Internal Prototypes **************************/
-
-#define ejsInitVar(vp, varType) \
- if (1) { \
- (vp)->type = varType; \
- (vp)->isArray = 0; \
- (vp)->flags = 0; \
- } else
-extern void ejsClearVar(Ejs *ep, EjsVar *vp);
-
-extern int ejsDestroyObj(Ejs *ep, EjsObj *obj);
-extern EjsVar *ejsCreatePropertyMethod(Ejs *ep, EjsVar *obj,
- const char *name);
-extern EjsVar *ejsSetPropertyMethod(Ejs *ep, EjsVar *obj, const char *name,
- const EjsVar *value);
-extern EjsVar *ejsGetPropertyMethod(Ejs *ep, EjsVar *obj, const char *name);
-extern int ejsDeletePropertyMethod(Ejs *ep, EjsVar *obj,
- const char *name);
-extern void ejsSetArrayLength(Ejs *ep, EjsVar *obj, const char *creating,
- const char *deleting, const EjsVar *setLength);
-
-/*
- * At the moment, these are the same routine
- */
-extern void ejsSetClassName(Ejs *ep, EjsVar *obj, const char *name);
-#define ejsSetObjName ejsSetObjName
-
-extern bool ejsIsObjDirty(EjsVar *vp);
-extern void ejsResetObjDirtyBit(EjsVar *vp);
-
-extern int ejsObjHasErrors(EjsVar *vp);
-extern void ejsClearObjErrors(EjsVar *vp);
-
-extern EjsVar *ejsClearProperty(Ejs *ep, EjsVar *obj, const char *prop);
-
-typedef int (*EjsSortFn)(Ejs *ep, EjsProperty *p1, EjsProperty *p2,
- const char *propertyName, int order);
-extern void ejsSortProperties(Ejs *ep, EjsVar *obj, EjsSortFn fn,
- const char *propertyName, int order);
-
-#if BLD_DEBUG
-#define ejsSetVarName(ep, vp, varName) \
- if (1) { \
- (vp)->propertyName = varName; \
- if ((vp)->type == EJS_TYPE_OBJECT && \
- (vp)->objectState && \
- ((vp)->objectState->objName == 0)) { \
- (vp)->objectState->objName = \
- mprStrdup(ep, varName); \
- } \
- } else
-#else
-#define ejsSetVarName(ep, vp, varName)
-#endif
-
-EjsVar *ejsFindProperty(Ejs *ep, EjsVar **obj, char **property,
- EjsVar *global, EjsVar *local, const char *fullName,
- int create);
-
-extern EjsVar *ejsCopyProperties(Ejs *ep, EjsVar *dest,
- const EjsVar *src, EjsCopyDepth copyDepth);
-
-#define EJS_LINK_OFFSET ((uint) (&((EjsProperty*) 0)->link))
-#define ejsGetPropertyFromLink(lp) \
- ((EjsProperty*) ((char*) lp - EJS_LINK_OFFSET))
-
-#define ejsGetObjPtr(vp) ((EjsObj*) vp->objectState)
-
-extern void ejsMakePropertyPrivate(EjsProperty *pp, int isPrivate);
-extern void ejsMakePropertyReadOnly(EjsProperty *pp, int readonly);
-extern void ejsMakePropertyUndeleteable(EjsProperty *pp, int deletable);
-extern int ejsMakeObjLive(EjsVar *vp, bool alive);
-extern void ejsMakeClassNoConstructor(EjsVar *vp);
-
-extern bool ejsBlockInUseInt(EjsVar *vp);
-#if BLD_DEBUG
- #define ejsBlockInUse(vp) ejsBlockInUseInt(vp)
-#else
- #define ejsBlockInUse(vp)
-#endif
-
-/********************************* Prototypes *********************************/
-
-/*
- * Variable constructors and destructors
- */
-extern EjsVar *ejsCreateBinaryStringVar(Ejs *ep, const uchar *value,
- int len);
-extern EjsVar *ejsCreateBoolVar(Ejs *ep, int value);
-extern EjsVar *ejsCreateCMethodVar(Ejs *ep, EjsCMethod fn,
- void *userData, int flags);
-#if BLD_FEATURE_FLOATING_POINT
-extern EjsVar *ejsCreateFloatVar(Ejs *ep, double value);
-#endif
-extern EjsVar *ejsCreateIntegerVar(Ejs *ep, int value);
-#if BLD_FEATURE_INT64
-extern EjsVar *ejsCreateInteger64Var(Ejs *ep, int64 value);
-#endif
-
-extern EjsVar *ejsCreateMethodVar(Ejs *ep, const char *body,
- MprArray *args, int flags);
-extern EjsVar *ejsCreateNullVar(Ejs *ep);
-extern EjsVar *ejsCreateNumberVar(Ejs *ep, EjsNumber value);
-
-#define ejsCreateObjVar(ep) \
- ejsCreateObjVarInternal(EJS_LOC_ARGS(ep))
-extern EjsVar *ejsCreateObjVarInternal(EJS_LOC_DEC(ep, loc));
-
-extern EjsVar *ejsCreatePtrVar(Ejs *ep, void *ptr, EjsDestructor dest);
-
-extern EjsVar *ejsCreateStringCMethodVar(Ejs *ep, EjsStringCMethod fn,
- void *userData, int flags);
-
-#define ejsCreateStringVar(ep, value) \
- ejsCreateStringVarInternal(EJS_LOC_ARGS(ep), value)
-extern EjsVar *ejsCreateStringVarInternal(EJS_LOC_DEC(ep, loc),
- const char *value);
-
-extern EjsVar *ejsCreateUndefinedVar(Ejs *ep);
-
-/* MOB -- naming. Should be Create/Destroy */
-extern void ejsFreeVar(Ejs *ep, EjsVar *vp);
-
-/*
- * Var support routines
- */
-extern int ejsGetVarFlags(EjsVar *vp);
-extern void ejsSetVarFlags(EjsVar *obj, int flags);
-
-extern EjsType ejsGetVarType(EjsVar *vp);
-extern const char *ejsGetVarTypeAsString(EjsVar *vp);
-
-extern void *ejsGetCMethodUserData(EjsVar *obj);
-extern void ejsSetCMethodUserData(EjsVar *obj, void *userData);
-
-extern void *ejsGetVarUserPtr(EjsVar *vp);
-extern void ejsSetVarUserPtr(EjsVar *vp, void *data);
-
-
-/*
- * Variable access and manipulation. These work on standalone objects.
- */
-#define ejsDupVar(ep, src, copyDepth) \
- ejsDupVarInternal(EJS_LOC_ARGS(ep), src, copyDepth)
-extern EjsVar *ejsDupVarInternal(EJS_LOC_DEC(ep, loc), EjsVar *src,
- EjsCopyDepth copyDepth);
-#define ejsWriteVar(ep, dest, src, copyDepth) \
- ejsWriteVarInternal(EJS_LOC_ARGS(ep), dest, src, copyDepth)
-extern EjsVar *ejsWriteVarInternal(EJS_LOC_DEC(ep, loc), EjsVar *dest,
- const EjsVar *src, EjsCopyDepth copyDepth);
-extern EjsVar *ejsWriteVarAsBinaryString(Ejs *ep, EjsVar *dest,
- const uchar *value, int len);
-extern EjsVar *ejsWriteVarAsBoolean(Ejs *ep, EjsVar *dest, bool value);
-extern EjsVar *ejsWriteVarAsCMethod(Ejs *ep, EjsVar *dest, EjsCMethod fn,
- void *userData, int flags);
-#if BLD_FEATURE_FLOATING_POINT
-extern EjsVar *ejsWriteVarAsFloat(Ejs *ep, EjsVar *dest, double value);
-#endif
-extern EjsVar *ejsWriteVarAsInteger(Ejs *ep, EjsVar *dest, int value);
-#if BLD_FEATURE_INT64
-extern EjsVar *ejsWriteVarAsInteger64(Ejs *ep, EjsVar *dest, int64 value);
-#endif
-extern EjsVar *ejsWriteVarAsMethod(Ejs *ep, EjsVar *dest,
- const char *body, MprArray *args);
-extern EjsVar *ejsWriteVarAsNull(Ejs *ep, EjsVar *dest);
-extern EjsVar *ejsWriteVarAsNumber(Ejs *ep, EjsVar *dest, EjsNum value);
-#define ejsWriteVarAsString(ep, dest, value) \
- ejsWriteVarAsStringInternal(EJS_LOC_ARGS(ep), dest, value)
-extern EjsVar *ejsWriteVarAsStringInternal(EJS_LOC_DEC(ep, loc),
- EjsVar *dest, const char *value);
-extern EjsVar *ejsWriteVarAsStringCMethod(Ejs *ep, EjsVar *dest,
- EjsStringCMethod fn, void *userData, int flags);
-extern EjsVar *ejsWriteVarAsUndefined(Ejs *ep, EjsVar *dest);
-
-/*
- * These routines do not convert types
- */
-/* MOB -- make this a fn and pass back the length as an arg */
-#define ejsReadVarAsBinaryString(vp) ((const uchar*) (vp->ustring));
-#define ejsReadVarAsBoolean(vp) (vp->boolean);
-#define ejsReadVarAsCMethod(vp) (vp->cMethod);
-#if BLD_FEATURE_FLOATING_POINT
-#define ejsReadVarAsFloat(vp) (vp->floating);
-#endif
-#define ejsReadVarAsInteger(vp) (vp->integer);
-#if BLD_FEATURE_INT64
-#define ejsReadVarAsInteger64(vp) (vp->int64);
-#endif
-#define ejsReadVarAsString(vp) ((const char*) (vp->string));
-#define ejsReadVarAsStringCMethod(vp) (vp->cMethodWithStrings);
-/* MOB -- remove this fn */
-#define ejsReadVarStringLength(vp) (vp->length);
-
-/*
- * Object property creation routines
- */
-extern EjsProperty *ejsCreateProperty(Ejs *ep, EjsVar *obj, const char *prop);
-extern EjsProperty *ejsCreateSimpleProperty(Ejs *ep, EjsVar *obj,
- const char *prop);
-extern EjsProperty *ejsCreateSimpleNonUniqueProperty(Ejs *ep, EjsVar *obj,
- const char *prop);
-/* MOB -- should be destroy */
-extern int ejsDeleteProperty(Ejs *ep, EjsVar *obj, const char *prop);
-
-
-/*
- * Get property routines
- */
-extern EjsProperty *ejsGetProperty(Ejs *ep, EjsVar *obj, const char *prop);
-extern EjsProperty *ejsGetSimpleProperty(Ejs *ep, EjsVar *obj,
- const char *prop);
-
-extern EjsVar *ejsGetPropertyAsVar(Ejs *ep, EjsVar *obj,
- const char *prop);
-extern int ejsGetPropertyCount(EjsVar *obj);
-
-extern const uchar *ejsGetPropertyAsBinaryString(Ejs *ep, EjsVar *obj,
- const char *prop, int *length);
-extern bool ejsGetPropertyAsBoolean(Ejs *ep, EjsVar *obj,
- const char *prop);
-extern int ejsGetPropertyAsInteger(Ejs *ep, EjsVar *obj,
- const char *prop);
-extern int64 ejsGetPropertyAsInteger64(Ejs *ep, EjsVar *obj,
- const char *prop);
-extern EjsNum ejsGetPropertyAsNumber(Ejs *ep, EjsVar *obj,
- const char *prop);
-extern void *ejsGetPropertyAsPtr(Ejs *ep, EjsVar *obj,
- const char *prop);
-extern const char *ejsGetPropertyAsString(Ejs *ep, EjsVar *obj,
- const char *prop);
-
-/*
- * Object property update routines
- */
-extern EjsProperty *ejsSetBaseProperty(Ejs *ep, EjsVar *obj, const char *prop,
- const EjsVar *value);
-extern EjsProperty *ejsSetProperty(Ejs *ep, EjsVar *obj, const char *prop,
- const EjsVar *value);
-extern EjsProperty *ejsSetPropertyAndFree(Ejs *ep, EjsVar *obj,
- const char *prop, EjsVar *value);
-extern EjsProperty *ejsSetPropertyToBinaryString(Ejs *ep, EjsVar *obj,
- const char *prop, const uchar *value, int len);
-extern EjsProperty *ejsSetPropertyToBoolean(Ejs *ep, EjsVar *obj,
- const char *prop, bool value);
-extern EjsProperty *ejsSetPropertyToCMethod(Ejs *ep, EjsVar *obj,
- const char *prop, EjsCMethod fn, void *userData,
- int flags);
-#if BLD_FEATURE_FLOATING_POINT
-extern EjsProperty *ejsSetPropertyToFloat(Ejs *ep, EjsVar *obj,
- const char *prop, double value);
-#endif
-extern EjsProperty *ejsSetPropertyToInteger(Ejs *ep, EjsVar *obj,
- const char *prop, int value);
-#if BLD_FEATURE_INT64
-extern EjsProperty *ejsSetPropertyToInteger64(Ejs *ep, EjsVar *obj,
- const char *prop, int64 value);
-#endif
-extern EjsProperty *ejsSetPropertyToMethod(Ejs *ep, EjsVar *obj,
- const char *prop, const char *body, MprArray *args,
- int flags);
-extern EjsProperty *ejsSetPropertyToNewObj(Ejs *ep, EjsVar *obj,
- const char *prop, const char *className,
- MprArray *args);
-extern EjsProperty *ejsSetPropertyToNull(Ejs *ep, EjsVar *obj,
- const char *prop);
-extern EjsProperty *ejsSetPropertyToNumber(Ejs *ep, EjsVar *obj,
- const char *prop, EjsNum value);
-extern EjsProperty *ejsSetPropertyToObj(Ejs *ep, EjsVar *obj,
- const char *prop);
-extern EjsProperty *ejsSetPropertyToPtr(Ejs *ep, EjsVar *obj,
- const char *prop, void *ptr, EjsDestructor destructor);
-
-extern EjsProperty *ejsSetPropertyToStringCMethod(Ejs *ep, EjsVar *obj,
- const char *prop, EjsStringCMethod fn,
- void *userData, int flags);
-extern EjsProperty *ejsSetPropertyToString(Ejs *ep, EjsVar *obj,
- const char *prop, const char *value);
-extern EjsProperty *ejsSetPropertyToUndefined(Ejs *ep, EjsVar *obj,
- const char *prop);
-
-
-/* Convenience function */
-extern EjsVar *ejsSetPropertyToObjAsVar(Ejs *ep, EjsVar *obj,
- const char *prop);
-extern void ejsSetObjDestructor(Ejs *ep, EjsVar *obj,
- EjsDestructor destructor);
-extern void ejsClearObjDestructor(Ejs *ep, EjsVar *obj);
-
-/*
- * Enumeration of properties
- * MOB -- should these take an ejs parameter to be consistent
- */
-extern EjsProperty *ejsGetFirstProperty(const EjsVar *obj, int flags);
-extern EjsProperty *ejsGetNextProperty(EjsProperty *last, int flags);
-
-/*
- * Method definition and control.
- */
-extern EjsProperty *ejsDefineMethod(Ejs *ep, EjsVar *obj, const char *prop,
- const char *body, MprArray *args);
-extern EjsProperty *ejsDefineCMethod(Ejs *ep, EjsVar *obj, const char *prop,
- EjsCMethod fn, int flags);
-
-extern EjsProperty *ejsDefineStringCMethod(Ejs *ep, EjsVar *obj,
- const char *prop, EjsStringCMethod fn, int flags);
-
-extern EjsProperty *ejsDefineAccessors(Ejs *ep, EjsVar *obj,
- const char *prop, const char *getBody,
- const char *setBody);
-extern EjsProperty *ejsDefineCAccessors(Ejs *ep, EjsVar *obj,
- const char *prop, EjsCMethod getFn, EjsCMethod setFn,
- int flags);
-
-/*
- * Macro to get the variable value portion of a property
- */
-#define ejsGetVarPtr(pp) (&((pp)->var))
-#define ejsGetPropertyPtr(vp) ((EjsProperty*) vp)
-
-/* MOB -- take ejs to be consistent */
-extern int ejsMakePropertyEnumerable(EjsProperty *pp, bool enumerable);
-extern int ejsMakeObjPermanent(EjsVar *vp, bool permanent);
-
-
-/*
- * Var conversion routines
- * MOB -- should these take an Ejs as first arg for consistency
- */
-extern bool ejsVarToBoolean(EjsVar *vp);
-#if BLD_FEATURE_FLOATING_POINT
-extern double ejsVarToFloat(EjsVar *vp);
-#endif
-extern int ejsVarToInteger(EjsVar *vp);
-#if BLD_FEATURE_INT64
-extern int64 ejsVarToInteger64(EjsVar *vp);
-#endif
-extern EjsNum ejsVarToNumber(EjsVar *vp);
-extern char *ejsVarToString(Ejs *ep, EjsVar *vp);
-extern char *ejsVarToStringEx(Ejs *ep, EjsVar *vp, bool *alloc);
-extern char *ejsFormatVar(Ejs *ep, const char *fmt, EjsVar *vp);
-
-#if BLD_FEATURE_FLOATING_POINT
-extern double ejsParseFloat(const char *str);
-#endif
-/*
- * Parsing and type range checking routines
- */
-extern bool ejsParseBoolean(const char *str);
-extern int ejsParseInteger(const char *str);
-#if BLD_FEATURE_INT64
-extern int64 ejsParseInteger64(const char *str);
-#endif
-extern EjsNum ejsParseNumber(const char *str);
-extern EjsVar *ejsParseVar(Ejs *ep, const char *str, EjsType prefType);
-
-#if BLD_FEATURE_FLOATING_POINT
-extern bool ejsIsInfinite(double f);
-extern bool ejsIsNan(double f);
-#endif
-
-/*
- * Advisory locking support
- */
-#if BLD_FEATURE_MULTITHREAD
-extern void ejsLockObj(EjsVar *vp);
-extern void ejsUnlockObj(EjsVar *vp);
-#endif
-
-/*
- * Just for debugging
- */
-extern bool ejsObjIsCollectable(EjsVar *vp);
-
-#ifdef __cplusplus
-}
-#endif
-
-/*****************************************************************************/
-#endif /* _h_EJS_VAR */
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- * @file event.js
- * @brief Event class
- * @copy Copyright (c) Mbedthis Software LLC, 2005-2006. All Rights Reserved.
- *
- * Usage:
- * listener = new System.Listener();
- * listener.onClick = function() {
- * // Any code here
- * }
- * eventTarget.addListener(eventName, listener);
- * or
- * listener = new System.Listener(obj, method);
- * eventTarget.addListener(eventName, listener);
- *
- * To fire events:
- * eventTarget.fire(eventName, new System.Event("My Event"));
- */
-
-/******************************************************************************/
-/*
- * Base event class
- */
-class System.Event
-{
- var type; // keyboard
- var timeStamp;
- var arg;
-
- /* MOB -- constructor should take a type */
- function Event(arg)
- {
- timeStamp = time();
- type = "default";
- this.arg = arg;
- }
-}
-
-/* MOB -- should not be needed */
-Event = System.Event;
-
-class System.Listener
-{
- var obj;
- var method;
-
- function Listener(obj, method)
- {
- if (arguments.length >= 1) {
- this.obj = obj;
- } else {
- this.obj = this;
- }
- if (arguments.length == 2) {
- this.method = method;
- } else {
- this.method = "onEvent";
- }
- }
-}
-/* MOB -- should not be needed */
-Listener = System.Listener;
-
-
-/*
- * The Event target class
- */
-class System.EventTarget
-{
- // Private
- var events; /* Hash of a event names */
-
- function EventTarget()
- {
- events = new Object();
- }
-
- // Public
- function addListener(eventName, listener)
- {
- var listeners = events[eventName];
- if (listeners == undefined) {
- listeners = events[eventName] = new Array();
- }
- if (arguments.length == 2) {
- var method = eventName;
- }
- /* MOB OPT */
- for (var i = 0; i < listeners.length; i++) {
- var l = listeners[i];
- if (l == listener) {
- return;
- }
- }
- listeners[listeners.length] = listener;
- }
-
- function removeListener(eventName, listener)
- {
- var listeners = events[eventName];
-
- if (listeners == undefined) {
- return;
- }
-
- for (var i = 0; i < listeners.length; i++) {
- var l = listeners[i];
- if (l == listener) {
- // MOB -- want listeners.splice here
- // listeners.splice(i, 1);
- for (var j = i; j < (listeners.length - 1); j++) {
- listeners[j] = listeners[j + 1];
- }
- delete listeners[listeners.length - 1];
- i = listeners.length;
- }
- }
- }
-
- function fire(eventName, event)
- {
- var listeners = events[eventName];
-
- if (listeners == undefined) {
- // println("Event.fire(): unknown eventName " + eventName);
- return;
- }
-
- for (var i = listeners.length - 1; i >= 0; i--) {
- var listener = listeners[i];
- var method = listener.obj[listener.method];
- if (method == undefined) {
- throw new EvalError("Undefined method: " + listener.method);
- }
- listener.obj[listener.method](listener, event);
- }
- }
-}
-
-/* MOB -- should not be needed */
-EventTarget = System.EventTarget;
+++ /dev/null
-/*
- * @file global.js
- * @brief Misc global functions
- * @copy Copyright (c) Mbedthis Software LLC, 2005-2006. All Rights Reserved.
- */
-
-/******************************************************************************/
-
-function min(a, b)
-{
- if (a < b) {
- return a;
- } else {
- return b;
- }
-}
-
-
-function max(a, b)
-{
- if (a > b) {
- return a;
- } else {
- return b;
- }
-}
-
-function abs(a)
-{
- if (a < 0) {
- return -a;
- }
- return a;
-}
+++ /dev/null
-/*
- * @file startup.js
- * @brief Embedded JavaScript Startup Code
- * @copy Copyright (c) Mbedthis Software LLC, 2005-2006. All Rights Reserved.
- *
- * Invoked automatically on startup.
- */
-
-/******************************************************************************/
-
-// println("Loading startup.js ...");
-
-include("lib/event.js");
-include("lib/global.js");
-include("lib/timer.js");
+++ /dev/null
-/*
- * @file timer.js
- * @brief Timer class
- * @copy Copyright (c) Mbedthis Software LLC, 2005-2006. All Rights Reserved.
- *
- * Usage:
- * timer = new System.Timer("name", period);
- * timer.onTick = function(arg) {
- * // Anything here
- * }
- * timer.start();
- * or
- *
- * timer = new System.Timer("name", period, obj, method);
- * timer.start();
- */
-
-/******************************************************************************/
-
-class System.Timer
-{
- var id;
-
- /* MOB -- really need accessor on period. If user updates period,
- then due must be updated. */
- var period;
- var due;
- var runOnce; // Run timer just once
- var method; // Callback method
- var obj; // Callback object
-
- function Timer(id, period, obj, method)
- {
- this.id = id;
- this.period = period;
- due = time() + period;
-
- if (arguments.length >= 3) {
- this.obj = obj;
- } else {
- this.obj = this;
- }
- if (arguments.length >= 4) {
- this.method = method;
- } else {
- this.method = "onTick";
- }
- }
-
- /* MOB this should be deprecated */
- function reschedule(period)
- {
- /* MOB -- should update the timer service somehow */
- this.period = period;
- }
-
- function run(now)
- {
- if (obj[method] == undefined) {
- trace("Timer cant find timer method " + method);
- due = now + this.period;
- return;
- }
-
- /*
- * Run the timer
- */
- try {
- obj[method](this);
- }
- catch (error) {
- trace("Timer exception: " + error);
- }
-
- if (runOnce) {
- timerService.removeTimer(this);
-
- } else {
- due = now + this.period;
- }
- }
-
- function start()
- {
- if (obj[method] == undefined) {
- throw new Error("Callback method is undefined");
- } else {
- timerService.addTimer(this);
- }
- }
-
- function stop()
- {
- timerService.removeTimer(this);
- }
-
-}
-
-/* MOB -- should not need this */
-Timer = System.Timer;
-
-
-/*
- * Timer service
- */
-class System.TimerService
-{
- var timers;
- var nextDue;
-
- function TimerService()
- {
- timers = new Object();
- nextDue = 0;
- global.timerService = this;
- }
-
- function addTimer(timer)
- {
- timers[timer.id] = timer;
- }
-
- function removeTimer(timer)
- {
- try {
- delete timers[timer.id];
- }
- catch {}
- }
-
- function getIdleTime()
- {
- return nextDue - time();
- }
-
- function runTimers()
- {
- var now = time();
-
- nextDue = 2147483647; /* MOB -- MATH.MAX_INT; */
-
- for each (var timer in timers)
- {
- if (timer.due < now) {
- timer.run(now);
- }
- }
- for each (var timer in timers)
- {
- if (timer.due < nextDue) {
- nextDue = timer.due;
- }
- }
- // println("runTimers leaving with " + (nextDue - now));
- return nextDue - time();
- }
-}
-TimerService = System.TimerService;
+++ /dev/null
-#
-# Makefile to build the EJS Object Model
-#
-# Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
-#
-
-COMPILE := *.c
-EXPORT_OBJECTS := yes
-MAKE_IFLAGS := -I.. -I../../mpr -I../../exml
-
-include make.dep
-
-ifeq ($(BLD_HOST_UNIX),1)
-PRE_DIRS = UNIX
-else
-PRE_DIRS = $(BLD_HOST_OS)
-endif
-
-compileExtra: .updated
-
-.updated: $(FILES)
- @touch .updated
-
-## Local variables:
-## tab-width: 4
-## End:
-## vim: tw=78 sw=4 ts=4
+++ /dev/null
-Embedded JavaScript System Model
-
-
-- Need args, arg types and exceptions thrown
-- Error classes
-
-class Global
- class System
- class environment
- var
- class GC
- void function run()
- function tune()
- function getUsedMemory() // Should be properties
- function getAllocatedMemory() // Should be properties
-
- var javascript
- var null
- var undefined
- var true
- var false
- var Nan
- var Infinity
-
- function random // Not implemented
- function sleep // Not implemented
- function exit
- function yield // Not implemented
-
- Debug
- isDebugMode
-
- Limits
- isLimitsMode // Not implemented
- stack // Not implemented
- heap // Not implemented
- flash // Not implemented
-
- Memory
- getUsedMemory() // Should be properties
- getAvailableMemory() // Should be properties
- used
- flash // Not implemented
-
- assert()
- breakpoint()
- dirname()
- basename()
- eval()
- exit()
- print()
- println()
- printVars()
- sleep()
- sort()
- time()
- typeof()
- include()
- trace()
- printf() // Not implemented
- sprintf()
-
-
+++ /dev/null
-#
-# Makefile to build the EJS Object Model for WIN
-#
-# Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
-#
-
-COMPILE := *.c
-EXPORT_OBJECTS := yes
-MAKE_IFLAGS := -I../.. -I../../../mpr
-
-include make.dep
-
-compileExtra: .updated
-
-.updated: $(FILES)
- @touch .updated
-
-## Local variables:
-## tab-width: 4
-## End:
-## vim: tw=78 sw=4 ts=4
+++ /dev/null
-/*
- * @file ejsFile.c
- * @brief File class for the EJ System Object Model
- */
-/********************************** Copyright *********************************/
-/*
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- */
-/********************************** Includes **********************************/
-
-#include "ejs.h"
-
-/******************************************************************************/
-/*
- * Default Constructor
- */
-
-/******************************************************************************/
-/************************************ Methods *********************************/
-/******************************************************************************/
-/*
- * function open();
- */
-
-static int openProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- ejsTrace(ep, "File.open()\n");
- return 0;
-}
-
-/******************************************************************************/
-/*
- * function close();
- */
-
-static int closeProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- ejsTrace(ep, "File.close()\n");
- return 0;
-}
-
-/******************************************************************************/
-/*
- * function read();
- */
-
-static int readProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- ejsTrace(ep, "File.read()\n");
- return 0;
-}
-
-/******************************************************************************/
-/*
- * function write();
- */
-
-static int writeProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- ejsTrace(ep, "File.write()\n");
- return 0;
-}
-
-/******************************************************************************/
-/******************************** Initialization ******************************/
-/******************************************************************************/
-
-int ejsDefineFileClass(Ejs *ep)
-{
- EjsVar *fileClass;
-
- fileClass = ejsDefineClass(ep, "File", "Object", 0);
- if (fileClass == 0) {
- return MPR_ERR_CANT_INITIALIZE;
- }
-
- /*
- * Define the methods
- */
- ejsDefineCMethod(ep, fileClass, "open", openProc, 0);
- ejsDefineCMethod(ep, fileClass, "close", closeProc, 0);
- ejsDefineCMethod(ep, fileClass, "read", readProc, 0);
- ejsDefineCMethod(ep, fileClass, "write", writeProc, 0);
-
- return ejsObjHasErrors(fileClass) ? MPR_ERR_CANT_INITIALIZE: 0;
-}
-
-/******************************************************************************/
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- * @file ejsFileSystem.c
- * @brief FileSystem class for the EJ System Object Model
- * MOB -- this is almost the same as for Windows. Should common up.
- */
-/********************************** Copyright *********************************/
-/*
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- */
-/********************************** Includes **********************************/
-
-#include "ejs.h"
-#include <dirent.h>
-
-/******************************************************************************/
-/************************************ Methods *********************************/
-/******************************************************************************/
-/*
- * function void access(string path);
- * MOB - API insufficient. Access for read or write?
- */
-
-static int accessProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- int rc;
-
- if (argc != 1 || !ejsVarIsString(argv[0])) {
- ejsError(ejs, EJS_ARG_ERROR, "Bad usage: access(path)");
- return -1;
- }
-
- rc = access(argv[0]->string, 04);
-
- ejsSetReturnValueToBoolean(ejs, (rc == 0) ? 1 : 0);
- return 0;
-}
-
-/******************************************************************************/
-/*
- * function void mkdir(string path);
- */
-
-static int mkdirProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- if (argc != 1 || !ejsVarIsString(argv[0])) {
- ejsError(ejs, EJS_ARG_ERROR, "Bad usage: mkdir(path)");
- return -1;
- }
-
- if (mprMakeDirPath(ejs, argv[0]->string) < 0) {
- ejsError(ejs, EJS_IO_ERROR, "Cant create directory");
- return -1;
- }
- return 0;
-}
-
-/******************************************************************************/
-/*
- * function void rmdir(string path);
- */
-
-static int rmdirProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- int rc;
-
- if (argc != 1 || !ejsVarIsString(argv[0])) {
- ejsError(ejs, EJS_ARG_ERROR, "Bad usage: mkdir(path)");
- return -1;
- }
-
- rc = mprDeleteDir(ejs, argv[0]->string);
-
- if (rc < 0) {
- ejsError(ejs, EJS_IO_ERROR, "Cant remove directory");
- return -1;
- }
- return 0;
-}
-
-/******************************************************************************/
-/*
- * function void dirList(string path, [bool enumDirs]);
- * MOB -- need pattern to match (what about "." and ".." and ".*"
- */
-
-static int dirListProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- DIR *dir;
- struct dirent *dirent;
- char path[MPR_MAX_FNAME];
- EjsVar *array, *vp;
- uchar enumDirs;
-
- if (argc < 1 || !ejsVarIsString(argv[0])) {
- ejsError(ejs, EJS_ARG_ERROR, "Bad usage: dirList(path)");
- return -1;
- }
- if (argc == 2) {
- enumDirs = ejsVarToBoolean(argv[1]);
- } else {
- enumDirs = 0;
- }
- array = ejsCreateArray(ejs, 0);
- ejsMakeObjPermanent(array, 1);
-
- /*
- * First collect the files
- */
- mprSprintf(path, sizeof(path), "%s/*.*", argv[0]->string);
-
- dir = opendir(path);
- if (dir == 0) {
- ejsError(ejs, EJS_ARG_ERROR, "Can't enumerate dirList(path)");
- return -1;
- }
-
- while ((dirent = readdir(dir)) != 0) {
- if (dirent->d_name[0] == '.') {
- continue;
- }
- if (!enumDirs || (dirent->d_type & DT_DIR)) {
- mprSprintf(path, sizeof(path), "%s/%s", argv[0]->string,
- dirent->d_name);
- vp = ejsCreateStringVar(ejs, path);
- ejsAddArrayElt(ejs, array, vp, EJS_SHALLOW_COPY);
- ejsFreeVar(ejs, vp);
- }
- }
-
- closedir(dir);
-
- ejsSetReturnValue(ejs, array);
- ejsMakeObjPermanent(array, 0);
-
- /*
- * Can free now as the return value holds the reference
- */
- ejsFreeVar(ejs, array);
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * function void getFreeSpace();
- */
-
-static int getFreeSpaceProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
-#if UNUSED
- MprApp *app;
- uint space;
-
- app = mprGetApp(ejs);
- space = IFILEMGR_GetFreeSpace(app->fileMgr, 0);
- ejsSetReturnValueToInteger(ejs, space);
-#endif
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * function void writeFile(string path, var data);
- */
-
-static int writeFileProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- MprFile *file;
- char *data, *buf;
- int bytes, length, rc;
-
- if (argc != 2 || !ejsVarIsString(argv[0])) {
- ejsError(ejs, EJS_ARG_ERROR, "Bad usage: writeFile(path, var)");
- return -1;
- }
-
- if (ejsVarIsString(argv[1])) {
- data = argv[1]->string;
- length = argv[1]->length;
- buf = 0;
- } else {
- buf = data = ejsVarToString(ejs, argv[1]);
- length = strlen(data);
- }
-
- /*
- * Create fails if already present
- */
- rc = mprDelete(ejs, argv[0]->string);
- file = mprOpen(ejs, argv[0]->string, O_CREAT | O_WRONLY | O_BINARY, 0664);
- if (file == 0) {
- ejsError(ejs, EJS_IO_ERROR, "Cant create %s", argv[0]->string);
- mprFree(buf);
- return -1;
- }
-
- rc = 0;
- bytes = mprWrite(file, data, length);
- if (bytes != length) {
- ejsError(ejs, EJS_IO_ERROR, "Write error to %s", argv[1]->string);
- rc = -1;
- }
-
- mprClose(file);
-
- mprFree(buf);
- return rc;
-}
-
-/******************************************************************************/
-/*
- * function string readFile(string path);
- */
-
-static int readFileProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- MprApp *app;
- MprFile *file;
- MprBuf *buf;
- char *data;
- int bytes, rc;
-
- if (argc != 1 || !ejsVarIsString(argv[0])) {
- ejsError(ejs, EJS_ARG_ERROR, "Bad usage: readFile(path)");
- return -1;
- }
- buf = mprCreateBuf(ejs, MPR_BUF_INCR, MPR_MAX_BUF);
- if (buf == 0) {
- ejsMemoryError(ejs);
- return -1;
- }
-
- data = mprAlloc(ejs, MPR_BUFSIZE);
- if (buf == 0) {
- mprFree(buf);
- ejsMemoryError(ejs);
- return -1;
- }
-
- app = mprGetApp(ejs);
- file = mprOpen(ejs, argv[0]->string, O_RDONLY, 0664);
- if (file == 0) {
- ejsError(ejs, EJS_IO_ERROR, "Cant open %s", argv[0]->string);
- mprFree(buf);
- return -1;
- }
-
- rc = 0;
- while ((bytes = mprRead(file, data, MPR_BUFSIZE)) > 0) {
- if (mprPutBlockToBuf(buf, data, bytes) != bytes) {
- ejsError(ejs, EJS_IO_ERROR, "Write error to %s", argv[1]->string);
- rc = -1;
- break;
- }
- }
-
- ejsSetReturnValueToBinaryString(ejs, (uchar*) mprGetBufStart(buf),
- mprGetBufLength(buf));
-
- mprClose(file);
- mprFree(data);
- mprFree(buf);
-
- return rc;
-}
-
-/******************************************************************************/
-/*
- * function void remove(string path);
- */
-
-static int removeProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- int rc;
-
- if (argc != 1 || !ejsVarIsString(argv[0])) {
- ejsError(ejs, EJS_ARG_ERROR, "Bad usage: remove(path)");
- return -1;
- }
-
- rc = unlink(argv[0]->string);
- if (rc < 0) {
- ejsError(ejs, EJS_IO_ERROR, "Cant remove file");
- return -1;
- }
- return 0;
-}
-
-/******************************************************************************/
-/*
- * function void rename(string from, string to);
- */
-
-static int renameProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- int rc;
-
- if (argc != 2 || !ejsVarIsString(argv[0]) || !ejsVarIsString(argv[1])) {
- ejsError(ejs, EJS_ARG_ERROR, "Bad usage: rename(old, new)");
- return -1;
- }
-
- unlink(argv[1]->string);
- rc = rename(argv[0]->string, argv[1]->string);
- if (rc < 0) {
- ejsError(ejs, EJS_IO_ERROR, "Cant rename file");
- return -1;
- }
- return 0;
-}
-
-/******************************************************************************/
-/*
- * function void copy(string old, string new);
- */
-
-static int copyProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- MprFile *from, *to;
- char *buf;
- uint bytes;
- int rc;
-
- if (argc != 2 || !ejsVarIsString(argv[0]) || !ejsVarIsString(argv[1])) {
- ejsError(ejs, EJS_ARG_ERROR, "Bad usage: copy(old, new)");
- return -1;
- }
-
- buf = mprAlloc(ejs, MPR_BUFSIZE);
- if (buf == 0) {
- ejsMemoryError(ejs);
- return -1;
- }
-
- from = mprOpen(ejs, argv[0]->string, O_RDONLY | O_BINARY, 0664);
- if (from == 0) {
- ejsError(ejs, EJS_IO_ERROR, "Cant open %s", argv[0]->string);
- mprFree(buf);
- return -1;
- }
-
- to = mprOpen(ejs, argv[1]->string, O_CREAT | O_BINARY, 0664);
- if (to == 0) {
- ejsError(ejs, EJS_IO_ERROR, "Cant create %s", argv[1]->string);
- mprClose(from);
- mprFree(buf);
- return -1;
- }
-
- rc = 0;
- while ((bytes = mprRead(from, buf, MPR_BUFSIZE)) > 0) {
- if (mprWrite(to, buf, bytes) != bytes) {
- ejsError(ejs, EJS_IO_ERROR, "Write error to %s", argv[1]->string);
- rc = -1;
- break;
- }
- }
-
- mprClose(from);
- mprClose(to);
- mprFree(buf);
-
- return rc;
-}
-
-/******************************************************************************/
-/*
- * function FileInfo getFileInfo(string path);
- *
- * MOB -- should create a real class FileInfo
- */
-
-static int getFileInfoProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- MprFileInfo info;
- EjsVar *fileInfo;
- int rc;
-
- if (argc != 1 || !ejsVarIsString(argv[0])) {
- ejsError(ejs, EJS_ARG_ERROR, "Bad usage: getFileInfo(path)");
- return -1;
- }
-
- fileInfo = ejsCreateObjVar(ejs);
- if (fileInfo == 0) {
- ejsMemoryError(ejs);
- return -1;
- }
- ejsMakeObjPermanent(fileInfo, 1);
-
- rc = mprGetFileInfo(ejs, argv[0]->string, &info);
- if (rc < 0) {
- ejsMakeObjPermanent(fileInfo, 0);
- ejsFreeVar(ejs, fileInfo);
- ejsError(ejs, EJS_IO_ERROR, "Cant get file info for %s",
- argv[0]->string);
- return -1;
- }
-
- ejsSetPropertyToInteger(ejs, fileInfo, "created", info.ctime);
- ejsSetPropertyToInteger(ejs, fileInfo, "length", info.size);
- ejsSetPropertyToBoolean(ejs, fileInfo, "isDir", info.isDir);
-
- ejsSetReturnValue(ejs, fileInfo);
- ejsMakeObjPermanent(fileInfo, 0);
-
- return 0;
-}
-
-/******************************************************************************/
-/******************************** Initialization ******************************/
-/******************************************************************************/
-
-int ejsDefineFileSystemClass(Ejs *ejs)
-{
- EjsVar *fileSystemClass;
-
- fileSystemClass = ejsDefineClass(ejs, "FileSystem", "Object", 0);
- if (fileSystemClass == 0) {
- return MPR_ERR_CANT_INITIALIZE;
- }
-
- /*
- * Define the methods
- */
- ejsDefineCMethod(ejs, fileSystemClass, "access", accessProc, 0);
- ejsDefineCMethod(ejs, fileSystemClass, "mkdir", mkdirProc, 0);
- ejsDefineCMethod(ejs, fileSystemClass, "rmdir", rmdirProc, 0);
- ejsDefineCMethod(ejs, fileSystemClass, "dirList", dirListProc, 0);
- ejsDefineCMethod(ejs, fileSystemClass, "writeFile", writeFileProc, 0);
- ejsDefineCMethod(ejs, fileSystemClass, "readFile", readFileProc, 0);
- ejsDefineCMethod(ejs, fileSystemClass, "remove", removeProc, 0);
- ejsDefineCMethod(ejs, fileSystemClass, "rename", renameProc, 0);
- ejsDefineCMethod(ejs, fileSystemClass, "copy", copyProc, 0);
- ejsDefineCMethod(ejs, fileSystemClass, "getFileInfo", getFileInfoProc, 0);
-
- // MOB -- should be a property with accessor
- ejsDefineCMethod(ejs, fileSystemClass, "getFreeSpace", getFreeSpaceProc, 0);
-
- return ejsObjHasErrors(fileSystemClass) ? MPR_ERR_CANT_INITIALIZE: 0;
-}
-
-/******************************************************************************/
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- * @file ejsHTTP.c
- * @brief HTTP class for the EJ System Object Model
- */
-/********************************** Copyright *********************************/
-/*
- * Copyright (c) Mbedthis Software LLC, 2005-2006. All Rights Reserved.
- */
-/********************************** Includes **********************************/
-
-#include "ejs.h"
-
-#if UNUSED
-/*********************************** Defines **********************************/
-
-#define EJS_WEB_PROPERTY "-web"
-#define EJS_HTTP_PROPERTY "-http"
-
-#define EJS_HTTP_DISPOSED 550
-
-/*
- * Control structure for one HTTP request structure
- */
-typedef struct HTTPControl {
- Ejs *ejs;
- IWebResp *webResp;
- AEECallback *callback;
- MprBuf *buf;
- EjsVar *thisObj;
- char *url;
- MprTime requestStarted;
- uint timeout;
-} HTTPControl;
-
-/****************************** Forward Declarations **************************/
-
-static void cleanup(HTTPControl *hp);
-static int createWeb(Ejs *ejs, EjsVar *thisObj);
-static void brewCallback(HTTPControl *hp);
-static int httpDestructor(Ejs *ejs, EjsVar *vp);
-static void httpCallback(HTTPControl *hp, int responseCode);
-static int setCallback(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv);
-
-/******************************************************************************/
-/*
- * Constructor
- */
-
-int ejsHTTPConstructor(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- if (argc != 0 && argc != 2) {
- ejsError(ejs, EJS_ARG_ERROR,
- "Bad usage: HTTP([obj = this, method = onComplete]);");
- return -1;
- }
-
- if (createWeb(ejs, thisObj) < 0) {
- return -1;
- }
-
- setCallback(ejs, thisObj, argc, argv);
- return 0;
-}
-
-/******************************************************************************/
-
-static int createWeb(Ejs *ejs, EjsVar *thisObj)
-{
- MprApp *app;
- void *web;
-
- app = mprGetApp(ejs);
-
- /*
- * Create one instance of IWeb for the entire application. Do it here
- * so only widgets that require HTTP incurr the overhead.
- */
- web = mprGetKeyValue(ejs, "bpWeb");
- if (web == 0) {
- if (ISHELL_CreateInstance(app->shell, AEECLSID_WEB, &web) != SUCCESS) {
- ejsError(ejs, EJS_IO_ERROR, "Can't create IWEB");
- return -1;
- }
- }
- mprSetKeyValue(ejs, "bpWeb", web);
- return 0;
-}
-
-/******************************************************************************/
-/************************************ Methods *********************************/
-/******************************************************************************/
-/*
- * function setCallback(obj, methodString);
- */
-
-static int setCallback(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- if (argc >= 1) {
- ejsSetProperty(ejs, thisObj, "obj", argv[0]);
- } else {
- ejsSetProperty(ejs, thisObj, "obj", thisObj);
- }
-
- if (argc >= 2) {
- ejsSetProperty(ejs, thisObj, "method", argv[1]);
- } else {
- ejsSetPropertyToString(ejs, thisObj, "method", "onComplete");
- }
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * function fetch();
- */
-
-static int fetchProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- HTTPControl *hp;
- EjsProperty *pp;
- MprApp *app;
- IWeb *web;
-
- if (argc != 1 || !ejsVarIsString(argv[0])) {
- ejsError(ejs, EJS_ARG_ERROR, "Bad usage: fetch(url)");
- return -1;
- }
-
- app = mprGetApp(ejs);
- web = (IWeb*) mprGetKeyValue(ejs, "bpWeb");
-
- /*
- * Web options
- *
- * WEBOPT_USERAGENT (char*) sets user agent
- * WEBOPT_HANDLERDATA (void*)
- * WEBOPT_CONNECTTIMEOUT (uint) msec
- * WEBOPT_CONTENTLENGTH (long)
- * WEBOPT_IDLECONNTIMEOUT (int)
- * WEBOPT_ACTIVEXACTIONST (uint) Number of active requests
- *
- * WEBREQUEST_REDIRECT redirect transparently
- *
- */
-
- hp = mprAllocType(ejs, HTTPControl);
- if (hp == 0) {
- ejsMemoryError(ejs);
- return -1;
- }
-
- hp->ejs = ejs;
- hp->buf = mprCreateBuf(hp, MPR_BUF_INCR, MPR_MAX_BUF);
- if (hp->buf == 0) {
- mprFree(hp);
- ejsMemoryError(ejs);
- return -1;
- }
-
- /*
- * We copy thisObj because we need to preserve both the var and the object.
- * We pass the var to brewCallback and so it must persist. The call to
- * ejsMakeObjPermanent will stop the GC from collecting the object.
- */
- hp->thisObj = ejsDupVar(ejs, thisObj, EJS_SHALLOW_COPY);
- ejsSetVarName(ejs, hp->thisObj, "internalHttp");
-
- /*
- * Must keep a reference to the http object
- */
- ejsMakeObjPermanent(hp->thisObj, 1);
-
- /*
- * Make a property so we can access the HTTPControl structure from other
- * methods.
- */
- pp = ejsSetPropertyToPtr(ejs, thisObj, EJS_HTTP_PROPERTY, hp, 0);
- ejsMakePropertyEnumerable(pp, 0);
- ejsSetObjDestructor(ejs, hp->thisObj, httpDestructor);
-
- hp->url = mprStrdup(hp, argv[0]->string);
-
- hp->timeout = ejsGetPropertyAsInteger(ejs, thisObj, "timeout");
- mprGetTime(hp, &hp->requestStarted);
-
- hp->callback = mprAllocTypeZeroed(hp, AEECallback);
- CALLBACK_Init(hp->callback, brewCallback, hp);
-
- hp->webResp = 0;
- IWEB_GetResponse(web,
- (web, &hp->webResp, hp->callback, hp->url,
- WEBOPT_HANDLERDATA, hp,
- WEBOPT_USERAGENT, "Mozilla/4.0 (compatible; MSIE 5.5; Windows NT 5.0)",
- WEBOPT_CONNECTTIMEOUT, hp->timeout,
- WEBOPT_COPYOPTS, TRUE,
- WEBOPT_CONTENTLENGTH, 0,
- WEBOPT_END));
-
- ejsSetPropertyToString(ejs, thisObj, "status", "active");
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Called whenver the http object is deleted.
- */
-
-static int httpDestructor(Ejs *ejs, EjsVar *thisObj)
-{
- HTTPControl *hp;
-
- /*
- * If the httpCallback has run, then this property will not exist
- */
- hp = ejsGetPropertyAsPtr(ejs, thisObj, EJS_HTTP_PROPERTY);
-
- if (hp) {
- cleanup(hp);
- }
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Stop the request immediately without calling the callback
- */
-
-static int stopProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- HTTPControl *hp;
-
- hp = ejsGetPropertyAsPtr(ejs, thisObj, EJS_HTTP_PROPERTY);
-
- if (hp) {
- cleanup(hp);
- }
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Brew HTTP callback. Invoked for any return data.
- */
-
-static void brewCallback(HTTPControl *hp)
-{
- Ejs *ejs;
- EjsVar *thisObj;
- ISource *source;
- WebRespInfo *info;
- char data[MPR_BUF_INCR];
- int bytes;
-
- mprAssert(hp);
- mprAssert(hp->webResp);
-
- info = IWEBRESP_GetInfo(hp->webResp);
-
- if (info == 0) {
- mprAssert(info);
- /* should not happen */
- return;
- }
-
- ejs = hp->ejs;
- thisObj = hp->thisObj;
-
- if (! WEB_ERROR_SUCCEEDED(info->nCode)) {
- ejsSetPropertyToString(ejs, thisObj, "status", "error");
- httpCallback(hp, info->nCode);
- return;
- }
-
- if (hp->timeout) {
- if (mprGetTimeRemaining(hp, hp->requestStarted, hp->timeout) <= 0) {
- ejsSetPropertyToString(ejs, thisObj, "status", "timeout");
- httpCallback(hp, 504);
- return;
- }
- }
-
- /*
- * Normal success
- */
- source = info->pisMessage;
- mprAssert(source);
-
- bytes = ISOURCE_Read(source, data, sizeof(data));
-
- switch (bytes) {
- case ISOURCE_WAIT: // No data yet
- ISOURCE_Readable(source, hp->callback);
- break;
-
- case ISOURCE_ERROR:
- ejsSetPropertyToString(ejs, thisObj, "status", "error");
- httpCallback(hp, info->nCode);
- break;
-
- case ISOURCE_END:
- mprAddNullToBuf(hp->buf);
- ejsSetPropertyToString(ejs, thisObj, "status", "complete");
- httpCallback(hp, info->nCode);
- break;
-
- default:
- if (bytes > 0) {
- if (mprPutBlockToBuf(hp->buf, data, bytes) != bytes) {
- ejsSetPropertyToString(ejs, thisObj, "status", "partialData");
- httpCallback(hp, 500);
- }
- }
- ISOURCE_Readable(source, hp->callback);
- break;
- }
-}
-
-/******************************************************************************/
-/*
- * Invoke the HTTP completion method
- */
-
-static void httpCallback(HTTPControl *hp, int responseCode)
-{
- Ejs *ejs;
- EjsVar *thisObj, *callbackObj;
- MprArray *args;
- char *msg;
- const char *callbackMethod;
-
- mprAssert(hp);
- mprAssert(hp->webResp);
-
- thisObj = hp->thisObj;
- ejs = hp->ejs;
-
- ejsSetPropertyToInteger(ejs, thisObj, "responseCode", responseCode);
- if (mprGetBufLength(hp->buf) > 0) {
- ejsSetPropertyToBinaryString(ejs, thisObj, "responseData",
- mprGetBufStart(hp->buf), mprGetBufLength(hp->buf));
- }
-
- callbackObj = ejsGetPropertyAsVar(ejs, thisObj, "obj");
- callbackMethod = ejsGetPropertyAsString(ejs, thisObj, "method");
-
- if (callbackObj != 0 && callbackMethod != 0) {
-
- args = mprCreateItemArray(ejs, EJS_INC_ARGS, EJS_MAX_ARGS);
- mprAddItem(args, ejsDupVar(ejs, hp->thisObj, EJS_SHALLOW_COPY));
-
- if (ejsRunMethod(ejs, callbackObj, callbackMethod, args) < 0) {
- msg = ejsGetErrorMsg(ejs);
- mprError(ejs, MPR_LOC, "HTTP callback failed. Details: %s", msg);
- }
- ejsFreeMethodArgs(ejs, args);
-
- } else if (ejsRunMethod(ejs, thisObj, "onComplete", 0) < 0) {
- msg = ejsGetErrorMsg(ejs);
- mprError(ejs, MPR_LOC, "HTTP onComplete failed. Details: %s", msg);
- }
-
- cleanup(hp);
-}
-
-/******************************************************************************/
-/*
- * Cleanup
- */
-
-static void cleanup(HTTPControl *hp)
-{
- Ejs *ejs;
- MprApp *app;
- int rc;
-
- mprAssert(hp);
- mprAssert(hp->webResp);
-
- ejs = hp->ejs;
-
- if (hp->webResp) {
- rc = IWEBRESP_Release(hp->webResp);
- // mprAssert(rc == 0);
- hp->webResp = 0;
- }
-
- if (hp->callback) {
- CALLBACK_Cancel(hp->callback);
- mprFree(hp->callback);
- hp->callback = 0;
- }
-
- /*
- * Once the property is deleted, then if the destructor runs, it will
- * notice that the EJS_HTTP_PROPERTY is undefined.
- */
- ejsDeleteProperty(ejs, hp->thisObj, EJS_HTTP_PROPERTY);
-
- /*
- * Allow garbage collection to work on thisObj
- */
- ejsMakeObjPermanent(hp->thisObj, 0);
- ejsFreeVar(ejs, hp->thisObj);
-
- mprFree(hp->buf);
- mprFree(hp->url);
-
- mprFree(hp);
-
- app = mprGetApp(ejs);
-
-
- ISHELL_SendEvent(app->shell, (AEECLSID) app->classId, EVT_USER, 0, 0);
-}
-
-/******************************************************************************/
-/******************************** Initialization ******************************/
-/******************************************************************************/
-
-int ejsDefineHTTPClass(Ejs *ejs)
-{
- EjsVar *httpClass;
-
- httpClass =
- ejsDefineClass(ejs, "HTTP", "Object", ejsHTTPConstructor);
- if (httpClass == 0) {
- return MPR_ERR_CANT_INITIALIZE;
- }
-
- /*
- * Define the methods
- */
- ejsDefineCMethod(ejs, httpClass, "fetch", fetchProc, 0);
- ejsDefineCMethod(ejs, httpClass, "stop", stopProc, 0);
- ejsDefineCMethod(ejs, httpClass, "setCallback", setCallback, 0);
-
-#if FUTURE
- ejsDefineCMethod(ejs, httpClass, "put", put, 0);
- ejsDefineCMethod(ejs, httpClass, "upload", upload, 0);
- ejsDefineCMethod(ejs, httpClass, "addUploadFile", addUploadFile, 0);
- ejsDefineCMethod(ejs, httpClass, "addPostData", addPostData, 0);
- ejsDefineCMethod(ejs, httpClass, "setUserPassword", setUserPassword, 0);
- ejsDefineCMethod(ejs, httpClass, "addCookie", addCookie, 0);
-#endif
-
- /*
- * Define properties
- */
- ejsSetPropertyToString(ejs, httpClass, "status", "inactive");
-
- /* This default should come from player.xml */
-
- ejsSetPropertyToInteger(ejs, httpClass, "timeout", 30 * 1000);
- ejsSetPropertyToInteger(ejs, httpClass, "responseCode", 0);
-
- return ejsObjHasErrors(httpClass) ? MPR_ERR_CANT_INITIALIZE: 0;
-}
-
-/******************************************************************************/
-
-void ejsTermHTTPClass(Ejs *ejs)
-{
- IWeb *web;
- int rc;
-
- web = (IWeb*) mprGetKeyValue(ejs, "bpWeb");
- if (web) {
- rc = IWEB_Release(web);
- mprAssert(rc == 0);
- }
-}
-
-#endif
-/******************************************************************************/
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-#
-# Makefile to build the EJS Object Model for WIN
-#
-# Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
-#
-
-COMPILE := *.c
-EXPORT_OBJECTS := yes
-MAKE_IFLAGS := -I../.. -I../../../mpr
-
-include make.dep
-
-compileExtra: .updated
-
-.updated: $(FILES)
- @touch .updated
-
-## Local variables:
-## tab-width: 4
-## End:
-## vim: tw=78 sw=4 ts=4
+++ /dev/null
-/*
- * @file ejsFile.c
- * @brief File class for the EJScript System Object Model
- */
-/********************************** Copyright *********************************/
-/*
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- */
-/********************************** Includes **********************************/
-
-#include "ejs.h"
-
-/******************************************************************************/
-/*
- * Default Constructor
- */
-
-/******************************************************************************/
-/************************************ Methods *********************************/
-/******************************************************************************/
-/*
- * function open();
- */
-
-static int openProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- ejsTrace(ep, "File.open()\n");
- return 0;
-}
-
-/******************************************************************************/
-/*
- * function close();
- */
-
-static int closeProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- ejsTrace(ep, "File.close()\n");
- return 0;
-}
-
-/******************************************************************************/
-/*
- * function read();
- */
-
-static int readProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- ejsTrace(ep, "File.read()\n");
- return 0;
-}
-
-/******************************************************************************/
-/*
- * function write();
- */
-
-static int writeProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- ejsTrace(ep, "File.write()\n");
- return 0;
-}
-
-/******************************************************************************/
-/******************************** Initialization ******************************/
-/******************************************************************************/
-
-int ejsDefineFileClass(Ejs *ep)
-{
- EjsVar *fileClass;
-
- fileClass = ejsDefineClass(ep, "File", "Object", 0);
- if (fileClass == 0) {
- return MPR_ERR_CANT_INITIALIZE;
- }
-
- /*
- * Define the methods
- */
- ejsDefineCMethod(ep, fileClass, "open", openProc, 0);
- ejsDefineCMethod(ep, fileClass, "close", closeProc, 0);
- ejsDefineCMethod(ep, fileClass, "read", readProc, 0);
- ejsDefineCMethod(ep, fileClass, "write", writeProc, 0);
-
- return ejsObjHasErrors(fileClass) ? MPR_ERR_CANT_INITIALIZE: 0;
-}
-
-/******************************************************************************/
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- * @file ejsFileSystem.c
- * @brief FileSystem class for the EJ System Object Model
- */
-/********************************** Copyright *********************************/
-/*
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- */
-/********************************** Includes **********************************/
-
-#include "ejs.h"
-
-/******************************************************************************/
-/*
- * Default Constructor
- */
-
-/******************************************************************************/
-/************************************ Methods *********************************/
-/******************************************************************************/
-/*
- * function void access(string path);
- * MOB - API insufficient. Access for read or write?
- */
-
-static int accessProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- int rc;
-
- if (argc != 1 || !ejsVarIsString(argv[0])) {
- ejsError(ejs, EJS_ARG_ERROR, "Bad usage: access(path)");
- return -1;
- }
-
- rc = access(argv[0]->string, 04);
-
- ejsSetReturnValueToBoolean(ejs, (rc == 0) ? 1 : 0);
- return 0;
-}
-
-/******************************************************************************/
-/*
- * function void mkdir(string path);
- */
-
-static int mkdirProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- if (argc != 1 || !ejsVarIsString(argv[0])) {
- ejsError(ejs, EJS_ARG_ERROR, "Bad usage: mkdir(path)");
- return -1;
- }
-
- if (mprMakeDirPath(ejs, argv[0]->string) < 0) {
- ejsError(ejs, EJS_IO_ERROR, "Cant create directory");
- return -1;
- }
- return 0;
-}
-
-/******************************************************************************/
-/*
- * function void rmdir(string path);
- */
-
-static int rmdirProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- int rc;
-
- if (argc != 1 || !ejsVarIsString(argv[0])) {
- ejsError(ejs, EJS_ARG_ERROR, "Bad usage: mkdir(path)");
- return -1;
- }
-
- rc = mprDeleteDir(ejs, argv[0]->string);
-
- if (rc < 0) {
- ejsError(ejs, EJS_IO_ERROR, "Cant remove directory");
- return -1;
- }
- return 0;
-}
-
-/******************************************************************************/
-/*
- * function void dirList(string path, [bool enumDirs]);
- * MOB -- need pattern to match (what about "." and ".." and ".*"
- */
-
-static int dirListProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- WIN32_FIND_DATA findData;
- HANDLE h;
- char path[MPR_MAX_FNAME];
- EjsVar *array, *vp;
- uchar enumDirs;
-
- if (argc < 1 || !ejsVarIsString(argv[0])) {
- ejsError(ejs, EJS_ARG_ERROR, "Bad usage: dirList(path)");
- return -1;
- }
- if (argc == 2) {
- enumDirs = ejsVarToBoolean(argv[1]);
- } else {
- enumDirs = 0;
- }
- array = ejsCreateArray(ejs, 0);
- ejsMakeObjPermanent(array, 1);
-
- /*
- * First collect the files
- */
- mprSprintf(path, sizeof(path), "%s/*.*", argv[0]->string);
- h = FindFirstFile(path, &findData);
- if (h == INVALID_HANDLE_VALUE) {
- ejsError(ejs, EJS_ARG_ERROR, "Can't enumerate dirList(path)");
- return -1;
- }
-
- do {
- if (findData.cFileName[0] == '.') {
- continue;
- }
- if (!enumDirs ||
- (findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
- mprSprintf(path, sizeof(path), "%s/%s", argv[0]->string,
- findData.cFileName);
- vp = ejsCreateStringVar(ejs, path);
- ejsAddArrayElt(ejs, array, vp, EJS_SHALLOW_COPY);
- ejsFreeVar(ejs, vp);
- }
- } while (FindNextFile(h, &findData) != 0);
-
- FindClose(h);
-
- ejsSetReturnValue(ejs, array);
- ejsMakeObjPermanent(array, 0);
-
- /*
- * Can free now as the return value holds the reference
- */
- ejsFreeVar(ejs, array);
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * function void getFreeSpace();
- */
-
-static int getFreeSpaceProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
-#if UNUSED
- MprApp *app;
- uint space;
-
- app = mprGetApp(ejs);
- space = IFILEMGR_GetFreeSpace(app->fileMgr, 0);
- ejsSetReturnValueToInteger(ejs, space);
-#endif
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * function void writeFile(string path, var data);
- */
-
-static int writeFileProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- MprFile *file;
- char *data, *buf;
- int bytes, length, rc;
-
- if (argc != 2 || !ejsVarIsString(argv[0])) {
- ejsError(ejs, EJS_ARG_ERROR, "Bad usage: writeFile(path, var)");
- return -1;
- }
-
- if (ejsVarIsString(argv[1])) {
- data = argv[1]->string;
- length = argv[1]->length;
- buf = 0;
- } else {
- buf = data = ejsVarToString(ejs, argv[1]);
- length = strlen(data);
- }
-
- /*
- * Create fails if already present
- */
- rc = mprDelete(ejs, argv[0]->string);
- file = mprOpen(ejs, argv[0]->string, O_CREAT | O_WRONLY | O_BINARY, 0664);
- if (file == 0) {
- ejsError(ejs, EJS_IO_ERROR, "Cant create %s", argv[0]->string);
- mprFree(buf);
- return -1;
- }
-
- rc = 0;
- bytes = mprWrite(file, data, length);
- if (bytes != length) {
- ejsError(ejs, EJS_IO_ERROR, "Write error to %s", argv[1]->string);
- rc = -1;
- }
-
- mprClose(file);
-
- mprFree(buf);
- return rc;
-}
-
-/******************************************************************************/
-/*
- * function string readFile(string path);
- */
-
-static int readFileProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- MprApp *app;
- MprFile *file;
- MprBuf *buf;
- char *data;
- int bytes, rc;
-
- if (argc != 1 || !ejsVarIsString(argv[0])) {
- ejsError(ejs, EJS_ARG_ERROR, "Bad usage: readFile(path)");
- return -1;
- }
- buf = mprCreateBuf(ejs, MPR_BUF_INCR, MPR_MAX_BUF);
- if (buf == 0) {
- ejsMemoryError(ejs);
- return -1;
- }
-
- data = mprAlloc(ejs, MPR_BUFSIZE);
- if (buf == 0) {
- mprFree(buf);
- ejsMemoryError(ejs);
- return -1;
- }
-
- app = mprGetApp(ejs);
- file = mprOpen(ejs, argv[0]->string, O_RDONLY, 0664);
- if (file == 0) {
- ejsError(ejs, EJS_IO_ERROR, "Cant open %s", argv[0]->string);
- mprFree(buf);
- return -1;
- }
-
- rc = 0;
- while ((bytes = mprRead(file, data, MPR_BUFSIZE)) > 0) {
- if (mprPutBlockToBuf(buf, data, bytes) != bytes) {
- ejsError(ejs, EJS_IO_ERROR, "Write error to %s", argv[1]->string);
- rc = -1;
- break;
- }
- }
-
- ejsSetReturnValueToBinaryString(ejs, mprGetBufStart(buf),
- mprGetBufLength(buf));
-
- mprClose(file);
- mprFree(data);
- mprFree(buf);
-
- return rc;
-}
-
-/******************************************************************************/
-/*
- * function void remove(string path);
- */
-
-static int removeProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- int rc;
-
- if (argc != 1 || !ejsVarIsString(argv[0])) {
- ejsError(ejs, EJS_ARG_ERROR, "Bad usage: remove(path)");
- return -1;
- }
-
- rc = unlink(argv[0]->string);
- if (rc < 0) {
- ejsError(ejs, EJS_IO_ERROR, "Cant remove file");
- return -1;
- }
- return 0;
-}
-
-/******************************************************************************/
-/*
- * function void rename(string from, string to);
- */
-
-static int renameProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- int rc;
-
- if (argc != 2 || !ejsVarIsString(argv[0]) || !ejsVarIsString(argv[1])) {
- ejsError(ejs, EJS_ARG_ERROR, "Bad usage: rename(old, new)");
- return -1;
- }
-
- unlink(argv[1]->string);
- rc = rename(argv[0]->string, argv[1]->string);
- if (rc < 0) {
- ejsError(ejs, EJS_IO_ERROR, "Cant rename file");
- return -1;
- }
- return 0;
-}
-
-/******************************************************************************/
-/*
- * function void copy(string old, string new);
- */
-
-static int copyProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- MprFile *from, *to;
- char *buf;
- int bytes, rc;
-
- if (argc != 2 || !ejsVarIsString(argv[0]) || !ejsVarIsString(argv[1])) {
- ejsError(ejs, EJS_ARG_ERROR, "Bad usage: copy(old, new)");
- return -1;
- }
-
- buf = mprAlloc(ejs, MPR_BUFSIZE);
- if (buf == 0) {
- ejsMemoryError(ejs);
- return -1;
- }
-
- from = mprOpen(ejs, argv[0]->string, O_RDONLY | O_BINARY, 0664);
- if (from == 0) {
- ejsError(ejs, EJS_IO_ERROR, "Cant open %s", argv[0]->string);
- mprFree(buf);
- return -1;
- }
-
- to = mprOpen(ejs, argv[1]->string, O_CREAT | O_BINARY, 0664);
- if (to == 0) {
- ejsError(ejs, EJS_IO_ERROR, "Cant create %s", argv[1]->string);
- mprClose(from);
- mprFree(buf);
- return -1;
- }
-
- rc = 0;
- while ((bytes = mprRead(from, buf, MPR_BUFSIZE)) > 0) {
- if (mprWrite(to, buf, bytes) != bytes) {
- ejsError(ejs, EJS_IO_ERROR, "Write error to %s", argv[1]->string);
- rc = -1;
- break;
- }
- }
-
- mprClose(from);
- mprClose(to);
- mprFree(buf);
-
- return rc;
-}
-
-/******************************************************************************/
-/*
- * function FileInfo getFileInfo(string path);
- *
- * MOB -- should create a real class FileInfo
- */
-
-static int getFileInfoProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- MprFileInfo info;
- EjsVar *fileInfo;
- int rc;
-
- if (argc != 1 || !ejsVarIsString(argv[0])) {
- ejsError(ejs, EJS_ARG_ERROR, "Bad usage: getFileInfo(path)");
- return -1;
- }
-
- fileInfo = ejsCreateObjVar(ejs);
- if (fileInfo == 0) {
- ejsMemoryError(ejs);
- return -1;
- }
- ejsMakeObjPermanent(fileInfo, 1);
-
- rc = mprGetFileInfo(ejs, argv[0]->string, &info);
- if (rc < 0) {
- ejsMakeObjPermanent(fileInfo, 0);
- ejsFreeVar(ejs, fileInfo);
- ejsError(ejs, EJS_IO_ERROR, "Cant get file info for %s",
- argv[0]->string);
- return -1;
- }
-
- ejsSetPropertyToInteger(ejs, fileInfo, "created", info.ctime);
- ejsSetPropertyToInteger(ejs, fileInfo, "length", info.size);
- ejsSetPropertyToBoolean(ejs, fileInfo, "isDir", info.isDir);
-
- ejsSetReturnValue(ejs, fileInfo);
- ejsMakeObjPermanent(fileInfo, 0);
-
- return 0;
-}
-
-/******************************************************************************/
-/******************************** Initialization ******************************/
-/******************************************************************************/
-
-int ejsDefineFileSystemClass(Ejs *ejs)
-{
- EjsVar *fileSystemClass;
-
- fileSystemClass = ejsDefineClass(ejs, "FileSystem", "Object", 0);
- if (fileSystemClass == 0) {
- return MPR_ERR_CANT_INITIALIZE;
- }
-
- /*
- * Define the methods
- */
- ejsDefineCMethod(ejs, fileSystemClass, "access", accessProc, 0);
- ejsDefineCMethod(ejs, fileSystemClass, "mkdir", mkdirProc, 0);
- ejsDefineCMethod(ejs, fileSystemClass, "rmdir", rmdirProc, 0);
- ejsDefineCMethod(ejs, fileSystemClass, "dirList", dirListProc, 0);
- ejsDefineCMethod(ejs, fileSystemClass, "writeFile", writeFileProc, 0);
- ejsDefineCMethod(ejs, fileSystemClass, "readFile", readFileProc, 0);
- ejsDefineCMethod(ejs, fileSystemClass, "remove", removeProc, 0);
- ejsDefineCMethod(ejs, fileSystemClass, "rename", renameProc, 0);
- ejsDefineCMethod(ejs, fileSystemClass, "copy", copyProc, 0);
- ejsDefineCMethod(ejs, fileSystemClass, "getFileInfo", getFileInfoProc, 0);
-
- // MOB -- should be a property with accessor
- ejsDefineCMethod(ejs, fileSystemClass, "getFreeSpace", getFreeSpaceProc, 0);
-
- return ejsObjHasErrors(fileSystemClass) ? MPR_ERR_CANT_INITIALIZE: 0;
-}
-
-/******************************************************************************/
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- * @file ejsHTTP.c
- * @brief HTTP class for the EJ System Object Model
- */
-/********************************** Copyright *********************************/
-/*
- * Copyright (c) Mbedthis Software LLC, 2005-2006. All Rights Reserved.
- */
-/********************************** Includes **********************************/
-
-#include "ejs.h"
-
-#if UNUSED
-/*********************************** Defines **********************************/
-
-#define EJS_WEB_PROPERTY "-web"
-#define EJS_HTTP_PROPERTY "-http"
-
-#define EJS_HTTP_DISPOSED 550
-
-/*
- * Control structure for one HTTP request structure
- */
-typedef struct HTTPControl {
- Ejs *ejs;
- IWebResp *webResp;
- AEECallback *callback;
- MprBuf *buf;
- EjsVar *thisObj;
- char *url;
- MprTime requestStarted;
- uint timeout;
-} HTTPControl;
-
-/****************************** Forward Declarations **************************/
-
-static void cleanup(HTTPControl *hp);
-static int createWeb(Ejs *ejs, EjsVar *thisObj);
-static void brewCallback(HTTPControl *hp);
-static int httpDestructor(Ejs *ejs, EjsVar *vp);
-static void httpCallback(HTTPControl *hp, int responseCode);
-static int setCallback(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv);
-
-/******************************************************************************/
-/*
- * Constructor
- */
-
-int ejsHTTPConstructor(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- if (argc != 0 && argc != 2) {
- ejsError(ejs, EJS_ARG_ERROR,
- "Bad usage: HTTP([obj = this, method = onComplete]);");
- return -1;
- }
-
- if (createWeb(ejs, thisObj) < 0) {
- return -1;
- }
-
- setCallback(ejs, thisObj, argc, argv);
- return 0;
-}
-
-/******************************************************************************/
-
-static int createWeb(Ejs *ejs, EjsVar *thisObj)
-{
- MprApp *app;
- void *web;
-
- app = mprGetApp(ejs);
-
- /*
- * Create one instance of IWeb for the entire application. Do it here
- * so only widgets that require HTTP incurr the overhead.
- */
- web = mprGetKeyValue(ejs, "bpWeb");
- if (web == 0) {
- if (ISHELL_CreateInstance(app->shell, AEECLSID_WEB, &web) != SUCCESS) {
- ejsError(ejs, EJS_IO_ERROR, "Can't create IWEB");
- return -1;
- }
- }
- mprSetKeyValue(ejs, "bpWeb", web);
- return 0;
-}
-
-/******************************************************************************/
-/************************************ Methods *********************************/
-/******************************************************************************/
-/*
- * function setCallback(obj, methodString);
- */
-
-static int setCallback(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- if (argc >= 1) {
- ejsSetProperty(ejs, thisObj, "obj", argv[0]);
- } else {
- ejsSetProperty(ejs, thisObj, "obj", thisObj);
- }
-
- if (argc >= 2) {
- ejsSetProperty(ejs, thisObj, "method", argv[1]);
- } else {
- ejsSetPropertyToString(ejs, thisObj, "method", "onComplete");
- }
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * function fetch();
- */
-
-static int fetchProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- HTTPControl *hp;
- EjsProperty *pp;
- MprApp *app;
- IWeb *web;
-
- if (argc != 1 || !ejsVarIsString(argv[0])) {
- ejsError(ejs, EJS_ARG_ERROR, "Bad usage: fetch(url)");
- return -1;
- }
-
- app = mprGetApp(ejs);
- web = (IWeb*) mprGetKeyValue(ejs, "bpWeb");
-
- /*
- * Web options
- *
- * WEBOPT_USERAGENT (char*) sets user agent
- * WEBOPT_HANDLERDATA (void*)
- * WEBOPT_CONNECTTIMEOUT (uint) msec
- * WEBOPT_CONTENTLENGTH (long)
- * WEBOPT_IDLECONNTIMEOUT (int)
- * WEBOPT_ACTIVEXACTIONST (uint) Number of active requests
- *
- * WEBREQUEST_REDIRECT redirect transparently
- *
- */
-
- hp = mprAllocType(ejs, HTTPControl);
- if (hp == 0) {
- ejsMemoryError(ejs);
- return -1;
- }
-
- hp->ejs = ejs;
- hp->buf = mprCreateBuf(hp, MPR_BUF_INCR, MPR_MAX_BUF);
- if (hp->buf == 0) {
- mprFree(hp);
- ejsMemoryError(ejs);
- return -1;
- }
-
- /*
- * We copy thisObj because we need to preserve both the var and the object.
- * We pass the var to brewCallback and so it must persist. The call to
- * ejsMakeObjPermanent will stop the GC from collecting the object.
- */
- hp->thisObj = ejsDupVar(ejs, thisObj, EJS_SHALLOW_COPY);
- ejsSetVarName(ejs, hp->thisObj, "internalHttp");
-
- /*
- * Must keep a reference to the http object
- */
- ejsMakeObjPermanent(hp->thisObj, 1);
-
- /*
- * Make a property so we can access the HTTPControl structure from other
- * methods.
- */
- pp = ejsSetPropertyToPtr(ejs, thisObj, EJS_HTTP_PROPERTY, hp, 0);
- ejsMakePropertyEnumerable(pp, 0);
- ejsSetObjDestructor(ejs, hp->thisObj, httpDestructor);
-
- hp->url = mprStrdup(hp, argv[0]->string);
-
- hp->timeout = ejsGetPropertyAsInteger(ejs, thisObj, "timeout");
- mprGetTime(hp, &hp->requestStarted);
-
- hp->callback = mprAllocTypeZeroed(hp, AEECallback);
- CALLBACK_Init(hp->callback, brewCallback, hp);
-
- hp->webResp = 0;
- IWEB_GetResponse(web,
- (web, &hp->webResp, hp->callback, hp->url,
- WEBOPT_HANDLERDATA, hp,
- WEBOPT_USERAGENT, "Mozilla/4.0 (compatible; MSIE 5.5; Windows NT 5.0)",
- WEBOPT_CONNECTTIMEOUT, hp->timeout,
- WEBOPT_COPYOPTS, TRUE,
- WEBOPT_CONTENTLENGTH, 0,
- WEBOPT_END));
-
- ejsSetPropertyToString(ejs, thisObj, "status", "active");
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Called whenver the http object is deleted.
- */
-
-static int httpDestructor(Ejs *ejs, EjsVar *thisObj)
-{
- HTTPControl *hp;
-
- /*
- * If the httpCallback has run, then this property will not exist
- */
- hp = ejsGetPropertyAsPtr(ejs, thisObj, EJS_HTTP_PROPERTY);
-
- if (hp) {
- cleanup(hp);
- }
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Stop the request immediately without calling the callback
- */
-
-static int stopProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- HTTPControl *hp;
-
- hp = ejsGetPropertyAsPtr(ejs, thisObj, EJS_HTTP_PROPERTY);
-
- if (hp) {
- cleanup(hp);
- }
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Brew HTTP callback. Invoked for any return data.
- */
-
-static void brewCallback(HTTPControl *hp)
-{
- Ejs *ejs;
- EjsVar *thisObj;
- ISource *source;
- WebRespInfo *info;
- char data[MPR_BUF_INCR];
- int bytes;
-
- mprAssert(hp);
- mprAssert(hp->webResp);
-
- info = IWEBRESP_GetInfo(hp->webResp);
-
- if (info == 0) {
- mprAssert(info);
- /* should not happen */
- return;
- }
-
- ejs = hp->ejs;
- thisObj = hp->thisObj;
-
- if (! WEB_ERROR_SUCCEEDED(info->nCode)) {
- ejsSetPropertyToString(ejs, thisObj, "status", "error");
- httpCallback(hp, info->nCode);
- return;
- }
-
- if (hp->timeout) {
- if (mprGetTimeRemaining(hp, hp->requestStarted, hp->timeout) <= 0) {
- ejsSetPropertyToString(ejs, thisObj, "status", "timeout");
- httpCallback(hp, 504);
- return;
- }
- }
-
- /*
- * Normal success
- */
- source = info->pisMessage;
- mprAssert(source);
-
- bytes = ISOURCE_Read(source, data, sizeof(data));
-
- switch (bytes) {
- case ISOURCE_WAIT: // No data yet
- ISOURCE_Readable(source, hp->callback);
- break;
-
- case ISOURCE_ERROR:
- ejsSetPropertyToString(ejs, thisObj, "status", "error");
- httpCallback(hp, info->nCode);
- break;
-
- case ISOURCE_END:
- mprAddNullToBuf(hp->buf);
- ejsSetPropertyToString(ejs, thisObj, "status", "complete");
- httpCallback(hp, info->nCode);
- break;
-
- default:
- if (bytes > 0) {
- if (mprPutBlockToBuf(hp->buf, data, bytes) != bytes) {
- ejsSetPropertyToString(ejs, thisObj, "status", "partialData");
- httpCallback(hp, 500);
- }
- }
- ISOURCE_Readable(source, hp->callback);
- break;
- }
-}
-
-/******************************************************************************/
-/*
- * Invoke the HTTP completion method
- */
-
-static void httpCallback(HTTPControl *hp, int responseCode)
-{
- Ejs *ejs;
- EjsVar *thisObj, *callbackObj;
- MprArray *args;
- char *msg;
- const char *callbackMethod;
-
- mprAssert(hp);
- mprAssert(hp->webResp);
-
- thisObj = hp->thisObj;
- ejs = hp->ejs;
-
- ejsSetPropertyToInteger(ejs, thisObj, "responseCode", responseCode);
- if (mprGetBufLength(hp->buf) > 0) {
- ejsSetPropertyToBinaryString(ejs, thisObj, "responseData",
- mprGetBufStart(hp->buf), mprGetBufLength(hp->buf));
- }
-
- callbackObj = ejsGetPropertyAsVar(ejs, thisObj, "obj");
- callbackMethod = ejsGetPropertyAsString(ejs, thisObj, "method");
-
- if (callbackObj != 0 && callbackMethod != 0) {
-
- args = mprCreateItemArray(ejs, EJS_INC_ARGS, EJS_MAX_ARGS);
- mprAddItem(args, ejsDupVar(ejs, hp->thisObj, EJS_SHALLOW_COPY));
-
- if (ejsRunMethod(ejs, callbackObj, callbackMethod, args) < 0) {
- msg = ejsGetErrorMsg(ejs);
- mprError(ejs, MPR_LOC, "HTTP callback failed. Details: %s", msg);
- }
- ejsFreeMethodArgs(ejs, args);
-
- } else if (ejsRunMethod(ejs, thisObj, "onComplete", 0) < 0) {
- msg = ejsGetErrorMsg(ejs);
- mprError(ejs, MPR_LOC, "HTTP onComplete failed. Details: %s", msg);
- }
-
- cleanup(hp);
-}
-
-/******************************************************************************/
-/*
- * Cleanup
- */
-
-static void cleanup(HTTPControl *hp)
-{
- Ejs *ejs;
- MprApp *app;
- int rc;
-
- mprAssert(hp);
- mprAssert(hp->webResp);
-
- ejs = hp->ejs;
-
- if (hp->webResp) {
- rc = IWEBRESP_Release(hp->webResp);
- // mprAssert(rc == 0);
- hp->webResp = 0;
- }
-
- if (hp->callback) {
- CALLBACK_Cancel(hp->callback);
- mprFree(hp->callback);
- hp->callback = 0;
- }
-
- /*
- * Once the property is deleted, then if the destructor runs, it will
- * notice that the EJS_HTTP_PROPERTY is undefined.
- */
- ejsDeleteProperty(ejs, hp->thisObj, EJS_HTTP_PROPERTY);
-
- /*
- * Allow garbage collection to work on thisObj
- */
- ejsMakeObjPermanent(hp->thisObj, 0);
- ejsFreeVar(ejs, hp->thisObj);
-
- mprFree(hp->buf);
- mprFree(hp->url);
-
- mprFree(hp);
-
- app = mprGetApp(ejs);
-
-
- ISHELL_SendEvent(app->shell, (AEECLSID) app->classId, EVT_USER, 0, 0);
-}
-
-/******************************************************************************/
-/******************************** Initialization ******************************/
-/******************************************************************************/
-
-int ejsDefineHTTPClass(Ejs *ejs)
-{
- EjsVar *httpClass;
-
- httpClass =
- ejsDefineClass(ejs, "HTTP", "Object", ejsHTTPConstructor);
- if (httpClass == 0) {
- return MPR_ERR_CANT_INITIALIZE;
- }
-
- /*
- * Define the methods
- */
- ejsDefineCMethod(ejs, httpClass, "fetch", fetchProc, 0);
- ejsDefineCMethod(ejs, httpClass, "stop", stopProc, 0);
- ejsDefineCMethod(ejs, httpClass, "setCallback", setCallback, 0);
-
-#if FUTURE
- ejsDefineCMethod(ejs, httpClass, "put", put, 0);
- ejsDefineCMethod(ejs, httpClass, "upload", upload, 0);
- ejsDefineCMethod(ejs, httpClass, "addUploadFile", addUploadFile, 0);
- ejsDefineCMethod(ejs, httpClass, "addPostData", addPostData, 0);
- ejsDefineCMethod(ejs, httpClass, "setUserPassword", setUserPassword, 0);
- ejsDefineCMethod(ejs, httpClass, "addCookie", addCookie, 0);
-#endif
-
- /*
- * Define properties
- */
- ejsSetPropertyToString(ejs, httpClass, "status", "inactive");
-
- /* This default should come from player.xml */
-
- ejsSetPropertyToInteger(ejs, httpClass, "timeout", 30 * 1000);
- ejsSetPropertyToInteger(ejs, httpClass, "responseCode", 0);
-
- return ejsObjHasErrors(httpClass) ? MPR_ERR_CANT_INITIALIZE: 0;
-}
-
-/******************************************************************************/
-
-void ejsTermHTTPClass(Ejs *ejs)
-{
- IWeb *web;
- int rc;
-
- web = (IWeb*) mprGetKeyValue(ejs, "bpWeb");
- if (web) {
- rc = IWEB_Release(web);
- mprAssert(rc == 0);
- }
-}
-
-#endif
-/******************************************************************************/
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- * @file ejsGC.c
- * @brief Garbage collector class for the EJS Object Model
- */
-/********************************** Copyright *********************************/
-/*
- * Copyright (c) Mbedthis Software LLC, 2005-2006. All Rights Reserved.
- */
-/********************************** Includes **********************************/
-
-#include "ejs.h"
-
-/******************************************************************************/
-/************************************ Methods *********************************/
-/******************************************************************************/
-#if (WIN || BREW_SIMULATOR) && BLD_DEBUG
-
-static int checkProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- _CrtCheckMemory();
- return 0;
-}
-
-#endif
-/******************************************************************************/
-
-static int debugProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- if (argc != 1) {
- ejsError(ep, EJS_ARG_ERROR, "Bad args: debug(debugLevel)");
- return -1;
- }
-
- ejsSetGCDebugLevel(ep, ejsVarToInteger(argv[0]));
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Print stats and dump objects
- */
-
-static int printStatsProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- bool leakStats;
-
- if (argc > 1) {
- leakStats = ejsVarToInteger(argv[0]);
- } else {
- leakStats = 0;
- }
-
-#if BLD_FEATURE_ALLOC_STATS
- ejsPrintAllocReport(ep, 0);
-
- mprPrintAllocReport(mprGetApp(ep), leakStats, 0);
-#endif
-
-#if BLD_DEBUG
- ejsDumpObjects(ep);
-#endif
-
- return 0;
-}
-
-/******************************************************************************/
-
-static int runProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- if (argc > 1) {
- ejsError(ep, EJS_ARG_ERROR, "Bad args: run([quick])");
- return -1;
- }
-
- if (argc == 1) {
- ejsIncrementalCollectGarbage(ep);
- } else {
- ejsCollectGarbage(ep, -1);
- }
- return 0;
-}
-
-/******************************************************************************/
-
-static int usedMemoryProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- ejsSetReturnValueToInteger(ep, ejsGetUsedMemory(ep));
- return 0;
-}
-
-/******************************************************************************/
-
-static int allocatedMemoryProc(Ejs *ep, EjsVar *thisObj, int argc,
- EjsVar **argv)
-{
-#if BLD_FEATURE_ALLOC_STATS
- ejsSetReturnValueToInteger(ep, ejsGetAllocatedMemory(ep));
-#endif
- return 0;
-}
-
-/******************************************************************************/
-
-static int mprMemoryProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
-#if BLD_FEATURE_ALLOC_STATS
- ejsSetReturnValueToInteger(ep, mprGetAllocatedMemory(ep));
-#endif
- return 0;
-}
-
-/******************************************************************************/
-
-static int peakMprMemoryProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
-#if BLD_FEATURE_ALLOC_STATS
- ejsSetReturnValueToInteger(ep, mprGetPeakAllocatedMemory(ep));
-#endif
- return 0;
-}
-
-/******************************************************************************/
-
-static int getDebugLevel(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- ejsSetReturnValueToInteger(ep, ep->gc.debugLevel);
- return 0;
-}
-
-/******************************************************************************/
-
-static int setDebugLevel(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- if (argc != 1) {
- ejsArgError(ep, "Bad arguments");
- return -1;
- }
- ep->gc.debugLevel= ejsVarToInteger(argv[0]);
- return 0;
-}
-
-/******************************************************************************/
-
-static int getEnable(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- ejsSetReturnValueToBoolean(ep, ep->gc.enable);
- return 0;
-}
-
-/******************************************************************************/
-
-static int setEnable(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- if (argc != 1) {
- ejsArgError(ep, "Bad arguments");
- return -1;
- }
- ep->gc.enable= ejsVarToBoolean(argv[0]);
- return 0;
-}
-
-/******************************************************************************/
-
-static int getDemandCollect(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- ejsSetReturnValueToBoolean(ep, ep->gc.enableDemandCollect);
- return 0;
-}
-
-/******************************************************************************/
-
-static int setDemandCollect(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- if (argc != 1) {
- ejsArgError(ep, "Bad arguments");
- return -1;
- }
- ep->gc.enableDemandCollect = ejsVarToBoolean(argv[0]);
- return 0;
-}
-
-/******************************************************************************/
-
-static int getIdleCollect(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- ejsSetReturnValueToBoolean(ep, ep->gc.enableIdleCollect);
- return 0;
-}
-
-/******************************************************************************/
-
-static int setIdleCollect(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- if (argc != 1) {
- ejsArgError(ep, "Bad arguments");
- return -1;
- }
- ep->gc.enableIdleCollect = ejsVarToBoolean(argv[0]);
- return 0;
-}
-
-/******************************************************************************/
-
-static int getWorkQuota(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- ejsSetReturnValueToInteger(ep, ep->gc.workQuota);
- return 0;
-}
-
-/******************************************************************************/
-
-static int setWorkQuota(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- int quota;
-
- if (argc != 1) {
- ejsArgError(ep, "Bad arguments");
- return -1;
- }
- quota = ejsVarToInteger(argv[0]);
- if (quota < EJS_GC_MIN_WORK_QUOTA && quota != 0) {
- ejsArgError(ep, "Bad work quota");
- return -1;
- }
-
- ep->gc.workQuota = quota;
- return 0;
-}
-
-/******************************************************************************/
-
-static int getMaxMemory(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- ejsSetReturnValueToInteger(ep, ep->gc.maxMemory);
- return 0;
-}
-
-/******************************************************************************/
-
-static int setMaxMemory(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- int maxMemory;
-
- if (argc != 1) {
- ejsArgError(ep, "Bad arguments");
- return -1;
- }
- maxMemory = ejsVarToInteger(argv[0]);
- if (maxMemory < 0) {
- ejsArgError(ep, "Bad maxMemory");
- return -1;
- }
-
- ep->gc.maxMemory = maxMemory;
- return 0;
-}
-
-/******************************************************************************/
-/******************************** Initialization ******************************/
-/******************************************************************************/
-
-int ejsDefineGCClass(Ejs *ep)
-{
- EjsVar *gcClass;
- int flags;
-
- flags = EJS_NO_LOCAL;
-
- /*
- * NOTE: We create the GC class and define static methods on it. There
- * is no object instance
- */
- gcClass = ejsDefineClass(ep, "System.GC", "Object", 0);
- if (gcClass == 0) {
- return MPR_ERR_CANT_INITIALIZE;
- }
-
- /*
- * MOB -- convert these to properties with accessors when available
- */
- ejsDefineCMethod(ep, gcClass, "printStats", printStatsProc, flags);
- ejsDefineCMethod(ep, gcClass, "run", runProc, flags);
-
- ejsDefineCMethod(ep, gcClass, "getUsedMemory", usedMemoryProc, flags);
- ejsDefineCMethod(ep, gcClass, "getAllocatedMemory", allocatedMemoryProc,
- flags);
- ejsDefineCMethod(ep, gcClass, "getMprMemory", mprMemoryProc, flags);
- ejsDefineCMethod(ep, gcClass, "getPeakMprMemory", peakMprMemoryProc, flags);
- ejsDefineCMethod(ep, gcClass, "debug", debugProc, flags);
-
-#if (WIN || BREW_SIMULATOR) && BLD_DEBUG
- ejsDefineCMethod(ep, gcClass, "check", checkProc, flags);
-#endif
-
- ejsDefineCAccessors(ep, gcClass, "debugLevel",
- getDebugLevel, setDebugLevel, flags);
-
- ejsDefineCAccessors(ep, gcClass, "enable",
- getEnable, setEnable, flags);
-
- ejsDefineCAccessors(ep, gcClass, "demandCollect",
- getDemandCollect, setDemandCollect, flags);
-
- ejsDefineCAccessors(ep, gcClass, "idleCollect",
- getIdleCollect, setIdleCollect, flags);
-
- ejsDefineCAccessors(ep, gcClass, "workQuota",
- getWorkQuota, setWorkQuota, flags);
-
- ejsDefineCAccessors(ep, gcClass, "maxMemory",
- getMaxMemory, setMaxMemory, flags);
-
- return ejsObjHasErrors(gcClass) ? MPR_ERR_CANT_INITIALIZE : 0;
-}
-
-/******************************************************************************/
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- * @file ejsGlobal.c
- * @brief EJS support methods
- */
-/********************************* Copyright **********************************/
-/*
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- * Copyright (c) Michael O'Brien, 1994-1995. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-/********************************** Includes **********************************/
-
-#include "ejs.h"
-
-#if BLD_FEATURE_EJS
-
-/******************************************************************************/
-/************************************* Code ***********************************/
-/******************************************************************************/
-/*
- * assert(condition)
- */
-
-static int assertProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- int b;
-
- if (argc < 1) {
- ejsError(ep, EJS_ARG_ERROR, "usage: assert(condition)");
- return -1;
- }
- b = ejsVarToBoolean(argv[0]);
- if (b == 0) {
- ejsError(ep, EJS_ASSERT_ERROR, "Assertion failure at line %d",
- ejsGetLineNumber(ep));
- return -1;
- }
- ejsWriteVarAsBoolean(ep, ep->result, b);
- return 0;
-}
-
-/******************************************************************************/
-/*
- * breakpoint(msg)
- */
-
-static int breakpointProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- char *buf;
-
- if (argc < 1) {
- return 0;
- }
- buf = ejsVarToString(ep, argv[0]);
- if (buf) {
- mprBreakpoint(0, buf);
- }
- return 0;
-}
-
-/******************************************************************************/
-/*
- * basename(path)
- */
-
-static int basenameProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- char *path;
-
- if (argc != 1) {
- ejsError(ep, EJS_ARG_ERROR, "usage: basename(path)");
- return -1;
- }
-
- path = ejsVarToString(ep, argv[0]);
- if (path == 0) {
- return MPR_ERR_MEMORY;
- }
- ejsSetReturnValueToString(ep, mprGetBaseName(path));
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * stripext(path)
- */
-
-static int stripextProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- char *cp, *path, *stripPath;
-
- if (argc != 1) {
- ejsError(ep, EJS_ARG_ERROR, "usage: stripext(path)");
- return -1;
- }
-
- path = ejsVarToString(ep, argv[0]);
- if (path == 0) {
- return MPR_ERR_MEMORY;
- }
- stripPath = mprStrdup(ep, path);
-
- if ((cp = strrchr(stripPath, '.')) != 0) {
- *cp = '\0';
- }
-
- ejsSetReturnValueToString(ep, stripPath);
-
- mprFree(stripPath);
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * dirname(path)
- */
-
-static int dirnameProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- char *path;
- char dirname[MPR_MAX_FNAME];
-
- if (argc != 1) {
- ejsError(ep, EJS_ARG_ERROR, "usage: dirname(path)");
- return -1;
- }
-
- path = ejsVarToString(ep, argv[0]);
- if (path == 0) {
- return MPR_ERR_MEMORY;
- }
-
- ejsSetReturnValueToString(ep,
- mprGetDirName(dirname, sizeof(dirname), path));
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * trim(string) -- trim white space
- */
-
-static int trimProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- char *str, *buf, *cp;
-
- if (argc != 1) {
- ejsError(ep, EJS_ARG_ERROR, "usage: trim(string)");
- return -1;
- }
-
- str = ejsVarToString(ep, argv[0]);
- if (str == 0) {
- return MPR_ERR_MEMORY;
- }
- str = buf = mprStrdup(ep, str);
-
- while (isspace(*str)) {
- str++;
- }
- cp = &str[strlen(str) - 1];
- while (cp >= str) {
- if (isspace(*cp)) {
- *cp = '\0';
- } else {
- break;
- }
- cp--;
- }
-
- ejsSetReturnValueToString(ep, str);
-
- mprFree(buf);
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Terminate the script
- */
-
-static int exitScript(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- int status;
-
- if (argc != 1) {
- ejsError(ep, EJS_ARG_ERROR, "usage: exit(status)");
- return -1;
- }
- status = (int) ejsVarToInteger(argv[0]);
- ejsExit(ep, status);
-
- ejsWriteVarAsString(ep, ep->result, "");
- return 0;
-}
-
-/******************************************************************************/
-/*
- * include javascript libraries.
- */
-
-static int includeProc(Ejs *ep, EjsVar *thisObj, int argc, char **argv)
-{
- int i;
-
- mprAssert(argv);
-
- for (i = 0; i < argc; i++) {
- if (ejsEvalFile(ep, argv[i], 0) < 0) {
- return -1;
- }
- }
- return 0;
-}
-
-/******************************************************************************/
-/*
- * include javascript libraries at the global level
- */
-
-static int includeGlobalProc(Ejs *ep, EjsVar *thisObj, int argc, char **argv)
-{
- int fid, i;
-
- mprAssert(argv);
-
- /*
- * Create a new block and set the context to be the global scope
- */
- fid = ejsSetBlock(ep, ep->global);
-
- for (i = 0; i < argc; i++) {
- if (ejsEvalFile(ep, argv[i], 0) < 0) {
- ejsCloseBlock(ep, fid);
- return -1;
- }
- }
- ejsCloseBlock(ep, fid);
- return 0;
-}
-
-/******************************************************************************/
-#if BLD_DEBUG
-/*
- * Print variables to stdout
- */
-
-static int printvProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- EjsVar *vp;
- char *buf;
- int i;
-
- for (i = 0; i < argc; ) {
- vp = argv[i++];
-
- /* mprPrintf(ep, "arg[%d] = ", i); */
-
- buf = ejsVarToString(ep, vp);
-
- if (vp->propertyName == 0 || *vp->propertyName == '\0') {
- mprPrintf(ep, "%s: ", buf);
-
- } else if (i < argc) {
- mprPrintf(ep, "%s = %s, ", vp->propertyName, buf);
- } else {
- mprPrintf(ep, "%s = %s\n", vp->propertyName, buf);
- }
- }
- return 0;
-}
-
-#endif
-/******************************************************************************/
-/*
- * Print the args to stdout
- */
-
-static int printProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- char *buf;
- int i;
-
- for (i = 0; i < argc; i++) {
- buf = ejsVarToString(ep, argv[i]);
- mprPrintf(ep, "%s", buf);
- }
- return 0;
-}
-
-/******************************************************************************/
-/*
- * println
- */
-
-static int printlnProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- printProc(ep, thisObj, argc, argv);
- mprPrintf(ep, "\n");
- return 0;
-}
-
-/******************************************************************************/
-#if FUTURE
-/*
- * sprintf
- */
-
-static int sprintfProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- va_list ap;
- char *buf;
- void **args;
- int result;
-
- if (argc <= 1) {
- ejsError(ep, EJS_ARG_ERROR, "Usage: sprintf(fmt, [args ...])");
- return -1;
- }
-
- args = mprAlloc(ep, sizeof(void*) * (argc - 1));
- if (args == 0) {
- mprAssert(args);
- return -1;
- }
-
- for (i = 1; i < argc; i++) {
- args[i - 1] = argv[i]);
- }
-
- va_start(ap, fmt);
- *buf = 0;
- result = inner(0, &buf, MPR_MAX_STRING, fmt, args);
- va_end(ap);
-
- ejsSetReturnValueToString(ep, buf);
-
- mprFree(buf);
- return 0;
-}
-
-/******************************************************************************/
-
-inner(const char *fmt, void **args)
-{
- va_list ap;
-
- va_start(ap, fmt);
- *buf = 0;
- mprSprintfCore(ctx, &buf, maxSize, fmt, ap, MPR_PRINTF_ARGV);
- va_end(ap);
-}
-
-#endif
-/******************************************************************************/
-/*
- * sleep
- */
-
-static int sleepProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- if (argc != 1) {
- ejsError(ep, EJS_ARG_ERROR, "Usage: sleep(milliseconds)");
- return -1;
- }
- mprSleep(ep, ejsVarToInteger(argv[0]));
- return 0;
-}
-
-/******************************************************************************/
-/*
- * sort properties
- * FUTURE -- should have option to sort object based on a given property value
- * ascending or descending
- * Usage: sort(object, order = ascending, property = 0);
- */
-
-static int sortProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- const char *property;
- int error, order;
-
- error = 0;
- property = 0;
-
- /*
- * Default order is increasing
- */
- order = 1;
-
- if (argc < 1 || argc > 3 || !ejsVarIsObject(argv[0])) {
- error++;
- }
-
- if (argc >= 2) {
- order = ejsVarToInteger(argv[1]);
- }
-
- /*
- * If property is not defined, it sorts the properties in the object
- */
- if (argc == 3) {
- if (! ejsVarIsString(argv[2])) {
- error++;
- } else {
- property = argv[2]->string;
- }
- }
-
- if (error) {
- ejsError(ep, EJS_ARG_ERROR, "Usage: sort(object, [order], [property])");
- return -1;
- }
- ejsSortProperties(ep, argv[0], 0, property, order);
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Get a time mark
- * MOB -- WARNING: this can overflow. OK on BREW, but other O/Ss it may have
- * overflowed on the first call. It should be renamed.
- * MOB -- replace with proper Date.
- */
-
-static int timeProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- MprTime now;
-
- mprGetTime(ep, &now);
-#if WIN || LINUX || SOLARIS
-{
- /* MOB -- poor hack */
- static MprTime initial;
- if (initial.sec == 0) {
- initial = now;
- }
- now.sec -= initial.sec;
-
- if (initial.msec > now.msec) {
- now.msec = now.msec + 1000 - initial.msec;
- now.sec--;
- } else {
- now.msec -= initial.msec;
- }
-}
-#endif
- /* MOB -- this can overflow */
- ejsSetReturnValueToInteger(ep, now.sec * 1000 + now.msec);
- return 0;
-}
-
-/******************************************************************************/
-/*
- * MOB -- Temporary Get the date (time since Jan 6, 1980 GMT
- */
-
-static int dateProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
-#if BREW
- uint now;
-
- now = GETTIMESECONDS();
- ejsSetReturnValueToInteger(ep, now);
-#endif
- return 0;
-}
-
-/******************************************************************************/
-/*
- * strlen(string)
- */
-
-static int strlenProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- char *buf;
- int len;
-
- if (argc != 1) {
- ejsError(ep, EJS_ARG_ERROR, "Usage: strlen(var)");
- return -1;
- }
-
- len = 0;
- if (! ejsVarIsString(argv[0])) {
- buf = ejsVarToString(ep, argv[0]);
- if (buf) {
- len = strlen(buf);
- }
-
- } else {
- len = argv[0]->length;
- }
-
- ejsSetReturnValueToInteger(ep, len);
- return 0;
-}
-
-/******************************************************************************/
-/*
- * toint(num)
- */
-
-static int tointProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- int i;
-
- if (argc != 1) {
- ejsError(ep, EJS_ARG_ERROR, "Usage: toint(number)");
- return -1;
- }
-
- i = ejsVarToInteger(argv[0]);
-
- ejsSetReturnValueToInteger(ep, i);
- return 0;
-}
-
-/******************************************************************************/
-/*
- * string strstr(string, pat)
- */
-
-static int strstrProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- char *str, *pat;
- char *s;
- int strAlloc;
-
- if (argc != 2) {
- ejsError(ep, EJS_ARG_ERROR, "Usage: strstr(string, pat)");
- return -1;
- }
-
- str = ejsVarToString(ep, argv[0]);
-
- strAlloc = ep->castAlloc;
- ep->castTemp = 0;
-
- pat = ejsVarToString(ep, argv[1]);
-
- s = strstr(str, pat);
-
- if (s == 0) {
- ejsSetReturnValueToUndefined(ep);
- } else {
- ejsSetReturnValueToString(ep, s);
- }
-
- if (strAlloc) {
- mprFree(str);
- }
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Trace
- */
-
-static int traceProc(Ejs *ep, EjsVar *thisObj, int argc, char **argv)
-{
- if (argc == 1) {
- mprLog(ep, 0, "%s", argv[0]);
-
- } else if (argc == 2) {
- mprLog(ep, atoi(argv[0]), "%s", argv[1]);
-
- } else {
- ejsError(ep, EJS_ARG_ERROR, "Usage: trace([level], message)");
- return -1;
- }
- ejsWriteVarAsString(ep, ep->result, "");
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Evaluate a sub-script. It is evaluated in the same variable scope as
- * the calling script / method.
- */
-
-static int evalScriptProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- EjsVar *arg;
- int i;
-
- ejsWriteVarAsUndefined(ep, ep->result);
-
- for (i = 0; i < argc; i++) {
- arg = argv[i];
- if (arg->type != EJS_TYPE_STRING) {
- continue;
- }
- if (ejsEvalScript(ep, arg->string, 0) < 0) {
- return -1;
- }
- }
- /*
- * Return with the value of the last expression
- */
- return 0;
-}
-
-/******************************************************************************/
-
-/* MOB -- need a real datatype returning int, int64, etc */
-
-static int typeofProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- const struct {
- EjsType type;
- const char *name;
- } types[] = {
- { EJS_TYPE_UNDEFINED, "undefined" },
-#if EJS_ECMA_STND
- { EJS_TYPE_NULL, "object" },
-#else
- { EJS_TYPE_NULL, "null" },
-#endif
- { EJS_TYPE_BOOL, "boolean" },
- { EJS_TYPE_CMETHOD, "function" },
- { EJS_TYPE_FLOAT, "number" },
- { EJS_TYPE_INT, "number" },
- { EJS_TYPE_INT64, "number" },
- { EJS_TYPE_OBJECT, "object" },
- { EJS_TYPE_METHOD, "function" },
- { EJS_TYPE_STRING, "string" },
- { EJS_TYPE_STRING_CMETHOD, "function" },
- { EJS_TYPE_PTR, "pointer" }
- };
- const char *type;
- int i;
-
- type = NULL;
- if (argc != 1) {
- ejsError(ep, EJS_ARG_ERROR, "Bad args: typeof(var)");
- return -1;
- }
-
- for (i = 0; i < MPR_ARRAY_SIZE(types); i++) {
- if (argv[0]->type == types[i].type) {
- type = types[i].name;
- break;
- }
- }
- if (type == NULL) {
- mprAssert(type);
- return -1;
- }
-
- ejsSetReturnValueToString(ep, type);
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Define the standard properties and methods inherited by all interpreters
- * Obj is set to the global class in the default interpreter. When an
- * interpreter attempts to write to any property, a copy will be written
- * into the interpeters own global space. This is like a "copy-on-write".
- */
-
-int ejsDefineGlobalProperties(Ejs *ep)
-{
- EjsVar *obj;
-
- obj = ep->service->globalClass;
- mprAssert(obj);
-
- ejsSetPropertyToNull(ep, obj, "null");
- ejsSetPropertyToUndefined(ep, obj, "undefined");
- ejsSetPropertyToBoolean(ep, obj, "true", 1);
- ejsSetPropertyToBoolean(ep, obj, "false", 0);
-
-#if BLD_FEATURE_FLOATING_POINT
- {
- /* MOB. Fix. This generates warnings on some systems.
- This is intended. */
- double d = 0.0;
- double e = 0.0;
- ejsSetPropertyToFloat(ep, obj, "NaN", e / d);
-
- d = MAX_FLOAT;
- ejsSetPropertyToFloat(ep, obj, "Infinity", d * d);
- }
-#endif
-
-#if BLD_FEATURE_LEGACY_API
- /*
- * DEPRECATED: 2.0.
- * So that ESP/ASP can ignore "language=javascript" statements
- */
- ejsSetPropertyToInteger(ep, obj, "javascript", 0);
-#endif
-
- /*
- * Extension methods. We go directly to the mpr property APIs for speed.
- * Flags will cause the callbacks to be supplied the Ejs handle.
- */
- ejsDefineCMethod(ep, obj, "assert", assertProc, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, obj, "breakpoint", breakpointProc, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, obj, "basename", basenameProc, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, obj, "dirname", dirnameProc, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, obj, "stripext", stripextProc, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, obj, "trim", trimProc, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, obj, "eval", evalScriptProc, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, obj, "exit", exitScript, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, obj, "print", printProc, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, obj, "println", printlnProc, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, obj, "sleep", sleepProc, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, obj, "sort", sortProc, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, obj, "time", timeProc, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, obj, "date", dateProc, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, obj, "strlen", strlenProc, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, obj, "strstr", strstrProc, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, obj, "typeof", typeofProc, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, obj, "toint", tointProc, EJS_NO_LOCAL);
-
- ejsDefineStringCMethod(ep, obj, "include", includeProc, EJS_NO_LOCAL);
- ejsDefineStringCMethod(ep, obj, "includeGlobal", includeGlobalProc,
- EJS_NO_LOCAL);
- ejsDefineStringCMethod(ep, obj, "trace", traceProc, EJS_NO_LOCAL);
-
-#if BLD_DEBUG
- ejsDefineCMethod(ep, obj, "printv", printvProc, EJS_NO_LOCAL);
-#endif
-
-#if FUTURE
- ejsDefineCMethod(ep, obj, "printf", printfProc, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, obj, "sprintf", sprintfProc, EJS_NO_LOCAL);
-#endif
-
- if (ejsObjHasErrors(obj)) {
- return MPR_ERR_CANT_INITIALIZE;
- }
- return 0;
-}
-
-/******************************************************************************/
-
-#else
-void ejsProcsDummy() {}
-
-/******************************************************************************/
-#endif /* BLD_FEATURE_EJS */
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- * @file ejsSystem.c
- * @brief System class for the EJS Object Model
- */
-/********************************** Copyright *********************************/
-/*
- * Copyright (c) Mbedthis Software LLC, 2005-2006. All Rights Reserved.
- */
-/********************************** Includes **********************************/
-
-#include "ejs.h"
-
-/******************************************************************************/
-/************************************ Methods *********************************/
-/******************************************************************************/
-#if UNUSED
-/*
- * function int random()
- */
-
-static int randomProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- ejsTrace(ep, "random()\n");
- return 0;
-}
-
-/******************************************************************************/
-/*
- * function void yield()
- */
-
-static int yieldProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- ejsTrace(ep, "yield()\n");
- return 0;
-}
-
-/******************************************************************************/
-/*
- * function void sleep(int milliSeconds)
- */
-
-static int sleepProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- ejsTrace(ep, "sleep()\n");
- return 0;
-}
-
-#endif
-/******************************************************************************/
-/*
- * function void exit(int status)
- *
- * Exit the widget with the given status. All JavaScript processing ceases.
- */
-
-static int exitProc(Ejs *ep, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- int status;
-
- status = 0;
- if ((argc == 1) && ejsVarIsInteger(argv[0])) {
- status = argv[0]->integer;
- }
- ejsExit(ep, status);
- return 0;
-}
-
-/******************************************************************************/
-/******************************** Initialization ******************************/
-/******************************************************************************/
-
-int ejsDefineSystemClass(Ejs *ep)
-{
- EjsVar *systemClass;
-
- /*
- * We create the system class and define static methods on it.
- * NOTE: There is no object instance
- */
- systemClass = ejsDefineClass(ep, "System", "Object", 0);
- if (systemClass == 0) {
- return MPR_ERR_CANT_INITIALIZE;
- }
-
- ejsDefineCMethod(ep, systemClass, "exit", exitProc, EJS_NO_LOCAL);
-
-#if UNUSED
- ejsDefineCMethod(ep, systemClass, "random", randomProc, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, systemClass, "yield", yieldProc, EJS_NO_LOCAL);
- ejsDefineCMethod(ep, systemClass, "sleep", sleepProc, EJS_NO_LOCAL);
-
- /*
- * Define properties
- */
- ejsSetPropertyToString(systemClass, "name", "");
-#endif
-
- return ejsObjHasErrors(systemClass) ? MPR_ERR_CANT_INITIALIZE : 0;
-}
-
-/******************************************************************************/
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- * @file ejsSystemApp.c
- * @brief App class
- */
-/********************************** Copyright *********************************/
-/*
- * Copyright (c) Mbedthis Software Inc, 2005-2006. All Rights Reserved.
- */
-/********************************** Includes **********************************/
-
-#include "ejs.h"
-
-/************************************ Code ************************************/
-
-int ejsDefineAppClass(Ejs *ep)
-{
- EjsVar *appClass;
-
- appClass = ejsDefineClass(ep, "System.App", "Object", 0);
- if (appClass == 0) {
- return MPR_ERR_CANT_INITIALIZE;
- }
-
- /*
- * Define properties
- */
- ejsSetPropertyToString(ep, appClass, "name", BLD_PRODUCT);
- ejsSetPropertyToString(ep, appClass, "title", BLD_NAME);
- ejsSetPropertyToString(ep, appClass, "version", BLD_VERSION);
-
- /*
- * Command line arguments
- */
- ejsSetPropertyToNull(ep, appClass, "args");
-
- return ejsObjHasErrors(appClass) ? MPR_ERR_CANT_INITIALIZE : 0;
-}
-
-/******************************************************************************/
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- * @file ejsSystemDebug.c
- * @brief System.Debug class
- */
-/********************************** Copyright *********************************/
-/*
- * Copyright (c) Mbedthis Software LLC, 2005-2006. All Rights Reserved.
- */
-/********************************** Includes **********************************/
-
-#include "ejs.h"
-
-/******************************************************************************/
-/************************************ Methods *********************************/
-/******************************************************************************/
-/*
- * function bool isDebugMode()
- * MOB -- convert to accessor
- */
-
-static int isDebugMode(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- ejsTrace(ejs, "isDebugMode()\n");
- ejsSetReturnValueToInteger(ejs, mprGetDebugMode(ejs));
- return 0;
-}
-
-/******************************************************************************/
-/******************************** Initialization ******************************/
-/******************************************************************************/
-
-int ejsDefineDebugClass(Ejs *ejs)
-{
- EjsVar *systemDebugClass;
-
- systemDebugClass = ejsDefineClass(ejs, "System.Debug", "Object", 0);
- if (systemDebugClass == 0) {
- return MPR_ERR_CANT_INITIALIZE;
- }
-
- /*
- * Define the class methods
- */
- ejsDefineCMethod(ejs, systemDebugClass, "isDebugMode", isDebugMode,
- EJS_NO_LOCAL);
-
- return ejsObjHasErrors(systemDebugClass) ? MPR_ERR_CANT_INITIALIZE : 0;
-}
-
-/******************************************************************************/
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- * @file ejsSystemLog.c
- * @brief System.Log class for the EJS Object Model
- */
-/********************************** Copyright *********************************/
-/*
- * Copyright (c) Mbedthis Software LLC, 2005-2006. All Rights Reserved.
- */
-/********************************** Includes **********************************/
-
-#include "ejs.h"
-
-/*********************************** Usage ************************************/
-/*
- * System.Log.setLog(path);
- * System.Log.enable;
- */
-/******************************************************************************/
-
-static void logHandler(MPR_LOC_DEC(ctx, loc), int flags, int level,
- const char *msg)
-{
- MprApp *app;
- char *buf;
- int len;
-
- app = mprGetApp(ctx);
- if (app->logFile == 0) {
- return;
- }
-
- if (flags & MPR_LOG_SRC) {
- len = mprAllocSprintf(MPR_LOC_PASS(ctx, loc), &buf, 0,
- "Log %d: %s\n", level, msg);
-
- } else if (flags & MPR_ERROR_SRC) {
- len = mprAllocSprintf(MPR_LOC_PASS(ctx, loc), &buf, 0,
- "Error: %s\n", msg);
-
- } else if (flags & MPR_FATAL_SRC) {
- len = mprAllocSprintf(MPR_LOC_PASS(ctx, loc), &buf, 0,
- "Fatal: %s\n", msg);
-
- } else if (flags & MPR_ASSERT_SRC) {
-#if BLD_FEATURE_ALLOC_LEAK_TRACK
- len = mprAllocSprintf(MPR_LOC_PASS(ctx, loc), &buf, 0,
- "Assertion %s, failed at %s\n",
- msg, loc);
-#else
- len = mprAllocSprintf(MPR_LOC_PASS(ctx, loc), &buf, 0,
- "Assertion %s, failed\n", msg);
-#endif
-
- } else if (flags & MPR_RAW) {
- /* OPT */
- len = mprAllocSprintf(MPR_LOC_PASS(ctx, loc), &buf, 0,
- "%s", msg);
-
- } else {
- return;
- }
-
- mprPuts(app->logFile, buf, len);
-
- mprFree(buf);
-}
-
-/******************************************************************************/
-/************************************ Methods *********************************/
-/******************************************************************************/
-/*
- * function int setLog(string path)
- */
-
-static int setLog(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- const char *path;
- MprFile *file;
- MprApp *app;
-
- if (argc != 1 || !ejsVarIsString(argv[0])) {
- ejsArgError(ejs, "Usage: setLog(path)");
- return -1;
- }
-
- app = mprGetApp(ejs);
-
- /*
- * Ignore errors if we can't create the log file.
- * Use the app context so this will live longer than the interpreter
- * MOB -- this leaks files.
- */
- path = argv[0]->string;
- file = mprOpen(app, path, O_CREAT | O_TRUNC | O_WRONLY, 0664);
- if (file) {
- app->logFile = file;
- mprSetLogHandler(ejs, logHandler);
- }
- mprLog(ejs, 0, "Test log");
-
- return 0;
-}
-
-/******************************************************************************/
-#if UNUSED
-
-static int enableSetAccessor(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- if (argc != 1) {
- ejsArgError(ejs, "Usage: set(value)");
- return -1;
- }
- ejsSetProperty(ejs, thisObj, "_enabled", argv[0]);
- return 0;
-}
-
-/******************************************************************************/
-
-static int enableGetAccessor(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- ejsSetReturnValue(ejs, ejsGetPropertyAsVar(ejs, thisObj, "_enabled"));
- return 0;
-}
-
-#endif
-/******************************************************************************/
-/******************************** Initialization ******************************/
-/******************************************************************************/
-
-int ejsDefineLogClass(Ejs *ejs)
-{
- EjsVar *logClass;
-
- logClass = ejsDefineClass(ejs, "System.Log", "Object", 0);
- if (logClass == 0) {
- return MPR_ERR_CANT_INITIALIZE;
- }
-
- ejsDefineCMethod(ejs, logClass, "setLog", setLog, EJS_NO_LOCAL);
-
-#if UNUSED
- EjsProperty *pp;
- ejsDefineCAccessors(ejs, logClass, "enable", enableSetAccessor,
- enableGetAccessor, EJS_NO_LOCAL);
-
- pp = ejsSetPropertyToBoolean(ejs, logClass, "_enabled", 0);
- ejsMakePropertyEnumerable(pp, 0);
-#endif
-
- return ejsObjHasErrors(logClass) ? MPR_ERR_CANT_INITIALIZE : 0;
-}
-
-/******************************************************************************/
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- * @file ejsSystemMemory.c
- * @brief System.Memory class
- */
-/********************************** Copyright *********************************/
-/*
- * Copyright (c) Mbedthis Software LLC, 2005-2006. All Rights Reserved.
- */
-/********************************** Includes **********************************/
-
-#include "ejs.h"
-
-/****************************** Forward Declarations***************************/
-
-static uint getUsedMemory(Ejs *ejs);
-
-/******************************************************************************/
-/*********************************** Methods *********************************/
-/******************************************************************************/
-
-static int getUsedMemoryProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- ejsSetReturnValueToInteger(ejs, getUsedMemory(ejs));
- return 0;
-}
-
-/******************************************************************************/
-
-static int getUsedStackProc(Ejs *ejs, EjsVar *thisObj, int argc, EjsVar **argv)
-{
- ejsSetReturnValueToInteger(ejs, mprStackSize(ejs));
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Public function
- */
-
-uint ejsGetAvailableMemory(Ejs *ejs)
-{
- EjsVar *memoryClass;
- uint ram;
-
- memoryClass = ejsGetClass(ejs, 0, "System.Memory");
-
- ram = ejsGetPropertyAsInteger(ejs, memoryClass, "ram");
- return ram - getUsedMemory(ejs);
-}
-
-/******************************************************************************/
-
-static int getAvailableMemoryProc(Ejs *ejs, EjsVar *thisObj, int argc,
- EjsVar **argv)
-{
- EjsVar *memoryClass;
- uint ram;
-
- memoryClass = ejsGetClass(ejs, 0, "System.Memory");
-
- ram = ejsGetPropertyAsInteger(ejs, memoryClass, "ram");
-#if BREW
- ejsSetReturnValueToInteger(ejs, ram - getUsedMemory(ejs));
-#else
- ejsSetReturnValueToInteger(ejs, 0);
-#endif
- return 0;
-}
-
-/******************************************************************************/
-
-static uint getUsedMemory(Ejs *ejs)
-{
-#if BREW
- MprApp *app;
- IHeap *heap;
- uint memInUse;
- void *ptr;
-
- app = mprGetApp(ejs);
- ptr = (void*) &heap;
- if (ISHELL_CreateInstance(app->shell, AEECLSID_HEAP, (void**) ptr)
- == SUCCESS) {
- memInUse = IHEAP_GetMemStats(heap);
- IHEAP_Release(heap);
- } else {
- memInUse = 0;
- }
-
- return memInUse;
-#else
- return 0;
-#endif
-}
-
-/******************************************************************************/
-/******************************** Initialization ******************************/
-/******************************************************************************/
-
-int ejsDefineMemoryClass(Ejs *ejs)
-{
- EjsVar *memoryClass;
- uint used;
-
-#if BREW
- MprApp *app;
- AEEDeviceInfo *info;
-
- /*
- * Get needed information for class properties.
- */
- info = mprAllocType(ejs, AEEDeviceInfo);
- if (info == 0) {
- return MPR_ERR_CANT_ALLOCATE;
- }
- info->wStructSize = sizeof(AEEDeviceInfo);
- app = mprGetApp(ejs);
- ISHELL_GetDeviceInfo(app->shell, info);
- used = getUsedMemory(ejs);
-#else
- used = 0;
-#endif
-
- /*
- * Create the class
- */
- memoryClass = ejsDefineClass(ejs, "System.Memory", "Object", 0);
- if (memoryClass == 0) {
- return MPR_ERR_CANT_INITIALIZE;
- }
-
- /*
- * Define the class methods
- * MOB -- change to accessors
- */
- ejsDefineCMethod(ejs, memoryClass, "getUsedStack", getUsedStackProc,
- EJS_NO_LOCAL);
- ejsDefineCMethod(ejs, memoryClass, "getUsedMemory", getUsedMemoryProc,
- EJS_NO_LOCAL);
- ejsDefineCMethod(ejs, memoryClass, "getAvailableMemory",
- getAvailableMemoryProc, EJS_NO_LOCAL);
-
- /*
- * Define properties
- */
-#if BREW
- ejsSetPropertyToInteger(ejs, memoryClass, "ram", info->dwRAM);
-
-#if UNUSED
- /* MOB -- delete this */
- ejsSetPropertyToInteger(ejs, memoryClass, "available",
- info->dwRAM - used);
-#endif
-#endif
-
-#if UNUSED
- ejsSetPropertyToInteger(ejs, memoryClass, "used", used);
- ejsSetPropertyToInteger(ejs, memoryClass, "flash", 0);
-#endif
-
- return ejsObjHasErrors(memoryClass) ? MPR_ERR_CANT_INITIALIZE : 0;
-}
-
-/******************************************************************************/
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-#
-# Makefile for Embedded XML (EXML)
-#
-# Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
-#
-
-#
-# EXML may be linked into shared handlers so we must build the objects both
-# shared and static.
-#
-COMPILE := *.c
-EXPORT_OBJECTS := yes
-MAKE_IFLAGS := -I../mpr
-
-include make.dep
-
-ifeq ($(BLD_FEATURE_TEST),1)
-POST_DIRS := test
-endif
-
-TARGETS += $(BLD_BIN_DIR)/libexml$(BLD_LIB)
-
-ifeq ($(BLD_FEATURE_XML),1)
-compileExtra: $(TARGETS)
-endif
-
-# MOB -- remove when FEATURE_XML is defined
-compileExtra: $(TARGETS)
-
-$(BLD_BIN_DIR)/libexml$(BLD_LIB): $(FILES)
- @bld --library $(BLD_BIN_DIR)/libexml \
- --objectsDir $(BLD_OBJ_DIR) --objectList files --libs mpr
-
-cleanExtra:
- @echo "rm -f $(TARGETS)" | $(BLDOUT)
- @rm -f $(TARGETS)
- @rm -f $(BLD_BIN_DIR)/libexml.*
-
-## Local variables:
-## tab-width: 4
-## End:
-## vim: tw=78 sw=4 ts=4
+++ /dev/null
-/*
- * exml.h -- Embedded Xml Parser header
- *
- * Copyright (c) Mbedthis Software, LLC, 2003-2003. All Rights Reserved. -- MOB
- */
-
-#ifndef _h_EXML
-#define _h_EXML 1
-
-/******************************** Description *********************************/
-
-#include "mpr.h"
-
-/********************************** Defines ***********************************/
-
-#if BLD_FEATURE_SQUEEZE
- #define EXML_BUFSIZE 512 /* Read buffer size */
-#else
- #define EXML_BUFSIZE 1024 /* Read buffer size */
-#endif
-
-/*
- * XML parser states. The states that are passed to the user handler have
- * "U" appended to the comment. The error states (ERR and EOF) must be
- * negative.
- */
-#define EXML_ERR -1 /* Error */
-#define EXML_EOF -2 /* End of input */
-#define EXML_BEGIN 1 /* Before next tag */
-#define EXML_AFTER_LS 2 /* Seen "<" */
-#define EXML_COMMENT 3 /* Seen "<!--" (usr) U */
-#define EXML_NEW_ELT 4 /* Seen "<tag" (usr) U */
-#define EXML_ATT_NAME 5 /* Seen "<tag att" */
-#define EXML_ATT_EQ 6 /* Seen "<tag att" = */
-#define EXML_NEW_ATT 7 /* Seen "<tag att = "val" U */
-#define EXML_SOLO_ELT_DEFINED 8 /* Seen "<tag../>" U */
-#define EXML_ELT_DEFINED 9 /* Seen "<tag...>" U */
-#define EXML_ELT_DATA 10 /* Seen "<tag>....<" U */
-#define EXML_END_ELT 11 /* Seen "<tag>....</tag>" U */
-#define EXML_PI 12 /* Seen "<?processingInst" U */
-#define EXML_CDATA 13 /* Seen "<![CDATA[" U */
-
-/*
- * Lex tokens
- */
-typedef enum ExmlToken {
- TOKEN_ERR,
- TOKEN_TOO_BIG, /* Token is too big */
- TOKEN_CDATA,
- TOKEN_COMMENT,
- TOKEN_INSTRUCTIONS,
- TOKEN_LS, /* "<" -- Opening a tag */
- TOKEN_LS_SLASH, /* "</" -- Closing a tag */
- TOKEN_GR, /* ">" -- End of an open tag */
- TOKEN_SLASH_GR, /* "/>" -- End of a solo tag */
- TOKEN_TEXT,
- TOKEN_EQ,
- TOKEN_EOF,
- TOKEN_SPACE,
-} ExmlToken;
-
-struct Exml;
-typedef int (*ExmlHandler)(struct Exml *xp, int state,
- const char *tagName, const char* attName, const char* value);
-typedef int (*ExmlInputStream)(struct Exml *xp, void *arg, char *buf, int size);
-
-/*
- * Per XML session structure
- */
-typedef struct Exml {
- ExmlHandler handler; /* Callback function */
- ExmlInputStream readFn; /* Read data function */
- MprBuf *inBuf; /* Input data queue */
- MprBuf *tokBuf; /* Parsed token buffer */
- int quoteChar; /* XdbAtt quote char */
- int lineNumber; /* Current line no for debug */
- void *parseArg; /* Arg passed to exmlParse() */
- void *inputArg; /* Arg passed to exmlSetInputStream() */
- char *errMsg; /* Error message text */
-} Exml;
-
-extern Exml *exmlOpen(MprCtx ctx, int initialSize, int maxSize);
-extern void exmlClose(Exml *xp);
-extern void exmlSetParserHandler(Exml *xp, ExmlHandler h);
-extern void exmlSetInputStream(Exml *xp, ExmlInputStream s, void *arg);
-extern int exmlParse(Exml *xp);
-extern void exmlSetParseArg(Exml *xp, void *parseArg);
-extern void *exmlGetParseArg(Exml *xp);
-extern const char *exmlGetErrorMsg(Exml *xp);
-extern int exmlGetLineNumber(Exml *xp);
-
-/******************************************************************************/
-
-#endif /* _h_EXML */
+++ /dev/null
-/*
- * exml.c -- A simple SAX style XML parser
- */
-
-/********************************* Description ********************************/
-/*
- * This is a recursive descent parser for XML text files. It is a one-pass
- * simple parser that invokes a user supplied callback for key tokens in the
- * XML file. The user supplies a read function so that XML files can be parsed
- * from disk or in-memory.
- */
-/********************************** Includes **********************************/
-
-#include "exml.h"
-
-/****************************** Forward Declarations **************************/
-/* MOB -- FIX */
-#if BLD_FEATURE_EXML || 1
-
-static int parseNext(Exml *xp, int state);
-static ExmlToken getToken(Exml *xp, int state);
-static int getNextChar(Exml *xp);
-static int scanFor(Exml *xp, char *str);
-static int putLastChar(Exml *xp, int c);
-static void error(Exml *xp, char *fmt, ...);
-static void trimToken(Exml *xp);
-
-/************************************ Code ************************************/
-
-Exml *exmlOpen(MprCtx ctx, int initialSize, int maxSize)
-{
- Exml *xp;
-
- xp = mprAllocTypeZeroed(ctx, Exml);
-
- xp->inBuf = mprCreateBuf(xp, EXML_BUFSIZE, EXML_BUFSIZE);
- xp->tokBuf = mprCreateBuf(xp, initialSize, maxSize);
-
- return xp;
-}
-
-/******************************************************************************/
-
-void exmlClose(Exml *xp)
-{
- mprAssert(xp);
-
- mprFree(xp);
-}
-
-/******************************************************************************/
-
-void exmlSetParserHandler(Exml *xp, ExmlHandler h)
-{
- mprAssert(xp);
-
- xp->handler = h;
-}
-
-/******************************************************************************/
-
-void exmlSetInputStream(Exml *xp, ExmlInputStream s, void *arg)
-{
- mprAssert(xp);
-
- xp->readFn = s;
- xp->inputArg = arg;
-}
-
-/******************************************************************************/
-/*
- * Set the parse arg
- */
-
-void exmlSetParseArg(Exml *xp, void *parseArg)
-{
- mprAssert(xp);
-
- xp->parseArg = parseArg;
-}
-
-/******************************************************************************/
-/*
- * Set the parse arg
- */
-
-void *exmlGetParseArg(Exml *xp)
-{
- mprAssert(xp);
-
- return xp->parseArg;
-}
-
-/******************************************************************************/
-/*
- * Parse an XML file. Return 0 for success, -1 for error.
- */
-
-int exmlParse(Exml *xp)
-{
- mprAssert(xp);
-
- return parseNext(xp, EXML_BEGIN);
-}
-
-/******************************************************************************/
-/*
- * XML parser. This is a recursive descent parser. Return -1 for errors, 0 for
- * EOF and 1 if there is still more data to parse.
- */
-
-static int parseNext(Exml *xp, int state)
-{
- ExmlHandler handler;
- ExmlToken token;
- MprBuf *tokBuf;
- char *tname, *aname;
- int rc;
-
- mprAssert(state >= 0);
-
- tokBuf = xp->tokBuf;
- handler = xp->handler;
- tname = aname = 0;
- rc = 0;
-
- /*
- * In this parse loop, the state is never assigned EOF or ERR. In
- * such cases we always return EOF or ERR.
- */
- while (1) {
-
- token = getToken(xp, state);
-
- if (token == TOKEN_TOO_BIG) {
- error(xp, "XML token is too big");
- goto err;
- }
-
- switch (state) {
- case EXML_BEGIN: /* ------------------------------------------ */
- /*
- * Expect to get an element, comment or processing instruction
- */
- switch (token) {
- case TOKEN_EOF:
- goto exit;
-
- case TOKEN_LS:
- /*
- * Recurse to handle the new element, comment etc.
- */
- rc = parseNext(xp, EXML_AFTER_LS);
- if (rc < 0) {
- goto exit;
- }
- break;
-
- default:
- error(xp, "Syntax error");
- goto err;
- }
- break;
-
- case EXML_AFTER_LS: /* ------------------------------------------ */
- switch (token) {
- case TOKEN_COMMENT:
- state = EXML_COMMENT;
- rc = (*handler)(xp, state, "!--", 0, mprGetBufStart(tokBuf));
- if (rc < 0) {
- goto err;
- }
- rc = 1;
- goto exit;
-
- case TOKEN_CDATA:
- state = EXML_CDATA;
- rc = (*handler)(xp, state, "!--", 0, mprGetBufStart(tokBuf));
- if (rc < 0) {
- goto err;
- }
- rc = 1;
- goto exit;
-
- case TOKEN_INSTRUCTIONS:
- /* Just ignore processing instructions */
- rc = 1;
- goto exit;
-
- case TOKEN_TEXT:
- state = EXML_NEW_ELT;
- tname = mprStrdup(xp, mprGetBufStart(tokBuf));
- if (tname == 0) {
- rc = MPR_ERR_MEMORY;
- goto exit;
- }
- rc = (*handler)(xp, state, tname, 0, 0);
- if (rc < 0) {
- goto err;
- }
- break;
-
- default:
- error(xp, "Syntax error");
- goto err;
- }
- break;
-
- case EXML_NEW_ELT: /* ------------------------------------------ */
- /*
- * We have seen the opening "<element" for a new element and have
- * not yet seen the terminating ">" of the opening element.
- */
- switch (token) {
- case TOKEN_TEXT:
- /*
- * Must be an attribute name
- */
- aname = mprStrdup(xp, mprGetBufStart(tokBuf));
- token = getToken(xp, state);
- if (token != TOKEN_EQ) {
- error(xp, "Missing assignment for attribute \"%s\"", aname);
- goto err;
- }
-
- token = getToken(xp, state);
- if (token != TOKEN_TEXT) {
- error(xp, "Missing value for attribute \"%s\"", aname);
- goto err;
- }
- state = EXML_NEW_ATT;
- rc = (*handler)(xp, state, tname, aname,
- mprGetBufStart(tokBuf));
- if (rc < 0) {
- goto err;
- }
- state = EXML_NEW_ELT;
- break;
-
- case TOKEN_GR:
- /*
- * This is ">" the termination of the opening element
- */
- if (*tname == '\0') {
- error(xp, "Missing element name");
- goto err;
- }
-
- /*
- * Tell the user that the opening element is now complete
- */
- state = EXML_ELT_DEFINED;
- rc = (*handler)(xp, state, tname, 0, 0);
- if (rc < 0) {
- goto err;
- }
- state = EXML_ELT_DATA;
- break;
-
- case TOKEN_SLASH_GR:
- /*
- * If we see a "/>" then this is a solo element
- */
- if (*tname == '\0') {
- error(xp, "Missing element name");
- goto err;
- }
- state = EXML_SOLO_ELT_DEFINED;
- rc = (*handler)(xp, state, tname, 0, 0);
- if (rc < 0) {
- goto err;
- }
- rc = 1;
- goto exit;
-
- default:
- error(xp, "Syntax error");
- goto err;
- }
- break;
-
- case EXML_ELT_DATA: /* -------------------------------------- */
- /*
- * We have seen the full opening element "<name ...>" and now
- * await data or another element.
- */
- if (token == TOKEN_LS) {
- /*
- * Recurse to handle the new element, comment etc.
- */
- rc = parseNext(xp, EXML_AFTER_LS);
- if (rc < 0) {
- goto exit;
- }
- break;
-
- } else if (token == TOKEN_LS_SLASH) {
- state = EXML_END_ELT;
- break;
-
- } else if (token != TOKEN_TEXT) {
- goto err;
- }
- if (mprGetBufLength(tokBuf) > 0) {
- /*
- * Pass the data between the element to the user
- */
- rc = (*handler)(xp, state, tname, 0, mprGetBufStart(tokBuf));
- if (rc < 0) {
- goto err;
- }
- }
- break;
-
- case EXML_END_ELT: /* -------------------------------------- */
- if (token != TOKEN_TEXT) {
- error(xp, "Missing closing element name for \"%s\"", tname);
- goto err;
- }
- /*
- * The closing element name must match the opening element name
- */
- if (strcmp(tname, mprGetBufStart(tokBuf)) != 0) {
- error(xp,
- "Closing element name \"%s\" does not match on line %d"
- "opening name \"%s\"",
- mprGetBufStart(tokBuf), xp->lineNumber, tname);
- goto err;
- }
- rc = (*handler)(xp, state, tname, 0, 0);
- if (rc < 0) {
- goto err;
- }
- if (getToken(xp, state) != TOKEN_GR) {
- error(xp, "Syntax error");
- goto err;
- }
- return 1;
-
- case EXML_EOF: /* ---------------------------------------------- */
- goto exit;
-
- case EXML_ERR: /* ---------------------------------------------- */
- default:
- goto err;
- }
- }
- mprAssert(0);
-
-err:
- rc = -1;
-
-exit:
- mprFree(tname);
- mprFree(aname);
-
- return rc;
-}
-
-/******************************************************************************/
-/*
- * Lexical analyser for XML. Return the next token reading input as required.
- * It uses a one token look ahead and push back mechanism (LAR1 parser).
- * Text token identifiers are left in the tokBuf parser buffer on exit.
- * This Lex has special cases for the states EXML_ELT_DATA where we
- * have an optimized read of element data, and EXML_AFTER_LS where we
- * distinguish between element names, processing instructions and comments.
- */
-
-static ExmlToken getToken(Exml *xp, int state)
-{
- MprBuf *tokBuf, *inBuf;
- uchar *cp;
- int c, rc;
-
- tokBuf = xp->tokBuf;
- inBuf = xp->inBuf;
-
- mprAssert(state >= 0);
-
- if ((c = getNextChar(xp)) < 0) {
- return TOKEN_EOF;
- }
- mprFlushBuf(tokBuf);
-
- /*
- * Special case parsing for names and for element data. We do this for
- * performance so we can return to the caller the largest token possible
- */
- if (state == EXML_ELT_DATA) {
- /*
- * Read all the data up to the start of the closing element "<" or the
- * start of a sub-element.
- */
-#if UNUSED
- while (isspace(c)) {
- if ((c = getNextChar(xp)) < 0) {
- return TOKEN_EOF;
- }
- }
-#endif
- if (c == '<') {
- if ((c = getNextChar(xp)) < 0) {
- return TOKEN_EOF;
- }
- if (c == '/') {
- return TOKEN_LS_SLASH;
- }
- putLastChar(xp, c);
- return TOKEN_LS;
- }
- do {
- if (mprPutCharToBuf(tokBuf, c) < 0) {
- return TOKEN_TOO_BIG;
- }
- if ((c = getNextChar(xp)) < 0) {
- return TOKEN_EOF;
- }
- } while (c != '<');
-
- /*
- * Put back the last look-ahead character
- */
- putLastChar(xp, c);
-
- /*
- * If all white space, then zero the token buffer
- */
- for (cp = tokBuf->start; *cp; cp++) {
- if (!isspace(*cp)) {
- return TOKEN_TEXT;
- }
- }
- mprFlushBuf(tokBuf);
- return TOKEN_TEXT;
- }
-
- while (1) {
- switch (c) {
- case ' ':
- case '\n':
- case '\t':
- case '\r':
- break;
-
- case '<':
- if ((c = getNextChar(xp)) < 0) {
- return TOKEN_EOF;
- }
- if (c == '/') {
- return TOKEN_LS_SLASH;
- }
- putLastChar(xp, c);
- return TOKEN_LS;
-
- case '=':
- return TOKEN_EQ;
-
- case '>':
- return TOKEN_GR;
-
- case '/':
- if ((c = getNextChar(xp)) < 0) {
- return TOKEN_EOF;
- }
- if (c == '>') {
- return TOKEN_SLASH_GR;
- }
- return TOKEN_ERR;
-
- case '\"':
- case '\'':
- xp->quoteChar = c;
- /* Fall through */
-
- default:
- /*
- * We handle element names, attribute names and attribute values
- * here. We do NOT handle data between elements here. Read the
- * token. Stop on white space or a closing element ">"
- */
- if (xp->quoteChar) {
- if ((c = getNextChar(xp)) < 0) {
- return TOKEN_EOF;
- }
- while (c != xp->quoteChar) {
- if (mprPutCharToBuf(tokBuf, c) < 0) {
- return TOKEN_TOO_BIG;
- }
- if ((c = getNextChar(xp)) < 0) {
- return TOKEN_EOF;
- }
- }
- xp->quoteChar = 0;
-
- } else {
- while (!isspace(c) && c != '>' && c != '/' && c != '=') {
- if (mprPutCharToBuf(tokBuf, c) < 0) {
- return TOKEN_TOO_BIG;
- }
- if ((c = getNextChar(xp)) < 0) {
- return TOKEN_EOF;
- }
- }
- putLastChar(xp, c);
- }
- if (mprGetBufLength(tokBuf) <= 0) {
- return TOKEN_ERR;
- }
- mprAddNullToBuf(tokBuf);
-
- if (state == EXML_AFTER_LS) {
- /*
- * If we are just inside an element "<", then analyze what we
- * have to see if we have an element name, instruction or
- * comment. Tokbuf will hold "?" for instructions or "!--"
- * for comments.
- */
- if (mprLookAtNextCharInBuf(tokBuf) == '?') {
- /* Just ignore processing instructions */
- rc = scanFor(xp, "?>");
- if (rc < 0) {
- return TOKEN_TOO_BIG;
- } else if (rc == 0) {
- return TOKEN_ERR;
- }
- return TOKEN_INSTRUCTIONS;
-
- } else if (mprLookAtNextCharInBuf(tokBuf) == '!') {
- /*
- * First discard the comment leadin "!--" and eat leading
- * white space.
- */
- if (strcmp((char*) tokBuf->start, "![CDATA[") == 0) {
- mprFlushBuf(tokBuf);
-#if UNUSED
- c = mprLookAtNextCharInBuf(inBuf);
- while (isspace(c)) {
- if ((c = getNextChar(xp)) < 0) {
- return TOKEN_EOF;
- }
- c = mprLookAtNextCharInBuf(inBuf);
- }
-#endif
- rc = scanFor(xp, "]]>");
- if (rc < 0) {
- return TOKEN_TOO_BIG;
- } else if (rc == 0) {
- return TOKEN_ERR;
- }
- return TOKEN_CDATA;
-
- } else {
- mprFlushBuf(tokBuf);
-#if UNUSED
- c = mprLookAtNextCharInBuf(inBuf);
- while (isspace(c)) {
- if ((c = getNextChar(xp)) < 0) {
- return TOKEN_EOF;
- }
- c = mprLookAtNextCharInBuf(inBuf);
- }
-#endif
- rc = scanFor(xp, "-->");
- if (rc < 0) {
- return TOKEN_TOO_BIG;
- } else if (rc == 0) {
- return TOKEN_ERR;
- }
- return TOKEN_COMMENT;
- }
- }
- }
- trimToken(xp);
- return TOKEN_TEXT;
- }
- if ((c = getNextChar(xp)) < 0) {
- return TOKEN_EOF;
- }
- }
-
- /* Should never get here */
- mprAssert(0);
- return TOKEN_ERR;
-}
-
-/******************************************************************************/
-/*
- * Scan for a pattern. Eat and discard input up to the pattern. Return 1 if
- * the pattern was found, return 0 if not found. Return < 0 on errors.
- */
-
-static int scanFor(Exml *xp, char *str)
-{
- MprBuf *tokBuf;
- char *cp;
- int c;
-
- mprAssert(str);
-
- tokBuf = xp->tokBuf;
-
- while (1) {
- for (cp = str; *cp; cp++) {
- if ((c = getNextChar(xp)) < 0) {
- return 0;
- }
- if (tokBuf) {
- if (mprPutCharToBuf(tokBuf, c) < 0) {
- return -1;
- }
- }
- if (c != *cp) {
- break;
- }
- }
- if (*cp == '\0') {
- /*
- * Remove the pattern from the tokBuf
- */
- if (tokBuf) {
- mprAdjustBufEnd(tokBuf, -(int) strlen(str));
- trimToken(xp);
- }
- return 1;
- }
- }
-}
-
-/******************************************************************************/
-/*
- * Get another character. We read and buffer blocks of data if we need more
- * data to parse.
- */
-
-static int getNextChar(Exml *xp)
-{
- MprBuf *inBuf;
- char c;
- int l;
-
- inBuf = xp->inBuf;
- if (mprGetBufLength(inBuf) <= 0) {
- /*
- * Flush to reset the servp/endp pointers to the start of the buffer
- * so we can do a maximal read
- */
- mprFlushBuf(inBuf);
- l = (xp->readFn)(xp, xp->inputArg, mprGetBufStart(inBuf),
- mprGetBufLinearSpace(inBuf));
- if (l <= 0) {
- return -1;
- }
- mprAdjustBufEnd(inBuf, l);
- }
- c = mprGetCharFromBuf(inBuf);
-
- if (c == '\n') {
- xp->lineNumber++;
- }
- return c;
-}
-
-/******************************************************************************/
-/*
- * Put back a character in the input buffer
- */
-
-static int putLastChar(Exml *xp, int c)
-{
- if (mprInsertCharToBuf(xp->inBuf, (char) c) < 0) {
- mprAssert(0);
- return -1;
- }
- if (c == '\n') {
- xp->lineNumber--;
- }
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Output a parse message
- */
-
-static void error(Exml *xp, char *fmt, ...)
-{
- va_list args;
- char *buf;
-
- mprAssert(fmt);
-
- va_start(args, fmt);
- mprAllocVsprintf(MPR_LOC_ARGS(xp), &buf, MPR_MAX_STRING, fmt, args);
- va_end(args);
-
- /*
- * MOB need to add the failing line text and a pointer to which column
- */
- mprFree(xp->errMsg);
- mprAllocSprintf(MPR_LOC_ARGS(xp), &xp->errMsg, MPR_MAX_STRING,
- "XML error: %s\nAt line %d\n", buf, xp->lineNumber);
-
- mprFree(buf);
-}
-
-/******************************************************************************/
-/*
- * Remove trailing whitespace in a token and ensure it is terminated with
- * a NULL for easy parsing
- */
-
-static void trimToken(Exml *xp)
-{
- while (isspace(mprLookAtLastCharInBuf(xp->tokBuf))) {
- mprAdjustBufEnd(xp->tokBuf, -1);
- }
- mprAddNullToBuf(xp->tokBuf);
-}
-
-/******************************************************************************/
-
-const char *exmlGetErrorMsg(Exml *xp)
-{
- if (xp->errMsg == 0) {
- return "";
- }
- return xp->errMsg;
-}
-
-/******************************************************************************/
-
-int exmlGetLineNumber(Exml *xp)
-{
- return xp->lineNumber;
-}
-
-/******************************************************************************/
-#else
-
-void exmlParserDummy() {}
-#endif /* BLD_FEATURE_EXML */
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-${BLD_OBJ_DIR}/exmlParser${BLD_OBJ}
+++ /dev/null
-#
-# Makefile for the Mbedthis Portable Runtime (MPR) library
-#
-# Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
-#
-
-COMPILE := *.c
-EXPORT_OBJECTS := yes
-
-include make.dep
-
-ifeq ($(BLD_HOST_UNIX),1)
-PRE_DIRS = UNIX
-else
-PRE_DIRS = $(BLD_HOST_OS)
-endif
-
-POST_DIRS = package
-
-TARGETS += $(BLD_BIN_DIR)/libmpr$(BLD_LIB)
-
-compileExtra: $(TARGETS)
-
-#
-# Build the mpr libraries
-#
-$(BLD_BIN_DIR)/libmpr$(BLD_LIB): files \
- $(shell BLD_OBJ=$(BLD_OBJ) \; BLD_OBJ_DIR=$(BLD_OBJ_DIR) \; \
- eval echo `cat files`)
- @bld --library $(BLD_BIN_DIR)/libmpr \
- --objectsDir $(BLD_OBJ_DIR) --objectList files
-
-cleanExtra:
- @echo "rm -f $(TARGETS)" | $(BLDOUT)
- @rm -f $(TARGETS)
- @rm -f $(BLD_BIN_DIR)/libmpr.*
-
-## Local variables:
-## tab-width: 4
-## End:
-## vim: tw=78 sw=4 ts=4
+++ /dev/null
-#
-# Makefile for the Mbedthis Portable Runtime (MPR) library for UNIX
-#
-# Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
-#
-
-COMPILE := *.c
-EXPORT_OBJECTS := yes
-MAKE_IFLAGS := -I..
-
-include make.dep
-
-## Local variables:
-## tab-width: 4
-## End:
-## vim: tw=78 sw=4 ts=4
+++ /dev/null
-/**
- * @file mprFile.c
- * @brief File services for Unix
- * @overview
- * @remarks
- * See mprGenFile.c for other file services.
- */
-
-/******************************************************************************/
-/*
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-
-/********************************** Includes **********************************/
-
-#include "mpr.h"
-
-/************************************ Code ************************************/
-
-int mprGetFileInfo(MprCtx ctx, const char *path, MprFileInfo *info)
-{
- struct stat s;
-
- mprAssert(path);
- mprAssert(info);
-
- if (stat(path, &s) < 0) {
- return -1;
- }
-
- info->size = s.st_size;
- info->ctime = s.st_ctime;
- info->mtime = s.st_mtime;
- info->inode = s.st_ino;
- info->isDir = (s.st_mode & S_IFDIR) != 0;
- info->isReg = (s.st_mode & S_IFREG) != 0;
-
- if (strcmp(path, "/dev/null") == 0) {
- info->isReg = 0;
- }
-
- return 0;
-}
-
-/******************************************************************************/
-
-int mprMakeDir(MprCtx ctx, const char *path, int perms)
-{
- return mkdir(path, perms);
-}
-
-/******************************************************************************/
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/**
- * @file mprPlatform.c
- * @brief Cross platform routines
- * @overview This module provides low level cross platform routines.
- * @remarks Most routines in this file are not thread-safe. It is the callers
- * responsibility to perform all thread synchronization.
- */
-
-/*
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-
-/********************************** Includes **********************************/
-/*
- * We need to use the underlying str(cpy) routines to implement our safe
- * alternatives
- */
-#if !DOXYGEN
-#define UNSAFE_FUNCTIONS_OK 1
-#endif
-
-#include "mpr.h"
-
-/************************************ Code ************************************/
-
-char *mprInetToStr(char *buffer, int bufsize, const struct in_addr in)
-{
-#if HAVE_NTOA_R
- inet_ntoa_r(in, buffer, bufsize);
-#else
- uchar *cp;
- /* FUTURE -- this is not portable */
- cp = (uchar*) ∈
- mprSprintf(buffer, bufsize, "%d.%d.%d.%d", cp[0], cp[1], cp[2], cp[3]);
-#endif
- return buffer;
-}
-
-/******************************************************************************/
-
-void mprSetShell(MprCtx ctx, void *shell)
-{
-}
-
-/******************************************************************************/
-
-void *mprGetShell(MprCtx ctx)
-{
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Sleep. Period given in milliseconds.
- */
-
-void mprSleep(MprCtx ctx, int milliseconds)
-{
- struct timespec timeout;
- int rc;
-
- mprAssert(milliseconds >= 0);
- timeout.tv_sec = milliseconds / 1000;
- timeout.tv_nsec = (milliseconds % 1000) * 1000000;
- do {
- rc = nanosleep(&timeout, 0);
- } while (rc < 0 && errno == EINTR);
-}
-
-/******************************************************************************/
-/*
- * Make intervening directories
- */
-
-int mprMakeDirPath(MprCtx ctx, const char *path)
-{
- char dir[MPR_MAX_PATH], buf[MPR_MAX_PATH];
- char *dirSep;
- char *next, *tok;
-
- dir[0] = '\0';
- dirSep = "/\\";
-
- if (path == 0 || *path == '\0') {
- return MPR_ERR_BAD_ARGS;
- }
-
- mprStrcpy(buf, sizeof(buf), path);
- next = mprStrTok(buf, dirSep, &tok);
- if (*buf == '/') {
- dir[0] = '/';
- }
- while (next != NULL) {
- if (strcmp(next, ".") == 0 ) {
- next = mprStrTok(NULL, dirSep, &tok);
- continue;
- }
- strcat(dir, next);
- if (access(dir, R_OK) != 0) {
- if (mkdir(dir, 0666) < 0) {
- return MPR_ERR_CANT_CREATE;
- }
- }
- strcat(dir, "/");
- next = mprStrTok(NULL, dirSep, &tok);
- }
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Get a fully qualified file name for the given path. Return with forward
- * slashes always
- */
-
-char *mprGetFullPathName(char *buf, int buflen, const char *path)
-{
- if (mprStrcpy(buf, buflen, path) < 0) {
- mprAssert(0);
- return 0;
- }
- return buf;
-}
-
-/******************************************************************************/
-/*
- * Replacement for gethostbyname that is multi-thread safe
- */
-
-struct hostent *mprGetHostByName(MprCtx ctx, const char *name)
-{
- MprApp *app;
- struct hostent *hp;
- struct hostent *ip;
- int count, i;
-
- hp = (struct hostent*) mprAlloc(ctx, sizeof(struct hostent));
- memset(hp, 0, sizeof(struct hostent));
-
- app = mprGetApp(ctx);
-
- #undef gethostbyname
-
- mprGlobalLock(app);
- ip = gethostbyname(name);
- mprGlobalUnlock(app);
-
- if (ip == 0) {
- return 0;
- }
- hp->h_addrtype = ip->h_addrtype;
- hp->h_length = ip->h_length;
- hp->h_name = mprStrdup(hp, ip->h_name);
- hp->h_addr_list = 0;
- hp->h_aliases = 0;
-
- for (count = 0; ip->h_addr_list[count] != 0; ) {
- count++;
- }
- if (count > 0) {
- count++;
- hp->h_addr_list = mprAlloc(hp, count * sizeof(char*));
- for (i = 0; ip->h_addr_list[i] != 0; i++) {
- memcpy(&hp->h_addr_list[i], &ip->h_addr_list[i], ip->h_length);
- }
- hp->h_addr_list[i] = 0;
- }
-
- for (count = 0; ip->h_aliases[count] != 0; ) {
- count++;
- }
- if (count > 0) {
- count++;
- hp->h_aliases = mprAlloc(hp, count * sizeof(char*));
- for (i = 0; ip->h_aliases[i] != 0; i++) {
- hp->h_aliases[i] = mprStrdup(hp, ip->h_aliases[i]);
- }
- hp->h_aliases[i] = 0;
- }
- return hp;
-}
-
-/******************************************************************************/
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/**
- * @file mprTime.c
- * @brief Time handling for Unix
- * @overview
- */
-
-/*
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-
-/********************************* Includes ***********************************/
-
-#include "mpr.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#undef localtime
-#undef localtime_r
-#undef gmtime
-#undef gmtime_r
-#undef ctime
-#undef ctime_r
-#undef asctime
-#undef asctime_r
-
-/******************************************************************************/
-/*
- * Returns time in seconds and milliseconds. This is NOT time-of-day.
- */
-
-MprTime *mprGetTime(MprCtx ctx, MprTime *tp)
-{
- struct timeval tv;
-
- if (gettimeofday(&tv, 0) < 0) {
- mprAssert(0);
- tp->sec = 0;
- tp->msec = 0;
- return tp;
- }
- tp->sec = tv.tv_sec;
- tp->msec = tv.tv_usec / 1000;
- return tp;
-}
-
-/******************************************************************************/
-/*
- * Thread-safe wrapping of localtime
- */
-
-struct tm *mprLocaltime(MprCtx ctx, struct tm *timep, time_t *now)
-{
- localtime_r(now, timep);
-
- return timep;
-}
-
-/******************************************************************************/
-/*
- * Thread-safe wrapping of gmtime
- */
-
-struct tm *mprGmtime(MprCtx ctx, time_t *now, struct tm *timep)
-{
- gmtime_r(now, timep);
-
- return timep;
-}
-
-/******************************************************************************/
-/*
- * Thread-safe wrapping of ctime
- */
-
-int mprCtime(MprCtx ctx, char *buf, int bufsize, const time_t *timer)
-{
- char localBuf[80];
- char *cp;
- int len;
-
- mprAssert(buf);
-
- mprGlobalLock(ctx);
-
- cp = ctime_r(timer, localBuf);
- if ((int) strlen(cp) >= bufsize) {
- mprStrcpy(buf, bufsize, "WONT FIT");
- mprAssert(0);
- return MPR_ERR_WONT_FIT;
- }
- len = mprStrcpy(buf, bufsize, cp);
-
- if (buf[len - 1] == '\n') {
- buf[len - 1] = '\0';
- }
-
- mprGlobalUnlock(ctx);
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Thread-safe wrapping of asctime
- */
-
-int mprAsctime(MprCtx ctx, char *buf, int bufsize, const struct tm *timeptr)
-{
- char *cp;
- char localBuf[80];
-
- cp = asctime_r(timeptr, localBuf);
- if ((int) strlen(cp) >= bufsize) {
- mprAssert(0);
- return MPR_ERR_WONT_FIT;
- }
- mprStrcpy(buf, bufsize, cp);
-
- return strlen(buf);
-}
-
-/******************************************************************************/
-
-#ifdef __cplusplus
-}
-#endif
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-#
-# Makefile for the Mbedthis Portable Runtime (MPR) library for VXWORKS
-#
-# Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
-#
-
-COMPILE := *.c
-EXPORT_OBJECTS := yes
-MAKE_IFLAGS := -I..
-
-include make.dep
-
-## Local variables:
-## tab-width: 4
-## End:
-## vim: tw=78 sw=4 ts=4
+++ /dev/null
-/**
- * @file mprUnixFile.c
- * @brief File services for Unix
- * @overview
- * @remarks
- */
-
-/******************************************************************************/
-/*
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-
-/********************************** Includes **********************************/
-
-#include "mpr.h"
-
-/************************************ Code ************************************/
-
-int mprGetFileInfo(MprCtx ctx, const char *path, MprFileInfo *info)
-{
- struct stat s;
-
- mprAssert(path);
- mprAssert(info);
-
- if (stat(path, &s) < 0) {
- return -1;
- }
-
- info->size = s.st_size;
- info->ctime = s.st_ctime;
- info->mtime = s.st_mtime;
- info->inode = s.st_ino;
- info->isDir = (s.st_mode & S_IFDIR) != 0;
- info->isReg = (s.st_mode & S_IFREG) != 0;
-
- if (strcmp(path, "/dev/null") == 0) {
- info->isReg = 0;
- }
-
- return 0;
-}
-
-/******************************************************************************/
-
-int mprMakeDir(MprCtx ctx, const char *path, int perms)
-{
- return mkdir(path, perms);
-}
-
-/******************************************************************************/
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/**
- * @file mprPlatform.c
- * @brief Cross platform routines
- * @overview This module provides low level cross platform routines.
- * @remarks Most routines in this file are not thread-safe. It is the callers
- * responsibility to perform all thread synchronization.
- */
-
-/*
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-
-/********************************** Includes **********************************/
-/*
- * We need to use the underlying str(cpy) routines to implement our safe
- * alternatives
- */
-#if !DOXYGEN
-#define UNSAFE_FUNCTIONS_OK 1
-#endif
-
-#include "mpr.h"
-
-/************************************ Code ************************************/
-
-char *mprInetToStr(char *buffer, int bufsize, const struct in_addr in)
-{
-#if HAVE_NTOA_R
- inet_ntoa_r(in, buffer, bufsize);
-#else
- uchar *cp;
- /* FUTURE -- this is not portable */
- cp = (uchar*) ∈
- mprSprintf(buffer, bufsize, "%d.%d.%d.%d", cp[0], cp[1], cp[2], cp[3]);
-#endif
- return buffer;
-}
-
-/******************************************************************************/
-
-void mprSetShell(MprCtx ctx, void *shell)
-{
-}
-
-/******************************************************************************/
-
-void *mprGetShell(MprCtx ctx)
-{
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Sleep. Period given in milliseconds.
- */
-
-void mprSleep(MprCtx ctx, int milliseconds)
-{
- struct timeval timeout;
- int rc;
-
- timeout.tv_sec = milliseconds / 1000;
- timeout.tv_usec = (milliseconds % 1000) * 1000;
- do {
- rc = select(1, 0, 0, 0, &timeout);
- } while (rc < 0 && errno == EINTR);
-}
-
-/******************************************************************************/
-/*
- * Make intervening directories
- */
-
-int mprMakeDirPath(MprCtx ctx, const char *path)
-{
- char dir[MPR_MAX_PATH], buf[MPR_MAX_PATH];
- char *dirSep;
- char *next, *tok;
-
- dir[0] = '\0';
- dirSep = "/\\";
-
- if (path == 0 || *path == '\0') {
- return MPR_ERR_BAD_ARGS;
- }
-
- mprStrcpy(buf, sizeof(buf), path);
- next = mprStrTok(buf, dirSep, &tok);
- if (*buf == '/') {
- dir[0] = '/';
- }
- while (next != NULL) {
- if (strcmp(next, ".") == 0 ) {
- next = mprStrTok(NULL, dirSep, &tok);
- continue;
- }
- strcat(dir, next);
- if (access(dir, R_OK) != 0) {
- if (mkdir(dir) < 0) {
- return MPR_ERR_CANT_CREATE;
- }
- }
- strcat(dir, "/");
- next = mprStrTok(NULL, dirSep, &tok);
- }
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Get a fully qualified file name for the given path. Return with forward
- * slashes always
- */
-
-char *mprGetFullPathName(char *buf, int buflen, const char *path)
-{
- if (mprStrcpy(buf, buflen, path) < 0) {
- mprAssert(0);
- return 0;
- }
- return buf;
-}
-
-/******************************************************************************/
-/*
- * Replacement for gethostbyname that is multi-thread safe
- */
-
-struct hostent *mprGetHostByName(MprCtx ctx, const char *name)
-{
- struct hostent *hp;
-
- hp = (struct hostent*) mprAlloc(ctx, sizeof(struct hostent));
- memset(hp, 0, sizeof(struct hostent));
-
- struct in_addr inaddr;
- inaddr.s_addr = (ulong) hostGetByName(name);
- if (inaddr.s_addr < 0) {
- mprAssert(0);
- return 0;
- }
- hp->h_addrtype = AF_INET;
- hp->h_length = sizeof(int);
- hp->h_name = mprStrdup(name);
- hp->h_addr_list = 0;
- hp->h_aliases = 0;
-
- hp->h_addr_list = new char*[2];
- hp->h_addr_list[0] = (char *) mprAlloc(hp, sizeof(struct in_addr));
- memcpy(&hp->h_addr_list[0], &inaddr, hp->h_length);
- hp->h_addr_list[1] = 0;
-
- return hp;
-}
-
-/******************************************************************************/
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/**
- * @file mprTime.c
- * @brief Time handling for VxWorks
- * @overview
- */
-
-/*
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-
-/********************************* Includes ***********************************/
-
-#include "mpr.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#undef localtime
-#undef localtime_r
-#undef gmtime
-#undef gmtime_r
-#undef ctime
-#undef ctime_r
-#undef asctime
-#undef asctime_r
-
-/******************************************************************************/
-/*
- * Returns time in seconds and milliseconds. This is NOT time-of-day.
- */
-
-MprTime *mprGetTime(MprCtx ctx, MprTime *tp)
-{
- struct timeval tv;
-
- if (gettimeofday(&tv, 0) < 0) {
- mprAssert(0);
- tp->sec = 0;
- tp->msec = 0;
- return tp;
- }
- tp->sec = tv.tv_sec;
- tp->msec = tv.tv_usec / 1000;
- return tp;
-}
-
-/******************************************************************************/
-/*
- * Thread-safe wrapping of localtime
- */
-
-struct tm *mprLocaltime(MprCtx ctx, struct tm *timep, time_t *now)
-{
- localtime_r(now, timep);
-
- return timep;
-}
-
-/******************************************************************************/
-/*
- * Thread-safe wrapping of gmtime
- */
-
-struct tm *mprGmtime(MprCtx ctx, time_t *now, struct tm *timep)
-{
- gmtime_r(now, timep);
-
- return timep;
-}
-
-/******************************************************************************/
-/*
- * Thread-safe wrapping of ctime
- */
-
-int mprCtime(MprCtx ctx, char *buf, int bufsize, const time_t *timer)
-{
- char localBuf[80];
- char *cp;
- int len;
-
- mprAssert(buf);
-
- mprGlobalLock(ctx);
-
- cp = ctime_r(timer, localBuf);
- if ((int) strlen(cp) >= bufsize) {
- mprStrcpy(buf, bufsize, "WONT FIT");
- mprAssert(0);
- return MPR_ERR_WONT_FIT;
- }
- len = mprStrcpy(buf, bufsize, cp);
-
- if (buf[len - 1] == '\n') {
- buf[len - 1] = '\0';
- }
-
- mprGlobalUnlock(ctx);
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Thread-safe wrapping of asctime
- */
-
-int mprAsctime(MprCtx ctx, char *buf, int bufsize, const struct tm *timeptr)
-{
- char *cp;
- char localBuf[80];
-
- cp = asctime_r(timeptr, localBuf);
- if ((int) strlen(cp) >= bufsize) {
- mprAssert(0);
- return MPR_ERR_WONT_FIT;
- }
- mprStrcpy(buf, bufsize, cp);
-
- return strlen(buf);
-}
-
-/******************************************************************************/
-
-#ifdef __cplusplus
-}
-#endif
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-#
-# Makefile for the Mbedthis Portable Runtime (MPR) library for Windows
-#
-# Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
-#
-
-COMPILE := *.c
-EXPORT_OBJECTS := yes
-MAKE_IFLAGS := -I..
-
-include make.dep
-
-## Local variables:
-## tab-width: 4
-## End:
-## vim: tw=78 sw=4 ts=4
+++ /dev/null
-/**
- * @file mprWinFile.c
- * @brief File services for Windows
- * @overview
- * @remarks
- */
-
-/******************************************************************************/
-/*
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-
-/********************************** Includes **********************************/
-
-#include "mpr.h"
-
-/************************************ Code ************************************/
-
-int mprGetFileInfo(MprCtx ctx, const char *path, MprFileInfo *info)
-{
- struct stat s;
-
- mprAssert(path);
- mprAssert(info);
-
- if (stat(path, &s) < 0) {
- return -1;
- }
-
- info->size = s.st_size;
- /*
- * MOB -- these are time64_t. Loss of precision
- */
- info->ctime = (uint) s.st_ctime;
- info->mtime = (uint) s.st_mtime;
- info->inode = s.st_ino;
- info->isDir = (s.st_mode & S_IFDIR) != 0;
- info->isReg = (s.st_mode & S_IFREG) != 0;
-
- /*
- * Work hard on windows to determine if the file is a regular file.
- * FUTURE -- OPT. Eliminate this CreateFile.
- */
- if (info->isReg) {
- long fileType, att;
-
- if ((att = GetFileAttributes(path)) == -1) {
- return -1;
- }
- if (att & (FILE_ATTRIBUTE_REPARSE_POINT |
- FILE_ATTRIBUTE_DIRECTORY |
- FILE_ATTRIBUTE_ENCRYPTED |
- FILE_ATTRIBUTE_SYSTEM |
- FILE_ATTRIBUTE_OFFLINE)) {
- /*
- * Catch accesses to devices like CON, AUX, NUL, LPT etc
- * att will be set to ENCRYPTED on Win9X and NT.
- */
- info->isReg = 0;
- }
- if (info->isReg) {
- HANDLE handle;
- handle = CreateFile(path, 0, FILE_SHARE_READ | FILE_SHARE_WRITE,
- 0, OPEN_EXISTING, 0, 0);
- if (handle == INVALID_HANDLE_VALUE) {
- info->isReg = 0;
- } else {
- fileType = GetFileType(handle);
- if (fileType == FILE_TYPE_CHAR || fileType == FILE_TYPE_PIPE) {
- info->isReg = 0;
- }
- CloseHandle(handle);
- }
- }
- }
- if (strcmp(path, "nul") == 0) {
- info->isReg = 0;
- }
- return 0;
-}
-
-/******************************************************************************/
-
-int mprMakeDir(MprCtx ctx, const char *path, int perms)
-{
- return mkdir(path, perms);
-}
-
-/******************************************************************************/
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/**
- * @file mprPlatform.c
- * @brief Cross platform routines
- * @overview This module provides low level cross platform routines.
- * @remarks Most routines in this file are not thread-safe. It is the callers
- * responsibility to perform all thread synchronization.
- */
-
-/*
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-
-/********************************** Includes **********************************/
-/*
- * We need to use the underlying str(cpy) routines to implement our safe
- * alternatives
- */
-#if !DOXYGEN
-#define UNSAFE_FUNCTIONS_OK 1
-#endif
-
-#include "mpr.h"
-
-/**************************** Forward Declarations ****************************/
-
-static const char *getHive(const char *keyPath, HKEY *hive);
-
-/************************************ Code ************************************/
-
-char *mprInetToStr(char *buffer, int bufsize, const struct in_addr in)
-{
-#if HAVE_NTOA_R
- inet_ntoa_r(in, buffer, bufsize);
-#else
- uchar *cp;
- cp = (uchar*) ∈
- mprSprintf(buffer, bufsize, "%d.%d.%d.%d", cp[0], cp[1], cp[2], cp[3]);
-#endif
- return buffer;
-}
-
-/******************************************************************************/
-
-void mprSetShell(MprCtx ctx, void *shell)
-{
-}
-
-/******************************************************************************/
-
-void *mprGetShell(MprCtx ctx)
-{
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Sleep. Period given in milliseconds.
- */
-
-void mprSleep(MprCtx ctx, int milliseconds)
-{
- Sleep(milliseconds);
-}
-
-/******************************************************************************/
-/*
- * Make intervening directories
- */
-
-int mprMakeDirPath(MprCtx ctx, const char *path)
-{
- char dir[MPR_MAX_PATH], buf[MPR_MAX_PATH];
- char *dirSep;
- char *next, *tok;
-
- dir[0] = '\0';
- dirSep = "/\\";
-
- if (path == 0 || *path == '\0') {
- return MPR_ERR_BAD_ARGS;
- }
-
- mprStrcpy(buf, sizeof(buf), path);
- next = mprStrTok(buf, dirSep, &tok);
- if (*buf == '/') {
- dir[0] = '/';
- }
- while (next != NULL) {
- if (strcmp(next, ".") == 0 ) {
- next = mprStrTok(NULL, dirSep, &tok);
- continue;
- }
- strcat(dir, next);
- if (access(dir, R_OK) != 0) {
- if (_mkdir(dir) < 0) {
- return MPR_ERR_CANT_CREATE;
- }
- }
- strcat(dir, "/");
- next = mprStrTok(NULL, dirSep, &tok);
- }
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Get a fully qualified file name for the given path. Return with forward
- * slashes always
- */
-
-char *mprGetFullPathName(char *buf, int buflen, const char *path)
-{
-#if (WIN || NW || OS2) && !BLD_FEATURE_ROMFS
- char *junk, *cp;
- int rc;
-
- --buflen;
- rc = GetFullPathName(path, buflen, buf, &junk);
- for (cp = buf; *cp; cp++) {
- if (*cp == '\\') {
- *cp = '/';
- }
- }
- buf[buflen] = '\0';
-#else
- if (mprStrcpy(buf, buflen, path) < 0) {
- mprAssert(0);
- return 0;
- }
-#endif
- return buf;
-}
-
-/******************************************************************************/
-/*
- * Replacement for gethostbyname that is multi-thread safe
- */
-
-struct hostent *mprGetHostByName(MprCtx ctx, const char *name)
-{
- MprApp *app;
- struct hostent *hp;
- struct hostent *ip;
- int count, i;
-
- hp = (struct hostent*) mprAlloc(ctx, sizeof(struct hostent));
- memset(hp, 0, sizeof(struct hostent));
-
- app = mprGetApp(ctx);
-
- #undef gethostbyname
-
- mprGlobalLock(app);
- ip = gethostbyname(name);
- mprGlobalUnlock(app);
-
- if (ip == 0) {
- return 0;
- }
- hp->h_addrtype = ip->h_addrtype;
- hp->h_length = ip->h_length;
- hp->h_name = mprStrdup(hp, ip->h_name);
- hp->h_addr_list = 0;
- hp->h_aliases = 0;
-
- for (count = 0; ip->h_addr_list[count] != 0; ) {
- count++;
- }
- if (count > 0) {
- count++;
- hp->h_addr_list = mprAlloc(hp, count * sizeof(char*));
- for (i = 0; ip->h_addr_list[i] != 0; i++) {
- memcpy(&hp->h_addr_list[i], &ip->h_addr_list[i], ip->h_length);
- }
- hp->h_addr_list[i] = 0;
- }
-
- for (count = 0; ip->h_aliases[count] != 0; ) {
- count++;
- }
- if (count > 0) {
- count++;
- hp->h_aliases = mprAlloc(hp, count * sizeof(char*));
- for (i = 0; ip->h_aliases[i] != 0; i++) {
- hp->h_aliases[i] = mprStrdup(hp, ip->h_aliases[i]);
- }
- hp->h_aliases[i] = 0;
- }
- return hp;
-}
-
-/******************************************************************************/
-/*
- * Read a registry value. Returns allocated memory in buf.
- */
-
-int mprReadRegistry(MprCtx ctx, char **buf, int max, const char *key,
- const char *name)
-{
- HKEY top, h;
- char *value;
- ulong type, size;
-
- mprAssert(key && *key);
- mprAssert(buf);
-
- /*
- * Get the registry hive
- */
- if ((key = getHive(key, &top)) == 0) {
- return MPR_ERR_CANT_ACCESS;
- }
-
- if (RegOpenKeyEx(top, key, 0, KEY_READ, &h) != ERROR_SUCCESS) {
- return MPR_ERR_CANT_ACCESS;
- }
-
- /*
- * Get the type
- */
- if (RegQueryValueEx(h, name, 0, &type, 0, &size) != ERROR_SUCCESS) {
- RegCloseKey(h);
- return MPR_ERR_CANT_READ;
- }
- if (type != REG_SZ && type != REG_EXPAND_SZ) {
- RegCloseKey(h);
- return MPR_ERR_BAD_TYPE;
- }
-
- value = (char*) mprAlloc(ctx, size);
- if ((int) size > max) {
- RegCloseKey(h);
- return MPR_ERR_WONT_FIT;
- }
- if (RegQueryValueEx(h, name, 0, &type, (uchar*) value, &size) !=
- ERROR_SUCCESS) {
- mprFree(value);
- RegCloseKey(h);
- return MPR_ERR_CANT_READ;
- }
-
- RegCloseKey(h);
- *buf = value;
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Write a string registry value. Returns allocated memory in buf.
- */
-
-int mprWriteRegistry(MprCtx ctx, const char *key, const char *name,
- const char *value)
-{
- HKEY top, h, subHandle;
- ulong disposition;
-
- mprAssert(key && *key);
- mprAssert(name && *name);
- mprAssert(value && *value);
-
- /*
- * Get the registry hive
- */
- if ((key = getHive(key, &top)) == 0) {
- return MPR_ERR_CANT_ACCESS;
- }
-
- if (name) {
- /*
- * Write a registry string value
- */
- if (RegOpenKeyEx(top, key, 0, KEY_ALL_ACCESS, &h) != ERROR_SUCCESS) {
- return MPR_ERR_CANT_ACCESS;
- }
- if (RegSetValueEx(h, name, 0, REG_SZ, value, strlen(value) + 1)
- != ERROR_SUCCESS) {
- RegCloseKey(h);
- return MPR_ERR_CANT_READ;
- }
-
- } else {
- /*
- * Create a new sub key
- */
- if (RegOpenKeyEx(top, key, 0, KEY_CREATE_SUB_KEY, &h) != ERROR_SUCCESS){
- return MPR_ERR_CANT_ACCESS;
- }
- if (RegCreateKeyEx(h, name, 0, NULL, REG_OPTION_NON_VOLATILE,
- KEY_ALL_ACCESS, NULL, &subHandle, &disposition) != ERROR_SUCCESS) {
- return MPR_ERR_CANT_ACCESS;
- }
- RegCloseKey(subHandle);
- }
- RegCloseKey(h);
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Determine the registry hive by the first portion of the path. Return
- * a pointer to the rest of key path after the hive portion.
- */
-
-static const char *getHive(const char *keyPath, HKEY *hive)
-{
- char key[MPR_MAX_STRING], *cp;
- int len;
-
- mprAssert(keyPath && *keyPath);
-
- *hive = 0;
-
- mprStrcpy(key, sizeof(key), keyPath);
- key[sizeof(key) - 1] = '\0';
-
- if (cp = strchr(key, '\\')) {
- *cp++ = '\0';
- }
- if (cp == 0 || *cp == '\0') {
- return 0;
- }
-
- if (!mprStrcmpAnyCase(key, "HKEY_LOCAL_MACHINE")) {
- *hive = HKEY_LOCAL_MACHINE;
- } else if (!mprStrcmpAnyCase(key, "HKEY_CURRENT_USER")) {
- *hive = HKEY_CURRENT_USER;
- } else if (!mprStrcmpAnyCase(key, "HKEY_USERS")) {
- *hive = HKEY_USERS;
- } else if (!mprStrcmpAnyCase(key, "HKEY_CLASSES_ROOT")) {
- *hive = HKEY_CLASSES_ROOT;
- } else {
- return 0;
- }
-
- if (*hive == 0) {
- return 0;
- }
- len = strlen(key) + 1;
- return keyPath + len;
-}
-
-/******************************************************************************/
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/**
- * @file mprTime.c
- * @brief Time handling for Windows
- * @overview
- */
-
-/*
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-
-/********************************* Includes ***********************************/
-
-#include "mpr.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/************************************ Code ************************************/
-/*
- * Returns time in seconds and milliseconds. This is NOT time-of-day.
- */
-
-MprTime *mprGetTime(MprCtx ctx, MprTime *tp)
-{
- FILETIME fileTime;
- int64 now, base;
-
- GetSystemTimeAsFileTime(&fileTime);
-
- now = ((((int64) fileTime.dwHighDateTime) << BITS(uint)) +
- ((int64) fileTime.dwLowDateTime));
-
- /*
- * Convert from 100-nanosec units to milliseconds
- */
- now = (now / 10000);
-
- /*
- * Adjust to be seconds since Jan 1 1970. Do this to be consistent with
- * UNIX but not really required by the API definition.
- */
- base = ((UINT64(365) * 86400 * (1970 - 1601)) * 1000);
- now -= base;
- tp->sec = (uint) (now / 1000);
- tp->msec = (uint) (now % 1000);
-
-#if UNUSED
-{
- static int64 start;
-
- if (start == 0) {
- start = now;
- }
- if (now < start) {
- mprLog(ctx, 0, "TIME WENT BACKWARDS");
- mprLog(ctx, 0, "start %Ld", start);
- mprLog(ctx, 0, "now %Ld", now);
- }
- mprLog(ctx, 0, "getTime %Ld", now);
- start = now;
-}
-#endif
-
- return tp;
-}
-
-/******************************************************************************/
-/*
- * Thread-safe wrapping of localtime
- */
-
-struct tm *mprLocaltime(MprCtx ctx, struct tm *timep, time_t *now)
-{
- struct tm *tbuf;
- mprGlobalLock(ctx);
- tbuf = localtime(now);
- *timep = *tbuf;
- mprGlobalUnlock(ctx);
-
- return timep;
-}
-
-/******************************************************************************/
-/*
- * Thread-safe wrapping of gmtime
- */
-
-struct tm *mprGmtime(MprCtx ctx, time_t *now, struct tm *timep)
-{
- struct tm *tbuf;
- tbuf = gmtime(now);
- *timep = *tbuf;
-
- return timep;
-}
-
-/******************************************************************************/
-/*
- * Thread-safe wrapping of ctime
- */
-
-int mprCtime(MprCtx ctx, char *buf, int bufsize, const time_t *timer)
-{
- char *cp;
- int len;
-
- mprAssert(buf);
-
- mprGlobalLock(ctx);
-
- cp = ctime(timer);
- if ((int) strlen(cp) >= bufsize) {
- mprStrcpy(buf, bufsize, "WONT FIT");
- mprAssert(0);
- mprGlobalUnlock(ctx);
- return MPR_ERR_WONT_FIT;
- }
-
- len = mprStrcpy(buf, bufsize, cp);
- if (buf[len - 1] == '\n') {
- buf[len - 1] = '\0';
- }
-
- mprGlobalUnlock(ctx);
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Thread-safe wrapping of asctime
- */
-
-int mprAsctime(MprCtx ctx, char *buf, int bufsize, const struct tm *timeptr)
-{
- char *cp;
-
- mprAssert(buf);
- mprGlobalLock(ctx);
- cp = asctime(timeptr);
- if ((int) strlen(cp) >= bufsize) {
- mprAssert(0);
- mprGlobalUnlock(ctx);
- return MPR_ERR_WONT_FIT;
- }
- mprStrcpy(buf, bufsize, cp);
- mprGlobalUnlock(ctx);
-
- return strlen(buf);
-}
-
-/******************************************************************************/
-
-#ifdef __cplusplus
-}
-#endif
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-${BLD_OBJ_DIR}/mpr${BLD_OBJ}
-${BLD_OBJ_DIR}/mprAlloc${BLD_OBJ}
-${BLD_OBJ_DIR}/mprArray${BLD_OBJ}
-${BLD_OBJ_DIR}/mprBuf${BLD_OBJ}
-${BLD_OBJ_DIR}/mprFile${BLD_OBJ}
-${BLD_OBJ_DIR}/mprGenFile${BLD_OBJ}
-${BLD_OBJ_DIR}/mprGenTime${BLD_OBJ}
-${BLD_OBJ_DIR}/mprLock${BLD_OBJ}
-${BLD_OBJ_DIR}/mprLog${BLD_OBJ}
-${BLD_OBJ_DIR}/mprPlatform${BLD_OBJ}
-${BLD_OBJ_DIR}/mprPrintf${BLD_OBJ}
-${BLD_OBJ_DIR}/mprString${BLD_OBJ}
-${BLD_OBJ_DIR}/mprSymbol${BLD_OBJ}
-${BLD_OBJ_DIR}/mprTime${BLD_OBJ}
+++ /dev/null
-/**
- * @file mpr.c
- * @brief Mpr initialization
- * @overview
- * @remarks Most routines in this file are not thread-safe. It is the callers
- * responsibility to perform all thread synchronization.
- */
-
-/*
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-
-/********************************** Includes **********************************/
-/*
- * We need to use the underlying str(cpy) routines to implement our safe
- * alternatives
- */
-#if !DOXYGEN
-#define UNSAFE_FUNCTIONS_OK 1
-#endif
-
-#include "mpr.h"
-
-/******************************************************************************/
-/*
- * Initialize the MPR. Create the top level memory context. This routine is
- * the first call an MPR application must do. If using MprServices, the
- * creation of an Mpr object will call this routine.
- */
-
-MprApp *mprInit(MprAllocCback cback)
-{
- return mprInitEx(cback, 0);
-}
-
-/******************************************************************************/
-/*
- * Add a shell parameter then do the regular init
- */
-
-MprApp *mprInitEx(MprAllocCback cback, void *shell)
-{
- MprApp *app;
-
- app = (MprApp*) mprAllocInit(cback);
-
- mprAssert(app);
- if (app == 0) {
- return 0;
- }
-
- app->name = mprStrdup(app, BLD_PRODUCT);
- app->title = mprStrdup(app, BLD_NAME);
- app->version = mprStrdup(app, BLD_VERSION);
-
- mprSetShell(app, shell);
-
- app->table = mprCreateSymbolTable(app, 0);
-
- if (mprStartFileServices(app) < 0) {
- mprAllocTerm(app);
- return 0;
- }
-
-#if BLD_FEATURE_MULTITHREAD
- mprInitThreads(app);
-#endif
-
- /*
- * See if any of the preceeding allocations failed
- */
- if (mprGetAllocErrors(app) > 0) {
- mprAllocTerm(app);
- return 0;
- }
-
- /*
- * Mark all blocks allocated so far as required. They will then be
- * omitted from leak reports.
- */
- mprSetRequiredAlloc(app, 1);
-
- return app;
-}
-
-/******************************************************************************/
-/*
- * Terminate the MPR. If doStats is true, then output a memory allocation
- * report.
- */
-
-void mprTerm(MprApp *app, bool doStats)
-{
-#if BLD_FEATURE_ALLOC_STATS
- if (doStats) {
- mprPrintAllocReport(app, 1, "MPR Memory Allocation Report");
- }
-#endif
-
-#if BLD_FEATURE_MULTITHREAD
- mprTermThreads(app);
-#endif
-
- mprStopFileServices(app);
-
-#if BLD_DEBUG
- mprValidateAllocTree(app);
-#endif
- mprAllocTerm(app);
-}
-
-/******************************************************************************/
-
-bool mprIsExiting(MprCtx ctx)
-{
- MprApp *app;
-
- app = mprGetApp(ctx);
- if (app == 0) {
- return 1;
- }
- return app->flags & MPR_APP_EXITING;
-}
-
-/******************************************************************************/
-
-int mprHasAllocError(MprCtx ctx)
-{
- MprApp *app;
-
- app = mprGetApp(ctx);
- if (app == 0) {
- return 1;
- }
-
- return app->flags & MPR_APP_ALLOC_ERROR;
-}
-
-/******************************************************************************/
-
-void mprSignalExit(MprCtx ctx)
-{
- MprApp *app;
-
- app = mprGetApp(ctx);
- app->flags |= MPR_APP_EXITING;
-}
-
-/******************************************************************************/
-
-void mprSignalAllocError(MprCtx ctx)
-{
- MprApp *app;
-
- app = mprGetApp(ctx);
- app->flags |= MPR_APP_ALLOC_ERROR;
-}
-
-/******************************************************************************/
-
-int mprSetAppName(MprCtx ctx, const char *name, const char *title,
- const char *version)
-{
- MprApp *app;
-
- app = mprGetApp(ctx);
-
- if (name) {
- mprFree(app->name);
- if ((app->name = mprStrdup(ctx, name)) == 0) {
- return MPR_ERR_CANT_ALLOCATE;
- }
- }
-
- if (title) {
- mprFree(app->title);
- if ((app->title = mprStrdup(ctx, title)) == 0) {
- return MPR_ERR_CANT_ALLOCATE;
- }
- }
-
- if (version) {
- mprFree(app->version);
- if ((app->version = mprStrdup(ctx, version)) == 0) {
- return MPR_ERR_CANT_ALLOCATE;
- }
- }
- return 0;
-}
-
-/******************************************************************************/
-
-const char *mprGetAppName(MprCtx ctx)
-{
- MprApp *app;
-
- app = mprGetApp(ctx);
- return app->name;
-}
-
-/******************************************************************************/
-
-const char *mprGetAppTitle(MprCtx ctx)
-{
- MprApp *app;
-
- app = mprGetApp(ctx);
- return app->title;
-}
-
-/******************************************************************************/
-
-const char *mprGetAppVersion(MprCtx ctx)
-{
- MprApp *app;
-
- app = mprGetApp(ctx);
- return app->version;
-}
-
-/******************************************************************************/
-
-int mprSetKeyValue(MprCtx ctx, const char *key, void *ptr)
-{
- MprApp *app;
-
- app = mprGetApp(ctx);
- if (mprInsertSymbol(app->table, key, ptr) == 0) {
- return MPR_ERR_CANT_WRITE;
- }
- return 0;
-}
-
-/******************************************************************************/
-
-int mprRemoveKeyValue(MprCtx ctx, const char *key)
-{
- MprApp *app;
-
- app = mprGetApp(ctx);
- return mprRemoveSymbol(app->table, key);
-}
-
-/******************************************************************************/
-
-void *mprGetKeyValue(MprCtx ctx, const char *key)
-{
- MprApp *app;
-
- app = mprGetApp(ctx);
- return mprLookupSymbol(app->table, key);
-}
-
-/******************************************************************************/
-
-bool mprGetDebugMode(MprCtx ctx)
-{
- return mprGetApp(ctx)->debugMode;
-}
-
-/******************************************************************************/
-
-void mprSetDebugMode(MprCtx ctx, bool on)
-{
- mprGetApp(ctx)->debugMode = on;
-}
-
-/******************************************************************************/
-
-void mprSetLogHandler(MprCtx ctx, MprLogHandler handler)
-{
- mprGetApp(ctx)->logHandler = handler;
-}
-
-/******************************************************************************/
-
-MprLogHandler mprGetLogHandler(MprCtx ctx)
-{
- return mprGetApp(ctx)->logHandler;
-}
-
-#if UNUSED
-/******************************************************************************/
-
-void mprSetMprInstance(MprCtx ctx, void *mprInstance)
-{
- mprGetApp(ctx)->mprInstance = mprInstance;
-}
-
-/******************************************************************************/
-
-void *mprGetMprInstance(MprCtx ctx)
-{
- return mprGetApp(ctx)->mprInstance;
-}
-
-#endif
-/******************************************************************************/
-
-const char *mprCopyright()
-{
- return "Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.";
-}
-
-/******************************************************************************/
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- * @file mpr.h
- * @brief Header for the Mbedthis Portable Runtime (MPR) Base.
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-/******************************* Documentation ********************************/
-/*
- * See mpr.dox for additional documentation.
- */
-
-/******************************************************************************/
-
-#ifndef _h_MPR
-#define _h_MPR 1
-
-/***********************************Includes **********************************/
-
-#include "mprOs.h"
-
-/******************************************************************************/
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/********************************** Constants *********************************/
-
-#if BLD_FEATURE_SQUEEZE
-#if BREW || DOXYGEN
-/*
- * Maximum length of a file path name. Reduced from the system maximum to
- * save memory space.
- */
-#define MPR_MAX_FNAME 64 /**< Reasonable filename size */
-#define MPR_MAX_PATH 64 /**< Reasonable path name size */
-#define MPR_DEFAULT_STACK (16 * 1024) /**< Default stack size */
-#else
-#define MPR_MAX_FNAME 128 /**< Reasonable filename size */
-#define MPR_MAX_PATH 256 /**< Reasonable path name size */
-#define MPR_DEFAULT_STACK (32 * 1024) /**< Default stack size */
-#endif
-/*
- * Reasonable length of a file name used by the product. Use where you know
- * the expected file name and it is certain to be less than this limit.
- */
-#define MPR_DEFAULT_ALLOC 64 /**< Default small alloc size */
-#define MPR_DEFAULT_HASH_SIZE 23 /**< Default size of hash table */
-#define MPR_MAX_ARGC 32 /**< Reasonable max of args */
-#define MPR_MAX_STRING 512 /**< Maximum (stack) string size */
-#define MPR_MAX_LOG_STRING 512 /**< Maximum log message */
-#define MPR_MAX_URL 256 /**< Reasonable size of a URL */
-#define MPR_BUFSIZE 512 /**< Reasonable size for buffers */
-#define MPR_SLAB_STR_MAX 32 /**< Size of string slab blocks */
-#define MPR_SLAB_STR_INC 32 /**< Pre-allocate increment */
-#define MPR_SLAB_DEFAULT_INC 8 /**< Default pre-allocate inc */
-#define MPR_ARRAY_INCR 8 /**< Default array growth inc */
-#define MPR_BUF_INCR 1024 /**< Default array growth inc */
-#define MPR_MAX_BUF (1024*4096) /**< Default array growth inc */
-
-#define MPR_BLK_HDR_SIZE ((sizeof(struct MprBlk) + 3) & ~3)
-
-#else
-#define MPR_MAX_FNAME 256
-#define MPR_MAX_PATH 1024
-#define MPR_DEFAULT_ALLOC 256
-#define MPR_DEFAULT_HASH_SIZE 43
-#define MPR_DEFAULT_STACK (64 * 1024)
-#define MPR_MAX_ARGC 128
-#define MPR_MAX_STRING 4096
-#define MPR_MAX_LOG_STRING 8192
-#define MPR_MAX_URL 1024
-#define MPR_BUFSIZE 1024
-#define MPR_SLAB_STR_MAX 32
-#define MPR_SLAB_STR_INC 64
-#define MPR_SLAB_DEFAULT_INC 16
-#define MPR_ARRAY_INCR 16
-#define MPR_BUF_INCR 1024
-#define MPR_MAX_BUF (1024*4096)
-
-#define MPR_BLK_HDR_SIZE ((sizeof(struct MprBlk) + 15) & ~15)
-#endif
-
-/**
- * Maximum size of a host name string
- */
-#define MPR_MAX_IP_NAME 64
-
-/**
- * Maximum size of an IP address
- */
-#define MPR_MAX_IP_ADDR 16
-
-/**
- * Maximum size of an IP address including port number
- */
-#define MPR_MAX_IP_ADDR_PORT 32
-
-#define MPR_MAX_SLAB 16 /* Slabs from 32-512 bytes */
-
-#define MPR_MAX_TIME_SYNC (10 * 1000) /* Time sync adjustments */
-
-/**
- * @overview Memory context type
- * @description Blocks of memory are allocated using a memory context
- * as the parent with the \ref MprApp structure being the root of the
- * tree. Any allocated memory block may serve as the memory context for
- * subsequent memory allocations. Freeing a block via \ref mprFree will
- * release the allocated block and all child blocks.
- * @stability Prototype.
- * @library libmpr.
- * @see mprInit, mprAlloc, mprFree
- */
-typedef const void *MprCtx;
-
-/*
- * Allocated memory destructor type
- */
-typedef int (*MprDestructor)(void *);
-
-/******************************** Error Codes *********************************/
-
-/*
- * Standard MPR return and error codes
- */
-
-#define MPR_ERR_OK (0)
-/**< Success */
-
-#define MPR_ERR_BASE (-200)
-/**< Base error code */
-
-#define MPR_ERR_GENERAL (MPR_ERR_BASE - 1)
-/**< General error */
-#define MPR_ERR_ABORTED (MPR_ERR_BASE - 2)
-/**< Action aborted */
-#define MPR_ERR_ALREADY_EXISTS (MPR_ERR_BASE - 3)
-/**< Item already exists */
-#define MPR_ERR_BAD_ARGS (MPR_ERR_BASE - 4)
-/**< Bad arguments or paramaeters */
-#define MPR_ERR_BAD_FORMAT (MPR_ERR_BASE - 5)
-/**< Bad input format */
-#define MPR_ERR_BAD_HANDLE (MPR_ERR_BASE - 6)
-#define MPR_ERR_BAD_STATE (MPR_ERR_BASE - 7)
-/**< Module is in a bad state */
-#define MPR_ERR_BAD_SYNTAX (MPR_ERR_BASE - 8)
-/**< Input has bad syntax */
-#define MPR_ERR_BAD_TYPE (MPR_ERR_BASE - 9)
-#define MPR_ERR_BAD_VALUE (MPR_ERR_BASE - 10)
-#define MPR_ERR_BUSY (MPR_ERR_BASE - 11)
-#define MPR_ERR_CANT_ACCESS (MPR_ERR_BASE - 12)
-/**< Can't access the file or resource */
-#define MPR_ERR_CANT_COMPLETE (MPR_ERR_BASE - 13)
-#define MPR_ERR_CANT_CREATE (MPR_ERR_BASE - 14)
-/**< Can't create the file or resource */
-#define MPR_ERR_CANT_INITIALIZE (MPR_ERR_BASE - 15)
-#define MPR_ERR_CANT_OPEN (MPR_ERR_BASE - 16)
-/**< Can't open the file or resource */
-#define MPR_ERR_CANT_READ (MPR_ERR_BASE - 17)
-/**< Can't read from the file or resource */
-#define MPR_ERR_CANT_WRITE (MPR_ERR_BASE - 18)
-/**< Can't write to the file or resource */
-#define MPR_ERR_DELETED (MPR_ERR_BASE - 19)
-#define MPR_ERR_NETWORK (MPR_ERR_BASE - 20)
-#define MPR_ERR_NOT_FOUND (MPR_ERR_BASE - 21)
-#define MPR_ERR_NOT_INITIALIZED (MPR_ERR_BASE - 22)
-/**< Module or resource is not initialized */
-#define MPR_ERR_NOT_READY (MPR_ERR_BASE - 23)
-#define MPR_ERR_READ_ONLY (MPR_ERR_BASE - 24)
-/**< The operation timed out */
-#define MPR_ERR_TIMEOUT (MPR_ERR_BASE - 25)
-#define MPR_ERR_TOO_MANY (MPR_ERR_BASE - 26)
-#define MPR_ERR_WONT_FIT (MPR_ERR_BASE - 27)
-#define MPR_ERR_WOULD_BLOCK (MPR_ERR_BASE - 28)
-#define MPR_ERR_CANT_ALLOCATE (MPR_ERR_BASE - 29)
-// MOB -- rename NO_MEMORY
-#define MPR_ERR_MEMORY (MPR_ERR_BASE - 30)
-#define MPR_ERR_CANT_DELETE (MPR_ERR_BASE - 31)
-#define MPR_ERR_MAX (MPR_ERR_BASE - 32)
-
-/*
- * Standard logging trace levels are 0 to 9 with 0 being the most verbose.
- * the These are ored with the error source and type flags. The MPR_LOG_MASK
- * is used to extract the trace level from a flags word. We expect most apps
- * to run with level 2 trace enabled.
- */
-#define MPR_ERROR 1 /**< Hard error trace level */
-#define MPR_WARN 2 /**< Soft warning trace level */
-#define MPR_CONFIG 2 /**< Configuration settings trace level. */
-#define MPR_INFO 3 /**< Informational trace only */
-#define MPR_DEBUG 4 /**< Debug information trace level */
-#define MPR_VERBOSE 9 /**< Highest level of trace */
-#define MPR_LEVEL_MASK 0xf /**< Level mask */
-
-/*
- * Error source flags
- */
-#define MPR_ERROR_SRC 0x10 /**< Originated from mprError */
-#define MPR_LOG_SRC 0x20 /**< Originated from mprLog */
-#define MPR_ASSERT_SRC 0x40 /**< Originated from mprAssert */
-#define MPR_FATAL_SRC 0x80 /**< Fatal error. Log and exit */
-
-/*
- * Log message type flags. Specify what kind of log / error message it is.
- * Listener handlers examine this flag to determine if they should process
- * the message.Assert messages are trapped when in DEV mode. Otherwise ignored.
- */
-#define MPR_LOG_MSG 0x100 /**< Log trace message - not an error */
-#define MPR_ERROR_MSG 0x200 /**< General error */
-#define MPR_ASSERT_MSG 0x400 /**< Assert flags -- trap in debugger */
-#define MPR_USER_MSG 0x800 /**< User message */
-
-/*
- * Log output modifiers
- */
-#define MPR_RAW 0x1000 /**< Raw trace output */
-
-/*
- * Error line number information.
- */
-#define MPR_LINE(s) #s
-#define MPR_LINE2(s) MPR_LINE(s)
-#define MPR_LINE3 MPR_LINE2(__LINE__)
-#define MPR_LOC __FILE__ ":" MPR_LINE3
-
-/*
- * Macros to pass file and line number information
- * Use MPR_LOC_ARGS in normal user code.
- * Use MPR_LOC_DEC in declarations.
- * Use MPR_LOC_PASS in layered APIs to pass original line info down.
- */
-#if BLD_FEATURE_ALLOC_LEAK_TRACK
-#define MPR_LOC_ARGS(ctx) ctx, MPR_LOC
-#define MPR_LOC_DEC(ctx, loc) MprCtx ctx, const char *loc
-#define MPR_LOC_PASS(ctx, loc) ctx, loc
-#else
-#define MPR_LOC_ARGS(ctx) ctx
-#define MPR_LOC_DEC(ctx, loc) MprCtx ctx
-#define MPR_LOC_PASS(ctx, loc) ctx
-#endif
-
-/******************************* Debug and Assert *****************************/
-
-extern void mprBreakpoint(const char *loc, const char *msg);
-
-#if BLD_FEATURE_ASSERT
- #define mprAssert(C) if (C) ; else mprStaticAssert(MPR_LOC, #C)
-#else
- #define mprAssert(C) if (1) ; else
-#endif
-
-/********************************* Safe Strings *******************************/
-/*
- * Unsafe functions that should not be used. Define UNSAFE_STRINGS_OK before
- * including mpr.h if you really want to use these functions. A better approach
- * is to undefine them just prior to using them in your C/C++ source file.
- */
-#if BLD_FEATURE_SAFE_STRINGS
-
-#if BLD_FEATURE_PHP4_MODULE || BLD_FEATURE_PHP5_MODULE
- #ifndef UNSAFE_FUNCTIONS_OK
- #define UNSAFE_FUNCTIONS_OK 1
- #endif
-#endif
-
-#ifndef UNSAFE_FUNCTIONS_OK
- #define sprintf UseMprSprintfInstead
- #define fprintf UseMprFprintfInstead
- #define vsprintf UseMprVsprintfInstead
- #define strtok UseMprStrTokInstead
- #define gethostbyname UseMprGetHostByNameInstead
- #define ctime UseMprCtimeInstead
- #define asctime UseMprAsctimeInstead
- #define localtime UseMprLocaltimeInstead
- #define gmtime UseMprGmtimeInstead
- #define malloc UseMprMallocInstead
- #define free UseMprFreeInstead
- #define realloc UseMprReallocInstead
- #define strncpy UseMprStrcpyInstead
- #define inet_ntoa UseMprInetToStrInstead
-
-#if !BREW
- #define printf UseMprPrintfInstead
-#endif
-
- #if FUTURE
- #define strlen UseMprStrlenInstead
- #define strcpy UseMprStrcpyInstead
- #endif
-
-#endif /* UNSAFE_FUNCTIONS_OK */
-#endif /* BLD_FEATURE_SAFE_STRINGS */
-
-/******************************************************************************/
-
-struct MprBuf;
-typedef int (*MprBufProc)(struct MprBuf* bp, void *arg);
-
-/**
- * @overview Dynamic buffer structure
- * @description MprBuf is a flexible, dynamic growable buffer structure. It
- * utilizes a ring buffer mechanism and is suitable for high performance
- * buffering in a variety of situations.
- * @stability Prototype.
- * @library libmpr.
- * @see mprCreateBuf, mprFree, MprArray
- */
-typedef struct MprBuf {
- uchar *buf; /* Actual buffer for data */
- uchar *endbuf; /* Pointer one past the end of buffer */
- uchar *start; /* Pointer to next data char */
- uchar *end; /* Pointer one past the last data chr */
- int buflen; /* Current size of buffer */
- int maxsize; /* Max size the buffer can ever grow */
- int growBy; /* Next growth increment to use */
- MprBufProc refillProc; /* Auto-refill procedure */
- void *refillArg; /* Refill arg */
-} MprBuf;
-
-/**
- * @overview File structure
- * @description MprFile is the cross platform File I/O abstraction control
- * structure.
- * @stability Prototype.
- * @library libmpr.
- * @see mprOpen, mprClose, mprRead, mprWrite
- */
-typedef struct MprFile
-{
- MprBuf *buf; /* Buffer for I/O */
-#if BREW
- IFile *fd; /* File handle */
-#else
- int fd;
-#endif
-} MprFile;
-
-/**
- * File information structure
- * @overview File information structure
- * @description MprFileInfo is the cross platform File information structure.
- * @stability Prototype.
- * @see mprGetFileInfo, mprOpen, mprClose, mprRead, mprWrite
- */
-typedef struct MprFileInfo
-{
- uint size; /* File length */
- uint ctime; /* Create time */
- uint mtime; /* Modified time */
- uint inode; /* Inode number */
- int isDir; /* Set if directory */
- int isReg; /* Set if a regular file */
-} MprFileInfo;
-
-/**
- * @overview Mpr time structure.
- * @description MprTime is the cross platform time abstraction structure.
- * @stability Prototype.
- * @library libmpr.
- * @see mprGetTime
- */
-typedef struct MprTime
-{
- uint sec; /* Seconds */
- uint msec; /* Milliseconds */
-} MprTime;
-
-
-/**
- * @overview Generic array type
- * @description The MprArray is a dynamic growable array suitable for storing
- * pointers to arbitrary objects.
- * @stability Prototype.
- * @library libmpr.
- * @see mprCreateItemArray, mprFree, MprBuf
- */
-typedef struct MprArray
-{
- int capacity; /* Current capacity of the array */
- int length; /* Count of used items */
- int incr; /* Growth increment */
- int maxSize; /* Maximum capacity */
- void **items;
-} MprArray;
-
-
-#if BLD_FEATURE_MULTITHREAD
-/**
- * @overview Multithreading lock control structure
- * @description MprLock is used for multithread locking in multithreaded
- * applications.
- * @library libmpr.
- * @see mprCreateLock, mprDestroyLock, mprLock, mprUnlock
- */
-typedef struct
-{
- #if WIN
- CRITICAL_SECTION cs; /* O/S critical section */
- #endif
- #if LINUX || MACOSX || SOLARIS
- pthread_mutex_t cs; /* O/S critical section */
- #endif
- #if VXWORKS
- SEM_ID cs; /* Semaphore */
- #endif
-} MprLock;
-#endif
-
-/*
- * Error and Logging callback
- */
-typedef void (*MprLogHandler)(MPR_LOC_DEC(ctx, loc), int flags,
- int level, const char *msg);
-
-/*
- * Symbol table
- * MOB -- rename hash
- */
-typedef struct MprSymbol
-{
- struct MprSymbol *next; /* Next symbol in hash chain */
- char *key; /* Symbol key */
- void *data; /* Pointer to symbol data */
- int bucket; /* Hash bucket index */
-} MprSymbol;
-
-typedef struct MprSymbolTable
-{
- MprSymbol **buckets;
- int hashSize; /* Size of the buckets array */
- int count; /* Number of symbols in the table */
-} MprSymbolTable;
-
-
-/*
- * Memory allocation error callback
- */
-struct MprApp;
-typedef int (*MprAllocCback)(struct MprApp *app, uint size, uint total,
- bool granted);
-
-
-/*
- * Slab block pointer links
- */
-typedef struct MprSlabBlock {
- struct MprSlabBlock *next;
-} MprSlabBlock;
-
-
-#if BLD_FEATURE_ALLOC_STATS
-/*
- * Memory Slab Statistics
- */
-typedef struct MprSlabStats {
- uint allocCount; /* Number of allocated blocks */
- uint freeCount; /* Number of blocks on the slab freelist */
- uint peakAllocCount; /* Peak allocated */
- uint totalAllocCount; /* Total count of allocation calls */
- uint peakFreeCount; /* Peak on the free list */
- MprSlabBlock *next;
-} MprSlabStats;
-#endif
-
-
-/*
- * Slab control structure
- */
-typedef struct MprSlab {
- MprSlabBlock *next;
- uint preAllocateIncr; /* Pre-allocation increment */
-#if BLD_FEATURE_ALLOC_STATS
- MprSlabStats stats;
-#endif
-} MprSlab;
-
-/*
- * Allocation stats (kept even in production code so we can detect memory
- * allocation failures)
- */
-typedef struct MprAllocStats
-{
- uint bytesAllocated; /* Bytes currently allocated */
- uint peakAllocated; /* Peak bytes allocated */
- uint allocCount; /* Number of allocated blocks */
- uint redLine; /* Warn above this level */
- uint maxMemory; /* Max memory to allocate */
- uint errors; /* Allocation errors */
-} MprAllocStats;
-
-/*
- * Memory allocation control
- */
-
-typedef struct MprAlloc {
- MprSlab *slabs; /* Array[MPR_MAX_SLAB] of MprSlab */
- MprAllocCback cback; /* Memory allocation callback */
- MprAllocStats stats; /* Keep stats even in release */
- int inAllocException; /* Recursive protect */
-} MprAlloc;
-
-
-/*
- * MprApp State Flags
- */
-#define MPR_APP_EXITING 0x1 /* App is exiting */
-#define MPR_APP_ALLOC_ERROR 0x2 /* App has allocation error */
-
-/* MOB -- temporary */
-#define MPR_APP_NEED_GC 0x4 /* App needs GC */
-
-/**
- * @overview Primary MPR application control structure
- * @description The MprApp structure stores critical application state
- * information and is the root memory allocation context block. It is
- * used as the MprCtx context for other memory allocations and is thus
- * the ultimate parent of all allocated memory.
- * \n\n
- * The MprApp structure is allocated by the mprInit API.
- */
-typedef struct MprApp
-{
- uint magic; /* Corruption protection */
- MprFile *console; /* Stdout file */
- bool debugMode; /* Run in debug mode (no timers) */
- MprFile *error; /* Stderr file */
- int logLevel; /* Log trace level */
- MprFile *logFile; /* Log file */
- MprLogHandler logHandler; /* Current log handler callback */
- MprSymbolTable *table;
- char *name; /* Product name */
- char *title; /* Product title */
- char *version; /* Product version */
-
-#if BREW
- uint classId; /* Brew class ID */
- IShell *shell; /* Brew shell object */
- IDisplay *display; /* Brew display object */
- IFileMgr *fileMgr; /* File manager */
- ITAPI *tapi; /* TAPI object */
- int displayHeight; /* Display height */
- int displayWidth; /* Display width */
- char *args; /* Command line args */
-#endif
-
- void *stackStart; /* Start of app stack */
- uint maxStack; /* Max stack size recorded */
-
- MprAlloc alloc; /* Memory allocation data */
- int flags; /* App state flags */
-
-#if BLD_FEATURE_MULTITHREAD
- MprLock *globalLock;
- MprLock *allocLock;
-#endif
-} MprApp;
-
-
-/*
- * String type. Minimum size is 8 words (32 bytes).
- */
-#define MPR_MAX_INLINE_STR 24
-
-
-/*
- * The block header structure for all allocated memory blocks (32 bytes)
- * WARNING: Don't increase the size of this structure. It just fits into
- * 32 bytes currently. Alignment requirements will double this size if you
- * add one byte!
- */
-typedef struct MprBlk
-{
- MprApp *app; /* app is the top level alloc context */
- struct MprBlk *parent; /* Parent block */
- struct MprBlk *children; /* First child block */
- struct MprBlk *next; /* Next sibling */
- struct MprBlk *prev; /* Previous sibling */
- MprDestructor destructor; /* Destructor function (optional) */
- uint size; /* Size of block sans HDR_SIZE */
- uint flags; /* Allocation flags and magic number */
-#if BLD_FEATURE_ALLOC_LEAK_TRACK
- const char *location; /* Allocating code (file + line) */
-#endif
-} MprBlk;
-
-/******************************************************************************/
-/****************************** Internal Prototypes ***************************/
-/******************************************************************************/
-
-extern void mprSignalAllocError(MprCtx ctx);
-
-/******************************************************************************/
-/********************************** Prototypes ********************************/
-/******************************************************************************/
-
-extern MprApp *mprInit(MprAllocCback cback);
-extern MprApp *mprInitEx(MprAllocCback cback, void *shell);
-extern void mprTerm(MprApp *app, bool doStats);
-extern void mprSignalExit(MprCtx ctx);
-extern bool mprIsExiting(MprCtx ctx);
-extern bool mprHasAllocError(MprCtx ctx);
-
-#if BLD_DEBUG && UNUSED
-extern MprApp *mprGetApp(MprCtx ctx);
-#else
-#define mprGetApp(ctx) \
- (((MprBlk*) ((char*) ctx - MPR_BLK_HDR_SIZE))->app)
-#endif
-
-/******************************************************************************/
-
-extern int mprSetKeyValue(MprCtx ctx, const char *key, void *ptr);
-/* MOB -- should this be delete or remove or unset */
-extern int mprRemoveKeyValue(MprCtx ctx, const char *key);
-extern void *mprGetKeyValue(MprCtx ctx, const char *key);
-/* MOB -- should be setAppName, getAppName */
-extern int mprSetAppName(MprCtx ctx, const char *name, const char *title,
- const char *version);
-extern const char *mprGetAppName(MprCtx ctx);
-extern const char *mprGetAppTitle(MprCtx ctx);
-extern const char *mprGetAppVersion(MprCtx ctx);
-
-/*
- * File services
- */
-extern void mprStopFileServices(MprCtx ctx);
-extern int mprStartFileServices(MprCtx ctx);
-
-/*
- * Item Array
- */
-#define mprCreateItemArray(ctx, initialSize, maxSize) \
- mprCreateItemArrayInternal(MPR_LOC_ARGS(ctx), initialSize, \
- maxSize)
-
-extern MprArray *mprCreateItemArrayInternal(MPR_LOC_DEC(ctx, loc),
- int initialSize, int maxSize);
-/* MOB -- should be insert not add/delete or insert / remove */
-extern int mprAddItem(MprArray *array, void *item);
-extern void mprClearItems(MprArray *array);
-extern void mprClearAndFreeItems(MprArray *array);
-extern int mprFindItem(MprArray *array, void *item);
-extern void *mprGetFirstItem(MprArray *array, int *lastIndex);
-extern void *mprGetItem(MprArray *array, int index);
-extern int mprGetItemCapacity(MprArray *array);
-extern int mprGetItemCount(MprArray *array);
-extern void *mprGetNextItem(MprArray *array, int *lastIndex);
-extern void *mprGetPrevItem(MprArray *array, int *lastIndex);
-extern int mprRemoveItem(MprArray *array, void *item);
-extern int mprRemoveItemByIndex(MprArray *array, int index);
-extern int mprRemoveRangeOfItems(MprArray *array, int start, int end);
-
-
-/*
- * Printf replacements
- */
-extern int mprSprintf(char *buf, int maxSize, const char *fmt, ...)
- PRINTF_ATTRIBUTE(3,4);
-extern int mprVsprintf(char *buf, int maxSize, const char *fmt,
- va_list arg) PRINTF_ATTRIBUTE(3,0);
-extern char *mprItoa(char *buf, int size, int value);
-extern int mprAtoi(const char *str, int radix);
-
-extern int mprPrintf(MprCtx ctx, const char *fmt, ...)
- PRINTF_ATTRIBUTE(2,3);
-/* MOB -- NEED DOC */
-extern int mprErrorPrintf(MprCtx ctx, const char *fmt, ...)
- PRINTF_ATTRIBUTE(2,3);
-extern int mprStaticPrintf(MprCtx ctx, const char *fmt, ...)
- PRINTF_ATTRIBUTE(2,3);
-extern int mprPrintfError(MprCtx ctx, const char *fmt, ...)
- PRINTF_ATTRIBUTE(2,3);
-extern int mprFprintf(MprFile *file, const char *fmt, ...)
- PRINTF_ATTRIBUTE(2,3);
-
-/*
- * Safe string routines
- */
-extern char *mprGetWordTok(char *buf, int bufsize, const char *str,
- const char *delim, const char **tok);
-extern int mprMemcpy(char *dest, int destMax, const char *src,
- int nbytes);
-extern int mprStrcat(char *dest, int max, const char *delim,
- const char *src, ...);
-extern int mprStrcpy(char *dest, int destMax, const char *src);
-
-extern int mprStrcmpAnyCase(const char *str1, const char *str2);
-extern int mprStrcmpAnyCaseCount(const char *str1, const char *str2,
- int len);
-extern int mprStrlen(const char *src, int max);
-
-extern char *mprStrLower(char *str);
-extern char *mprStrUpper(char *str);
-extern char *mprStrTrim(char *str, const char *set);
-extern char *mprStrTok(char *str, const char *delim, char **last);
-
-/*
- * Symbol table
- */
-extern MprSymbolTable *mprCreateSymbolTable(MprCtx ctx, int hashSize);
-extern MprSymbol *mprGetFirstSymbol(MprSymbolTable *table);
-extern MprSymbol *mprGetNextSymbol(MprSymbolTable *table, MprSymbol *last);
-extern int mprGetSymbolCount(MprSymbolTable *table);
-extern MprSymbol *mprInsertSymbol(MprSymbolTable *table, const char *key,
- void *ptr);
-extern void *mprLookupSymbol(MprSymbolTable *table, const char *key);
-extern int mprRemoveSymbol(MprSymbolTable *table, const char *key);
-
-/*
- * File I/O support
- */
-extern void mprClose(MprFile *file);
-extern int mprDelete(MprCtx ctx, const char *path);
-extern int mprDeleteDir(MprCtx ctx, const char *path);
-extern int mprGetFileInfo(MprCtx ctx, const char *path, MprFileInfo *info);
-extern char *mprGets(MprFile *file, char *buf, uint size);
-extern int mprMakeDir(MprCtx ctx, const char *path, int perms);
-extern MprFile *mprOpen(MprCtx ctx, const char *path, int omode, int perms);
-extern int mprPuts(MprFile *file, const char *buf, uint size);
-extern int mprRead(MprFile *file, void *buf, uint size);
-extern int mprSeek(MprFile *file, int seekType, long distance);
-extern int mprWrite(MprFile *file, const void *buf, uint count);
-
-extern int mprMakeTempFileName(MprCtx ctx, char *buf, int bufsize,
- const char *tmpDir);
-
-
-/*
- * Error handling and logging
- */
-extern void mprSetLogHandler(MprCtx ctx, MprLogHandler handler);
-extern MprLogHandler mprGetLogHandler(MprCtx ctx);
-
-extern void mprAssertError(MPR_LOC_DEC(ctx, loc), const char *msg);
-extern void mprError(MPR_LOC_DEC(ctx, loc),
- const char *fmt, ...) PRINTF_ATTRIBUTE(3,4);
-extern void mprFatalError(MPR_LOC_DEC(ctx, loc),
- const char *fmt, ...) PRINTF_ATTRIBUTE(3,4);
-extern void mprLog(MprCtx ctx, int level,
- const char *fmt, ...) PRINTF_ATTRIBUTE(3,4);
-extern void mprRawLog(MprCtx ctx, const char *fmt, ...);
-extern void mprStaticAssert(const char *loc, const char *msg);
-extern void mprStaticError(MPR_LOC_DEC(ctx, loc),
- const char *fmt, ...) PRINTF_ATTRIBUTE(3,4);
-extern void mprUserError(MPR_LOC_DEC(ctx, loc),
- const char *fmt, ...) PRINTF_ATTRIBUTE(3,4);
-
-/*
- * Dynamic Buffering routines
- */
-extern MprBuf *mprCreateBuf(MprCtx ctx, int initialSize, int maxSize);
-extern char *mprStealBuf(MprCtx ctx, MprBuf *bp);
-extern void mprAddNullToBuf(MprBuf *bp);
-extern void mprAdjustBufStart(MprBuf *bp, int size);
-extern void mprAdjustBufEnd(MprBuf *bp, int size);
-extern void mprCopyBufDown(MprBuf *bp);
-extern void mprFlushBuf(MprBuf *bp);
-extern int mprGetCharFromBuf(MprBuf *bp);
-extern int mprGetBlockFromBuf(MprBuf *bp, uchar *buf, int len);
-extern int mprGetBufLength(MprBuf *bp);
-extern int mprGetBufLinearSpace(MprBuf *bp);
-extern int mprGetBufLinearData(MprBuf *bp);
-extern char *mprGetBufOrigin(MprBuf *bp);
-extern int mprGetBufSize(MprBuf *bp);
-extern int mprGetBufSpace(MprBuf *bp);
-extern char *mprGetBufStart(MprBuf *bp);
-extern char *mprGetBufEnd(MprBuf *bp);
-extern int mprInsertCharToBuf(MprBuf *bp, int c);
-extern int mprLookAtNextCharInBuf(MprBuf *bp);
-extern int mprLookAtLastCharInBuf(MprBuf *bp);
-extern int mprPutCharToBuf(MprBuf *bp, int c);
-extern int mprPutBlockToBuf(MprBuf *bp, const char *str, int size);
-extern int mprPutIntToBuf(MprBuf *bp, int i);
-extern int mprPutStringToBuf(MprBuf *bp, const char *str);
-extern int mprPutFmtStringToBuf(MprBuf *bp, const char *fmt, ...);
-extern int mprRefillBuf(MprBuf *bp);
-extern void mprResetBufIfEmpty(MprBuf *bp);
-extern void mprSetBufSize(MprBuf *bp, int initialSize, int maxSize);
-extern MprBufProc mprGetBufRefillProc(MprBuf *bp);
-extern void mprSetBufRefillProc(MprBuf *bp, MprBufProc fn, void *arg);
-
-/*
- * General other xPlatform routines
- */
-extern const char *mprGetBaseName(const char *name);
-extern bool mprGetDebugMode(MprCtx ctx);
-extern char *mprGetDirName(char *buf, int bufsize, const char *path);
-extern char *mprGetFullPathName(char *buf, int buflen, const char *path);
-extern int mprGetLogLevel(MprCtx ctx);
-extern int mprGetOsError();
-
-
-extern int mprMakeArgv(MprCtx ctx, const char *prog, const char *cmd,
- char ***argv, int *argc);
-extern int mprMakeDirPath(MprCtx ctx, const char *path);
-extern void mprSetDebugMode(MprCtx ctx, bool on);
-extern void mprSetLogLevel(MprCtx ctx, int level);
-extern void mprSleep(MprCtx ctx, int msec);
-extern void mprSetShell(MprCtx ctx, void *shell);
-extern void *mprGetShell(MprCtx ctx);
-extern void mprSetClassId(MprCtx ctx, uint classId);
-extern uint mprGetClassId(MprCtx ctx);
-
-#if BREW
-extern void mprSetDisplay(MprCtx ctx, void *display);
-extern void *mprGetDisplay(MprCtx ctx);
-extern void mprSetFileMgr(MprCtx ctx, void *fileMgr);
-extern void *mprGetFileMgr(MprCtx ctx);
-#else
-extern char *mprInetToStr(char *buf, int size, const struct in_addr in);
-#endif
-
-/*
- * Memory allocation
- */
-extern MprApp *mprAllocInit(MprAllocCback cback);
-extern void mprAllocTerm(MprApp *app);
-extern void mprAllocAbort();
-
-extern void *mprAllocBlock(MPR_LOC_DEC(ctx, loc), uint size);
-extern void *mprAllocZeroedBlock(MPR_LOC_DEC(ctx, loc), uint size);
-extern void *mprReallocBlock(MPR_LOC_DEC(ctx, loc), void *ptr, uint size);
-extern int mprFree(void *ptr);
-extern int mprStealAllocBlock(MPR_LOC_DEC(ctx, loc), const void *ptr);
-extern void *mprMemdupInternal(MPR_LOC_DEC(ctx, loc), const void *ptr,
- uint size);
-extern char *mprStrndupInternal(MPR_LOC_DEC(ctx, loc), const char *str,
- uint size);
-extern char *mprStrdupInternal(MPR_LOC_DEC(ctx, loc), const char *str);
-
-extern void *mprSlabAllocBlock(MPR_LOC_DEC(ctx, loc), uint size, uint inc);
-extern void *mprSlabAllocZeroedBlock(MPR_LOC_DEC(ctx, loc), uint size,
- uint inc);
-
-extern uint mprGetAllocBlockSize(MprCtx ctx);
-extern uint mprGetAllocBlockCount(MprCtx ctx);
-extern uint mprGetAllocBlockMemory(MprCtx ctx);
-extern void *mprGetAllocParent(MprCtx ctx);
-extern uint mprGetAllocatedMemory(MprCtx ctx);
-extern uint mprGetPeakAllocatedMemory(MprCtx ctx);
-extern uint mprGetAllocatedSlabMemory(MprCtx ctx);
-extern int mprIsAllocBlockValid(MprCtx ctx);
-extern int mprStackCheck(MprCtx ctx);
-extern int mprStackSize(MprCtx ctx);
-extern int mprGetAllocErrors(MprCtx ctx);
-extern void mprClearAllocErrors(MprCtx ctx);
-
-extern MprDestructor mprSetDestructor(MprCtx ctx, MprDestructor destructor);
-extern MprAllocCback mprSetAllocCallback(MprApp *app, MprAllocCback cback);
-extern void mprSetAllocLimits(MprApp *app, uint redLine, uint maxMemory);
-
-#if BLD_FEATURE_ALLOC_STATS
-extern MprSlabStats *mprGetSlabAllocStats(MprApp *app, int slabIndex);
-extern MprAllocStats *mprGetAllocStats(MprApp *app);
-extern void mprPrintAllocReport(MprApp *app, bool doBlocks,
- const char *msg);
-#endif
-
-#if BLD_DEBUG
-extern int mprPrintAllocBlocks(MprCtx ctx, int indent);
-extern const char *mprGetAllocLocation(MprCtx ptr);
-#endif
-
-extern int mprValidateBlock(MprCtx ctx);
-extern int mprValidateAllocTree(MprCtx ptr);
-extern void mprSetRequiredAlloc(MprCtx ptr, bool recurse);
-
-/*
- * Sprintf style allocators
- */
-extern int mprAllocSprintf(MPR_LOC_DEC(ctx, loc), char **buf, int maxSize,
- const char *fmt, ...) PRINTF_ATTRIBUTE(5,6);
-extern int mprAllocVsprintf(MPR_LOC_DEC(ctx, loc), char **buf, int maxSize,
- const char *fmt, va_list arg) PRINTF_ATTRIBUTE(5,0);
-extern int mprAllocMemcpy(MPR_LOC_DEC(ctx, loc), char **dest, int destMax,
- const void *src, int nbytes);
-extern int mprAllocStrcat(MPR_LOC_DEC(ctx, loc), char **dest, int max,
- const char *delim, const char *src, ...);
-extern int mprAllocStrcpy(MPR_LOC_DEC(ctx, loc), char **dest, int max,
- const char *src);
-extern int mprReallocStrcat(MPR_LOC_DEC(ctx, loc), char **dest, int max,
- int existingLen, const char *delim, const char *src, ...);
-
-/*
- * MACROS: These are the convenience macros to automatically supply file
- * names and line numbers when debugging.
- */
-#define mprNew(ctx) new(MPR_LOC_ARGS(ctx))
-
-#define mprAlloc(ctx, size) mprAllocBlock(MPR_LOC_ARGS(ctx), size)
-
-#define mprAllocZeroed(ctx, size) mprAllocZeroedBlock(MPR_LOC_ARGS(ctx), size)
-
-#define mprSlabAlloc(ctx, size, inc) \
- ((type*) mprSlabAllocBlock(MPR_LOC_ARGS(ctx), size, inc))
-
-#define mprSlabAllocZeroed(ctx, size, inc) \
- ((type*) mprSlabAllocBlock(MPR_LOC_ARGS(ctx), size, inc))
-
-#define mprRealloc(ctx, ptr, size) mprReallocBlock(MPR_LOC_ARGS(ctx), ptr, size)
-
-#define mprMemdup(ctx, ptr, size) \
- mprMemdupInternal(MPR_LOC_ARGS(ctx), ptr, size)
-
-#define mprStrdup(ctx, str) mprStrdupInternal(MPR_LOC_ARGS(ctx), str)
-
-#define mprStrndup(ctx, str, size) mprStrndupDebug(MPR_LOC_ARGS(ctx), str, size)
-
-/*
- * Allocate type macros
- */
-#define mprAllocType(ctx, type) \
- ((type*) mprAllocBlock(MPR_LOC_ARGS(ctx), sizeof(type)))
-
-#define mprAllocTypeZeroed(ctx, type) \
- ((type*) mprAllocZeroedBlock(MPR_LOC_ARGS(ctx), sizeof(type)))
-
-#define mprSlabAllocType(ctx, type, inc) \
- ((type*) mprSlabAllocBlock(MPR_LOC_ARGS(ctx), sizeof(type), inc))
-
-#define mprSlabAllocTypeZeroed(ctx, type, inc) \
- ((type*) mprSlabAllocZeroedBlock(MPR_LOC_ARGS(ctx), sizeof(type), \
- inc))
-
-/*
- * Multithread locking
- */
-#if BLD_FEATURE_MULTITHREAD
-extern void mprInitThreads(MprApp *app);
-extern void mprTermThreads(MprApp *app);
-extern MprLock *mprCreateLock(MprCtx ctx);
-extern void mprDestroyLock(MprLock *lock);
-extern void mprLock(MprLock *lock);
-extern int mprTryLock(MprLock *lock);
-extern void mprUnlock(MprLock *lock);
-extern void mprGlobalLock(MprCtx ctx);
-extern void mprGlobalUnlock(MprCtx ctx);
-extern int mprGetCurrentThreadID();
-#else
-/*
- * Disable multithreading
- */
-#define mprInitThreads(ctx, app)
-#define mprTermThreads(app)
-#define mprCreateLock(ctx)
-#define mprDestroyLock(lock)
-#define mprLock(lock)
-#define mprTryLock(lock)
-#define mprUnlock(lock)
-#define mprGlobalLock(app)
-#define mprGlobalUnlock(app)
-#define mprGetCurrentThreadID()
-#endif
-
-/*
- * Time
- */
-extern MprTime *mprGetTime(MprCtx ctx, MprTime *tp);
-extern int mprGetTimeRemaining(MprCtx ctx, MprTime mark, uint timeout);
-extern int mprGetElapsedTime(MprCtx ctx, MprTime mark);
-extern int mprCompareTime(MprTime *t1, MprTime *t2);
-extern uint mprSubtractTime(MprTime *t1, MprTime *t2);
-extern void mprAddElapsedToTime(MprTime *time, uint elapsed);
-
-#if !BREW
-extern int mprAsctime(MprCtx ctx, char *buf, int bufsize,
- const struct tm *timeptr);
-extern int mprCtime(MprCtx ctx, char *buf, int bufsize,
- const time_t *timer);
-extern struct tm *mprLocaltime(MprCtx ctx, struct tm *timep, time_t *now);
-extern struct tm *mprGmtime(MprCtx ctx, time_t* now, struct tm *timep);
-extern int mprRfcTime(MprCtx ctx, char *buf, int bufsize,
- const struct tm *timep);
-#endif /* !BREW */
-
-/*
- * Host name
- */
-extern struct hostent* mprGetHostByName(MprCtx ctx, const char *name);
-
-#if WIN
-extern int mprReadRegistry(MprCtx ctx, char **buf, int max,
- const char *key, const char *val);
-extern int mprWriteRegistry(MprCtx ctx, const char *key, const char *name,
- const char *value);
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _h_MPR */
-
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/**
- * @file mprAlloc.c
- * @brief Memory Allocation
- * @overview
- */
-
-/*
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-
-/********************************* Includes ***********************************/
-
-#define UNSAFE_FUNCTIONS_OK 1
-
-#include "mpr.h"
-
-/******************************* Local Defines ********************************/
-/*
- * Set to 1 to disable slab based allocations
- */
-#define NO_SLAB 0
-
-/*
- * Validation mode is quite slow
- */
-#define VALIDATE_ALLOC 0
-#if VALIDATE_ALLOC
-#define VALIDATE_BLOCK(ptr) mprValidateBlock(ptr)
-#else
-#define VALIDATE_BLOCK(ptr)
-#endif
-
-/*
- * Align on 4 bytes if squeeze, Otherwize on 16 bytes.
- */
-#define HDR_SIZE MPR_BLK_HDR_SIZE
-
-#define APP_MAGIC 0xa571cb80
-#define ALLOC_MAGIC 0xe814ecc0
-
-/*
- * This must be at least one word to ensure that the smallest allocation is
- * 4 bytes. Slab allocations need at least one word to store their next ptr.
- */
-#define ALLOC_ALIGN(x) (((x)+3)&~3)
-#define GET_HDR(ptr) ((MprBlk*) (((char*) (ptr)) - HDR_SIZE))
-#define GET_PTR(bp) ((void*) (((char*) (bp)) + HDR_SIZE))
-#define VALID_HDR(bp) (((bp)->flags & ~0x3F) == ALLOC_MAGIC)
-#define VALID_BLK(ptr) (VALID_HDR(GET_HDR(ptr)))
-
-/*
- * In production releases, mprAssert will compile out (not be included)
- * but CHECK_HDR will remain even in production builds.
- */
-#define CHECK_HDR(bp) \
- if (1) { if (! VALID_HDR(bp)) { mprAllocAbort(); } } else
-
-/*
- * Chunk the slabs into 32 byte increments.
- * This allows for allocations up to 512 bytes via slabs and maximizes
- * sharing of slab allocations.
- *
- * Index map:
- * 0 == 32 bytes
- * 1 == 64 bytes
- * 2 == 96 bytes
- * 3 == 128 bytes
- * 4 == 160 bytes
- * 5 == 192 bytes
- * 6 == 224 bytes
- * 7 == 256 bytes
- * 8 == 288 bytes
- * 9 == 320 bytes
- * 10 == 352 bytes
- * 11 == 384 bytes
- * 12 == 416 bytes
- * 13 == 448 bytes
- * 14 == 480 bytes
- * 15 == 512 bytes
- */
-#define SLAB_ALIGN(size) ((size + 31) & ~31)
-#define GET_SLAB(size) (size >> 6)
-
-/*
- * Block flags
- */
-#define ALLOC_FLAGS_FREE 0x1 /* Block is free */
-#define ALLOC_FLAGS_FREEING 0x2 /* Block is being freed */
-#define ALLOC_FLAGS_SLAB_BLOCK 0x4 /* Block was allocated from slab */
-#define ALLOC_FLAGS_REQUIRED 0x8 /* Block is required by alloc */
-#define ALLOC_FLAGS_KEEP 0x10 /* Keep block - don't mprFree */
-#define ALLOC_FLAGS_DONT_OS_FREE 0x20 /* Don't return mem to O/S */
-#define ALLOC_FLAGS_IS_SLAB 0x40 /* Block is a slab */
-
-#if BLD_DEBUG && !BREW
-/*
- * Set this address to break when this address is allocated or freed. This is
- * a block address (not a user ptr).
- */
-static MprBlk *stopAlloc;
-#endif
-
-#if !BREW
-static MprCtx rootCtx; /* Root context if none supplied */
-#endif
-
-/***************************** Forward Declarations ***************************/
-
-static int mprAllocException(MPR_LOC_DEC(ptr, loc), uint size, bool granted);
-static void slabFree(MprBlk *bp);
-static int growSlab(MPR_LOC_DEC(ctx, loc), MprSlab *slab, uint size, uint inc);
-
-/******************************************************************************/
-/*
- * Put first in file so it is easy to locate in a debugger
- */
-
-void mprBreakpoint(const char *loc, const char *msg)
-{
-}
-
-/******************************************************************************/
-#if (WIN || BREW_SIMULATOR) && BLD_DEBUG
-
-int crtReportHook(int type, char *msg, int *retval)
-{
- printf("%s\n", msg);
- *retval = 0;
- return TRUE;
-}
-
-#endif
-/******************************************************************************/
-/*
- * Initialize the memory subsystem
- */
-
-MprApp *mprAllocInit(MprAllocCback cback)
-{
- MprAllocStats *stats;
- MprApp *app;
- MprSlab *slab;
- MprBlk *bp, *sp;
- int i;
-
- bp = malloc(sizeof(MprApp) + HDR_SIZE);
- mprAssert(bp);
- if (bp == 0) {
- if (cback) {
- (*cback)(0, sizeof(MprApp), 0, 0);
- }
- return 0;
- }
- memset(bp, 0, sizeof(MprApp) + HDR_SIZE);
-
- bp->parent = bp;
- bp->size = sizeof(MprApp);
- bp->flags = ALLOC_MAGIC;
- bp->next = bp->prev = bp;
-
-#if BLD_FEATURE_ALLOC_LEAK_TRACK
- bp->location = MPR_LOC;
-#endif
-
- app = (MprApp*) GET_PTR(bp);
- app->magic = APP_MAGIC;
-
- app->alloc.cback = cback;
- app->stackStart = (void*) &app;
-
- bp->app = app;
-
- app->alloc.slabs = mprAllocZeroedBlock(MPR_LOC_PASS(app, MPR_LOC),
- sizeof(MprSlab) * MPR_MAX_SLAB);
- if (app->alloc.slabs == 0) {
- mprFree(app);
- return 0;
- }
-
- /*
- * The slab control structures must not be freed. Set keep to safeguard
- * against accidents.
- */
- sp = GET_HDR(app->alloc.slabs);
- sp->flags |= ALLOC_FLAGS_KEEP;
-
- for (i = 0; i < MPR_MAX_SLAB; i++) {
- /*
- * This is overriden by requestors calling slabAlloc
- */
- slab = &app->alloc.slabs[i];
- slab->preAllocateIncr = MPR_SLAB_DEFAULT_INC;
- }
-
- /*
- * Keep aggregated stats even in production code
- */
- stats = &app->alloc.stats;
- stats->bytesAllocated += sizeof(MprApp);
- if (stats->bytesAllocated > stats->peakAllocated) {
- stats->peakAllocated = stats->bytesAllocated;
- }
- stats->allocCount++;
-
-#if !BREW
- rootCtx = app;
-#endif
-#if (WIN || BREW_SIMULATOR) && BLD_DEBUG
- _CrtSetReportHook(crtReportHook);
-#endif
- return app;
-}
-
-/******************************************************************************/
-/*
- * Terminate the alloc module
- */
-
-void mprAllocTerm(MprApp *app)
-{
- MprSlab *slabs;
- MprBlk *appBlk, *slabBlk;
-
- /*
- * Must do a carefully ordered cleanup. Need to free all children blocks
- * before freeing the slab memory. Save a local pointer to the slabs.
- */
- slabs = app->alloc.slabs;
-
- /*
- * Free the app and all children. Set DONT_OS_FREE to prevent free() being
- * called on app itself. We need that so we can free the slabs below.
- */
- appBlk = GET_HDR(app);
- appBlk->flags |= ALLOC_FLAGS_DONT_OS_FREE;
- mprFree(app);
-
- /*
- * Slabs are initially marked don't free. We must preserve them while all
- * other blocks are freed. Then we clear the don't free flag and free.
- * Now we don't have an app structure which is used by mprFree. We must
- * fake it.
- */
- slabBlk = GET_HDR(slabs);
- slabBlk->flags &= ~ALLOC_FLAGS_KEEP;
- mprFree(slabs);
-
- /*
- * Now we can finally free the memory for the app structure
- */
- free(appBlk);
-}
-
-/******************************************************************************/
-/*
- * Allocate a block
- */
-
-void *mprAllocBlock(MPR_LOC_DEC(ctx, loc), uint size)
-{
- MprAllocStats *stats;
- MprBlk *bp, *parent;
- MprApp *app;
- int diff;
-
- mprAssert(size > 0);
-
- if (ctx == 0) {
-#if BREW
- mprAssert(ctx);
- return 0;
-#else
- ctx = rootCtx;
-#endif
- }
- if (size == 0) {
- size = 1;
- }
-
- mprAssert(VALID_BLK(ctx));
- parent = GET_HDR(ctx);
- mprAssert(VALID_HDR(parent));
-
- CHECK_HDR(parent);
-
- size = ALLOC_ALIGN(size);
-
- app = parent->app;
-
- stats = &app->alloc.stats;
-
- mprLock(app->allocLock);
-
- stats->bytesAllocated += size + HDR_SIZE;
- if (stats->bytesAllocated > stats->peakAllocated) {
- stats->peakAllocated = stats->bytesAllocated;
- }
-
- /*
- * Prevent allocation if over the maximum
- */
- if (stats->maxMemory && stats->bytesAllocated > stats->maxMemory) {
- stats->bytesAllocated -= (size + HDR_SIZE);
- mprUnlock(app->allocLock);
- if (mprAllocException(MPR_LOC_PASS(ctx, loc), size, 0) < 0) {
- return 0;
- }
- mprLock(app->allocLock);
- }
-
- if ((bp = malloc(size + HDR_SIZE)) == 0) {
- mprAssert(bp);
- stats->errors++;
- mprUnlock(app->allocLock);
- mprAllocException(MPR_LOC_PASS(ctx, loc), size, 0);
- return 0;
- }
-
-#if BLD_DEBUG
- memset(bp, 0xf7, size + HDR_SIZE);
-#endif
-
-#if BLD_DEBUG && !BREW
- if (bp == stopAlloc) {
- mprBreakpoint(MPR_LOC, "breakOnAddr");
- }
-#endif
-
- /*
- * Warn if allocation puts us over the red line
- */
- if (stats->redLine && stats->bytesAllocated > stats->redLine) {
- mprUnlock(app->allocLock);
- if (mprAllocException(MPR_LOC_PASS(ctx, loc), size, 1) < 0) {
- return 0;
- }
- mprLock(app->allocLock);
- }
-
- bp->size = size;
- bp->flags = ALLOC_MAGIC;
- bp->destructor = 0;
-
- bp->parent = parent;
-
- if (parent->children == 0) {
- parent->children = bp;
- bp->next = bp->prev = bp;
-
- } else {
- /*
- * Append to the end of the list. Preserve alloc order
- */
- bp->next = parent->children;
- bp->prev = parent->children->prev;
- parent->children->prev->next = bp;
- parent->children->prev = bp;
- }
-
- bp->children = 0;
-
-#if BLD_FEATURE_ALLOC_LEAK_TRACK
- bp->location = loc;
-#endif
-
- bp->app = parent->app;
-
- VALIDATE_BLOCK(GET_PTR(bp));
-
- stats->allocCount++;
-
- /*
- * Monitor stack usage
- */
- diff = (int) bp->app->stackStart - (int) &stats;
- if (diff < 0) {
- app->maxStack -= diff;
- app->stackStart = (void*) &stats;
- diff = 0;
- }
-
- if ((uint) diff > app->maxStack) {
- app->maxStack = diff;
- }
- mprUnlock(app->allocLock);
-
- return GET_PTR(bp);
-}
-
-/******************************************************************************/
-/*
- * Allocate and zero a block
- */
-
-void *mprAllocZeroedBlock(MPR_LOC_DEC(ctx, loc), uint size)
-{
- void *newBlock;
-
- MprBlk *bp;
-
- bp = GET_HDR(ctx);
- mprAssert(VALID_BLK(ctx));
-
- newBlock = mprAllocBlock(MPR_LOC_PASS(ctx, loc), size);
- if (newBlock) {
- memset(newBlock, 0, size);
- }
- return newBlock;
-}
-
-/******************************************************************************/
-/*
- * Free a block of memory. Free all children recursively.
- */
-
-int mprFree(void *ptr)
-{
- MprAllocStats *stats;
- MprBlk *bp, *parent, *cp, *firstChild, *prev;
- MprApp *app;
-
- if (ptr == 0) {
- return 0;
- }
-
- mprAssert(VALID_BLK(ptr));
- VALIDATE_BLOCK(ptr);
-
- bp = GET_HDR(ptr);
-
-#if BLD_DEBUG && !BREW
- if (bp == stopAlloc) {
- mprBreakpoint(MPR_LOC, "breakOnAddr");
- }
-#endif
-
- mprAssert(bp);
- mprAssert(VALID_HDR(bp));
-
- CHECK_HDR(bp);
-
- /*
- * Test if already freed
- */
- mprAssert(! (bp->flags & ALLOC_FLAGS_FREE));
- if (bp->flags & ALLOC_FLAGS_FREE) {
- return 0;
- }
-
- /*
- * Return if recursive freeing or this is a permanent block
- */
- app = bp->app;
- mprLock(app->allocLock);
- if (bp->flags & (ALLOC_FLAGS_FREEING | ALLOC_FLAGS_KEEP)) {
- mprUnlock(app->allocLock);
- return 0;
- }
- bp->flags |= ALLOC_FLAGS_FREEING;
-
-
- /*
- * Call any destructors
- */
- if (bp->destructor) {
- mprUnlock(app->allocLock);
- if ((bp->destructor)(ptr) < 0) {
- return -1;
- }
- mprLock(app->allocLock);
- bp->destructor = 0;
- }
-
- /*
- * Free the children. Free in reverse order so firstChild is preserved
- * during the list scan as an end of list marker.
- */
- if ((firstChild = bp->children) != 0) {
- cp = firstChild->prev;
- while (cp != firstChild) {
-
- mprAssert(VALID_HDR(cp));
- VALIDATE_BLOCK(GET_PTR(cp));
-
- prev = cp->prev;
-
- /*
- * FUTURE - OPT. Make this inline
- */
- mprFree(GET_PTR(cp));
-
- cp = prev;
- }
-
- mprFree(GET_PTR(firstChild));
-
- /*
- * Just for clarity
- */
- bp->children = 0;
- }
-
- parent = bp->parent;
-
- mprAssert(VALID_HDR(parent));
-
- /*
- * Unlink from the parent
- */
- if (parent->children == bp) {
- if (bp->next == bp) {
- parent->children = 0;
- } else {
- parent->children = bp->next;
- }
- }
-
- /*
- * Remove from the sibling chain
- */
- bp->prev->next = bp->next;
- bp->next->prev = bp->prev;
-
- bp->flags |= ALLOC_FLAGS_FREE;
-
- /*
- * Release the memory. If from a slab, return to the slab. Otherwise,
- * return to the O/S.
- */
- if (bp->flags & ALLOC_FLAGS_SLAB_BLOCK) {
- slabFree(bp);
-
- } else {
- mprAssert(bp);
-
- /*
- * Update the stats
- */
- stats = &bp->app->alloc.stats;
- stats->bytesAllocated -= (bp->size + HDR_SIZE);
- mprAssert(stats->bytesAllocated >= 0);
-
- stats->allocCount--;
- mprAssert(stats->allocCount >= 0);
-
-#if BLD_DEBUG && !BREW
- if (bp == stopAlloc) {
- mprBreakpoint(MPR_LOC, "breakOnAddr");
- }
-#endif
-
- /*
- * Return to the O/S
- */
- if (! (bp->flags & ALLOC_FLAGS_DONT_OS_FREE)) {
- free(bp);
- }
- }
- /* OPT */
- if (app != ptr) {
- mprUnlock(app->allocLock);
- }
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Rallocate a block
- */
-
-void *mprReallocBlock(MPR_LOC_DEC(ctx, loc), void *ptr, uint size)
-{
- MprBlk *bp, *newbp, *firstChild, *cp;
- MprApp *app;
- void *newPtr;
-
- mprAssert(VALID_BLK(ctx));
- mprAssert(size > 0);
-
- if (ptr == 0) {
- return mprAllocBlock(MPR_LOC_PASS(ctx, loc), size);
- }
-
- mprAssert(VALID_BLK(ptr));
- bp = GET_HDR(ptr);
- mprAssert(bp);
- mprAssert(VALID_HDR(bp));
-
- CHECK_HDR(bp);
-
- if (size < bp->size) {
- return ptr;
- }
-
- newPtr = mprAllocBlock(MPR_LOC_PASS(ctx, loc), size);
- if (newPtr == 0) {
- bp->flags &= ~ALLOC_FLAGS_FREE;
- free(bp);
- return 0;
- }
-
- newbp = GET_HDR(newPtr);
- mprAssert(newbp->size >= size);
- memcpy((char*) newbp + HDR_SIZE, (char*) bp + HDR_SIZE, bp->size);
- mprAssert(newbp->size >= size);
-
- /*
- * Fix the next / prev pointers
- */
- app = bp->app;
- mprLock(app->allocLock);
- newbp->next->prev = newbp;
- newbp->prev->next = newbp;
-
- /*
- * Need to fix the parent pointer of all children
- */
- if ((firstChild = newbp->children) != 0) {
- cp = firstChild;
- do {
- cp->parent = newbp;
- cp = cp->next;
- } while (cp != firstChild);
- }
-
- /*
- * May need to set the children pointer of our parent
- */
- if (newbp->parent->children == bp) {
- newbp->parent->children = newbp;
- }
-
- /*
- * Free the original block
- */
- mprFree(ptr);
-
- mprUnlock(app->allocLock);
-
- return GET_PTR(newbp);
-}
-
-/******************************************************************************/
-/*
- * Allocate a block from a slab
- */
-
-void *mprSlabAllocBlock(MPR_LOC_DEC(ctx, loc), uint size, uint inc)
-{
-
-#if NO_SLAB
- return mprAllocBlock(MPR_LOC_PASS(ctx, loc), size);
-#else
-
- MprBlk *parent, *bp;
- MprSlabBlock *sb;
- MprApp *app;
- MprSlab *slab;
- int slabIndex;
-
- if (ctx == 0) {
- mprAssert(ctx);
- return 0;
- }
-
- mprAssert(size > 0);
- mprAssert(VALID_BLK(ctx));
-
- parent = GET_HDR(ctx);
- mprAssert(VALID_HDR(parent));
-
- CHECK_HDR(parent);
-
- size = SLAB_ALIGN(size);
-
- app = parent->app;
- mprAssert(app);
-
- slabIndex = GET_SLAB(size);
-
- if (slabIndex < 0 || slabIndex >= MPR_MAX_SLAB) {
- return mprAllocBlock(MPR_LOC_PASS(ctx, loc), size);
- }
-
- /*
- * Dequeue a block from the slab. "sb" will point to the user data
- * portion of the block (i.e. after the MprBlk header). Slabs must be
- * allocated off the "slabs" context to ensure they don't get freed
- * until after all other blocks are freed.
- */
- mprLock(app->allocLock);
- slab = &app->alloc.slabs[slabIndex];
- if ((sb = slab->next) == 0) {
- if (growSlab(MPR_LOC_ARGS(parent->app->alloc.slabs),
- slab, size, inc) < 0) {
- mprUnlock(app->allocLock);
- return 0;
- }
- sb = slab->next;
- }
- mprAssert(sb);
-
- /*
- * Dequeue the block
- */
- slab->next = sb->next;
-
-#if BLD_FEATURE_ALLOC_STATS
-{
- MprSlabStats *slabStats;
- /*
- * Update the slab stats
- */
- slabStats = &slab->stats;
- slabStats->totalAllocCount++;
- slabStats->freeCount--;
- slabStats->allocCount++;
- if (slabStats->allocCount > slabStats->peakAllocCount) {
- slabStats->peakAllocCount = slabStats->allocCount;
- }
-}
-#endif /* BLD_FEATURE_ALLOC_STATS */
-
- bp = GET_HDR(sb);
-
-#if BLD_DEBUG && !BREW
- if (bp == stopAlloc) {
- mprBreakpoint(MPR_LOC, "breakOnAddr");
- }
-#endif
-
- bp->size = size;
- bp->flags = ALLOC_MAGIC | ALLOC_FLAGS_SLAB_BLOCK;
- bp->destructor = 0;
-
- bp->parent = parent;
-
- if (parent->children == 0) {
- parent->children = bp;
- bp->next = bp->prev = bp;
-
- } else {
- /*
- * Append to the end of the list. Preserve alloc order
- */
- bp->next = parent->children;
- bp->prev = parent->children->prev;
- parent->children->prev->next = bp;
- parent->children->prev = bp;
- }
-
- bp->children = 0;
-
- bp->app = app;
-
-#if BLD_FEATURE_ALLOC_LEAK_TRACK
- bp->location = loc;
-#endif
- mprUnlock(app->allocLock);
-
- return GET_PTR(bp);
-#endif
-}
-
-/******************************************************************************/
-/*
- * Return a block back to its slab
- */
-
-static void slabFree(MprBlk *bp)
-{
- MprSlab *slab;
- MprApp *app;
- void *ptr;
- int slabIndex;
-
- mprAssert(VALID_HDR(bp));
-
- slabIndex = GET_SLAB(bp->size);
- mprAssert(0 <= slabIndex && slabIndex < MPR_MAX_SLAB);
-
- if (0 <= slabIndex && slabIndex < MPR_MAX_SLAB) {
- mprLock(bp->app->allocLock);
- slab = &bp->app->alloc.slabs[slabIndex];
- app = bp->app;
-
-#if BLD_DEBUG
- memset(bp, 0xfc, bp->size + HDR_SIZE);
-#endif
-
- ptr = GET_PTR(bp);
- ((MprSlabBlock*) ptr)->next = slab->next;
- slab->next = ((MprSlabBlock*) ptr);
-
-#if BLD_FEATURE_ALLOC_STATS
-{
- MprSlabStats *slabStats;
- slabStats = &slab->stats;
-
- slabStats->freeCount++;
- slabStats->allocCount--;
-
- if (slabStats->freeCount >= slabStats->peakFreeCount) {
- slabStats->peakFreeCount = slabStats->freeCount;
- }
-}
-#endif
- mprUnlock(app->allocLock);
- }
-}
-
-/******************************************************************************/
-/*
- * Grow the slab and return the next free block
- * Must be called locked.
- */
-
-static int growSlab(MPR_LOC_DEC(ctx, loc), MprSlab *slab, uint size, uint inc)
-{
- MprBlk *bp;
- MprSlabBlock *sb;
- int i, chunkSize, len;
-
- mprAssert(VALID_BLK(ctx));
- mprAssert(slab);
- mprAssert(size > 0);
-
- /*
- * Take the maximum requested by anyone
- */
- slab->preAllocateIncr = max(slab->preAllocateIncr, inc);
-
- /*
- * We allocate an array of blocks each of user "size" bytes.
- */
- chunkSize = HDR_SIZE + size;
- len = chunkSize * slab->preAllocateIncr;
- bp = mprAllocBlock(MPR_LOC_PASS(ctx, loc), len);
-
-#if BLD_DEBUG
- memset(bp, 0xf1, len);
-#endif
-
- if (bp == 0) {
- mprAssert(0);
- return MPR_ERR_MEMORY;
- }
- bp->flags |= ALLOC_FLAGS_IS_SLAB;
-
- /*
- * We store the slab information in the user data portion
- */
- sb = (MprSlabBlock*) GET_PTR(bp);
-
-
- sb = (MprSlabBlock*) ((char*) sb + len - chunkSize);
- for (i = slab->preAllocateIncr - 1; i >= 0; i--) {
- sb->next = slab->next;
- slab->next = sb;
- sb = (MprSlabBlock*) ((char*) sb - chunkSize);
- }
-
-#if BLD_FEATURE_ALLOC_STATS
-{
- MprSlabStats *stats;
- stats = &slab->stats;
- stats->freeCount += slab->preAllocateIncr;
- if (stats->freeCount > stats->peakFreeCount) {
- stats->peakFreeCount = stats->freeCount;
- }
-}
-#endif
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Set the pre-allocate amount
- */
-
-int mprSetSlabPreAllocate(MprCtx ctx, int slabIndex, int preAllocateIncr)
-{
- MprApp *app;
- MprSlab *slab;
-
- mprAssert(VALID_BLK(ctx));
- mprAssert(0 <= slabIndex && slabIndex < MPR_MAX_SLAB);
- mprAssert(preAllocateIncr > 0);
-
- if (0 <= slabIndex && slabIndex < MPR_MAX_SLAB) {
- app = mprGetApp(ctx);
- slab = &app->alloc.slabs[slabIndex];
- slab->preAllocateIncr = preAllocateIncr;
- } else {
- return MPR_ERR_BAD_ARGS;
- }
- return 0;
-}
-
-/******************************************************************************/
-
-void *mprSlabAllocZeroedBlock(MPR_LOC_DEC(ctx, loc), uint size, uint inc)
-{
- void *newBlock;
-
- mprAssert(VALID_BLK(ctx));
- mprAssert(size > 0);
-
- newBlock = mprSlabAllocBlock(MPR_LOC_PASS(ctx, loc), size, inc);
- if (newBlock) {
- memset(newBlock, 0, size);
- }
- return newBlock;
-}
-
-/******************************************************************************/
-/*
- * Internal strdup function. Will use the slab allocator for small strings
- */
-
-char *mprStrdupInternal(MPR_LOC_DEC(ctx, loc), const char *str)
-{
- char *newp;
- int len;
-
- mprAssert(VALID_BLK(ctx));
-
- if (str == 0) {
- str = "";
- }
-
- len = strlen(str) + 1;
-
- if (len < MPR_SLAB_STR_MAX) {
- newp = mprSlabAllocBlock(MPR_LOC_PASS(ctx, loc), MPR_SLAB_STR_MAX,
- MPR_SLAB_STR_INC);
- } else {
- newp = mprAllocBlock(MPR_LOC_PASS(ctx, loc), len);
- }
-
- if (newp) {
- memcpy(newp, str, len);
- }
-
- return newp;
-}
-
-/******************************************************************************/
-/*
- * Internal strndup function. Will use the slab allocator for small strings
- */
-
-char *mprStrndupInternal(MPR_LOC_DEC(ctx, loc), const char *str, uint size)
-{
- char *newp;
- uint len;
-
- mprAssert(VALID_BLK(ctx));
-
- if (str == 0) {
- str = "";
- }
- len = strlen(str) + 1;
- len = min(len, size);
-
- if (len < MPR_SLAB_STR_MAX) {
- newp = mprSlabAllocBlock(MPR_LOC_PASS(ctx, loc), MPR_SLAB_STR_MAX,
- MPR_SLAB_STR_INC);
- } else {
- newp = mprAllocBlock(MPR_LOC_PASS(ctx, loc), len);
- }
-
- if (newp) {
- memcpy(newp, str, len);
- }
-
- return newp;
-}
-
-/******************************************************************************/
-/*
- * Internal memcpy function. Will use the slab allocator for small strings
- */
-
-void *mprMemdupInternal(MPR_LOC_DEC(ctx, loc), const void *ptr, uint size)
-{
- char *newp;
-
- mprAssert(VALID_BLK(ctx));
-
- if (size < MPR_SLAB_STR_MAX) {
- newp = mprSlabAllocBlock(MPR_LOC_PASS(ctx, loc), MPR_SLAB_STR_MAX,
- MPR_SLAB_STR_INC);
- } else {
- newp = mprAllocBlock(MPR_LOC_PASS(ctx, loc), size);
- }
-
- if (newp) {
- memcpy(newp, ptr, size);
- }
-
- return newp;
-}
-
-/******************************************************************************/
-/*
- * Steal a block from one context and insert in another
- */
-
-int mprStealAllocBlock(MPR_LOC_DEC(ctx, loc), const void *ptr)
-{
- MprBlk *bp, *parent;
-
- if (ptr == 0) {
- return 0;
- }
-
- mprAssert(VALID_BLK(ctx));
- mprAssert(VALID_BLK(ptr));
-
- bp = GET_HDR(ptr);
-
-#if BLD_DEBUG && !BREW
- if (bp == stopAlloc) {
- mprBreakpoint(MPR_LOC, "breakOnAddr");
- }
-#endif
-
- mprAssert(bp);
- mprAssert(VALID_HDR(bp));
- mprAssert(ptr != mprGetAllocParent(ptr));
-
- CHECK_HDR(bp);
-
- mprAssert(bp->prev);
- mprAssert(bp->prev->next);
- mprAssert(bp->next);
- mprAssert(bp->next->prev);
-
- parent = bp->parent;
- mprAssert(VALID_HDR(parent));
-
- mprLock(bp->app->allocLock);
- if (parent->children == bp) {
- if (bp->next == bp) {
- parent->children = 0;
- } else {
- parent->children = bp->next;
- }
- }
-
- bp->prev->next = bp->next;
- bp->next->prev = bp->prev;
-
- parent = GET_HDR(ctx);
- mprAssert(VALID_HDR(parent));
- bp->parent = parent;
-
- if (parent->children == 0) {
- parent->children = bp;
- bp->next = bp->prev = bp;
-
- } else {
- bp->next = parent->children;
- bp->prev = parent->children->prev;
- parent->children->prev->next = bp;
- parent->children->prev = bp;
- }
-
-#if BLD_FEATURE_ALLOC_LEAK_TRACK
- bp->location = loc;
-#endif
-
- VALIDATE_BLOCK(GET_PTR(bp));
-
- mprUnlock(bp->app->allocLock);
-
- return 0;
-}
-
-/******************************************************************************/
-
-void mprSetRequiredAlloc(MprCtx ptr, bool recurse)
-{
- MprBlk *bp, *firstChild, *cp;
-
- bp = GET_HDR(ptr);
-
- bp->flags |= ALLOC_FLAGS_REQUIRED;
-
- if (recurse && (firstChild = bp->children) != 0) {
- cp = firstChild;
- do {
- mprSetRequiredAlloc(GET_PTR(cp), recurse);
- cp = cp->next;
- } while (cp != firstChild);
- }
-}
-
-/******************************************************************************/
-/*
- * Monitor stack usage. Return true if the stack has grown
- */
-
-int mprStackCheck(MprCtx ptr)
-{
- MprApp *app;
- int size;
-
- mprAssert(VALID_BLK(ptr));
-
- app = mprGetApp(ptr);
-
- size = (int) app->stackStart - (int) &app;
- if (size < 0) {
- app->maxStack -= size;
- app->stackStart = (void*) &app;
- size = 0;
- }
- if ((uint) size > app->maxStack) {
- app->maxStack = size;
- return 1;
- }
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Return the stack size
- */
-
-int mprStackSize(MprCtx ptr)
-{
- MprApp *app;
-
- mprAssert(VALID_BLK(ptr));
-
- app = mprGetApp(ptr);
- return app->maxStack;
-}
-
-/******************************************************************************/
-
-static int mprAllocException(MPR_LOC_DEC(ctx, loc), uint size, bool granted)
-{
- MprApp *app;
- MprAlloc *alloc;
- int rc;
-
- mprAssert(VALID_BLK(ctx));
-
- app = mprGetApp(ctx);
- alloc = &app->alloc;
-
- if (alloc->cback == 0) {
- return 0;
- }
-
- mprLock(app->allocLock);
- if (alloc->inAllocException == 0) {
- alloc->inAllocException = 1;
- mprUnlock(app->allocLock);
-
- rc = (alloc->cback)(app, size, alloc->stats.bytesAllocated, granted);
-
- mprLock(app->allocLock);
- app->alloc.inAllocException = 0;
- mprUnlock(app->allocLock);
-
- return rc;
- }
- return 0;
-}
-
-/******************************************************************************/
-
-void mprSetAllocLimits(MprApp *app, uint redLine, uint maxMemory)
-{
- app->alloc.stats.redLine = redLine;
- app->alloc.stats.maxMemory = maxMemory;
-}
-
-/******************************************************************************/
-
-MprAllocCback mprSetAllocCallback(MprApp *app, MprAllocCback cback)
-{
- MprAllocCback old;
-
- mprAssert(app);
- mprAssert(VALID_BLK(app));
-
- old = app->alloc.cback;
- app->alloc.cback = cback;
- return old;
-}
-
-/******************************************************************************/
-
-uint mprGetAllocBlockSize(MprCtx ptr)
-{
- MprBlk *bp;
-
- mprAssert(VALID_BLK(ptr));
-
- if (ptr == 0) {
- return 0;
- }
-
- bp = GET_HDR(ptr);
- mprAssert(VALID_HDR(bp));
-
- CHECK_HDR(bp);
-
- return bp->size;
-}
-
-/******************************************************************************/
-/*
- * Return the total block count used by a block including all children
- */
-
-uint mprGetAllocBlockCount(MprCtx ptr)
-{
- MprBlk *bp, *firstChild, *cp;
- uint count;
-
- mprAssert(VALID_BLK(ptr));
-
- if (ptr == 0) {
- return 0;
- }
-
- bp = GET_HDR(ptr);
- mprAssert(VALID_HDR(bp));
-
- /*
- * Add one for itself
- */
- count = 1;
- if ((firstChild = bp->children) != 0) {
- cp = firstChild;
- do {
- count += mprGetAllocBlockCount(GET_PTR(cp));
- cp = cp->next;
- } while (cp != firstChild);
- }
- return count;
-}
-
-/******************************************************************************/
-/*
- * Return the total of all memory allocated including slabs
- */
-
-uint mprGetAllocBlockMemory(MprCtx ptr)
-{
- MprBlk *bp, *firstChild, *cp;
- uint count;
-
- mprAssert(VALID_BLK(ptr));
-
- if (ptr == 0) {
- return 0;
- }
-
- bp = GET_HDR(ptr);
- mprAssert(VALID_HDR(bp));
-
- count = bp->size + HDR_SIZE;
- if ((firstChild = bp->children) != 0) {
- cp = firstChild;
- do {
- count += mprGetAllocBlockMemory(GET_PTR(cp));
- cp = cp->next;
- } while (cp != firstChild);
- }
- return count;
-}
-
-/******************************************************************************/
-#if BLD_FEATURE_ALLOC_LEAK_TRACK
-
-const char *mprGetAllocLocation(MprCtx ptr)
-{
- MprBlk *bp;
-
- if (ptr == 0) {
- return 0;
- }
- mprAssert(VALID_BLK(ptr));
-
- bp = GET_HDR(ptr);
- mprAssert(VALID_HDR(bp));
- return bp->location;
-}
-
-#endif
-/******************************************************************************/
-
-void *mprGetAllocParent(MprCtx ptr)
-{
- MprBlk *bp;
-
- mprAssert(VALID_BLK(ptr));
-
- if (ptr == 0) {
- return 0;
- }
-
- bp = GET_HDR(ptr);
- mprAssert(VALID_HDR(bp));
-
- CHECK_HDR(bp);
-
- return GET_PTR(bp->parent);
-}
-
-/******************************************************************************/
-
-MprAllocStats *mprGetAllocStats(MprApp *app)
-{
- mprAssert(VALID_BLK(app));
-
- return &app->alloc.stats;
-}
-
-/******************************************************************************/
-#if BLD_FEATURE_ALLOC_STATS
-
-MprSlabStats *mprGetSlabAllocStats(MprApp *app, int slabIndex)
-{
- MprSlab *slab;
-
- mprAssert(VALID_BLK(app));
-
- if (0 <= slabIndex && slabIndex < MPR_MAX_SLAB) {
- slab = &app->alloc.slabs[slabIndex];
- return &slab->stats;
- }
-
- mprAssert(0 <= slabIndex && slabIndex < MPR_MAX_SLAB);
- return 0;
-}
-
-#endif /* BLD_FEATURE_ALLOC_STATS */
-/******************************************************************************/
-#if BLD_DEBUG
-
-int mprPrintAllocBlocks(MprCtx ptr, int indent)
-{
- MprBlk *bp, *firstChild, *cp;
- const char *location;
- int subTotal, size, indentSpaces, code;
-
- subTotal = 0;
-
- bp = GET_HDR(ptr);
-
- if (! (bp->flags & ALLOC_FLAGS_REQUIRED)) {
- size = bp->size + HDR_SIZE;
-
- /*
- * Take one level off because we don't trace app
- */
- indentSpaces = indent;
-
- if (bp->flags & ALLOC_FLAGS_REQUIRED) {
- code = 'R';
- } else if (bp->flags & ALLOC_FLAGS_IS_SLAB) {
- code = 'S';
- } else {
- code = ' ';
- }
-
-#if BLD_FEATURE_ALLOC_LEAK_TRACK
- location = bp->location;
-#else
- location = "";
-#endif
- mprLog(bp->app, 0,
- "%c %.*s %-16s %.*s size %5d has %3d deps, total %6d", code,
- indentSpaces, " ",
- mprGetBaseName(location),
- 8 - indent, " ",
- size,
- mprGetAllocBlockCount(GET_PTR(bp)),
- mprGetAllocBlockMemory(GET_PTR(bp))
- /* (uint) bp */
- );
-
- subTotal += size;
- }
-
- if ((firstChild = bp->children) != 0) {
- cp = firstChild;
- do {
- subTotal += mprPrintAllocBlocks(GET_PTR(cp), indent + 2);
- cp = cp->next;
- } while (cp != firstChild);
- }
-
- return subTotal;
-}
-
-#endif
-/******************************************************************************/
-#if BLD_FEATURE_ALLOC_STATS
-/*
- * Print a memory allocation report that includes a list of allocated blocks
- * and a statistics summary
- */
-
-void mprPrintAllocReport(MprApp *app, bool printBlocks, const char *msg)
-{
- MprSlabStats *stats;
- uint total;
- int i, size;
-
- mprAssert(VALID_BLK(app));
-
- if (msg) {
- mprLog(app, 0, " ");
- mprLog(app, 0, "%s", msg);
- }
-
-#if BLD_DEBUG
- /*
- * Do block stats
- */
- if (printBlocks) {
- int sum;
- mprLog(app, 0, " ");
- sum = mprPrintAllocBlocks(app, 0);
- if (sum) {
- mprLog(app, 0, " Sum of blocks %d", sum);
- } else {
- mprLog(app, 0, " None");
- }
- }
-#endif
-
- /*
- * Do Slab stats
- */
- mprLog(app, 0, " ");
- mprLog(app, 0, "MPR Slab Memory Stats");
- mprLog(app, 0, " ");
-
- mprLog(app, 0,
- " Index Size Total Allocated Free PeakAlloc PeakFree TotalAlloc");
-
- total = 0;
- for (i = 0; i < MPR_MAX_SLAB; i++) {
- stats = &app->alloc.slabs[i].stats;
- size = 1 << (i + 5);
- if (stats->totalAllocCount > 0) {
- mprLog(app, 0, " %2d %6d %8d %9d %6d %9d %8d %10d",
- i, size, size * (stats->allocCount + stats->freeCount),
- stats->allocCount, stats->freeCount,
- stats->peakAllocCount, stats->peakFreeCount,
- stats->totalAllocCount);
- total += size * (stats->allocCount + stats->freeCount);
- }
- }
- mprLog(app, 0, " ");
- mprLog(app, 0, "MPR Total Allocated Slab RAM: %10d", total);
- mprLog(app, 0, "MPR Total Allocated RAM: %10d",
- mprGetAllocatedMemory(app));
- mprLog(app, 0, "MPR Peak Allocated RAM: %10d",
- mprGetPeakAllocatedMemory(app));
- mprLog(app, 0, " ");
-}
-
-/******************************************************************************/
-/*
- * Return the total memory allocated.
- */
-
-uint mprGetAllocatedMemory(MprCtx ctx)
-{
- MprApp *app;
-
- app = mprGetApp(ctx);
-
- return app->alloc.stats.bytesAllocated;
-}
-
-/******************************************************************************/
-/*
- * Return the peak memory allocated.
- */
-
-uint mprGetPeakAllocatedMemory(MprCtx ctx)
-{
- MprApp *app;
-
- app = mprGetApp(ctx);
-
- return app->alloc.stats.peakAllocated;
-}
-
-/******************************************************************************/
-/*
- * Return memory in the MPR slab. This excludes the EJS slabs
- */
-
-uint mprGetAllocatedSlabMemory(MprCtx ctx)
-{
- MprApp *app;
- MprSlabStats *stats;
- uint total;
- int i, size;
-
- app = mprGetApp(ctx);
-
- total = 0;
- for (i = 0; i < MPR_MAX_SLAB; i++) {
- stats = &app->alloc.slabs[i].stats;
- size = 1 << (i + 5);
- if (stats->totalAllocCount > 0) {
- total += size * (stats->allocCount + stats->freeCount);
- }
- }
- return total;
-}
-
-#endif /* BLD_FEATURE_ALLOC_STATS */
-/******************************************************************************/
-
-MprDestructor mprSetDestructor(MprCtx ptr, MprDestructor destructor)
-{
- MprDestructor old;
- MprBlk *bp;
-
- mprAssert(VALID_BLK(ptr));
-
- if (ptr == 0) {
- return 0;
- }
-
- bp = GET_HDR(ptr);
-
- mprAssert(bp);
- mprAssert(VALID_HDR(bp));
- mprAssert(ptr != mprGetAllocParent(ptr));
-
- CHECK_HDR(bp);
-
- old = bp->destructor;
- bp->destructor = destructor;
-
- return old;
-}
-
-/******************************************************************************/
-
-int mprIsAllocBlockValid(MprCtx ptr)
-{
- MprBlk *bp;
-
- bp = GET_HDR(ptr);
- return (bp && VALID_HDR(bp));
-}
-
-/******************************************************************************/
-#if VALIDATE_ALLOC
-/*
- * Exhaustive validation of the block and its children. Does not go recursive
- * as it would be too slow.
- */
-
-int mprValidateBlock(MprCtx ptr)
-{
- MprBlk *bp, *parent, *cp, *firstChild;
- int count;
-
- mprAssert(ptr);
- mprAssert(VALID_BLK(ptr));
-
- bp = GET_HDR(ptr);
-
- mprAssert(bp);
- mprAssert(VALID_HDR(bp));
- mprAssert(VALID_HDR(bp->parent));
-
- if (ptr != bp->app) {
- mprAssert(bp != bp->parent);
- }
- mprAssert(! (bp->flags & ALLOC_FLAGS_FREE));
- mprAssert(! (bp->flags & ALLOC_FLAGS_FREEING));
-
- /*
- *
- */
- count = 0;
- parent = bp->parent;
-
- if ((firstChild = bp->children) != 0) {
- cp = firstChild;
- mprAssert((int) cp != 0xfeefee);
- do {
- mprAssert(bp->next->prev == bp);
- mprAssert(bp->prev->next == bp);
- mprAssert(bp->prev->parent == parent);
- mprAssert(bp->next->parent == parent);
-
- count++;
- cp = cp->next;
-
- if (bp->next == bp) {
- mprAssert(bp->prev == bp);
- if (ptr != bp->app) {
- mprAssert(parent->children == bp);
- }
- }
- if (bp->prev == bp) {
- mprAssert(bp->next == bp);
- if (ptr != bp->app) {
- mprAssert(parent->children == bp);
- }
- }
- } while (cp != firstChild);
- }
-
- return 0;
-}
-
-#endif
-/******************************************************************************/
-/*
- * Validate a block and all children
- */
-
-int mprValidateAllocTree(MprCtx ptr)
-{
-#if VALIDATE_ALLOC
- MprBlk *bp, *cp, *firstChild;
-
- mprAssert(ptr);
- mprAssert(VALID_BLK(ptr));
-
- bp = GET_HDR(ptr);
-
- mprValidateBlock(GET_PTR(bp));
-
- if ((firstChild = bp->children) != 0) {
- cp = firstChild;
- do {
- mprValidateAllocTree(GET_PTR(cp));
- cp = cp->next;
- } while (cp != firstChild);
- }
-
-#endif
- return 0;
-}
-
-/******************************************************************************/
-#if UNUSED && FUTURE
-/*
- * Exhaustive validation of the block and its children. Does not go recursive
- * as it would be too slow.
- */
-
-int mprValidateSlabs(MprApp *app)
-{
- MprSlab *slab;
- MprSlabStats *slabStats;
- MprSlabBlock *sp;
- int count, i;
-
- for (i = 0; i < MPR_MAX_SLAB; i++) {
- slab = &app->alloc.slabs[i];
- slabStats = &slab->stats;
-
- count = 0;
- for (sp = slab->next; sp; sp = sp->next) {
- count++;
- }
- mprAssert(count == (int) slabStats->freeCount);
- }
- return 0;
-}
-
-#endif
-/******************************************************************************/
-
-void mprAllocAbort()
-{
-#if BREW
- printf("Bad block header");
-#else
- exit(255);
-#endif
-}
-
-/******************************************************************************/
-#undef mprGetApp
-/*
- * Get the root parent from any block (which is the MprApp structure)
- */
-
-MprApp *mprGetApp(MprCtx ptr)
-{
- MprBlk *bp;
-
- mprAssert(ptr);
-
- bp = GET_HDR(ptr);
- mprAssert(VALID_HDR(bp));
-
- CHECK_HDR(bp);
-
- mprAssert(bp->app->magic == APP_MAGIC);
-
- return bp->app;
-}
-
-/******************************************************************************/
-
-int mprGetAllocErrors(MprCtx ctx)
-{
- MprApp *app;
-
- app = mprGetApp(ctx);
- return app->alloc.stats.errors;
-}
-
-/******************************************************************************/
-
-void mprClearAllocErrors(MprCtx ctx)
-{
- MprApp *app;
-
- app = mprGetApp(ctx);
- app->alloc.stats.errors = 0;
-}
-
-/******************************************************************************/
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/**
- * @file mprArray.c
- * @brief Growable array structure
- * @overview Simple growable array structure.
- * @remarks Most routines in this file are not thread-safe. It is the callers
- * responsibility to perform all thread synchronization.
- */
-
-/*
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-
-/********************************** Includes **********************************/
-
-#include "mpr.h"
-
-/******************************************************************************/
-/*
- * Create a general growable array structure. Use mprFree to destroy.
- */
-
-MprArray *mprCreateItemArrayInternal(MPR_LOC_DEC(ctx, loc), int initialSize,
- int maxSize)
-{
- MprArray *array;
- int size;
-
- mprAssert(initialSize <= maxSize);
-
- array = (MprArray*) mprSlabAllocZeroedBlock(MPR_LOC_PASS(ctx, loc),
- sizeof(MprArray), 0);
- if (array == 0) {
- return 0;
- }
-
- if (initialSize == 0) {
- initialSize = MPR_ARRAY_INCR;
- }
- if (maxSize == 0) {
- maxSize = MAXINT;
- }
- size = initialSize * sizeof(void*);
-
- array->items = (void**) mprSlabAllocBlock(MPR_LOC_PASS(array, loc),
- size, 0);
-
- if (array->items == 0) {
- mprFree(array);
- return 0;
- }
-
- array->capacity = initialSize;
- array->maxSize = maxSize;
- array->incr = min(initialSize * 2, (array->maxSize - array->length));
- array->length = 0;
-
- return array;
-}
-
-/******************************************************************************/
-/*
- * Add an item to the array
- */
-
-int mprAddItem(MprArray *array, void *item)
-{
- int memsize, index, len;
-
- mprAssert(array);
- mprAssert(array->capacity >= 0);
- mprAssert(array->length >= 0);
-
- if (array->length < array->capacity) {
- /*
- * Room to fit in the current capacity
- */
- index = array->length++;
- array->items[index] = item;
- return index;
- }
- mprAssert(array->length == array->capacity);
-
- /*
- * Need to grow the array
- */
- if (array->capacity >= array->maxSize) {
- mprAssert(array->capacity < array->maxSize);
- return MPR_ERR_TOO_MANY;
- }
-
- len = array->capacity + array->incr;
- memsize = len * sizeof(void*);
-
- /*
- * Grow the array of items
- */
-
- array->items = (void**) mprRealloc(array, array->items, memsize);
-
- /*
- * Zero the new portion
- */
- memset(&array->items[array->capacity], 0, sizeof(void*) * array->incr);
- array->capacity = len;
-
- array->incr = min(array->incr * 2, (array->maxSize - array->length));
-
- index = array->length++;
- array->items[index] = item;
-
- return index;
-}
-
-/******************************************************************************/
-/*
- * Remove an item from the array
- */
-
-int mprRemoveItem(MprArray *array, void *item)
-{
- int index;
-
- mprAssert(array);
- mprAssert(array->capacity > 0);
- mprAssert(array->length > 0);
-
- index = mprFindItem(array, item);
- if (index < 0) {
- return index;
- }
-
- return mprRemoveItemByIndex(array, index);
-}
-
-/******************************************************************************/
-/*
- * Remove an index from the array
- */
-
-int mprRemoveItemByIndex(MprArray *array, int index)
-{
- void **items;
- int i;
-
- mprAssert(array);
- mprAssert(array->capacity > 0);
- mprAssert(index >= 0 && index < array->capacity);
- mprAssert(array->items[index] != 0);
- mprAssert(array->length > 0);
-
- if (index < 0 || index >= array->length) {
- return MPR_ERR_NOT_FOUND;
- }
-
- /*
- * Copy down to compress
- */
- items = array->items;
- for (i = index; i < (array->length - 1); i++) {
- items[i] = items[i + 1];
- }
- array->length--;
-
-#if BLD_DEBUG
- if (array->length < array->capacity) {
- items[array->length] = 0;
- }
-#endif
- return 0;
-}
-
-/******************************************************************************/
-
-int mprRemoveRangeOfItems(MprArray *array, int start, int end)
-{
- void **items;
- int i, count;
-
- mprAssert(array);
- mprAssert(array->capacity > 0);
- mprAssert(array->length > 0);
- mprAssert(start > end);
-
- if (start < 0 || start >= array->length) {
- return MPR_ERR_NOT_FOUND;
- }
- if (end < 0 || end >= array->length) {
- return MPR_ERR_NOT_FOUND;
- }
- if (start > end) {
- return MPR_ERR_BAD_ARGS;
- }
-
- /*
- * Copy down to compress
- */
- items = array->items;
- count = end - start;
- for (i = start; i < (array->length - count); i++) {
- items[i] = items[i + count];
- }
- array->length -= count;
-
-#if BLD_DEBUG
- if (array->length < array->capacity) {
- for (i = array->length; i < array->capacity; i++) {
- items[i] = 0;
- }
- }
-#endif
- return 0;
-}
-
-/******************************************************************************/
-
-void *mprGetItem(MprArray *array, int index)
-{
- mprAssert(array);
-
- if (index < 0 || index >= array->length) {
- return 0;
- }
- return array->items[index];
-}
-
-/******************************************************************************/
-
-void *mprGetFirstItem(MprArray *array, int *last)
-{
- mprAssert(array);
- mprAssert(last);
-
- if (array == 0) {
- return 0;
- }
-
- *last = 0;
-
- if (array->length == 0) {
- return 0;
- }
- return array->items[0];
-}
-
-/******************************************************************************/
-
-void *mprGetNextItem(MprArray *array, int *last)
-{
- int index;
-
- mprAssert(array);
- mprAssert(last);
- mprAssert(*last >= 0);
-
- index = *last;
-
- if (++index < array->length) {
- *last = index;
- return array->items[index];
- }
- return 0;
-}
-
-/******************************************************************************/
-
-void *mprGetPrevItem(MprArray *array, int *last)
-{
- int index;
-
- mprAssert(array);
- mprAssert(last);
- mprAssert(*last >= 0);
-
- if (array == 0) {
- return 0;
- }
-
- index = *last;
-
- if (--index < array->length && index >= 0) {
- *last = index;
- return array->items[index];
- }
- return 0;
-}
-
-/******************************************************************************/
-
-int mprGetItemCount(MprArray *array)
-{
- mprAssert(array);
-
- if (array == 0) {
- return 0;
- }
-
- return array->length;
-}
-
-/******************************************************************************/
-
-int mprGetItemCapacity(MprArray *array)
-{
- mprAssert(array);
-
- if (array == 0) {
- return 0;
- }
-
- return array->capacity;
-}
-
-/******************************************************************************/
-
-void mprClearAndFreeItems(MprArray *array)
-{
- int i;
-
- mprAssert(array);
-
- for (i = 0; i < array->length; i++) {
- mprFree(array->items[i]);
- }
-}
-
-/******************************************************************************/
-
-void mprClearItems(MprArray *array)
-{
- mprAssert(array);
-
- array->length = 0;
-}
-
-/******************************************************************************/
-
-int mprFindItem(MprArray *array, void *item)
-{
- int i;
-
- mprAssert(array);
-
- for (i = 0; i < array->length; i++) {
- if (array->items[i] == item) {
- return i;
- }
- }
- return MPR_ERR_NOT_FOUND;
-}
-
-/******************************************************************************/
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/**
- * @file mprBuf.c
- * @brief Dynamic buffer module
- * @overview
- * @remarks
- */
-
-/******************************************************************************/
-/*
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-
-
-/********************************** Includes **********************************/
-
-#include "mpr.h"
-
-/**************************** Forward Declarations ****************************/
-
-static int grow(MprBuf *bp);
-
-/*********************************** Code *************************************/
-/*
- * Create a new buffer. "maxsize" is the limit to which the buffer can
- * ever grow. -1 means no limit. The buffer can ever only fix maxsize-1 bytes.
- * "initialSize" is used to define the amount to increase the size of the
- * buffer each time if it becomes full. (Note: grow() will exponentially
- * increase this number for performance.)
- */
-
-MprBuf *mprCreateBuf(MprCtx ctx, int initialSize, int maxSize)
-{
- MprBuf *bp;
-
- if (initialSize <= 0) {
- initialSize = MPR_DEFAULT_ALLOC;
- }
- bp = mprAllocTypeZeroed(ctx, MprBuf);
- bp->growBy = MPR_BUFSIZE;
- bp->maxsize = 0;
- mprSetBufSize(bp, initialSize, maxSize);
- return bp;
-}
-
-/******************************************************************************/
-/*
- * Set the initial buffer parameters and create the first buffer
- */
-
-void mprSetBufSize(MprBuf *bp, int initialSize, int max)
-{
- mprAssert(initialSize > 0);
-
- if (max > 0 && initialSize > max) {
- initialSize = max;
- }
-
- if (bp->buf && bp->growBy > 0) {
- mprFree(bp->buf);
- }
-
- bp->buf = (uchar*) mprAlloc(bp, initialSize);
- bp->growBy = initialSize;
- bp->maxsize = max;
- bp->buflen = initialSize;
- bp->endbuf = &bp->buf[bp->buflen];
- bp->start = bp->buf;
- bp->end = bp->buf;
- *bp->start = '\0';
-}
-
-/******************************************************************************/
-
-char *mprStealBuf(MprCtx ctx, MprBuf *bp)
-{
- char *str;
-
- str = (char*) bp->start;
-
- mprStealAllocBlock(MPR_LOC_ARGS(ctx), bp->start);
-
- bp->start = bp->end = bp->buf = bp->endbuf = 0;
- bp->buflen = 0;
-
- return str;
-}
-
-/******************************************************************************/
-
-void mprAddNullToBuf(MprBuf *bp)
-{
- *((char*) bp->end) = (char) '\0';
-}
-
-/******************************************************************************/
-
-void mprAdjustBufEnd(MprBuf *bp, int size)
-{
- mprAssert(bp->buflen == (bp->endbuf - bp->buf));
- mprAssert(size < bp->buflen);
-
- bp->end += size;
- if (bp->end >= bp->endbuf) {
- bp->end -= bp->buflen;
- }
- if (bp->end < bp->buf) {
- bp->end += bp->buflen;
- }
-
- if (bp->end >= bp->endbuf) {
- mprAssert(bp->end < bp->endbuf);
- mprFlushBuf(bp);
- }
-}
-
-/******************************************************************************/
-/*
- * Adjust the start pointer after a user copy
- */
-
-void mprAdjustBufStart(MprBuf *bp, int size)
-{
- mprAssert(bp->buflen == (bp->endbuf - bp->buf));
- mprAssert(size < bp->buflen);
-
- bp->start += size;
- while (bp->start >= bp->endbuf) {
- bp->start -= bp->buflen;
- }
- while (bp->start < bp->buf) {
- bp->start += bp->buflen;
- }
-
- /*
- * Flush the buffer if the start pointer is corrupted via a bad size
- */
- if (bp->start >= bp->endbuf) {
- mprAssert(bp->start < bp->endbuf);
- mprFlushBuf(bp);
- }
-}
-
-
-/******************************************************************************/
-
-void mprFlushBuf(MprBuf *bp)
-{
- bp->start = bp->buf;
- bp->end = bp->buf;
-}
-
-/******************************************************************************/
-
-int mprGetCharFromBuf(MprBuf *bp)
-{
- int c;
-
- if (bp->start == bp->end) {
- return -1;
- }
- c = (uchar) *bp->start++;
- if (bp->start >= bp->endbuf) {
- bp->start = bp->buf;
- }
- return c;
-}
-
-/******************************************************************************/
-
-int mprGetBlockFromBuf(MprBuf *bp, uchar *buf, int size)
-{
- int thisLen, bytesRead;
-
- mprAssert(buf);
- mprAssert(size > 0);
- mprAssert(bp->buflen == (bp->endbuf - bp->buf));
-
- /*
- * Get the max bytes in a straight copy
- */
- bytesRead = 0;
- while (size > 0) {
- thisLen = mprGetBufLinearData(bp);
- thisLen = min(thisLen, size);
- if (thisLen <= 0) {
- break;
- }
-
- memcpy(buf, bp->start, thisLen);
- buf += thisLen;
- bp->start += thisLen;
- size -= thisLen;
- bytesRead += thisLen;
-
- if (bp->start >= bp->endbuf) {
- bp->start = bp->buf;
- }
- }
- return bytesRead;
-}
-
-/******************************************************************************/
-
-int mprGetBufLength(MprBuf *bp)
-{
- if (bp->start > bp->end) {
- return (bp->buflen + (bp->end - bp->start));
- } else {
- return (bp->end - bp->start);
- }
-}
-
-/******************************************************************************/
-
-int mprGetBufLinearData(MprBuf *bp)
-{
- return min(mprGetBufLength(bp), (bp->endbuf - bp->start));
-}
-
-/******************************************************************************/
-
-int mprGetBufLinearSpace(MprBuf *bp)
-{
- int len = mprGetBufLength(bp);
- int space = bp->buflen - len - 1;
- return min((bp->endbuf - bp->end), space);
-}
-
-/******************************************************************************/
-
-int mprGetBufSize(MprBuf *bp)
-{
- return bp->buflen;
-}
-
-/******************************************************************************/
-
-int mprGetBufSpace(MprBuf *bp)
-{
- return bp->buflen - mprGetBufLength(bp) - 1;
-}
-
-/******************************************************************************/
-
-char *mprGetBufOrigin(MprBuf *bp)
-{
- return (char*) bp->buf;
-}
-
-/******************************************************************************/
-
-char *mprGetBufStart(MprBuf *bp)
-{
- return (char*) bp->start;
-}
-
-/******************************************************************************/
-
-char *mprGetBufEnd(MprBuf *bp)
-{
- return (char*) bp->end;
-}
-
-/******************************************************************************/
-
-int mprInsertCharToBuf(MprBuf *bp, int c)
-{
- char *cp;
- int space;
-
- mprAssert(bp->buflen == (bp->endbuf - bp->buf));
-
- space = bp->buflen - mprGetBufLength(bp) - 1;
- if (space < (int) sizeof(char)) {
- if (!grow(bp)) {
- return -1;
- }
- }
- if (bp->start <= bp->buf) {
- bp->start = bp->endbuf;
- }
- cp = (char*) bp->start;
- *--cp = (char) c;
- bp->start = (uchar *) cp;
- return 0;
-}
-
-/******************************************************************************/
-
-int mprLookAtNextCharInBuf(MprBuf *bp)
-{
- if (bp->start == bp->end) {
- return -1;
- }
- return *bp->start;
-}
-
-/******************************************************************************/
-
-int mprLookAtLastCharInBuf(MprBuf *bp)
-{
- if (bp->start == bp->end) {
- return -1;
- }
- return (bp->end == bp->buf) ? bp->endbuf[-1] : bp->end[-1];
-}
-
-/******************************************************************************/
-
-int mprPutCharToBuf(MprBuf *bp, int c)
-{
- char *cp;
- int space;
-
- mprAssert(bp->buflen == (bp->endbuf - bp->buf));
-
- space = bp->buflen - mprGetBufLength(bp) - 1;
- if (space < (int) sizeof(char)) {
- if (! grow(bp)) {
- return -1;
- }
- }
-
- cp = (char*) bp->end;
- *cp++ = (char) c;
- bp->end = (uchar *) cp;
- if (bp->end >= bp->endbuf) {
- bp->end = bp->buf;
- }
- *((char*) bp->end) = (char) '\0';
- return 0;
-}
-
-/******************************************************************************/
-
-int mprPutBlockToBuf(MprBuf *bp, const char *str, int size)
-{
- int thisLen, bytes, space;
-
- mprAssert(str);
- mprAssert(size >= 0);
- mprAssert(bp->buflen == (bp->endbuf - bp->buf));
-
- /*
- * Add the max we can in one copy
- */
- bytes = 0;
- while (size > 0) {
- space = mprGetBufLinearSpace(bp);
- thisLen = min(space, size);
- if (thisLen <= 0) {
- if (! grow(bp)) {
- break;
- }
- space = mprGetBufLinearSpace(bp);
- thisLen = min(space, size);
- }
-
- memcpy(bp->end, str, thisLen);
- str += thisLen;
- bp->end += thisLen;
- size -= thisLen;
- bytes += thisLen;
-
- if (bp->end >= bp->endbuf) {
- bp->end = bp->buf;
- }
- }
- *((char*) bp->end) = (char) '\0';
- return bytes;
-}
-
-/******************************************************************************/
-
-int mprPutStringToBuf(MprBuf *bp, const char *str)
-{
- return mprPutBlockToBuf(bp, str, strlen(str));
-}
-
-/******************************************************************************/
-
-int mprPutFmtStringToBuf(MprBuf *bp, const char *fmt, ...)
-{
- va_list ap;
- char *buf;
- int rc, len, space;
-
- va_start(ap, fmt);
- space = mprGetBufLinearSpace(bp);
-
- /*
- * Add max that the buffer can grow
- */
- space += (bp->maxsize - bp->buflen - 1);
-
- len = mprAllocVsprintf(MPR_LOC_ARGS(bp), &buf, space, fmt, ap);
- rc = mprPutBlockToBuf(bp, buf, len);
-
- mprFree(buf);
- va_end(ap);
- return rc;
-}
-
-/******************************************************************************/
-/*
- * Grow the buffer to fit new data. Return 1 if the buffer can grow.
- * Grow using the growBy size specified when creating the buffer.
- */
-
-static int grow(MprBuf *bp)
-{
- uchar *newbuf;
-
- if (bp->maxsize > 0 && bp->buflen >= bp->maxsize) {
- return 0;
- }
-
- newbuf = (uchar*) mprAlloc(bp, bp->buflen + bp->growBy);
- if (bp->buf) {
- memcpy(newbuf, bp->buf, bp->buflen);
- mprFree(bp->buf);
- }
-
- bp->buflen += bp->growBy;
- bp->end = newbuf + (bp->end - bp->buf);
- bp->start = newbuf + (bp->start - bp->buf);
- bp->buf = newbuf;
- bp->endbuf = &bp->buf[bp->buflen];
-
- /*
- * Increase growBy to reduce overhead
- */
- bp->growBy *= 2;
- if (bp->maxsize > 0 && (bp->buflen + bp->growBy) > bp->maxsize) {
- bp->growBy = bp->maxsize - bp->buflen;
- }
- return 1;
-}
-
-/******************************************************************************/
-/*
- * Add a number to the buffer (always null terminated).
- */
-
-int mprPutIntToBuf(MprBuf *bp, int i)
-{
- char numBuf[16];
- int rc;
-
- mprItoa(numBuf, sizeof(numBuf), i);
- rc = mprPutStringToBuf(bp, numBuf);
- *((char*) bp->end) = (char) '\0';
-
- return rc;
-}
-
-/******************************************************************************/
-
-void mprCopyBufDown(MprBuf *bp)
-{
- if (mprGetBufLength(bp) == 0) {
- mprFlushBuf(bp);
- return;
- }
- memmove(bp->buf, bp->start, (bp->end - bp->start));
- bp->end -= (bp->start - bp->buf);
- bp->start = bp->buf;
-}
-
-/******************************************************************************/
-
-MprBufProc mprGetBufRefillProc(MprBuf *bp)
-{
- return bp->refillProc;
-}
-
-/******************************************************************************/
-
-void mprSetBufRefillProc(MprBuf *bp, MprBufProc fn, void *arg)
-{
- bp->refillProc = fn;
- bp->refillArg = arg;
-}
-
-/******************************************************************************/
-
-int mprRefillBuf(MprBuf *bp)
-{
- return (bp->refillProc) ? (bp->refillProc)(bp, bp->refillArg) : 0;
-}
-
-/******************************************************************************/
-
-void mprResetBufIfEmpty(MprBuf *bp)
-{
- if (mprGetBufLength(bp) == 0) {
- mprFlushBuf(bp);
- }
-}
-
-/******************************************************************************/
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/**
- * @file mprGenFile.c
- * @brief Generic File services
- * @overview
- * @remarks
- * See OS/mprFile.c for the per O/S portions
- */
-
-/******************************************************************************/
-/*
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-
-/********************************** Includes **********************************/
-
-#include "mpr.h"
-
-/****************************** Forward Declarations **************************/
-#if !BREW
-
-static int closeDestructor(void *data);
-
-/************************************ Code ************************************/
-
-int mprStartFileServices(MprCtx ctx)
-{
- MprApp *app;
-
- app = mprGetApp(ctx);
- app->console = mprAllocTypeZeroed(ctx, MprFile);
- app->error = mprAllocTypeZeroed(ctx, MprFile);
-
- /*
- * We assume that STDOUT is 1 and STDERR is 2
- */
- app->console->fd = 1;
- app->error->fd = 2;
-
- return 0;
-}
-
-/******************************************************************************/
-
-void mprStopFileServices(MprCtx ctx)
-{
- MprApp *app;
-
- app = mprGetApp(ctx);
-
- mprFree(app->console);
- app->console = 0;
- mprFree(app->error);
- app->error = 0;
-}
-
-/******************************************************************************/
-
-MprFile *mprOpen(MprCtx ctx, const char *path, int omode, int perms)
-{
- MprFile *file;
-
- mprAssert(path && *path);
-
- file = mprAllocTypeZeroed(ctx, MprFile);
-
- file->fd = open(path, omode, perms);
- if (file->fd < 0) {
- mprFree(file);
- return 0;
- }
-
- mprSetDestructor(file, closeDestructor);
- return file;
-}
-
-/******************************************************************************/
-
-static int closeDestructor(void *data)
-{
- MprFile *file = (MprFile*) data;
-
- mprAssert(file);
-
- mprClose(file);
- return 0;
-}
-
-/******************************************************************************/
-
-void mprClose(MprFile *file)
-{
- mprAssert(file);
-
- if (file < 0) {
- return;
- }
-
- mprAssert(file->fd >= 0);
- close(file->fd);
-
- mprSetDestructor(file, 0);
- mprFree(file);
-}
-
-/******************************************************************************/
-
-int mprRead(MprFile *file, void *buf, uint size)
-{
- mprAssert(file);
-
- if (file == 0) {
- return MPR_ERR_BAD_HANDLE;
- }
-
- return read(file->fd, buf, size);
-}
-
-/******************************************************************************/
-
-int mprWrite(MprFile *file, const void *buf, uint count)
-{
- mprAssert(file);
-
- if (file == 0) {
- return MPR_ERR_BAD_HANDLE;
- }
-
- return write(file->fd, buf, count);
-}
-
-/******************************************************************************/
-
-int mprSeek(MprFile *file, int seekType, long distance)
-{
- mprAssert(file);
-
- if (file == 0) {
- return MPR_ERR_BAD_HANDLE;
- }
-
- return lseek(file->fd, seekType, distance);
-}
-
-/******************************************************************************/
-
-int mprDelete(MprCtx ctx, const char *path)
-{
- return unlink(path);
-}
-
-/******************************************************************************/
-
-int mprDeleteDir(MprCtx ctx, const char *path)
-{
- return rmdir(path);
-}
-
-#endif /* !BREW */
-/******************************************************************************/
-
-char *mprGets(MprFile *file, char *buf, uint size)
-{
- MprBuf *bp;
- int count, len, c;
-
- mprAssert(file);
-
- if (file == 0) {
- return 0;
- }
-
- if (file->buf == 0) {
- file->buf = mprCreateBuf(file, MPR_DEFAULT_ALLOC, MPR_MAX_STRING);
- }
- bp = file->buf;
-
- /*
- * Must leave room for null
- */
- count = 0;
- while (--size > 0) {
- if (mprGetBufLength(bp) == 0) {
- mprFlushBuf(bp);
- len = mprRead(file, mprGetBufEnd(bp),
- mprGetBufLinearSpace(bp));
- if (len <= 0) {
- return 0;
- }
- mprAdjustBufEnd(bp, len);
- mprAddNullToBuf(bp);
- }
- if ((c = mprGetCharFromBuf(bp)) == '\n') {
- buf[count] = '\0';
- return buf;
- }
- buf[count++] = c;
- }
- buf[count] = '\0';
- return buf;
-}
-
-/******************************************************************************/
-
-int mprPuts(MprFile *file, const char *writeBuf, uint count)
-{
- MprBuf *bp;
- char *buf;
- int total, bytes, len;
-
- mprAssert(file);
-
- /*
- * Buffer output and flush when full.
- */
- if (file->buf == 0) {
- file->buf = mprCreateBuf(file, MPR_BUFSIZE, 0);
- if (file->buf == 0) {
- return MPR_ERR_CANT_ALLOCATE;
- }
- }
- bp = file->buf;
-
- if (mprGetBufLength(bp) > 0 && mprGetBufSpace(bp) < (int) count) {
- len = mprGetBufLength(bp);
- if (mprWrite(file, mprGetBufStart(bp), len) != len) {
- return MPR_ERR_CANT_WRITE;
- }
- mprFlushBuf(bp);
- }
-
- total = 0;
- buf = (char*) writeBuf;
-
- while (count > 0) {
- bytes = mprPutBlockToBuf(bp, buf, count);
- if (bytes <= 0) {
- return MPR_ERR_CANT_ALLOCATE;
- }
- count -= bytes;
- buf += bytes;
- total += bytes;
- mprAddNullToBuf(bp);
-
- if (count > 0) {
- len = mprGetBufLength(bp);
- if (mprWrite(file, mprGetBufStart(bp), len) != len) {
- return MPR_ERR_CANT_WRITE;
- }
- mprFlushBuf(bp);
- }
- }
- return total;
-}
-
-/******************************************************************************/
-
-int mprMakeTempFileName(MprCtx ctx, char *buf, int bufsize, const char *tempDir)
-{
- MprFile *file;
- MprTime now;
- char *dir;
- int seed, i;
-
- if (tempDir == 0) {
-#if WIN
- char *cp;
- dir = mprStrdup(ctx, getenv("TEMP"));
- for (cp = dir; *cp; cp++) {
- if (*cp == '\\') {
- *cp = '/';
- }
- }
-#else
- dir = mprStrdup(ctx, "/tmp");
-#endif
- } else {
- dir = mprStrdup(ctx, tempDir);
- }
-
- mprGetTime(ctx, &now);
- seed = now.msec % 64000;
- file = 0;
-
- for (i = 0; i < 128; i++) {
- mprSprintf(buf, bufsize, "%s/MPR_%d_%d.tmp", dir, getpid(), seed++);
- file = mprOpen(ctx, buf, O_CREAT | O_EXCL | O_BINARY, 0664);
- if (file) {
- break;
- }
- }
-
- if (file == 0) {
- return MPR_ERR_CANT_CREATE;
- }
-
- mprClose(file);
- mprFree(dir);
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/**
- * @file mprGenTime.c
- * @brief Generic Time handling
- * @overview
- */
-
-/*
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-
-/********************************* Includes ***********************************/
-
-#include "mpr.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/******************************************************************************/
-/*
- * Return the number of milliseconds until the given timeout has expired.
- */
-
-int mprGetTimeRemaining(MprCtx ctx, MprTime mark, uint timeout)
-{
- MprTime now;
- uint diff;
-
- mprGetTime(ctx, &now);
- diff = ((now.sec - mark.sec) * 1000) + (now.msec - mark.msec);
-
- if (diff < 0) {
- /*
- * Detect time going backwards
- */
- mprAssert(diff >= 0);
- diff = 0;
- }
- return (int) (timeout - diff);
-}
-
-/******************************************************************************/
-/*
- * Return the number of milliseconds until the given timeout has expired.
- */
-
-int mprGetElapsedTime(MprCtx ctx, MprTime mark)
-{
- MprTime now;
-
- mprGetTime(ctx, &now);
- return ((now.sec - mark.sec) * 1000) + (now.msec - mark.msec);
-}
-
-/******************************************************************************/
-
-void mprAddElapsedToTime(MprTime *time, uint elapsed)
-{
- time->sec += elapsed / 1000;
- time->msec += elapsed % 1000;
- if (time->msec > 1000) {
- time->msec -= 1000;
- time->sec++;
- }
-}
-
-/******************************************************************************/
-
-int mprCompareTime(MprTime *t1, MprTime *t2)
-{
- if (t1->sec < t2->sec) {
- return -1;
- } else if (t1->sec == t2->sec) {
- if (t1->msec < t2->msec) {
- return -1;
- } else if (t1->msec == t2->msec) {
- return 0;
- }
- }
- return 1;
-}
-
-/******************************************************************************/
-
-uint mprSubtractTime(MprTime *t1, MprTime *t2)
-{
- return ((t1->sec - t2->sec) * 1000) + (t1->msec - t2->msec);
-}
-
-/******************************************************************************/
-#if !BREW
-/*
- * Thread-safe RFC822 dates (Eg: "Fri, 07 Jan 2003 12:12:21 GMT")
- */
-
-int mprRfcTime(MprCtx ctx, char *buf, int bufsize, const struct tm *timep)
-{
- char months[12][4] = {
- "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep",
- "Oct", "Nov", "Dec"
- };
-
- char days[7][4] = {
- "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
- };
-
- char *dayp, *monthp;
- int year;
-
- if (bufsize < 30) {
- return MPR_ERR_WONT_FIT;
- }
- dayp = &days[timep->tm_wday][0];
- *buf++ = *dayp++;
- *buf++ = *dayp++;
- *buf++ = *dayp++;
- *buf++ = ',';
- *buf++ = ' ';
-
- *buf++ = timep->tm_mday / 10 + '0';
- *buf++ = timep->tm_mday % 10 + '0';
- *buf++ = ' ';
-
- monthp = &months[timep->tm_mon][0];
- *buf++ = *monthp++;
- *buf++ = *monthp++;
- *buf++ = *monthp++;
- *buf++ = ' ';
-
- year = 1900 + timep->tm_year;
- /* This routine isn't y10k ready. */
- *buf++ = year / 1000 + '0';
- *buf++ = year % 1000 / 100 + '0';
- *buf++ = year % 100 / 10 + '0';
- *buf++ = year % 10 + '0';
- *buf++ = ' ';
-
- *buf++ = timep->tm_hour / 10 + '0';
- *buf++ = timep->tm_hour % 10 + '0';
- *buf++ = ':';
- *buf++ = timep->tm_min / 10 + '0';
- *buf++ = timep->tm_min % 10 + '0';
- *buf++ = ':';
- *buf++ = timep->tm_sec / 10 + '0';
- *buf++ = timep->tm_sec % 10 + '0';
- *buf++ = ' ';
-
- *buf++ = 'G';
- *buf++ = 'M';
- *buf++ = 'T';
- *buf++ = 0;
- return 0;
-}
-
-#endif
-/******************************************************************************/
-
-#ifdef __cplusplus
-}
-#endif
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/**
- * @file mprThread.c
- * @brief Mbedthis Portable Runtime Base Thread Locking Support
- */
-
-/*
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-
-#include "mpr.h"
-
-#if BLD_FEATURE_MULTITHREAD
-/************************************ Code ************************************/
-
-void mprInitThreads(MprApp *app)
-{
- mprAssert(app);
-
- if (app->globalLock == 0) {
- app->globalLock = mprCreateLock(app);
- app->allocLock = mprCreateLock(app);
- }
-}
-
-/******************************************************************************/
-
-void mprTermThreads(MprApp *app)
-{
- mprAssert(app);
-
- if (app->globalLock) {
- mprDestroyLock(app->globalLock);
- app->globalLock = 0;
- }
- if (app->allocLock) {
- MprLock *lock = app->allocLock;
- app->allocLock = 0;
- mprDestroyLock(lock);
- }
-}
-
-/******************************************************************************/
-
-MprLock *mprCreateLock(MprCtx ctx)
-{
- MprLock *lock;
-
- mprAssert(ctx);
-
- lock = mprAllocType(ctx, MprLock);
-
-#if BLD_HOST_UNIX
- pthread_mutexattr_t attr;
-
- pthread_mutexattr_init(&attr);
- pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE_NP);
- pthread_mutex_init(&lock->cs, &attr);
- pthread_mutexattr_destroy(&attr);
-#elif WIN
- InitializeCriticalSectionAndSpinCount(&lock->cs, 5000);
-#elif VXWORKS
- lock->cs = semMCreate(SEM_Q_PRIORITY | SEM_DELETE_SAFE |
- SEM_INVERSION_SAFE);
- if (lock->cs == 0) {
- mprAssert(0);
- mprFree(lock);
- return 0;
- }
-#endif
- return lock;
-}
-
-/******************************************************************************/
-/*
- * Destroy a lock. Must be locked on entrance.
- */
-
-void mprDestroyLock(MprLock *lock)
-{
- mprAssert(lock);
- if (lock == 0) {
- return;
- }
-
-#if BLD_HOST_UNIX
- pthread_mutex_unlock(&lock->cs);
- pthread_mutex_destroy(&lock->cs);
-#elif WIN
- DeleteCriticalSection(&lock->cs);
-#elif VXWORKS
- semDelete(lock->cs);
-#endif
- mprFree(lock);
-}
-
-/******************************************************************************/
-/*
- * Lock a mutex
- */
-
-void mprLock(MprLock *lock)
-{
- /*
- * OPT -- Do this just so we can allocate MprApp before we have created its
- * lock. Should remove this test here and in mprUnlock.
- */
- if (lock == 0) {
- return;
- }
-
-#if BLD_HOST_UNIX
- pthread_mutex_lock(&lock->cs);
-#elif WIN
- EnterCriticalSection(&lock->cs);
-#elif VXWORKS
- semTake(lock->cs, WAIT_FOREVER);
-#endif
-}
-
-/******************************************************************************/
-/*
- * Try to attain a lock. Do not block!
- */
-
-int mprTryLock(MprLock *lock)
-{
- mprAssert(lock);
-
-#if BLD_HOST_UNIX
- {
- int err;
-
- if ((err = pthread_mutex_trylock(&lock->cs)) != 0) {
- if (err == EBUSY) {
- return MPR_ERR_BUSY;
- } else {
- return MPR_ERR_CANT_ACCESS;
- }
- }
- return 0;
- }
-#elif WIN
- if (TryEnterCriticalSection(&lock->cs) == 0) {
- return MPR_ERR_BUSY;
- }
-#elif VXWORKS
- {
- int rc;
-
- rc = semTake(cs, NO_WAIT);
- if (rc == -1) {
- mprAssert(0);
- }
- if (rc == S_objLib_OBJ_UNAVAILABLE) {
- return MPR_ERR_BUSY;
- } else {
- return MPR_ERR_CANT_ACCESS;
- }
- /* Success */
- return 0;
- }
-#endif
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Unlock.
- */
-
-void mprUnlock(MprLock *lock)
-{
- if (lock == 0) {
- return;
- }
-
-#if BLD_HOST_UNIX
- pthread_mutex_unlock(&lock->cs);
-#elif WIN
- LeaveCriticalSection(&lock->cs);
-#elif VXWORKS
- semGive(lock->cs);
-#endif
-}
-
-/******************************************************************************/
-/*
- * Big global lock. Avoid using this.
- */
-
-void mprGlobalLock(MprCtx ctx)
-{
- MprApp *app;
-
- app = mprGetApp(ctx);
- mprAssert(app);
-
- if (app && app->globalLock) {
- mprLock(app->globalLock);
- }
-}
-
-/******************************************************************************/
-
-void mprGlobalUnlock(MprCtx ctx)
-{
- MprApp *app;
-
- app = mprGetApp(ctx);
- mprAssert(app);
-
- if (app && app->globalLock) {
- mprUnlock(app->globalLock);
- }
-}
-
-/******************************************************************************/
-
-int mprGetCurrentThreadID()
-{
-#if BLD_HOST_UNIX
- return (int) pthread_self();
-#elif WIN
- return GetCurrentThreadId();
-#elif VXWORKS
- return (int) pthread_self();
-#endif
-}
-
-/******************************************************************************/
-#endif /* BLD_FEATURE_MULTITHREAD */
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/**
- * @file mprLog.c
- * @brief Mbedthis Portable Runtime (MPR) Logging and error reporting.
- * @remarks We always provide these routines.
- */
-
-/*********************************** License **********************************/
-/*
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-
-#include "mpr.h"
-
-/****************************** Forward Declarations **************************/
-
-static void defaultLogHandler(MPR_LOC_DEC(ctx, loc), int flags,
- int level, const char *msg);
-static void logOutput(MPR_LOC_DEC(ctx, loc), int flags, int level,
- const char *msg);
-
-/************************************ Code ************************************/
-
-void mprLog(MprCtx ctx, int level, const char *fmt, ...)
-{
- va_list args;
- char *buf;
-
- if (level > mprGetLogLevel(ctx)) {
- return;
- }
-
- va_start(args, fmt);
- mprAllocVsprintf(MPR_LOC_ARGS(ctx), &buf, 0, fmt, args);
- va_end(args);
-
- logOutput(MPR_LOC_ARGS(ctx), MPR_LOG_SRC, level, buf);
-
- va_end(args);
- mprFree(buf);
-}
-
-/*****************************************************************************/
-/*
- * Do raw output
- */
-
-void mprRawLog(MprCtx ctx, const char *fmt, ...)
-{
- va_list args;
- char *buf;
- int len;
-
- va_start(args, fmt);
- len = mprAllocVsprintf(MPR_LOC_ARGS(ctx), &buf, 0, fmt, args);
- va_end(args);
-
- logOutput(MPR_LOC_ARGS(ctx), MPR_RAW, 0, buf);
- mprFree(buf);
-}
-
-/*****************************************************************************/
-/*
- * Handle an error
- */
-
-void mprError(MPR_LOC_DEC(ctx, loc), const char *fmt, ...)
-{
- va_list args;
- char *buf;
- int len;
-
- va_start(args, fmt);
- len = mprAllocVsprintf(MPR_LOC_ARGS(ctx), &buf, 0, fmt, args);
- va_end(args);
-
- logOutput(MPR_LOC_PASS(ctx, loc), MPR_ERROR_MSG | MPR_ERROR_SRC, 0, buf);
-
- mprFree(buf);
-}
-
-/*****************************************************************************/
-/*
- * Handle an error that should be displayed to the user
- */
-
-void mprUserError(MPR_LOC_DEC(ctx, loc), const char *fmt, ...)
-{
- va_list args;
- char *buf;
- int len;
-
- va_start(args, fmt);
- len = mprAllocVsprintf(MPR_LOC_ARGS(ctx), &buf, 0, fmt, args);
- va_end(args);
-
- logOutput(MPR_LOC_PASS(ctx, loc), MPR_USER_MSG | MPR_ERROR_SRC, 0, buf);
-
- mprFree(buf);
-}
-
-/*****************************************************************************/
-/*
- * Handle a fatal error. Forcibly shutdown the application.
- */
-
-void mprFatalError(MPR_LOC_DEC(ctx, loc), const char *fmt, ...)
-{
- va_list args;
- char *buf;
- int len;
-
- va_start(args, fmt);
- len = mprAllocVsprintf(MPR_LOC_ARGS(ctx), &buf, 0, fmt, args);
- va_end(args);
-
- logOutput(MPR_LOC_PASS(ctx, loc), MPR_USER_MSG | MPR_FATAL_SRC, 0, buf);
-
- mprFree(buf);
-
-#if BREW
- mprSignalExit(ctx);
-#else
- exit(2);
-#endif
-}
-
-/*****************************************************************************/
-/*
- * Handle a program assertion
- */
-
-void mprAssertError(MPR_LOC_DEC(ctx, loc), const char *msg)
-{
- logOutput(MPR_LOC_PASS(ctx, loc), MPR_ASSERT_MSG | MPR_ASSERT_SRC, 0, msg);
-}
-
-/*****************************************************************************/
-/*
- * Handle an error
- */
-
-void mprStaticError(MPR_LOC_DEC(ctx, loc), const char *fmt, ...)
-{
- va_list args;
- int len;
- char buf[MPR_MAX_STRING];
-
- va_start(args, fmt);
- len = mprVsprintf(buf, sizeof(buf), fmt, args);
- va_end(args);
-
- logOutput(MPR_LOC_PASS(ctx, loc), MPR_ERROR_MSG | MPR_ERROR_SRC, 0, buf);
-}
-
-/*****************************************************************************/
-/*
- * Direct output to the standard output. Does not hook into the logging
- * system and does not allocate memory.
- */
-
-void mprStaticAssert(const char *loc, const char *msg)
-{
-#if BLD_DEBUG
- char buf[MPR_MAX_STRING];
- int len;
-
- len = mprSprintf(buf, sizeof(buf), "Assertion %s, failed at %s\n",
- msg, loc);
- mprBreakpoint(loc, buf);
-
-#if BLD_HOST_UNIX
- /*
- * MOB -- but is stdout always okay to use
- */
- write(1, buf, len);
-#elif BREW || WIN
- /*
- * Only time we use printf. We can't get an alloc context so we have
- * to use real print
- */
-#if BREW && !BREW_SIMULATOR
- printf(" MP: %s\n", buf);
-#else
- printf("%s\n", buf);
-#endif
-
-#endif
-#endif
-}
-
-/*****************************************************************************/
-
-int mprGetLogLevel(MprCtx ctx)
-{
- return mprGetApp(ctx)->logLevel;
-}
-
-/******************************************************************************/
-
-void mprSetLogLevel(MprCtx ctx, int level)
-{
- mprGetApp(ctx)->logLevel = level;
-}
-
-/*****************************************************************************/
-/*
- * Output a log message to the log handler
- */
-
-static void logOutput(MPR_LOC_DEC(ctx, loc), int flags, int level,
- const char *msg)
-{
- MprLogHandler handler;
-
- if (flags & (MPR_ERROR_SRC | MPR_FATAL_SRC | MPR_ASSERT_SRC)) {
- mprBreakpoint(MPR_LOC, 0);
- }
-
- mprAssert(ctx != 0);
- handler = mprGetApp(ctx)->logHandler;
- if (handler != 0) {
- (handler)(MPR_LOC_PASS(ctx, loc), flags, level, msg);
- return;
- }
- defaultLogHandler(MPR_LOC_PASS(ctx, loc), flags, level, msg);
-}
-
-/*****************************************************************************/
-/*
- * Default log output is just to the console
- */
-
-static void defaultLogHandler(MPR_LOC_DEC(ctx, loc), int flags,
- int level, const char *msg)
-{
- MprApp *app;
- char *prefix;
-
- app = mprGetApp(ctx);
- prefix = app->name;
-
- while (*msg == '\n') {
- mprPrintf(ctx, "\n");
- msg++;
- }
-
- if (flags & MPR_LOG_SRC) {
-#if BREW && !BREW_SIMULATOR
- mprPrintf(ctx, "%s\n", msg);
-#else
- mprPrintf(ctx, "%s: %d: %s\n", prefix, level, msg);
-#endif
-
- } else if (flags & MPR_ERROR_SRC) {
- /*
- * Use static printing to avoid malloc when the messages are small.
- * This is important for memory allocation errors.
- */
- if (strlen(msg) < (MPR_MAX_STRING - 32)) {
- mprStaticPrintf(ctx, "%s: Error: %s\n", prefix, msg);
- } else {
- mprPrintf(ctx, "%s: Error: %s\n", prefix, msg);
- }
-
- } else if (flags & MPR_FATAL_SRC) {
- mprPrintf(ctx, "%s: Fatal: %s\n", prefix, msg);
-
- } else if (flags & MPR_ASSERT_SRC) {
-#if BLD_FEATURE_ALLOC_LEAK_TRACK
- mprPrintf(ctx, "%s: Assertion %s, failed at %s\n", prefix, msg, loc);
-#else
- mprPrintf(ctx, "%s: Assertion %s, failed\n", prefix, msg);
-#endif
-
- } else if (flags & MPR_RAW) {
- mprPrintf(ctx, "%s", msg);
-
- } else {
- return;
- }
-}
-
-/*****************************************************************************/
-/*
- * Map the O/S error code to portable error codes.
- */
-
-int mprGetOsError()
-{
-#if WIN
- int rc;
- rc = GetLastError();
-
- /*
- * Client has closed the pipe
- */
- if (rc == ERROR_NO_DATA) {
- return EPIPE;
- }
- return rc;
-#endif
-#if LINUX || VXWORKS || SOLARIS
- return errno;
-#endif
-#if BREW
- /*
- * No such thing on Brew. Errors are per class
- */
- return 0;
-#endif
-}
-
-/******************************************************************************/
-#if UNUSED
-
-const char *mprGetErrorMsg(int err)
-{
- /*
- * MPR error messages. Declare here so we don't have any globals.
- */
- char *mprErrMessages[] = {
- /* 0 MPR_ERR_OK */ "Success",
- /* -201 MPR_ERR_GENERAL */ "General error",
- /* -202 MPR_ERR_ABORTED */ "Aborted",
- /* -203 MPR_ERR_ALREADY_EXISTS */ "Already exists",
- /* -204 MPR_ERR_BAD_ARGS */ "Bad args",
- /* -205 MPR_ERR_BAD_FORMAT */ "Bad format",
- /* -206 MPR_ERR_BAD_HANDLE */ "Bad handle",
- /* -207 MPR_ERR_BAD_STATE */ "Bad state",
- /* -208 MPR_ERR_BAD_SYNTAX */ "Bad syntax",
- /* -209 MPR_ERR_BAD_TYPE */ "Bad type",
- /* -210 MPR_ERR_BAD_VALUE */ "Bad value",
- /* -211 MPR_ERR_BUSY */ "Busy",
- /* -212 MPR_ERR_CANT_ACCESS */ "Can't access",
- /* -213 MPR_ERR_CANT_COMPLETE */ "Can't complete",
- /* -214 MPR_ERR_CANT_CREATE */ "Can't create",
- /* -215 MPR_ERR_CANT_INITIALIZE */ "Can't initialize",
- /* -216 MPR_ERR_CANT_OPEN */ "Can't open",
- /* -217 MPR_ERR_CANT_READ */ "Can't read",
- /* -218 MPR_ERR_CANT_WRITE */ "Can't write",
- /* -219 MPR_ERR_DELETED */ "Already deleted",
- /* -220 MPR_ERR_NETWORK */ "Network error",
- /* -221 MPR_ERR_NOT_FOUND */ "Not found",
- /* -222 MPR_ERR_NOT_INITIALIZED */ "Not initialized",
- /* -223 MPR_ERR_NOT_READY */ "Not ready",
- /* -224 MPR_ERR_READ_ONLY */ "Read only",
- /* -225 MPR_ERR_TIMEOUT */ "Timeout",
- /* -226 MPR_ERR_TOO_MANY */ "Too many",
- /* -227 MPR_ERR_WONT_FIT */ "Won't fit",
- /* -228 MPR_ERR_WOULD_BLOCK */ "Would block",
- /* -229 MPR_ERR_CANT_ALLOCATE */ "Can't allocate",
- };
- int mprNumErr = sizeof(mprErrMessages) / sizeof(char*);
-
-/*
- * Operating system error messages
- */
-#if WIN
-char *osErrMessages[] =
-{
- /* 0 */ "No error",
- /* 1 EPERM */ "Operation not permitted",
- /* 2 ENOENT */ "No such file or directory",
- /* 3 ESRCH */ "No such process",
- /* 4 EINTR */ "Interrupted function call",
- /* 5 EIO */ "I/O error",
- /* 6 ENXIO */ "No such device or address",
- /* 7 E2BIG */ "Arg list too long",
- /* 8 ENOEXEC */ "Exec format error",
- /* 9 EBADF */ "Bad file number",
- /* 10 ECHILD */ "No child processes",
- /* 11 EAGAIN */ "Try again",
- /* 12 ENOMEM */ "Out of memory",
- /* 13 EACCES */ "Permission denied",
- /* 14 EFAULT */ "Bad address",
- /* 15 ENOTBLK */ "Unknown error",
- /* 16 EBUSY */ "Resource busy",
- /* 17 EEXIST */ "File exists",
- /* 18 EXDEV */ "Improper link",
- /* 19 ENODEV */ "No such device",
- /* 20 ENOTDIR */ "Not a directory",
- /* 21 EISDIR */ "Is a directory",
- /* 22 EINVAL */ "Invalid argument",
- /* 23 ENFILE */ "Too many open files in system",
- /* 24 EMFILE */ "Too many open files",
- /* 25 ENOTTY */ "Inappropriate I/O control operation",
- /* 26 ETXTBSY */ "Unknown error",
- /* 27 EFBIG */ "File too large",
- /* 28 ENOSPC */ "No space left on device",
- /* 29 ESPIPE */ "Invalid seek",
- /* 30 EROFS */ "Read-only file system",
- /* 31 EMLINK */ "Too many links",
- /* 32 EPIPE */ "Broken pipe",
- /* 33 EDOM */ "Domain error",
- /* 34 ERANGE */ "Result too large",
- /* 35 EUCLEAN */ "Unknown error",
- /* 36 EDEADLK */ "Resource deadlock would occur",
- /* 37 UNKNOWN */ "Unknown error",
- /* 38 ENAMETOOLONG */ "Filename too long",
- /* 39 ENOLCK */ "No locks available",
- /* 40 ENOSYS */ "Function not implemented",
- /* 41 ENOTEMPTY */ "Directory not empty",
- /* 42 EILSEQ */ "Illegal byte sequence",
- /* 43 ENETDOWN */ "Network is down",
- /* 44 ECONNRESET */ "Connection reset",
- /* 45 ECONNREFUSED */ "Connection refused",
- /* 46 EADDRINUSE */ "Address already in use"
-
-};
-
-#else /* WIN */
-
-char *osErrMessages[] =
-{
- /* 0 */ "Success"
- /* 1 EPERM */ "Operation not permitted"
- /* 2 ENOENT */ "No such file or directory"
- /* 3 ESRCH */ "No such process"
- /* 4 EINTR */ "Interrupted system call"
- /* 5 EIO */ "I/O error"
- /* 6 ENXIO */ "No such device or address"
- /* 7 E2BIG */ "Arg list too long"
- /* 8 ENOEXEC */ "Exec format error"
- /* 9 EBADF */ "Bad file number"
- /* 10 ECHILD */ "No child processes"
- /* 11 EAGAIN */ "Try again"
- /* 12 ENOMEM */ "Out of memory"
- /* 13 EACCES */ "Permission denied"
- /* 14 EFAULT */ "Bad address"
- /* 15 ENOTBLK */ "Block device required"
- /* 16 EBUSY */ "Device or resource busy"
- /* 17 EEXIST */ "File exists"
- /* 18 EXDEV */ "Cross-device link"
- /* 19 ENODEV */ "No such device"
- /* 20 ENOTDIR */ "Not a directory"
- /* 21 EISDIR */ "Is a directory"
- /* 22 EINVAL */ "Invalid argument"
- /* 23 ENFILE */ "File table overflow"
- /* 24 EMFILE */ "Too many open files"
- /* 25 ENOTTY */ "Not a typewriter"
- /* 26 ETXTBSY */ "Text file busy"
- /* 27 EFBIG */ "File too large"
- /* 28 ENOSPC */ "No space left on device"
- /* 29 ESPIPE */ "Illegal seek"
- /* 30 EROFS */ "Read-only file system"
- /* 31 EMLINK */ "Too many links"
- /* 32 EPIPE */ "Broken pipe"
- /* 33 EDOM */ "Math argument out of domain of func"
- /* 34 ERANGE */ "Math result not representable"
- /* 35 EDEADLK */ "Resource deadlock would occur"
- /* 36 ENAMETOOLONG */ "File name too long"
- /* 37 ENOLCK */ "No record locks available"
- /* 38 ENOSYS */ "Function not implemented"
- /* 39 ENOTEMPTY */ "Directory not empty"
- /* 40 ELOOP */ "Too many symbolic links encountered"
- /* 41 EWOULDBLOCK EAGAIN */"Operation would block"
- /* 42 ENOMSG */ "No message of desired type"
- /* 43 EIDRM */ "Identifier removed"
-
-#if !BLD_FEATURE_SQUEEZE
- /* 44 ECHRNG */ "Channel number out of range"
- /* 45 EL2NSYNC */ "Level 2 not synchronized"
- /* 46 EL3HLT */ "Level 3 halted"
- /* 47 EL3RST */ "Level 3 reset"
- /* 48 ELNRNG */ "Link number out of range"
- /* 49 EUNATCH */ "Protocol driver not attached"
- /* 50 ENOCSI */ "No CSI structure available"
- /* 51 EL2HLT */ "Level 2 halted"
- /* 52 EBADE */ "Invalid exchange"
- /* 53 EBADR */ "Invalid request descriptor"
- /* 54 EXFULL */ "Exchange full"
- /* 55 ENOANO */ "No anode"
- /* 56 EBADRQC */ "Invalid request code"
- /* 57 EBADSLT */ "Invalid slot"
- /* 59 EBFONT */ "Bad font file format"
- /* 60 ENOSTR */ "Device not a stream"
- /* 61 ENODATA */ "No data available"
- /* 62 ETIME */ "Timer expired"
- /* 63 ENOSR */ "Out of streams resources"
- /* 64 ENONET */ "Machine is not on the network"
- /* 65 ENOPKG */ "Package not installed"
- /* 66 EREMOTE */ "Object is remote"
- /* 67 ENOLINK */ "Link has been severed"
- /* 68 EADV */ "Advertise error"
- /* 69 ESRMNT */ "Srmount error"
- /* 70 ECOMM */ "Communication error on send"
- /* 71 EPROTO */ "Protocol error"
- /* 72 EMULTIHOP */ "Multihop attempted"
- /* 73 EDOTDOT */ "RFS specific error"
- /* 74 EBADMSG */ "Not a data message"
- /* 75 EOVERFLOW */ "Value too large for defined data type"
- /* 76 ENOTUNIQ */ "Name not unique on network"
- /* 77 EBADFD */ "File descriptor in bad state"
- /* 78 EREMCHG */ "Remote address changed"
- /* 79 ELIBACC */ "Can not access a needed shared library"
- /* 80 ELIBBAD */ "Accessing a corrupted shared library"
- /* 81 ELIBSCN */ ".lib section in a.out corrupted"
- /* 82 ELIBMAX */ "Linking in too many shared libraries"
- /* 83 ELIBEXEC */ "Cannot exec a shared library directly"
- /* 84 EILSEQ */ "Illegal byte sequence"
- /* 85 ERESTART */ "Interrupted system call should be restarted"
- /* 86 ESTRPIPE */ "Streams pipe error"
- /* 87 EUSERS */ "Too many users"
- /* 88 ENOTSOCK */ "Socket operation on non-socket"
- /* 89 EDESTADDRREQ */ "Destination address required"
- /* 90 EMSGSIZE */ "Message too long"
- /* 91 EPROTOTYPE */ "Protocol wrong type for socket"
- /* 92 ENOPROTOOPT */ "Protocol not available"
- /* 93 EPROTONOSUPPORT */ "Protocol not supported"
- /* 94 ESOCKTNOSUPPORT */ "Socket type not supported"
- /* 95 EOPNOTSUPP */ "Operation not supported on transport endpoint"
- /* 96 EPFNOSUPPORT */ "Protocol family not supported"
- /* 97 EAFNOSUPPORT */ "Address family not supported by protocol"
- /* 98 EADDRINUSE */ "Address already in use"
- /* 99 EADDRNOTAVAIL */ "Cannot assign requested address"
- /* 100 ENETDOWN */ "Network is down"
- /* 101 ENETUNREACH */ "Network is unreachable"
- /* 102 ENETRESET */ "Network dropped connection because of reset"
- /* 103 ECONNABORTED */ "Software caused connection abort"
- /* 104 ECONNRESET */ "Connection reset by peer"
- /* 105 ENOBUFS */ "No buffer space available"
- /* 106 EISCONN */ "Transport endpoint is already connected"
- /* 107 ENOTCONN */ "Transport endpoint is not connected"
- /* 108 ESHUTDOWN */ "Cannot send after transport endpoint shutdown"
- /* 109 ETOOMANYREFS */ "Too many references: cannot splice"
- /* 110 ETIMEDOUT */ "Connection timed out"
- /* 111 ECONNREFUSED */ "Connection refused"
- /* 112 EHOSTDOWN */ "Host is down"
- /* 113 EHOSTUNREACH */ "No route to host"
- /* 114 EALREADY */ "Operation already in progress"
- /* 115 EINPROGRESS */ "Operation now in progress"
- /* 116 ESTALE */ "Stale NFS file handle"
- /* 117 EUCLEAN */ "Structure needs cleaning"
- /* 118 ENOTNAM */ "Not a XENIX named type file"
- /* 119 ENAVAIL */ "No XENIX semaphores available"
- /* 120 EISNAM */ "Is a named type file"
- /* 121 EREMOTEIO */ "Remote I/O error"
- /* 122 EDQUOT */ "Quota exceeded"
- /* 123 ENOMEDIUM */ "No medium found"
- /* 124 EMEDIUMTYPE */ "Wrong medium type"
-};
-#endif /* BLD_FEATURE_SQUEEZE */
-#endif /* WIN */
-
- int osNumErr = sizeof(osErrMessages) / sizeof(char*);
-
- if (err < MPR_ERR_BASE) {
- err = MPR_ERR_BASE - err;
- if (err < 0 || err >= mprNumErr) {
- return "Bad error code";
- }
- return mprErrMessages[err];
-
- } else {
- /*
- * Negative O/S error code. Map to a positive standard Posix error.
- */
- err = -err;
- if (err < 0 || err >= osNumErr) {
- return "Bad O/S error code";
- }
- return osErrMessages[err];
- }
-}
-
-#endif
-/*****************************************************************************/
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- * @file mprOs.h
- * @brief Include O/S headers and smooth out per-O/S differences
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-
-/******************************* Documentation ********************************/
-
-/*
- * This header is part of the Mbedthis Portable Runtime and aims to include
- * all necessary O/S headers and to unify the constants and declarations
- * required by Mbedthis products. It can be included by C or C++ programs.
- */
-
-/******************************************************************************/
-
-#ifndef _h_MPR_OS_HDRS
-#define _h_MPR_OS_HDRS 1
-
-#include "buildConfig.h"
-
-/********************************* CPU Families *******************************/
-/*
- * Porters, add your CPU families here and update configure code.
- */
-#define MPR_CPU_UNKNOWN 0
-#define MPR_CPU_IX86 1
-#define MPR_CPU_PPC 2
-#define MPR_CPU_SPARC 3
-#define MPR_CPU_XSCALE 4
-#define MPR_CPU_ARM 5
-#define MPR_CPU_MIPS 6
-#define MPR_CPU_68K 7
-#define MPR_CPU_SIMNT 8 /* VxWorks NT simulator */
-#define MPR_CPU_SIMSPARC 9 /* VxWorks sparc simulator */
-
-/********************************* O/S Includes *******************************/
-
-#if LINUX || SOLARIS
- #include <sys/types.h>
- #include <time.h>
- #include <arpa/inet.h>
- #include <ctype.h>
- #include <dirent.h>
- #include <dlfcn.h>
- #include <fcntl.h>
- #include <grp.h>
- #include <errno.h>
- #include <libgen.h>
- #include <limits.h>
- #include <netdb.h>
- #include <net/if.h>
- #include <netinet/in.h>
- #include <netinet/tcp.h>
- #include <netinet/ip.h>
- #include <pthread.h>
- #include <pwd.h>
- #include <resolv.h>
- #include <signal.h>
- #include <stdarg.h>
- #include <stdio.h>
- #include <stdlib.h>
- #include <string.h>
- #include <syslog.h>
- #include <sys/ioctl.h>
- #include <sys/stat.h>
- #include <sys/param.h>
- #include <sys/resource.h>
- #include <sys/sem.h>
- #include <sys/shm.h>
- #include <sys/socket.h>
- #include <sys/select.h>
- #include <sys/time.h>
- #include <sys/times.h>
- #include <sys/utsname.h>
- #include <sys/wait.h>
- #include <unistd.h>
-
-#if LINUX
- #include <stdint.h>
-#endif
-
-#if SOLARIS
- #include <netinet/in_systm.h>
-#endif
-
-#if BLD_FEATURE_FLOATING_POINT
- #define __USE_ISOC99 1
- #include <math.h>
- #include <values.h>
-#endif
-
-#endif /* LINUX || SOLARIS */
-
-#if VXWORKS
- #include <vxWorks.h>
- #include <envLib.h>
- #include <sys/types.h>
- #include <time.h>
- #include <arpa/inet.h>
- #include <ctype.h>
- #include <dirent.h>
- #include <fcntl.h>
- #include <errno.h>
- #include <limits.h>
- #include <loadLib.h>
- #include <netdb.h>
- #include <net/if.h>
- #include <netinet/tcp.h>
- #include <netinet/in.h>
- #include <netinet/ip.h>
- #include <signal.h>
- #include <stdarg.h>
- #include <stdio.h>
- #include <stdlib.h>
- #include <string.h>
- #include <sysSymTbl.h>
- #include <sys/fcntlcom.h>
- #include <sys/ioctl.h>
- #include <sys/stat.h>
- #include <sys/socket.h>
- #include <sys/times.h>
- #include <sys/wait.h>
- #include <unistd.h>
- #include <unldLib.h>
-
- #if BLD_FEATURE_FLOATING_POINT
- #include <float.h>
- #define __USE_ISOC99 1
- #include <math.h>
- #endif
-
- #include <sockLib.h>
- #include <inetLib.h>
- #include <ioLib.h>
- #include <pipeDrv.h>
- #include <hostLib.h>
- #include <netdb.h>
- #include <tickLib.h>
- #include <taskHookLib.h>
-
-#endif /* VXWORKS */
-
-#if MACOSX
- #include <time.h>
- #include <arpa/inet.h>
- #include <ctype.h>
- #include <fcntl.h>
- #include <grp.h>
- #include <errno.h>
- #include <libgen.h>
- #include <limits.h>
- #include <mach-o/dyld.h>
- #include <netdb.h>
- #include <net/if.h>
- #include <netinet/in_systm.h>
- #include <netinet/in.h>
- #include <netinet/tcp.h>
- #include <netinet/ip.h>
- #include <pthread.h>
- #include <pwd.h>
- #include <resolv.h>
- #include <signal.h>
- #include <stdarg.h>
- #include <stdio.h>
- #include <stdlib.h>
- #include <stdint.h>
- #include <string.h>
- #include <syslog.h>
- #include <sys/ioctl.h>
- #include <sys/types.h>
- #include <sys/stat.h>
- #include <sys/param.h>
- #include <sys/resource.h>
- #include <sys/sem.h>
- #include <sys/shm.h>
- #include <sys/socket.h>
- #include <sys/select.h>
- #include <sys/time.h>
- #include <sys/times.h>
- #include <sys/types.h>
- #include <sys/utsname.h>
- #include <sys/wait.h>
- #include <unistd.h>
-#endif /* MACOSX */
-
-#if WIN
- /*
- * We replace insecure functions with Mbedthis replacements
- */
- #define _CRT_SECURE_NO_DEPRECATE 1
-
- #include <ctype.h>
- #include <conio.h>
- #include <direct.h>
- #include <errno.h>
- #include <fcntl.h>
- #include <io.h>
- #include <limits.h>
- #include <malloc.h>
- #include <process.h>
- #include <sys/stat.h>
- #include <sys/types.h>
- #include <stddef.h>
- #include <stdio.h>
- #include <stdlib.h>
- #include <string.h>
- #include <stdarg.h>
- #include <time.h>
- #define WIN32_LEAN_AND_MEAN
- #include <winsock2.h>
- #include <windows.h>
- #include <winbase.h>
- #if BLD_FEATURE_FLOATING_POINT
- #include <float.h>
- #endif
- #include <shlobj.h>
- #include <shellapi.h>
- #include <wincrypt.h>
-
-#if BLD_DEBUG
- #include <crtdbg.h>
-#endif
- #include "mprUnix.h"
-#endif /* WIN */
-
-#if BREW
- #if BLD_FEATURE_FLOATING_POINT
- #warning "Floating point is not supported on Brew"
- #endif
- #if BLD_FEATURE_MULTITHREAD
- #warning "Multithreading is not supported on Brew"
- #endif
-
- #include "AEEModGen.h"
- #include "AEEAppGen.h"
- #include "BREWVersion.h"
-
- #if BREW_MAJ_VER == 2
- /*
- * Fix for BREW 2.X
- */
- #ifdef __GNUC__
- #define __inline extern __inline__
- #endif
- #include "AEENet.h"
- #undef __inline
- #endif
-
- #include "AEE.h"
- #include "AEEBitmap.h"
- #include "AEEDisp.h"
- #include "AEEFile.h"
- #include "AEEHeap.h"
- #include "AEEImageCtl.h"
- #include "AEEMedia.h"
- #include "AEEMediaUtil.h"
- #include "AEEMimeTypes.h"
- #include "AEEStdLib.h"
- #include "AEEShell.h"
- #include "AEESoundPlayer.h"
- #include "AEEText.h"
- #include "AEETransform.h"
- #include "AEEWeb.h"
- #if BREW_MAJ_VER >= 3
- #include "AEESMS.h"
- #endif
- #include "AEETAPI.h"
-
-#if 0
- #include "AEESound.h"
- #include "AEEDb.h"
- #include "AEEMenu.h"
-#endif
-
-#endif /* BREW */
-
-/******************************************************************************/
-/******************************* General Defines ******************************/
-/******************************************************************************/
-
-#ifndef MAXINT
-#if INT_MAX
- #define MAXINT INT_MAX
-#else
- #define MAXINT 0x7fffffff
-#endif
-#endif
-
-#ifndef BITSPERBYTE
-#define BITSPERBYTE (8 * sizeof(char))
-#endif
-
-#define BITS(type) (BITSPERBYTE * (int) sizeof(type))
-
-#ifndef max
-#define max(a,b) (((a) > (b)) ? (a) : (b))
-#endif
-
-#ifndef min
-#define min(a,b) (((a) < (b)) ? (a) : (b))
-#endif
-
-#define MPR_ARRAY_SIZE(type) (sizeof(type) / sizeof(type[0]))
-
-#ifndef PRINTF_ATTRIBUTE
-#if (__GNUC__ >= 3) && !DOXYGEN && BLD_FEATURE_ALLOC_LEAK_TRACK
-/** Use gcc attribute to check printf fns. a1 is the 1-based index of
- * the parameter containing the format, and a2 the index of the first
- * argument. Note that some gcc 2.x versions don't handle this
- * properly **/
-#define PRINTF_ATTRIBUTE(a1, a2) __attribute__ ((format (__printf__, a1, a2)))
-#else
-#define PRINTF_ATTRIBUTE(a1, a2)
-#endif
-#endif
-
-typedef char *MprStr; /* Used for dynamic strings */
-
-#ifdef __cplusplus
-extern "C" {
-#else
-typedef int bool;
-#endif
-
-/******************************************************************************/
-/******************************** Linux Defines *******************************/
-/******************************************************************************/
-
-#if LINUX
- typedef unsigned char uchar;
-
-#if BLD_FEATURE_INT64
- __extension__ typedef long long int int64;
- __extension__ typedef unsigned long long int uint64;
- #define INT64(x) (x##LL)
- #define UINT64(x) (x##ULL)
-#endif
-
- #define closesocket(x) close(x)
- #define MPR_BINARY ""
- #define MPR_TEXT ""
- #define O_BINARY 0
- #define O_TEXT 0
- #define SOCKET_ERROR -1
- #define MPR_DLL_EXT ".so"
-
-#if BLD_FEATURE_FLOATING_POINT
- #define MAX_FLOAT MAXFLOAT
-#endif
-
-/*
- * For some reason it is removed from fedora pthreads.h and only
- * comes in for UNIX96
- */
-extern int pthread_mutexattr_gettype (__const pthread_mutexattr_t *__restrict
- __attr, int *__restrict __kind) __THROW;
-/* Set the mutex kind attribute in *ATTR to KIND (either PTHREAD_MUTEX_NORMAL,
- PTHREAD_MUTEX_RECURSIVE, PTHREAD_MUTEX_ERRORCHECK, or
- PTHREAD_MUTEX_DEFAULT). */
-extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind)
- __THROW;
-
-#endif /* LINUX */
-
-/******************************************************************************/
-/******************************* VxWorks Defines ******************************/
-/******************************************************************************/
-
-#if VXWORKS
-
- typedef unsigned char uchar;
- typedef unsigned int uint;
- typedef unsigned long ulong;
-
- #define HAVE_SOCKLEN_T
- typedef int socklen_t;
-
-#if BLD_FEATURE_INT64
- typedef long long int int64;
- typedef unsigned long long int uint64;
- #define INT64(x) (x##LL)
- #define UINT64(x) (x##ULL)
-#endif
-
- #define closesocket(x) close(x)
- #define getpid() taskIdSelf()
- #define MPR_BINARY ""
- #define MPR_TEXT ""
- #define O_BINARY 0
- #define O_TEXT 0
- #define SOCKET_ERROR -1
- #define MPR_DLL_EXT ".so"
-
-#if BLD_FEATURE_FLOATING_POINT
- #define MAX_FLOAT FLT_MAX
-#endif
-
- #undef R_OK
- #define R_OK 4
- #undef W_OK
- #define W_OK 2
- #undef X_OK
- #define X_OK 1
- #undef F_OK
- #define F_OK 0
-
- #define MSG_NOSIGNAL 0
-
- extern int access(char *path, int mode);
- extern int sysClkRateGet();
-
-#endif /* VXWORKS */
-
-/******************************************************************************/
-/******************************** MacOsx Defines ******************************/
-/******************************************************************************/
-#if MACOSX
- typedef unsigned long ulong;
- typedef unsigned char uchar;
-
-#if BLD_FEATURE_INT64
- __extension__ typedef long long int int64;
- __extension__ typedef unsigned long long int uint64;
- #define INT64(x) (x##LL)
- #define UINT64(x) (x##ULL)
-#endif
-
- #define closesocket(x) close(x)
- #define MPR_BINARY ""
- #define MPR_TEXT ""
- #define O_BINARY 0
- #define O_TEXT 0
- #define SOCKET_ERROR -1
- #define MPR_DLL_EXT ".dylib"
- #define MSG_NOSIGNAL 0
- #define __WALL 0x40000000
- #define PTHREAD_MUTEX_RECURSIVE_NP PTHREAD_MUTEX_RECURSIVE
-
-#if BLD_FEATURE_FLOATING_POINT
- #define MAX_FLOAT MAXFLOAT
-#endif
-
-#endif /* MACOSX */
-
-/******************************************************************************/
-/******************************* Windows Defines ******************************/
-/******************************************************************************/
-
-#if WIN
- typedef unsigned char uchar;
- typedef unsigned int uint;
- typedef unsigned long ulong;
- typedef unsigned short ushort;
-
-/*
- * We always define INT64 types on windows
- */
-#if BLD_FEATURE_INT64 || 1
- typedef __int64 int64;
- typedef unsigned __int64 uint64;
- #define INT64(x) (x##i64)
- #define UINT64(x) (x##Ui64)
-#endif
-
- typedef int uid_t;
- typedef void *handle;
- typedef char *caddr_t;
- typedef long pid_t;
- typedef int gid_t;
- typedef ushort mode_t;
- typedef void *siginfo_t;
-
- #define HAVE_SOCKLEN_T
- typedef int socklen_t;
-
- #undef R_OK
- #define R_OK 4
- #undef W_OK
- #define W_OK 2
-
- /*
- * On windows map X_OK to R_OK
- */
- #undef X_OK
- #define X_OK 4
- #undef F_OK
- #define F_OK 0
-
- #ifndef EADDRINUSE
- #define EADDRINUSE 46
- #endif
- #ifndef EWOULDBLOCK
- #define EWOULDBLOCK EAGAIN
- #endif
- #ifndef ENETDOWN
- #define ENETDOWN 43
- #endif
- #ifndef ECONNRESET
- #define ECONNRESET 44
- #endif
- #ifndef ECONNREFUSED
- #define ECONNREFUSED 45
- #endif
-
- #define MSG_NOSIGNAL 0
- #define MPR_BINARY "b"
- #define MPR_TEXT "t"
-
-#if BLD_FEATURE_FLOATING_POINT
- #define MAX_FLOAT DBL_MAX
-#endif
-
-#ifndef FILE_FLAG_FIRST_PIPE_INSTANCE
-#define FILE_FLAG_FIRST_PIPE_INSTANCE 0x00080000
-#endif
-
- #define MPR_DLL_EXT ".dll"
-#endif /* WIN */
-
-/******************************************************************************/
-/****************************** Solaris Defines *******************************/
-/******************************************************************************/
-
-#if SOLARIS
- typedef unsigned char uchar;
-
-#if BLD_FEATURE_INT64
- typedef long long int int64;
- typedef unsigned long long int uint64;
- #define INT64(x) (x##LL)
- #define UINT64(x) (x##ULL)
-#endif
-
- #define closesocket(x) close(x)
- #define MPR_BINARY ""
- #define MPR_TEXT ""
- #define O_BINARY 0
- #define O_TEXT 0
- #define SOCKET_ERROR -1
- #define MPR_DLL_EXT ".so"
- #define MSG_NOSIGNAL 0
- #define INADDR_NONE ((in_addr_t) 0xffffffff)
- #define __WALL 0
- #define PTHREAD_MUTEX_RECURSIVE_NP PTHREAD_MUTEX_RECURSIVE
-
-#if BLD_FEATURE_FLOATING_POINT
- #define MAX_FLOAT MAXFLOAT
-#endif
-
-#endif /* SOLARIS */
-
-/******************************************************************************/
-/********************************* BREW Defines *******************************/
-/******************************************************************************/
-
-#if BREW
- typedef unsigned char uchar;
- typedef unsigned int uint;
- typedef unsigned long ulong;
- typedef unsigned short ushort;
-
- typedef uint off_t;
- typedef long pid_t;
-
-#if UNUSED
- typedef int uid_t;
- typedef void *handle;
- typedef char *caddr_t;
- typedef int gid_t;
- typedef ushort mode_t;
- typedef void *siginfo_t;
-
- #define HAVE_SOCKLEN_T
- typedef int socklen_t;
-
- #ifndef EADDRINUSE
- #define EADDRINUSE 46
- #endif
- #ifndef EWOULDBLOCK
- #define EWOULDBLOCK EAGAIN
- #endif
- #ifndef ENETDOWN
- #define ENETDOWN 43
- #endif
- #ifndef ECONNRESET
- #define ECONNRESET 44
- #endif
- #ifndef ECONNREFUSED
- #define ECONNREFUSED 45
- #endif
-
- #define MSG_NOSIGNAL 0
- #define MPR_BINARY "b"
- #define MPR_TEXT "t"
-
- #define MPR_DLL_EXT ".dll"
-#endif
-
- #define O_RDONLY 0
- #define O_WRONLY 1
- #define O_RDWR 2
- #define O_CREAT 0x200
- #define O_TRUNC 0x400
- #define O_BINARY 0
- #define O_TEXT 0x20000
- #define O_EXCL 0x40000
- #define O_APPEND 0x80000
-
- #define R_OK 4
- #define W_OK 2
- #define X_OK 1
- #define F_OK 0
-
- #define SEEK_SET 0
- #define SEEK_CUR 1
- #define SEEK_END 2
-
-#if UNUSED
-struct stat {
- uint st_size;
-};
-#endif
-
-extern int getpid();
-extern int isalnum(int c);
-extern int isalpha(int c);
-extern int isdigit(int c);
-extern int islower(int c);
-extern int isupper(int c);
-extern int isspace(int c);
-extern int isxdigit(int c);
-
-extern uint strlen(const char *str);
-extern char *strstr(const char *string, const char *strSet);
-extern void *memset(const void *dest, int c, uint count);
-extern void exit(int status);
-extern char *strpbrk(const char *str, const char *set);
-extern uint strspn(const char *str, const char *set);
-extern int tolower(int c);
-extern int toupper(int c);
-extern void *memcpy(void *dest, const void *src, uint count);
-extern void *memmove(void *dest, const void *src, uint count);
-
-extern int atoi(const char *str);
-extern void free(void *ptr);
-extern void *malloc(uint size);
-extern void *realloc(void *ptr, uint size);
-extern char *strcat(char *dest, const char *src);
-extern char *strchr(const char *str, int c);
-extern int strcmp(const char *s1, const char *s2);
-extern int strncmp(const char *s1, const char *s2, uint count);
-extern char *strcpy(char *dest, const char *src);
-extern char *strncpy(char *dest, const char *src, uint count);
-extern char *strrchr(const char *str, int c);
-
-#undef printf
-#define printf DBGPRINTF
-
-#if BREW_SIMULATOR && BLD_DEBUG
-extern _CRTIMP int __cdecl _CrtCheckMemory(void);
-extern _CRTIMP int __cdecl _CrtSetReportHook();
-#endif
-
-#endif /* BREW */
-
-/******************************************************************************/
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _h_MPR_OS_HDRS */
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/**
- * @file mprPrintf.c
- * @brief Printf routines safe for embedded programming
- * @overview This module provides safe replacements for the standard
- * printf formatting routines.
- * @remarks Most routines in this file are not thread-safe. It is the callers
- * responsibility to perform all thread synchronization.
- */
-
-/*
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-
-/********************************** Includes **********************************/
-/*
- * We need to use the underlying str(cpy) routines to implement our safe
- * alternatives
- */
-#if !DOXYGEN
-#define UNSAFE_FUNCTIONS_OK 1
-#endif
-
-#include "mpr.h"
-
-/*********************************** Defines **********************************/
-/*
- * Class definitions
- */
-#define CLASS_NORMAL 0 /* [All other] Normal characters */
-#define CLASS_PERCENT 1 /* [%] Begin format */
-#define CLASS_MODIFIER 2 /* [-+ #,] Modifiers */
-#define CLASS_ZERO 3 /* [0] Special modifier */
-#define CLASS_STAR 4 /* [*] Width supplied by arg */
-#define CLASS_DIGIT 5 /* [1-9] Field widths */
-#define CLASS_DOT 6 /* [.] Introduce precision */
-#define CLASS_BITS 7 /* [hlL] Length bits */
-#define CLASS_TYPE 8 /* [cdfinopsSuxX] Type specifiers */
-
-#define STATE_NORMAL 0 /* Normal chars in format string */
-#define STATE_PERCENT 1 /* "%" */
-#define STATE_MODIFIER 2 /* Read flag */
-#define STATE_WIDTH 3 /* Width spec */
-#define STATE_DOT 4 /* "." */
-#define STATE_PRECISION 5 /* Precision spec */
-#define STATE_BITS 6 /* Size spec */
-#define STATE_TYPE 7 /* Data type */
-#define STATE_COUNT 8
-
-/*
- * Format: %[modifier][width][precision][bits][type]
- *
- * #define CLASS_MODIFIER 2 [-+ #,] Modifiers
- * #define CLASS_BITS 7 [hlL] Length bits
- */
-
-
-/*
- * Flags
- */
-#define SPRINTF_LEFT 0x1 /* Left align */
-#define SPRINTF_SIGN 0x2 /* Always sign the result */
-#define SPRINTF_LEAD_SPACE 0x4 /* put leading space for +ve numbers */
-#define SPRINTF_ALTERNATE 0x8 /* Alternate format */
-#define SPRINTF_LEAD_ZERO 0x10 /* Zero pad */
-#define SPRINTF_SHORT 0x20 /* 16-bit */
-#define SPRINTF_LONG 0x40 /* 32-bit */
-#if BLD_FEATURE_INT64
-#define SPRINTF_LONGLONG 0x80 /* 64-bit */
-#endif
-#define SPRINTF_COMMA 0x100 /* Thousand comma separators */
-#define SPRINTF_UPPER_CASE 0x200 /* As the name says for numbers */
-
-typedef struct Format {
- uchar *buf;
- uchar *endbuf;
- uchar *start;
- uchar *end;
- int growBy;
- int maxsize;
-
- int precision;
- int radix;
- int width;
- int flags;
- int len;
-} Format;
-
-static int growBuf(MPR_LOC_DEC(ctx, loc), Format *fmt);
-
-#define BPUT(ctx, loc, fmt, c) \
- if (1) { \
- /* Less one to allow room for the null */ \
- if ((fmt)->end >= ((fmt)->endbuf - sizeof(char))) { \
- if (growBuf(MPR_LOC_PASS(ctx, loc), fmt)) { \
- *(fmt)->end++ = (c); \
- } \
- } else { \
- *(fmt)->end++ = (c); \
- } \
- } else
-
-#define BPUTNULL(ctx, loc, fmt) \
- if (1) { \
- if ((fmt)->end > (fmt)->endbuf) { \
- if (growBuf(MPR_LOC_PASS(ctx, loc), fmt)) { \
- *(fmt)->end = '\0'; \
- } \
- } else { \
- *(fmt)->end = '\0'; \
- } \
- } else
-
-/******************************************************************************/
-
-#if BLD_FEATURE_INT64
-#define unum uint64
-#define num int64
-#else
-#define unum uint
-#define num int
-#endif
-
-/***************************** Forward Declarations ***************************/
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-static int getState(char c, int state);
-static int mprSprintfCore(MPR_LOC_DEC(ctx, loc), char **s,
- int maxsize, const char *fmt, va_list arg);
-static void outNum(MPR_LOC_DEC(ctx, loc), Format *fmt, const char *prefix,
- unum val);
-
-#if BLD_FEATURE_FLOATING_POINT
-static void outFloat(MPR_LOC_DEC(ctx, loc), Format *fmt, char specChar,
- double value);
-#endif
-
-/******************************************************************************/
-
-int mprPrintf(MprCtx ctx, const char *fmt, ...)
-{
- va_list ap;
- char *buf;
- int len;
- MprApp *app;
-
- /* No asserts here as this is used as part of assert reporting */
-
- app = mprGetApp(ctx);
-
- va_start(ap, fmt);
- len = mprAllocVsprintf(MPR_LOC_ARGS(ctx), &buf, 0, fmt, ap);
- va_end(ap);
- if (len >= 0 && app->console) {
- len = mprWrite(app->console, buf, len);
- }
- mprFree(buf);
-
- return len;
-}
-
-/******************************************************************************/
-
-int mprErrorPrintf(MprCtx ctx, const char *fmt, ...)
-{
- va_list ap;
- char *buf;
- int len;
- MprApp *app;
-
- /* No asserts here as this is used as part of assert reporting */
-
- app = mprGetApp(ctx);
-
- va_start(ap, fmt);
- len = mprAllocVsprintf(MPR_LOC_ARGS(ctx), &buf, 0, fmt, ap);
- va_end(ap);
- if (len >= 0 && app->error) {
- len = mprWrite(app->error, buf, len);
- }
- mprFree(buf);
-
- return len;
-}
-
-/******************************************************************************/
-
-int mprFprintf(MprFile *file, const char *fmt, ...)
-{
- va_list ap;
- char *buf;
- int len;
-
- if (file == 0) {
- return MPR_ERR_BAD_HANDLE;
- }
-
- va_start(ap, fmt);
- len = mprAllocVsprintf(MPR_LOC_ARGS(file), &buf, 0, fmt, ap);
- va_end(ap);
-
- if (len >= 0) {
- len = mprWrite(file, buf, len);
- }
- mprFree(buf);
- return len;
-}
-
-/******************************************************************************/
-/*
- * Printf with a static buffer. Used internally only. WILL NOT MALLOC.
- */
-
-int mprStaticPrintf(MprCtx ctx, const char *fmt, ...)
-{
- va_list ap;
- char buf[MPR_MAX_STRING];
- char *bufp;
- int len;
- MprApp *app;
-
- app = mprGetApp(ctx);
-
- va_start(ap, fmt);
- bufp = buf;
- len = mprSprintfCore(MPR_LOC_ARGS(0), &bufp, MPR_MAX_STRING, fmt, ap);
- va_end(ap);
- if (len >= 0) {
- len = mprWrite(app->console, buf, len);
- }
- return len;
-}
-
-/******************************************************************************/
-
-int mprSprintf(char *buf, int n, const char *fmt, ...)
-{
- va_list ap;
- int result;
-
- mprAssert(buf);
- mprAssert(fmt);
- mprAssert(n > 0);
-
- va_start(ap, fmt);
- result = mprSprintfCore(MPR_LOC_ARGS(0), &buf, n, fmt, ap);
- va_end(ap);
- return result;
-}
-
-/******************************************************************************/
-
-int mprVsprintf(char *buf, int n, const char *fmt, va_list arg)
-{
- mprAssert(buf);
- mprAssert(fmt);
- mprAssert(n > 0);
-
- return mprSprintfCore(MPR_LOC_ARGS(0), &buf, n, fmt, arg);
-}
-
-/******************************************************************************/
-
-int mprAllocSprintf(MPR_LOC_DEC(ctx, loc), char **buf, int maxSize,
- const char *fmt, ...)
-{
- va_list ap;
- int result;
-
- mprAssert(buf);
- mprAssert(fmt);
-
- *buf = 0;
- va_start(ap, fmt);
- result = mprSprintfCore(MPR_LOC_PASS(ctx, loc), buf, maxSize, fmt, ap);
- va_end(ap);
- return result;
-}
-
-/******************************************************************************/
-
-int mprAllocVsprintf(MPR_LOC_DEC(ctx, loc), char **buf, int maxSize,
- const char *fmt, va_list arg)
-{
- mprAssert(buf);
- mprAssert(fmt);
-
- *buf = 0;
- return mprSprintfCore(MPR_LOC_PASS(ctx, loc), buf, maxSize, fmt, arg);
-}
-
-/******************************************************************************/
-
-static int getState(char c, int state)
-{
- /*
- * Declared here to remove all static / globals
- * FUTURE OPT -- need to measure this. Could be slow on BREW.
- */
-
- char stateMap[] = {
- /* STATES: Normal Percent Modifier Width Dot Prec Bits Type */
- /* CLASS 0 1 2 3 4 5 6 7 */
- /* Normal 0 */ 0, 0, 0, 0, 0, 0, 0, 0,
- /* Percent 1 */ 1, 0, 1, 1, 1, 1, 1, 1,
- /* Modifier 2 */ 0, 2, 2, 0, 0, 0, 0, 0,
- /* Zero 3 */ 0, 2, 2, 3, 0, 5, 0, 0,
- /* Star 4 */ 0, 3, 3, 0, 5, 0, 0, 0,
- /* Digit 5 */ 0, 3, 3, 3, 5, 5, 0, 0,
- /* Dot 6 */ 0, 4, 4, 4, 0, 0, 0, 0,
- /* Bits 7 */ 0, 6, 6, 6, 6, 6, 6, 0,
- /* Types 8 */ 0, 7, 7, 7, 7, 7, 7, 0,
- };
-
- /*
- * Format: %[modifier][width][precision][bits][type]
- */
- char classMap[] = {
- /* 0 ' ' ! " # $ % & ' */
- 2, 0, 0, 2, 0, 1, 0, 0,
- /* 07 ( ) * + , - . / */
- 0, 0, 4, 2, 2, 2, 6, 0,
- /* 10 0 1 2 3 4 5 6 7 */
- 3, 5, 5, 5, 5, 5, 5, 5,
- /* 17 8 9 : ; < = > ? */
- 5, 5, 0, 0, 0, 0, 0, 0,
- /* 20 @ A B C D E F G */
- 0, 0, 0, 0, 0, 0, 0, 0,
- /* 27 H I J K L M N O */
- 0, 0, 0, 0, 7, 0, 0, 0,
- /* 30 P Q R S T U V W */
- 0, 0, 0, 8, 0, 0, 0, 0,
- /* 37 X Y Z [ \ ] ^ _ */
- 8, 0, 0, 0, 0, 0, 0, 0,
- /* 40 ' a b c d e f g */
- 0, 0, 0, 8, 8, 0, 8, 0,
- /* 47 h i j k l m n o */
- 7, 8, 0, 0, 7, 0, 8, 8,
- /* 50 p q r s t u v w */
- 8, 0, 0, 8, 0, 8, 0, 0,
- /* 57 x y z */
- 8, 0, 0,
- };
-
- int chrClass;
-
- if (c < ' ' || c > 'z') {
- chrClass = CLASS_NORMAL;
- } else {
- mprAssert((c - ' ') < (int) sizeof(classMap));
- chrClass = classMap[(c - ' ')];
- }
- mprAssert((chrClass * STATE_COUNT + state) < (int) sizeof(stateMap));
- state = stateMap[chrClass * STATE_COUNT + state];
- return state;
-}
-
-/******************************************************************************/
-
-static int mprSprintfCore(MPR_LOC_DEC(ctx, loc), char **bufPtr,
- int maxsize, const char *spec, va_list arg)
-{
- Format fmt;
- char *cp;
- char c;
- char *sValue;
- num iValue;
- unum uValue;
- int count, i, len, state;
-
- mprAssert(bufPtr);
- mprAssert(spec);
-
- if (*bufPtr != 0) {
- mprAssert(maxsize > 0);
- fmt.buf = (uchar*) *bufPtr;
- fmt.endbuf = &fmt.buf[maxsize];
- fmt.growBy = 0;
- } else {
- if (maxsize <= 0) {
- maxsize = MAXINT;
- }
-
- len = min(MPR_DEFAULT_ALLOC, maxsize);
- fmt.buf = (uchar*) mprAllocBlock(MPR_LOC_PASS(ctx, loc), len);
- fmt.endbuf = &fmt.buf[len];
- fmt.growBy = MPR_DEFAULT_ALLOC * 2;
- }
-
- fmt.maxsize = maxsize;
- fmt.start = fmt.buf;
- fmt.end = fmt.buf;
- fmt.len = 0;
- *fmt.start = '\0';
-
- state = STATE_NORMAL;
-
- while ((c = *spec++) != '\0') {
- state = getState(c, state);
-
- switch (state) {
- case STATE_NORMAL:
- BPUT(ctx, loc, &fmt, c);
- break;
-
- case STATE_PERCENT:
- fmt.precision = -1;
- fmt.width = 0;
- fmt.flags = 0;
- break;
-
- case STATE_MODIFIER:
- switch (c) {
- case '+':
- fmt.flags |= SPRINTF_SIGN;
- break;
- case '-':
- fmt.flags |= SPRINTF_LEFT;
- break;
- case '#':
- fmt.flags |= SPRINTF_ALTERNATE;
- break;
- case '0':
- fmt.flags |= SPRINTF_LEAD_ZERO;
- break;
- case ' ':
- fmt.flags |= SPRINTF_LEAD_SPACE;
- break;
- case ',':
- fmt.flags |= SPRINTF_COMMA;
- break;
- }
- break;
-
- case STATE_WIDTH:
- if (c == '*') {
- fmt.width = va_arg(arg, int);
- if (fmt.width < 0) {
- fmt.width = -fmt.width;
- fmt.flags |= SPRINTF_LEFT;
- }
- } else {
- while (isdigit((int)c)) {
- fmt.width = fmt.width * 10 + (c - '0');
- c = *spec++;
- }
- spec--;
- }
- break;
-
- case STATE_DOT:
- fmt.precision = 0;
- fmt.flags &= ~SPRINTF_LEAD_ZERO;
- break;
-
- case STATE_PRECISION:
- if (c == '*') {
- fmt.precision = va_arg(arg, int);
- } else {
- while (isdigit((int) c)) {
- fmt.precision = fmt.precision * 10 + (c - '0');
- c = *spec++;
- }
- spec--;
- }
- break;
-
- case STATE_BITS:
- switch (c) {
-#if BLD_FEATURE_INT64
- case 'L':
- fmt.flags |= SPRINTF_LONGLONG; /* 64 bit */
- break;
-#endif
-
- case 'l':
- fmt.flags |= SPRINTF_LONG;
- break;
-
- case 'h':
- fmt.flags |= SPRINTF_SHORT;
- break;
- }
- break;
-
- case STATE_TYPE:
- switch (c) {
-#if BLD_FEATURE_FLOATING_POINT
- case 'e':
- case 'g':
- case 'f':
- fmt.radix = 10;
- outFloat(MPR_LOC_PASS(ctx, loc), &fmt, c,
- (double) va_arg(arg, double));
- break;
-#endif
- case 'c':
- BPUT(ctx, loc, &fmt, (char) va_arg(arg, int));
- break;
-
- case 's':
- case 'S':
- sValue = va_arg(arg, char*);
- if (sValue == 0) {
- sValue = "null";
- len = strlen(sValue);
- } else if (fmt.flags & SPRINTF_ALTERNATE) {
- sValue++;
- len = (int) *sValue;
- } else if (fmt.precision >= 0) {
- /*
- * Can't use strlen(), the string may not have a null
- */
- cp = sValue;
- for (len = 0; len < fmt.precision; len++) {
- if (*cp++ == '\0') {
- break;
- }
- }
- } else {
- len = strlen(sValue);
- }
- if (!(fmt.flags & SPRINTF_LEFT)) {
- for (i = len; i < fmt.width; i++) {
- BPUT(ctx, loc, &fmt, (char) ' ');
- }
- }
- for (i = 0; i < len && *sValue; i++) {
- BPUT(ctx, loc, &fmt, *sValue++);
- }
- if (fmt.flags & SPRINTF_LEFT) {
- for (i = len; i < fmt.width; i++) {
- BPUT(ctx, loc, &fmt, (char) ' ');
- }
- }
- break;
-
- case 'i':
- ;
- case 'd':
- fmt.radix = 10;
- if (fmt.flags & SPRINTF_SHORT) {
- iValue = (short) va_arg(arg, int);
- } else if (fmt.flags & SPRINTF_LONG) {
- iValue = va_arg(arg, long);
-#if BLD_FEATURE_INT64
- } else if (fmt.flags & SPRINTF_LONGLONG) {
- iValue = va_arg(arg, num);
-#endif
- } else {
- iValue = va_arg(arg, int);
- }
- if (iValue >= 0) {
- if (fmt.flags & SPRINTF_LEAD_SPACE) {
- outNum(MPR_LOC_PASS(ctx, loc), &fmt, " ", iValue);
- } else if (fmt.flags & SPRINTF_SIGN) {
- outNum(MPR_LOC_PASS(ctx, loc), &fmt, "+", iValue);
- } else {
- outNum(MPR_LOC_PASS(ctx, loc), &fmt, 0, iValue);
- }
- } else {
- outNum(MPR_LOC_PASS(ctx, loc), &fmt, "-", -iValue);
- }
- break;
-
- case 'X':
- fmt.flags |= SPRINTF_UPPER_CASE;
- /* Fall through */
- case 'o':
- case 'x':
- case 'u':
- if (fmt.flags & SPRINTF_SHORT) {
- uValue = (ushort) va_arg(arg, uint);
- } else if (fmt.flags & SPRINTF_LONG) {
- uValue = va_arg(arg, ulong);
-#if BLD_FEATURE_INT64
- } else if (fmt.flags & SPRINTF_LONGLONG) {
- uValue = va_arg(arg, unum);
-#endif
- } else {
- uValue = va_arg(arg, uint);
- }
- if (c == 'u') {
- fmt.radix = 10;
- outNum(MPR_LOC_PASS(ctx, loc), &fmt, 0, uValue);
- } else if (c == 'o') {
- fmt.radix = 8;
- if (fmt.flags & SPRINTF_ALTERNATE && uValue != 0) {
- outNum(MPR_LOC_PASS(ctx, loc), &fmt, "0", uValue);
- } else {
- outNum(MPR_LOC_PASS(ctx, loc), &fmt, 0, uValue);
- }
- } else {
- fmt.radix = 16;
- if (fmt.flags & SPRINTF_ALTERNATE && uValue != 0) {
- if (c == 'X') {
- outNum(MPR_LOC_PASS(ctx, loc), &fmt, "0X", uValue);
- } else {
- outNum(MPR_LOC_PASS(ctx, loc), &fmt, "0x", uValue);
- }
- } else {
- outNum(MPR_LOC_PASS(ctx, loc), &fmt, 0, uValue);
- }
- }
- break;
-
- case 'n': /* Count of chars seen thus far */
- if (fmt.flags & SPRINTF_SHORT) {
- short *count = va_arg(arg, short*);
- *count = fmt.end - fmt.start;
- } else if (fmt.flags & SPRINTF_LONG) {
- long *count = va_arg(arg, long*);
- *count = fmt.end - fmt.start;
- } else {
- int *count = va_arg(arg, int *);
- *count = fmt.end - fmt.start;
- }
- break;
-
- case 'p': /* Pointer */
-#if __WORDSIZE == 64 && BLD_FEATURE_INT64
- uValue = (unum) va_arg(arg, void*);
-#else
- uValue = (uint) (int) va_arg(arg, void*);
-#endif
- fmt.radix = 16;
- outNum(MPR_LOC_PASS(ctx, loc), &fmt, "0x", uValue);
- break;
-
- default:
- BPUT(ctx, loc, &fmt, c);
- }
- }
- }
- BPUTNULL(ctx, loc, &fmt);
-
- count = fmt.end - fmt.start;
- if (*bufPtr == 0) {
- *bufPtr = (char*) fmt.buf;
- }
- return count;
-}
-
-/******************************************************************************/
-/*
- * Output a number according to the given format. If BLD_FEATURE_INT64 is
- * defined, then uses 64 bits universally. Slower but smaller code.
- */
-
-static void outNum(MPR_LOC_DEC(ctx, loc), Format *fmt, const char *prefix,
- unum value)
-{
- char numBuf[64];
- char *cp;
- char *endp;
- char c;
- int letter, len, leadingZeros, i, fill;
-
- endp = &numBuf[sizeof(numBuf) - 1];
- *endp = '\0';
- cp = endp;
-
- /*
- * Convert to ascii
- */
- if (fmt->radix == 16) {
- do {
- letter = (int) (value % fmt->radix);
- if (letter > 9) {
- if (fmt->flags & SPRINTF_UPPER_CASE) {
- letter = 'A' + letter - 10;
- } else {
- letter = 'a' + letter - 10;
- }
- } else {
- letter += '0';
- }
- *--cp = letter;
- value /= fmt->radix;
- } while (value > 0);
-
- } else if (fmt->flags & SPRINTF_COMMA) {
- i = 1;
- do {
- *--cp = '0' + (int) (value % fmt->radix);
- value /= fmt->radix;
- if ((i++ % 3) == 0 && value > 0) {
- *--cp = ',';
- }
- } while (value > 0);
- } else {
- do {
- *--cp = '0' + (int) (value % fmt->radix);
- value /= fmt->radix;
- } while (value > 0);
- }
-
- len = endp - cp;
- fill = fmt->width - len;
-
- if (prefix != 0) {
- fill -= strlen(prefix);
- }
- leadingZeros = (fmt->precision > len) ? fmt->precision - len : 0;
- fill -= leadingZeros;
-
- if (!(fmt->flags & SPRINTF_LEFT)) {
- c = (fmt->flags & SPRINTF_LEAD_ZERO) ? '0': ' ';
- for (i = 0; i < fill; i++) {
- BPUT(ctx, loc, fmt, c);
- }
- }
- if (prefix != 0) {
- while (*prefix) {
- BPUT(ctx, loc, fmt, *prefix++);
- }
- }
- for (i = 0; i < leadingZeros; i++) {
- BPUT(ctx, loc, fmt, '0');
- }
- while (*cp) {
- BPUT(ctx, loc, fmt, *cp);
- cp++;
- }
- if (fmt->flags & SPRINTF_LEFT) {
- for (i = 0; i < fill; i++) {
- BPUT(ctx, loc, fmt, ' ');
- }
- }
-}
-
-/******************************************************************************/
-#if BLD_FEATURE_FLOATING_POINT
-/*
- * Output a floating point number
- */
-
-static void outFloat(MPR_LOC_DEC(ctx, loc), Format *fmt, char specChar,
- double value)
-{
- char *cp;
-#if FUTURE
- char numBuf[64];
- char *endp;
- char c;
- int letter, len, leadingZeros, i, fill, width, precision;
-
- endp = &numBuf[sizeof(numBuf) - 1];
- *endp = '\0';
-
- precision = fmt->precision;
- if (precision < 0) {
- precision = 6;
- } else if (precision > (sizeof(numBuf) - 1)) {
- precision = (sizeof(numBuf) - 1);
- }
- width = min(fmt->width, sizeof(numBuf) - 1);
-
- if (__isnanl(value)) {
- "nan"
- } else if (__isinfl(value)) {
- "infinity"
- } else if (value < 0) {
- prefix = "-";
- } else if (fmt.flags & SPRINTF_LEAD_SPACE) {
- prefix = " ";
- } else if (fmt.flags & SPRINTF_SIGN) {
- prefix = "+";
- }
-
-
- /*
- * Do the exponent part
- */
- cp = &numBuf[sizeof(numBuf) - precision];
- for (i = 0; i < precision; i++) {
- *cp++ = '0' + (int) (value % fmt->radix);
- value /= fmt->radix;
- }
-
- /*
- * Do the decimal part
- */
- if (fmt->flags & SPRINTF_COMMA) {
- i = 1;
- do {
- *--cp = '0' + (int) (value % fmt->radix);
- value /= fmt->radix;
- if ((i++ % 3) == 0 && value > 0) {
- *--cp = ',';
- }
- } while (value >= 1.0);
-
- } else {
- do {
- *--cp = '0' + (int) (value % fmt->radix);
- value /= fmt->radix;
- } while (value > 1.0);
- }
-
- len = endp - cp;
- fill = fmt->width - len;
-
- if (prefix != 0) {
- fill -= strlen(prefix);
- }
-
- leadingZeros = (fmt->precision > len) ? fmt->precision - len : 0;
- fill -= leadingZeros;
-
- if (!(fmt->flags & SPRINTF_LEFT)) {
- c = (fmt->flags & SPRINTF_LEAD_ZERO) ? '0': ' ';
- for (i = 0; i < fill; i++) {
- BPUT(ctx, loc, fmt, c);
- }
- }
- if (prefix != 0) {
- BPUT(ctx, loc, fmt, prefix);
- }
- for (i = 0; i < leadingZeros; i++) {
- BPUT(ctx, loc, fmt, '0');
- }
- BPUT(ctx, loc, fmt, cp);
- if (fmt->flags & SPRINTF_LEFT) {
- for (i = 0; i < fill; i++) {
- BPUT(ctx, loc, fmt, ' ');
- }
- }
-#else
- char numBuf[64];
- if (specChar == 'f') {
- sprintf(numBuf, "%*.*f", fmt->width, fmt->precision, value);
- } else if (specChar == 'g') {
- sprintf(numBuf, "%*.*g", fmt->width, fmt->precision, value);
- } else if (specChar == 'e') {
- sprintf(numBuf, "%*.*e", fmt->width, fmt->precision, value);
- }
- for (cp = numBuf; *cp; cp++) {
- BPUT(ctx, loc, fmt, *cp);
- }
-#endif
-}
-
-#endif /* BLD_FEATURE_FLOATING_POINT */
-/******************************************************************************/
-/*
- * Grow the buffer to fit new data. Return 1 if the buffer can grow.
- * Grow using the growBy size specified when creating the buffer.
- */
-
-static int growBuf(MPR_LOC_DEC(ctx, loc), Format *fmt)
-{
- uchar *newbuf;
- int buflen;
-
- buflen = fmt->endbuf - fmt->buf;
- if (fmt->maxsize >= 0 && buflen >= fmt->maxsize) {
- return 0;
- }
- if (fmt->growBy < 0) {
- /*
- * User supplied buffer
- */
- return 0;
- }
-
- newbuf = (uchar*) mprAlloc(ctx, buflen + fmt->growBy);
- if (fmt->buf) {
- memcpy(newbuf, fmt->buf, buflen);
- mprFree(fmt->buf);
- }
-
- buflen += fmt->growBy;
- fmt->end = newbuf + (fmt->end - fmt->buf);
- fmt->start = newbuf + (fmt->start - fmt->buf);
- fmt->buf = newbuf;
- fmt->endbuf = &fmt->buf[buflen];
-
- /*
- * Increase growBy to reduce overhead
- */
- if ((buflen + (fmt->growBy * 2)) < fmt->maxsize) {
- fmt->growBy *= 2;
- }
- return 1;
-}
-
-/******************************************************************************/
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/**
- * @file mprString.c
- * @brief String routines safe for embedded programming
- * @overview This module provides safe replacements for the standard
- * string library.
- * @remarks Most routines in this file are not thread-safe. It is the callers
- * responsibility to perform all thread synchronization.
- */
-
-/*
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-
-#include "mpr.h"
-
-/********************************** Includes **********************************/
-/*
- * We need to use the underlying str(cpy) routines to implement our safe
- * alternatives
- */
-#if !DOXYGEN
-#define UNSAFE_FUNCTIONS_OK 1
-#endif
-
-/******************************************************************************/
-/**************************** Safe String Handling ****************************/
-/******************************************************************************/
-
-int mprStrcpy(char *dest, int destMax, const char *src)
-{
- int len;
-
- mprAssert(dest);
- mprAssert(destMax >= 0);
- mprAssert(src);
-
- len = strlen(src);
- if (destMax > 0 && len >= destMax && len > 0) {
- return MPR_ERR_WONT_FIT;
- }
- if (len > 0) {
- memcpy(dest, src, len);
- dest[len] = '\0';
- } else {
- *dest = '\0';
- len = 0;
- }
- return len;
-}
-
-/******************************************************************************/
-
-int mprAllocStrcpy(MPR_LOC_DEC(ctx, loc), char **dest, int destMax,
- const char *src)
-{
- int len;
-
- mprAssert(dest);
- mprAssert(destMax >= 0);
- mprAssert(src);
-
- len = strlen(src);
- if (destMax > 0 && len >= destMax) {
- mprAssert(0);
- return MPR_ERR_WONT_FIT;
- }
- if (len > 0) {
- *dest = (char*) mprAllocBlock(MPR_LOC_PASS(ctx, loc), len);
- memcpy(*dest, src, len);
- (*dest)[len] = '\0';
- } else {
- *dest = (char*) mprAlloc(ctx, 1);
- *dest = '\0';
- len = 0;
- }
- return len;
-}
-
-/******************************************************************************/
-
-int mprMemcpy(char *dest, int destMax, const char *src, int nbytes)
-{
- mprAssert(dest);
- mprAssert(destMax <= 0 || destMax >= nbytes);
- mprAssert(src);
- mprAssert(nbytes >= 0);
-
- if (destMax > 0 && nbytes > destMax) {
- mprAssert(0);
- return MPR_ERR_WONT_FIT;
- }
- if (nbytes > 0) {
- memcpy(dest, src, nbytes);
- return nbytes;
- } else {
- return 0;
- }
-}
-
-/******************************************************************************/
-
-int mprAllocMemcpy(MPR_LOC_DEC(ctx, loc), char **dest, int destMax,
- const void *src, int nbytes)
-{
- mprAssert(dest);
- mprAssert(src);
- mprAssert(nbytes > 0);
- mprAssert(destMax <= 0 || destMax >= nbytes);
-
- if (destMax > 0 && nbytes > destMax) {
- mprAssert(0);
- return MPR_ERR_WONT_FIT;
- }
- if (nbytes > 0) {
- *dest = (char*) mprAllocBlock(MPR_LOC_PASS(ctx,loc), nbytes);
- if (*dest == 0) {
- return MPR_ERR_MEMORY;
- }
- memcpy(*dest, src, nbytes);
- } else {
- *dest = (char*) mprAlloc(ctx, 1);
- }
- return nbytes;
-}
-
-/******************************************************************************/
-
-static int mprCoreStrcat(MPR_LOC_DEC(ctx, loc), char **destp, int destMax,
- int existingLen, const char *delim, const char *src, va_list args)
-{
- va_list ap;
- char *dest, *str, *dp;
- int sepLen, addBytes, required;
-
- mprAssert(destp);
- mprAssert(destMax >= 0);
- mprAssert(src);
-
- dest = *destp;
- sepLen = (delim) ? strlen(delim) : 0;
-
-#ifdef __va_copy
- __va_copy(ap, args);
-#else
- ap = args;
-#endif
- addBytes = 0;
- if (existingLen > 0) {
- addBytes += sepLen;
- }
- str = (char*) src;
-
- while (str) {
- addBytes += strlen(str);
- str = va_arg(ap, char*);
- if (str) {
- addBytes += sepLen;
- }
- }
-
- required = existingLen + addBytes + 1;
- if (destMax > 0 && required >= destMax) {
- mprAssert(0);
- return MPR_ERR_WONT_FIT;
- }
-
- if (ctx != 0) {
- if (dest == 0) {
- dest = (char*) mprAllocBlock(MPR_LOC_PASS(ctx, loc), required);
- } else {
- dest = (char*) mprReallocBlock(MPR_LOC_PASS(ctx, loc), dest,
- required);
- }
- } else {
- dest = (char*) *destp;
- }
-
- dp = &dest[existingLen];
- if (delim && existingLen > 0) {
- strcpy(dp, delim);
- dp += sepLen;
- }
-
- if (addBytes > 0) {
-#ifdef __va_copy
- __va_copy(ap, args);
-#else
- ap = args;
-#endif
- str = (char*) src;
- while (str) {
- strcpy(dp, str);
- dp += strlen(str);
- str = va_arg(ap, char*);
- if (delim && str) {
- strcpy(dp, delim);
- dp += sepLen;
- }
- }
- } else if (dest == 0) {
- dest = (char*) mprAlloc(ctx, 1);
- }
- *dp = '\0';
-
- *destp = dest;
- mprAssert(dp < &dest[required]);
- return required - 1;
-}
-
-/*****************************************************************************
- Note that this VARARGS function must be NULL (not 0, this must be a
- pointer) terminated
-*/
-int mprStrcat(char *dest, int destMax, const char *delim, const char *src, ...)
-{
- va_list ap;
- int rc;
-
- mprAssert(dest);
- mprAssert(src);
-
- va_start(ap, src);
- rc = mprCoreStrcat(MPR_LOC_ARGS(0), &dest, destMax, strlen(dest),
- delim, src, ap);
- va_end(ap);
- return rc;
-}
-
-/*****************************************************************************
- Note that this VARARGS function must be NULL (not 0, this must be a
- pointer) terminated
-*/
-int mprAllocStrcat(MPR_LOC_DEC(ctx, loc), char **destp, int destMax,
- const char *delim, const char *src, ...)
-{
- va_list ap;
- int rc;
-
- mprAssert(destp);
- mprAssert(src);
-
- *destp = 0;
- va_start(ap, src);
- rc = mprCoreStrcat(MPR_LOC_PASS(ctx, loc), destp, destMax, 0, delim,
- src, ap);
- va_end(ap);
- return rc;
-}
-
-/*****************************************************************************
- Note that this VARARGS function must be NULL (not 0, this must be a
- pointer) terminated
-*/
-int mprReallocStrcat(MPR_LOC_DEC(ctx, loc), char **destp, int destMax,
- int existingLen, const char *delim, const char *src,...)
-{
- va_list ap;
- int rc;
-
- va_start(ap, src);
- rc = mprCoreStrcat(MPR_LOC_PASS(ctx, loc), destp, destMax, existingLen,
- delim, src, ap);
- va_end(ap);
- return rc;
-}
-
-/******************************************************************************/
-
-int mprStrlen(const char *src, int max)
-{
- int len;
-
- len = strlen(src);
- if (len >= max) {
- mprAssert(0);
- return MPR_ERR_WONT_FIT;
- }
- return len;
-}
-
-/******************************************************************************/
-
-char *mprStrTrim(char *str, const char *set)
-{
- int len, i;
-
- if (str == 0 || set == 0) {
- return str;
- }
-
- i = strspn(str, set);
- str += i;
-
- len = strlen(str);
- while (strspn(&str[len - 1], set) > 0) {
- str[len - 1] = '\0';
- len--;
- }
- return str;
-}
-
-/******************************************************************************/
-/*
- * Map a string to lower case (overwrites original string)
- */
-
-char *mprStrLower(char *str)
-{
- char *cp;
-
- mprAssert(str);
-
- if (str == 0) {
- return 0;
- }
-
- for (cp = str; *cp; cp++) {
- if (isupper(*cp)) {
- *cp = (char) tolower(*cp);
- }
- }
- return str;
-}
-
-/******************************************************************************/
-/*
- * Map a string to upper case (overwrites buffer)
- */
-
-char *mprStrUpper(char *str)
-{
- char *cp;
-
- mprAssert(str);
- if (str == 0) {
- return 0;
- }
-
- for (cp = str; *cp; cp++) {
- if (islower(*cp)) {
- *cp = (char) toupper(*cp);
- }
- }
- return str;
-}
-
-/******************************************************************************/
-/*
- * Case insensitive string comparison. Stop at the end of str1.
- */
-
-int mprStrcmpAnyCase(const char *str1, const char *str2)
-{
- int rc;
-
- if (str1 == 0 || str2 == 0) {
- return -1;
- }
- if (str1 == str2) {
- return 0;
- }
-
- for (rc = 0; *str1 && rc == 0; str1++, str2++) {
- rc = tolower(*str1) - tolower(*str2);
- }
- if (*str2) {
- return -1;
- }
- return rc;
-}
-
-/******************************************************************************/
-/*
- * Case insensitive string comparison. Limited by length
- */
-
-int mprStrcmpAnyCaseCount(const char *str1, const char *str2, int len)
-{
- int rc;
-
- if (str1 == 0 || str2 == 0) {
- return -1;
- }
- if (str1 == str2) {
- return 0;
- }
-
- for (rc = 0; len-- > 0 && *str1 && rc == 0; str1++, str2++) {
- rc = tolower(*str1) - tolower(*str2);
- }
- return rc;
-}
-
-/******************************************************************************/
-/*
- * Return the last portion of a pathname
- */
-
-const char *mprGetBaseName(const char *name)
-{
- char *cp;
-
- cp = strrchr(name, '/');
-
- if (cp == 0) {
- cp = strrchr(name, '\\');
- if (cp == 0) {
- return name;
- }
- }
- if (cp == name) {
- if (cp[1] == '\0') {
- return name;
- }
- } else {
- if (cp[1] == '\0') {
- return "";
- }
- }
- return &cp[1];
-}
-
-/******************************************************************************/
-/*
- * Return the directory portion of a pathname into the users buffer.
- */
-
-char *mprGetDirName(char *buf, int bufsize, const char *path)
-{
- char *cp;
- int dlen;
-
- mprAssert(path);
- mprAssert(buf);
- mprAssert(bufsize > 0);
-
- cp = strrchr(path, '/');
- if (cp == 0) {
-#if WIN
- cp = strrchr(path, '\\');
- if (cp == 0)
-#endif
- {
- buf[0] = '\0';
- return buf;
- }
- }
-
- if (cp == path && cp[1] == '\0') {
- strcpy(buf, ".");
- return buf;
- }
-
- dlen = cp - path;
- if (dlen < bufsize) {
- if (dlen == 0) {
- dlen++;
- }
- mprMemcpy(buf, bufsize, path, dlen);
- buf[dlen] = '\0';
- return buf;
- }
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Thread-safe wrapping of strtok. Note "str" is modifed as per strtok()
- */
-
-char *mprStrTok(char *str, const char *delim, char **last)
-{
- char *start, *end;
- int i;
-
- start = str ? str : *last;
-
- if (start == 0) {
- return 0;
- }
-
- i = strspn(start, delim);
- start += i;
- if (*start == '\0') {
- *last = 0;
- return 0;
- }
- end = strpbrk(start, delim);
- if (end) {
- *end++ = '\0';
- i = strspn(end, delim);
- end += i;
- }
- *last = end;
- return start;
-}
-
-/******************************************************************************/
-/*
- * Split the buffer into word tokens
- */
-
-char *mprGetWordTok(char *buf, int bufsize, const char *str, const char *delim,
- const char **tok)
-{
- const char *start, *end;
- int i, len;
-
- start = str ? str : *tok;
-
- if (start == 0) {
- return 0;
- }
-
- i = strspn(start, delim);
- start += i;
- if (*start =='\0') {
- *tok = 0;
- return 0;
- }
- end = strpbrk(start, delim);
- if (end) {
- len = min(end - start, bufsize - 1);
- mprMemcpy(buf, bufsize, start, len);
- buf[len] = '\0';
- } else {
- if (mprStrcpy(buf, bufsize, start) < 0) {
- buf[bufsize - 1] = '\0';
- return 0;
- }
- buf[bufsize - 1] = '\0';
- }
- *tok = end;
- return buf;
-}
-
-/******************************************************************************/
-/*
- * Format a number as a string.
- */
-
-char *mprItoa(char *buf, int size, int value)
-{
- char numBuf[16];
- char *cp, *dp, *endp;
- int negative;
-
- cp = &numBuf[sizeof(numBuf)];
- *--cp = '\0';
-
- if (value < 0) {
- negative = 1;
- value = -value;
- size--;
- } else {
- negative = 0;
- }
-
- do {
- *--cp = '0' + (value % 10);
- value /= 10;
- } while (value > 0);
-
- if (negative) {
- *--cp = '-';
- }
-
- dp = buf;
- endp = &buf[size];
- while (dp < endp && *cp) {
- *dp++ = *cp++;
- }
- *dp++ = '\0';
- return buf;
-}
-
-/******************************************************************************/
-/*
- * Parse an ascii number. Supports radix 10 or 16.
- */
-
-int mprAtoi(const char *str, int radix)
-{
- int c, val, negative;
-
- mprAssert(radix == 10 || radix == 16);
-
- if (str == 0) {
- return 0;
- }
-
- val = 0;
- if (radix == 10 && *str == '-') {
- negative = 1;
- str++;
- } else {
- negative = 0;
- }
-
- if (radix == 10) {
- while (*str && isdigit(*str)) {
- val = (val * radix) + *str - '0';
- str++;
- }
- } else if (radix == 16) {
- if (*str == '0' && tolower(str[1]) == 'x') {
- str += 2;
- }
- while (*str) {
- c = tolower(*str);
- if (isdigit(c)) {
- val = (val * radix) + c - '0';
- } else if (c >= 'a' && c <= 'f') {
- val = (val * radix) + c - 'a' + 10;
- } else {
- break;
- }
- str++;
- }
- }
-
- return (negative) ? -val: val;
-}
-
-/******************************************************************************/
-/*
- * Make an argv array. Caller must free by calling mprFree(argv) to free
- * everything.
- */
-
-int mprMakeArgv(MprCtx ctx, const char *program, const char *cmd,
- char ***argvp, int *argcp)
-{
- char *cp, **argv, *buf, *args;
- int size, argc;
-
- /*
- * Allocate one buffer for argv and the actual args themselves
- */
- size = strlen(cmd) + 1;
-
- buf = (char*) mprAlloc(ctx, (MPR_MAX_ARGC * sizeof(char*)) + size);
- if (buf == 0) {
- return MPR_ERR_MEMORY;
- }
-
- args = &buf[MPR_MAX_ARGC * sizeof(char*)];
- strcpy(args, cmd);
- argv = (char**) buf;
-
- argc = 0;
- if (program) {
- argv[argc++] = (char*) mprStrdup(ctx, program);
- }
-
- for (cp = args; cp && *cp != '\0'; argc++) {
- if (argc >= MPR_MAX_ARGC) {
- mprAssert(argc < MPR_MAX_ARGC);
- mprFree(buf);
- *argvp = 0;
- if (argcp) {
- *argcp = 0;
- }
- return MPR_ERR_TOO_MANY;
- }
- while (isspace(*cp)) {
- cp++;
- }
- if (*cp == '\0') {
- break;
- }
- if (*cp == '"') {
- cp++;
- argv[argc] = cp;
- while ((*cp != '\0') && (*cp != '"')) {
- cp++;
- }
- } else {
- argv[argc] = cp;
- while (*cp != '\0' && !isspace(*cp)) {
- cp++;
- }
- }
- if (*cp != '\0') {
- *cp++ = '\0';
- }
- }
- argv[argc] = 0;
-
- if (argcp) {
- *argcp = argc;
- }
- *argvp = argv;
-
- return argc;
-}
-
-/******************************************************************************/
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- * @file mprSym.cpp
- * @brief Fast hashing symbol table lookup module
- * @overview This symbol table uses a fast key lookup mechanism. Keys are
- * strings and the value entries are arbitrary pointers. The keys are
- * hashed into a series of buckets which then have a chain of hash
- * entries using the standard doubly linked list classes (List/Link).
- * The chain in in collating sequence so search time through the chain
- * is on average (N/hashSize)/2.
- * @remarks This module is not thread-safe. It is the callers responsibility
- * to perform all thread synchronization.
- */
-/********************************* Copyright **********************************/
-/*
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http: *www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http: *www.mbedthis.com
- *
- * @end
- */
-/********************************** Includes **********************************/
-
-#include "mpr.h"
-
-/**************************** Forward Declarations ****************************/
-
-static int hashIndex(const char *key, int size);
-static MprSymbol *lookupInner(int *bucketIndex, MprSymbol **prevSp,
- MprSymbolTable *table, const char *key);
-
-/*********************************** Code *************************************/
-/*
- * Create a new symbol table of a given size. Caller should provide a size
- * that is a prime number for the greatest efficiency. Caller should use
- * mprFree to free the symbol table.
- */
-
-MprSymbolTable *mprCreateSymbolTable(MprCtx ctx, int hashSize)
-{
- MprSymbolTable *table;
-
- table = mprAllocTypeZeroed(ctx, MprSymbolTable);
- if (table == 0) {
- return 0;
- }
-
- if (hashSize < MPR_DEFAULT_HASH_SIZE) {
- hashSize = MPR_DEFAULT_HASH_SIZE;
- }
- table->hashSize = hashSize;
-
- table->count = 0;
- table->hashSize = hashSize;
- table->buckets = mprAllocZeroedBlock(MPR_LOC_ARGS(table),
- sizeof(MprSymbol*) * hashSize);
-
- if (table->buckets == 0) {
- mprFree(table);
- return 0;
- }
-
- return table;
-}
-
-/******************************************************************************/
-/*
- * Insert an entry into the symbol table. If the entry already exists, update
- * its value. Order of insertion is not preserved.
- */
-
-MprSymbol *mprInsertSymbol(MprSymbolTable *table, const char *key, void *ptr)
-{
- MprSymbol *sp, *prevSp;
- int index;
-
- sp = lookupInner(&index, &prevSp, table, key);
-
- if (sp != 0) {
- /*
- * Already exists. Just update the data.
- */
- sp->data = ptr;
- return sp;
- }
-
- /*
- * New entry
- */
- sp = mprAllocTypeZeroed(table, MprSymbol);
- if (sp == 0) {
- return 0;
- }
-
- sp->data = ptr;
- sp->key = mprStrdup(sp, key);
- sp->bucket = index;
-
- sp->next = table->buckets[index];
- table->buckets[index] = sp;
-
- table->count++;
- return sp;
-}
-
-/******************************************************************************/
-/*
- * Remove an entry from the table
- */
-
-int mprRemoveSymbol(MprSymbolTable *table, const char *key)
-{
- MprSymbol *sp, *prevSp;
- int index;
-
- if ((sp = lookupInner(&index, &prevSp, table, key)) == 0) {
- return MPR_ERR_NOT_FOUND;
- }
-
- if (prevSp) {
- prevSp->next = sp->next;
- } else {
- table->buckets[index] = sp->next;
- }
- table->count--;
-
- mprFree(sp);
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Lookup a key and return the hash entry
- */
-
-void *mprLookupSymbol(MprSymbolTable *table, const char *key)
-{
- MprSymbol *sp;
-
- mprAssert(key);
-
- sp = lookupInner(0, 0, table, key);
- if (sp == 0) {
- return 0;
- }
- return sp->data;
-}
-
-/******************************************************************************/
-
-static MprSymbol *lookupInner(int *bucketIndex, MprSymbol **prevSp,
- MprSymbolTable *table, const char *key)
-{
- MprSymbol *sp, *prev;
- int index, rc;
-
- mprAssert(key);
-
- index = hashIndex(key, table->hashSize);
- if (bucketIndex) {
- *bucketIndex = index;
- }
-
- sp = table->buckets[index];
- prev = 0;
-
- while (sp) {
- rc = strcmp(sp->key, key);
- if (rc == 0) {
- if (prevSp) {
- *prevSp = prev;
- }
- return sp;
- }
- prev = sp;
- mprAssert(sp != sp->next);
- sp = sp->next;
- }
- return 0;
-}
-
-/******************************************************************************/
-
-int mprGetSymbolCount(MprSymbolTable *table)
-{
- return table->count;
-}
-
-/******************************************************************************/
-/*
- * Return the first entry in the table.
- */
-
-MprSymbol *mprGetFirstSymTab(MprSymbolTable *table)
-{
- MprSymbol *sp;
- int i;
-
- mprAssert(table);
-
- for (i = 0; i < table->hashSize; i++) {
- if ((sp = (MprSymbol*) table->buckets[i]) != 0) {
- return sp;
- }
- }
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Return the next entry in the table
- */
-
-MprSymbol *mprGetNextSymTab(MprSymbolTable *table, MprSymbol *last)
-{
- MprSymbol *sp;
- int i;
-
- mprAssert(table);
-
- if (last->next) {
- return last->next;
- }
-
- for (i = last->bucket + 1; i < table->hashSize; i++) {
- if ((sp = (MprSymbol*) table->buckets[i]) != 0) {
- return sp;
- }
- }
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Hash the key to produce a hash index.
- */
-
-static int hashIndex(const char *key, int size)
-{
- uint sum;
-
- sum = 0;
- while (*key) {
- sum += (sum * 33) + *key++;
- }
-
- return sum % size;
-}
-
-/******************************************************************************/
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- * @file mprUnix.h
- * @brief Make windows a bit more unix like
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-
-/******************************* Documentation ********************************/
-
-/*
- * This header is part of the Mbedthis Portable Runtime and aims to include
- * all necessary O/S headers and to unify the constants and declarations
- * required by Mbedthis products. It can be included by C or C++ programs.
- */
-
-/******************************************************************************/
-
-#ifndef _h_MPR_UNIX
-#define _h_MPR_UNIX 1
-
-/******************************************************************************/
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*
- * Define BLD_NO_POSIX_REMAP if these defines mess with your app
- */
-#if WIN && !BLD_NO_POSIX_REMAP
-/*
- * MOB -- clashes with ATL
- */
-#define access _access
-#define close _close
-#define fileno _fileno
-#define fstat _fstat
-#define getpid _getpid
-#define open _open
-#define putenv _putenv
-#define read _read
-#define stat _stat
-#define umask _umask
-#define unlink _unlink
-#define write _write
-#define strdup _strdup
-#define lseek _lseek
-#define getcwd _getcwd
-#define chdir _chdir
-
-#define mkdir(a,b) _mkdir(a)
-#define rmdir(a) _rmdir(a)
-
-#define R_OK 4
-#define W_OK 2
-#define MPR_TEXT "t"
-
-extern void srand48(long);
-extern long lrand48(void);
-extern long ulimit(int, ...);
-extern long nap(long);
-extern int getuid(void);
-extern int geteuid(void);
-#endif
-
-
-/******************************************************************************/
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _h_MPR_UNIX */
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-#define BLD_PRODUCT "Samba4"
-#define BLD_NAME "Samba4 WEB Applications"
-#define BLD_VERSION "4"
-#define BLD_NUMBER "1"
-#define BLD_TYPE "DEBUG"
-#define BLD_DEFAULTS "normal"
-#define BLD_PACKAGES ""
-#define BLD_APPWEB_CONFIG "normal.conf"
-#define BLD_APPWEB 0
-#define BLD_COMPANY "Mbedthis"
-#define BLD_DEBUG 0
-#define BLD_DIRS "bootstrap include obj bin mpr ejs esp http doc appWeb appWebSamples images"
-#define BLD_HTTP_PORT 7777
-#define BLD_LIB_VERSION "1.0.0"
-#define BLD_SSL_PORT 4443
-#define BLD_CLEAN_INSTALL "0"
-#define BLD_LICENSE "gpl"
-#define BLD_HOST_SYSTEM "i686-pc-linux-gnu"
-#define BLD_BUILD_SYSTEM "i686-pc-linux-gnu"
-#define BLD_HOST_OS "LINUX"
-#define BLD_HOST_CPU_ARCH MPR_CPU_IX86
-#define BLD_HOST_CPU "i686"
-#define BLD_HOST_UNIX 1
-#define BLD_BUILD_OS "LINUX"
-#define BLD_BUILD_CPU_ARCH MPR_CPU_IX86
-#define BLD_BUILD_CPU i686
-#define BLD_BUILD_UNIX 1
-#define BLD_ROOT_PREFIX "/"
-#define BLD_FEATURE_ACCESS_LOG 0
-#define BLD_FEATURE_ADMIN_MODULE 0
-#define BLD_FEATURE_ASPNET_MODULE 0
-#define BLD_FEATURE_ASSERT 1
-#define BLD_FEATURE_AUTH_MODULE 0
-#define BLD_FEATURE_C_API_MODULE 1
-#define BLD_FEATURE_C_API_CLIENT 0
-#define BLD_FEATURE_CGI_MODULE 0
-#define BLD_FEATURE_COMPAT_MODULE 0
-#define BLD_FEATURE_CONFIG_PARSE 0
-#define BLD_FEATURE_CONFIG_SAVE 0
-#define BLD_FEATURE_COOKIE 0
-#define BLD_FEATURE_COPY_MODULE 0
-#define BLD_FEATURE_DIGEST 0
-#define BLD_FEATURE_DLL 0
-#define BLD_FEATURE_EGI_MODULE 0
-#define BLD_FEATURE_EJS 1
-#define BLD_FEATURE_ESP_MODULE 1
-#define BLD_FEATURE_EVAL_PERIOD 30
-#define BLD_FEATURE_FLOATING_POINT 1
-#define BLD_FEATURE_IF_MODIFIED 0
-#define BLD_FEATURE_INT64 1
-#define BLD_FEATURE_KEEP_ALIVE 0
-#define BLD_FEATURE_LEGACY_API 0
-#define BLD_FEATURE_LIB_STDCPP 0
-#define BLD_FEATURE_LICENSE 0
-#define BLD_FEATURE_LOG 0
-#define BLD_FEATURE_MULTITHREAD 0
-#define BLD_FEATURE_MALLOC 0
-#define BLD_FEATURE_MALLOC_STATS 0
-#define BLD_FEATURE_MALLOC_LEAK 0
-#define BLD_FEATURE_MALLOC_HOOK 0
-#define BLD_FEATURE_NUM_TYPE int64_t
-#define BLD_FEATURE_NUM_TYPE_ID MPR_TYPE_INT64
-#define BLD_FEATURE_ROMFS 0
-#define BLD_FEATURE_RUN_AS_SERVICE 0
-#define BLD_FEATURE_SAFE_STRINGS 0
-#define BLD_FEATURE_SAMPLES 0
-#define BLD_FEATURE_SESSION 1
-#define BLD_FEATURE_SHARED 0
-#define BLD_FEATURE_SQUEEZE 0
-#define BLD_FEATURE_SSL_MODULE 0
-#define BLD_FEATURE_STATIC 1
-#define BLD_FEATURE_STATIC_LINK_LIBC 0
-#define BLD_FEATURE_TEST 0
-#define BLD_FEATURE_UPLOAD_MODULE 0
-#define BLD_FEATURE_XDB_MODULE 0
-#define BLD_FEATURE_ADMIN_MODULE_BUILTIN 0
-#define BLD_FEATURE_ASPNET_MODULE_BUILTIN 0
-#define BLD_FEATURE_AUTH_MODULE_BUILTIN 0
-#define BLD_FEATURE_C_API_MODULE_BUILTIN 0
-#define BLD_FEATURE_CGI_MODULE_BUILTIN 0
-#define BLD_FEATURE_COMPAT_MODULE_BUILTIN 0
-#define BLD_FEATURE_COPY_MODULE_BUILTIN 0
-#define BLD_FEATURE_EGI_MODULE_BUILTIN 0
-#define BLD_FEATURE_ESP_MODULE_BUILTIN 0
-#define BLD_FEATURE_SSL_MODULE_BUILTIN 0
-#define BLD_FEATURE_UPLOAD_MODULE_BUILTIN 0
-#define BLD_FEATURE_XDB_MODULE_BUILTIN 0
-#define BLD_FEATURE_ADMIN_MODULE_LOADABLE 0
-#define BLD_FEATURE_ASPNET_MODULE_LOADABLE 0
-#define BLD_FEATURE_AUTH_MODULE_LOADABLE 0
-#define BLD_FEATURE_C_API_MODULE_LOADABLE 0
-#define BLD_FEATURE_CGI_MODULE_LOADABLE 0
-#define BLD_FEATURE_COMPAT_MODULE_LOADABLE 0
-#define BLD_FEATURE_COPY_MODULE_LOADABLE 0
-#define BLD_FEATURE_EGI_MODULE_LOADABLE 0
-#define BLD_FEATURE_ESP_MODULE_LOADABLE 0
-#define BLD_FEATURE_SSL_MODULE_LOADABLE 0
-#define BLD_FEATURE_UPLOAD_MODULE_LOADABLE 0
-#define BLD_FEATURE_XDB_MODULE_LOADABLE 0
-#define BLD_AR_FOR_BUILD "ar"
-#define BLD_CC_FOR_BUILD "cc"
-#define BLD_CSC_FOR_BUILD ""
-#define BLD_JAVAC_FOR_BUILD ""
-#define BLD_LD_FOR_BUILD "ld"
-#define BLD_RANLIB_FOR_BUILD ""
-#define BLD_NM_FOR_BUILD "nm"
-#define BLD_CFLAGS_FOR_BUILD ""
-#define BLD_IFLAGS_FOR_BUILD ""
-#define BLD_LDFLAGS_FOR_BUILD ""
-#define BLD_ARCHIVE_FOR_BUILD ".a"
-#define BLD_EXE_FOR_BUILD ""
-#define BLD_OBJ_FOR_BUILD ".o"
-#define BLD_PIOBJ_FOR_BUILD ".lo"
-#define BLD_CLASS_FOR_BUILD ".class"
-#define BLD_SHLIB_FOR_BUILD ""
-#define BLD_SHOBJ_FOR_BUILD ".so"
-#define BLD_AR_FOR_HOST "ar"
-#define BLD_CC_FOR_HOST "cc"
-#define BLD_CSC_FOR_HOST "csc"
-#define BLD_JAVAC_FOR_HOST "javac"
-#define BLD_LD_FOR_HOST "ld"
-#define BLD_RANLIB_FOR_HOST "true"
-#define BLD_NM_FOR_HOST "nm"
-#define BLD_CFLAGS_FOR_HOST ""
-#define BLD_IFLAGS_FOR_HOST ""
-#define BLD_LDFLAGS_FOR_HOST ""
-#define BLD_ARCHIVE_FOR_HOST ".a"
-#define BLD_EXE_FOR_HOST ""
-#define BLD_OBJ_FOR_HOST ".o"
-#define BLD_PIOBJ_FOR_HOST ".lo"
-#define BLD_CLASS_FOR_HOST ".class"
-#define BLD_SHLIB_FOR_HOST ""
-#define BLD_SHOBJ_FOR_HOST ".so"
-#define BLD_TOOLS_DIR "${BLD_TOP}/bin"
-#define BLD_BIN_DIR "${BLD_TOP}/bin"
-#define BLD_INC_DIR "/usr/include/${BLD_PRODUCT}"
-#define BLD_EXP_OBJ_DIR "${BLD_TOP}/obj"
-
-#ifndef MAX_FLOAT
-#define MAX_FLOAT 3.40282347e+38F
-#endif
+++ /dev/null
-/*
- * @file ejs.h
- * @brief Primary Embedded Javascript (ECMAScript) header.
- * @overview This Embedded Javascript (EJS) header defines the
- * public API. This API should only be used by those directly
- * using EJS without using Embedded Server Pages (ESP). ESP
- * wraps all relevant APIs to expose a single consistent API.
- * \n\n
- * This API requires the mpr/var.h facilities to create and
- * manage objects and properties.
- */
-/********************************* Copyright **********************************/
-/*
- * @copy default.g
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2005. All Rights Reserved.
- * Portions Copyright (c) GoAhead Software, 1995-2000. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-/********************************** Includes **********************************/
-
-#ifndef _h_EJS
-#define _h_EJS 1
-
-#include "lib/appweb/mpr/miniMpr.h"
-#include "lib/appweb/mpr/var.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/********************************* Prototypes *********************************/
-
-typedef MprVarHandle EjsId;
-typedef MprVarHandle EjsHandle;
-
-/*
- * Multithreaded lock routines
- */
-typedef void (*EjsLock)(void *lockData);
-typedef void (*EjsUnlock)(void *lockData);
-
-/********************************* Prototypes *********************************/
-/*
- * Module management
- */
-extern int ejsOpen(EjsLock lock, EjsUnlock unlock, void *lockData);
-extern void ejsClose(void);
-extern EjsId ejsOpenEngine(EjsHandle primaryHandle, EjsHandle altHandle);
-extern void ejsCloseEngine(EjsId eid);
-
-void *ejs_save_state(void);
-void ejs_restore_state(void *ptr);
-
-/*
- * Evaluation functions
- */
-extern int ejsEvalFile(EjsId eid, char *path, MprVar *result, char **emsg);
-extern int ejsEvalScript(EjsId eid, char *script, MprVar *result,
- char **emsg);
-extern int ejsRunFunction(int eid, MprVar *obj, const char *functionName,
- MprArray *args);
-
-/*
- * Composite variable get / set routines. Can also use the MPR property
- * routines on an object variable.
- */
-extern MprVar ejsCreateObj(const char *name, int hashSize);
-extern MprVar ejsCreateArray(const char *name, int hashSize);
-extern bool ejsDestroyVar(MprVar *obj);
-extern int ejsCopyVar(EjsId eid, const char *var, MprVar *value,
- bool copyRef);
-extern int ejsReadVar(EjsId eid, const char *var, MprVar *value);
-extern int ejsWriteVar(EjsId eid, const char *var, MprVar *value);
-extern int ejsWriteVarValue(EjsId eid, const char *var, MprVar value);
-extern int ejsDeleteVar(EjsId eid, const char *var);
-
-extern MprVar *ejsGetLocalObject(EjsId eid);
-extern MprVar *ejsGetGlobalObject(EjsId eid);
-
-/*
- * Function routines
- */
-extern void ejsDefineFunction(EjsId eid, const char *functionName,
- char *args, char *body);
-extern void ejsDefineCFunction(EjsId eid, const char *functionName,
- MprCFunction fn, void *thisPtr, int flags);
-extern void ejsDefineStringCFunction(EjsId eid, const char *functionName,
- MprStringCFunction fn, void *thisPtr, int flags);
-extern void *ejsGetThisPtr(EjsId eid);
-extern MprVar *ejsGetReturnValue(EjsId eid);
-extern int ejsGetLineNumber(EjsId eid);
-extern int ejsParseArgs(int argc, char **argv, char *fmt, ...);
-extern void ejsSetErrorMsg(EjsId eid, const char* fmt, ...)
- PRINTF_ATTRIBUTE(2,3);
-extern void ejsSetReturnValue(EjsId eid, MprVar value);
-extern void ejsSetReturnString(EjsId eid, const char *str);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* _h_EJS */
-
-/*****************************************************************************/
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- * @file ejsInternal.h
- * @brief Private header for Embedded Javascript (ECMAScript)
- * @overview This Embedded Javascript header defines the private Embedded
- * Javascript internal structures.
- */
-/********************************* Copyright **********************************/
-/*
- * @copy default.g
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2005. All Rights Reserved.
- * Portions Copyright (c) GoAhead Software, 1995-2000. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-/********************************* Includes ***********************************/
-
-#ifndef _h_EJS_INTERNAL
-#define _h_EJS_INTERNAL 1
-
-#include "ejs.h"
-
-/********************************** Defines ***********************************/
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*
- * Constants
- */
-
-#if BLD_FEATURE_SQUEEZE
- #define EJS_PARSE_INCR 256 /* Growth factor */
- #define EJS_MAX_RECURSE 25 /* Sanity for maximum recursion */
- #define EJS_MAX_ID 128 /* Maximum ID length */
- #define EJS_OBJ_HASH_SIZE 13 /* Object hash table size */
- #define EJS_SMALL_OBJ_HASH_SIZE 11 /* Small object hash size */
- #define EJS_LIST_INCR 8 /* Growth increment for lists */
-#else
- #define EJS_PARSE_INCR 1024 /* Growth factor */
- #define EJS_MAX_RECURSE 100 /* Sanity for maximum recursion */
- #define EJS_MAX_ID 256 /* Maximum ID length */
- #define EJS_OBJ_HASH_SIZE 29 /* Object hash table size */
- #define EJS_SMALL_OBJ_HASH_SIZE 11 /* Small object hash size */
- #define EJS_LIST_INCR 16 /* Growth increment for lists */
-#endif
-#define EJS_TOKEN_STACK 4 /* Put back token stack */
-
-/*
- * Lexical analyser tokens
- */
-#define EJS_TOK_ERR -1 /* Any error */
-#define EJS_TOK_LPAREN 1 /* ( */
-#define EJS_TOK_RPAREN 2 /* ) */
-#define EJS_TOK_IF 3 /* if */
-#define EJS_TOK_ELSE 4 /* else */
-#define EJS_TOK_LBRACE 5 /* { */
-#define EJS_TOK_RBRACE 6 /* } */
-#define EJS_TOK_LOGICAL 7 /* ||, &&, ! */
-#define EJS_TOK_EXPR 8 /* +, -, /, % */
-#define EJS_TOK_SEMI 9 /* ; */
-#define EJS_TOK_LITERAL 10 /* literal string */
-#define EJS_TOK_FUNCTION_NAME 11 /* functionName */
-#define EJS_TOK_NEWLINE 12 /* newline white space */
-#define EJS_TOK_ID 13 /* Identifier */
-#define EJS_TOK_EOF 14 /* End of script */
-#define EJS_TOK_COMMA 15 /* Comma */
-#define EJS_TOK_VAR 16 /* var */
-#define EJS_TOK_ASSIGNMENT 17 /* = */
-#define EJS_TOK_FOR 18 /* for */
-#define EJS_TOK_INC_DEC 19 /* ++, -- */
-#define EJS_TOK_RETURN 20 /* return */
-#define EJS_TOK_PERIOD 21 /* . */
-#define EJS_TOK_LBRACKET 22 /* [ */
-#define EJS_TOK_RBRACKET 23 /* ] */
-#define EJS_TOK_NEW 24 /* new */
-#define EJS_TOK_DELETE 25 /* delete */
-#define EJS_TOK_IN 26 /* in */
-#define EJS_TOK_FUNCTION 27 /* function */
-#define EJS_TOK_NUMBER 28 /* Number */
-
-/*
- * Expression operators
- */
-#define EJS_EXPR_LESS 1 /* < */
-#define EJS_EXPR_LESSEQ 2 /* <= */
-#define EJS_EXPR_GREATER 3 /* > */
-#define EJS_EXPR_GREATEREQ 4 /* >= */
-#define EJS_EXPR_EQ 5 /* == */
-#define EJS_EXPR_NOTEQ 6 /* != */
-#define EJS_EXPR_PLUS 7 /* + */
-#define EJS_EXPR_MINUS 8 /* - */
-#define EJS_EXPR_DIV 9 /* / */
-#define EJS_EXPR_MOD 10 /* % */
-#define EJS_EXPR_LSHIFT 11 /* << */
-#define EJS_EXPR_RSHIFT 12 /* >> */
-#define EJS_EXPR_MUL 13 /* * */
-#define EJS_EXPR_ASSIGNMENT 14 /* = */
-#define EJS_EXPR_INC 15 /* ++ */
-#define EJS_EXPR_DEC 16 /* -- */
-#define EJS_EXPR_BOOL_COMP 17 /* ! */
-
-/*
- * Conditional operators
- */
-#define EJS_COND_AND 1 /* && */
-#define EJS_COND_OR 2 /* || */
-#define EJS_COND_NOT 3 /* ! */
-
-/*
- * States
- */
-#define EJS_STATE_ERR -1 /* Error state */
-#define EJS_STATE_EOF 1 /* End of file */
-#define EJS_STATE_COND 2 /* Parsing a "(conditional)" stmt */
-#define EJS_STATE_COND_DONE 3
-#define EJS_STATE_RELEXP 4 /* Parsing a relational expr */
-#define EJS_STATE_RELEXP_DONE 5
-#define EJS_STATE_EXPR 6 /* Parsing an expression */
-#define EJS_STATE_EXPR_DONE 7
-#define EJS_STATE_STMT 8 /* Parsing General statement */
-#define EJS_STATE_STMT_DONE 9
-#define EJS_STATE_STMT_BLOCK_DONE 10 /* End of block "}" */
-#define EJS_STATE_ARG_LIST 11 /* Function arg list */
-#define EJS_STATE_ARG_LIST_DONE 12
-#define EJS_STATE_DEC_LIST 16 /* Declaration list */
-#define EJS_STATE_DEC_LIST_DONE 17
-#define EJS_STATE_DEC 18 /* Declaration statement */
-#define EJS_STATE_DEC_DONE 19
-#define EJS_STATE_RET 20 /* Return statement */
-
-#define EJS_STATE_BEGIN EJS_STATE_STMT
-
-/*
- * General parsing flags.
- */
-#define EJS_FLAGS_EXE 0x1 /* Execute statements */
-#define EJS_FLAGS_LOCAL 0x2 /* Get local vars only */
-#define EJS_FLAGS_GLOBAL 0x4 /* Get global vars only */
-#define EJS_FLAGS_CREATE 0x8 /* Create var */
-#define EJS_FLAGS_ASSIGNMENT 0x10 /* In assignment stmt */
-#define EJS_FLAGS_DELETE 0x20 /* Deleting a variable */
-#define EJS_FLAGS_FOREACH 0x40 /* In foreach */
-#define EJS_FLAGS_NEW 0x80 /* In a new stmt() */
-#define EJS_FLAGS_EXIT 0x100 /* Must exit */
-
-/*
- * Putback token
- */
-
-typedef struct EjsToken {
- char *token; /* Token string */
- int id; /* Token ID */
-} EjsToken;
-
-/*
- * EJ evaluation block structure
- */
-typedef struct ejEval {
- EjsToken putBack[EJS_TOKEN_STACK]; /* Put back token stack */
- int putBackIndex; /* Top of stack index */
- MprStr line; /* Current line */
- int lineLength; /* Current line length */
- int lineNumber; /* Parse line number */
- int lineColumn; /* Column in line */
- MprStr script; /* Input script for parsing */
- char *scriptServp; /* Next token in the script */
- int scriptSize; /* Length of script */
- MprStr tokbuf; /* Current token */
- char *tokEndp; /* Pointer past end of token */
- char *tokServp; /* Pointer to next token char */
- int tokSize; /* Size of token buffer */
- struct ejEval *next; /* used for backtraces */
- const char *procName; /* gives name in backtrace */
-} EjsInput;
-
-/*
- * Function call structure
- */
-typedef struct {
- MprArray *args; /* Args for function */
- MprVar *fn; /* Function definition */
- char *procName; /* Function name */
-} EjsProc;
-
-/*
- * Per EJS structure
- */
-typedef struct ej {
- EjsHandle altHandle; /* alternate callback handle */
- MprVar *currentObj; /* Ptr to current object */
- MprVar *currentProperty; /* Ptr to current property */
- EjsId eid; /* Halloc handle */
- char *error; /* Error message */
- int exitStatus; /* Status to exit() */
- int flags; /* Flags */
- MprArray *frames; /* List of variable frames */
- MprVar *global; /* Global object */
- EjsInput *input; /* Input evaluation block */
- MprVar *local; /* Local object */
- EjsHandle primaryHandle; /* primary callback handle */
- EjsProc *proc; /* Current function */
- MprVar result; /* Variable result */
- void *thisPtr; /* C++ ptr for functions */
- int tid; /* Current token id */
- char *token; /* Pointer to token string */
- MprVar tokenNumber; /* Parsed number */
-} Ejs;
-
-typedef int EjsBlock; /* Scope block id */
-
-/*
- * Function callback when using Alternate handles.
- */
-typedef int (*EjsAltStringCFunction)(EjsHandle userHandle, EjsHandle altHandle,
- int argc, char **argv);
-typedef int (*EjsAltCFunction)(EjsHandle userHandle, EjsHandle altHandle,
- int argc, MprVar **argv);
-
-/******************************** Prototypes **********************************/
-/*
- * Ejs Lex
- */
-extern int ejsLexOpenScript(Ejs* ep, char *script);
-extern void ejsLexCloseScript(Ejs* ep);
-extern int ejsInitInputState(EjsInput *ip);
-extern void ejsLexSaveInputState(Ejs* ep, EjsInput* state);
-extern void ejsLexFreeInputState(Ejs* ep, EjsInput* state);
-extern void ejsLexRestoreInputState(Ejs* ep, EjsInput* state);
-extern int ejsLexGetToken(Ejs* ep, int state);
-extern void ejsLexPutbackToken(Ejs* ep, int tid, char *string);
-
-/*
- * Parsing
- */
-extern MprVar *ejsFindObj(Ejs *ep, int state, const char *property,
- int flags);
-extern MprVar *ejsFindProperty(Ejs *ep, int state, MprVar *obj,
- char *property, int flags);
-extern int ejsGetVarCore(Ejs *ep, const char *var, MprVar **obj,
- MprVar **varValue, int flags);
-extern int ejsParse(Ejs *ep, int state, int flags);
-extern Ejs *ejsPtr(EjsId eid);
-extern void ejsSetExitStatus(int eid, int status);
-extern void ejsSetFlags(int orFlags, int andFlags);
-
-/*
- * Create variable scope blocks
- */
-extern EjsBlock ejsOpenBlock(EjsId eid);
-extern int ejsCloseBlock(EjsId eid, EjsBlock vid);
-extern int ejsEvalBlock(EjsId eid, char *script, MprVar *v, char **err);
-extern int ejsDefineStandardProperties(MprVar *objVar);
-
-/*
- * Error handling
- */
-extern void ejsError(Ejs *ep, const char *fmt, ...) PRINTF_ATTRIBUTE(2,3);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* _h_EJS_INTERNAL */
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- * @file ejsLex.c
- * @brief EJS Lexical Analyser
- * @overview EJS lexical analyser. This implementes a lexical analyser
- * for a subset of the JavaScript language.
- */
-/********************************* Copyright **********************************/
-/*
- * @copy default.g
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2005. All Rights Reserved.
- * Portions Copyright (c) GoAhead Software, 1995-2000. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-/********************************** Includes **********************************/
-
-#include "ejsInternal.h"
-
-#if BLD_FEATURE_EJS
-
-/****************************** Forward Declarations **************************/
-
-static int getLexicalToken(Ejs *ep, int state);
-static int tokenAddChar(Ejs *ep, int c);
-static int inputGetc(Ejs *ep);
-static void inputPutback(Ejs *ep, int c);
-static int charConvert(Ejs *ep, int base, int maxDig);
-
-/************************************* Code ***********************************/
-/*
- * Open a new input script
- */
-
-int ejsLexOpenScript(Ejs *ep, char *script)
-{
- EjsInput *ip;
-
- mprAssert(ep);
- mprAssert(script);
-
- if ((ip = mprMalloc(sizeof(EjsInput))) == NULL) {
- return -1;
- }
- memset(ip, 0, sizeof(*ip));
- ip->next = ep->input;
- ep->input = ip;
- ip->procName = ep->proc?ep->proc->procName:NULL;
-
-/*
- * Create the parse token buffer and script buffer
- */
- ip->tokbuf = mprMalloc(EJS_PARSE_INCR);
- ip->tokSize = EJS_PARSE_INCR;
- ip->tokServp = ip->tokbuf;
- ip->tokEndp = ip->tokbuf;
-
- ip->script = mprStrdup(script);
- ip->scriptSize = strlen(script);
- ip->scriptServp = ip->script;
-
- ip->lineNumber = 1;
- ip->lineLength = 0;
- ip->lineColumn = 0;
- ip->line = NULL;
-
- ip->putBackIndex = -1;
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Close the input script
- */
-
-void ejsLexCloseScript(Ejs *ep)
-{
- EjsInput *ip;
- int i;
-
- mprAssert(ep);
-
- ip = ep->input;
- mprAssert(ip);
- ep->input = ip->next;
-
- for (i = 0; i < EJS_TOKEN_STACK; i++) {
- mprFree(ip->putBack[i].token);
- ip->putBack[i].token = 0;
- }
-
- mprFree(ip->line);
- mprFree(ip->tokbuf);
- mprFree(ip->script);
-
- mprFree(ip);
-}
-
-/******************************************************************************/
-/*
- * Initialize an input state structure
- */
-
-int ejsInitInputState(EjsInput *ip)
-{
- mprAssert(ip);
-
- memset(ip, 0, sizeof(*ip));
- ip->putBackIndex = -1;
-
- return 0;
-}
-/******************************************************************************/
-/*
- * Save the input state
- */
-
-void ejsLexSaveInputState(Ejs *ep, EjsInput *state)
-{
- EjsInput *ip;
- int i;
-
- mprAssert(ep);
-
- ip = ep->input;
- mprAssert(ip);
-
- *state = *ip;
-
- for (i = 0; i < ip->putBackIndex; i++) {
- state->putBack[i].token = mprStrdup(ip->putBack[i].token);
- state->putBack[i].id = ip->putBack[i].id;
- }
- for (; i < EJS_TOKEN_STACK; i++) {
- state->putBack[i].token = 0;
- }
-
- state->line = mprMalloc(ip->lineLength);
- mprStrcpy(state->line, ip->lineLength, ip->line);
-
- state->lineColumn = ip->lineColumn;
- state->lineNumber = ip->lineNumber;
- state->lineLength = ip->lineLength;
-}
-
-/******************************************************************************/
-/*
- * Restore the input state
- */
-
-void ejsLexRestoreInputState(Ejs *ep, EjsInput *state)
-{
- EjsInput *ip;
- int i;
-
- mprAssert(ep);
- mprAssert(state);
-
- ip = ep->input;
- mprAssert(ip);
-
- ip->tokbuf = state->tokbuf;
- ip->tokServp = state->tokServp;
- ip->tokEndp = state->tokEndp;
- ip->tokSize = state->tokSize;
-
- ip->script = state->script;
- ip->scriptServp = state->scriptServp;
- ip->scriptSize = state->scriptSize;
-
- ip->putBackIndex = state->putBackIndex;
- for (i = 0; i < ip->putBackIndex; i++) {
- mprFree(ip->putBack[i].token);
- ip->putBack[i].id = state->putBack[i].id;
- ip->putBack[i].token = mprStrdup(state->putBack[i].token);
- }
-
- mprFree(ip->line);
- ip->line = mprMalloc(state->lineLength);
- mprStrcpy(ip->line, state->lineLength, state->line);
-
- ip->lineColumn = state->lineColumn;
- ip->lineNumber = state->lineNumber;
- ip->lineLength = state->lineLength;
-}
-
-/******************************************************************************/
-/*
- * Free a saved input state
- */
-
-void ejsLexFreeInputState(Ejs *ep, EjsInput *state)
-{
- int i;
-
- mprAssert(ep);
- mprAssert(state);
-
- for (i = 0; i < EJS_TOKEN_STACK; i++) {
- mprFree(state->putBack[i].token);
- }
- state->putBackIndex = -1;
- mprFree(state->line);
- state->lineLength = 0;
- state->lineColumn = 0;
-}
-
-/******************************************************************************/
-/*
- * Get the next EJS token
- */
-
-int ejsLexGetToken(Ejs *ep, int state)
-{
- mprAssert(ep);
-
- ep->tid = getLexicalToken(ep, state);
- return ep->tid;
-}
-
-/******************************************************************************/
-
-/*
- * Check for reserved words "if", "else", "var", "for", "foreach",
- * "delete", "function", and "return". "new", "in" and "function"
- * done below. "true", "false", "null", "undefined" are handled
- * as global objects.
- *
- * Other reserved words not supported:
- * "break", "case", "catch", "continue", "default", "do",
- * "finally", "instanceof", "switch", "this", "throw", "try",
- * "typeof", "while", "with"
- *
- * ECMA extensions reserved words (not supported):
- * "abstract", "boolean", "byte", "char", "class", "const",
- * "debugger", "double", "enum", "export", "extends",
- * "final", "float", "goto", "implements", "import", "int",
- * "interface", "long", "native", "package", "private",
- * "protected", "public", "short", "static", "super",
- * "synchronized", "throws", "transient", "volatile"
- */
-
-static int checkReservedWord(Ejs *ep, int state, int c, int tid)
-{
- if (state == EJS_STATE_STMT) {
- if (strcmp(ep->token, "if") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_IF;
- } else if (strcmp(ep->token, "else") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_ELSE;
- } else if (strcmp(ep->token, "var") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_VAR;
- } else if (strcmp(ep->token, "for") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_FOR;
- } else if (strcmp(ep->token, "delete") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_DELETE;
- } else if (strcmp(ep->token, "function") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_FUNCTION;
- } else if (strcmp(ep->token, "return") == 0) {
- if ((c == ';') || (c == '(')) {
- inputPutback(ep, c);
- }
- return EJS_TOK_RETURN;
- }
- } else if (state == EJS_STATE_EXPR) {
- if (strcmp(ep->token, "new") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_NEW;
- } else if (strcmp(ep->token, "in") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_IN;
- } else if (strcmp(ep->token, "function") == 0) {
- inputPutback(ep, c);
- return EJS_TOK_FUNCTION;
- }
- }
- return tid;
-}
-
-/******************************************************************************/
-/*
- * Get the next EJS token
- */
-
-static int getLexicalToken(Ejs *ep, int state)
-{
- MprType type;
- EjsInput *ip;
- int done, tid, c, quote, style, idx;
-
- mprAssert(ep);
- ip = ep->input;
- mprAssert(ip);
-
- ep->tid = -1;
- tid = -1;
- type = BLD_FEATURE_NUM_TYPE_ID;
-
- /*
- * Use a putback tokens first. Don't free strings as caller needs access.
- */
- if (ip->putBackIndex >= 0) {
- idx = ip->putBackIndex;
- tid = ip->putBack[idx].id;
- ep->token = (char*) ip->putBack[idx].token;
- tid = checkReservedWord(ep, state, 0, tid);
- ip->putBackIndex--;
- return tid;
- }
- ep->token = ip->tokServp = ip->tokEndp = ip->tokbuf;
- *ip->tokServp = '\0';
-
- if ((c = inputGetc(ep)) < 0) {
- return EJS_TOK_EOF;
- }
-
- /*
- * Main lexical analyser
- */
- for (done = 0; !done; ) {
- switch (c) {
- case -1:
- return EJS_TOK_EOF;
-
- case ' ':
- case '\t':
- case '\r':
- do {
- if ((c = inputGetc(ep)) < 0)
- break;
- } while (c == ' ' || c == '\t' || c == '\r');
- break;
-
- case '\n':
- return EJS_TOK_NEWLINE;
-
- case '(':
- tokenAddChar(ep, c);
- return EJS_TOK_LPAREN;
-
- case ')':
- tokenAddChar(ep, c);
- return EJS_TOK_RPAREN;
-
- case '[':
- tokenAddChar(ep, c);
- return EJS_TOK_LBRACKET;
-
- case ']':
- tokenAddChar(ep, c);
- return EJS_TOK_RBRACKET;
-
- case '.':
- tokenAddChar(ep, c);
- return EJS_TOK_PERIOD;
-
- case '{':
- tokenAddChar(ep, c);
- return EJS_TOK_LBRACE;
-
- case '}':
- tokenAddChar(ep, c);
- return EJS_TOK_RBRACE;
-
- case '+':
- if ((c = inputGetc(ep)) < 0) {
- ejsError(ep, "Syntax Error");
- return EJS_TOK_ERR;
- }
- if (c != '+' ) {
- inputPutback(ep, c);
- tokenAddChar(ep, EJS_EXPR_PLUS);
- return EJS_TOK_EXPR;
- }
- tokenAddChar(ep, EJS_EXPR_INC);
- return EJS_TOK_INC_DEC;
-
- case '-':
- if ((c = inputGetc(ep)) < 0) {
- ejsError(ep, "Syntax Error");
- return EJS_TOK_ERR;
- }
- if (c != '-' ) {
- inputPutback(ep, c);
- tokenAddChar(ep, EJS_EXPR_MINUS);
- return EJS_TOK_EXPR;
- }
- tokenAddChar(ep, EJS_EXPR_DEC);
- return EJS_TOK_INC_DEC;
-
- case '*':
- tokenAddChar(ep, EJS_EXPR_MUL);
- return EJS_TOK_EXPR;
-
- case '%':
- tokenAddChar(ep, EJS_EXPR_MOD);
- return EJS_TOK_EXPR;
-
- case '/':
- /*
- * Handle the division operator and comments
- */
- if ((c = inputGetc(ep)) < 0) {
- ejsError(ep, "Syntax Error");
- return EJS_TOK_ERR;
- }
- if (c != '*' && c != '/') {
- inputPutback(ep, c);
- tokenAddChar(ep, EJS_EXPR_DIV);
- return EJS_TOK_EXPR;
- }
- style = c;
- /*
- * Eat comments. Both C and C++ comment styles are supported.
- */
- while (1) {
- if ((c = inputGetc(ep)) < 0) {
- if (style == '/') {
- return EJS_TOK_EOF;
- }
- ejsError(ep, "Syntax Error");
- return EJS_TOK_ERR;
- }
- if (c == '\n' && style == '/') {
- break;
- } else if (c == '*') {
- c = inputGetc(ep);
- if (style == '/') {
- if (c == '\n') {
- break;
- }
- } else {
- if (c == '/') {
- break;
- }
- }
- }
- }
- /*
- * Continue looking for a token, so get the next character
- */
- if ((c = inputGetc(ep)) < 0) {
- return EJS_TOK_EOF;
- }
- break;
-
- case '<': /* < and <= */
- if ((c = inputGetc(ep)) < 0) {
- ejsError(ep, "Syntax Error");
- return EJS_TOK_ERR;
- }
- if (c == '<') {
- tokenAddChar(ep, EJS_EXPR_LSHIFT);
- return EJS_TOK_EXPR;
- } else if (c == '=') {
- tokenAddChar(ep, EJS_EXPR_LESSEQ);
- return EJS_TOK_EXPR;
- }
- tokenAddChar(ep, EJS_EXPR_LESS);
- inputPutback(ep, c);
- return EJS_TOK_EXPR;
-
- case '>': /* > and >= */
- if ((c = inputGetc(ep)) < 0) {
- ejsError(ep, "Syntax Error");
- return EJS_TOK_ERR;
- }
- if (c == '>') {
- tokenAddChar(ep, EJS_EXPR_RSHIFT);
- return EJS_TOK_EXPR;
- } else if (c == '=') {
- tokenAddChar(ep, EJS_EXPR_GREATEREQ);
- return EJS_TOK_EXPR;
- }
- tokenAddChar(ep, EJS_EXPR_GREATER);
- inputPutback(ep, c);
- return EJS_TOK_EXPR;
-
- case '=': /* "==" */
- if ((c = inputGetc(ep)) < 0) {
- ejsError(ep, "Syntax Error");
- return EJS_TOK_ERR;
- }
- if (c == '=') {
- tokenAddChar(ep, EJS_EXPR_EQ);
- return EJS_TOK_EXPR;
- }
- inputPutback(ep, c);
- return EJS_TOK_ASSIGNMENT;
-
- case '!': /* "!=" or "!"*/
- if ((c = inputGetc(ep)) < 0) {
- ejsError(ep, "Syntax Error");
- return EJS_TOK_ERR;
- }
- if (c == '=') {
- tokenAddChar(ep, EJS_EXPR_NOTEQ);
- return EJS_TOK_EXPR;
- }
- inputPutback(ep, c);
- tokenAddChar(ep, EJS_EXPR_BOOL_COMP);
- return EJS_TOK_EXPR;
-
- case ';':
- tokenAddChar(ep, c);
- return EJS_TOK_SEMI;
-
- case ',':
- tokenAddChar(ep, c);
- return EJS_TOK_COMMA;
-
- case '|': /* "||" */
- if ((c = inputGetc(ep)) < 0 || c != '|') {
- ejsError(ep, "Syntax Error");
- return EJS_TOK_ERR;
- }
- tokenAddChar(ep, EJS_COND_OR);
- return EJS_TOK_LOGICAL;
-
- case '&': /* "&&" */
- if ((c = inputGetc(ep)) < 0 || c != '&') {
- ejsError(ep, "Syntax Error");
- return EJS_TOK_ERR;
- }
- tokenAddChar(ep, EJS_COND_AND);
- return EJS_TOK_LOGICAL;
-
- case '\"': /* String quote */
- case '\'':
- quote = c;
- if ((c = inputGetc(ep)) < 0) {
- ejsError(ep, "Syntax Error");
- return EJS_TOK_ERR;
- }
-
- while (c != quote) {
- /*
- * Check for escape sequence characters
- */
- if (c == '\\') {
- c = inputGetc(ep);
-
- if (isdigit(c)) {
- /*
- * Octal support, \101 maps to 65 = 'A'. Put first
- * char back so converter will work properly.
- */
- inputPutback(ep, c);
- c = charConvert(ep, 8, 3);
-
- } else {
- switch (c) {
- case 'n':
- c = '\n'; break;
- case 'b':
- c = '\b'; break;
- case 'f':
- c = '\f'; break;
- case 'r':
- c = '\r'; break;
- case 't':
- c = '\t'; break;
- case 'x':
- /*
- * Hex support, \x41 maps to 65 = 'A'
- */
- c = charConvert(ep, 16, 2);
- break;
- case 'u':
- /*
- * Unicode support, \x0401 maps to 65 = 'A'
- */
- c = charConvert(ep, 16, 2);
- c = c*16 + charConvert(ep, 16, 2);
-
- break;
- case '\'':
- case '\"':
- case '\\':
- break;
- default:
- ejsError(ep, "Invalid Escape Sequence");
- return EJS_TOK_ERR;
- }
- }
- if (tokenAddChar(ep, c) < 0) {
- return EJS_TOK_ERR;
- }
- } else {
- if (tokenAddChar(ep, c) < 0) {
- return EJS_TOK_ERR;
- }
- }
- if ((c = inputGetc(ep)) < 0) {
- ejsError(ep, "Unmatched Quote");
- return EJS_TOK_ERR;
- }
- }
- return EJS_TOK_LITERAL;
-
- case '0':
- if (tokenAddChar(ep, c) < 0) {
- return EJS_TOK_ERR;
- }
- if ((c = inputGetc(ep)) < 0) {
- break;
- }
- if (tolower(c) == 'x') {
- do {
- if (tokenAddChar(ep, c) < 0) {
- return EJS_TOK_ERR;
- }
- if ((c = inputGetc(ep)) < 0) {
- break;
- }
- } while (isdigit(c) || (tolower(c) >= 'a' && tolower(c) <= 'f'));
-
- mprDestroyVar(&ep->tokenNumber);
- ep->tokenNumber = mprParseVar(ep->token, type);
- inputPutback(ep, c);
- return EJS_TOK_NUMBER;
- }
- if (! isdigit(c)) {
-#if BLD_FEATURE_FLOATING_POINT
- if (c == '.' || tolower(c) == 'e' || c == '+' || c == '-') {
- /* Fall through */
- type = MPR_TYPE_FLOAT;
- } else
-#endif
- {
- mprDestroyVar(&ep->tokenNumber);
- ep->tokenNumber = mprParseVar(ep->token, type);
- inputPutback(ep, c);
- return EJS_TOK_NUMBER;
- }
- }
- /* Fall through to get more digits */
-
- case '1': case '2': case '3': case '4':
- case '5': case '6': case '7': case '8': case '9':
- do {
- if (tokenAddChar(ep, c) < 0) {
- return EJS_TOK_ERR;
- }
- if ((c = inputGetc(ep)) < 0) {
- break;
- }
-#if BLD_FEATURE_FLOATING_POINT
- if (c == '.' || tolower(c) == 'e' || tolower(c) == 'f') {
- type = MPR_TYPE_FLOAT;
- }
- } while (isdigit(c) || c == '.' || tolower(c) == 'e' || tolower(c) == 'f' ||
- ((type == MPR_TYPE_FLOAT) && (c == '+' || c == '-')));
-#else
- } while (isdigit(c));
-#endif
-
- mprDestroyVar(&ep->tokenNumber);
- ep->tokenNumber = mprParseVar(ep->token, type);
- inputPutback(ep, c);
- return EJS_TOK_NUMBER;
-
- default:
- /*
- * Identifiers or a function names
- */
- while (1) {
- if (c == '\\') {
- if ((c = inputGetc(ep)) < 0) {
- break;
- }
- if (c == '\n' || c == '\r') {
- break;
- }
- } else if (tokenAddChar(ep, c) < 0) {
- break;
- }
- if ((c = inputGetc(ep)) < 0) {
- break;
- }
- if (!isalnum(c) && c != '$' && c != '_' && c != '\\') {
- break;
- }
- }
- if (*ep->token == '\0') {
- c = inputGetc(ep);
- break;
- }
- if (! isalpha((int) *ep->token) && *ep->token != '$' &&
- *ep->token != '_') {
- ejsError(ep, "Invalid identifier %s", ep->token);
- return EJS_TOK_ERR;
- }
-
- tid = checkReservedWord(ep, state, c, EJS_TOK_ID);
- if (tid != EJS_TOK_ID) {
- return tid;
- }
-
- /*
- * Skip white space after token to find out whether this is
- * a function or not.
- */
- while (c == ' ' || c == '\t' || c == '\r' || c == '\n') {
- if ((c = inputGetc(ep)) < 0)
- break;
- }
-
- tid = EJS_TOK_ID;
- done++;
- }
- }
-
- /*
- * Putback the last extra character for next time
- */
- inputPutback(ep, c);
- return tid;
-}
-
-/******************************************************************************/
-/*
- * Convert a hex or octal character back to binary, return original char if
- * not a hex digit
- */
-
-static int charConvert(Ejs *ep, int base, int maxDig)
-{
- int i, c, lval, convChar;
-
- lval = 0;
- for (i = 0; i < maxDig; i++) {
- if ((c = inputGetc(ep)) < 0) {
- break;
- }
- /*
- * Initialize to out of range value
- */
- convChar = base;
- if (isdigit(c)) {
- convChar = c - '0';
- } else if (c >= 'a' && c <= 'f') {
- convChar = c - 'a' + 10;
- } else if (c >= 'A' && c <= 'F') {
- convChar = c - 'A' + 10;
- }
- /*
- * If unexpected character then return it to buffer.
- */
- if (convChar >= base) {
- inputPutback(ep, c);
- break;
- }
- lval = (lval * base) + convChar;
- }
- return lval;
-}
-
-/******************************************************************************/
-/*
- * Putback the last token read. Accept at most one push back token.
- */
-
-void ejsLexPutbackToken(Ejs *ep, int tid, char *string)
-{
- EjsInput *ip;
- int idx;
-
- mprAssert(ep);
- ip = ep->input;
- mprAssert(ip);
-
- ip->putBackIndex += 1;
- idx = ip->putBackIndex;
- ip->putBack[idx].id = tid;
-
- if (ip->putBack[idx].token) {
- if (ip->putBack[idx].token == string) {
- return;
- }
- mprFree(ip->putBack[idx].token);
- }
- ip->putBack[idx].token = mprStrdup(string);
-}
-
-/******************************************************************************/
-/*
- * Add a character to the token buffer
- */
-
-static int tokenAddChar(Ejs *ep, int c)
-{
- EjsInput *ip;
- uchar *oldbuf;
-
- mprAssert(ep);
- ip = ep->input;
- mprAssert(ip);
-
- if (ip->tokEndp >= &ip->tokbuf[ip->tokSize - 1]) {
- ip->tokSize += EJS_PARSE_INCR;
- oldbuf = ip->tokbuf;
- ip->tokbuf = mprRealloc(ip->tokbuf, ip->tokSize);
- if (ip->tokbuf == 0) {
- ejsError(ep, "Token too big");
- return -1;
- }
- ip->tokEndp += (int) ((uchar*) ip->tokbuf - oldbuf);
- ip->tokServp += (int) ((uchar*) ip->tokbuf - oldbuf);
- ep->token += (int) ((uchar*) ip->tokbuf - oldbuf);
- }
- *ip->tokEndp++ = c;
- *ip->tokEndp = '\0';
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Get another input character
- */
-
-static int inputGetc(Ejs *ep)
-{
- EjsInput *ip;
- int c;
-
- mprAssert(ep);
- ip = ep->input;
-
- if (ip->scriptSize <= 0) {
- return -1;
- }
-
- c = (uchar) (*ip->scriptServp++);
- ip->scriptSize--;
-
- /*
- * For debugging, accumulate the line number and the currenly parsed line
- */
- if (c == '\n') {
-#if BLD_DEBUG && 0
- if (ip->lineColumn > 0) {
- printf("PARSED: %s\n", ip->line);
- }
-#endif
- ip->lineNumber++;
- ip->lineColumn = 0;
- } else {
- if ((ip->lineColumn + 2) >= ip->lineLength) {
- ip->lineLength += 80;
- ip->line = mprRealloc(ip->line, ip->lineLength * sizeof(char));
- }
- ip->line[ip->lineColumn++] = c;
- ip->line[ip->lineColumn] = '\0';
- }
- return c;
-}
-
-/******************************************************************************/
-/*
- * Putback a character onto the input queue
- */
-
-static void inputPutback(Ejs *ep, int c)
-{
- EjsInput *ip;
-
- mprAssert(ep);
-
- if (c != 0) {
- ip = ep->input;
- *--ip->scriptServp = c;
- ip->scriptSize++;
- ip->lineColumn--;
- ip->line[ip->lineColumn] = '\0';
- }
-}
-
-/******************************************************************************/
-
-#else
-void ejsLexDummy() {}
-
-/******************************************************************************/
-#endif /* BLD_FEATURE_EJS */
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- * @file ejs.c
- * @brief Embedded JavaScript (EJS)
- * @overview Main module interface logic.
- */
-/********************************* Copyright **********************************/
-/*
- * @copy default.g
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2005. All Rights Reserved.
- * Portions Copyright (c) GoAhead Software, 1995-2000. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-/********************************** Includes **********************************/
-
-#include "ejsInternal.h"
-
-#if BLD_FEATURE_EJS
-
-/********************************** Local Data ********************************/
-
-/*
- * These fields must be locked before any access when multithreaded
- */
-static MprVar master; /* Master object */
-static MprArray *ejsList; /* List of ej handles */
-
-#if BLD_FEATURE_MULTITHREAD
-static EjsLock lock;
-static EjsUnlock unlock;
-static void *lockData;
-#define ejsLock() if (lock) { (lock)(lockData); } else
-#define ejsUnlock() if (unlock) { (unlock)(lockData); } else
-#else
-#define ejsLock()
-#define ejsUnlock()
-#endif
-
-
-/*
- save/restore global ejs state - used to cope with simultaneous ejs requests
- this is a workaround for the use of global variables in ejs
-*/
-struct ejs_state_ctx {
- MprVar master;
- MprArray *ejsList;
-};
-
-void *ejs_save_state(void)
-{
- struct ejs_state_ctx *ctx = talloc(talloc_autofree_context(), struct ejs_state_ctx);
- ctx->master = master;
- ctx->ejsList = ejsList;
- return ctx;
-}
-
-void ejs_restore_state(void *ptr)
-{
- struct ejs_state_ctx *ctx = talloc_get_type(ptr, struct ejs_state_ctx);
- master = ctx->master;
- ejsList = ctx->ejsList;
- talloc_free(ctx);
-}
-
-
-/****************************** Forward Declarations **************************/
-
-static char *getNextVarToken(char **next, char *tokBuf, int tokBufLen);
-
-/************************************* Code ***********************************/
-/*
- * Initialize the EJ subsystem
- */
-
-int ejsOpen(EjsLock lockFn, EjsUnlock unlockFn, void *data)
-{
- MprVar *np;
-
-#if BLD_FEATURE_MULTITHREAD
- if (lockFn) {
- lock = lockFn;
- unlock = unlockFn;
- lockData = data;
- }
-#endif
- ejsLock();
-
- /*
- * Master is the top level object (above global). It is used to clone its
- * contents into the global scope for each. This is never visible to the
- * user, so don't use ejsCreateObj().
- */
- master = mprCreateObjVar("master", EJS_SMALL_OBJ_HASH_SIZE);
- if (master.type == MPR_TYPE_UNDEFINED) {
- ejsUnlock();
- return MPR_ERR_CANT_ALLOCATE;
- }
-
- ejsList = mprCreateArray();
- ejsDefineStandardProperties(&master);
-
- /*
- * Make these objects immutable
- */
- np = mprGetFirstProperty(&master, MPR_ENUM_FUNCTIONS | MPR_ENUM_DATA);
- while (np) {
- mprSetVarReadonly(np, 1);
- np = mprGetNextProperty(&master, np, MPR_ENUM_FUNCTIONS |
- MPR_ENUM_DATA);
- }
- ejsUnlock();
- return 0;
-}
-
-/******************************************************************************/
-
-void ejsClose()
-{
- ejsLock();
- mprDestroyArray(ejsList);
- mprDestroyVar(&master);
- ejsUnlock();
-}
-
-/******************************************************************************/
-/*
- * Create and initialize an EJS engine
- */
-
-EjsId ejsOpenEngine(EjsHandle primaryHandle, EjsHandle altHandle)
-{
- MprVar *np;
- Ejs *ep;
-
- ep = (Ejs *)mprMalloc(sizeof(Ejs));
- if (ep == 0) {
- return (EjsId) -1;
- }
- memset(ep, 0, sizeof(Ejs));
-
- ejsLock();
- ep->eid = (EjsId) mprAddToArray(ejsList, ep);
- ejsUnlock();
-
- /*
- * Create array of local variable frames
- */
- ep->frames = mprCreateArray();
- if (ep->frames == 0) {
- ejsCloseEngine(ep->eid);
- return (EjsId) -1;
- }
- ep->primaryHandle = primaryHandle;
- ep->altHandle = altHandle;
-
- /*
- * Create first frame: global variables
- */
- ep->global = (MprVar*) mprMalloc(sizeof(MprVar));
- *ep->global = ejsCreateObj("global", EJS_OBJ_HASH_SIZE);
- if (ep->global->type == MPR_TYPE_UNDEFINED) {
- ejsCloseEngine(ep->eid);
- return (EjsId) -1;
- }
- mprAddToArray(ep->frames, ep->global);
-
- /*
- * Create first local variable frame
- */
- ep->local = (MprVar*) mprMalloc(sizeof(MprVar));
- *ep->local = ejsCreateObj("local", EJS_OBJ_HASH_SIZE);
- if (ep->local->type == MPR_TYPE_UNDEFINED) {
- ejsCloseEngine(ep->eid);
- return (EjsId) -1;
- }
- mprAddToArray(ep->frames, ep->local);
-
- /*
- * Clone all master variables into the global frame. This does a
- * reference copy.
- *
- * ejsDefineStandardProperties(ep->global);
- */
- np = mprGetFirstProperty(&master, MPR_ENUM_FUNCTIONS | MPR_ENUM_DATA);
- while (np) {
- mprCreateProperty(ep->global, np->name, np);
- np = mprGetNextProperty(&master, np, MPR_ENUM_FUNCTIONS |
- MPR_ENUM_DATA);
- }
-
- mprCreateProperty(ep->global, "global", ep->global);
- mprCreateProperty(ep->global, "this", ep->global);
- mprCreateProperty(ep->local, "local", ep->local);
-
- return ep->eid;
-}
-
-/******************************************************************************/
-/*
- * Close an EJS instance
- */
-
-void ejsCloseEngine(EjsId eid)
-{
- Ejs *ep;
- MprVar *vp;
- void **handles;
- int i;
-
- if ((ep = ejsPtr(eid)) == NULL) {
- mprAssert(ep);
- return;
- }
-
- mprFree(ep->error);
- mprDestroyVar(&ep->result);
- mprDestroyVar(&ep->tokenNumber);
-
- if (ep->local) {
- mprDeleteProperty(ep->local, "local");
- }
- mprDeleteProperty(ep->global, "this");
- mprDeleteProperty(ep->global, "global");
-
- handles = ep->frames->handles;
- for (i = 0; i < ep->frames->max; i++) {
- vp = handles[i];
- if (vp) {
-#if BLD_DEBUG
- if (vp->type == MPR_TYPE_OBJECT && vp->properties->refCount > 1) {
- mprLog(7, "ejsCloseEngine: %s has ref count %d\n",
- vp->name, vp->properties->refCount);
- }
-#endif
- mprDestroyVar(vp);
- mprFree(vp);
- mprRemoveFromArray(ep->frames, i);
- }
- }
- mprDestroyArray(ep->frames);
-
- ejsLock();
- mprRemoveFromArray(ejsList, (int) ep->eid);
- ejsUnlock();
-
- mprFree(ep);
-}
-
-/******************************************************************************/
-/*
- * Evaluate an EJS script file
- */
-
-int ejsEvalFile(EjsId eid, char *path, MprVar *result, char **emsg)
-{
- struct stat sbuf;
- Ejs *ep;
- char *script;
- int rc, fd;
-
- mprAssert(path && *path);
-
- if (emsg) {
- *emsg = NULL;
- }
-
- if ((ep = ejsPtr(eid)) == NULL) {
- mprAssert(ep);
- goto error;
- }
-
- if ((fd = open(path, O_RDONLY | O_BINARY, 0666)) < 0) {
- ejsError(ep, "Can't open %s\n", path);
- goto error;
- }
-
- if (stat(path, &sbuf) < 0) {
- close(fd);
- ejsError(ep, "Cant stat %s", path);
- goto error;
- }
-
- if ((script = (char*) mprMalloc(sbuf.st_size + 1)) == NULL) {
- close(fd);
- ejsError(ep, "Cant malloc %d", (int) sbuf.st_size);
- goto error;
- }
-
- if (read(fd, script, sbuf.st_size) != (int) sbuf.st_size) {
- close(fd);
- mprFree(script);
- ejsError(ep, "Error reading %s", path);
- goto error;
- }
-
- script[sbuf.st_size] = '\0';
- close(fd);
-
- rc = ejsEvalBlock(eid, script, result, emsg);
- mprFree(script);
-
- return rc;
-
-/*
- * Error return
- */
-error:
- if(emsg)
- *emsg = mprStrdup(ep->error);
- return -1;
-}
-
-/******************************************************************************/
-/*
- * Create a new variable scope block. This pushes the old local frame down
- * the stack and creates a new local variables frame.
- */
-
-int ejsOpenBlock(EjsId eid)
-{
- Ejs *ep;
-
- if((ep = ejsPtr(eid)) == NULL) {
- return -1;
- }
-
- ep->local = (MprVar*) mprMalloc(sizeof(MprVar));
- *ep->local = ejsCreateObj("localBlock", EJS_OBJ_HASH_SIZE);
-
- mprCreateProperty(ep->local, "local", ep->local);
-
- return mprAddToArray(ep->frames, ep->local);
-}
-
-/******************************************************************************/
-/*
- * Close a variable scope block opened via ejsOpenBlock. Pop back the old
- * local variables frame.
- */
-
-int ejsCloseBlock(EjsId eid, int fid)
-{
- Ejs *ep;
-
- if((ep = ejsPtr(eid)) == NULL) {
- mprAssert(ep);
- return -1;
- }
-
- /*
- * Must remove self-references before destroying "local"
- */
- mprDeleteProperty(ep->local, "local");
-
- mprDestroyVar(ep->local);
- mprFree(ep->local);
-
- mprRemoveFromArray(ep->frames, fid);
- ep->local = (MprVar*) ep->frames->handles[ep->frames->used - 1];
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Create a new variable scope block and evaluate a script. All frames
- * created during this context will be automatically deleted when complete.
- * vp and emsg are optional. i.e. created local variables will be discarded
- * when this routine returns.
- */
-
-int ejsEvalBlock(EjsId eid, char *script, MprVar *vp, char **emsg)
-{
- int rc, fid;
-
- mprAssert(script);
-
- fid = ejsOpenBlock(eid);
- rc = ejsEvalScript(eid, script, vp, emsg);
- ejsCloseBlock(eid, fid);
-
- return rc;
-}
-
-/******************************************************************************/
-/*
- * Parse and evaluate a EJS. Return the result in *vp. The result is "owned"
- * by EJ and the caller must not free it. Returns -1 on errors and zero
- * for success. On errors, emsg will be set to the reason. The caller must
- * free emsg.
- */
-
-int ejsEvalScript(EjsId eid, char *script, MprVar *vp, char **emsg)
-{
- Ejs *ep;
- int state;
- void *endlessLoopTest;
- int loopCounter;
-
- if (emsg) {
- *emsg = NULL;
- }
-
- if ((ep = ejsPtr(eid)) == NULL) {
- mprAssert(ep);
- return -1;
- }
-
- mprDestroyVar(&ep->result);
-
- if (script == 0) {
- return 0;
- }
-
- /*
- * Allocate a new evaluation block, and save the old one
- */
- ejsLexOpenScript(ep, script);
-
- /*
- * Do the actual parsing and evaluation
- */
- loopCounter = 0;
- endlessLoopTest = NULL;
- ep->exitStatus = 0;
-
- do {
- state = ejsParse(ep, EJS_STATE_BEGIN, EJS_FLAGS_EXE);
-
- if (state == EJS_STATE_RET) {
- state = EJS_STATE_EOF;
- }
- /*
- * Stuck parser and endless recursion protection.
- */
- if (endlessLoopTest == ep->input->scriptServp) {
- if (loopCounter++ > 10) {
- state = EJS_STATE_ERR;
- ejsError(ep, "Syntax error");
- }
- } else {
- endlessLoopTest = ep->input->scriptServp;
- loopCounter = 0;
- }
- } while (state != EJS_STATE_EOF && state != EJS_STATE_ERR);
-
- ejsLexCloseScript(ep);
-
- /*
- * Return any error string to the user
- */
- if (state == EJS_STATE_ERR && emsg) {
- *emsg = mprStrdup(ep->error);
- }
-
- if (state == EJS_STATE_ERR) {
- return -1;
- }
-
- if (vp) {
- *vp = ep->result;
- }
-
- return ep->exitStatus;
-}
-
-/******************************************************************************/
-/*
- * Core error handling
- */
-
-static void ejsErrorCore(Ejs* ep, const char *fmt, va_list args)
- PRINTF_ATTRIBUTE(2, 0);
-
-static void ejsErrorCore(Ejs* ep, const char *fmt, va_list args)
-{
- EjsInput *ip;
- char *errbuf, *msgbuf;
- int frame = 0;
-
- mprAssert(ep);
-
- msgbuf = NULL;
- mprAllocVsprintf(&msgbuf, MPR_MAX_STRING, fmt, args);
-
- ip = ep->input;
- mprAllocSprintf(&errbuf, MPR_MAX_STRING, "%s\nBacktrace:\n", msgbuf);
-
- /* form a backtrace */
- while (ip) {
- char *msg2, *ebuf2;
- mprAllocSprintf(&msg2, MPR_MAX_STRING,
- "\t[%2d] %20s:%-4d -> %s\n",
- frame++, ip->procName?ip->procName:"", ip->lineNumber, ip->line);
- ebuf2 = mprRealloc(errbuf, strlen(errbuf) + strlen(msg2) + 1);
- if (ebuf2 == NULL) break;
- errbuf = ebuf2;
- memcpy(errbuf+strlen(errbuf), msg2, strlen(msg2)+1);
- mprFree(msg2);
- ip = ip->next;
- }
- mprFree(ep->error);
- ep->error = errbuf;
- mprFree(msgbuf);
-}
-
-/******************************************************************************/
-/*
- * Internal use function to set the error message
- */
-
-void ejsError(Ejs* ep, const char* fmt, ...)
-{
- va_list args;
-
- va_start(args, fmt);
- ejsErrorCore(ep, fmt, args);
- va_end(args);
-}
-
-/******************************************************************************/
-/*
- * Public routine to set the error message
- */
-
-void ejsSetErrorMsg(EjsId eid, const char* fmt, ...)
-{
- va_list args;
- Ejs *ep;
-
- if ((ep = ejsPtr(eid)) == NULL) {
- mprAssert(ep);
- return;
- }
- va_start(args, fmt);
- ejsErrorCore(ep, fmt, args);
- va_end(args);
-}
-
-/******************************************************************************/
-/*
- * Get the current line number
- */
-
-int ejsGetLineNumber(EjsId eid)
-{
- Ejs *ep;
-
- if ((ep = ejsPtr(eid)) == NULL) {
- mprAssert(ep);
- return -1;
- }
- return ep->input->lineNumber;
-}
-
-/******************************************************************************/
-/*
- * Return the local object
- */
-
-MprVar *ejsGetLocalObject(EjsId eid)
-{
- Ejs *ep;
-
- if ((ep = ejsPtr(eid)) == NULL) {
- mprAssert(ep);
- return 0;
- }
- return ep->local;
-}
-
-/******************************************************************************/
-/*
- * Return the global object
- */
-
-MprVar *ejsGetGlobalObject(EjsId eid)
-{
- Ejs *ep;
-
- if ((ep = ejsPtr(eid)) == NULL) {
- mprAssert(ep);
- return 0;
- }
- return ep->global;
-}
-
-/******************************************************************************/
-/*
- * Copy the value of an object property. Return value is in "value".
- * If deepCopy is true, copy all object/strings. Otherwise, object reference
- * counts are incremented. Callers must always call mprDestroyVar on the
- * return value to prevent leaks.
- *
- * Returns: -1 on errors or if the variable is not found.
- */
-
-int ejsCopyVar(EjsId eid, const char *var, MprVar *value, bool deepCopy)
-{
- Ejs *ep;
- MprVar *vp;
-
- mprAssert(var && *var);
- mprAssert(value);
-
- if ((ep = ejsPtr(eid)) == NULL) {
- mprAssert(ep);
- return -1;
- }
-
- if (ejsGetVarCore(ep, var, 0, &vp, 0) < 0) {
- return -1;
- }
-
- return mprCopyProperty(value, vp, deepCopy);
-}
-
-/******************************************************************************/
-/*
- * Return the value of an object property. Return value is in "value".
- * Objects and strings are not copied and reference counts are not modified.
- * Callers should NOT call mprDestroyVar. Returns: -1 on errors or if the
- * variable is not found.
- */
-
-int ejsReadVar(EjsId eid, const char *var, MprVar *value)
-{
- Ejs *ep;
- MprVar *vp;
-
- mprAssert(var && *var);
- mprAssert(value);
-
- if ((ep = ejsPtr(eid)) == NULL) {
- mprAssert(ep);
- return -1;
- }
-
- if (ejsGetVarCore(ep, var, 0, &vp, 0) < 0) {
- return -1;
- }
-
- return mprReadProperty(vp, value);
-}
-
-/******************************************************************************/
-/*
- * Set a variable that may be an arbitrarily complex object or array reference.
- * Will always define in the top most variable frame.
- */
-
-int ejsWriteVar(EjsId eid, const char *var, MprVar *value)
-{
- Ejs *ep;
- MprVar *vp;
-
- mprAssert(var && *var);
-
- if ((ep = ejsPtr(eid)) == NULL) {
- mprAssert(ep);
- return -1;
- }
-
- if (ejsGetVarCore(ep, var, 0, &vp, EJS_FLAGS_CREATE) < 0) {
- return -1;
- }
- mprAssert(vp);
-
- /*
- * Only copy the value. Don't overwrite the object's name
- */
- mprWriteProperty(vp, value);
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Set a variable that may be an arbitrarily complex object or array reference.
- * Will always define in the top most variable frame.
- */
-
-int ejsWriteVarValue(EjsId eid, const char *var, MprVar value)
-{
- return ejsWriteVar(eid, var, &value);
-}
-
-/******************************************************************************/
-/*
- * Delete a variable
- */
-
-int ejsDeleteVar(EjsId eid, const char *var)
-{
- Ejs *ep;
- MprVar *vp;
- MprVar *obj;
-
- if ((ep = ejsPtr(eid)) == NULL) {
- mprAssert(ep);
- return -1;
- }
- if (ejsGetVarCore(ep, var, &obj, &vp, 0) < 0) {
- return -1;
- }
- mprDeleteProperty(obj, vp->name);
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Set the expression return value
- */
-
-void ejsSetReturnValue(EjsId eid, MprVar value)
-{
- Ejs *ep;
-
- if ((ep = ejsPtr(eid)) == NULL) {
- mprAssert(ep);
- return;
- }
- mprCopyVar(&ep->result, &value, MPR_SHALLOW_COPY);
-}
-
-/******************************************************************************/
-/*
- * Set the expression return value to a string value
- */
-
-void ejsSetReturnString(EjsId eid, const char *str)
-{
- Ejs *ep;
-
- if ((ep = ejsPtr(eid)) == NULL) {
- mprAssert(ep);
- return;
- }
- mprCopyVarValue(&ep->result, mprCreateStringVar(str, 0), MPR_SHALLOW_COPY);
-}
-
-/******************************************************************************/
-/*
- * Get the expression return value
- */
-
-MprVar *ejsGetReturnValue(EjsId eid)
-{
- Ejs *ep;
-
- if ((ep = ejsPtr(eid)) == NULL) {
- mprAssert(ep);
- return 0;
- }
- return &ep->result;
-}
-
-/******************************************************************************/
-/*
- * Define a C function. If eid < 0, then update the master object with this
- * function. NOTE: in this case, functionName must be simple without any "." or
- * "[]" elements. If eid >= 0, add to the specified script engine. In this
- * case, functionName can be an arbitrary object reference and can contain "."
- * or "[]".
- */
-
-void ejsDefineCFunction(EjsId eid, const char *functionName, MprCFunction fn,
- void *thisPtr, int flags)
-{
- if (eid < 0) {
- ejsLock();
- mprCreatePropertyValue(&master, functionName,
- mprCreateCFunctionVar(fn, thisPtr, flags));
- ejsUnlock();
- } else {
- ejsWriteVarValue(eid, functionName,
- mprCreateCFunctionVar(fn, thisPtr, flags));
- }
-}
-
-/******************************************************************************/
-/*
- * Define a C function with String arguments
- */
-
-void ejsDefineStringCFunction(EjsId eid, const char *functionName,
- MprStringCFunction fn, void *thisPtr, int flags)
-{
- if (eid < 0) {
- ejsLock();
- mprCreatePropertyValue(&master, functionName,
- mprCreateStringCFunctionVar(fn, thisPtr, flags));
- ejsUnlock();
- } else {
- ejsWriteVarValue(eid, functionName,
- mprCreateStringCFunctionVar(fn, thisPtr, flags));
- }
-}
-
-/******************************************************************************/
-/*
- * Define a JavaScript function. Args should be comma separated.
- * Body should not contain braces.
- */
-
-void ejsDefineFunction(EjsId eid, const char *functionName, char *args,
- char *body)
-{
- MprVar v;
-
- v = mprCreateFunctionVar(args, body, 0);
- if (eid < 0) {
- ejsLock();
- mprCreateProperty(&master, functionName, &v);
- ejsUnlock();
- } else {
- ejsWriteVar(eid, functionName, &v);
- }
- mprDestroyVar(&v);
-}
-
-/******************************************************************************/
-
-void *ejsGetThisPtr(EjsId eid)
-{
- Ejs *ep;
-
- if ((ep = ejsPtr(eid)) == NULL) {
- mprAssert(ep);
- return 0;
- }
- return ep->thisPtr;
-}
-
-/******************************************************************************/
-/*
- * Find a variable given a variable name and return the parent object and
- * the variable itself, the variable . This routine supports variable names
- * that may be objects or arrays but may NOT have expressions in the array
- * indicies. Returns -1 on errors or if the variable is not found.
- */
-
-int ejsGetVarCore(Ejs *ep, const char *vname, MprVar **obj,
- MprVar **varValue, int flags)
-{
- MprVar *currentObj;
- MprVar *currentVar;
- char tokBuf[EJS_MAX_ID];
- char *propertyName, *token, *next, *cp, *varName;
-
- if (obj) {
- *obj = 0;
- }
- if (varValue) {
- *varValue = 0;
- }
- currentObj = ejsFindObj(ep, 0, vname, flags);
- currentVar = 0;
- propertyName = 0;
-
- next = varName = mprStrdup(vname);
-
- token = getNextVarToken(&next, tokBuf, sizeof(tokBuf));
-
- while (currentObj != 0 && token != 0 && *token) {
-
- if (*token == '[') {
- token = getNextVarToken(&next, tokBuf, sizeof(tokBuf));
-
- propertyName = token;
- if (*propertyName == '\"') {
- propertyName++;
- if ((cp = strchr(propertyName, '\"')) != 0) {
- *cp = '\0';
- }
- } else if (*propertyName == '\'') {
- propertyName++;
- if ((cp = strchr(propertyName, '\'')) != 0) {
- *cp = '\0';
- }
- }
-
- currentObj = currentVar;
- currentVar = ejsFindProperty(ep, 0, currentObj, propertyName, 0);
-
- token = getNextVarToken(&next, tokBuf, sizeof(tokBuf));
- if (*token != ']') {
- mprFree(varName);
- return -1;
- }
-
- } else if (*token == '.') {
- token = getNextVarToken(&next, tokBuf, sizeof(tokBuf));
- if (!isalpha((int) token[0]) &&
- token[0] != '_' && token[0] != '$') {
- mprFree(varName);
- return -1;
- }
-
- propertyName = token;
- currentObj = currentVar;
- currentVar = ejsFindProperty(ep, 0, currentObj, token, 0);
-
- } else {
- currentVar = ejsFindProperty(ep, 0, currentObj, token, 0);
- }
- token = getNextVarToken(&next, tokBuf, sizeof(tokBuf));
- }
- mprFree(varName);
-
- if (currentVar == 0 && currentObj >= 0 && flags & EJS_FLAGS_CREATE) {
- currentVar = mprCreatePropertyValue(currentObj, propertyName,
- mprCreateUndefinedVar());
- }
- if (obj) {
- *obj = currentObj;
- }
-
- /*
- * Don't use mprCopyVar as it will copy the data
- */
- if (varValue) {
- *varValue = currentVar;
- }
- return currentVar ? 0 : -1;
-}
-
-/******************************************************************************/
-/*
- * Get the next token as part of a variable specification. This will return
- * a pointer to the next token and will return a pointer to the next token
- * (after this one) in "next". The tokBuf holds the parsed token.
- */
-static char *getNextVarToken(char **next, char *tokBuf, int tokBufLen)
-{
- char *start, *cp;
- int len;
-
- start = *next;
- while (isspace((int) *start) || *start == '\n' || *start == '\r') {
- start++;
- }
- cp = start;
-
- if (*cp == '.' || *cp == '[' || *cp == ']') {
- cp++;
- } else {
- while (*cp && *cp != '.' && *cp != '[' && *cp != ']' &&
- !isspace((int) *cp) && *cp != '\n' && *cp != '\r') {
- cp++;
- }
- }
- len = mprMemcpy(tokBuf, tokBufLen - 1, start, cp - start);
- tokBuf[len] = '\0';
-
- *next = cp;
- return tokBuf;
-}
-
-/******************************************************************************/
-/*
- * Get the EJS structure pointer
- */
-
-Ejs *ejsPtr(EjsId eid)
-{
- Ejs *handle;
- int intId;
-
- intId = (int) eid;
-
- ejsLock();
- mprAssert(0 <= intId && intId < ejsList->max);
-
- if (intId < 0 || intId >= ejsList->max || ejsList->handles[intId] == NULL) {
- mprAssert(0);
- ejsUnlock();
- return NULL;
- }
- handle = ejsList->handles[intId];
- ejsUnlock();
- return handle;
-}
-
-/******************************************************************************/
-/*
- * Utility routine to crack JavaScript arguments. Return the number of args
- * seen. This routine only supports %s and %d type args.
- *
- * Typical usage:
- *
- * if (ejsParseArgs(argc, argv, "%s %d", &name, &age) < 2) {
- * mprError("Insufficient args\n");
- * return -1;
- * }
- */
-
-int ejsParseArgs(int argc, char **argv, char *fmt, ...)
-{
- va_list vargs;
- bool *bp;
- char *cp, **sp, *s;
- int *ip, argn;
-
- va_start(vargs, fmt);
-
- if (argv == 0) {
- return 0;
- }
-
- for (argn = 0, cp = fmt; cp && *cp && argn < argc && argv[argn]; ) {
- if (*cp++ != '%') {
- continue;
- }
-
- s = argv[argn];
- switch (*cp) {
- case 'b':
- bp = va_arg(vargs, bool*);
- if (bp) {
- if (strcmp(s, "true") == 0 || s[0] == '1') {
- *bp = 1;
- } else {
- *bp = 0;
- }
- } else {
- *bp = 0;
- }
- break;
-
- case 'd':
- ip = va_arg(vargs, int*);
- *ip = atoi(s);
- break;
-
- case 's':
- sp = va_arg(vargs, char**);
- *sp = s;
- break;
-
- default:
- mprAssert(0);
- }
- argn++;
- }
-
- va_end(vargs);
- return argn;
-}
-
-/******************************************************************************/
-
-#else
-void ejsDummy() {}
-
-/******************************************************************************/
-#endif /* BLD_FEATURE_EJS */
-
-/******************************************************************************/
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- * @file ejsParser.c
- * @brief EJS Parser and Execution
- */
-/********************************* Copyright **********************************/
-/*
- * @copy default.g
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2005. All Rights Reserved.
- * Portions Copyright (c) GoAhead Software, 1995-2000. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-
-/********************************** Includes **********************************/
-
-#include "ejsInternal.h"
-
-#if BLD_FEATURE_EJS
-
-/****************************** Forward Declarations **************************/
-
-static void appendValue(MprVar *v1, MprVar *v2);
-static int evalCond(Ejs *ep, MprVar *lhs, int rel, MprVar *rhs);
-static int evalExpr(Ejs *ep, MprVar *lhs, int rel, MprVar *rhs);
-#if BLD_FEATURE_FLOATING_POINT
-static int evalFloatExpr(Ejs *ep, double l, int rel, double r);
-#endif
-static int evalBoolExpr(Ejs *ep, bool l, int rel, bool r);
-static int evalPtrExpr(Ejs *ep, void *l, int rel, void *r);
-static int evalNumericExpr(Ejs *ep, MprNum l, int rel, MprNum r);
-static int evalStringExpr(Ejs *ep, MprVar *lhs, int rel, MprVar *rhs);
-static int evalFunction(Ejs *ep, MprVar *obj, int flags);
-static void freeProc(EjsProc *proc);
-static int parseArgs(Ejs *ep, int state, int flags);
-static int parseAssignment(Ejs *ep, int state, int flags, char *id,
- char *fullName);
-static int parseCond(Ejs *ep, int state, int flags);
-static int parseDeclaration(Ejs *ep, int state, int flags);
-static int parseExpr(Ejs *ep, int state, int flags);
-static int parseFor(Ejs *ep, int state, int flags);
-static int parseForIn(Ejs *ep, int state, int flags);
-static int parseFunctionDec(Ejs *ep, int state, int flags);
-static int parseFunction(Ejs *ep, int state, int flags, char *id);
-static int parseId(Ejs *ep, int state, int flags, char **id,
- char **fullName, int *fullNameLen, int *done);
-static int parseInc(Ejs *ep, int state, int flags);
-static int parseIf(Ejs *ep, int state, int flags, int *done);
-static int parseStmt(Ejs *ep, int state, int flags);
-static void removeNewlines(Ejs *ep, int state);
-static void updateResult(Ejs *ep, int state, int flags, MprVar *vp);
-
-/************************************* Code ***********************************/
-/*
- * Recursive descent parser for EJS
- */
-
-int ejsParse(Ejs *ep, int state, int flags)
-{
- mprAssert(ep);
-
- switch (state) {
- /*
- * Any statement, function arguments or conditional expressions
- */
- case EJS_STATE_STMT:
- if ((state = parseStmt(ep, state, flags)) != EJS_STATE_STMT_DONE &&
- state != EJS_STATE_EOF && state != EJS_STATE_STMT_BLOCK_DONE &&
- state != EJS_STATE_RET) {
- state = EJS_STATE_ERR;
- }
- break;
-
- case EJS_STATE_DEC:
- if ((state = parseStmt(ep, state, flags)) != EJS_STATE_DEC_DONE &&
- state != EJS_STATE_EOF) {
- state = EJS_STATE_ERR;
- }
- break;
-
- case EJS_STATE_EXPR:
- if ((state = parseStmt(ep, state, flags)) != EJS_STATE_EXPR_DONE &&
- state != EJS_STATE_EOF) {
- state = EJS_STATE_ERR;
- }
- break;
-
- /*
- * Variable declaration list
- */
- case EJS_STATE_DEC_LIST:
- state = parseDeclaration(ep, state, flags);
- break;
-
- /*
- * Function argument string
- */
- case EJS_STATE_ARG_LIST:
- state = parseArgs(ep, state, flags);
- break;
-
- /*
- * Logical condition list (relational operations separated by &&, ||)
- */
- case EJS_STATE_COND:
- state = parseCond(ep, state, flags);
- break;
-
- /*
- * Expression list
- */
- case EJS_STATE_RELEXP:
- state = parseExpr(ep, state, flags);
- break;
- }
-
- if (state == EJS_STATE_ERR && ep->error == NULL) {
- ejsError(ep, "Syntax error");
- }
- return state;
-}
-
-/******************************************************************************/
-/*
- * Parse any statement including functions and simple relational operations
- */
-
-static int parseStmt(Ejs *ep, int state, int flags)
-{
- EjsProc *saveProc;
- MprVar *vp, *saveObj;
- char *id, *fullName, *initToken;
- int done, expectSemi, tid, fullNameLen, rel;
- int initId;
-
- mprAssert(ep);
-
- expectSemi = 0;
- saveProc = NULL;
- id = 0;
- fullName = 0;
- fullNameLen = 0;
-
- ep->currentObj = 0;
- ep->currentProperty = 0;
-
- for (done = 0; !done && state != EJS_STATE_ERR; ) {
- tid = ejsLexGetToken(ep, state);
-
- switch (tid) {
- default:
- ejsLexPutbackToken(ep, EJS_TOK_EXPR, ep->token);
- done++;
- break;
-
- case EJS_TOK_EXPR:
- rel = (int) *ep->token;
- if (state == EJS_STATE_EXPR) {
- ejsLexPutbackToken(ep, EJS_TOK_EXPR, ep->token);
- }
- done++;
- break;
-
- case EJS_TOK_LOGICAL:
- ejsLexPutbackToken(ep, tid, ep->token);
- done++;
- break;
-
- case EJS_TOK_ERR:
- state = EJS_STATE_ERR;
- done++;
- break;
-
- case EJS_TOK_EOF:
- state = EJS_STATE_EOF;
- done++;
- break;
-
- case EJS_TOK_NEWLINE:
- break;
-
- case EJS_TOK_SEMI:
- /*
- * This case is when we discover no statement and just a lone ';'
- */
- if (state != EJS_STATE_STMT) {
- ejsLexPutbackToken(ep, tid, ep->token);
- }
- done++;
- break;
-
- case EJS_TOK_PERIOD:
- if (flags & EJS_FLAGS_EXE) {
- if (ep->currentProperty == 0) {
- ejsError(ep, "Undefined object \"%s\"\n", id);
- goto error;
- }
- }
- ep->currentObj = ep->currentProperty;
-
- if ((tid = ejsLexGetToken(ep, state)) != EJS_TOK_ID) {
- ejsError(ep, "Bad property after '.': %s\n", ep->token);
- goto error;
- }
- mprFree(id);
- id = mprStrdup(ep->token);
-
- vp = ejsFindProperty(ep, state, ep->currentObj, id, flags);
- updateResult(ep, state, flags, vp);
-
-#if BLD_DEBUG
- fullNameLen = mprReallocStrcat(&fullName, MPR_MAX_VAR, fullNameLen,
- 0, ".", NULL);
-#endif
-
- ep->currentProperty = vp;
- ejsLexPutbackToken(ep, tid, ep->token);
- break;
-
- case EJS_TOK_LBRACKET:
- ep->currentObj = ep->currentProperty;
- saveObj = ep->currentObj;
- if (ejsParse(ep, EJS_STATE_RELEXP, flags) != EJS_STATE_RELEXP_DONE){
- goto error;
- }
- ep->currentObj = saveObj;
-
- mprFree(id);
- mprVarToString(&id, MPR_MAX_STRING, 0, &ep->result);
-
- if (id[0] == '\0') {
- if (flags & EJS_FLAGS_EXE) {
- ejsError(ep,
- "[] expression evaluates to the empty string\n");
- goto error;
- }
- } else {
- vp = ejsFindProperty(ep, state, ep->currentObj, id, flags);
- ep->currentProperty = vp;
- updateResult(ep, state, flags, vp);
- }
-
-#if BLD_DEBUG
- if (id[0] && strlen(id) < (MPR_MAX_VAR / 2)) {
- /*
- * If not executing yet, id may not be known
- */
- fullNameLen = mprReallocStrcat(&fullName, MPR_MAX_VAR,
- fullNameLen, 0, "[", id, "]", NULL);
- }
-#endif
-
- if ((tid = ejsLexGetToken(ep, state)) != EJS_TOK_RBRACKET) {
- ejsError(ep, "Missing ']'\n");
- goto error;
- }
- break;
-
- case EJS_TOK_ID:
- state = parseId(ep, state, flags, &id, &fullName, &fullNameLen,
- &done);
- if (done && state == EJS_STATE_STMT) {
- expectSemi++;
- }
- break;
-
- case EJS_TOK_ASSIGNMENT:
- state = parseAssignment(ep, state, flags, id, fullName);
- if (state == EJS_STATE_STMT) {
- expectSemi++;
- done++;
- }
- break;
-
- case EJS_TOK_INC_DEC:
- state = parseInc(ep, state, flags);
- if (state == EJS_STATE_STMT) {
- expectSemi++;
- }
- break;
-
- case EJS_TOK_NEW:
- if (ejsParse(ep, EJS_STATE_EXPR, flags | EJS_FLAGS_NEW)
- != EJS_STATE_EXPR_DONE) {
- goto error;
- }
- break;
-
- case EJS_TOK_DELETE:
- if (ejsParse(ep, EJS_STATE_EXPR,
- flags | EJS_FLAGS_DELETE) != EJS_STATE_EXPR_DONE) {
- goto error;
- }
- if (flags & EJS_FLAGS_EXE) {
- mprDeleteProperty(ep->currentObj, ep->currentProperty->name);
- }
- done++;
- break;
-
- case EJS_TOK_FUNCTION:
- state = parseFunctionDec(ep, state, flags);
- done++;
- break;
-
- case EJS_TOK_LITERAL:
- /*
- * Set the result to the string literal
- */
- mprCopyVarValue(&ep->result, mprCreateStringVar(ep->token, 0),
- MPR_SHALLOW_COPY);
- if (state == EJS_STATE_STMT) {
- expectSemi++;
- }
- done++;
- break;
-
- case EJS_TOK_NUMBER:
- /*
- * Set the result to the parsed number
- */
- mprCopyVar(&ep->result, &ep->tokenNumber, 0);
- if (state == EJS_STATE_STMT) {
- expectSemi++;
- }
- done++;
- break;
-
- case EJS_TOK_FUNCTION_NAME:
- state = parseFunction(ep, state, flags, id);
- if (state == EJS_STATE_STMT) {
- expectSemi++;
- }
- if (ep->flags & EJS_FLAGS_EXIT) {
- state = EJS_STATE_RET;
- }
- done++;
- break;
-
- case EJS_TOK_IF:
- state = parseIf(ep, state, flags, &done);
- if (state == EJS_STATE_RET) {
- goto doneParse;
- }
- break;
-
- case EJS_TOK_FOR:
- if (state != EJS_STATE_STMT) {
- goto error;
- }
- if (ejsLexGetToken(ep, state) != EJS_TOK_LPAREN) {
- goto error;
- }
- /*
- * Need to peek 2-3 tokens ahead and see if this is a
- * for ([var] x in set)
- * or
- * for (init ; whileCond; incr)
- */
- initId = ejsLexGetToken(ep, EJS_STATE_EXPR);
- if (initId == EJS_TOK_ID && strcmp(ep->token, "var") == 0) {
- /* Simply eat var tokens */
- initId = ejsLexGetToken(ep, EJS_STATE_EXPR);
- }
- initToken = mprStrdup(ep->token);
-
- tid = ejsLexGetToken(ep, EJS_STATE_EXPR);
-
- ejsLexPutbackToken(ep, tid, ep->token);
- ejsLexPutbackToken(ep, initId, initToken);
- mprFree(initToken);
-
- if (tid == EJS_TOK_IN) {
- if ((state = parseForIn(ep, state, flags)) < 0) {
- goto error;
- }
- } else {
- if ((state = parseFor(ep, state, flags)) < 0) {
- goto error;
- }
- }
- done++;
- break;
-
- case EJS_TOK_VAR:
- if (ejsParse(ep, EJS_STATE_DEC_LIST, flags)
- != EJS_STATE_DEC_LIST_DONE) {
- goto error;
- }
- done++;
- break;
-
- case EJS_TOK_COMMA:
- ejsLexPutbackToken(ep, tid, ep->token);
- done++;
- break;
-
- case EJS_TOK_LPAREN:
- if (state == EJS_STATE_EXPR) {
- if (ejsParse(ep, EJS_STATE_RELEXP, flags)
- != EJS_STATE_RELEXP_DONE) {
- goto error;
- }
- if (ejsLexGetToken(ep, state) != EJS_TOK_RPAREN) {
- goto error;
- }
- }
- done++;
- break;
-
- case EJS_TOK_RPAREN:
- ejsLexPutbackToken(ep, tid, ep->token);
- done++;
- break;
-
- case EJS_TOK_LBRACE:
- /*
- * This handles any code in braces except "if () {} else {}"
- */
- if (state != EJS_STATE_STMT) {
- goto error;
- }
-
- /*
- * Parse will return EJS_STATE_STMT_BLOCK_DONE when the RBRACE
- * is seen.
- */
- do {
- state = ejsParse(ep, EJS_STATE_STMT, flags);
- } while (state == EJS_STATE_STMT_DONE);
-
- if (state != EJS_STATE_RET) {
- if (ejsLexGetToken(ep, state) != EJS_TOK_RBRACE) {
- goto error;
- }
- state = EJS_STATE_STMT_DONE;
- }
- done++;
- break;
-
- case EJS_TOK_RBRACE:
- if (state == EJS_STATE_STMT) {
- ejsLexPutbackToken(ep, tid, ep->token);
- state = EJS_STATE_STMT_BLOCK_DONE;
- done++;
- break;
- }
- goto error;
-
- case EJS_TOK_RETURN:
- if (ejsParse(ep, EJS_STATE_RELEXP, flags)
- != EJS_STATE_RELEXP_DONE) {
- goto error;
- }
- if (flags & EJS_FLAGS_EXE) {
- while (ejsLexGetToken(ep, state) != EJS_TOK_EOF) {
- ;
- }
- state = EJS_STATE_RET;
- done++;
- }
- break;
- }
- }
-
- if (expectSemi) {
- tid = ejsLexGetToken(ep, state);
- if (tid != EJS_TOK_SEMI && tid != EJS_TOK_NEWLINE &&
- tid != EJS_TOK_EOF) {
- goto error;
- }
-
- /*
- * Skip newline after semi-colon
- */
- removeNewlines(ep, state);
- }
-
-/*
- * Free resources and return the correct status
- */
-doneParse:
- mprFree(id);
- mprFree(fullName);
-
- /*
- * Advance the state
- */
- switch (state) {
- case EJS_STATE_STMT:
- return EJS_STATE_STMT_DONE;
-
- case EJS_STATE_DEC:
- return EJS_STATE_DEC_DONE;
-
- case EJS_STATE_EXPR:
- return EJS_STATE_EXPR_DONE;
-
- case EJS_STATE_STMT_DONE:
- case EJS_STATE_STMT_BLOCK_DONE:
- case EJS_STATE_EOF:
- case EJS_STATE_RET:
- return state;
-
- default:
- return EJS_STATE_ERR;
- }
-
-/*
- * Common error exit
- */
-error:
- state = EJS_STATE_ERR;
- goto doneParse;
-}
-
-/******************************************************************************/
-/*
- * Parse function arguments
- */
-
-static int parseArgs(Ejs *ep, int state, int flags)
-{
- int tid;
-
- mprAssert(ep);
-
- do {
- /*
- * Peek and see if there are no args
- */
- tid = ejsLexGetToken(ep, state);
- ejsLexPutbackToken(ep, tid, ep->token);
- if (tid == EJS_TOK_RPAREN) {
- break;
- }
-
- state = ejsParse(ep, EJS_STATE_RELEXP, flags);
- if (state == EJS_STATE_EOF || state == EJS_STATE_ERR) {
- return state;
- }
- if (state == EJS_STATE_RELEXP_DONE) {
- if (flags & EJS_FLAGS_EXE) {
- mprAssert(ep->proc->args);
- mprAddToArray(ep->proc->args,
- mprDupVar(&ep->result, MPR_SHALLOW_COPY));
- }
- }
- /*
- * Peek at the next token, continue if more args (ie. comma seen)
- */
- tid = ejsLexGetToken(ep, state);
- if (tid != EJS_TOK_COMMA) {
- ejsLexPutbackToken(ep, tid, ep->token);
- }
- } while (tid == EJS_TOK_COMMA);
-
- if (tid != EJS_TOK_RPAREN && state != EJS_STATE_RELEXP_DONE) {
- return EJS_STATE_ERR;
- }
- return EJS_STATE_ARG_LIST_DONE;
-}
-
-/******************************************************************************/
-/*
- * Parse an assignment statement
- */
-
-static int parseAssignment(Ejs *ep, int state, int flags, char *id,
- char *fullName)
-{
- MprVar *vp, *saveProperty, *saveObj;
-
- if (id == 0) {
- return -1;
- }
-
- saveObj = ep->currentObj;
- saveProperty = ep->currentProperty;
- if (ejsParse(ep, EJS_STATE_RELEXP, flags | EJS_FLAGS_ASSIGNMENT)
- != EJS_STATE_RELEXP_DONE) {
- return -1;
- }
- ep->currentObj = saveObj;
- ep->currentProperty = saveProperty;
-
- if (! (flags & EJS_FLAGS_EXE)) {
- return state;
- }
-
- if (ep->currentProperty) {
- /*
- * Update the variable. Update the property name if not
- * yet defined.
- */
- if (ep->currentProperty->name == 0 ||
- ep->currentProperty->name[0] == '\0') {
- mprSetVarName(ep->currentProperty, id);
- }
- if (mprWriteProperty(ep->currentProperty, &ep->result) < 0){
- ejsError(ep, "Can't write to variable\n");
- return -1;
- }
-
- } else {
- /*
- * Create the variable
- */
- if (ep->currentObj) {
- if (ep->currentObj->type != MPR_TYPE_OBJECT) {
- if (strcmp(ep->currentObj->name, "session") == 0) {
- ejsError(ep, "Variable \"%s\" is not an array or object."
- "If using ESP, you need useSession(); in your page.",
- ep->currentObj->name);
- } else {
- ejsError(ep, "Variable \"%s\" is not an array or object",
- ep->currentObj->name);
- }
- return -1;
- }
- vp = mprCreateProperty(ep->currentObj, id, &ep->result);
-
- } else {
- /*
- * Standard says: "var x" means declare locally.
- * "x = 2" means declare globally if x is undefined.
- */
- if (state == EJS_STATE_DEC) {
- vp = mprCreateProperty(ep->local, id, &ep->result);
- } else {
- vp = mprCreateProperty(ep->global, id, &ep->result);
- }
- }
-#if BLD_DEBUG
- mprSetVarFullName(vp, fullName);
-#endif
- }
- return state;
-}
-
-/******************************************************************************/
-/*
- * Parse conditional expression (relational ops separated by ||, &&)
- */
-
-static int parseCond(Ejs *ep, int state, int flags)
-{
- MprVar lhs, rhs;
- int tid, operator;
-
- mprAssert(ep);
-
- mprDestroyVar(&ep->result);
- rhs = lhs = mprCreateUndefinedVar();
- operator = 0;
-
- do {
- /*
- * Recurse to handle one side of a conditional. Accumulate the
- * left hand side and the final result in ep->result.
- */
- state = ejsParse(ep, EJS_STATE_RELEXP, flags);
- if (state != EJS_STATE_RELEXP_DONE) {
- state = EJS_STATE_ERR;
- break;
- }
-
- if (operator > 0) {
- mprCopyVar(&rhs, &ep->result, MPR_SHALLOW_COPY);
- if (evalCond(ep, &lhs, operator, &rhs) < 0) {
- state = EJS_STATE_ERR;
- break;
- }
- }
- mprCopyVar(&lhs, &ep->result, MPR_SHALLOW_COPY);
-
- tid = ejsLexGetToken(ep, state);
- if (tid == EJS_TOK_LOGICAL) {
- operator = (int) *ep->token;
-
- } else if (tid == EJS_TOK_RPAREN || tid == EJS_TOK_SEMI) {
- ejsLexPutbackToken(ep, tid, ep->token);
- state = EJS_STATE_COND_DONE;
- break;
-
- } else {
- ejsLexPutbackToken(ep, tid, ep->token);
- }
- tid = (state == EJS_STATE_RELEXP_DONE);
-
- } while (state == EJS_STATE_RELEXP_DONE);
-
- mprDestroyVar(&lhs);
- mprDestroyVar(&rhs);
- return state;
-}
-
-/******************************************************************************/
-/*
- * Parse variable declaration list. Declarations can be of the following forms:
- * var x;
- * var x, y, z;
- * var x = 1 + 2 / 3, y = 2 + 4;
- *
- * We set the variable to NULL if there is no associated assignment.
- */
-
-static int parseDeclaration(Ejs *ep, int state, int flags)
-{
- int tid;
-
- mprAssert(ep);
-
- do {
- if ((tid = ejsLexGetToken(ep, state)) != EJS_TOK_ID) {
- return EJS_STATE_ERR;
- }
- ejsLexPutbackToken(ep, tid, ep->token);
-
- /*
- * Parse the entire assignment or simple identifier declaration
- */
- if (ejsParse(ep, EJS_STATE_DEC, flags) != EJS_STATE_DEC_DONE) {
- return EJS_STATE_ERR;
- }
-
- /*
- * Peek at the next token, continue if comma seen
- */
- tid = ejsLexGetToken(ep, state);
- if (tid == EJS_TOK_SEMI) {
- return EJS_STATE_DEC_LIST_DONE;
- } else if (tid != EJS_TOK_COMMA) {
- return EJS_STATE_ERR;
- }
- } while (tid == EJS_TOK_COMMA);
-
- if (tid != EJS_TOK_SEMI) {
- return EJS_STATE_ERR;
- }
- return EJS_STATE_DEC_LIST_DONE;
-}
-
-/******************************************************************************/
-/*
- * Parse expression (leftHandSide operator rightHandSide)
- */
-
-static int parseExpr(Ejs *ep, int state, int flags)
-{
- MprVar lhs, rhs;
- int rel, tid;
-
- mprAssert(ep);
-
- mprDestroyVar(&ep->result);
- rhs = lhs = mprCreateUndefinedVar();
- rel = 0;
- tid = 0;
-
- do {
- /*
- * This loop will handle an entire expression list. We call parse
- * to evalutate each term which returns the result in ep->result.
- */
- if (tid == EJS_TOK_LOGICAL) {
- state = ejsParse(ep, EJS_STATE_RELEXP, flags);
- if (state != EJS_STATE_RELEXP_DONE) {
- state = EJS_STATE_ERR;
- break;
- }
- } else {
- tid = ejsLexGetToken(ep, state);
- if (tid == EJS_TOK_EXPR && (int) *ep->token == EJS_EXPR_MINUS) {
- lhs = mprCreateIntegerVar(0);
- rel = (int) *ep->token;
- } else {
- ejsLexPutbackToken(ep, tid, ep->token);
- }
-
- state = ejsParse(ep, EJS_STATE_EXPR, flags);
- if (state != EJS_STATE_EXPR_DONE) {
- state = EJS_STATE_ERR;
- break;
- }
- }
-
- if (rel > 0) {
- mprCopyVar(&rhs, &ep->result, MPR_SHALLOW_COPY);
- if (tid == EJS_TOK_LOGICAL) {
- if (evalCond(ep, &lhs, rel, &rhs) < 0) {
- state = EJS_STATE_ERR;
- break;
- }
- } else {
- if (evalExpr(ep, &lhs, rel, &rhs) < 0) {
- state = EJS_STATE_ERR;
- break;
- }
- }
- }
- mprCopyVar(&lhs, &ep->result, MPR_SHALLOW_COPY);
-
- if ((tid = ejsLexGetToken(ep, state)) == EJS_TOK_EXPR ||
- tid == EJS_TOK_INC_DEC || tid == EJS_TOK_LOGICAL) {
- rel = (int) *ep->token;
-
- } else {
- ejsLexPutbackToken(ep, tid, ep->token);
- state = EJS_STATE_RELEXP_DONE;
- }
-
- } while (state == EJS_STATE_EXPR_DONE);
-
- mprDestroyVar(&lhs);
- mprDestroyVar(&rhs);
-
- return state;
-}
-
-/******************************************************************************/
-/*
- * Parse the "for ... in" statement. Format for the statement is:
- *
- * for (var in expr) {
- * body;
- * }
- */
-
-static int parseForIn(Ejs *ep, int state, int flags)
-{
- EjsInput endScript, bodyScript;
- MprVar *iteratorVar, *setVar, *vp, v;
- int forFlags, tid;
-
- mprAssert(ep);
-
- tid = ejsLexGetToken(ep, state);
- if (tid != EJS_TOK_ID) {
- return -1;
- }
- ejsLexPutbackToken(ep, tid, ep->token);
-
- if (ejsParse(ep, EJS_STATE_EXPR, EJS_FLAGS_FOREACH | EJS_FLAGS_EXE)
- != EJS_STATE_EXPR_DONE) {
- return -1;
- }
- if (ep->currentProperty == 0) {
- return -1;
- }
- iteratorVar = ep->currentProperty;
-
- if (ejsLexGetToken(ep, state) != EJS_TOK_IN) {
- return -1;
- }
-
- /*
- * Get the set
- */
- tid = ejsLexGetToken(ep, state);
- if (tid != EJS_TOK_ID) {
- return -1;
- }
- ejsLexPutbackToken(ep, tid, ep->token);
-
- if (ejsParse(ep, EJS_STATE_EXPR, flags) != EJS_STATE_EXPR_DONE) {
- return -1;
- }
- if (ep->currentProperty == 0 && flags & EJS_FLAGS_EXE) {
- return -1;
- }
- setVar = ep->currentProperty;
-
- if (ejsLexGetToken(ep, state) != EJS_TOK_RPAREN) {
- return -1;
- }
-
- /*
- * Parse the body and remember the end of the body script
- */
- forFlags = flags & ~EJS_FLAGS_EXE;
- ejsLexSaveInputState(ep, &bodyScript);
- if (ejsParse(ep, EJS_STATE_STMT, forFlags) != EJS_STATE_STMT_DONE) {
- ejsLexFreeInputState(ep, &bodyScript);
- return -1;
- }
- ejsInitInputState(&endScript);
- ejsLexSaveInputState(ep, &endScript);
-
- /*
- * Now actually do the for loop.
- */
- if (flags & EJS_FLAGS_EXE) {
- if (setVar->type == MPR_TYPE_OBJECT) {
- vp = mprGetFirstProperty(setVar, MPR_ENUM_DATA);
- while (vp) {
- if (strcmp(vp->name, "length") != 0) {
- v = mprCreateStringVar(vp->name, 0);
- if (mprWriteProperty(iteratorVar, &v) < 0) {
- ejsError(ep, "Can't write to variable\n");
- ejsLexFreeInputState(ep, &bodyScript);
- ejsLexFreeInputState(ep, &endScript);
- return -1;
- }
-
- ejsLexRestoreInputState(ep, &bodyScript);
- switch (ejsParse(ep, EJS_STATE_STMT, flags)) {
- case EJS_STATE_RET:
- return EJS_STATE_RET;
- case EJS_STATE_STMT_DONE:
- break;
- default:
- ejsLexFreeInputState(ep, &endScript);
- ejsLexFreeInputState(ep, &bodyScript);
- return -1;
- }
- }
- vp = mprGetNextProperty(setVar, vp, MPR_ENUM_DATA);
- }
- } else {
- ejsError(ep, "Variable \"%s\" is not an array or object",
- setVar->name);
- ejsLexFreeInputState(ep, &endScript);
- ejsLexFreeInputState(ep, &bodyScript);
- return -1;
- }
- }
- ejsLexRestoreInputState(ep, &endScript);
-
- ejsLexFreeInputState(ep, &endScript);
- ejsLexFreeInputState(ep, &bodyScript);
-
- return state;
-}
-
-/******************************************************************************/
-/*
- * Parse the for statement. Format for the expression is:
- *
- * for (initial; condition; incr) {
- * body;
- * }
- */
-
-static int parseFor(Ejs *ep, int state, int flags)
-{
- EjsInput condScript, endScript, bodyScript, incrScript;
- int forFlags, cond;
-
- ejsInitInputState(&endScript);
- ejsInitInputState(&bodyScript);
- ejsInitInputState(&incrScript);
- ejsInitInputState(&condScript);
-
- mprAssert(ep);
-
- /*
- * Evaluate the for loop initialization statement
- */
- if (ejsParse(ep, EJS_STATE_EXPR, flags) != EJS_STATE_EXPR_DONE) {
- return -1;
- }
- if (ejsLexGetToken(ep, state) != EJS_TOK_SEMI) {
- return -1;
- }
-
- /*
- * The first time through, we save the current input context just prior
- * to each step: prior to the conditional, the loop increment and
- * the loop body.
- */
- ejsLexSaveInputState(ep, &condScript);
- if (ejsParse(ep, EJS_STATE_COND, flags) != EJS_STATE_COND_DONE) {
- goto error;
- }
- cond = (ep->result.boolean != 0);
-
- if (ejsLexGetToken(ep, state) != EJS_TOK_SEMI) {
- goto error;
- }
-
- /*
- * Don't execute the loop increment statement or the body
- * first time.
- */
- forFlags = flags & ~EJS_FLAGS_EXE;
- ejsLexSaveInputState(ep, &incrScript);
- if (ejsParse(ep, EJS_STATE_EXPR, forFlags) != EJS_STATE_EXPR_DONE) {
- goto error;
- }
- if (ejsLexGetToken(ep, state) != EJS_TOK_RPAREN) {
- goto error;
- }
-
- /*
- * Parse the body and remember the end of the body script
- */
- ejsLexSaveInputState(ep, &bodyScript);
- if (ejsParse(ep, EJS_STATE_STMT, forFlags) != EJS_STATE_STMT_DONE) {
- goto error;
- }
- ejsLexSaveInputState(ep, &endScript);
-
- /*
- * Now actually do the for loop. Note loop has been rotated
- */
- while (cond && (flags & EJS_FLAGS_EXE)) {
- /*
- * Evaluate the body
- */
- ejsLexRestoreInputState(ep, &bodyScript);
-
- switch (ejsParse(ep, EJS_STATE_STMT, flags)) {
- case EJS_STATE_RET:
- return EJS_STATE_RET;
- case EJS_STATE_STMT_DONE:
- break;
- default:
- goto error;
- }
- /*
- * Evaluate the increment script
- */
- ejsLexRestoreInputState(ep, &incrScript);
- if (ejsParse(ep, EJS_STATE_EXPR, flags) != EJS_STATE_EXPR_DONE){
- goto error;
- }
- /*
- * Evaluate the condition
- */
- ejsLexRestoreInputState(ep, &condScript);
- if (ejsParse(ep, EJS_STATE_COND, flags) != EJS_STATE_COND_DONE) {
- goto error;
- }
- mprAssert(ep->result.type == MPR_TYPE_BOOL);
- cond = (ep->result.boolean != 0);
- }
-
- ejsLexRestoreInputState(ep, &endScript);
-
-done:
- ejsLexFreeInputState(ep, &condScript);
- ejsLexFreeInputState(ep, &incrScript);
- ejsLexFreeInputState(ep, &endScript);
- ejsLexFreeInputState(ep, &bodyScript);
- return state;
-
-error:
- state = EJS_STATE_ERR;
- goto done;
-}
-
-/******************************************************************************/
-/*
- * Parse a function declaration
- */
-
-static int parseFunctionDec(Ejs *ep, int state, int flags)
-{
- EjsInput endScript, bodyScript;
- MprVar v, *currentObj, *vp;
- char *procName;
- int len, tid, bodyFlags;
-
- mprAssert(ep);
- mprAssert(ejsPtr(ep->eid));
-
- /*
- * function <name>(arg, arg, arg) { body };
- * function name(arg, arg, arg) { body };
- */
-
- tid = ejsLexGetToken(ep, state);
- if (tid == EJS_TOK_ID) {
- procName = mprStrdup(ep->token);
- tid = ejsLexGetToken(ep, state);
- } else {
- procName = 0;
- }
- if (tid != EJS_TOK_LPAREN) {
- mprFree(procName);
- return EJS_STATE_ERR;
- }
-
- /*
- * Hand craft the function value structure.
- */
- v = mprCreateFunctionVar(0, 0, 0);
- tid = ejsLexGetToken(ep, state);
- while (tid == EJS_TOK_ID) {
- mprAddToArray(v.function.args, mprStrdup(ep->token));
- tid = ejsLexGetToken(ep, state);
- if (tid == EJS_TOK_RPAREN || tid != EJS_TOK_COMMA) {
- break;
- }
- tid = ejsLexGetToken(ep, state);
- }
- if (tid != EJS_TOK_RPAREN) {
- mprFree(procName);
- mprDestroyVar(&v);
- return EJS_STATE_ERR;
- }
-
- /* Allow new lines before opening brace */
- do {
- tid = ejsLexGetToken(ep, state);
- } while (tid == EJS_TOK_NEWLINE);
-
- if (tid != EJS_TOK_LBRACE) {
- mprFree(procName);
- mprDestroyVar(&v);
- return EJS_STATE_ERR;
- }
-
- /*
- * Register the function name early to allow for recursive
- * function calls (see note in ECMA standard, page 71)
- */
- if (!(flags & EJS_FLAGS_ASSIGNMENT)) {
- currentObj = ejsFindObj(ep, 0, procName, flags);
- vp = mprSetProperty(currentObj, procName, &v);
- }
-
- /*
- * Parse the function body. Turn execute off.
- */
- bodyFlags = flags & ~EJS_FLAGS_EXE;
- ejsLexSaveInputState(ep, &bodyScript);
-
- do {
- state = ejsParse(ep, EJS_STATE_STMT, bodyFlags);
- } while (state == EJS_STATE_STMT_DONE);
-
- tid = ejsLexGetToken(ep, state);
- if (state != EJS_STATE_STMT_BLOCK_DONE || tid != EJS_TOK_RBRACE) {
- mprFree(procName);
- mprDestroyVar(&v);
- ejsLexFreeInputState(ep, &bodyScript);
- return EJS_STATE_ERR;
- }
- ejsLexSaveInputState(ep, &endScript);
-
- /*
- * Save the function body between the starting and ending parse positions.
- * Overwrite the trailing '}' with a null.
- */
- len = endScript.scriptServp - bodyScript.scriptServp;
- v.function.body = mprMalloc(len + 1);
- memcpy(v.function.body, bodyScript.scriptServp, len);
-
- if (len <= 0) {
- v.function.body[0] = '\0';
- } else {
- v.function.body[len - 1] = '\0';
- }
- ejsLexFreeInputState(ep, &bodyScript);
- ejsLexFreeInputState(ep, &endScript);
-
- /*
- * If we are in an assignment, don't register the function name, rather
- * return the function structure in the parser result.
- */
- if (flags & EJS_FLAGS_ASSIGNMENT) {
- mprCopyVar(&ep->result, &v, MPR_SHALLOW_COPY);
- } else {
- currentObj = ejsFindObj(ep, 0, procName, flags);
- vp = mprSetProperty(currentObj, procName, &v);
- }
-
- mprFree(procName);
- mprDestroyVar(&v);
-
- return EJS_STATE_STMT;
-}
-
-/******************************************************************************/
-/*
- * Parse a function name and invoke the function
- */
-
-static int parseFunction(Ejs *ep, int state, int flags, char *id)
-{
- EjsProc proc, *saveProc;
- MprVar *saveObj;
-
- /*
- * Must save any current ep->proc value for the current stack frame
- * to allow for recursive function calls.
- */
- saveProc = (ep->proc) ? ep->proc: 0;
-
- memset(&proc, 0, sizeof(EjsProc));
- proc.procName = mprStrdup(id);
- proc.fn = ep->currentProperty;
- proc.args = mprCreateArray();
- ep->proc = &proc;
-
- mprDestroyVar(&ep->result);
-
- saveObj = ep->currentObj;
- if (ejsParse(ep, EJS_STATE_ARG_LIST, flags) != EJS_STATE_ARG_LIST_DONE) {
- freeProc(&proc);
- ep->proc = saveProc;
- return -1;
- }
- ep->currentObj = saveObj;
-
- /*
- * Evaluate the function if required
- */
- if (flags & EJS_FLAGS_EXE) {
- if (evalFunction(ep, ep->currentObj, flags) < 0) {
- freeProc(&proc);
- ep->proc = saveProc;
- return -1;
- }
- }
-
- freeProc(&proc);
- ep->proc = saveProc;
-
- if (ejsLexGetToken(ep, state) != EJS_TOK_RPAREN) {
- return -1;
- }
- return state;
-}
-
-/******************************************************************************/
-/*
- * Parse an identifier. This is a segment of a fully qualified variable.
- * May come here for an initial identifier or for property names
- * after a "." or "[...]".
- */
-
-static int parseId(Ejs *ep, int state, int flags, char **id, char **fullName,
- int *fullNameLen, int *done)
-{
- int tid;
-
- mprFree(*id);
- *id = mprStrdup(ep->token);
-#if BLD_DEBUG
- *fullNameLen = mprReallocStrcat(fullName, MPR_MAX_VAR, *fullNameLen,
- 0, *id, NULL);
-#endif
- if (ep->currentObj == 0) {
- ep->currentObj = ejsFindObj(ep, state, *id, flags);
- }
-
- /*
- * Find the referenced variable and store it in currentProperty.
- */
- ep->currentProperty = ejsFindProperty(ep, state, ep->currentObj,
- *id, flags);
- updateResult(ep, state, flags, ep->currentProperty);
-
-#if BLD_DEBUG
- if (ep->currentProperty && (ep->currentProperty->name == 0 ||
- ep->currentProperty->name[0] == '\0')) {
- mprSetVarName(ep->currentProperty, *id);
- }
-#endif
-
- tid = ejsLexGetToken(ep, state);
- if (tid == EJS_TOK_LPAREN) {
- if (ep->currentProperty == 0 && (flags & EJS_FLAGS_EXE)) {
- ejsError(ep, "Function name not defined \"%s\"\n", *id);
- return -1;
- }
- ejsLexPutbackToken(ep, EJS_TOK_FUNCTION_NAME, ep->token);
- return state;
- }
-
- if (tid == EJS_TOK_PERIOD || tid == EJS_TOK_LBRACKET ||
- tid == EJS_TOK_ASSIGNMENT || tid == EJS_TOK_INC_DEC) {
- ejsLexPutbackToken(ep, tid, ep->token);
- return state;
- }
-
- /*
- * Only come here for variable access and declarations.
- * Assignment handled elsewhere.
- */
- if (flags & EJS_FLAGS_EXE) {
- if (state == EJS_STATE_DEC) {
- /*
- * Declare a variable. Standard allows: var x ; var x ;
- */
-#if DISABLED
- if (ep->currentProperty != 0) {
- ejsError(ep, "Variable already defined \"%s\"\n", *id);
- return -1;
- }
-#endif
- /*
- * Create or overwrite if it already exists
- */
- mprSetPropertyValue(ep->currentObj, *id,
- mprCreateUndefinedVar());
- ep->currentProperty = 0;
- mprDestroyVar(&ep->result);
-
- } else if (flags & EJS_FLAGS_FOREACH) {
- if (ep->currentProperty == 0) {
- ep->currentProperty =
- mprCreatePropertyValue(ep->currentObj, *id,
- mprCreateUndefinedVar());
- }
-
- } else {
- if (ep->currentProperty == 0) {
- if (ep->currentObj == ep->global ||
- ep->currentObj == ep->local) {
- ejsError(ep, "Undefined variable \"%s\"\n", *id);
- return -1;
- }
- ep->currentProperty = mprCreatePropertyValue(ep->currentObj,
- *id, mprCreateUndefinedVar());
- }
- }
- }
- ejsLexPutbackToken(ep, tid, ep->token);
- if (tid == EJS_TOK_RBRACKET || tid == EJS_TOK_COMMA ||
- tid == EJS_TOK_IN) {
- *done = 1;
- }
- return state;
-}
-
-/******************************************************************************/
-/*
- * Parse an "if" statement
- */
-
-static int parseIf(Ejs *ep, int state, int flags, int *done)
-{
- bool ifResult;
- int thenFlags, elseFlags, tid;
-
- if (state != EJS_STATE_STMT) {
- return -1;
- }
- if (ejsLexGetToken(ep, state) != EJS_TOK_LPAREN) {
- return -1;
- }
-
- /*
- * Evaluate the entire condition list "(condition)"
- */
- if (ejsParse(ep, EJS_STATE_COND, flags) != EJS_STATE_COND_DONE) {
- return -1;
- }
- if (ejsLexGetToken(ep, state) != EJS_TOK_RPAREN) {
- return -1;
- }
-
- /*
- * This is the "then" case. We need to always parse both cases and
- * execute only the relevant case.
- */
- ifResult = mprVarToBool(&ep->result);
- if (ifResult) {
- thenFlags = flags;
- elseFlags = flags & ~EJS_FLAGS_EXE;
- } else {
- thenFlags = flags & ~EJS_FLAGS_EXE;
- elseFlags = flags;
- }
-
- /*
- * Process the "then" case.
- */
- switch (ejsParse(ep, EJS_STATE_STMT, thenFlags)) {
- case EJS_STATE_RET:
- state = EJS_STATE_RET;
- return state;
- case EJS_STATE_STMT_DONE:
- break;
- default:
- return -1;
- }
-
- /*
- * Check to see if there is an "else" case
- */
- removeNewlines(ep, state);
- tid = ejsLexGetToken(ep, state);
- if (tid != EJS_TOK_ELSE) {
- ejsLexPutbackToken(ep, tid, ep->token);
- *done = 1;
- return state;
- }
-
- /*
- * Process the "else" case.
- */
- switch (ejsParse(ep, EJS_STATE_STMT, elseFlags)) {
- case EJS_STATE_RET:
- state = EJS_STATE_RET;
- return state;
- case EJS_STATE_STMT_DONE:
- break;
- default:
- return -1;
- }
- *done = 1;
- return state;
-}
-
-/******************************************************************************/
-/*
- * Parse an "++" or "--" statement
- */
-
-static int parseInc(Ejs *ep, int state, int flags)
-{
- MprVar one;
-
- if (! (flags & EJS_FLAGS_EXE)) {
- return state;
- }
-
- if (ep->currentProperty == 0) {
- ejsError(ep, "Undefined variable \"%s\"\n", ep->token);
- return -1;
- }
- one = mprCreateIntegerVar(1);
- if (evalExpr(ep, ep->currentProperty, (int) *ep->token,
- &one) < 0) {
- return -1;
- }
- if (mprWriteProperty(ep->currentProperty, &ep->result) < 0) {
- ejsError(ep, "Can't write to variable\n");
- return -1;
- }
- return state;
-}
-
-/******************************************************************************/
-/*
- * Evaluate a condition. Implements &&, ||, !. Returns with a boolean result
- * in ep->result. Returns -1 on errors, zero if successful.
- */
-
-static int evalCond(Ejs *ep, MprVar *lhs, int rel, MprVar *rhs)
-{
- bool l, r, lval;
-
- mprAssert(rel > 0);
-
- l = mprVarToBool(lhs);
- r = mprVarToBool(rhs);
-
- switch (rel) {
- case EJS_COND_AND:
- lval = l && r;
- break;
- case EJS_COND_OR:
- lval = l || r;
- break;
- default:
- ejsError(ep, "Bad operator %d", rel);
- return -1;
- }
-
- mprCopyVarValue(&ep->result, mprCreateBoolVar(lval), 0);
- return 0;
-}
-
-
-/*
- return true if this string is a valid number
-*/
-static int string_is_number(const char *s)
-{
- char *endptr = NULL;
- if (s == NULL || *s == 0) {
- return 0;
- }
- strtod(s, &endptr);
- if (endptr != NULL && *endptr == 0) {
- return 1;
- }
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Evaluate an operation. Returns with the result in ep->result. Returns -1
- * on errors, otherwise zero is returned.
- */
-
-static int evalExpr(Ejs *ep, MprVar *lhs, int rel, MprVar *rhs)
-{
- char *str;
- MprNum lval, num;
- int rc;
-
- mprAssert(rel > 0);
- str = 0;
- lval = 0;
-
- /*
- * Type conversion. This is tricky and must be according to the standard.
- * Only numbers (including floats) and strings can be compared. All other
- * types are first converted to numbers by preference and if that fails,
- * to strings.
- *
- * First convert objects to comparable types. The "===" operator will
- * test the sameness of object references. Here, we coerce to comparable
- * types first.
- */
- if (lhs->type == MPR_TYPE_OBJECT) {
- if (ejsRunFunction(ep->eid, lhs, "toValue", 0) == 0) {
- mprCopyVar(lhs, &ep->result, MPR_SHALLOW_COPY);
- } else {
- if (ejsRunFunction(ep->eid, lhs, "toString", 0) == 0) {
- mprCopyVar(lhs, &ep->result, MPR_SHALLOW_COPY);
- }
- }
- /* Nothing more can be done */
- }
-
- if (rhs->type == MPR_TYPE_OBJECT) {
- if (ejsRunFunction(ep->eid, rhs, "toValue", 0) == 0) {
- mprCopyVar(rhs, &ep->result, MPR_SHALLOW_COPY);
- } else {
- if (ejsRunFunction(ep->eid, rhs, "toString", 0) == 0) {
- mprCopyVar(rhs, &ep->result, MPR_SHALLOW_COPY);
- }
- }
- /* Nothing more can be done */
- }
-
- /* undefined and null are special, in that they don't get promoted when
- comparing */
- if (rel == EJS_EXPR_EQ || rel == EJS_EXPR_NOTEQ) {
- if (lhs->type == MPR_TYPE_UNDEFINED || rhs->type == MPR_TYPE_UNDEFINED) {
- return evalBoolExpr(ep,
- lhs->type == MPR_TYPE_UNDEFINED,
- rel,
- rhs->type == MPR_TYPE_UNDEFINED);
- }
-
- if (lhs->type == MPR_TYPE_NULL || rhs->type == MPR_TYPE_NULL) {
- return evalBoolExpr(ep,
- lhs->type == MPR_TYPE_NULL,
- rel,
- rhs->type == MPR_TYPE_NULL);
- }
- }
-
- /*
- * From here on, lhs and rhs may contain allocated data (strings), so
- * we must always destroy before overwriting.
- */
-
- /*
- * Only allow a few bool operations. Otherwise convert to number.
- */
- if (lhs->type == MPR_TYPE_BOOL && rhs->type == MPR_TYPE_BOOL &&
- (rel != EJS_EXPR_EQ && rel != EJS_EXPR_NOTEQ &&
- rel != EJS_EXPR_BOOL_COMP)) {
- num = mprVarToNumber(lhs);
- mprDestroyVar(lhs);
- *lhs = mprCreateNumberVar(num);
- }
-
- /*
- * Types do not match, so try to coerce the right operand to match the left
- * But first, try to convert a left operand that is a numeric stored as a
- * string, into a numeric.
- */
- if (lhs->type != rhs->type) {
- if (lhs->type == MPR_TYPE_STRING) {
- if (string_is_number(lhs->string)) {
- num = mprVarToNumber(lhs);
- lhs->allocatedVar = 0;
- mprDestroyVar(lhs);
- *lhs = mprCreateNumberVar(num);
- /* Examine further below */
-
- } else {
- /*
- * Convert the RHS to a string
- */
- mprVarToString(&str, MPR_MAX_STRING, 0, rhs);
- rhs->allocatedVar = 0;
- mprDestroyVar(rhs);
- *rhs = mprCreateStringVar(str, 1);
- mprFree(str);
- }
-
-#if BLD_FEATURE_FLOATING_POINT
- } else if (lhs->type == MPR_TYPE_FLOAT) {
- /*
- * Convert rhs to floating
- */
- double f = mprVarToFloat(rhs);
- mprDestroyVar(rhs);
- *rhs = mprCreateFloatVar(f);
-
-#endif
-#if BLD_FEATURE_INT64
- } else if (lhs->type == MPR_TYPE_INT64) {
- /*
- * Convert the rhs to 64 bit
- */
- int64 n = mprVarToInteger64(rhs);
- mprDestroyVar(rhs);
- *rhs = mprCreateInteger64Var(n);
-#endif
- } else if (lhs->type == MPR_TYPE_BOOL || lhs->type == MPR_TYPE_INT) {
-
- if (rhs->type == MPR_TYPE_STRING) {
- /*
- * Convert to lhs to a string
- */
- mprVarToString(&str, MPR_MAX_STRING, 0, lhs);
- mprDestroyVar(lhs);
- *lhs = mprCreateStringVar(str, 1);
- mprFree(str);
-
-#if BLD_FEATURE_FLOATING_POINT
- } else if (rhs->type == MPR_TYPE_FLOAT) {
- /*
- * Convert lhs to floating
- */
- double f = mprVarToFloat(lhs);
- mprDestroyVar(lhs);
- *lhs = mprCreateFloatVar(f);
-#endif
-
- } else {
- /*
- * Convert both operands to numbers
- */
- num = mprVarToNumber(lhs);
- mprDestroyVar(lhs);
- *lhs = mprCreateNumberVar(num);
-
- num = mprVarToNumber(rhs);
- mprDestroyVar(rhs);
- *rhs = mprCreateNumberVar(num);
- }
- }
- }
-
- /*
- * We have failed to coerce the types to be the same. Special case here
- * for undefined and null. We need to allow comparisions against these
- * special values.
- */
- if (lhs->type == MPR_TYPE_UNDEFINED || lhs->type == MPR_TYPE_NULL) {
- switch (rel) {
- case EJS_EXPR_EQ:
- lval = lhs->type == rhs->type;
- break;
- case EJS_EXPR_NOTEQ:
- lval = lhs->type != rhs->type;
- break;
- case EJS_EXPR_BOOL_COMP:
- lval = ! mprVarToBool(rhs);
- break;
- default:
- lval = 0;
- }
- mprCopyVarValue(&ep->result, mprCreateBoolVar((bool) lval), 0);
- return 0;
- }
-
- /*
- * Types are the same here
- */
- switch (lhs->type) {
- default:
- case MPR_TYPE_UNDEFINED:
- case MPR_TYPE_NULL:
- /* Should be handled above */
- mprAssert(0);
- return 0;
-
- case MPR_TYPE_STRING_CFUNCTION:
- case MPR_TYPE_CFUNCTION:
- case MPR_TYPE_FUNCTION:
- case MPR_TYPE_OBJECT:
- mprCopyVarValue(&ep->result, mprCreateBoolVar(0), 0);
- return 0;
-
- case MPR_TYPE_PTR:
- rc = evalPtrExpr(ep, lhs->ptr, rel, rhs->ptr);
- break;
-
- case MPR_TYPE_BOOL:
- rc = evalBoolExpr(ep, lhs->boolean, rel, rhs->boolean);
- break;
-
-#if BLD_FEATURE_FLOATING_POINT
- case MPR_TYPE_FLOAT:
- rc = evalFloatExpr(ep, lhs->floating, rel, rhs->floating);
- break;
-#endif
-
- case MPR_TYPE_INT:
- rc = evalNumericExpr(ep, (MprNum) lhs->integer, rel,
- (MprNum) rhs->integer);
- break;
-
-#if BLD_FEATURE_INT64
- case MPR_TYPE_INT64:
- rc = evalNumericExpr(ep, (MprNum) lhs->integer64, rel,
- (MprNum) rhs->integer64);
- break;
-#endif
-
- case MPR_TYPE_STRING:
- rc = evalStringExpr(ep, lhs, rel, rhs);
- }
- return rc;
-}
-
-/******************************************************************************/
-#if BLD_FEATURE_FLOATING_POINT
-/*
- * Expressions with floating operands
- */
-
-static int evalFloatExpr(Ejs *ep, double l, int rel, double r)
-{
- double lval;
- bool logical;
-
- lval = 0;
- logical = 0;
-
- switch (rel) {
- case EJS_EXPR_PLUS:
- lval = l + r;
- break;
- case EJS_EXPR_INC:
- lval = l + 1;
- break;
- case EJS_EXPR_MINUS:
- lval = l - r;
- break;
- case EJS_EXPR_DEC:
- lval = l - 1;
- break;
- case EJS_EXPR_MUL:
- lval = l * r;
- break;
- case EJS_EXPR_DIV:
- lval = l / r;
- break;
- default:
- logical++;
- break;
- }
-
- /*
- * Logical operators
- */
- if (logical) {
-
- switch (rel) {
- case EJS_EXPR_EQ:
- lval = l == r;
- break;
- case EJS_EXPR_NOTEQ:
- lval = l != r;
- break;
- case EJS_EXPR_LESS:
- lval = (l < r) ? 1 : 0;
- break;
- case EJS_EXPR_LESSEQ:
- lval = (l <= r) ? 1 : 0;
- break;
- case EJS_EXPR_GREATER:
- lval = (l > r) ? 1 : 0;
- break;
- case EJS_EXPR_GREATEREQ:
- lval = (l >= r) ? 1 : 0;
- break;
- case EJS_EXPR_BOOL_COMP:
- lval = (r == 0) ? 1 : 0;
- break;
- default:
- ejsError(ep, "Bad operator %d", rel);
- return -1;
- }
- mprCopyVarValue(&ep->result, mprCreateBoolVar(lval != 0), 0);
-
- } else {
- mprCopyVarValue(&ep->result, mprCreateFloatVar(lval), 0);
- }
- return 0;
-}
-
-#endif /* BLD_FEATURE_FLOATING_POINT */
-/******************************************************************************/
-/*
- * Expressions with boolean operands
- */
-
-static int evalBoolExpr(Ejs *ep, bool l, int rel, bool r)
-{
- bool lval;
-
- switch (rel) {
- case EJS_EXPR_EQ:
- lval = l == r;
- break;
- case EJS_EXPR_NOTEQ:
- lval = l != r;
- break;
- case EJS_EXPR_BOOL_COMP:
- lval = (r == 0) ? 1 : 0;
- break;
- default:
- ejsError(ep, "Bad operator %d", rel);
- return -1;
- }
- mprCopyVarValue(&ep->result, mprCreateBoolVar(lval), 0);
- return 0;
-}
-
-static int evalPtrExpr(Ejs *ep, void *l, int rel, void *r)
-{
- bool lval;
-
- switch (rel) {
- case EJS_EXPR_EQ:
- lval = l == r;
- break;
- case EJS_EXPR_NOTEQ:
- lval = l != r;
- break;
- case EJS_EXPR_BOOL_COMP:
- lval = (r == NULL) ? 1 : 0;
- break;
- default:
- ejsError(ep, "Bad operator %d", rel);
- return -1;
- }
- mprCopyVarValue(&ep->result, mprCreateBoolVar(lval), 0);
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Expressions with numeric operands
- */
-
-static int evalNumericExpr(Ejs *ep, MprNum l, int rel, MprNum r)
-{
- MprNum lval;
- bool logical;
-
- lval = 0;
- logical = 0;
-
- switch (rel) {
- case EJS_EXPR_PLUS:
- lval = l + r;
- break;
- case EJS_EXPR_INC:
- lval = l + 1;
- break;
- case EJS_EXPR_MINUS:
- lval = l - r;
- break;
- case EJS_EXPR_DEC:
- lval = l - 1;
- break;
- case EJS_EXPR_MUL:
- lval = l * r;
- break;
- case EJS_EXPR_DIV:
- if (r != 0) {
- lval = l / r;
- } else {
- ejsError(ep, "Divide by zero");
- return -1;
- }
- break;
- case EJS_EXPR_MOD:
- if (r != 0) {
- lval = l % r;
- } else {
- ejsError(ep, "Modulo zero");
- return -1;
- }
- break;
- case EJS_EXPR_LSHIFT:
- lval = l << r;
- break;
- case EJS_EXPR_RSHIFT:
- lval = l >> r;
- break;
-
- default:
- logical++;
- break;
- }
-
- /*
- * Logical operators
- */
- if (logical) {
-
- switch (rel) {
- case EJS_EXPR_EQ:
- lval = l == r;
- break;
- case EJS_EXPR_NOTEQ:
- lval = l != r;
- break;
- case EJS_EXPR_LESS:
- lval = (l < r) ? 1 : 0;
- break;
- case EJS_EXPR_LESSEQ:
- lval = (l <= r) ? 1 : 0;
- break;
- case EJS_EXPR_GREATER:
- lval = (l > r) ? 1 : 0;
- break;
- case EJS_EXPR_GREATEREQ:
- lval = (l >= r) ? 1 : 0;
- break;
- case EJS_EXPR_BOOL_COMP:
- lval = (r == 0) ? 1 : 0;
- break;
- default:
- ejsError(ep, "Bad operator %d", rel);
- return -1;
- }
- mprCopyVarValue(&ep->result, mprCreateBoolVar(lval != 0), 0);
-
- } else {
- mprCopyVarValue(&ep->result, mprCreateNumberVar(lval), 0);
- }
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Expressions with string operands
- */
-
-static int evalStringExpr(Ejs *ep, MprVar *lhs, int rel, MprVar *rhs)
-{
- int lval;
-
- mprAssert(ep);
- mprAssert(lhs);
- mprAssert(rhs);
-
- switch (rel) {
- case EJS_EXPR_LESS:
- lval = strcmp(lhs->string, rhs->string) < 0;
- break;
- case EJS_EXPR_LESSEQ:
- lval = strcmp(lhs->string, rhs->string) <= 0;
- break;
- case EJS_EXPR_GREATER:
- lval = strcmp(lhs->string, rhs->string) > 0;
- break;
- case EJS_EXPR_GREATEREQ:
- lval = strcmp(lhs->string, rhs->string) >= 0;
- break;
- case EJS_EXPR_EQ:
- lval = strcmp(lhs->string, rhs->string) == 0;
- break;
- case EJS_EXPR_NOTEQ:
- lval = strcmp(lhs->string, rhs->string) != 0;
- break;
- case EJS_EXPR_PLUS:
- /*
- * This differs from all the above operations. We append rhs to lhs.
- */
- mprDestroyVar(&ep->result);
- appendValue(&ep->result, lhs);
- appendValue(&ep->result, rhs);
- return 0;
-
- case EJS_EXPR_INC:
- case EJS_EXPR_DEC:
- case EJS_EXPR_MINUS:
- case EJS_EXPR_DIV:
- case EJS_EXPR_MOD:
- case EJS_EXPR_LSHIFT:
- case EJS_EXPR_RSHIFT:
- default:
- ejsError(ep, "Bad operator");
- return -1;
- }
-
- mprCopyVarValue(&ep->result, mprCreateBoolVar(lval), 0);
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Evaluate a function. obj is set to the current object if a function is being
- * run.
- */
-
-static int evalFunction(Ejs *ep, MprVar *obj, int flags)
-{
- EjsProc *proc;
- MprVar arguments, callee, thisObject, *prototype, **argValues;
- MprArray *formalArgs, *actualArgs;
- char buf[16], **argNames, **argBuf;
- int i, rc, fid;
-
- mprAssert(ep);
- mprAssert(ejsPtr(ep->eid));
-
- rc = -1;
- proc = ep->proc;
- prototype = proc->fn;
- actualArgs = proc->args;
- argValues = (MprVar**) actualArgs->handles;
-
- /*
- * Create a new variable stack frame. ie. new local variables.
- */
- fid = ejsOpenBlock(ep->eid);
-
- if (flags & EJS_FLAGS_NEW) {
- /*
- * Create a new bare object and pass it into the constructor as the
- * "this" local variable.
- */
- thisObject = ejsCreateObj("this", EJS_OBJ_HASH_SIZE);
- mprCreatePropertyValue(ep->local, "this", thisObject);
-
- } else if (obj) {
- mprCreateProperty(ep->local, "this", obj);
- }
-
- switch (prototype->type) {
- default:
- mprAssert(0);
- break;
-
- case MPR_TYPE_STRING_CFUNCTION:
- if (actualArgs->used > 0) {
- argBuf = mprMalloc((1+actualArgs->used) * sizeof(char*));
- for (i = 0; i < actualArgs->used; i++) {
- mprVarToString(&argBuf[i], MPR_MAX_STRING, 0, argValues[i]);
- }
- argBuf[i] = NULL;
- } else {
- argBuf = 0;
- }
-
- /*
- * Call the function depending on the various handle flags
- */
- ep->thisPtr = prototype->cFunctionWithStrings.thisPtr;
- if (prototype->flags & MPR_VAR_ALT_HANDLE) {
- rc = ((EjsAltStringCFunction) prototype->cFunctionWithStrings.fn)
- (ep->eid, ep->altHandle, actualArgs->used, argBuf);
- } else if (prototype->flags & MPR_VAR_SCRIPT_HANDLE) {
- rc = (prototype->cFunctionWithStrings.fn)(ep->eid,
- actualArgs->used, argBuf);
- } else {
- rc = (prototype->cFunctionWithStrings.fn)(ep->primaryHandle,
- actualArgs->used, argBuf);
- }
-
- if (actualArgs->used > 0) {
- for (i = 0; i < actualArgs->used; i++) {
- mprFree(argBuf[i]);
- }
- mprFree(argBuf);
- }
- ep->thisPtr = 0;
- break;
-
- case MPR_TYPE_CFUNCTION:
- /*
- * Call the function depending on the various handle flags
- */
- ep->thisPtr = prototype->cFunction.thisPtr;
- if (prototype->flags & MPR_VAR_ALT_HANDLE) {
- rc = ((EjsAltCFunction) prototype->cFunction.fn)
- (ep->eid, ep->altHandle, actualArgs->used, argValues);
- } else if (prototype->flags & MPR_VAR_SCRIPT_HANDLE) {
- rc = (prototype->cFunction.fn)(ep->eid, actualArgs->used,
- argValues);
- } else {
- rc = (prototype->cFunction.fn)(ep->primaryHandle,
- actualArgs->used, argValues);
- }
- ep->thisPtr = 0;
- break;
-
- case MPR_TYPE_FUNCTION:
-
- formalArgs = prototype->function.args;
- argNames = (char**) formalArgs->handles;
-
- if (formalArgs->used > actualArgs->used) {
- ejsError(ep, "Bad number of args. Should be %d",
- formalArgs->used);
- return -1;
- }
-
- /*
- * Create the arguments and callee variables
- */
- arguments = ejsCreateObj("arguments", EJS_SMALL_OBJ_HASH_SIZE);
- callee = ejsCreateObj("callee", EJS_SMALL_OBJ_HASH_SIZE);
-
- /*
- * Overwrite the length property
- */
- mprCreatePropertyValue(&arguments, "length",
- mprCreateIntegerVar(actualArgs->used));
- mprCreatePropertyValue(&callee, "length",
- mprCreateIntegerVar(formalArgs->used));
-
- /*
- * Define all the agruments to be set to the actual parameters
- */
- for (i = 0; i < formalArgs->used; i++) {
- mprCreateProperty(ep->local, argNames[i], argValues[i]);
- }
- for (i = 0; i < actualArgs->used; i++) {
- mprItoa(i, buf, sizeof(buf));
- mprCreateProperty(&arguments, buf, argValues[i]);
- }
-
- mprCreateProperty(&arguments, "callee", &callee);
- mprCreateProperty(ep->local, "arguments", &arguments);
-
- /*
- * Can destroy our variables here as they are now referenced via
- * "local"
- */
- mprDestroyVar(&callee);
- mprDestroyVar(&arguments);
-
- /*
- * Actually run the function
- */
- rc = ejsEvalScript(ep->eid, prototype->function.body, 0, 0);
- break;
- }
-
- ejsCloseBlock(ep->eid, fid);
-
- /*
- * New statements return the newly created object as the result of the
- * command
- */
- if (flags & EJS_FLAGS_NEW) {
- mprDestroyVar(&ep->result);
- /*
- * Don't copy, we want to assign the actual object into result.
- * (mprCopyVar would inc the refCount to 2).
- */
- ep->result = thisObject;
- }
- return rc;
-}
-
-/******************************************************************************/
-/*
- * Run a function
- */
-
-int ejsRunFunction(int eid, MprVar *obj, const char *functionName,
- MprArray *args)
-{
- EjsProc proc, *saveProc;
- Ejs *ep;
- int rc;
-
- mprAssert(obj);
- mprAssert(functionName && *functionName);
-
- if ((ep = ejsPtr(eid)) == NULL) {
- mprAssert(ep);
- return MPR_ERR_NOT_FOUND;
- }
- saveProc = ep->proc;
- ep->proc = &proc;
-
- memset(&proc, 0, sizeof(EjsProc));
- mprDestroyVar(&ep->result);
-
- proc.fn = mprGetProperty(obj, functionName, 0);
- if (proc.fn == 0 || proc.fn->type == MPR_TYPE_UNDEFINED) {
- ep->proc = saveProc;
- return MPR_ERR_NOT_FOUND;
- }
- proc.procName = mprStrdup(functionName);
- if (args == 0) {
- proc.args = mprCreateArray();
- rc = evalFunction(ep, obj, 0);
- } else {
- proc.args = args;
- rc = evalFunction(ep, obj, 0);
- proc.args = 0;
- }
-
- freeProc(&proc);
- ep->proc = saveProc;
-
- return rc;
-}
-
-/******************************************************************************/
-/*
- * Find which object contains the property given the current context.
- * Only used for top level properties.
- */
-
-MprVar *ejsFindObj(Ejs *ep, int state, const char *property, int flags)
-{
- MprVar *obj;
-
- mprAssert(ep);
- mprAssert(property && *property);
-
- if (flags & EJS_FLAGS_GLOBAL) {
- obj = ep->global;
-
- } else if (state == EJS_STATE_DEC || flags & EJS_FLAGS_LOCAL) {
- obj = ep->local;
-
- } else {
- /* First look local, then look global */
- if (mprGetProperty(ep->local, property, 0)) {
- obj = ep->local;
- } else {
- obj = ep->global;
- }
- }
- return obj;
-}
-
-/******************************************************************************/
-/*
- * Find an object property given a object and a property name. We
- * intelligently look in the local and global namespaces depending on
- * our state. If not found in local or global, try base classes for function
- * names only. Returns the property or NULL.
- */
-
-MprVar *ejsFindProperty(Ejs *ep, int state, MprVar *obj, char *property,
- int flags)
-{
- MprVar *vp;
-
- mprAssert(ep);
- if (flags & EJS_FLAGS_EXE) {
- mprAssert(property && *property);
- }
-
- if (obj != 0) {
-#if FUTURE && MB
- op = obj;
- do {
- vp = mprGetProperty(op, property, 0);
- if (vp != 0) {
- if (op != obj && mprVarIsFunction(vp->type)) {
- }
- break;
- }
- op = op->baseObj;
- } while (op);
-#endif
- vp = mprGetProperty(obj, property, 0);
-
- } else {
- if (state == EJS_STATE_DEC) {
- vp = mprGetProperty(ep->local, property, 0);
-
- } else {
- /* Look local first, then global */
- vp = mprGetProperty(ep->local, property, 0);
- if (vp == NULL) {
- vp = mprGetProperty(ep->global, property, 0);
- }
- }
- }
- return vp;
-}
-
-/******************************************************************************/
-/*
- * Update result
- */
-
-static void updateResult(Ejs *ep, int state, int flags, MprVar *vp)
-{
- if (flags & EJS_FLAGS_EXE && state != EJS_STATE_DEC) {
- mprDestroyVar(&ep->result);
- if (vp) {
- mprCopyProperty(&ep->result, vp, MPR_SHALLOW_COPY);
- }
- }
-}
-
-/******************************************************************************/
-/*
- * Append to the pointer value
- */
-
-static void appendValue(MprVar *dest, MprVar *src)
-{
- char *value, *oldBuf, *buf;
- int len, oldLen;
-
- mprAssert(dest);
-
- mprVarToString(&value, MPR_MAX_STRING, 0, src);
-
- if (mprVarIsValid(dest)) {
- len = strlen(value);
- oldBuf = dest->string;
- oldLen = strlen(oldBuf);
- buf = mprRealloc(oldBuf, (len + oldLen + 1) * sizeof(char));
- dest->string = buf;
- strcpy(&buf[oldLen], value);
-
- } else {
- *dest = mprCreateStringVar(value, 1);
- }
- mprFree(value);
-}
-
-/******************************************************************************/
-/*
- * Exit with status
- */
-
-void ejsSetExitStatus(int eid, int status)
-{
- Ejs *ep;
-
- if ((ep = ejsPtr(eid)) == NULL) {
- mprAssert(ep);
- return;
- }
- ep->exitStatus = status;
- ep->flags |= EJS_FLAGS_EXIT;
-}
-
-/******************************************************************************/
-/*
- * Free an argument list
- */
-
-static void freeProc(EjsProc *proc)
-{
- MprVar **argValues;
- int i;
-
- if (proc->args) {
- argValues = (MprVar**) proc->args->handles;
-
- for (i = 0; i < proc->args->max; i++) {
- if (argValues[i]) {
- mprDestroyVar(argValues[i]);
- mprFree(argValues[i]);
- mprRemoveFromArray(proc->args, i);
- }
- }
-
- mprDestroyArray(proc->args);
- }
-
- if (proc->procName) {
- mprFree(proc->procName);
- proc->procName = NULL;
- }
-}
-
-/******************************************************************************/
-/*
- * This function removes any new lines. Used for else cases, etc.
- */
-
-static void removeNewlines(Ejs *ep, int state)
-{
- int tid;
-
- do {
- tid = ejsLexGetToken(ep, state);
- } while (tid == EJS_TOK_NEWLINE);
-
- ejsLexPutbackToken(ep, tid, ep->token);
-}
-
-/******************************************************************************/
-
-#else
-void ejsParserDummy() {}
-
-/******************************************************************************/
-#endif /* BLD_FEATURE_EJS */
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- * @file ejsProc.c
- * @brief EJS support functions
- */
-/********************************* Copyright **********************************/
-/*
- * @copy default.g
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2005. All Rights Reserved.
- * Portions Copyright (c) GoAhead Software, 1995-2000. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-/********************************** Includes **********************************/
-
-#include "ejsInternal.h"
-
-#if BLD_FEATURE_EJS
-
-/****************************** Forward Declarations **************************/
-/*
- * Object constructors
- */
-static int objectConsProc(EjsHandle eid, int argc, MprVar **argv);
-static int arrayConsProc(EjsHandle eid, int argc, MprVar **argv);
-static int booleanConsProc(EjsHandle eid, int argc, MprVar **agv);
-static int numberConsProc(EjsHandle eid, int argc, MprVar **argv);
-static int stringConsProc(EjsHandle eid, int argc, MprVar **argv);
-
-/*
- * Core functions
- */
-static int toStringProc(EjsHandle eid, int argc, MprVar **argv);
-static int valueOfProc(EjsHandle eid, int argc, MprVar **argv);
-
-/*
- * Triggers
- */
-static MprVarTriggerStatus lengthTrigger(MprVarTriggerOp op,
- MprProperties *parentProperties, MprVar *prop, MprVar *newValue,
- int copyRef);
-
-/******************************************************************************/
-/*
- * Routine to create the base common to all object types
- */
-
-MprVar ejsCreateObj(const char *name, int hashSize)
-{
- MprVar o;
-
- o = mprCreateObjVar(name, hashSize);
- if (o.type == MPR_TYPE_UNDEFINED) {
- mprAssert(0);
- return o;
- }
-
- mprCreatePropertyValue(&o, "toString",
- mprCreateCFunctionVar(toStringProc, 0, MPR_VAR_SCRIPT_HANDLE));
- mprCreatePropertyValue(&o, "valueOf",
- mprCreateCFunctionVar(valueOfProc, 0, MPR_VAR_SCRIPT_HANDLE));
- return o;
-}
-
-/******************************************************************************/
-/*
- * Routine to destroy a variable
- */
-
-bool ejsDestroyVar(MprVar *obj)
-{
- return mprDestroyVar(obj);
-}
-
-/******************************************************************************/
-/*
- * Routine to create the base array type
- */
-
-MprVar ejsCreateArray(const char *name, int size)
-{
- MprVar obj, *lp, undef;
- char idx[16];
- int i;
-
- /* Sanity limit for size of hash table */
-
- obj = ejsCreateObj(name, max(size, 503));
- if (obj.type == MPR_TYPE_UNDEFINED) {
- mprAssert(0);
- return obj;
- }
-
- undef = mprCreateUndefinedVar();
- for (i = 0; i < size; i++) {
- mprItoa(i, idx, sizeof(idx));
- mprCreateProperty(&obj, idx, &undef);
- }
-
- lp = mprCreatePropertyValue(&obj, "length", mprCreateIntegerVar(size));
- mprAssert(lp);
-
- mprSetVarReadonly(lp, 1);
- mprAddVarTrigger(lp, lengthTrigger);
-
- return obj;
-}
-
-/******************************************************************************/
-/******************************** Constructors ********************************/
-/******************************************************************************/
-/*
- * Object constructor. Nothing really done here. For future expansion.
- */
-
-static int objectConsProc(EjsHandle eid, int argc, MprVar **argv)
-{
-#if XX_UNUSED_XX
- MprVar *obj;
- Ejs *ep;
-
- if((ep = ejsPtr(eid)) == NULL) {
- return -1;
- }
-
- obj = mprGetProperty(ep->local, "this", 0);
- mprAssert(obj);
-#endif
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Array constructor
- */
-
-static int arrayConsProc(EjsHandle eid, int argc, MprVar **argv)
-{
- MprVar *obj, *lp, undef;
- Ejs *ep;
- char idx[16];
- int i, max;
-
- objectConsProc(eid, argc, argv);
-
- if((ep = ejsPtr(eid)) == NULL) {
- return -1;
- }
- obj = mprGetProperty(ep->local, "this", 0);
- mprAssert(obj);
-
-
- if (argc == 1 && mprVarIsNumber(argv[0]->type)) {
- /*
- * x = new Array(size);
- */
- undef = mprCreateUndefinedVar();
- max = (int) mprVarToInteger(argv[0]);
- for (i = 0; i < max; i++) {
- mprItoa(i, idx, sizeof(idx));
- mprCreateProperty(obj, idx, &undef);
- }
- } else {
- /*
- * x = new Array(element0, element1, ..., elementN):
- */
- max = argc;
- for (i = 0; i < max; i++) {
- mprItoa(i, idx, sizeof(idx));
- mprCreateProperty(obj, idx, argv[i]);
- }
- }
-
- lp = mprCreatePropertyValue(obj, "length", mprCreateIntegerVar(max));
- mprAssert(lp);
-
- mprSetVarReadonly(lp, 1);
- mprAddVarTrigger(lp, lengthTrigger);
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Boolean constructor
- */
-
-static int booleanConsProc(EjsHandle eid, int argc, MprVar **argv)
-{
- objectConsProc(eid, argc, argv);
- return 0;
-}
-
-/******************************************************************************/
-#if FUTURE
-/*
- * Date constructor
- */
-
-static int dateConsProc(EjsHandle eid, int argc, MprVar **argv)
-{
- objectConsProc(eid, argc, argv);
- return 0;
-}
-
-#endif
-/******************************************************************************/
-/*
- * Number constructor
- */
-
-static int numberConsProc(EjsHandle eid, int argc, MprVar **argv)
-{
- objectConsProc(eid, argc, argv);
- return 0;
-}
-
-/******************************************************************************/
-/*
- * String constructor
- */
-
-static int stringConsProc(EjsHandle eid, int argc, MprVar **argv)
-{
- objectConsProc(eid, argc, argv);
- return 0;
-}
-
-/******************************************************************************/
-/********************************** Functions *********************************/
-/******************************************************************************/
-
-static int toStringProc(EjsHandle eid, int argc, MprVar **argv)
-{
- MprVar *obj;
- Ejs *ep;
- char *buf;
- int radix;
-
- if (argc == 0) {
- radix = 10;
-
- } else if (argc == 1) {
- radix = (int) mprVarToInteger(argv[0]);
-
- } else {
- mprAssert(0);
- return -1;
- }
-
- if((ep = ejsPtr(eid)) == NULL) {
- return -1;
- }
-
- obj = mprGetProperty(ep->local, "this", 0);
- mprAssert(obj);
-
- mprVarToString(&buf, MPR_MAX_STRING, 0, obj);
- mprCopyVarValue(&ep->result, mprCreateStringVar(buf, 0), MPR_SHALLOW_COPY);
- mprFree(buf);
-
- return 0;
-}
-
-/******************************************************************************/
-
-static int valueOfProc(EjsHandle eid, int argc, MprVar **argv)
-{
- MprVar *obj;
- Ejs *ep;
-
- if (argc != 0) {
- mprAssert(0);
- return -1;
- }
-
- if((ep = ejsPtr(eid)) == NULL) {
- return -1;
- }
-
- obj = mprGetProperty(ep->local, "this", 0);
- mprAssert(obj);
-
- switch (obj->type) {
- default:
- case MPR_TYPE_UNDEFINED:
- case MPR_TYPE_NULL:
- case MPR_TYPE_CFUNCTION:
- case MPR_TYPE_OBJECT:
- case MPR_TYPE_FUNCTION:
- case MPR_TYPE_STRING_CFUNCTION:
- case MPR_TYPE_PTR:
- mprCopyVar(&ep->result, obj, MPR_SHALLOW_COPY);
- break;
-
- case MPR_TYPE_STRING:
- mprCopyVarValue(&ep->result, mprCreateIntegerVar(atoi(obj->string)), 0);
- break;
-
- case MPR_TYPE_BOOL:
- case MPR_TYPE_INT:
-#if BLD_FEATURE_INT64
- case MPR_TYPE_INT64:
-#endif
-#if BLD_FEATURE_FLOATING_POINT
- case MPR_TYPE_FLOAT:
-#endif
- mprCopyVar(&ep->result, obj, 0);
- break;
- }
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Var access trigger on the Array.length property. Return the count of
- * enumerable properties (don't count functions).
- */
-
-static MprVarTriggerStatus lengthTrigger(MprVarTriggerOp op,
- MprProperties *parentProperties, MprVar *prop, MprVar *newValue,
- int copyRef)
-{
- switch (op) {
- case MPR_VAR_READ:
- /*
- * Subtract one for the length property
- * FUTURE -- need an API to access parentProperties
- * FUTURE -- contradiction to be read-only yet allow USE_NEW_VALUE.
- * API needs finer control.
- */
- *newValue = mprCreateIntegerVar(parentProperties->numDataItems - 1);
- return MPR_TRIGGER_USE_NEW_VALUE;
-
- case MPR_VAR_WRITE:
- return MPR_TRIGGER_ABORT;
-
- case MPR_VAR_CREATE_PROPERTY:
- case MPR_VAR_DELETE_PROPERTY:
- case MPR_VAR_DELETE:
- default:
- break;
- }
- return MPR_TRIGGER_PROCEED;
-}
-
-/******************************************************************************/
-/**************************** Extension Functions *****************************/
-/******************************************************************************/
-/*
- * Assert
- */
-
-static int assertProc(EjsHandle eid, int argc, MprVar **argv)
-{
- bool b;
-
- if (argc < 1) {
- ejsSetErrorMsg(eid, "usage: assert(condition)\n");
- return -1;
- }
- b = mprVarToBool(argv[0]);
- if (b == 0) {
- ejsSetErrorMsg(eid, "Assertion failure\n");
- return -1;
- }
- ejsSetReturnValue(eid, mprCreateBoolVar(b));
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Exit
- */
-
-static int exitProc(EjsHandle eid, int argc, MprVar **argv)
-{
- int status;
-
- if (argc < 1) {
- ejsSetErrorMsg(eid, "usage: exit(status)\n");
- return -1;
- }
- status = (int) mprVarToInteger(argv[0]);
- ejsSetExitStatus(eid, status);
-
- ejsSetReturnValue(eid, mprCreateStringVar("", 0));
- return 0;
-}
-
-/******************************************************************************/
-
-static void printVar(MprVar *vp, int recurseCount, int indent)
-{
- MprVar *np;
- char *buf;
- int i;
-
- if (recurseCount > 5) {
- write(1, "Skipping - recursion too deep\n", 29);
- return;
- }
-
- for (i = 0; i < indent; i++) {
- write(1, " ", 2);
- }
-
- if (vp->type == MPR_TYPE_OBJECT) {
- if (vp->name) {
- write(1, vp->name, strlen(vp->name));
- } else {
- write(1, "unknown", 7);
- }
- write(1, ": {\n", 4);
- np = mprGetFirstProperty(vp, MPR_ENUM_DATA);
- while (np) {
- if (strcmp(np->name, "local") == 0 ||
- strcmp(np->name, "global") == 0 ||
- strcmp(np->name, "this") == 0) {
- np = mprGetNextProperty(vp, np, MPR_ENUM_DATA);
- continue;
- }
- printVar(np, recurseCount + 1, indent + 1);
- np = mprGetNextProperty(vp, np, MPR_ENUM_DATA);
- if (np) {
- write(1, ",\n", 2);
- }
- }
- write(1, "\n", 1);
- for (i = 0; i < indent; i++) {
- write(1, " ", 2);
- }
- write(1, "}", 1);
-
- } else {
- if (vp->name) {
- write(1, vp->name, strlen(vp->name));
- } else {
- write(1, "unknown", 7);
- }
- write(1, ": ", 2);
-
- /* FUTURE -- other types ? */
- mprVarToString(&buf, MPR_MAX_STRING, 0, vp);
- if (vp->type == MPR_TYPE_STRING) {
- write(1, "\"", 1);
- }
- write(1, buf, strlen(buf));
- if (vp->type == MPR_TYPE_STRING) {
- write(1, "\"", 1);
- }
- mprFree(buf);
- }
-}
-
-/******************************************************************************/
-/*
- * Print the args to stdout
- */
-
-static int printVarsProc(EjsHandle eid, int argc, MprVar **argv)
-{
- MprVar *vp;
- char *buf;
- int i;
-
- for (i = 0; i < argc; i++) {
- vp = argv[i];
- switch (vp->type) {
- case MPR_TYPE_OBJECT:
- printVar(vp, 0, 0);
- break;
- default:
- mprVarToString(&buf, MPR_MAX_STRING, 0, vp);
- write(1, buf, strlen(buf));
- mprFree(buf);
- break;
- }
- }
- write(1, "\n", 1);
-
- ejsSetReturnValue(eid, mprCreateStringVar("", 0));
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Print the args to stdout
- */
-
-static int printProc(EjsHandle eid, int argc, MprVar **argv)
-{
- char *buf;
- int i;
-
- for (i = 0; i < argc; i++) {
- mprVarToString(&buf, MPR_MAX_STRING, 0, argv[i]);
- write(1, buf, strlen(buf));
- mprFree(buf);
- }
- return 0;
-}
-
-/******************************************************************************/
-/*
- * println
- */
-
-static int printlnProc(EjsHandle eid, int argc, MprVar **argv)
-{
- printProc(eid, argc, argv);
- write(1, "\n", 1);
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Trace
- */
-
-static int traceProc(EjsHandle eid, int argc, char **argv)
-{
- if (argc == 1) {
- mprLog(0, "%s", argv[0]);
-
- } else if (argc == 2) {
- mprLog(atoi(argv[0]), "%s", argv[1]);
-
- } else {
- ejsSetErrorMsg(eid, "Usage: trace([level], message)");
- return -1;
- }
- ejsSetReturnString(eid, "");
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Return the object reference count
- */
-
-static int refCountProc(EjsHandle eid, int argc, MprVar **argv)
-{
- MprVar *vp;
- int count;
-
- vp = argv[0];
- if (vp->type == MPR_TYPE_OBJECT) {
- count = mprGetVarRefCount(vp);
- ejsSetReturnValue(eid, mprCreateIntegerVar(count));
- } else {
- ejsSetReturnValue(eid, mprCreateIntegerVar(0));
- }
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Evaluate a sub-script. It is evaluated in the same variable scope as
- * the calling script / function.
- */
-
-static int evalScriptProc(EjsHandle eid, int argc, MprVar **argv)
-{
- MprVar *arg;
- char *emsg;
- int i;
-
- ejsSetReturnValue(eid, mprCreateUndefinedVar());
-
- for (i = 0; i < argc; i++) {
- arg = argv[i];
- if (arg->type != MPR_TYPE_STRING) {
- continue;
- }
- if (ejsEvalScript(eid, arg->string, 0, &emsg) < 0) {
- ejsSetErrorMsg(eid, "%s", emsg);
- mprFree(emsg);
- return -1;
- }
- }
- /*
- * Return with the value of the last expression
- */
- return 0;
-}
-
-/******************************************************************************/
-/******************************************************************************/
-/******************************************************************************/
-/*
- * Define the standard properties and functions inherited by all script engines.
- */
-
-int ejsDefineStandardProperties(MprVar *obj)
-{
-#if BLD_FEATURE_FLOATING_POINT
- double d = 0.0;
-
- /* FUTURE - this generates warnings on some systems. This is okay. */
-
- mprCreatePropertyValue(obj, "NaN", mprCreateFloatVar(0.0 / d));
- d = MAX_FLOAT;
- mprCreatePropertyValue(obj, "Infinity", mprCreateFloatVar(d * d));
-#endif
- mprCreatePropertyValue(obj, "null", mprCreateNullVar());
- mprCreatePropertyValue(obj, "undefined", mprCreateUndefinedVar());
- mprCreatePropertyValue(obj, "true", mprCreateBoolVar(1));
- mprCreatePropertyValue(obj, "false", mprCreateBoolVar(0));
- mprCreatePropertyValue(obj, "NULL", mprCreatePtrVar(NULL));
-
-#if BLD_FEATURE_LEGACY_API
- /*
- * DEPRECATED: 2.0.
- * So that ESP/ASP can ignore "language=javascript" statements
- */
- mprCreatePropertyValue(obj, "javascript", mprCreateIntegerVar(0));
-#endif
-
- /*
- * Extension functions
- */
- mprCreatePropertyValue(obj, "assert",
- mprCreateCFunctionVar(assertProc, 0, MPR_VAR_SCRIPT_HANDLE));
- mprCreatePropertyValue(obj, "eval",
- mprCreateCFunctionVar(evalScriptProc, 0, MPR_VAR_SCRIPT_HANDLE));
- mprCreatePropertyValue(obj, "exit",
- mprCreateCFunctionVar(exitProc, 0, MPR_VAR_SCRIPT_HANDLE));
- mprCreatePropertyValue(obj, "refCount",
- mprCreateCFunctionVar(refCountProc, 0, MPR_VAR_SCRIPT_HANDLE));
- mprCreatePropertyValue(obj, "print",
- mprCreateCFunctionVar(printProc, 0, MPR_VAR_SCRIPT_HANDLE));
- mprCreatePropertyValue(obj, "println",
- mprCreateCFunctionVar(printlnProc, 0, MPR_VAR_SCRIPT_HANDLE));
- mprCreatePropertyValue(obj, "printVars",
- mprCreateCFunctionVar(printVarsProc,0, MPR_VAR_SCRIPT_HANDLE));
- mprCreatePropertyValue(obj, "trace",
- mprCreateStringCFunctionVar(traceProc, 0, MPR_VAR_SCRIPT_HANDLE));
-
- /*
- * Constructors
- */
- mprCreatePropertyValue(obj, "Array",
- mprCreateCFunctionVar(arrayConsProc, 0, MPR_VAR_SCRIPT_HANDLE));
- mprCreatePropertyValue(obj, "Boolean",
- mprCreateCFunctionVar(booleanConsProc, 0, MPR_VAR_SCRIPT_HANDLE));
- mprCreatePropertyValue(obj, "Object",
- mprCreateCFunctionVar(objectConsProc, 0, MPR_VAR_SCRIPT_HANDLE));
- mprCreatePropertyValue(obj, "Number",
- mprCreateCFunctionVar(numberConsProc, 0, MPR_VAR_SCRIPT_HANDLE));
- mprCreatePropertyValue(obj, "String",
- mprCreateCFunctionVar(stringConsProc, 0, MPR_VAR_SCRIPT_HANDLE));
-
- /* mprCreatePropertyValue(obj, "Date",
- * mprCreateCFunctionVar(dateConsProc, 0, MPR_VAR_SCRIPT_HANDLE));
- * mprCreatePropertyValue(obj, "Regexp",
- * mprCreateCFunctionVar(regexpConsProc, 0, MPR_VAR_SCRIPT_HANDLE));
- */
-
- /*
- * Can we use on var x = "string text";
- */
- return 0;
-}
-
-/******************************************************************************/
-
-#else
-void ejsProcsDummy() {}
-
-/******************************************************************************/
-#endif /* BLD_FEATURE_EJS */
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- * @file esp.c
- * @brief Embedded Server Pages (ESP) core processing.
- * @overview Embedded Server Pages provides an efficient way to generate
- * dynamic pages using server-side Javascript. This code provides
- * core processing, and should be called by an associated web
- * server URL handler.
- */
-/********************************* Copyright **********************************/
-/*
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2005. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-/********************************** Includes **********************************/
-
-#include "esp.h"
-
-#if BLD_FEATURE_ESP_MODULE
-
-/*********************************** Locals ***********************************/
-/*
- * Master ESP control interface with the web server
- */
-
-static const Esp *esp;
-
-/***************************** Forward Declarations ***************************/
-
-static int buildScript(EspRequest *ep, char **jsBuf, char *input, char
- **errMsg);
-
-/************************************ Code ************************************/
-/*
- * Called at server initialization
- */
-
-int espOpen(const Esp *control)
-{
- mprAssert(control);
-
-#if BLD_FEATURE_MULTITHREAD
- ejsOpen(control->lock, control->unlock, control->lockData);
-#else
- ejsOpen(0, 0, 0);
-#endif
-
- /*
- * Register the standard procedures
- */
- espRegisterProcs();
-
- /*
- * Just for brain dead systems that don't zero global memory
- */
- esp = control;
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Called at server termination
- */
-
-void espClose()
-{
- ejsClose();
-}
-
-/******************************************************************************/
-/*
- * Create for new ESP request. Assumed that this is called after all the
- * HTTP headers have been read but before POST data has been read. It is
- * expected that any session cookies have been read and that "variables"
- * contains references to all the environment objects including "session".
- * requestHandle is the web server request handle.
- */
-
-EspRequest *espCreateRequest(EspHandle webServerRequestHandle, char *uri,
- MprVar *variables)
-{
- EspRequest *ep;
- MprVar *global;
-#if BLD_FEATURE_LEGACY_API
- MprVar *np;
- char keyBuf[ESP_MAX_HEADER];
- int i;
-#endif
-
- mprAssert(variables);
-
- ep = mprMalloc(sizeof(EspRequest));
- if (ep == 0) {
- return 0;
- }
- memset(ep, 0, sizeof(EspRequest));
- ep->requestHandle = webServerRequestHandle;
- ep->esp = esp;
- ep->uri = mprStrdup(uri);
- ep->docPath = 0;
- ep->variables = variables;
-
- /*
- * The handle passed to ejsOpenEngine is passed to every C function
- * called by JavaScript.
- */
- ep->eid = ejsOpenEngine((EjsHandle) ep, (EjsHandle) webServerRequestHandle);
- if (ep->eid < 0) {
- mprFree(ep);
- return 0;
- }
-
- /*
- * All these copies and SetProperties will only copy references
- * They will increments the object ref counts.
- */
- mprCopyVar(&variables[ESP_GLOBAL_OBJ], ejsGetGlobalObject(ep->eid),
- MPR_SHALLOW_COPY);
- mprCopyVar(&variables[ESP_LOCAL_OBJ], ejsGetLocalObject(ep->eid),
- MPR_SHALLOW_COPY);
-
- global = &variables[ESP_GLOBAL_OBJ];
- mprCreateProperty(global, "application", &variables[ESP_APPLICATION_OBJ]);
- mprCreateProperty(global, "cookies", &variables[ESP_COOKIES_OBJ]);
- mprCreateProperty(global, "files", &variables[ESP_FILES_OBJ]);
- mprCreateProperty(global, "form", &variables[ESP_FORM_OBJ]);
- mprCreateProperty(global, "headers", &variables[ESP_HEADERS_OBJ]);
- mprCreateProperty(global, "request", &variables[ESP_REQUEST_OBJ]);
-
- /*
- * FUTURE -- could server be shared across all requests for a given host
- * and be made read-only.
- */
- mprCreateProperty(global, "server", &variables[ESP_SERVER_OBJ]);
-
-#if BLD_FEATURE_SESSION
- mprCreateProperty(global, "session", &variables[ESP_SESSION_OBJ]);
-#endif
-
-#if BLD_FEATURE_LEGACY_API
- /*
- * DEPRECATED: 2.0
- * Define variables as globals. headers[] are prefixed with "HTTP_".
- * NOTE: MaRequest::setVar does not copy into globals, whereas espSetVar
- * does if legacy_api is defined. So variables pre-defined by MaRequest
- * must be copied here into globals[].
- *
- * NOTE: if a variable is in session[] and in form[], the form[] will
- * override being later in the variables[] list. Use mprSetProperty
- * instead of mprCreateProperty to cover for this case.
- */
- for (i = 0; i < ESP_OBJ_MAX; i++) {
- if (i == ESP_GLOBAL_OBJ || i == ESP_LOCAL_OBJ) {
- continue;
- }
- if (variables[i].type != MPR_TYPE_OBJECT) {
- continue;
- }
- np = mprGetFirstProperty(&variables[i], MPR_ENUM_DATA);
- while (np) {
- if (i == ESP_HEADERS_OBJ) {
- mprSprintf(keyBuf, sizeof(keyBuf) - 1, "HTTP_%s", np->name);
- mprSetProperty(global, keyBuf, np);
- } else {
- mprSetProperty(global, np->name, np);
- }
- np = mprGetNextProperty(&variables[i], np, MPR_ENUM_DATA);
- }
- }
-#endif
- return ep;
-}
-
-/******************************************************************************/
-
-void espDestroyRequest(EspRequest *ep)
-{
- mprAssert(ep);
- mprAssert(ep->eid >= 0);
-
- mprFree(ep->uri);
- mprFree(ep->docPath);
- ejsCloseEngine(ep->eid);
- mprFree(ep);
-}
-
-/******************************************************************************/
-/*
- * The callback function will be called:
- *
- * (fn)(EjsId eid, EspRequest *ep, argc, argv);
- *
- * Callers can get their web server handle by calling:
- *
- * rq = (requiredCast) espGetHandle(ep);
- */
-
-void espDefineCFunction(EspRequest *ep, const char *functionName, EspCFunction fn,
- void *thisPtr)
-{
- mprAssert(functionName && *functionName);
- mprAssert(fn);
-
- if (ep) {
- ejsDefineCFunction(ep->eid, functionName, (MprCFunction) fn,
- thisPtr, 0);
- } else {
- ejsDefineCFunction(-1, functionName, (MprCFunction) fn, thisPtr, 0);
- }
-}
-
-/******************************************************************************/
-
-void espDefineStringCFunction(EspRequest *ep, const char *functionName,
- EspStringCFunction fn, void *thisPtr)
-{
- mprAssert(functionName && *functionName);
- mprAssert(fn);
-
- if (ep) {
- ejsDefineStringCFunction(ep->eid, functionName, (MprStringCFunction) fn,
- thisPtr, 0);
- } else {
- ejsDefineStringCFunction(-1, functionName, (MprStringCFunction) fn,
- thisPtr, 0);
- }
-}
-
-/******************************************************************************/
-
-void *espGetRequestHandle(EspRequest *ep)
-{
- return ep->requestHandle;
-}
-
-/******************************************************************************/
-
-EjsId espGetScriptHandle(EspRequest *ep)
-{
- return ep->eid;
-}
-
-/******************************************************************************/
-
-char *espGetStringVar(EspRequest *ep, EspEnvType oType, char *var,
- char *defaultValue)
-{
- MprVar value;
-
- if (espGetVar(ep, oType, var, &value) < 0 ||
- value.type != MPR_TYPE_STRING) {
- return defaultValue;
- }
- return value.string;
-}
-
-/******************************************************************************/
-
-int espGetVar(EspRequest *ep, EspEnvType oType, char *var, MprVar *value)
-{
- MprVar *vp;
-
- mprAssert(ep);
- mprAssert(var);
-
- vp = mprGetProperty(&ep->variables[oType], var, 0);
- if (vp == 0) {
- return -1;
- }
- *value = *vp;
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Process the ESP page. docBuf holds the page already. We expect that
- * ep->variables holds all the pertinent environment variables.
- */
-
-int espProcessRequest(EspRequest *ep, const char *docPath, char *docBuf,
- char **errMsg)
-{
- char *jsBuf;
-
- mprAssert(ep);
-
- ep->docPath = mprStrdup(docPath);
-
- jsBuf = 0;
- if (buildScript(ep, &jsBuf, docBuf, errMsg) < 0) {
- return MPR_ERR_CANT_COMPLETE;
- }
-
- if (jsBuf) {
- mprLog(7, "esp: script is:\n%s\n", jsBuf);
-
- /*
- * Now evaluate the entire escript
- * MOB could cache the script
- */
- if (ejsEvalScript(ep->eid, jsBuf, 0, errMsg) < 0) {
- return MPR_ERR_ABORTED;
- }
-
- mprFree(jsBuf);
- }
- return 0;
-}
-
-/******************************************************************************/
-
-void espRedirect(EspRequest *ep, int code, char *url)
-{
- mprAssert(ep);
- mprAssert(url);
-
- ep->esp->redirect(ep->requestHandle, code, url);
-}
-
-/******************************************************************************/
-
-void espError(EspRequest *ep, const char *fmt, ...)
-{
- va_list args;
- char *buf;
-
- mprAssert(ep);
- mprAssert(fmt);
-
- va_start(args, fmt);
- mprAllocVsprintf(&buf, MPR_MAX_HEAP_SIZE, fmt, args);
- ejsSetErrorMsg(ep->eid, "%s", buf);
- mprFree(buf);
- va_end(args);
-}
-
-/******************************************************************************/
-
-void espSetHeader(EspRequest *ep, char *header, bool allowMultiple)
-{
- mprAssert(ep);
-
- ep->esp->setHeader(ep->requestHandle, header, allowMultiple);
-}
-
-/******************************************************************************/
-/*
- * Caller does not need to destroy the var
- */
-
-MprVar *espGetResult(EspRequest *ep)
-{
- mprAssert(ep);
-
- return ejsGetReturnValue(ep->eid);
-}
-
-/******************************************************************************/
-
-void espSetReturn(EspRequest *ep, MprVar value)
-{
- mprAssert(ep);
-
- ejsSetReturnValue(ep->eid, value);
-}
-
-/******************************************************************************/
-
-void espSetReturnString(EspRequest *ep, const char *str)
-{
- mprAssert(ep);
-
- ejsSetReturnValue(ep->eid, mprCreateStringVar(str, 0));
-}
-
-/******************************************************************************/
-
-void espSetResponseCode(EspRequest *ep, int code)
-{
- mprAssert(ep);
-
- ep->esp->setResponseCode(ep->requestHandle, code);
-}
-
-/******************************************************************************/
-
-void espSetVar(EspRequest *ep, EspEnvType oType, char *var, MprVar value)
-{
- mprCreatePropertyValue(&ep->variables[oType], var, value);
-}
-
-/******************************************************************************/
-
-void espSetStringVar(EspRequest *ep, EspEnvType oType,
- const char *var, const char *value)
-{
- /*
- * Will create or update if already existing
- */
- mprCreatePropertyValue(&ep->variables[oType], var,
- mprCreateStringVar(value, 0));
-}
-
-/******************************************************************************/
-
-int espUnsetVar(EspRequest *ep, EspEnvType oType, char *var)
-{
- return mprDeleteProperty(&ep->variables[oType], var);
-}
-
-/******************************************************************************/
-
-int espWrite(EspRequest *ep, char *buf, int size)
-{
- mprAssert(ep);
- mprAssert(buf);
- mprAssert(size >= 0);
-
- return ep->esp->writeBlock(ep->requestHandle, buf, size);
-}
-
-/******************************************************************************/
-
-int espWriteString(EspRequest *ep, char *buf)
-{
- mprAssert(ep);
- mprAssert(buf);
-
- return ep->esp->writeBlock(ep->requestHandle, buf, strlen(buf));
-}
-
-/******************************************************************************/
-
-int espWriteFmt(EspRequest *ep, char *fmt, ...)
-{
- va_list args;
- char *buf;
- int rc, len;
-
- mprAssert(ep);
- mprAssert(fmt);
-
- va_start(args, fmt);
- len = mprAllocVsprintf(&buf, MPR_MAX_HEAP_SIZE, fmt, args);
- rc = ep->esp->writeBlock(ep->requestHandle, buf, len);
- mprFree(buf);
- va_end(args);
- return rc;
-}
-
-/******************************************************************************/
-/******************************************************************************/
-/******************************************************************************/
-/*
- * Get a javascript identifier. Must allow x.y['abc'] or x.y["abc"].
- * Must be careful about quoting and only allow quotes inside [].
- */
-
-static int getIdentifier(EspParse *parse)
-{
- int atQuote, prevC, c;
-
- mprAssert(parse);
-
- atQuote = 0;
- prevC = 0;
- c = *parse->inp++;
-
- while (isalnum(c) || c == '_' || c == '.' || c == '[' ||
- c == ']' || c == '\'' || c == '\"') {
- if (c == '\'' || c == '\"') {
- if (c == atQuote) {
- atQuote = 0;
- } else if (prevC == '[') {
- atQuote = c;
- } else {
- break;
- }
- }
- if (parse->tokp >= parse->endp) {
- parse->token = (char*) mprRealloc(parse->token,
- parse->tokLen + ESP_TOK_INCR);
- if (parse->token == 0) {
- return MPR_ERR_CANT_ALLOCATE;
- }
- parse->token[parse->tokLen] = '\0';
- parse->tokLen += ESP_TOK_INCR;
- parse->endp = &parse->token[parse->tokLen - 1];
- }
- *parse->tokp++ = c;
- prevC = c;
- c = *parse->inp++;
- }
-
- parse->inp--;
- *parse->tokp = '\0';
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Get the next ESP input token. input points to the next input token.
- * parse->token will hold the parsed token. The function returns the token id.
- */
-
-static int getEspToken(int state, EspParse *parse)
-{
- char *cp;
- int tid, done, c, quoted;
-
- tid = ESP_TOK_LITERAL;
- parse->tokp = parse->token;
- parse->tokp[0] = '\0';
- quoted = 0;
-
- c = *parse->inp++;
- for (done = 0; !done; c = *parse->inp++) {
-
- /*
- * Get room for more characters in the token buffer
- */
- if (parse->tokp >= parse->endp) {
- parse->token = (char*) mprRealloc(parse->token,
- parse->tokLen + ESP_TOK_INCR);
- if (parse->token == 0) {
- return ESP_TOK_ERR;
- }
- parse->token[parse->tokLen] = '\0';
- parse->tokp = &parse->token[parse->tokLen - 1];
- parse->tokLen += ESP_TOK_INCR;
- parse->endp = &parse->token[parse->tokLen - 1];
- }
-
- switch (c) {
- case 0:
- if (*parse->token) {
- done++;
- parse->inp--;
- break;
- }
- return ESP_TOK_EOF;
-
- default:
- if (c == '\"' && state != ESP_STATE_IN_ESP_TAG) {
- *parse->tokp++ = '\\';
- }
- *parse->tokp++ = c;
- quoted = 0;
- break;
-
- case '\\':
- quoted = 1;
- *parse->tokp++ = c;
- break;
-
- case '@':
- if (*parse->inp == '@' && state != ESP_STATE_IN_ESP_TAG) {
- if (quoted) {
- parse->tokp--;
- quoted = 0;
- } else {
- if (*parse->token) {
- parse->inp--;
- } else {
- parse->inp++;
- tid = ESP_TOK_ATAT;
- if (getIdentifier(parse) < 0) {
- return ESP_TOK_ERR;
- }
- }
- done++;
- break;
- }
- }
- *parse->tokp++ = c;
- break;
-
- case '<':
- if (*parse->inp == '%' && state != ESP_STATE_IN_ESP_TAG) {
- if (quoted) {
- parse->tokp--;
- quoted = 0;
- *parse->tokp++ = c;
- break;
- }
- if (*parse->token) {
- parse->inp--;
- done++;
- break;
- }
- parse->inp++;
- while (isspace((int) *parse->inp)) {
- parse->inp++;
- }
- if (*parse->inp == '=') {
- parse->inp++;
- while (isspace((int) *parse->inp)) {
- parse->inp++;
- }
- tid = ESP_TOK_EQUALS;
- if (getIdentifier(parse) < 0) {
- return ESP_TOK_ERR;
- }
- done++;
- break;
- }
- if (*parse->inp == 'i' &&
- strncmp(parse->inp, "include", 7) == 0 &&
- isspace((int) parse->inp[7])) {
- tid = ESP_TOK_INCLUDE;
- parse->inp += 7;
- while (isspace((int) *parse->inp)) {
- parse->inp++;
- }
- while (*parse->inp && !isspace((int) *parse->inp) &&
- *parse->inp != '%' && parse->tokp < parse->endp) {
- *parse->tokp++ = *parse->inp++;
- }
- *parse->tokp = '\0';
- if (parse->token[0] == '"') {
- parse->tokp = parse->token;
- for (cp = &parse->token[1]; *cp; ) {
- *parse->tokp++ = *cp++;
- }
- if (cp[-1] == '"') {
- parse->tokp--;
- }
- *parse->tokp = '\0';
- }
-
- } else {
- tid = ESP_TOK_START_ESP;
- }
- done++;
- break;
- }
- *parse->tokp++ = c;
- break;
-
- case '%':
- if (*parse->inp == '>' && state == ESP_STATE_IN_ESP_TAG) {
- if (quoted) {
- parse->tokp--;
- quoted = 0;
- } else {
- if (*parse->token) {
- parse->inp--;
- } else {
- tid = ESP_TOK_END_ESP;
- parse->inp++;
- }
- done++;
- break;
- }
- }
- *parse->tokp++ = c;
- break;
- }
- }
-
- *parse->tokp = '\0';
- parse->inp--;
- return tid;
-}
-
-/******************************************************************************/
-/*
- * Convert an ESP page into a JavaScript. We also expand include files.
- */
-
-static int buildScript(EspRequest *ep, char **jsBuf, char *input, char **errMsg)
-{
- EspParse parse;
- char path[MPR_MAX_FNAME], dir[MPR_MAX_FNAME], incPath[MPR_MAX_FNAME];
- char *incBuf, *incText;
- int state, tid, len, rc, maxScriptSize, incSize;
-
- mprAssert(ep);
- mprAssert(jsBuf);
- mprAssert(input);
-
- rc = 0;
- len = 0;
- state = ESP_STATE_BEGIN;
- if (errMsg) {
- *errMsg = 0;
- }
-
- memset(&parse, 0, sizeof(parse));
- parse.token = (char*) mprMalloc(ESP_TOK_INCR);
- if (parse.token == 0) {
- return MPR_ERR_CANT_ALLOCATE;
- }
- parse.token[0] = '\0';
- parse.tokLen = ESP_TOK_INCR;
- parse.endp = &parse.token[parse.tokLen - 1];
- parse.tokp = parse.token;
- parse.inBuf = input;
- parse.inp = parse.inBuf;
-
- maxScriptSize = esp->maxScriptSize;
-
- tid = getEspToken(state, &parse);
- while (tid != ESP_TOK_EOF && len >= 0) {
-
- switch (tid) {
- default:
- case ESP_TOK_ERR:
- mprFree(parse.token);
- return MPR_ERR_BAD_SYNTAX;
-
- case ESP_TOK_LITERAL:
- len = mprReallocStrcat(jsBuf, maxScriptSize, len, 0,
- "write(\"", parse.token, "\");\n", NULL);
- break;
-
- case ESP_TOK_ATAT:
- /*
- * Trick to get undefined variables to evaluate to "".
- * Catenate with "" to cause toString to run.
- */
- len = mprReallocStrcat(jsBuf, maxScriptSize, len, 0,
- "write(\"\" + ", parse.token, ");\n", NULL);
- break;
-
- case ESP_TOK_EQUALS:
- len = mprReallocStrcat(jsBuf, maxScriptSize, len, 0,
- "write(\"\" + ", parse.token, ");\n", NULL);
- state = ESP_STATE_IN_ESP_TAG;
- break;
-
- case ESP_TOK_START_ESP:
- state = ESP_STATE_IN_ESP_TAG;
- tid = getEspToken(state, &parse);
- while (tid != ESP_TOK_EOF && tid != ESP_TOK_EOF &&
- tid != ESP_TOK_END_ESP && len >= 0) {
- len = mprReallocStrcat(jsBuf, maxScriptSize, len, 0,
- parse.token, NULL);
- tid = getEspToken(state, &parse);
- }
- state = ESP_STATE_BEGIN;
- break;
-
- case ESP_TOK_END_ESP:
- state = ESP_STATE_BEGIN;
- break;
-
- case ESP_TOK_INCLUDE:
- if (parse.token[0] == '/') {
- mprStrcpy(incPath, sizeof(incPath), parse.token);
- } else {
- mprGetDirName(dir, sizeof(dir), ep->uri);
- mprSprintf(incPath, sizeof(incPath), "%s/%s",
- dir, parse.token);
- }
- if (esp->mapToStorage(ep->requestHandle, path, sizeof(path),
- incPath, 0) < 0) {
- mprAllocSprintf(errMsg, MPR_MAX_STRING,
- "Can't find include file: %s", path);
- rc = MPR_ERR_CANT_OPEN;
- break;
- }
- if (esp->readFile(ep->requestHandle, &incText, &incSize, path) < 0){
- mprAllocSprintf(errMsg, MPR_MAX_STRING,
- "Can't read include file: %s", path);
- rc = MPR_ERR_CANT_READ;
- break;
- }
- incText[incSize] = '\0';
-
- /*
- * Recurse and process the include script
- */
- incBuf = 0;
- if ((rc = buildScript(ep, &incBuf, incText, errMsg)) < 0) {
- mprFree(incText);
- mprFree(parse.token);
- return rc;
- }
-
- len = mprReallocStrcat(jsBuf, maxScriptSize, len, 0, incBuf, NULL);
- mprFree(incText);
- mprFree(incBuf);
- state = ESP_STATE_IN_ESP_TAG;
- break;
- }
- tid = getEspToken(state, &parse);
- }
- mprFree(parse.token);
- if (len < 0) {
- mprAllocSprintf(errMsg, MPR_MAX_STRING,
- "Script token is too big in %s.\nConfigured maximum is %d.",
- path, maxScriptSize);
- return MPR_ERR_WONT_FIT;
- }
- return rc;
-}
-
-/******************************************************************************/
-/******************************* Wrapped Routines *****************************/
-/******************************************************************************/
-
-int espCopyVar(EspRequest *ep, char *var, MprVar *value, int copyDepth)
-{
- return ejsCopyVar(ep->eid, var, value, copyDepth);
-}
-
-/******************************************************************************/
-
-MprVar espCreateObjVar(char *name, int hashSize)
-{
- return ejsCreateObj(name, hashSize);
-}
-
-/******************************************************************************/
-
-MprVar espCreateArrayVar(char *name, int size)
-{
- return ejsCreateArray(name, size);
-}
-
-/******************************************************************************/
-
-bool espDestroyVar(MprVar *obj)
-{
- return ejsDestroyVar(obj);
-}
-
-/******************************************************************************/
-
-MprVar *espCreateProperty(MprVar *obj, char *property, MprVar *newValue)
-{
- return mprCreateProperty(obj, property, newValue);
-}
-
-/******************************************************************************/
-
-MprVar *espCreatePropertyValue(MprVar *obj, char *property, MprVar newValue)
-{
- return mprCreatePropertyValue(obj, property, newValue);
-}
-
-/******************************************************************************/
-
-void espDefineFunction(EspRequest *ep, const char *functionName, char *args, char *body)
-{
- ejsDefineFunction(ep->eid, functionName, args, body);
-}
-
-/******************************************************************************/
-
-int espDeleteProperty(MprVar *obj, char *property)
-{
- return mprDeleteProperty(obj, property);
-}
-
-/******************************************************************************/
-
-int espDeleteVar(EspRequest *ep, char *var)
-{
- return ejsDeleteVar(ep->eid, var);
-}
-
-/******************************************************************************/
-int espEvalFile(EspRequest *ep, char *path, MprVar *result, char **emsg)
-{
- return ejsEvalFile(ep->eid, path, result, emsg);
-}
-
-/******************************************************************************/
-
-int espEvalScript(EspRequest *ep, char *script, MprVar *result, char **emsg)
-{
- return ejsEvalScript(ep->eid, script, result, emsg);
-}
-
-/******************************************************************************/
-
-int espGetPropertyCount(MprVar *obj, int includeFlags)
-{
- if (obj->type != MPR_TYPE_OBJECT) {
- return MPR_ERR_BAD_STATE;
- }
- return mprGetPropertyCount(obj, includeFlags);
-}
-
-/******************************************************************************/
-
-MprVar *espGetFirstProperty(MprVar *obj, int includeFlags)
-{
- return mprGetFirstProperty(obj, includeFlags);
-}
-
-/******************************************************************************/
-
-MprVar *espGetGlobalObject(EspRequest *ep)
-{
- return ejsGetGlobalObject(ep->eid);
-}
-
-/******************************************************************************/
-
-MprVar *espGetLocalObject(EspRequest *ep)
-{
- return ejsGetLocalObject(ep->eid);
-}
-
-/******************************************************************************/
-
-MprVar *espGetNextProperty(MprVar *obj, MprVar *currentProperty,
- int includeFlags)
-{
- return mprGetNextProperty(obj, currentProperty, includeFlags);
-}
-
-/******************************************************************************/
-
-MprVar *espGetProperty(MprVar *obj, char *property, MprVar *value)
-{
- return mprGetProperty(obj, property, value);
-}
-
-/******************************************************************************/
-
-void *espGetThisPtr(EspRequest *ep)
-{
- return ejsGetThisPtr(ep->eid);
-}
-
-/******************************************************************************/
-#if XX_UNUSED_XX
-
-int espReadProperty(MprVar *dest, MprVar *prop)
-{
- mprAssert(prop);
- mprAssert(dest);
-
- *dest = *prop;
- return 0;
-}
-
-#endif
-/******************************************************************************/
-
-int espReadVar(EspRequest *ep, char *var, MprVar *value)
-{
- return ejsReadVar(ep->eid, var, value);
-}
-
-/******************************************************************************/
-
-int espRunFunction(EspRequest *ep, MprVar *obj, char *functionName,
- MprArray *args)
-{
- return ejsRunFunction(ep->eid, obj, functionName, args);
-}
-
-/******************************************************************************/
-
-MprVar *espSetProperty(MprVar *obj, char *property, MprVar *newValue)
-{
- return mprSetProperty(obj, property, newValue);
-}
-
-/******************************************************************************/
-
-MprVar *espSetPropertyValue(MprVar *obj, char *property, MprVar newValue)
-{
- return mprSetPropertyValue(obj, property, newValue);
-}
-
-/******************************************************************************/
-
-int espWriteVar(EspRequest *ep, char *var, MprVar *value)
-{
- return ejsWriteVar(ep->eid, var, value);
-}
-
-/******************************************************************************/
-
-int espWriteVarValue(EspRequest *ep, char *var, MprVar value)
-{
- return ejsWriteVarValue(ep->eid, var, value);
-}
-
-/******************************************************************************/
-#if XX_UNUSED_XX
-
-int espWriteProperty(MprVar *prop, MprVar *newValue)
-{
- return mprWriteProperty(prop, newValue);
-}
-
-/******************************************************************************/
-
-int espWritePropertyValue(MprVar *prop, MprVar newValue)
-{
- return mprWritePropertyValue(prop, newValue);
-}
-
-#endif
-/******************************************************************************/
-
-#else /* !BLD_FEATURE_ESP_MODULE */
-void espDummy() {}
-
-/******************************************************************************/
-#endif /* BLD_FEATURE_ESP_MODULE */
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/**
- * @file esp.h
- * @brief Header for Embedded Server Pages (ESP)
- */
-/********************************* Copyright **********************************/
-/*
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2005. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-/********************************** Includes **********************************/
-
-#ifndef _h_ESP_h
-#define _h_ESP_h 1
-
-#include "lib/appweb/ejs/ejs.h"
-#include "lib/appweb/esp/espEnv.h"
-#include "lib/appweb/mpr/var.h"
-#include "lib/appweb/mpr/miniMpr.h"
-
-/*********************************** Defines **********************************/
-
-#if BLD_FEATURE_SQUEEZE
-#define ESP_TOK_INCR 1024
-#define ESP_MAX_HEADER 1024
-#else
-#define ESP_TOK_INCR 4096
-#define ESP_MAX_HEADER 4096
-#endif
-
-/*
- * ESP lexical analyser tokens
- */
-#define ESP_TOK_ERR -1 /* Any input error */
-#define ESP_TOK_EOF 0 /* End of file */
-#define ESP_TOK_START_ESP 1 /* <% */
-#define ESP_TOK_END_ESP 2 /* %> */
-#define ESP_TOK_ATAT 3 /* @@var */
-#define ESP_TOK_LITERAL 4 /* literal HTML */
-#define ESP_TOK_INCLUDE 5 /* include file.esp */
-#define ESP_TOK_EQUALS 6 /* = var */
-
-/*
- * ESP parser states
- */
-#define ESP_STATE_BEGIN 1 /* Starting state */
-#define ESP_STATE_IN_ESP_TAG 2 /* Inside a <% %> group */
-
-/*********************************** Types ************************************/
-
-typedef void* EspHandle; /* Opaque Web server handle type */
-
-/*
- * Per request control block
- */
-typedef struct EspRequest {
- MprStr docPath; /* Physical path for ESP page */
- EjsId eid; /* EJS instance handle */
- const struct Esp *esp; /* Pointer to ESP control block */
- EspHandle requestHandle; /* Per request web server handle */
- MprStr uri; /* Request URI */
- MprVar *variables; /* Pointer to variables */
-} EspRequest;
-
-/*
- * Master ESP control block. This defines the function callbacks for a
- * web server handler to implement. ESP will call these functions as
- * required.
- */
-typedef struct Esp {
- int maxScriptSize;
- void (*createSession)(EspHandle handle, int timeout);
- void (*destroySession)(EspHandle handle);
- const char *(*getSessionId)(EspHandle handle);
- int (*mapToStorage)(EspHandle handle, char *path, int len, const char *uri,
- int flags);
- int (*readFile)(EspHandle handle, char **buf, int *len, const char *path);
- void (*redirect)(EspHandle handle, int code, char *url);
- void (*setCookie)(EspHandle handle, const char *name, const char *value,
- int lifetime, const char *path, bool secure);
- void (*setHeader)(EspHandle handle, const char *value, bool allowMultiple);
- void (*setResponseCode)(EspHandle handle, int code);
- int (*writeBlock)(EspHandle handle, const char *buf, int size);
- int (*writeFmt)(EspHandle handle, char *fmt, ...);
-#if BLD_FEATURE_MULTITHREAD
- void (*lock)(void *lockData);
- void (*unlock)(void *lockData);
- void *lockData;
-#endif
-} Esp;
-
-
-/*
- * ESP parse context
- */
-typedef struct {
- char *inBuf; /* Input data to parse */
- char *inp; /* Next character for input */
- char *endp; /* End of storage (allow for null) */
- char *tokp; /* Pointer to current parsed token */
- char *token; /* Storage buffer for token */
- int tokLen; /* Length of buffer */
-} EspParse;
-
-
-/******************************** Private APIs ********************************/
-
-extern void espRegisterProcs(void);
-
-/******************************** Published API *******************************/
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*
- * Function callback signatures
- */
-typedef int (*EspCFunction)(EspRequest *ep, int argc,
- struct MprVar **argv);
-typedef int (*EspStringCFunction)(EspRequest *ep, int argc,
- char **argv);
-
-/*
- * APIs for those hosting the ESP module
- */
-extern int espOpen(const Esp *control);
-extern void espClose(void);
-extern EspRequest *espCreateRequest(EspHandle webServerRequestHandle,
- char *uri, MprVar *envObj);
-extern void espDestroyRequest(EspRequest *ep);
-extern int espProcessRequest(EspRequest *ep, const char *docPath,
- char *docBuf, char **errMsg);
-
-/*
- * Method invocation
- */
-extern void espDefineCFunction(EspRequest *ep, const char *functionName,
- EspCFunction fn, void *thisPtr);
-extern void espDefineFunction(EspRequest *ep, const char *functionName,
- char *args, char *body);
-extern void espDefineStringCFunction(EspRequest *ep,
- const char *functionName, EspStringCFunction fn,
- void *thisPtr);
-extern int espRunFunction(EspRequest *ep, MprVar *obj,
- char *functionName, MprArray *args);
-extern void espSetResponseCode(EspRequest *ep, int code);
-extern void espSetReturn(EspRequest *ep, MprVar value);
-extern void *espGetThisPtr(EspRequest *ep);
-
-/*
- * Utility routines to use in C methods
- */
-extern void espError(EspRequest *ep, const char *fmt, ...) PRINTF_ATTRIBUTE(2,3);
-extern int espEvalFile(EspRequest *ep, char *path, MprVar *result,
- char **emsg);
-extern int espEvalScript(EspRequest *ep, char *script, MprVar *result,
- char **emsg);
-extern MprVar *espGetLocalObject(EspRequest *ep);
-extern MprVar *espGetGlobalObject(EspRequest *ep);
-extern EspHandle espGetRequestHandle(EspRequest *ep);
-extern MprVar *espGetResult(EspRequest *ep);
-extern EjsId espGetScriptHandle(EspRequest *ep);
-extern void espRedirect(EspRequest *ep, int code, char *url);
-extern void espSetHeader(EspRequest *ep, char *header,
- bool allowMultiple);
-extern void espSetReturnString(EspRequest *ep, const char *str);
-extern int espWrite(EspRequest *ep, char *buf, int size);
-extern int espWriteString(EspRequest *ep, char *buf);
-extern int espWriteFmt(EspRequest *ep, char *fmt, ...) PRINTF_ATTRIBUTE(2,3);
-
-/*
- * ESP array[] variable access (set will update/create)
- */
-extern int espGetVar(EspRequest *ep, EspEnvType oType, char *var,
- MprVar *value);
-extern char *espGetStringVar(EspRequest *ep, EspEnvType oType,
- char *var, char *defaultValue);
-extern void espSetVar(EspRequest *ep, EspEnvType oType, char *var,
- MprVar value);
-extern void espSetStringVar(EspRequest *ep, EspEnvType oType,
- const char *var, const char *value);
-extern int espUnsetVar(EspRequest *ep, EspEnvType oType, char *var);
-
-/*
- * Object creation and management
- */
-extern MprVar espCreateObjVar(char *name, int hashSize);
-extern MprVar espCreateArrayVar(char *name, int size);
-extern bool espDestroyVar(MprVar *var);
-extern MprVar *espCreateProperty(MprVar *obj, char *property,
- MprVar *newValue);
-extern MprVar *espCreatePropertyValue(MprVar *obj, char *property,
- MprVar newValue);
-extern int espDeleteProperty(MprVar *obj, char *property);
-
-/*
- * JavaScript variable management. Set will create/update a property.
- * All return a property reference. GetProperty will optionally return the
- * property in value.
- */
-extern MprVar *espGetProperty(MprVar *obj, char *property,
- MprVar *value);
-extern MprVar *espSetProperty(MprVar *obj, char *property,
- MprVar *newValue);
-extern MprVar *espSetPropertyValue(MprVar *obj, char *property,
- MprVar newValue);
-
-#if 0
-/*
- * Low-level direct read and write of properties.
- * FUTURE: -- Read is not (dest, src). MUST WARN IN DOC ABOUT COPY/READ
- * Will still cause triggers to run.
- */
-extern int espReadProperty(MprVar *dest, MprVar *prop);
-extern int espWriteProperty(MprVar *prop, MprVar *newValue);
-extern int espWritePropertyValue(MprVar *prop, MprVar newValue);
-#endif
-
-
-/*
- * Access JavaScript variables by their full name. Can use "." or "[]". For
- * example: "global.request['REQUEST_URI']"
- * For Read/write, the variables must exist.
- */
-extern int espCopyVar(EspRequest *ep, char *var, MprVar *value,
- int copyDepth);
-extern int espDeleteVar(EspRequest *ep, char *var);
-extern int espReadVar(EspRequest *ep, char *var, MprVar *value);
-extern int espWriteVar(EspRequest *ep, char *var, MprVar *value);
-extern int espWriteVarValue(EspRequest *ep, char *var, MprVar value);
-
-/*
- * Object property enumeration
- */
-extern MprVar *espGetFirstProperty(MprVar *obj, int includeFlags);
-extern MprVar *espGetNextProperty(MprVar *obj, MprVar *currentProperty,
- int includeFlags);
-extern int espGetPropertyCount(MprVar *obj, int includeFlags);
-
-#ifdef __cplusplus
-}
-#endif
-/******************************************************************************/
-#endif /* _h_ESP_h */
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- * @file espEnv.h
- * @brief ESP Environment Variables
- */
-/********************************* Copyright **********************************/
-/*
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2005. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-
-/******************************************************************************/
-
-#ifndef _h_ESP_ENV_h
-#define _h_ESP_ENV_h 1
-
-/*
- * @brief Scripting environment variable array types
- */
-typedef enum EspEnvType {
- ESP_UNDEFINED_OBJ = -1,
-
- /**
- * Elements for server[]:
- * DOCUMENT_ROOT GATEWAY_INTERFACE SERVER_ADDR SERVER_PORT SERVER_NAME
- * SERVER_PROTOCOL SERVER_SOFTWARE SERVER_URL UPLOAD_DIR
- * FUTURE: SERVER_ADMIN
- * FUTURE: this could be shared across all hosts and be made read-only.
- */
- ESP_SERVER_OBJ = 0, /*! server[] data */
-
- /**
- * Elements for session[]: are user defined
- */
- ESP_SESSION_OBJ = 1, /*! session[] data */
-
- /**
- * Elements for request[]:
- * AUTH_TYPE CONTENT_LENGTH CONTENT_TYPE QUERY_STRING PATH_INFO
- * PATH_TRANSLATED REMOTE_ADDR REMOTE_HOST REMOTE_USER REQUEST_METHOD
- * REQUEST_URI SCRIPT_FILENAME SCRIPT_NAME
- * FUTURE: FILEPATH_INFO REDIRECT_URL SELF REMOTE_PORT AUTH_USER
- * AUTH_GROUP AUTH_ACL
- */
- ESP_REQUEST_OBJ = 2, /*! request[] data */
-
- /**
- * Elements for headers[]:
- * HTTP_ACCEPT HTTP_ACCEPT_CHARSET HTTP_CONNECTION HTTP_HOST
- * HTTP_REFERER HTTP_USER_AGENT and any other custom headers
- */
- ESP_HEADERS_OBJ = 3, /*! header [] data */
-
- /**
- * Elements for cookies[]: are defined by the HTTP request
- */
- ESP_COOKIES_OBJ = 4, /*! cookies[] data */
-
- /**
- * Elements for files[]: are defined by the HTTP request
- * CLIENT_FILENAME CONTENT_TYPE FILENAME SIZE
- */
- ESP_FILES_OBJ = 5, /*! files[] data */
-
- /**
- * Elements for form[]: are defined by the HTTP request
- */
- ESP_FORM_OBJ = 6, /*! form[] data */
-
- /**
- * Elements for application[]: are user defined
- */
- ESP_APPLICATION_OBJ = 7, /*! application[] data */
-
- /**
- * Elements for global[]: are defined by ESP/EJS
- */
- ESP_GLOBAL_OBJ = 8, /*! global [] data */
-
- /*
- * Elements for local[]: are defined by ESP/EJS
- */
- ESP_LOCAL_OBJ = 9, /*! local [] data */
-} EspEnvType;
-
-#define ESP_OBJ_MAX 10 /* Total objects */
-
-#if BLD_SQUEEZE
-#define ESP_HASH_SIZE 19 /* Size of hash tables */
-#else
-#define ESP_HASH_SIZE 37
-#endif
-
-/******************************************************************************/
-#endif /* _h_ESP_ENV_h */
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- * @file espProcs.c
- * @brief Embedded Server Pages (ESP) Procedures.
- * @overview These ESP procedures can be used in ESP pages for common tasks.
- */
-/********************************* Copyright **********************************/
-/*
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2005. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-/********************************** Includes **********************************/
-
-#include "esp.h"
-
-/************************************ Code ************************************/
-#if BLD_FEATURE_ESP_MODULE
-#if BLD_FEATURE_SESSION
-/*
- * destroySession
- */
-
-static int destroySessionProc(EspRequest *ep, int argc, char **argv)
-{
- ep->esp->destroySession(ep->requestHandle);
- return 0;
-}
-
-#endif /* BLD_FEATURE_SESSION */
-
-/******************************************************************************/
-/*
- * include
- *
- * This includes javascript libraries. For example:
- *
- * <% include("file", ...); %>
- *
- * Don't confuse with ESP includes:
- *
- * <% include file.esp %>
- *
- * Filenames are relative to the base document including the file.
- * FUTURE -- move back to EJS. Only here now because we need ep->readFile.
- */
-
-static int includeProc(EspRequest *ep, int argc, char **argv)
-{
- const Esp *esp;
- char path[MPR_MAX_FNAME], dir[MPR_MAX_FNAME];
- char *emsg=NULL, *buf;
- int size, i;
-
- esp = ep->esp;
- mprAssert(argv);
- for (i = 0; i < argc; i++) {
- const char *extension;
-
- if (argv[i][0] != '/') {
- mprGetDirName(dir, sizeof(dir), ep->docPath);
- mprSprintf(path, sizeof(path), "%s/%s", dir, argv[i]);
- } else {
- mprSprintf(path, sizeof(path), "%s", argv[i]);
- }
-
- if (esp->readFile(ep->requestHandle, &buf, &size, path) < 0) {
- espError(ep, "Can't read include file: %s", path);
- return MPR_ERR_CANT_ACCESS;
- }
- buf[size] = '\0';
-
- extension = strrchr(argv[i], '.');
-
- /*
- * Allow nested inclusion of ESP requests
- */
- if (extension && mprStrCmpAnyCase(extension, ".esp") == 0) {
- if (espProcessRequest(ep, path, buf, &emsg) != 0) {
- espError(ep, "Cant evaluate script - %s", emsg?emsg:"");
- mprFree(buf);
- return -1;
- }
- } else {
- if (ejsEvalScript(espGetScriptHandle(ep), buf, 0, &emsg) < 0) {
- espError(ep, "Cant evaluate script - %s", emsg?emsg:"");
- mprFree(buf);
- return -1;
- }
- }
- mprFree(buf);
- }
- return 0;
-}
-
-/******************************************************************************/
-/*
- * redirect
- *
- * This implemements <% redirect(url, code); %> command. The redirection
- * code is optional.
- */
-
-static int redirectProc(EspRequest *ep, int argc, char **argv)
-{
- char *url;
- int code;
-
- if (argc < 1) {
- espError(ep, "Bad args");
- return MPR_ERR_BAD_ARGS;
- }
- url = argv[0];
- if (argc == 2) {
- code = atoi(argv[1]);
- } else {
- code = 302;
- }
- espRedirect(ep, code, url);
- return 0;
-}
-
-/******************************************************************************/
-#if BLD_FEATURE_SESSION
-/*
- * useSession
- */
-
-static int useSessionProc(EspRequest *ep, int argc, char **argv)
-{
- int timeout;
-
- if (argc > 1) {
- espError(ep, "Bad args");
- return MPR_ERR_BAD_ARGS;
-
- } else if (argc == 1) {
- timeout = atoi(argv[0]);
- } else {
- timeout = 0;
- }
-
- ep->esp->createSession(ep->requestHandle, timeout);
- espSetReturnString(ep, ep->esp->getSessionId(ep->requestHandle));
- return 0;
-}
-
-#endif /* BLD_FEATURE_SESSION */
-/******************************************************************************/
-/*
- * setHeader
- *
- * This implemements <% setHeader("key: value", allowMultiple); %> command.
- */
-
-static int setHeaderProc(EspRequest *ep, int argc, char **argv)
-{
- mprAssert(argv);
- if (argc != 2) {
- espError(ep, "Bad args");
- return MPR_ERR_BAD_ARGS;
- }
- ep->esp->setHeader(ep->requestHandle, argv[0], atoi(argv[1]));
- return 0;
-}
-
-/******************************************************************************/
-/*
- * write
- *
- * This implemements <% write("text"); %> command.
- */
-
-static int writeProc(EspRequest *ep, int argc, char **argv)
-{
- char *s;
- int i, len;
-
- mprAssert(argv);
- for (i = 0; i < argc; i++) {
- s = argv[i];
- len = strlen(s);
- if (len > 0) {
- if (espWrite(ep, s, len) != len) {
- espError(ep, "Can't write to client");
- return -1;
- }
- }
- }
- return 0;
-}
-
-/******************************************************************************/
-
-void espRegisterProcs()
-{
- espDefineStringCFunction(0, "write", writeProc, 0);
- espDefineStringCFunction(0, "setHeader", setHeaderProc, 0);
- espDefineStringCFunction(0, "redirect", redirectProc, 0);
- espDefineStringCFunction(0, "include", includeProc, 0);
-
-#if BLD_FEATURE_SESSION
- /*
- * Create and use are synonomous
- */
- espDefineStringCFunction(0, "useSession", useSessionProc, 0);
- espDefineStringCFunction(0, "createSession", useSessionProc, 0);
- espDefineStringCFunction(0, "destroySession", destroySessionProc, 0);
-#endif
-}
-
-/******************************************************************************/
-
-#else
-void mprEspControlsDummy() {}
-
-#endif /* BLD_FEATURE_ESP_MODULE */
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- * @file miniMpr.cpp
- * @brief Mini Mbedthis Portable Runtime (MPR)
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2005. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-
-#include "miniMpr.h"
-#include "param/param.h"
-#include "lib/events/events.h"
-
-/************************************ Code ************************************/
-#if !BLD_APPWEB
-#if !BLD_GOAHEAD_WEBSERVER
-
-static void *mpr_ctx;
-
-/* set the memory context to be used for all ejs variables */
-void mprSetCtx(TALLOC_CTX *ctx)
-{
- mpr_ctx = ctx;
-}
-
-/* return the memory context being used for all ejs variables */
-void *mprMemCtx(void)
-{
- return mpr_ctx;
-}
-
-struct event_context *mprEventCtx(void)
-{
- return event_context_find(mprMemCtx());
-}
-
-/* return the loadparm context being used for all ejs variables */
-struct loadparm_context *mprLpCtx(void)
-{
- return global_loadparm;
-}
-
-void mprFree(void *ptr)
-{
- talloc_free(ptr);
-}
-
-void *mprMalloc(uint size)
-{
- return talloc_size(mpr_ctx, size);
-}
-
-/******************************************************************************/
-
-void *mprRealloc(void *ptr, uint size)
-{
- return talloc_realloc_size(mpr_ctx, ptr, size);
-}
-
-/******************************************************************************/
-
-char *mprStrdup(const char *str)
-{
- if (str == 0) {
- str = "";
- }
- return talloc_strdup(mpr_ctx, str);
-}
-
-/*****************************************************************************/
-
-int mprAllocSprintf(char **msgbuf, int maxSize, const char *fmt, ...)
-{
- va_list args;
- char *buf;
- int count;
-
- va_start(args, fmt);
- buf = mprMalloc(maxSize + 1);
- count = mtVsprintf(buf, maxSize, fmt, args);
- *msgbuf = buf;
- va_end(args);
- return count;
-}
-
-/*****************************************************************************/
-
-int mprAllocVsprintf(char **msgbuf, int maxSize, const char *fmt, va_list args)
-{
- char *buf;
- int count;
-
- buf = mprMalloc(maxSize + 1);
- count = mtVsprintf(buf, maxSize, fmt, args);
- *msgbuf = buf;
- return count;
-}
-
-
-/*****************************************************************************/
-/*
- * Format a number as a string. FUTURE -- reverse args to be standard.
- * ie. mprItoa(char *userBuf, int bufsize, int value);
- */
-
-char *mprItoa(int value, char *buf, int width)
-{
- char numBuf[16];
- char *cp, *dp, *endp;
- int negative;
-
- cp = &numBuf[sizeof(numBuf)];
- *--cp = '\0';
-
- if (value < 0) {
- negative = 1;
- value = -value;
- width--;
- } else {
- negative = 0;
- }
-
- do {
- *--cp = '0' + (value % 10);
- value /= 10;
- } while (value > 0);
-
- if (negative) {
- *--cp = '-';
- }
-
- dp = buf;
- endp = &buf[width];
- while (dp < endp && *cp) {
- *dp++ = *cp++;
- }
- *dp++ = '\0';
- return buf;
-}
-
-/*****************************************************************************/
-
-void mprLog(int level, const char *fmt, ...)
-{
- va_list args;
- char *buf;
-
- if (DEBUGLVL(level)) {
- va_start(args, fmt);
- mprAllocVsprintf(&buf, MPR_MAX_STRING, fmt, args);
- va_end(args);
- DEBUG(level, ("mprLog: %s", buf));
- mprFree(buf);
- }
-}
-
-/*****************************************************************************/
-
-void mprBreakpoint(const char *file, int line, const char *cond)
-{
- char *buf;
- mprAllocSprintf(&buf, MPR_MAX_STRING, "esp exception - ASSERT at %s:%d, %s\n",
- file, line, cond);
- ejs_exception(buf);
-}
-
-#endif /* !BLD_GOAHEAD_WEBSERVER */
-/*****************************************************************************/
-/*
- * Create a general growable array structure
- */
-
-MprArray *mprCreateArray()
-{
- MprArray *array;
- int size;
-
- array = (MprArray*) mprMalloc(sizeof(MprArray));
- if (array == 0) {
- return 0;
- }
- memset(array, 0, sizeof(MprArray));
-
- size = MPR_ARRAY_INCR * sizeof(void*);
- array->handles = (void**) mprMalloc(size);
- if (array->handles == 0) {
- mprFree(array);
- return 0;
- }
- memset(array->handles, 0, size);
- array->max = MPR_ARRAY_INCR;
- array->used = 0;
- return array;
-}
-
-/*****************************************************************************/
-/*
- * Dispose of the array. Callers responsibility to dispose of handle entries.
- */
-
-void mprDestroyArray(MprArray *array)
-{
- mprAssert(array);
- mprAssert(array->max >= 0);
- mprAssert(array->used >= 0);
-
- mprFree(array->handles);
- mprFree(array);
-}
-
-/*****************************************************************************/
-/*
- * Add an item to the array
- */
-
-int mprAddToArray(MprArray *array, void *item)
-{
- int memsize, idx, len;
-
- mprAssert(array);
- mprAssert(array->max >= 0);
- mprAssert(array->used >= 0);
-
- if (array->used < array->max) {
- idx = array->used++;
- mprAssert(idx >= 0 && idx < array->max);
- mprAssert(array->handles[idx] == 0);
- array->handles[idx] = item;
- return idx;
- }
-
- for (idx = array->used; idx < array->max; idx++) {
- if (array->handles[idx] == 0) {
- array->used++;
- mprAssert(array->handles[idx] == 0);
- array->handles[idx] = item;
- return idx;
- }
- }
-
- len = array->max + MPR_ARRAY_INCR;
- memsize = len * sizeof(void*);
- array->handles = (void**) mprRealloc((void*) array->handles, memsize);
- if (array->handles == NULL) {
- return -1;
- }
- memset(&array->handles[array->max], 0, sizeof(void*) * MPR_ARRAY_INCR);
- array->max = len;
- array->used++;
-
- mprAssert(idx >= 0 && idx < array->max);
- mprAssert(array->handles[idx] == 0);
-
- array->handles[idx] = item;
- return idx;
-}
-
-/*****************************************************************************/
-/*
- * Remove from the array
- */
-
-int mprRemoveFromArray(MprArray *array, int idx)
-{
- mprAssert(array);
- mprAssert(array->max > 0);
- mprAssert(idx >= 0 && idx < array->max);
- mprAssert(array->handles[idx] != 0);
- mprAssert(array->used > 0);
-
- array->handles[idx] = 0;
- return --array->used;
-}
-
-/*****************************************************************************/
-/*
- * Thread-safe wrapping of strtok. Note "str" is modifed as per strtok()
- */
-
-char *mprStrTok(char *str, const char *delim, char **tok)
-{
- char *start, *end;
- int i;
-
- start = str ? str : *tok;
-
- if (start == 0) {
- return 0;
- }
-
- i = strspn(start, delim);
- start += i;
- if (*start == '\0') {
- *tok = 0;
- return 0;
- }
- end = strpbrk(start, delim);
- if (end) {
- *end++ = '\0';
- i = strspn(end, delim);
- end += i;
- }
- *tok = end;
- return start;
-}
-
-/*****************************************************************************/
-
-static int mprCoreStrcat(int alloc, char **destp, int destMax, int existingLen,
- const char *delim, const char *src, va_list args)
-{
- va_list ap;
- char *dest, *dp;
- const char *str;
- int sepLen, addBytes, required;
-
- mprAssert(destp);
- mprAssert(destMax > 0);
- mprAssert(src);
-
- dest = *destp;
- sepLen = (delim) ? strlen(delim) : 0;
-
- va_copy(ap, args);
- addBytes = 0;
- str = src;
- while (str) {
- addBytes += strlen(str) + sepLen;
- str = va_arg(ap, const char*);
- }
- va_end(ap);
-
- if (existingLen > 0) {
- addBytes += sepLen;
- }
- required = existingLen + addBytes + 1;
- if (required >= destMax) {
- mprAssert(0);
- return MPR_ERR_WONT_FIT;
- }
-
- if (alloc) {
- if (dest == 0) {
- dest = (char*) mprMalloc(required);
- } else {
- dest = (char*) mprRealloc(dest, required);
- }
- } else {
- dest = (char*) *destp;
- }
-
- dp = &dest[existingLen];
- if (delim) {
- strcpy(dp, delim);
- dp += sepLen;
- }
-
- if (addBytes > 0) {
- va_copy(ap, args);
- str = src;
- while (str) {
- strcpy(dp, str);
- dp += strlen(str);
- str = va_arg(ap, char*);
- if (delim && str) {
- strcpy(dp, delim);
- dp += sepLen;
- }
- }
- va_end(ap);
- } else if (dest == 0) {
- dest = (char*) mprMalloc(1);
- }
- *dp = '\0';
-
- *destp = dest;
- mprAssert(dp < &dest[required]);
- return required - 1;
-}
-
-/*****************************************************************************
- Note that this VARARGS function must be NULL (not 0, this must be a
- pointer) terminated
-*/
-
-int mprReallocStrcat(char **destp, int destMax, int existingLen,
- const char *delim, const char *src,...)
-{
- va_list ap;
- int rc;
-
- va_start(ap, src);
- rc = mprCoreStrcat(1, destp, destMax, existingLen, delim, src, ap);
- va_end(ap);
- return rc;
-}
-
-/*****************************************************************************/
-/*
- * Return the directory portion of a pathname into the users buffer.
- */
-
-int mprGetDirName(char *buf, int bufsize, char *path)
-{
- char *cp;
- int dlen;
-
- mprAssert(path);
- mprAssert(buf);
- mprAssert(bufsize > 0);
-
- cp = strrchr(path, '/');
- if (cp == 0) {
-#if WIN
- cp = strrchr(path, '\\');
- if (cp == 0)
-#endif
- {
- buf[0] = '\0';
- return 0;
- }
- }
-
- if (cp == path && cp[1] == '\0') {
- strcpy(buf, ".");
- return 0;
- }
-
- dlen = cp - path;
- if (dlen < bufsize) {
- if (dlen == 0) {
- dlen++;
- }
- mprMemcpy(buf, bufsize, path, dlen);
- buf[dlen] = '\0';
- return 0;
- }
- return MPR_ERR_WONT_FIT;
-}
-
-/*****************************************************************************/
-
-int mprStrcpy(char *dest, int destMax, const char *src)
-{
- int len;
-
- mprAssert(dest);
- mprAssert(destMax > 0);
- mprAssert(src);
-
- len = strlen(src);
- if (len >= destMax && len > 0) {
- mprAssert(0);
- return MPR_ERR_WONT_FIT;
- }
- if (len > 0) {
- memcpy(dest, src, len);
- dest[len] = '\0';
- } else {
- *dest = '\0';
- len = 0;
- }
- return len;
-}
-
-/*****************************************************************************/
-
-int mprMemcpy(char *dest, int destMax, const char *src, int nbytes)
-{
- mprAssert(dest);
- mprAssert(destMax > nbytes);
- mprAssert(src);
- mprAssert(nbytes > 0);
-
- if (nbytes > destMax) {
- mprAssert(0);
- return MPR_ERR_WONT_FIT;
- }
- if (nbytes > 0) {
- memcpy(dest, src, nbytes);
- return nbytes;
- } else {
- return 0;
- }
-}
-
-/*****************************************************************************/
-#else
-void miniMprDummy() {}
-#endif // !BLD_APPWEB && !BLD_GOAHEAD_WEBSERVER
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- * @file miniMpr.h
- * @brief Mini Mbedthis Portable Runtime (MPR) Environment.
- * @copy default
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2005. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-#ifndef _h_MINI_MPR
-#define _h_MINI_MPR 1
-
-/********************************** Includes **********************************/
-/*
- * Find out about our configuration
- */
-#ifndef _INCLUDES_H
- #include "includes.h"
-#endif
-
-/* allow this library to use strcpy() */
-#undef strcpy
- #include "lib/appweb/ejs/config.h"
-
-#if BLD_APPWEB
- /*
- * If building within AppWeb, use the full MPR
- */
- #include "mpr.h"
-#else
-
- #include <ctype.h>
- #include <fcntl.h>
- #include <stdarg.h>
- #include <stdlib.h>
- #include <stdio.h>
- #include <string.h>
- #include <sys/stat.h>
-
-#if !WIN
- #include <unistd.h>
-#endif
-
-#if CE
- #include <io.h>
- #include "CE/wincompat.h"
-#endif
-
-#if LYNX
- #include <unistd.h>
-#endif
-
-#if QNX4
- #include <dirent.h>
-#endif
-#ifdef HAVE_MATH_H
- #include <math.h>
-#endif
-/********************************** Defines ***********************************/
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#if BLD_FEATURE_SQUEEZE
-/*
- * Reasonable length of a file path name to use in most cases where you know
- * the expected file name and it is certain to be less than this limit.
- */
-#define MPR_MAX_FNAME 128
-#define MPR_MAX_STRING 512
-#define MPR_DEFAULT_HASH_SIZE 23 /* Default size of hash table index */
-#define MPR_MAX_HEAP_SIZE (32 * 1024)
-#else
-#define MPR_MAX_FNAME 256
-#define MPR_MAX_STRING 4096
-#define MPR_DEFAULT_HASH_SIZE 43 /* Default size of hash table index */
-#define MPR_MAX_HEAP_SIZE (64 * 1024)
-#endif
-
-/*
- * Useful for debugging
- */
-#define MPR_L __FILE__, __LINE__
-
-#if BLD_FEATURE_ASSERT
-#define mprAssert(C) \
- if (C) ; else mprBreakpoint(__FILE__, __LINE__, #C)
-#else
- #define mprAssert(C) if (1) ; else
-#endif
-
-/*
- * Standard MPR return and error codes
- */
-#define MPR_ERR_BASE (-200) /* Error code */
-#define MPR_ERR_GENERAL (MPR_ERR_BASE - 1) /* Error code */
-#define MPR_ERR_ABORTED (MPR_ERR_BASE - 2) /* Error code */
-#define MPR_ERR_ALREADY_EXISTS (MPR_ERR_BASE - 3) /* Error code */
-#define MPR_ERR_BAD_ARGS (MPR_ERR_BASE - 4) /* Error code */
-#define MPR_ERR_BAD_FORMAT (MPR_ERR_BASE - 5) /* Error code */
-#define MPR_ERR_BAD_HANDLE (MPR_ERR_BASE - 6) /* Error code */
-#define MPR_ERR_BAD_STATE (MPR_ERR_BASE - 7) /* Error code */
-#define MPR_ERR_BAD_SYNTAX (MPR_ERR_BASE - 8) /* Error code */
-#define MPR_ERR_BAD_TYPE (MPR_ERR_BASE - 9) /* Error code */
-#define MPR_ERR_BAD_VALUE (MPR_ERR_BASE - 10) /* Error code */
-#define MPR_ERR_BUSY (MPR_ERR_BASE - 11) /* Error code */
-#define MPR_ERR_CANT_ACCESS (MPR_ERR_BASE - 12) /* Error code */
-#define MPR_ERR_CANT_COMPLETE (MPR_ERR_BASE - 13) /* Error code */
-#define MPR_ERR_CANT_CREATE (MPR_ERR_BASE - 14) /* Error code */
-#define MPR_ERR_CANT_INITIALIZE (MPR_ERR_BASE - 15) /* Error code */
-#define MPR_ERR_CANT_OPEN (MPR_ERR_BASE - 16) /* Error code */
-#define MPR_ERR_CANT_READ (MPR_ERR_BASE - 17) /* Error code */
-#define MPR_ERR_CANT_WRITE (MPR_ERR_BASE - 18) /* Error code */
-#define MPR_ERR_DELETED (MPR_ERR_BASE - 19) /* Error code */
-#define MPR_ERR_NETWORK (MPR_ERR_BASE - 20) /* Error code */
-#define MPR_ERR_NOT_FOUND (MPR_ERR_BASE - 21) /* Error code */
-#define MPR_ERR_NOT_INITIALIZED (MPR_ERR_BASE - 22) /* Error code */
-#define MPR_ERR_NOT_READY (MPR_ERR_BASE - 23) /* Error code */
-#define MPR_ERR_READ_ONLY (MPR_ERR_BASE - 24) /* Error code */
-#define MPR_ERR_TIMEOUT (MPR_ERR_BASE - 25) /* Error code */
-#define MPR_ERR_TOO_MANY (MPR_ERR_BASE - 26) /* Error code */
-#define MPR_ERR_WONT_FIT (MPR_ERR_BASE - 27) /* Error code */
-#define MPR_ERR_WOULD_BLOCK (MPR_ERR_BASE - 28) /* Error code */
-#define MPR_ERR_CANT_ALLOCATE (MPR_ERR_BASE - 29) /* Error code */
-#define MPR_ERR_MAX (MPR_ERR_BASE - 30) /* Error code */
-
-/*
- * Standard error severity and trace levels. These are ored with the error
- * severities below. The MPR_LOG_MASK is used to extract the trace level
- * from a flags word. We expect most apps to run with level 2 trace.
- */
-#define MPR_FATAL 0 /* Fatal error. Cant continue. */
-#define MPR_ERROR 1 /* Hard error */
-#define MPR_WARN 2 /* Soft warning */
-#define MPR_CONFIG 2 /* Essential configuration settings */
-#define MPR_INFO 3 /* Informational only */
-#define MPR_DEBUG 4 /* Debug information */
-#define MPR_VERBOSE 9 /* Highest level of trace */
-#define MPR_LOG_MASK 0xf /* Level mask */
-
-/*
- * Error flags. Specify where the error should be sent to. Note that the
- * product.xml setting "headless" will modify how errors are reported.
- * Assert errors are trapped when in DEV mode. Otherwise ignored.
- */
-#define MPR_TRAP 0x10 /* Assert error -- trap in debugger */
-#define MPR_LOG 0x20 /* Log the error in the O/S event log */
-#define MPR_USER 0x40 /* Display to the user */
-#define MPR_ALERT 0x80 /* Send a management alert */
-#define MPR_TRACE 0x100 /* Trace */
-
-/*
- * Error format flags
- */
-#define MPR_RAW 0x200 /* Raw trace output */
-
-/*
- * Error line number information
- */
-#define MPR_L __FILE__, __LINE__
-
-typedef char* MprStr;
-
-#ifndef __cplusplus
-typedef unsigned char uchar;
-#endif
-
-/*
- * Porters: put other operating system type defines here
- */
-#if WIN
- typedef unsigned int uint;
- typedef __int64 int64;
- typedef unsigned __int64 uint64;
-#else
-#define O_BINARY 0
-#ifndef uint
- #define uint unsigned
-#endif
- #define int64 int64_t
- #define uint64 uint64_t
-#endif
-
-/*
- * Flexible array data type
- */
-typedef struct {
- int max; /* Size of the handles array */
- int used; /* Count of used entries in handles */
- void **handles;
-} MprArray;
-
-#if BLD_FEATURE_SQUEEZE
-#define MPR_ARRAY_INCR 8
-#else
-#define MPR_ARRAY_INCR 16
-#endif
-
-#ifndef max
-#define max(a,b) (((a) > (b)) ? (a) : (b))
-#endif
-
-/********************************* Prototypes *********************************/
-/*
- * If running in the GoAhead WebServer, map some MPR routines to WebServer
- * equivalents.
- */
-
-#if BLD_GOAHEAD_WEBSERVER
-#include "uemf.h"
-#define mprMalloc(size) balloc(B_L, size)
-#define mprFree(ptr) bfreeSafe(B_L, ptr)
-#define mprRealloc(ptr, size) brealloc(B_L, ptr, size)
-#define mprStrdup(ptr) bstrdup(B_L, ptr)
-#define mprAllocSprintf fmtAlloc
-#define mprAllocVsprintf fmtValloc
-#define mprSprintf fmtStatic
-#define mprItoa stritoa
-#define mprLog trace
-#define mprBreakpoint(file, line, cond) \
- error(file, line, E_BLD_FEATURE_ASSERT, T("%s"), cond)
-
-#else /* !BLD_GOAHEAD_WEBSERVER */
-/* #define mprMalloc malloc */
-#define mprSprintf snprintf
-#define mtVsprintf vsnprintf
-extern void *mprMalloc(uint size);
-extern void *mprRealloc(void *ptr, uint size);
-extern void mprFree(void *ptr);
-extern char *mprStrdup(const char *str);
-extern int mprAllocVsprintf(char **msgbuf, int maxSize, const char *fmt,
- va_list args) PRINTF_ATTRIBUTE(3,0);
-extern int mprAllocSprintf(char **msgbuf, int maxSize, const char *fmt, ...) PRINTF_ATTRIBUTE(3,4);
-extern char *mprItoa(int num, char *buf, int width);
-extern void mprLog(int level, const char *fmt, ...) PRINTF_ATTRIBUTE(2,3);
-extern void mprBreakpoint(const char *file, int line, const char *msg) _NORETURN_;
-#endif /* BLD_GOAHEAD_WEBSERVER */
-
-extern MprArray *mprCreateArray(void);
-extern void mprDestroyArray(MprArray *array);
-extern int mprAddToArray(MprArray *array, void *item);
-extern int mprRemoveFromArray(MprArray *array, int idx);
-extern char *mprStrTok(char *str, const char *delim, char **tok);
-
-extern int mprGetDirName(char *buf, int bufsize, char *path);
-extern int mprReallocStrcat(char **dest, int max, int existingLen,
- const char *delim, const char *src, ...);
-extern int mprStrcpy(char *dest, int destMax, const char *src);
-extern int mprMemcpy(char *dest, int destMax, const char *src, int nbytes);
-
-extern void mprSetCtx(void *ctx);
-extern void *mprMemCtx(void);
-struct loadparm_context;
-extern struct loadparm_context *mprLpCtx(void);
-struct event_context;
-extern struct event_context *mprEventCtx(void);
-
-/* This function needs to be provided by anyone using ejs */
-void ejs_exception(const char *reason);
-
-#define mprStrCmpAnyCase(s1, s2) strcasecmp_m(s1, s2)
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !BLD_APPWEB */
-#endif /* _h_MINI_MPR */
-
-/*****************************************************************************/
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- * @file var.c
- * @brief MPR Universal Variable Type
- * @overview
- *
- * @copy default.m
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2005. All Rights Reserved.
- * Copyright (c) Michael O'Brien, 1994-1995. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-
-/******************************* Documentation ********************************/
-
-/*
- * This module is NOT multithreaded.
- *
- * Properties are variables that are stored in an object type variable.
- * Properties can be primitive data types, other objects or functions.
- * Properties are indexed by a character name.
- */
-
-/********************************** Includes **********************************/
-
-#include "var.h"
-
-/*********************************** Locals ***********************************/
-#if VAR_DEBUG
-
-static MprProperties objectList; /* Dummy head of objects list */
-static int objectCount = -1; /* Count of objects */
-
-#endif
-/***************************** Forward Declarations ***************************/
-
-static int adjustRefCount(MprProperties *pp, int adj);
-static int adjustVarRefCount(MprVar *vp, int adj);
-static MprVar *allocProperty(const char *propertyName);
-static void copyVarCore(MprVar *dest, MprVar *src, int copyDepth);
-static MprProperties
- *createProperties(const char *name, int hashSize);
-static bool freeVar(MprVar *vp, int force);
-static bool freeVarStorage(MprVar *vp, int force);
-static MprVar *getObjChain(MprProperties *pp, const char *property);
-static int hash(MprProperties *pp, const char *property);
-static bool releaseProperties(MprProperties *pp, int force);
-
-/*********************************** Code *************************************/
-/*
- * Destroy a variable and all referenced variables. Release any referenced
- * object regardless of whether other users still have references. Be VERY
- * careful using this routine.
- *
- * Return TRUE if the underlying data is freed. Objects may not be freed if
- * there are other users of the object.
- */
-
-bool mprDestroyAllVars(MprVar *vp)
-{
- mprAssert(vp);
-
- if (vp->trigger) {
- if ((vp->trigger)(MPR_VAR_DELETE, vp->parentProperties, vp, 0, 0)
- == MPR_TRIGGER_ABORT) {
- return 0;
- }
- }
-
- /*
- * Free the actual value. If this var refers to an object, we will
- * recurse through all the properties freeing all vars.
- */
- return freeVar(vp, 1);
-}
-
-/******************************************************************************/
-/*
- * Destroy a variable. Release any referenced object (destroy if no other
- * users are referencing).
- *
- * Return TRUE if the underlying data is freed. Objects may not be freed if
- * there are other users of the object.
- */
-
-bool mprDestroyVar(MprVar *vp)
-{
- mprAssert(vp);
-
- if (vp->trigger) {
- if ((vp->trigger)(MPR_VAR_DELETE, vp->parentProperties, vp, 0, 0)
- == MPR_TRIGGER_ABORT) {
- return 0;
- }
- }
-
- /*
- * Free the actual value. If this var refers to an object, we will
- * recurse through all the properties freeing all that have no other
- * references.
- */
- return freeVar(vp, 0);
-}
-
-/******************************************************************************/
-/*
- * Free the value in a variable for primitive types. Release objects.
- *
- * Return TRUE if the underlying data is freed. Objects may not be freed if
- * there are other users of the object.
- */
-
-static bool freeVar(MprVar *vp, int force)
-{
- bool freed;
-
- mprAssert(vp);
-
- freed = freeVarStorage(vp, force);
-
- mprFree(vp->name);
- mprFree(vp->fullName);
-
- if (vp->allocatedVar) {
- mprFree(vp);
- } else {
- vp->name = 0;
- vp->fullName = 0;
- vp->type = MPR_TYPE_UNDEFINED;
- }
- return freed;
-}
-
-/******************************************************************************/
-/*
- * Free the value in a variable for primitive types. Release objects.
- *
- * Return TRUE if the underlying data is freed. Objects may not be freed if
- * there are other users of the object.
- */
-
-static bool freeVarStorage(MprVar *vp, int force)
-{
- MprArray *argList;
- bool freed;
- int i;
-
- freed = 1;
- mprAssert(vp);
-
- switch (vp->type) {
- default:
- break;
-
- case MPR_TYPE_STRING:
- if (vp->allocatedData && vp->string != 0) {
- mprFree(vp->string);
- vp->string = 0;
- vp->allocatedData = 0;
- }
- break;
-
- case MPR_TYPE_PTR:
- if (vp->allocatedData) {
- vp->allocatedData = 0;
- mprFree(vp->ptr);
- }
- break;
-
- case MPR_TYPE_OBJECT:
-#if VAR_DEBUG
- /*
- * Recurse through all properties and release / delete. Release the
- * properties hash table.
- */
- if (vp->properties->refCount > 1) {
- mprLog(7, "freeVar: ACT \"%s\", 0x%x, ref %d, force %d\n",
- vp->name, vp->properties, vp->properties->refCount, force);
- } else {
- mprLog(7, "freeVar: DEL \"%s\", 0x%x, ref %d, force %d\n",
- vp->name, vp->properties, vp->properties->refCount, force);
- }
-#endif
- if (vp->allocatedData) {
- freed = releaseProperties(vp->properties, force);
- }
- vp->properties = 0;
- break;
-
- case MPR_TYPE_FUNCTION:
- if (vp->allocatedData) {
- argList = vp->function.args;
- for (i = 0; i < argList->max; i++) {
- if (argList->handles[i] != 0) {
- mprFree(argList->handles[i]);
- }
- }
- mprDestroyArray(argList);
- vp->function.args = 0;
- mprFree(vp->function.body);
- vp->function.body = 0;
- }
- break;
- }
-
- vp->type = MPR_TYPE_UNDEFINED;
- return freed;
-}
-
-/******************************************************************************/
-/*
- * Adjust the object reference count and return the currrent count of
- * users.
- */
-
-static int adjustVarRefCount(MprVar *vp, int adj)
-{
- mprAssert(vp);
-
- if (vp->type != MPR_TYPE_OBJECT) {
- mprAssert(vp->type == MPR_TYPE_OBJECT);
- return 0;
- }
- return adjustRefCount(vp->properties, adj);
-}
-
-/******************************************************************************/
-/*
- * Get the object reference count
- */
-
-int mprGetVarRefCount(MprVar *vp)
-{
- mprAssert(vp);
-
- if (vp->type != MPR_TYPE_OBJECT) {
- mprAssert(vp->type == MPR_TYPE_OBJECT);
- return 0;
- }
- return adjustRefCount(vp->properties, 0);
-}
-
-/******************************************************************************/
-/*
- * Update the variable's name
- */
-
-void mprSetVarName(MprVar *vp, char *name)
-{
- mprAssert(vp);
-
- mprFree(vp->name);
- vp->name = mprStrdup(name);
-}
-
-/******************************************************************************/
-/*
- * Append to the variable's full name
- */
-
-void mprSetVarFullName(MprVar *vp, char *name)
-{
-#if VAR_DEBUG
- mprAssert(vp);
-
- mprFree(vp->fullName);
- vp->fullName = mprStrdup(name);
- if (vp->type == MPR_TYPE_OBJECT) {
- if (strcmp(vp->properties->name, "this") == 0) {
- mprStrcpy(vp->properties->name, sizeof(vp->properties->name), name);
- }
- }
-#endif
-}
-
-/******************************************************************************/
-/*
- * Make a var impervious to recursive forced deletes.
- */
-
-void mprSetVarDeleteProtect(MprVar *vp, int deleteProtect)
-{
- mprAssert(vp);
-
- if (vp->type == MPR_TYPE_OBJECT && vp->properties) {
- vp->properties->deleteProtect = deleteProtect;
- }
-}
-
-/******************************************************************************/
-/*
- * Make a variable readonly. Can still be deleted.
- */
-
-void mprSetVarReadonly(MprVar *vp, int readonly)
-{
- mprAssert(vp);
-
- vp->readonly = readonly;
-}
-
-/******************************************************************************/
-
-MprVarTrigger mprAddVarTrigger(MprVar *vp, MprVarTrigger fn)
-{
- MprVarTrigger oldTrigger;
-
- mprAssert(vp);
- mprAssert(fn);
-
- oldTrigger = vp->trigger;
- vp->trigger = fn;
- return oldTrigger;
-}
-
-/******************************************************************************/
-
-MprType mprGetVarType(MprVar *vp)
-{
- mprAssert(vp);
-
- return vp->type;
-}
-
-/******************************************************************************/
-/********************************** Properties ********************************/
-/******************************************************************************/
-/*
- * Create a property in an object with a defined value. If the property
- * already exists in the object, then just write its value.
- */
-
-MprVar *mprCreateProperty(MprVar *obj, const char *propertyName,
- MprVar *newValue)
-{
- MprVar *prop, *last;
- int bucketIndex;
-
- mprAssert(obj);
- mprAssert(propertyName && *propertyName);
-
- if (obj->type != MPR_TYPE_OBJECT) {
- mprAssert(obj->type == MPR_TYPE_OBJECT);
- return 0;
- }
-
- /*
- * See if property already exists and locate the bucket to hold the
- * property reference.
- */
- last = 0;
- bucketIndex = hash(obj->properties, propertyName);
- prop = obj->properties->buckets[bucketIndex];
-
- /*
- * Find the property in the hash chain if it exists
- */
- for (last = 0; prop; last = prop, prop = prop->forw) {
- if (prop->name[0] == propertyName[0] &&
- strcmp(prop->name, propertyName) == 0) {
- break;
- }
- }
-
- if (prop) {
- /* FUTURE -- remove. Just for debug. */
- mprAssert(prop == 0);
- mprLog(0, "Attempting to create property %s in object %s\n",
- propertyName, obj->name);
- return 0;
- }
-
- if (obj->trigger) {
- if ((obj->trigger)(MPR_VAR_CREATE_PROPERTY, obj->properties, prop,
- newValue, 0) == MPR_TRIGGER_ABORT) {
- return 0;
- }
- }
-
- /*
- * Create a new property
- */
- prop = allocProperty(propertyName);
- if (prop == 0) {
- mprAssert(prop);
- return 0;
- }
-
- copyVarCore(prop, newValue, MPR_SHALLOW_COPY);
-
- prop->bucketIndex = bucketIndex;
- if (last) {
- last->forw = prop;
- } else {
- obj->properties->buckets[bucketIndex] = prop;
- }
- prop->parentProperties = obj->properties;
-
- /*
- * Update the item counts
- */
- obj->properties->numItems++;
- if (! mprVarIsFunction(prop->type)) {
- obj->properties->numDataItems++;
- }
-
- return prop;
-}
-
-/******************************************************************************/
-/*
- * Create a property in an object with a defined value. If the property
- * already exists in the object, then just write its value. Same as
- * mprCreateProperty except that the new value is passed by value rather than
- * by pointer.
- */
-
-MprVar *mprCreatePropertyValue(MprVar *obj, const char *propertyName,
- MprVar newValue)
-{
- return mprCreateProperty(obj, propertyName, &newValue);
-}
-
-/******************************************************************************/
-/*
- * Create a new property
- */
-
-static MprVar *allocProperty(const char *propertyName)
-{
- MprVar *prop;
-
- prop = (MprVar*) mprMalloc(sizeof(MprVar));
- if (prop == 0) {
- mprAssert(prop);
- return 0;
- }
- memset(prop, 0, sizeof(MprVar));
- prop->allocatedVar = 1;
- prop->name = mprStrdup(propertyName);
- prop->forw = (MprVar*) 0;
-
- return prop;
-}
-
-/******************************************************************************/
-/*
- * Update a property in an object with a defined value. Create the property
- * if it doesn not already exist.
- */
-
-MprVar *mprSetProperty(MprVar *obj, const char *propertyName, MprVar *newValue)
-{
- MprVar *prop, triggerValue;
- int rc;
-
- mprAssert(obj);
- mprAssert(propertyName && *propertyName);
- mprAssert(obj->type == MPR_TYPE_OBJECT);
-
- if (obj->type != MPR_TYPE_OBJECT) {
- mprAssert(0);
- return 0;
- }
-
- prop = mprGetProperty(obj, propertyName, 0);
- if (prop == 0) {
- return mprCreateProperty(obj, propertyName, newValue);
- }
-
- if (obj->trigger) {
- /*
- * Call the trigger before the update and pass it the new value.
- */
- triggerValue = *newValue;
- triggerValue.allocatedVar = 0;
- triggerValue.allocatedData = 0;
- rc = (obj->trigger)(MPR_VAR_WRITE, obj->properties, obj,
- &triggerValue, 0);
- if (rc == MPR_TRIGGER_ABORT) {
- return 0;
-
- } else if (rc == MPR_TRIGGER_USE_NEW_VALUE) {
- /*
- * Trigger must copy to triggerValue a variable that is not
- * a structure copy of the existing data.
- */
- copyVarCore(prop, &triggerValue, MPR_SHALLOW_COPY);
- mprDestroyVar(&triggerValue);
- return prop;
- }
- }
- copyVarCore(prop, newValue, MPR_SHALLOW_COPY);
- return prop;
-}
-
-/******************************************************************************/
-/*
- * Update a property in an object with a defined value. Create the property
- * if it does not already exist. Same as mprSetProperty except that the
- * new value is passed by value rather than by pointer.
- */
-
-MprVar *mprSetPropertyValue(MprVar *obj, const char *propertyName,
- MprVar newValue)
-{
- return mprSetProperty(obj, propertyName, &newValue);
-}
-
-/******************************************************************************/
-/*
- * Delete a property from this object
- */
-
-int mprDeleteProperty(MprVar *obj, const char *property)
-{
- MprVar *prop, *last;
- char *cp;
- int bucketIndex;
-
- mprAssert(obj);
- mprAssert(property && *property);
- mprAssert(obj->type == MPR_TYPE_OBJECT);
-
- if (obj->type != MPR_TYPE_OBJECT) {
- mprAssert(obj->type == MPR_TYPE_OBJECT);
- return 0;
- }
-
- last = 0;
- bucketIndex = hash(obj->properties, property);
- if ((prop = obj->properties->buckets[bucketIndex]) != 0) {
- for ( ; prop; prop = prop->forw) {
- cp = prop->name;
- if (cp[0] == property[0] && strcmp(cp, property) == 0) {
- break;
- }
- last = prop;
- }
- }
- if (prop == (MprVar*) 0) {
- mprAssert(prop);
- return MPR_ERR_NOT_FOUND;
- }
- if (prop->readonly) {
- mprAssert(! prop->readonly);
- return MPR_ERR_READ_ONLY;
- }
-
- if (obj->trigger) {
- if ((obj->trigger)(MPR_VAR_DELETE_PROPERTY, obj->properties, prop, 0, 0)
- == MPR_TRIGGER_ABORT) {
- return MPR_ERR_ABORTED;
- }
- }
-
- if (last) {
- last->forw = prop->forw;
- } else {
- obj->properties->buckets[bucketIndex] = prop->forw;
- }
-
- obj->properties->numItems--;
- if (! mprVarIsFunction(prop->type)) {
- obj->properties->numDataItems--;
- }
-
- mprDestroyVar(prop);
-
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Find a property in an object and return a pointer to it. If a value arg
- * is supplied, then copy the data into the var.
- */
-
-MprVar *mprGetProperty(MprVar *obj, const char *property, MprVar *value)
-{
- MprVar *prop, triggerValue;
- int rc;
-
- if (obj == 0 || obj->type != MPR_TYPE_OBJECT || property == 0 ||
- *property == '\0') {
- if (value) {
- value->type = MPR_TYPE_UNDEFINED;
- }
- return 0;
- }
-
- for (prop = getObjChain(obj->properties, property); prop;
- prop = prop->forw) {
- if (prop->name &&
- prop->name[0] == property[0] && strcmp(prop->name, property) == 0) {
- break;
- }
- }
- if (prop == 0) {
- if (value) {
- value->type = MPR_TYPE_UNDEFINED;
- }
- return 0;
- }
- if (value) {
- if (prop->trigger) {
- triggerValue = *prop;
- triggerValue.allocatedVar = 0;
- triggerValue.allocatedData = 0;
- /*
- * Pass the trigger the current read value and may receive
- * a new value.
- */
- rc = (prop->trigger)(MPR_VAR_READ, prop->parentProperties, prop,
- &triggerValue, 0);
- if (rc == MPR_TRIGGER_ABORT) {
- if (value) {
- value->type = MPR_TYPE_UNDEFINED;
- }
- return 0;
-
- } else if (rc == MPR_TRIGGER_USE_NEW_VALUE) {
- copyVarCore(prop, &triggerValue, MPR_SHALLOW_COPY);
- mprDestroyVar(&triggerValue);
- }
- }
- /*
- * Clone. No copy.
- */
- *value = *prop;
- }
- return prop;
-}
-
-/******************************************************************************/
-/*
- * Read a properties value. This returns the property's value. It does not
- * copy object/string data but returns a pointer directly into the variable.
- * The caller does not and should not call mprDestroy on the returned value.
- * If value is null, just read the property and run triggers.
- */
-
-int mprReadProperty(MprVar *prop, MprVar *value)
-{
- MprVar triggerValue;
- int rc;
-
- mprAssert(prop);
-
- if (prop->trigger) {
- triggerValue = *prop;
- triggerValue.allocatedVar = 0;
- triggerValue.allocatedData = 0;
- rc = (prop->trigger)(MPR_VAR_READ, prop->parentProperties, prop,
- &triggerValue, 0);
-
- if (rc == MPR_TRIGGER_ABORT) {
- return MPR_ERR_ABORTED;
-
- } else if (rc == MPR_TRIGGER_USE_NEW_VALUE) {
- copyVarCore(prop, &triggerValue, MPR_SHALLOW_COPY);
- mprDestroyVar(&triggerValue);
- return 0;
- }
- }
- if (value) {
- *value = *prop;
-
- /*
- * Just so that if the user calls mprDestroyVar on value, it will do no
- * harm.
- */
- value->allocatedVar = 0;
- value->allocatedData = 0;
- }
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Read a properties value. This returns a copy of the property variable.
- * However, if the property is an object or string, it returns a copy of the
- * reference to the underlying data. If copyDepth is set to MPR_DEEP_COPY,
- * then the underlying objects and strings data will be copied as well. If
- * copyDepth is set to MPR_SHALLOW_COPY, then only strings will be copied. If
- * it is set to MPR_NO_COPY, then no data will be copied. In all cases, the
- * user must call mprDestroyVar to free resources. This routine will run any
- * registered triggers which may modify the value the user receives (without
- * updating the properties real value).
- *
- * WARNING: the args are reversed to most other APIs. This conforms to the
- * strcpy(dest, src) standard instead.
- */
-
-int mprCopyProperty(MprVar *dest, MprVar *prop, int copyDepth)
-{
- MprVar triggerValue;
- int rc;
-
- mprAssert(prop);
- mprAssert(dest);
-
- if (prop->trigger) {
- triggerValue = *prop;
- triggerValue.allocatedVar = 0;
- triggerValue.allocatedData = 0;
- rc = (prop->trigger)(MPR_VAR_READ, prop->parentProperties, prop,
- &triggerValue, copyDepth);
-
- if (rc == MPR_TRIGGER_ABORT) {
- return MPR_ERR_ABORTED;
-
- } else if (rc == MPR_TRIGGER_USE_NEW_VALUE) {
- copyVarCore(dest, &triggerValue, MPR_SHALLOW_COPY);
- mprDestroyVar(&triggerValue);
- return 0;
- }
- }
- mprCopyVar(dest, prop, copyDepth);
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Write a new value into an existing property in an object.
- */
-
-int mprWriteProperty(MprVar *vp, MprVar *value)
-{
- MprVar triggerValue;
- int rc;
-
- mprAssert(vp);
- mprAssert(value);
-
- if (vp->readonly) {
- return MPR_ERR_READ_ONLY;
- }
-
- if (vp->trigger) {
- triggerValue = *value;
-
- rc = (vp->trigger)(MPR_VAR_WRITE, vp->parentProperties, vp,
- &triggerValue, 0);
-
- if (rc == MPR_TRIGGER_ABORT) {
- return MPR_ERR_ABORTED;
-
- } else if (rc == MPR_TRIGGER_USE_NEW_VALUE) {
- copyVarCore(vp, &triggerValue, MPR_SHALLOW_COPY);
- mprDestroyVar(&triggerValue);
- return 0;
- }
- /* Fall through */
- }
-
- copyVarCore(vp, value, MPR_SHALLOW_COPY);
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Write a new value into an existing property in an object.
- */
-
-int mprWritePropertyValue(MprVar *vp, MprVar value)
-{
- mprAssert(vp);
-
- return mprWriteProperty(vp, &value);
-}
-
-/******************************************************************************/
-/*
- * Get the count of properties.
- */
-
-int mprGetPropertyCount(MprVar *vp, int includeFlags)
-{
- mprAssert(vp);
-
- if (vp->type != MPR_TYPE_OBJECT) {
- return 0;
- }
- if (includeFlags == MPR_ENUM_DATA) {
- return vp->properties->numDataItems;
- } else {
- return vp->properties->numItems;
- }
-}
-
-/******************************************************************************/
-/*
- * Get the first property in an object. Used for walking all properties in an
- * object.
- */
-
-MprVar *mprGetFirstProperty(MprVar *obj, int includeFlags)
-{
- MprVar *prop;
- int i;
-
- mprAssert(obj);
- mprAssert(obj->type == MPR_TYPE_OBJECT);
-
- if (obj->type != MPR_TYPE_OBJECT) {
- mprAssert(obj->type == MPR_TYPE_OBJECT);
- return 0;
- }
-
- for (i = 0; i < (int) obj->properties->hashSize; i++) {
- for (prop = obj->properties->buckets[i]; prop; prop = prop->forw) {
- if (prop) {
- if (mprVarIsFunction(prop->type)) {
- if (!(includeFlags & MPR_ENUM_FUNCTIONS)) {
- continue;
- }
- } else {
- if (!(includeFlags & MPR_ENUM_DATA)) {
- continue;
- }
- }
- return prop;
- }
- break;
- }
- }
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Get the next property in sequence.
- */
-
-MprVar *mprGetNextProperty(MprVar *obj, MprVar *last, int includeFlags)
-{
- MprProperties *properties;
- int i;
-
- mprAssert(obj);
- mprAssert(obj->type == MPR_TYPE_OBJECT);
-
- if (obj->type != MPR_TYPE_OBJECT) {
- mprAssert(obj->type == MPR_TYPE_OBJECT);
- return 0;
- }
- properties = obj->properties;
-
- if (last->forw) {
- return last->forw;
- }
-
- for (i = last->bucketIndex + 1; i < (int) properties->hashSize; i++) {
- for (last = properties->buckets[i]; last; last = last->forw) {
- if (mprVarIsFunction(last->type)) {
- if (!(includeFlags & MPR_ENUM_FUNCTIONS)) {
- continue;
- }
- } else {
- if (!(includeFlags & MPR_ENUM_DATA)) {
- continue;
- }
- }
- return last;
- }
- }
- return 0;
-}
-
-/******************************************************************************/
-/************************** Internal Support Routines *************************/
-/******************************************************************************/
-/*
- * Create an hash table to hold and index properties. Properties are just
- * variables which may contain primitive data types, functions or other
- * objects. The hash table is the essence of an object. HashSize specifies
- * the size of the hash table to use and should be a prime number.
- */
-
-static MprProperties *createProperties(const char *name, int hashSize)
-{
- MprProperties *pp;
-
- if (hashSize < 7) {
- hashSize = 7;
- }
- if ((pp = (MprProperties*) mprMalloc(sizeof(MprProperties))) == NULL) {
- mprAssert(0);
- return 0;
- }
- mprAssert(pp);
- memset(pp, 0, sizeof(MprProperties));
-
- pp->numItems = 0;
- pp->numDataItems = 0;
- pp->hashSize = hashSize;
- pp->buckets = (MprVar**) mprMalloc(pp->hashSize * sizeof(MprVar*));
- mprAssert(pp->buckets);
- memset(pp->buckets, 0, pp->hashSize * sizeof(MprVar*));
- pp->refCount = 1;
-
-#if VAR_DEBUG
- if (objectCount == -1) {
- objectCount = 0;
- objectList.next = objectList.prev = &objectList;
- }
-
- mprStrcpy(pp->name, sizeof(pp->name), name);
- pp->next = &objectList;
- pp->prev = objectList.prev;
- objectList.prev->next = pp;
- objectList.prev = pp;
- objectCount++;
-#endif
- return pp;
-}
-
-/******************************************************************************/
-/*
- * Release an object's properties hash table. If this is the last person
- * using it, free it. Return TRUE if the object is released.
- */
-
-static bool releaseProperties(MprProperties *obj, int force)
-{
- MprProperties *pp;
- MprVar *prop, *forw;
- int i;
-
- mprAssert(obj);
- mprAssert(obj->refCount > 0);
-
-#if VAR_DEBUG
- /*
- * Debug sanity check
- */
- mprAssert(obj->refCount < 20);
-#endif
-
- if (--obj->refCount > 0 && !force) {
- return 0;
- }
-
-#if VAR_DEBUG
- mprAssert(obj->prev);
- mprAssert(obj->next);
- mprAssert(obj->next->prev);
- mprAssert(obj->prev->next);
- obj->next->prev = obj->prev;
- obj->prev->next = obj->next;
- objectCount--;
-#endif
-
- for (i = 0; i < (int) obj->hashSize; i++) {
- for (prop = obj->buckets[i]; prop; prop = forw) {
- forw = prop->forw;
- if (prop->type == MPR_TYPE_OBJECT) {
-
- if (prop->properties == obj) {
- /* Self reference */
- continue;
- }
- pp = prop->properties;
- if (pp->visited) {
- continue;
- }
-
- pp->visited = 1;
- if (! freeVar(prop, pp->deleteProtect ? 0 : force)) {
- pp->visited = 0;
- }
-
- } else {
- freeVar(prop, force);
- }
- }
- }
-
- mprFree((void*) obj->buckets);
- mprFree((void*) obj);
-
- return 1;
-}
-
-/******************************************************************************/
-/*
- * Adjust the reference count
- */
-
-static int adjustRefCount(MprProperties *pp, int adj)
-{
- mprAssert(pp);
-
- /*
- * Debug sanity check
- */
- mprAssert(pp->refCount < 20);
-
- return pp->refCount += adj;
-}
-
-/******************************************************************************/
-#if VAR_DEBUG
-/*
- * Print objects held
- */
-
-void mprPrintObjects(char *msg)
-{
- MprProperties *pp, *np;
- MprVar *prop, *forw;
- char *buf;
- int i;
-
- mprLog(7, "%s: Object Store. %d objects.\n", msg, objectCount);
- pp = objectList.next;
- while (pp != &objectList) {
- mprLog(7, "%s: 0x%x, refCount %d, properties %d\n",
- pp->name, pp, pp->refCount, pp->numItems);
- for (i = 0; i < (int) pp->hashSize; i++) {
- for (prop = pp->buckets[i]; prop; prop = forw) {
- forw = prop->forw;
- if (prop->properties == pp) {
- /* Self reference */
- continue;
- }
- mprVarToString(&buf, MPR_MAX_STRING, 0, prop);
- if (prop->type == MPR_TYPE_OBJECT) {
- np = objectList.next;
- while (np != &objectList) {
- if (prop->properties == np) {
- break;
- }
- np = np->next;
- }
- if (prop->properties == np) {
- mprLog(7, " %s: OBJECT 0x%x, <%s>\n",
- prop->name, prop->properties, prop->fullName);
- } else {
- mprLog(7, " %s: OBJECT NOT FOUND, %s <%s>\n",
- prop->name, buf, prop->fullName);
- }
- } else {
- mprLog(7, " %s: <%s> = %s\n", prop->name,
- prop->fullName, buf);
- }
- mprFree(buf);
- }
- }
- pp = pp->next;
- }
-}
-
-/******************************************************************************/
-
-void mprPrintObjRefCount(MprVar *vp)
-{
- mprLog(7, "OBJECT 0x%x, refCount %d\n", vp->properties,
- vp->properties->refCount);
-}
-
-#endif
-/******************************************************************************/
-/*
- * Get the bucket chain containing a property.
- */
-
-static MprVar *getObjChain(MprProperties *obj, const char *property)
-{
- mprAssert(obj);
-
- return obj->buckets[hash(obj, property)];
-}
-
-/******************************************************************************/
-/*
- * Fast hash. The history of this algorithm is part of lost computer science
- * folk lore.
- */
-
-static int hash(MprProperties *pp, const char *property)
-{
- uint sum;
-
- mprAssert(pp);
- mprAssert(property);
-
- sum = 0;
- while (*property) {
- sum += (sum * 33) + *property++;
- }
-
- return sum % pp->hashSize;
-}
-
-/******************************************************************************/
-/*********************************** Constructors *****************************/
-/******************************************************************************/
-/*
- * Initialize an undefined value.
- */
-
-MprVar mprCreateUndefinedVar()
-{
- MprVar v;
-
- memset(&v, 0x0, sizeof(v));
- v.type = MPR_TYPE_UNDEFINED;
- return v;
-}
-
-/******************************************************************************/
-/*
- * Initialize an null value.
- */
-
-MprVar mprCreateNullVar()
-{
- MprVar v;
-
- memset(&v, 0x0, sizeof(v));
- v.type = MPR_TYPE_NULL;
- return v;
-}
-
-/******************************************************************************/
-
-MprVar mprCreateBoolVar(bool value)
-{
- MprVar v;
-
- memset(&v, 0x0, sizeof(v));
- v.type = MPR_TYPE_BOOL;
- v.boolean = value;
- return v;
-}
-
-/******************************************************************************/
-/*
- * Initialize a C function.
- */
-
-MprVar mprCreateCFunctionVar(MprCFunction fn, void *thisPtr, int flags)
-{
- MprVar v;
-
- memset(&v, 0x0, sizeof(v));
- v.type = MPR_TYPE_CFUNCTION;
- v.cFunction.fn = fn;
- v.cFunction.thisPtr = thisPtr;
- v.flags = flags;
-
- return v;
-}
-
-/******************************************************************************/
-/*
- * Initialize a C function.
- */
-
-MprVar mprCreateStringCFunctionVar(MprStringCFunction fn, void *thisPtr,
- int flags)
-{
- MprVar v;
-
- memset(&v, 0x0, sizeof(v));
- v.type = MPR_TYPE_STRING_CFUNCTION;
- v.cFunctionWithStrings.fn = fn;
- v.cFunctionWithStrings.thisPtr = thisPtr;
- v.flags = flags;
-
- return v;
-}
-
-/******************************************************************************/
-/*
- * Initialize an opaque pointer.
- */
-
-MprVar mprCreatePtrVar(void *ptr)
-{
- MprVar v;
-
- memset(&v, 0x0, sizeof(v));
- v.type = MPR_TYPE_PTR;
- v.ptr = ptr;
-
- return v;
-}
-
-/******************************************************************************/
-#if BLD_FEATURE_FLOATING_POINT
-/*
- * Initialize a floating value.
- */
-
-MprVar mprCreateFloatVar(double value)
-{
- MprVar v;
-
- memset(&v, 0x0, sizeof(v));
- v.type = MPR_TYPE_FLOAT;
- v.floating = value;
- return v;
-}
-
-#endif
-/******************************************************************************/
-/*
- * Initialize an integer value.
- */
-
-MprVar mprCreateIntegerVar(int value)
-{
- MprVar v;
-
- memset(&v, 0x0, sizeof(v));
- v.type = MPR_TYPE_INT;
- v.integer = value;
- return v;
-}
-
-/******************************************************************************/
-#if BLD_FEATURE_INT64
-/*
- * Initialize a 64-bit integer value.
- */
-
-MprVar mprCreateInteger64Var(int64 value)
-{
- MprVar v;
-
- memset(&v, 0x0, sizeof(v));
- v.type = MPR_TYPE_INT64;
- v.integer64 = value;
- return v;
-}
-
-#endif /* BLD_FEATURE_INT64 */
-/******************************************************************************/
-/*
- * Initialize an number variable. Type is defined by configure.
- */
-
-MprVar mprCreateNumberVar(MprNum value)
-{
- MprVar v;
-
- memset(&v, 0x0, sizeof(v));
- v.type = BLD_FEATURE_NUM_TYPE_ID;
-#if BLD_FEATURE_NUM_TYPE_ID == MPR_TYPE_INT64
- v.integer64 = value;
-#elif BLD_FEATURE_NUM_TYPE_ID == MPR_TYPE_FLOAT
- v.float = value;
-#else
- v.integer = value;
-#endif
- return v;
-}
-
-/******************************************************************************/
-/*
- * Initialize a (bare) JavaScript function. args and body can be null.
- */
-
-MprVar mprCreateFunctionVar(char *args, char *body, int flags)
-{
- MprVar v;
- char *cp, *arg, *last;
- int aid;
-
- memset(&v, 0x0, sizeof(v));
- v.type = MPR_TYPE_FUNCTION;
- v.flags = flags;
-
- v.function.args = mprCreateArray();
-
- if (args) {
- args = mprStrdup(args);
- arg = mprStrTok(args, ",", &last);
- while (arg) {
- while (isspace((int) *arg))
- arg++;
- for (cp = &arg[strlen(arg) - 1]; cp > arg; cp--) {
- if (!isspace((int) *cp)) {
- break;
- }
- }
- cp[1] = '\0';
-
- aid = mprAddToArray(v.function.args, mprStrdup(arg));
- arg = mprStrTok(0, ",", &last);
- }
- mprFree(args);
- }
-
- if (body) {
- v.function.body = mprStrdup(body);
- }
- v.allocatedData = 1;
- return v;
-}
-
-/******************************************************************************/
-/*
- * Initialize an object variable. Return type == MPR_TYPE_UNDEFINED if the
- * memory allocation for the properties table failed.
- */
-
-MprVar mprCreateObjVar(const char *name, int hashSize)
-{
- MprVar v;
-
- mprAssert(name && *name);
-
- memset(&v, 0x0, sizeof(MprVar));
- v.type = MPR_TYPE_OBJECT;
- if (hashSize <= 0) {
- hashSize = MPR_DEFAULT_HASH_SIZE;
- }
- v.properties = createProperties(name, hashSize);
- if (v.properties == 0) {
- /* Indicate failed memory allocation */
- v.type = MPR_TYPE_UNDEFINED;
- }
- v.allocatedData = 1;
- v.name = mprStrdup(name);
- mprLog(7, "mprCreateObjVar %s, 0x%p\n", name, v.properties);
- return v;
-}
-
-/******************************************************************************/
-/*
- * Initialize a string value.
- */
-
-MprVar mprCreateStringVar(const char *value, bool allocate)
-{
- MprVar v;
-
- memset(&v, 0x0, sizeof(v));
- v.type = MPR_TYPE_STRING;
- if (value == 0) {
- v.string = (char*) "";
- } else if (allocate) {
- v.string = mprStrdup(value);
- v.allocatedData = 1;
- } else {
- v.string = (char*) value;
- }
- return v;
-}
-
-/******************************************************************************/
-/*
- * Copy an objects core value (only). This preserves the destination object's
- * name. This implements copy by reference for objects and copy by value for
- * strings and other types. Caller must free dest prior to calling.
- */
-
-static void copyVarCore(MprVar *dest, MprVar *src, int copyDepth)
-{
- MprVarTrigger saveTrigger;
- MprVar *srcProp, *destProp, *last;
- char **srcArgs;
- int i;
-
- mprAssert(dest);
- mprAssert(src);
-
- if (dest == src) {
- return;
- }
-
- /*
- * FUTURE: we should allow read-only triggers where the value is never
- * stored in the object. Currently, triggers override the readonly
- * status.
- */
-
- if (dest->type != MPR_TYPE_UNDEFINED && dest->readonly && !dest->trigger) {
- mprAssert(0);
- return;
- }
-
- if (dest->type != MPR_TYPE_UNDEFINED) {
- saveTrigger = dest->trigger;
- freeVarStorage(dest, 0);
- } else {
- saveTrigger = 0;
- }
-
- switch (src->type) {
- default:
- case MPR_TYPE_UNDEFINED:
- case MPR_TYPE_NULL:
- break;
-
- case MPR_TYPE_BOOL:
- dest->boolean = src->boolean;
- break;
-
- case MPR_TYPE_PTR:
- /* we have to reference here so talloc structures survive a
- copy */
- if (src->allocatedData) {
- dest->ptr = talloc_reference(mprMemCtx(), src->ptr);
- dest->allocatedData = 1;
- } else {
- dest->ptr = src->ptr;
- }
- break;
-
- case MPR_TYPE_STRING_CFUNCTION:
- dest->cFunctionWithStrings = src->cFunctionWithStrings;
- break;
-
- case MPR_TYPE_CFUNCTION:
- dest->cFunction = src->cFunction;
- break;
-
-#if BLD_FEATURE_FLOATING_POINT
- case MPR_TYPE_FLOAT:
- dest->floating = src->floating;
- break;
-#endif
-
- case MPR_TYPE_INT:
- dest->integer = src->integer;
- break;
-
-#if BLD_FEATURE_INT64
- case MPR_TYPE_INT64:
- dest->integer64 = src->integer64;
- break;
-#endif
-
- case MPR_TYPE_OBJECT:
- if (copyDepth == MPR_DEEP_COPY) {
-
- dest->properties = createProperties(src->name,
- src->properties->hashSize);
- dest->allocatedData = 1;
-
- for (i = 0; i < (int) src->properties->hashSize; i++) {
- last = 0;
- for (srcProp = src->properties->buckets[i]; srcProp;
- srcProp = srcProp->forw) {
- if (srcProp->visited) {
- continue;
- }
- destProp = allocProperty(srcProp->name);
- if (destProp == 0) {
- mprAssert(destProp);
- return;
- }
-
- destProp->bucketIndex = i;
- if (last) {
- last->forw = destProp;
- } else {
- dest->properties->buckets[i] = destProp;
- }
- destProp->parentProperties = dest->properties;
-
- /*
- * Recursively copy the object
- */
- srcProp->visited = 1;
- copyVarCore(destProp, srcProp, copyDepth);
- srcProp->visited = 0;
- last = destProp;
- }
- }
- dest->properties->numItems = src->properties->numItems;
- dest->properties->numDataItems = src->properties->numDataItems;
- dest->allocatedData = 1;
-
- } else if (copyDepth == MPR_SHALLOW_COPY) {
- dest->properties = src->properties;
- adjustVarRefCount(src, 1);
- dest->allocatedData = 1;
-
- } else {
- dest->properties = src->properties;
- dest->allocatedData = 0;
- }
- break;
-
- case MPR_TYPE_FUNCTION:
- if (copyDepth != MPR_NO_COPY) {
- dest->function.args = mprCreateArray();
- srcArgs = (char**) src->function.args->handles;
- for (i = 0; i < src->function.args->max; i++) {
- if (srcArgs[i]) {
- mprAddToArray(dest->function.args, mprStrdup(srcArgs[i]));
- }
- }
- dest->function.body = mprStrdup(src->function.body);
- dest->allocatedData = 1;
- } else {
- dest->function.args = src->function.args;
- dest->function.body = src->function.body;
- dest->allocatedData = 0;
- }
- break;
-
- case MPR_TYPE_STRING:
- if (src->string && copyDepth != MPR_NO_COPY) {
- dest->string = mprStrdup(src->string);
- dest->allocatedData = 1;
- } else {
- dest->string = src->string;
- dest->allocatedData = 0;
- }
- break;
- }
-
- dest->type = src->type;
- dest->flags = src->flags;
- dest->trigger = saveTrigger;
-
- /*
- * Just for safety
- */
- dest->spare = 0;
-}
-
-/******************************************************************************/
-/*
- * Copy an entire object including name.
- */
-
-void mprCopyVar(MprVar *dest, MprVar *src, int copyDepth)
-{
- mprAssert(dest);
- mprAssert(src);
-
- copyVarCore(dest, src, copyDepth);
-
- mprFree(dest->name);
- dest->name = mprStrdup(src->name);
-
-#if VAR_DEBUG
- if (src->type == MPR_TYPE_OBJECT) {
-
- mprFree(dest->fullName);
- dest->fullName = mprStrdup(src->fullName);
-
- mprLog(7, "mprCopyVar: object \"%s\", FDQ \"%s\" 0x%x, refCount %d\n",
- dest->name, dest->fullName, dest->properties,
- dest->properties->refCount);
- }
-#endif
-}
-
-/******************************************************************************/
-/*
- * Copy an entire object including name.
- */
-
-void mprCopyVarValue(MprVar *dest, MprVar src, int copyDepth)
-{
- mprAssert(dest);
-
- mprCopyVar(dest, &src, copyDepth);
-}
-
-/******************************************************************************/
-/*
- * Copy an object. This implements copy by reference for objects and copy by
- * value for strings and other types. Caller must free dest prior to calling.
- */
-
-MprVar *mprDupVar(MprVar *src, int copyDepth)
-{
- MprVar *dest;
-
- mprAssert(src);
-
- dest = (MprVar*) mprMalloc(sizeof(MprVar));
- memset(dest, 0, sizeof(MprVar));
-
- mprCopyVar(dest, src, copyDepth);
- return dest;
-}
-
-/******************************************************************************/
-/*
- * Convert a value to a text based representation of its value
- * FUTURE -- conver this to use the format string in all cases. Allow
- * arbitrary format strings.
- */
-
-void mprVarToString(char** out, int size, char *fmt, MprVar *obj)
-{
- char *src;
-
- mprAssert(out);
-
- *out = NULL;
-
- if (obj->trigger) {
- mprReadProperty(obj, 0);
- }
-
- switch (obj->type) {
- case MPR_TYPE_UNDEFINED:
- /* FUTURE -- spec says convert to "undefined" */
- *out = mprStrdup("");
- break;
-
- case MPR_TYPE_NULL:
- *out = mprStrdup("null");
- break;
-
- case MPR_TYPE_PTR:
- mprAllocSprintf(out, size, "[Opaque Pointer %p]", obj->ptr);
- break;
-
- case MPR_TYPE_BOOL:
- if (obj->boolean) {
- *out = mprStrdup("true");
- } else {
- *out = mprStrdup("false");
- }
- break;
-
-#if BLD_FEATURE_FLOATING_POINT
- case MPR_TYPE_FLOAT:
- if (fmt == NULL || *fmt == '\0') {
- mprAllocSprintf(out, size, "%f", obj->floating);
- } else {
- mprAllocSprintf(out, size, fmt, obj->floating);
- }
- break;
-#endif
-
- case MPR_TYPE_INT:
- if (fmt == NULL || *fmt == '\0') {
- mprAllocSprintf(out, size, "%d", obj->integer);
- } else {
- mprAllocSprintf(out, size, fmt, obj->integer);
- }
- break;
-
-#if BLD_FEATURE_INT64
- case MPR_TYPE_INT64:
- if (fmt == NULL || *fmt == '\0') {
-#if BLD_GOAHEAD_WEBSERVER
- mprAllocSprintf(out, size, "%d", (int) obj->integer64);
-#else
- mprAllocSprintf(out, size, "%lld", (long long)obj->integer64);
-#endif
- } else {
- mprAllocSprintf(out, size, fmt, obj->integer64);
- }
- break;
-#endif
-
- case MPR_TYPE_CFUNCTION:
- mprAllocSprintf(out, size, "[C Function]");
- break;
-
- case MPR_TYPE_STRING_CFUNCTION:
- mprAllocSprintf(out, size, "[C StringFunction]");
- break;
-
- case MPR_TYPE_FUNCTION:
- mprAllocSprintf(out, size, "[JavaScript Function]");
- break;
-
- case MPR_TYPE_OBJECT:
- /* FUTURE -- really want: [object class: name] */
- mprAllocSprintf(out, size, "[object %s]", obj->name);
- break;
-
- case MPR_TYPE_STRING:
- src = obj->string;
-
- mprAssert(src);
- if (fmt && *fmt) {
- mprAllocSprintf(out, size, fmt, src);
-
- } else if (src == NULL) {
- *out = mprStrdup("null");
-
- } else {
- *out = mprStrdup(src);
- }
- break;
-
- default:
- mprAssert(0);
- }
-}
-
-/******************************************************************************/
-/*
- * Parse a string based on formatting instructions and intelligently
- * create a variable.
- */
-
-MprVar mprParseVar(char *buf, MprType preferredType)
-{
- MprType type;
- char *cp;
-
- mprAssert(buf);
-
- type = preferredType;
-
- if (preferredType == MPR_TYPE_UNDEFINED) {
- if (*buf == '-') {
- type = MPR_NUM_VAR;
-
- } else if (!isdigit((int) *buf)) {
- if (strcmp(buf, "true") == 0 || strcmp(buf, "false") == 0) {
- type = MPR_TYPE_BOOL;
- } else {
- type = MPR_TYPE_STRING;
- }
-
- } else if (isdigit((int) *buf)) {
- type = MPR_NUM_VAR;
- cp = buf;
- if (*cp && tolower(cp[1]) == 'x') {
- cp = &cp[2];
- }
- for (cp = buf; *cp; cp++) {
- if (! isdigit((int) *cp)) {
- break;
- }
- }
-
- if (*cp != '\0') {
-#if BLD_FEATURE_FLOATING_POINT
- if (*cp == '.' || tolower(*cp) == 'e') {
- type = MPR_TYPE_FLOAT;
- } else
-#endif
- {
- type = MPR_NUM_VAR;
- }
- }
- }
- }
-
- switch (type) {
- case MPR_TYPE_OBJECT:
- case MPR_TYPE_UNDEFINED:
- case MPR_TYPE_NULL:
- case MPR_TYPE_PTR:
- default:
- break;
-
- case MPR_TYPE_BOOL:
- return mprCreateBoolVar(buf[0] == 't' ? 1 : 0);
-
- case MPR_TYPE_INT:
- return mprCreateIntegerVar(mprParseInteger(buf));
-
-#if BLD_FEATURE_INT64
- case MPR_TYPE_INT64:
- return mprCreateInteger64Var(mprParseInteger64(buf));
-#endif
-
- case MPR_TYPE_STRING:
- if (strcmp(buf, "null") == 0) {
- return mprCreateNullVar();
- } else if (strcmp(buf, "undefined") == 0) {
- return mprCreateUndefinedVar();
- }
-
- return mprCreateStringVar(buf, 1);
-
-#if BLD_FEATURE_FLOATING_POINT
- case MPR_TYPE_FLOAT:
- return mprCreateFloatVar(atof(buf));
-#endif
-
- }
- return mprCreateUndefinedVar();
-}
-
-/******************************************************************************/
-/*
- * Convert the variable to a boolean. Only for primitive types.
- */
-
-bool mprVarToBool(const MprVar *vp)
-{
- mprAssert(vp);
-
- switch (vp->type) {
- case MPR_TYPE_UNDEFINED:
- case MPR_TYPE_NULL:
- case MPR_TYPE_STRING_CFUNCTION:
- case MPR_TYPE_CFUNCTION:
- case MPR_TYPE_FUNCTION:
- case MPR_TYPE_OBJECT:
- return 0;
-
- case MPR_TYPE_PTR:
- return (vp->ptr != NULL);
-
- case MPR_TYPE_BOOL:
- return vp->boolean;
-
-#if BLD_FEATURE_FLOATING_POINT
- case MPR_TYPE_FLOAT:
- return (vp->floating != 0 && !mprIsNan(vp->floating));
-#endif
-
- case MPR_TYPE_INT:
- return (vp->integer != 0);
-
-#if BLD_FEATURE_INT64
- case MPR_TYPE_INT64:
- return (vp->integer64 != 0);
-#endif
-
- case MPR_TYPE_STRING:
- mprAssert(vp->string);
- return (vp->string[0] != '\0');
- }
-
- /* Not reached */
- return 0;
-}
-
-/******************************************************************************/
-#if BLD_FEATURE_FLOATING_POINT
-/*
- * Convert the variable to a floating point number. Only for primitive types.
- */
-
-double mprVarToFloat(const MprVar *vp)
-{
- mprAssert(vp);
-
- switch (vp->type) {
- case MPR_TYPE_UNDEFINED:
- case MPR_TYPE_NULL:
- case MPR_TYPE_STRING_CFUNCTION:
- case MPR_TYPE_CFUNCTION:
- case MPR_TYPE_FUNCTION:
- case MPR_TYPE_OBJECT:
- case MPR_TYPE_PTR:
- return 0;
-
- case MPR_TYPE_BOOL:
- return (vp->boolean) ? 1.0 : 0.0;
-
- case MPR_TYPE_FLOAT:
- return vp->floating;
-
- case MPR_TYPE_INT:
- return (double) vp->integer;
-
-#if BLD_FEATURE_INT64
- case MPR_TYPE_INT64:
- return (double) vp->integer64;
-#endif
-
- case MPR_TYPE_STRING:
- mprAssert(vp->string);
- return atof(vp->string);
- }
-
- /* Not reached */
- return 0;
-}
-
-#endif
-/******************************************************************************/
-/*
- * Convert the variable to a number type. Only works for primitive types.
- */
-
-MprNum mprVarToNumber(const MprVar *vp)
-{
-#if BLD_FEATURE_NUM_TYPE_ID == MPR_TYPE_INT64
- return mprVarToInteger64(vp);
-#elif BLD_FEATURE_NUM_TYPE_ID == MPR_TYPE_FLOAT
- return mprVarToFloat(vp);
-#else
- return mprVarToInteger(vp);
-#endif
-}
-
-/******************************************************************************/
-/*
- * Convert the variable to a number type. Only works for primitive types.
- */
-
-MprNum mprParseNumber(char *s)
-{
-#if BLD_FEATURE_NUM_TYPE_ID == MPR_TYPE_INT64
- return mprParseInteger64(s);
-#elif BLD_FEATURE_NUM_TYPE_ID == MPR_TYPE_FLOAT
- return mprParseFloat(s);
-#else
- return mprParseInteger(s);
-#endif
-}
-
-/******************************************************************************/
-#if BLD_FEATURE_INT64
-/*
- * Convert the variable to an Integer64 type. Only works for primitive types.
- */
-
-int64 mprVarToInteger64(const MprVar *vp)
-{
- mprAssert(vp);
-
- switch (vp->type) {
- case MPR_TYPE_UNDEFINED:
- case MPR_TYPE_NULL:
- case MPR_TYPE_STRING_CFUNCTION:
- case MPR_TYPE_CFUNCTION:
- case MPR_TYPE_FUNCTION:
- case MPR_TYPE_OBJECT:
- case MPR_TYPE_PTR:
- return 0;
-
- case MPR_TYPE_BOOL:
- return (vp->boolean) ? 1 : 0;
-
-#if BLD_FEATURE_FLOATING_POINT
- case MPR_TYPE_FLOAT:
- if (mprIsNan(vp->floating)) {
- return 0;
- }
- return (int64) vp->floating;
-#endif
-
- case MPR_TYPE_INT:
- return vp->integer;
-
- case MPR_TYPE_INT64:
- return vp->integer64;
-
- case MPR_TYPE_STRING:
- return mprParseInteger64(vp->string);
- }
-
- /* Not reached */
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Convert the string buffer to an Integer64.
- */
-
-int64 mprParseInteger64(char *str)
-{
- char *cp;
- int64 num64;
- int radix, c, negative;
-
- mprAssert(str);
-
- cp = str;
- num64 = 0;
- negative = 0;
-
- if (*cp == '-') {
- cp++;
- negative = 1;
- }
-
- /*
- * Parse a number. Observe hex and octal prefixes (0x, 0)
- */
- if (*cp != '0') {
- /*
- * Normal numbers (Radix 10)
- */
- while (isdigit((int) *cp)) {
- num64 = (*cp - '0') + (num64 * 10);
- cp++;
- }
- } else {
- cp++;
- if (tolower(*cp) == 'x') {
- cp++;
- radix = 16;
- while (*cp) {
- c = tolower(*cp);
- if (isdigit(c)) {
- num64 = (c - '0') + (num64 * radix);
- } else if (c >= 'a' && c <= 'f') {
- num64 = (c - ('a' - 10)) + (num64 * radix);
- } else {
- break;
- }
- cp++;
- }
-
- } else{
- radix = 8;
- while (*cp) {
- c = tolower(*cp);
- if (isdigit(c) && c < '8') {
- num64 = (c - '0') + (num64 * radix);
- } else {
- break;
- }
- cp++;
- }
- }
- }
-
- if (negative) {
- return 0 - num64;
- }
- return num64;
-}
-
-#endif /* BLD_FEATURE_INT64 */
-/******************************************************************************/
-/*
- * Convert the variable to an Integer type. Only works for primitive types.
- */
-
-int mprVarToInteger(const MprVar *vp)
-{
- mprAssert(vp);
-
- switch (vp->type) {
- case MPR_TYPE_UNDEFINED:
- case MPR_TYPE_NULL:
- case MPR_TYPE_STRING_CFUNCTION:
- case MPR_TYPE_CFUNCTION:
- case MPR_TYPE_FUNCTION:
- case MPR_TYPE_OBJECT:
- case MPR_TYPE_PTR:
- return 0;
-
- case MPR_TYPE_BOOL:
- return (vp->boolean) ? 1 : 0;
-
-#if BLD_FEATURE_FLOATING_POINT
- case MPR_TYPE_FLOAT:
- if (mprIsNan(vp->floating)) {
- return 0;
- }
- return (int) vp->floating;
-#endif
-
- case MPR_TYPE_INT:
- return vp->integer;
-
-#if BLD_FEATURE_INT64
- case MPR_TYPE_INT64:
- return (int) vp->integer64;
-#endif
-
- case MPR_TYPE_STRING:
- return mprParseInteger(vp->string);
- }
-
- /* Not reached */
- return 0;
-}
-
-/******************************************************************************/
-/*
- * Convert the string buffer to an Integer.
- */
-
-int mprParseInteger(char *str)
-{
- char *cp;
- int num;
- int radix, c, negative;
-
- mprAssert(str);
-
- cp = str;
- num = 0;
- negative = 0;
-
- if (*cp == '-') {
- cp++;
- negative = 1;
- }
-
- /*
- * Parse a number. Observe hex and octal prefixes (0x, 0)
- */
- if (*cp != '0') {
- /*
- * Normal numbers (Radix 10)
- */
- while (isdigit((int) *cp)) {
- num = (*cp - '0') + (num * 10);
- cp++;
- }
- } else {
- cp++;
- if (tolower(*cp) == 'x') {
- cp++;
- radix = 16;
- while (*cp) {
- c = tolower(*cp);
- if (isdigit(c)) {
- num = (c - '0') + (num * radix);
- } else if (c >= 'a' && c <= 'f') {
- num = (c - ('a' - 10)) + (num * radix);
- } else {
- break;
- }
- cp++;
- }
-
- } else{
- radix = 8;
- while (*cp) {
- c = tolower(*cp);
- if (isdigit(c) && c < '8') {
- num = (c - '0') + (num * radix);
- } else {
- break;
- }
- cp++;
- }
- }
- }
-
- if (negative) {
- return 0 - num;
- }
- return num;
-}
-
-/******************************************************************************/
-#if BLD_FEATURE_FLOATING_POINT
-/*
- * Convert the string buffer to an Floating.
- */
-
-double mprParseFloat(char *str)
-{
- return atof(str);
-}
-
-/******************************************************************************/
-
-bool mprIsNan(double f)
-{
-#if WIN
- return _isnan(f);
-#elif VXWORKS
- /* FUTURE */
- return (0);
-#elif defined(FP_NAN)
- return (f == FP_NAN);
-#else
- return 0;
-#endif
-}
-/******************************************************************************/
-
-bool mprIsInfinite(double f)
-{
-#if WIN
- return !_finite(f);
-#elif VXWORKS
- /* FUTURE */
- return (0);
-#elif defined(FP_INFINITE)
- return (f == FP_INFINITE);
-#else
- return 0;
-#endif
-}
-
-#endif /* BLD_FEATURE_FLOATING_POINT */
-/******************************************************************************/
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
+++ /dev/null
-/*
- * @file var.h
- * @brief MPR Universal Variable Type
- * @copy default.m
- *
- * Copyright (c) Mbedthis Software LLC, 2003-2005. All Rights Reserved.
- * Copyright (c) Michael O'Brien, 1994-1995. All Rights Reserved.
- *
- * This software is distributed under commercial and open source licenses.
- * You may use the GPL open source license described below or you may acquire
- * a commercial license from Mbedthis Software. You agree to be fully bound
- * by the terms of either license. Consult the LICENSE.TXT distributed with
- * this software for full details.
- *
- * This software is open source; 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 2 of the License, or (at your
- * option) any later version. See the GNU General Public License for more
- * details at: http://www.mbedthis.com/downloads/gplLicense.html
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the
- * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * This GPL license does NOT permit incorporating this software into
- * proprietary programs. If you are unable to comply with the GPL, you must
- * acquire a commercial license to use this software. Commercial licenses
- * for this software and support services are available from Mbedthis
- * Software at http://www.mbedthis.com
- *
- * @end
- */
-
-/******************************* Documentation ********************************/
-/*
- * Variables can efficiently store primitive types and can hold references to
- * objects. Objects can store properties which are themselves variables.
- * Properties can be primitive data types, other objects or functions.
- * Properties are indexed by a character name. A variable may store one of
- * the following types:
- *
- * string, integer, integer-64bit, C function, C function with string args,
- * Javascript function, Floating point number, boolean value, Undefined
- * value and the Null value.
- *
- * Variables have names while objects may be referenced by multiple variables.
- * Objects use reference counting for garbage collection.
- *
- * This module is not thread safe for performance and compactness. It relies
- * on upper modules to provide thread synchronization as required. The API
- * provides primitives to get variable/object references or to get copies of
- * variables which will help minimize required lock times.
- */
-
-#ifndef _h_MPR_VAR
-#define _h_MPR_VAR 1
-
-/********************************* Includes ***********************************/
-
-#include "miniMpr.h"
-
-/********************************** Defines ***********************************/
-
-/*
- * Define VAR_DEBUG if you want to track objects. However, this code is not
- * thread safe and you need to run the server single threaded.
- *
- * #define VAR_DEBUG 1
- */
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-/*
- * Forward declare types
- */
-struct MprProperties;
-struct MprVar;
-
-/*
- * Possible variable types. Don't use enum because we need to be able to
- * do compile time conditional compilation on BLD_FEATURE_NUM_TYPE_ID.
- */
-typedef int MprType;
-#define MPR_TYPE_UNDEFINED 0 /* Undefined. No value has been set. */
-#define MPR_TYPE_NULL 1 /* Value defined to be null. */
-#define MPR_TYPE_BOOL 2 /* Boolean type. */
-#define MPR_TYPE_CFUNCTION 3 /* C function or C++ method */
-#define MPR_TYPE_FLOAT 4 /* Floating point number */
-#define MPR_TYPE_INT 5 /* Integer number */
-#define MPR_TYPE_INT64 6 /* 64-bit Integer number */
-#define MPR_TYPE_OBJECT 7 /* Object reference */
-#define MPR_TYPE_FUNCTION 8 /* JavaScript function */
-#define MPR_TYPE_STRING 9 /* String (immutable) */
-#define MPR_TYPE_STRING_CFUNCTION 10 /* C/C++ function with string args */
-#define MPR_TYPE_PTR 11 /* Opaque pointer */
-
-/*
- * Create a type for the default number type
- * Config.h will define the default number type. For example:
- *
- * BLD_FEATURE_NUM_TYPE=int
- * BLD_FEATURE_NUM_TYPE_ID=MPR_TYPE_INT
- */
-
-/**
- * Set to the type used for MPR numeric variables. Will equate to int, int64
- * or double.
- */
-typedef BLD_FEATURE_NUM_TYPE MprNum;
-
-/**
- * Set to the MPR_TYPE used for MPR numeric variables. Will equate to
- * MPR_TYPE_INT, MPR_TYPE_INT64 or MPR_TYPE_FLOAT.
- */
-#define MPR_NUM_VAR BLD_FEATURE_NUM_TYPE_ID
-#define MPR_TYPE_NUM BLD_FEATURE_NUM_TYPE_ID
-
-/*
- * Return TRUE if a variable is a function type
- */
-#define mprVarIsFunction(type) \
- (type == MPR_TYPE_FUNCTION || type == MPR_TYPE_STRING_CFUNCTION || \
- type == MPR_TYPE_CFUNCTION)
-
-/*
- * Return TRUE if a variable is a numeric type
- */
-#define mprVarIsNumber(type) \
- (type == MPR_TYPE_INT || type == MPR_TYPE_INT64 || type == MPR_TYPE_FLOAT)
-
-/*
- * Return TRUE if a variable is a boolean
- */
-#define mprVarIsBoolean(type) \
- (type == MPR_TYPE_BOOL)
-#define mprVarIsString(type) \
- (type == MPR_TYPE_STRING)
-#define mprVarIsObject(type) \
- (type == MPR_TYPE_OBJECT)
-#define mprVarIsFloating(type) \
- (type == MPR_TYPE_FLOAT)
-#define mprVarIsPtr(type) \
- (type == MPR_TYPE_PTR)
-#define mprVarIsUndefined(var) \
- ((var)->type == MPR_TYPE_UNDEFINED)
-#define mprVarIsNull(var) \
- ((var)->type == MPR_TYPE_NULL)
-#define mprVarIsValid(var) \
- (((var)->type != MPR_TYPE_NULL) && ((var)->type != MPR_TYPE_UNDEFINED))
-
-#define MPR_VAR_MAX_RECURSE 5 /* Max object loops */
-
-#if BLD_FEATURE_SQUEEZE
-#define MPR_MAX_VAR 64 /* Max var full name */
-#else
-#define MPR_MAX_VAR 512
-#endif
-
-/*
- * Function signatures
- */
-typedef int MprVarHandle;
-typedef int (*MprCFunction)(MprVarHandle userHandle, int argc,
- struct MprVar **argv);
-typedef int (*MprStringCFunction)(MprVarHandle userHandle, int argc,
- char **argv);
-
-/*
- * Triggers
- */
-typedef enum {
- MPR_VAR_WRITE, /* This property is being updated */
- MPR_VAR_READ, /* This property is being read */
- MPR_VAR_CREATE_PROPERTY, /* A property is being created */
- MPR_VAR_DELETE_PROPERTY, /* A property is being deleted */
- MPR_VAR_DELETE /* This object is being deleted */
-} MprVarTriggerOp;
-
-/*
- * Trigger function return codes.
- */
-typedef enum {
- MPR_TRIGGER_ABORT, /* Abort the current operation */
- MPR_TRIGGER_USE_NEW_VALUE, /* Proceed and use the newValue */
- MPR_TRIGGER_PROCEED /* Proceed with the operation */
-} MprVarTriggerStatus;
-
-/*
- * The MprVarTrigger arguments have the following meaning:
- *
- * op The operation being performed. See MprVarTriggerOp.
- * parentProperties Pointer to the MprProperties structure.
- * vp Pointer to the property that registered the trigger.
- * newValue New value (see below for more details).
- * copyDepth Specify what data items to copy.
- *
- * For VAR_READ, newVar is set to a temporary variable that the trigger
- * function may assign a value to be returned instead of the actual
- * property value.
- * For VAR_WRITE, newValue holds the new value. The old existing value may be
- * accessed via vp.
- * For DELETE_PROPERTY, vp is the property being deleted. newValue is null.
- * For ADD_PROPERTY, vp is set to the property being added and newValue holds
- * the new value.
- */
-typedef MprVarTriggerStatus (*MprVarTrigger)(MprVarTriggerOp op,
- struct MprProperties *parentProperties, struct MprVar *vp,
- struct MprVar *newValue, int copyDepth);
-
-/*
- * mprCreateFunctionVar flags
- */
-/** Use the alternate handle on function callbacks */
-#define MPR_VAR_ALT_HANDLE 0x1
-
-/** Use the script handle on function callbacks */
-#define MPR_VAR_SCRIPT_HANDLE 0x2
-
-/*
- * Useful define for the copyDepth argument
- */
-/** Don't copy any data. Copy only the variable name */
-#define MPR_NO_COPY 0
-
-/** Copy strings. Increment object reference counts. */
-#define MPR_SHALLOW_COPY 1
-
-/** Copy strings and do complete object copies. */
-#define MPR_DEEP_COPY 2
-
-/*
- * GetFirst / GetNext flags
- */
-/** Step into data properties. */
-#define MPR_ENUM_DATA 0x1
-
-/** Step into functions properties. */
-#define MPR_ENUM_FUNCTIONS 0x2
-
-/*
- * Collection type to hold properties in an object
- */
-typedef struct MprProperties { /* Collection of properties */
-#if VAR_DEBUG
- struct MprProperties *next; /* Linked list */
- struct MprProperties *prev; /* Linked list */
- char name[32]; /* Debug name */
-#endif
- struct MprVar **buckets; /* Hash chains */
- int numItems; /* Total count of items */
- /* FUTURE - Better way of doing this */
- int numDataItems; /* Enumerable data items */
- uint hashSize : 8; /* Size of the hash table */
- /* FUTURE -- increase size of refCount */
- uint refCount : 8; /* References to this property*/
- /* FUTURE - make these flags */
- uint deleteProtect : 8; /* Don't recursively delete */
- uint visited : 8; /* Node has been processed */
-} MprProperties;
-
-/*
- * Universal Variable Type
- */
-typedef struct MprVar {
- /* FUTURE - remove name to outside reference */
- MprStr name; /* Property name */
- /* FUTURE - remove */
- MprStr fullName; /* Full object name */
- /* FUTURE - make part of the union */
- MprProperties *properties; /* Pointer to properties */
-
- /*
- * Packed bit field
- */
- MprType type : 8; /* Selector into union */
- uint bucketIndex : 8; /* Copy of bucket index */
-
- uint flags : 5; /* Type specific flags */
- uint allocatedData : 1; /* Data needs freeing */
- uint readonly : 1; /* Unmodifiable */
- uint deleteProtect : 1; /* Don't recursively delete */
-
- uint visited : 1; /* Node has been processed */
- uint allocatedVar : 1; /* Var needs freeing */
- uint spare : 6; /* Unused */
-
- struct MprVar *forw; /* Hash table linkage */
- MprVarTrigger trigger; /* Trigger function */
-
-#if UNUSED && KEEP
- struct MprVar *baseClass; /* Pointer to class object */
-#endif
- MprProperties *parentProperties; /* Pointer to parent object */
-
- /*
- * Union of primitive types. When debugging on Linux, don't use unions
- * as the gdb debugger can't display them.
- */
-#if 0 && !BLD_DEBUG && !LINUX && !VXWORKS
- union {
-#endif
- bool boolean;
-#if BLD_FEATURE_FLOATING_POINT
- double floating;
-#endif
- int integer;
-#if BLD_FEATURE_INT64
- int64 integer64;
-#endif
- struct { /* Javascript functions */
- MprArray *args; /* Null terminated */
- char *body;
- } function;
- struct { /* Function with MprVar args */
- MprCFunction fn;
- void *thisPtr;
- } cFunction;
- struct { /* Function with string args */
- MprStringCFunction fn;
- void *thisPtr;
- } cFunctionWithStrings;
- MprStr string; /* Allocated string */
- void *ptr; /* Opaque pointer */
-#if 0 && !BLD_DEBUG && !LINUX && !VXWORKS
- };
-#endif
-} MprVar;
-
-/*
- * Define a field macro so code an use numbers in a "generic" fashion.
- */
-#if MPR_NUM_VAR == MPR_TYPE_INT || DOXYGEN
-/* Default numeric type */
-#define mprNumber integer
-#endif
-#if MPR_NUM_VAR == MPR_TYPE_INT64
-/* Default numeric type */
-#define mprNumber integer64
-#endif
-#if MPR_NUM_VAR == MPR_TYPE_FLOAT
-/* Default numeric type */
-#define mprNumber floating
-#endif
-
-typedef BLD_FEATURE_NUM_TYPE MprNumber;
-
-/********************************* Prototypes *********************************/
-/*
- * Variable constructors and destructors
- */
-extern MprVar mprCreateObjVar(const char *name, int hashSize);
-extern MprVar mprCreateBoolVar(bool value);
-extern MprVar mprCreateCFunctionVar(MprCFunction fn, void *thisPtr,
- int flags);
-#if BLD_FEATURE_FLOATING_POINT
-extern MprVar mprCreateFloatVar(double value);
-#endif
-extern MprVar mprCreateIntegerVar(int value);
-#if BLD_FEATURE_INT64
-extern MprVar mprCreateInteger64Var(int64 value);
-#endif
-extern MprVar mprCreateFunctionVar(char *args, char *body, int flags);
-extern MprVar mprCreateNullVar(void);
-extern MprVar mprCreateNumberVar(MprNumber value);
-extern MprVar mprCreateStringCFunctionVar(MprStringCFunction fn,
- void *thisPtr, int flags);
-extern MprVar mprCreateStringVar(const char *value, bool allocate);
-extern MprVar mprCreateUndefinedVar(void);
-extern MprVar mprCreatePtrVar(void *ptr);
-extern bool mprDestroyVar(MprVar *vp);
-extern bool mprDestroyAllVars(MprVar* vp);
-extern MprType mprGetVarType(MprVar *vp);
-
-/*
- * Copy
- */
-extern void mprCopyVar(MprVar *dest, MprVar *src, int copyDepth);
-extern void mprCopyVarValue(MprVar *dest, MprVar src, int copyDepth);
-extern MprVar *mprDupVar(MprVar *src, int copyDepth);
-
-/*
- * Manage vars
- */
-extern MprVarTrigger
- mprAddVarTrigger(MprVar *vp, MprVarTrigger fn);
-extern int mprGetVarRefCount(MprVar *vp);
-extern void mprSetVarDeleteProtect(MprVar *vp, int deleteProtect);
-extern void mprSetVarFullName(MprVar *vp, char *name);
-extern void mprSetVarReadonly(MprVar *vp, int readonly);
-extern void mprSetVarName(MprVar *vp, char *name);
-
-/*
- * Create properties and return a reference to the property.
- */
-extern MprVar *mprCreateProperty(MprVar *obj, const char *property,
- MprVar *newValue);
-extern MprVar *mprCreatePropertyValue(MprVar *obj, const char *property,
- MprVar newValue);
-extern int mprDeleteProperty(MprVar *obj, const char *property);
-
-/*
- * Get/Set properties. Set will update/create.
- */
-extern MprVar *mprGetProperty(MprVar *obj, const char *property,
- MprVar *value);
-extern MprVar *mprSetProperty(MprVar *obj, const char *property,
- MprVar *value);
-extern MprVar *mprSetPropertyValue(MprVar *obj, const char *property,
- MprVar value);
-
-/*
- * Directly read/write property values (the property must already exist)
- * For mprCopyProperty, mprDestroyVar must always called on the var.
- */
-extern int mprReadProperty(MprVar *prop, MprVar *value);
-extern int mprWriteProperty(MprVar *prop, MprVar *newValue);
-extern int mprWritePropertyValue(MprVar *prop, MprVar newValue);
-
-/*
- * Copy a property. NOTE: reverse of most other args: (dest, src)
- */
-extern int mprCopyProperty(MprVar *dest, MprVar *prop, int copyDepth);
-
-/*
- * Enumerate properties
- */
-extern MprVar *mprGetFirstProperty(MprVar *obj, int includeFlags);
-extern MprVar *mprGetNextProperty(MprVar *obj, MprVar *currentProperty,
- int includeFlags);
-
-/*
- * Query properties characteristics
- */
-extern int mprGetPropertyCount(MprVar *obj, int includeFlags);
-
-/*
- * Conversion routines
- */
-extern MprVar mprParseVar(char *str, MprType prefType);
-extern MprNum mprVarToNumber(const MprVar *vp);
-extern int mprVarToInteger(const MprVar *vp);
-#if BLD_FEATURE_INT64
-extern int64 mprVarToInteger64(const MprVar *vp);
-#endif
-extern bool mprVarToBool(const MprVar *vp);
-#if BLD_FEATURE_FLOATING_POINT
-extern double mprVarToFloat(const MprVar *vp);
-#endif
-extern void mprVarToString(char** buf, int size, char *fmt, MprVar *vp);
-
-/*
- * Parsing and utility routines
- */
-extern MprNum mprParseNumber(char *str);
-extern int mprParseInteger(char *str);
-
-#if BLD_FEATURE_INT64
-extern int64 mprParseInteger64(char *str);
-#endif
-
-#if BLD_FEATURE_FLOATING_POINT
-extern double mprParseFloat(char *str);
-extern bool mprIsInfinite(double f);
-extern bool mprIsNan(double f);
-#endif
-
-#if VAR_DEBUG
-extern void mprPrintObjects(char *msg);
-extern void mprPrintObjRefCount(MprVar *vp);
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-/*****************************************************************************/
-#endif /* _h_MPR_VAR */
-
-/*
- * Local variables:
- * tab-width: 4
- * c-basic-offset: 4
- * End:
- * vim:tw=78
- * vim600: sw=4 ts=4 fdm=marker
- * vim<600: sw=4 ts=4
- */
void strupper_m(char *s);
void strlower_m(char *s);
char *strupper_talloc(TALLOC_CTX *ctx, const char *src);
+char *talloc_strdup_upper(TALLOC_CTX *ctx, const char *src);
char *strupper_talloc_n(TALLOC_CTX *ctx, const char *src, size_t n);
char *strlower_talloc(TALLOC_CTX *ctx, const char *src);
bool strhasupper(const char *string);
**/
_PUBLIC_ char *strchr_m(const char *s, char c)
{
+ if (s == NULL) {
+ return NULL;
+ }
/* characters below 0x3F are guaranteed to not appear in
non-initial position in multi-byte charsets */
if ((c & 0xC0) == 0) {
{
char *ret = NULL;
+ if (s == NULL) {
+ return NULL;
+ }
+
/* characters below 0x3F are guaranteed to not appear in
non-initial position in multi-byte charsets */
if ((c & 0xC0) == 0) {
return strupper_talloc_n(ctx, src, src?strlen(src):0);
}
-
+/**
+ talloc_strdup() a unix string to upper case.
+**/
+_PUBLIC_ char *talloc_strdup_upper(TALLOC_CTX *ctx, const char *src)
+{
+ return strupper_talloc(ctx, src);
+}
/**
Convert a string to lower case.
WERROR com_get_class_object(struct com_context *ctx, struct GUID *clsid, struct GUID *iid, struct IUnknown **ip);
NTSTATUS com_init(void);
+typedef struct IUnknown *(*get_class_object_function) (const struct GUID *clsid);
+
#endif /* __SAMBA_COM_H__ */
[SUBSYSTEM::COM]
+PRIVATE_DEPENDENCIES = LIBSAMBA-UTIL LIBSAMBA-HOSTCONFIG LIBEVENTS LIBNDR
-COM_OBJ_FILES = $(addprefix lib/com/, tables.o rot.o main.o)
+COM_OBJ_FILES = $(addprefix $(comsrcdir)/, tables.o rot.o main.o)
[SUBSYSTEM::DCOM]
-PUBLIC_DEPENDENCIES = com DCOM_PROXY_DCOM RPC_NDR_REMACT \
+PUBLIC_DEPENDENCIES = COM DCOM_PROXY_DCOM RPC_NDR_REMACT \
RPC_NDR_OXIDRESOLVER
-DCOM_OBJ_FILES = $(addprefix lib/com/dcom/, main.o tables.o)
+DCOM_OBJ_FILES = $(addprefix $(comsrcdir)/dcom/, main.o tables.o)
[MODULE::com_simple]
SUBSYSTEM = COM
INIT_FUNCTION = com_simple_init
-com_simple_OBJ_FILES = lib/com/classes/simple.o
+com_simple_OBJ_FILES = $(comsrcdir)/classes/simple.o
+
+[PYTHON::pycom]
+LIBRARY_REALNAME = samba/com.$(SHLIBEXT)
+PRIVATE_DEPENDENCIES = COM
+
+pycom_OBJ_FILES = $(comsrcdir)/pycom.o
int i;
struct GUID classfact_iid;
- GUID_from_string(DCERPC_ICLASSFACTORY_UUID, &classfact_iid);
+ GUID_from_string(NDR_ICLASSFACTORY_UUID, &classfact_iid);
/* Obtain class object */
error = com_get_class_object(ctx, clsid, &classfact_iid, (struct IUnknown **)&factory);
return IUnknown_QueryInterface(iu, ctx, iid, ip);
}
-
-NTSTATUS com_init(void)
-{
- static BOOL initialized = False;
-
- init_module_fn static_init[] = STATIC_com_MODULES;
- init_module_fn *shared_init;
-
- if (initialized) return NT_STATUS_OK;
- initialized = True;
-
- shared_init = load_samba_modules(NULL, "com");
-
- run_init_functions(static_init);
- run_init_functions(shared_init);
-
- talloc_free(shared_init);
-
- return NT_STATUS_OK;
-}
--- /dev/null
+/*
+ Unix SMB/CIFS implementation.
+ Python bindings for COM library.
+ Copyright (C) Jelmer Vernooij <jelmer@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.
+
+ 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 <Python.h>
+#include "lib/com/com.h"
+#include "librpc/ndr/libndr.h"
+#include "libcli/util/pyerrors.h"
+
+static struct com_context *py_com_ctx = NULL; /* FIXME: evil global */
+
+static PyObject *py_get_class_object(PyObject *self, PyObject *args)
+{
+ char *s_clsid, *s_iid;
+ struct GUID clsid, iid;
+ struct IUnknown *object;
+ NTSTATUS status;
+ WERROR error;
+
+ if (!PyArg_ParseTuple(args, "ss", &s_clsid, &s_iid))
+ return NULL;
+
+ status = GUID_from_string(s_clsid, &clsid);
+ if (!NT_STATUS_IS_OK(status)) {
+ PyErr_FromNTSTATUS(status);
+ return NULL;
+ }
+
+ status = GUID_from_string(s_iid, &iid);
+ if (!NT_STATUS_IS_OK(status)) {
+ PyErr_FromNTSTATUS(status);
+ return NULL;
+ }
+
+ error = com_get_class_object(py_com_ctx, &clsid, &iid, &object);
+ if (!W_ERROR_IS_OK(error)) {
+ PyErr_FromWERROR(error);
+ return NULL;
+ }
+
+ /* FIXME: Magic, integrate with stubs generated by pidl. */
+
+ return Py_None;
+}
+
+static struct PyMethodDef com_methods[] = {
+ { "get_class_object", (PyCFunction)py_get_class_object, METH_VARARGS, "S.get_class_object(clsid, iid) -> instance" },
+ { NULL },
+};
+
+void initcom(void)
+{
+ PyObject *m;
+ WERROR error;
+
+ error = com_init_ctx(&py_com_ctx, NULL);
+ if (!W_ERROR_IS_OK(error)) {
+ PyErr_FromWERROR(error);
+ return;
+ }
+
+ m = Py_InitModule3("com", com_methods, "Simple COM implementation");
+ if (m == NULL)
+ return;
+}
*/
#include "includes.h"
+#include "lib/com/com.h"
struct dcom_interface_p *dcom_get_local_iface_p(struct GUID *ipid)
{
+++ /dev/null
-/*
- Unix SMB/CIFS implementation.
-
- Copyright (C) Andrew Tridgell 2004
-
- 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 "lib/crypto/crc32.h"
-#include "lib/crypto/md4.h"
-#include "lib/crypto/md5.h"
-#include "lib/crypto/hmacmd5.h"
-#include "lib/crypto/sha256.h"
-#include "lib/crypto/hmacsha256.h"
-
-struct arcfour_state {
- uint8_t sbox[256];
- uint8_t index_i;
- uint8_t index_j;
-};
-
-void arcfour_init(struct arcfour_state *state, const DATA_BLOB *key);
-void arcfour_crypt_sbox(struct arcfour_state *state, uint8_t *data, int len);
-void arcfour_crypt_blob(uint8_t *data, int len, const DATA_BLOB *key);
-void arcfour_crypt(uint8_t *data, const uint8_t keystr[16], int len);
-
bindir = @bindir@
includedir = @includedir@
libdir = @libdir@
-VPATH = @srcdir@:@tallocdir@:@libreplacedir@
+VPATH = @srcdir@:@libreplacedir@
srcdir = @srcdir@
builddir = @builddir@
+sharedbuilddir = @sharedbuilddir@
+INSTALLCMD = @INSTALL@
CPPFLAGS = @CPPFLAGS@ -I$(srcdir)/include -Iinclude -I.
LDFLAGS = @LDFLAGS@
EXEEXT = @EXEEXT@
PYTHON_CHECK_TARGET = @PYTHON_CHECK_TARGET@
LIB_PATH_VAR = @LIB_PATH_VAR@
eventsdir = @eventsdir@
-tallocdir = @tallocdir@
-TALLOC_LIBS = @TALLOC_LIBS@
TALLOC_CFLAGS = @TALLOC_CFLAGS@
-TALLOC_OBJ = @TALLOC_OBJ@
+TALLOC_LDFLAGS = @TALLOC_CFLAGS@
+TALLOC_LIBS = @TALLOC_LIBS@
-CFLAGS = $(CPPFLAGS) $(TALLOC_CFLAGS) @CFLAGS@
+EVENTS_CFLAGS = @EVENTS_CFLAGS@
+EVENTS_LDFLAGS = @EVENTS_CFLAGS@
+EVENTS_LIBS = @EVENTS_LIBS@
-EVENTS_OBJ = @EVENTS_OBJ@ $(TALLOC_OBJ) @LIBREPLACEOBJ@
+CFLAGS = $(CPPFLAGS) $(TALLOC_CFLAGS) $(EVENTS_CFLAGS) @CFLAGS@
+LDFLAGS = $(TALLOC_LDFLAGS) $(EVENTS_LDFLAGS) @LDFLAGS@
+LIBS = $(TALLOC_LIBS) $(EVENTS_LIBS) @LIBS@
+
+EVENTS_OBJ = @EVENTS_OBJ@ @LIBREPLACEOBJ@
default: all
include $(eventsdir)/events.mk
include $(eventsdir)/rules.mk
-all:: showflags dirs $(PROGS) $(LIBEVENTS_SOLIB) libevents.a $(PYTHON_BUILD_TARGET)
+all:: showflags dirs $(PROGS) $(EVENTS_SOLIB) libevents.a $(PYTHON_BUILD_TARGET)
install:: all
-$(LIBEVENTS_SOLIB): $(EVENTS_OBJ)
- $(SHLD) $(SHLD_FLAGS) -o $@ $(EVENTS_OBJ) $(TALLOC_LIBS) @SONAMEFLAG@$(LIBEVENTS_SONAME)
+$(EVENTS_SOLIB): $(EVENTS_OBJ)
+ $(SHLD) $(SHLD_FLAGS) $(LDFLAGS) $(LIBS) -o $@ $(EVENTS_OBJ) @SONAMEFLAG@$(EVENTS_SONAME)
+
+shared-build: all
+ ${INSTALLCMD} -d $(sharedbuilddir)/lib
+ ${INSTALLCMD} -m 644 libevents.a $(sharedbuilddir)/lib
+ ${INSTALLCMD} -m 755 $(EVENTS_SOLIB) $(sharedbuilddir)/lib
+ ln -sf $(EVENTS_SOLIB) $(sharedbuilddir)/lib/$(EVENTS_SONAME)
+ ln -sf $(EVENTS_SOLIB) $(sharedbuilddir)/lib/libevents.so
+ ${INSTALLCMD} -d $(sharedbuilddir)/include
+ ${INSTALLCMD} -m 644 $(srcdir)/events.h $(sharedbuilddir)/include
check: test
clean::
rm -f *.o *.a */*.o
- rm -f $(TALLOC_OBJ)
distclean:: clean
rm -f config.log config.status include/config.h config.cache
rm -rf autom4te.cache
rm -f configure config.h.in
-IPATHS="-I libreplace -I lib/replace -I ../libreplace -I ../replace"
-IPATHS="$IPATHS -I lib/talloc -I talloc -I ../talloc"
+IPATHS="-I libreplace -I lib/replace -I ../libreplace -I ../replace -I ../../../lib/replace"
autoconf $IPATHS || exit 1
autoheader $IPATHS || exit 1
--- /dev/null
+AC_DEFUN(BUILD_WITH_SHARED_BUILD_DIR,
+ [ AC_ARG_WITH([shared-build-dir],
+ [AC_HELP_STRING([--with-shared-build-dir=DIR],
+ [temporary build directory where libraries are installed [$srcdir/sharedbuild]])])
+
+ sharedbuilddir="$srcdir/sharedbuild"
+ if test x"$with_shared_build_dir" != x; then
+ sharedbuilddir=$with_shared_build_dir
+ CFLAGS="$CFLAGS -I$with_shared_build_dir/include"
+ LDFLAGS="$LDFLAGS -L$with_shared_build_dir/lib"
+ fi
+ AC_SUBST(sharedbuilddir)
+ ])
+
AC_CONFIG_HEADER(config.h)
AC_LIBREPLACE_ALL_CHECKS
-m4_include(libtalloc.m4)
-
AC_LD_EXPORT_DYNAMIC
AC_LD_SONAMEFLAG
AC_LD_PICFLAG
AC_LIBREPLACE_SHLD
AC_LIBREPLACE_SHLD_FLAGS
AC_LIBREPLACE_RUNTIME_LIB_PATH_VAR
+
+m4_include(build_macros.m4)
+BUILD_WITH_SHARED_BUILD_DIR
+
+m4_include(pkg.m4)
+m4_include(libtalloc.m4)
+
m4_include(libevents.m4)
AC_PATH_PROGS([PYTHON_CONFIG], [python2.6-config python2.5-config python2.4-config python-config])
AC_PATH_PROGS([PYTHON], [python2.6 python2.5 python2.4 python])
%module(docstring="Event management.",package="samba.events") events;
-%import "../talloc/talloc.i";
+%import "../../../lib/talloc/talloc.i";
%{
#include "events.h"
libevents.a: $(EVENTS_OBJ)
ar -rv libevents.a $(EVENTS_OBJ)
-libevents.$(SHLIBEXT): $(LIBEVENTS_SOLIB)
+libevents.$(SHLIBEXT): $(EVENTS_SOLIB)
ln -fs $< $@
$(EVENTS_SONAME): $(EVENTS_SOLIB)
installlibs:: installdirs
cp events.pc $(DESTDIR)$(libdir)/pkgconfig
- cp libevents.a $(LIBEVENTS_SOLIB) $(DESTDIR)$(libdir)
+ cp libevents.a $(EVENTS_SOLIB) $(DESTDIR)$(libdir)
install:: all installdirs installheaders installlibs $(PYTHON_INSTALL_TARGET)
# This file was automatically generated by SWIG (http://www.swig.org).
-# Version 1.3.33
+# Version 1.3.36
#
# Don't modify this file, modify the SWIG interface instead.
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
- * Version 1.3.35
+ * Version 1.3.36
*
* This file is not intended to be easily readable and contains a number of
* coding conventions designed to improve portability and efficiency. Do not make
# endif
#endif
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+# pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
# define SWIGUNUSEDPARM(p)
#define SWIG_name "_events"
-#define SWIGVERSION 0x010335
+#define SWIGVERSION 0x010336
#define SWIG_VERSION SWIGVERSION
SWIGINTERN PyObject *_wrap_event_loop_once(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
event *arg1 = (event *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
+ int result;
if (!args) SWIG_fail;
swig_obj[0] = args;
SWIGINTERN PyObject *_wrap_event_loop_wait(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
event *arg1 = (event *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
+ int result;
if (!args) SWIG_fail;
swig_obj[0] = args;
}
arg1 = (event *)(argp1);
delete_event(arg1);
-
resultobj = SWIG_Py_Void();
return resultobj;
fail:
PyObject *resultobj = 0;
TALLOC_CTX *arg1 = (TALLOC_CTX *) 0 ;
char *arg2 = (char *) 0 ;
- struct event_context *result = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
char * kwnames[] = {
(char *) "name", NULL
};
+ struct event_context *result = 0 ;
arg1 = NULL;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:event_context_init_byname",kwnames,&obj0)) SWIG_fail;
EVENTS_CFLAGS="-I$eventsdir"
AC_SUBST(EVENTS_CFLAGS)
-EVENTS_LIBS=""
+EVENTS_LIBS="$AIO_LIBS"
AC_SUBST(EVENTS_LIBS)
--- /dev/null
+AC_SUBST(TALLOC_OBJ)
+AC_SUBST(TALLOC_CFLAGS)
+AC_SUBST(TALLOC_LIBS)
+
+AC_CHECK_HEADER(talloc.h,
+ [AC_CHECK_LIB(talloc, talloc_init, [TALLOC_LIBS="-ltalloc"]) ],
+ [PKG_CHECK_MODULES(TALLOC, talloc)])
--- /dev/null
+# pkg.m4 - Macros to locate and utilise pkg-config. -*- Autoconf -*-
+#
+# Copyright © 2004 Scott James Remnant <scott@netsplit.com>.
+#
+# 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/>.
+#
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+# PKG_PROG_PKG_CONFIG([MIN-VERSION])
+# ----------------------------------
+AC_DEFUN([PKG_PROG_PKG_CONFIG],
+[m4_pattern_forbid([^_?PKG_[A-Z_]+$])
+m4_pattern_allow([^PKG_CONFIG(_PATH)?$])
+AC_ARG_VAR([PKG_CONFIG], [path to pkg-config utility])dnl
+if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
+ AC_PATH_TOOL([PKG_CONFIG], [pkg-config])
+fi
+if test -n "$PKG_CONFIG"; then
+ _pkg_min_version=m4_default([$1], [0.9.0])
+ AC_MSG_CHECKING([pkg-config is at least version $_pkg_min_version])
+ if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then
+ AC_MSG_RESULT([yes])
+ else
+ AC_MSG_RESULT([no])
+ PKG_CONFIG=""
+ fi
+
+fi[]dnl
+])# PKG_PROG_PKG_CONFIG
+
+# PKG_CHECK_EXISTS(MODULES, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
+#
+# Check to see whether a particular set of modules exists. Similar
+# to PKG_CHECK_MODULES(), but does not set variables or print errors.
+#
+#
+# Similar to PKG_CHECK_MODULES, make sure that the first instance of
+# this or PKG_CHECK_MODULES is called, or make sure to call
+# PKG_CHECK_EXISTS manually
+# --------------------------------------------------------------
+AC_DEFUN([PKG_CHECK_EXISTS],
+[AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl
+if test -n "$PKG_CONFIG" && \
+ AC_RUN_LOG([$PKG_CONFIG --exists --print-errors "$1"]); then
+ m4_ifval([$2], [$2], [:])
+m4_ifvaln([$3], [else
+ $3])dnl
+fi])
+
+
+# _PKG_CONFIG([VARIABLE], [COMMAND], [MODULES])
+# ---------------------------------------------
+m4_define([_PKG_CONFIG],
+[if test -n "$PKG_CONFIG"; then
+ if test -n "$$1"; then
+ pkg_cv_[]$1="$$1"
+ else
+ PKG_CHECK_EXISTS([$3],
+ [pkg_cv_[]$1=`$PKG_CONFIG --[]$2 "$3" 2>/dev/null`],
+ [pkg_failed=yes])
+ fi
+else
+ pkg_failed=untried
+fi[]dnl
+])# _PKG_CONFIG
+
+# _PKG_SHORT_ERRORS_SUPPORTED
+# -----------------------------
+AC_DEFUN([_PKG_SHORT_ERRORS_SUPPORTED],
+[AC_REQUIRE([PKG_PROG_PKG_CONFIG])
+if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
+ _pkg_short_errors_supported=yes
+else
+ _pkg_short_errors_supported=no
+fi[]dnl
+])# _PKG_SHORT_ERRORS_SUPPORTED
+
+
+# PKG_CHECK_MODULES(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND],
+# [ACTION-IF-NOT-FOUND])
+#
+#
+# Note that if there is a possibility the first call to
+# PKG_CHECK_MODULES might not happen, you should be sure to include an
+# explicit call to PKG_PROG_PKG_CONFIG in your configure.ac
+#
+#
+# --------------------------------------------------------------
+AC_DEFUN([PKG_CHECK_MODULES],
+[AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl
+AC_ARG_VAR([$1][_CFLAGS], [C compiler flags for $1, overriding pkg-config])dnl
+AC_ARG_VAR([$1][_LIBS], [linker flags for $1, overriding pkg-config])dnl
+
+pkg_failed=no
+AC_MSG_CHECKING([for $1])
+
+_PKG_CONFIG([$1][_CFLAGS], [cflags], [$2])
+_PKG_CONFIG([$1][_LIBS], [libs], [$2])
+
+m4_define([_PKG_TEXT], [Alternatively, you may set the environment variables $1[]_CFLAGS
+and $1[]_LIBS to avoid the need to call pkg-config.
+See the pkg-config man page for more details.])
+
+if test $pkg_failed = yes; then
+ _PKG_SHORT_ERRORS_SUPPORTED
+ if test $_pkg_short_errors_supported = yes; then
+ $1[]_PKG_ERRORS=`$PKG_CONFIG --short-errors --errors-to-stdout --print-errors "$2"`
+ else
+ $1[]_PKG_ERRORS=`$PKG_CONFIG --errors-to-stdout --print-errors "$2"`
+ fi
+ # Put the nasty error message in config.log where it belongs
+ echo "$$1[]_PKG_ERRORS" >&AS_MESSAGE_LOG_FD
+
+ ifelse([$4], , [AC_MSG_ERROR(dnl
+[Package requirements ($2) were not met:
+
+$$1_PKG_ERRORS
+
+Consider adjusting the PKG_CONFIG_PATH environment variable if you
+installed software in a non-standard prefix.
+
+_PKG_TEXT
+])],
+ [AC_MSG_RESULT([no])
+ $4])
+elif test $pkg_failed = untried; then
+ ifelse([$4], , [AC_MSG_FAILURE(dnl
+[The pkg-config script could not be found or is too old. Make sure it
+is in your PATH or set the PKG_CONFIG environment variable to the full
+path to pkg-config.
+
+_PKG_TEXT
+
+To get pkg-config, see <http://www.freedesktop.org/software/pkgconfig>.])],
+ [$4])
+else
+ $1[]_CFLAGS=$pkg_cv_[]$1[]_CFLAGS
+ $1[]_LIBS=$pkg_cv_[]$1[]_LIBS
+ AC_MSG_RESULT([yes])
+ ifelse([$3], , :, [$3])
+fi[]dnl
+])# PKG_CHECK_MODULES
libdir = @libdir@
bindir = @bindir@
mandir = @mandir@
-VPATH = @srcdir@:@tdbdir@:@tallocdir@:@libreplacedir@:@poptdir@:@eventsdir@
+VPATH = @srcdir@:@libreplacedir@
srcdir = @srcdir@
builddir = @builddir@
+sharedbuilddir = @sharedbuilddir@
+INSTALLCMD = @INSTALL@
SLAPD = @SLAPD@
SWIG = swig
EXTRA_OBJ=@EXTRA_OBJ@
PACKAGE_VERSION = @PACKAGE_VERSION@
PYTHON = @PYTHON@
PYTHON_CONFIG = @PYTHON_CONFIG@
-tdbdir = @tdbdir@
ldbdir = $(srcdir)
-tallocdir = @tallocdir@
TALLOC_LIBS = @TALLOC_LIBS@
TALLOC_CFLAGS = @TALLOC_CFLAGS@
TDB_CFLAGS = @TDB_CFLAGS@
TDB_OBJ = @TDB_OBJ@
+EVENTS_LIBS = @EVENTS_LIBS@
EVENTS_CFLAGS = @EVENTS_CFLAGS@
EVENTS_OBJ = @EVENTS_OBJ@
headers = $(srcdir)/include/ldb.h $(srcdir)/include/ldb_errors.h $(srcdir)/include/ldb_handlers.h
-BINS = bin/ldbadd bin/ldbsearch bin/ldbdel bin/ldbmodify bin/ldbedit bin/ldbrename bin/ldbtest bin/oLschema2ldif
+BINS = bin/ldbadd bin/ldbsearch bin/ldbdel bin/ldbmodify bin/ldbedit bin/ldbrename bin/ldbtest
EXAMPLES = examples/ldbreader examples/ldifreader
@mkdir -p $(NSSDIR)
SONAME = libldb.$(SHLIBEXT).0
-SOLIB = lib/libldb.$(SHLIBEXT).$(PACKAGE_VERSION)
+SOLIB = libldb.$(SHLIBEXT).$(PACKAGE_VERSION)
+LIBSOLIB = lib/$(SOLIB)
STATICLIB = lib/libldb.a
-lib/$(SONAME): $(SOLIB)
+lib/$(SONAME): $(LIBSOLIB)
ln -fs libldb.$(SHLIBEXT).$(PACKAGE_VERSION) $@
-lib/libldb.$(SHLIBEXT): $(SOLIB)
+lib/libldb.$(SHLIBEXT): $(LIBSOLIB)
ln -fs libldb.$(SHLIBEXT).$(PACKAGE_VERSION) $@
-lib/libnss_ldb.$(SHLIBEXT).2: $(NSS_OBJ) $(SOLIB)
- $(SHLD) $(SHLD_FLAGS) -o $@ $(NSS_OBJ) $(LDFLAGS) $(SOLIB) @SONAMEFLAG@libnss_ldb.$(SHLIBEXT).2
+lib/libnss_ldb.$(SHLIBEXT).2: $(NSS_OBJ) $(LIBSOLIB)
+ $(SHLD) $(SHLD_FLAGS) -o $@ $(NSS_OBJ) $(LDFLAGS) $(LIBSOLIB) @SONAMEFLAG@libnss_ldb.$(SHLIBEXT).2
-$(SOLIB): $(OBJS)
- $(SHLD) $(SHLD_FLAGS) -o $@ $(OBJS) $(LDFLAGS) $(LIBS) $(TALLOC_LIBS) $(TDB_LIBS) $(LIBDL) $(LDAP_LIBS) @SONAMEFLAG@$(SONAME)
+$(LIBSOLIB): $(OBJS)
+ $(SHLD) $(SHLD_FLAGS) -o $@ $(OBJS) $(LDFLAGS) $(LIBS) $(TALLOC_LIBS) $(TDB_LIBS) $(EVENTS_LIBS) $(LIBDL) $(LDAP_LIBS) @SONAMEFLAG@$(SONAME)
+ ln -sf libldb.$(SHLIBEXT).$(PACKAGE_VERSION) lib/libldb.$(SHLIBEXT)
-all: showflags dirs $(OBJS) $(STATICLIB) $(SOLIB) $(BINS) $(EXAMPLES) manpages \
+all: showflags dirs $(OBJS) $(STATICLIB) $(LIBSOLIB) $(BINS) $(EXAMPLES) manpages \
@PYTHON_BUILD_TARGET@
+shared-build: all
+ ${INSTALLCMD} -d $(sharedbuilddir)/lib
+ ${INSTALLCMD} -m 644 $(STATICLIB) $(sharedbuilddir)/lib
+ ${INSTALLCMD} -m 755 $(LIBSOLIB) $(sharedbuilddir)/lib
+ ln -sf $(SOLIB) $(sharedbuilddir)/lib/$(SONAME)
+ ln -sf $(SOLIB) $(sharedbuilddir)/lib/libldb.so
+ ${INSTALLCMD} -d $(sharedbuilddir)/include
+ ${INSTALLCMD} -m 644 $(srcdir)/include/ldb.h $(sharedbuilddir)/include
+ ${INSTALLCMD} -m 644 $(srcdir)/include/ldb_errors.h $(sharedbuilddir)/include
+ ${INSTALLCMD} -m 644 $(srcdir)/include/ldb_handlers.h $(sharedbuilddir)/include
+
dirs:
@mkdir -p $(DIRS)
clean::
rm -f *.o */*.o *.gcov */*.gc?? tdbtest.ldb*
- rm -f $(BINS) $(TDB_OBJ) $(TALLOC_OBJ) $(STATICLIB) $(NSS_LIB) $(SOLIB)
+ rm -f $(BINS) $(TDB_OBJ) $(TALLOC_OBJ) $(STATICLIB) $(NSS_LIB) $(LIBSOLIB)
rm -f $(POPT_OBJ)
rm -f man/*.1 man/*.3 man/*.html
rm -f $(EXAMPLES)
cp $(headers) $(DESTDIR)$(includedir)
installlibs:: installdirs
- cp $(STATICLIB) $(SOLIB) $(DESTDIR)$(libdir)
+ cp $(STATICLIB) $(LIBSOLIB) $(DESTDIR)$(libdir)
cp ldb.pc $(DESTDIR)$(libdir)/pkgconfig
installbin:: installdirs
rm -rf autom4te.cache
rm -f configure config.h.in
-IPATHS="-I libreplace -I lib/replace -I ../libreplace -I ../replace"
-IPATHS="$IPATHS -I lib/events -I events -I ../events"
-IPATHS="$IPATHS -I lib/talloc -I talloc -I ../talloc"
-IPATHS="$IPATHS -I lib/tdb -I tdb -I ../tdb"
-IPATHS="$IPATHS -I lib/popt -I popt -I ../popt"
-
-# Always keep this listed last, so the built-in versions of tdb and talloc
-# get used if available.
+IPATHS="-I libreplace -I lib/replace -I ../libreplace -I ../replace -I ../../../lib/replace"
IPATHS="$IPATHS -I ./external"
autoheader $IPATHS || exit 1
--- /dev/null
+AC_DEFUN(BUILD_WITH_SHARED_BUILD_DIR,
+ [ AC_ARG_WITH([shared-build-dir],
+ [AC_HELP_STRING([--with-shared-build-dir=DIR],
+ [temporary build directory where libraries are installed [$srcdir/sharedbuild]])])
+
+ sharedbuilddir="$srcdir/sharedbuild"
+ if test x"$with_shared_build_dir" != x; then
+ sharedbuilddir=$with_shared_build_dir
+ CFLAGS="$CFLAGS -I$with_shared_build_dir/include"
+ LDFLAGS="$LDFLAGS -L$with_shared_build_dir/lib"
+ fi
+ AC_SUBST(sharedbuilddir)
+ ])
+
};
tmp_ctx = talloc_new(ldb);
- ret = ldb_search(ldb, ldb_dn_new(tmp_ctx, ldb, NULL), LDB_SCOPE_BASE,
- "(objectClass=*)", attrs, &res);
+ ret = ldb_search(ldb, tmp_ctx, &res, ldb_dn_new(tmp_ctx, ldb, NULL),
+ LDB_SCOPE_BASE, attrs, "(objectClass=*)");
if (ret != LDB_SUCCESS) {
talloc_free(tmp_ctx);
return;
}
if (res->count != 1) {
- talloc_free(res);
talloc_free(tmp_ctx);
return;
}
ldb_set_opaque(ldb, "defaultNamingContext", tmp_dn);
}
- talloc_free(res);
talloc_free(tmp_ctx);
}
return LDB_ERR_OTHER;
}
- /* TODO: get timeout from options if available there */
- ldb->default_timeout = 300; /* set default to 5 minutes */
-
/* set the default base dn */
ldb_set_default_dns(ldb);
int ldb_wait(struct ldb_handle *handle, enum ldb_wait_type type)
{
- int ret;
+ struct event_context *ev;
+
if (!handle) {
- return LDB_SUCCESS;
+ return LDB_ERR_UNAVAILABLE;
}
- ret = handle->module->ops->wait(handle, type);
- if (!ldb_errstring(handle->module->ldb)) {
- /* Set a default error string, to place the blame somewhere */
- ldb_asprintf_errstring(handle->module->ldb,
- "error waiting on module %s: %s (%d)",
- handle->module->ops->name,
- ldb_strerror(ret), ret);
+ if (handle->state == LDB_ASYNC_DONE) {
+ return handle->status;
}
- return ret;
+
+ ev = ldb_get_event_context(handle->ldb);
+ if (NULL == ev) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ switch (type) {
+ case LDB_WAIT_NONE:
+ event_loop_once(ev);
+ if (handle->state == LDB_ASYNC_DONE ||
+ handle->status != LDB_SUCCESS) {
+ return handle->status;
+ }
+ break;
+
+ case LDB_WAIT_ALL:
+ while (handle->state != LDB_ASYNC_DONE) {
+ event_loop_once(ev);
+ if (handle->status != LDB_SUCCESS) {
+ return handle->status;
+ }
+ }
+ return handle->status;
+ }
+
+ return LDB_SUCCESS;
}
/* set the specified timeout or, if timeout is 0 set the default timeout */
-/* timeout == -1 means no timeout */
int ldb_set_timeout(struct ldb_context *ldb,
struct ldb_request *req,
int timeout)
struct ldb_request *oldreq,
struct ldb_request *newreq)
{
- time_t now;
-
if (newreq == NULL) return LDB_ERR_OPERATIONS_ERROR;
- now = time(NULL);
-
- if (oldreq == NULL)
+ if (oldreq == NULL) {
return ldb_set_timeout(ldb, newreq, 0);
-
- if ((now - oldreq->starttime) > oldreq->timeout) {
- return LDB_ERR_TIME_LIMIT_EXCEEDED;
}
+
newreq->starttime = oldreq->starttime;
- newreq->timeout = oldreq->timeout - (now - oldreq->starttime);
+ newreq->timeout = oldreq->timeout;
return LDB_SUCCESS;
}
struct ldb_module *module;
int ret;
+ if (req->callback == NULL) {
+ ldb_set_errstring(ldb, "Requests MUST define callbacks");
+ return LDB_ERR_UNWILLING_TO_PERFORM;
+ }
+
ldb_reset_err_string(ldb);
/* call the first module in the chain */
return ret;
}
+int ldb_request_done(struct ldb_request *req, int status)
+{
+ req->handle->state = LDB_ASYNC_DONE;
+ req->handle->status = status;
+ return status;
+}
+
/*
search the database given a LDAP-like search expression
Use talloc_free to free the ldb_message returned in 'res', if successful
*/
-int ldb_search_default_callback(struct ldb_context *ldb,
- void *context,
+int ldb_search_default_callback(struct ldb_request *req,
struct ldb_reply *ares)
{
struct ldb_result *res;
int n;
- if (!context) {
- ldb_set_errstring(ldb, "NULL Context in callback");
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- res = talloc_get_type(context, struct ldb_result);
+ res = talloc_get_type(req->context, struct ldb_result);
- if (!res || !ares) {
- ldb_set_errstring(ldb, "NULL res or ares in callback");
- goto error;
+ if (!ares) {
+ return ldb_request_done(req, LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_request_done(req, ares->error);
}
switch (ares->type) {
case LDB_REPLY_ENTRY:
res->msgs = talloc_realloc(res, res->msgs,
- struct ldb_message *,
- res->count + 2);
+ struct ldb_message *, res->count + 2);
if (! res->msgs) {
- goto error;
+ return ldb_request_done(req, LDB_ERR_OPERATIONS_ERROR);
}
res->msgs[res->count + 1] = NULL;
res->msgs[res->count] = talloc_move(res->msgs, &ares->message);
res->count++;
break;
+
case LDB_REPLY_REFERRAL:
if (res->refs) {
for (n = 0; res->refs[n]; n++) /*noop*/ ;
res->refs = talloc_realloc(res, res->refs, char *, n + 2);
if (! res->refs) {
- goto error;
+ return ldb_request_done(req, LDB_ERR_OPERATIONS_ERROR);
}
res->refs[n] = talloc_move(res->refs, &ares->referral);
res->refs[n + 1] = NULL;
break;
- case LDB_REPLY_EXTENDED:
+
case LDB_REPLY_DONE:
/* TODO: we should really support controls on entries
* and referrals too! */
res->controls = talloc_move(res, &ares->controls);
- break;
+
+ /* this is the last message, and means the request is done */
+ /* we have to signal and eventual ldb_wait() waiting that the
+ * async request operation was completed */
+ return ldb_request_done(req, LDB_SUCCESS);
}
+
talloc_free(ares);
return LDB_SUCCESS;
+}
+
+int ldb_op_default_callback(struct ldb_request *req, struct ldb_reply *ares)
+{
+ int ret;
+
+ if (!ares) {
+ return ldb_request_done(req, LDB_ERR_OPERATIONS_ERROR);
+ }
+
+ if (ares->error != LDB_SUCCESS) {
+ ret = ares->error;
+ talloc_free(ares);
+ return ldb_request_done(req, ret);
+ }
+
+ if (ares->type != LDB_REPLY_DONE) {
+ talloc_free(ares);
+ ldb_set_errstring(req->handle->ldb, "Invalid reply type!");
+ return ldb_request_done(req, LDB_ERR_OPERATIONS_ERROR);
+ }
-error:
talloc_free(ares);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_request_done(req, LDB_SUCCESS);
}
-int ldb_build_search_req(struct ldb_request **ret_req,
+int ldb_build_search_req_ex(struct ldb_request **ret_req,
struct ldb_context *ldb,
void *mem_ctx,
struct ldb_dn *base,
enum ldb_scope scope,
- const char *expression,
+ struct ldb_parse_tree *tree,
const char * const *attrs,
struct ldb_control **controls,
void *context,
- ldb_request_callback_t callback)
+ ldb_request_callback_t callback,
+ struct ldb_request *parent)
{
struct ldb_request *req;
req = talloc(mem_ctx, struct ldb_request);
if (req == NULL) {
- ldb_set_errstring(ldb, "Out of Memory");
+ ldb_oom(ldb);
return LDB_ERR_OPERATIONS_ERROR;
}
}
req->op.search.scope = scope;
- req->op.search.tree = ldb_parse_tree(req, expression);
+ req->op.search.tree = tree;
if (req->op.search.tree == NULL) {
- ldb_set_errstring(ldb, "Unable to parse search expression");
+ ldb_set_errstring(ldb, "'tree' can't be NULL");
talloc_free(req);
return LDB_ERR_OPERATIONS_ERROR;
}
req->context = context;
req->callback = callback;
+ ldb_set_timeout_from_prev_req(ldb, parent, req);
+
+ req->handle = ldb_handle_new(req, ldb);
+ if (req->handle == NULL) {
+ ldb_oom(ldb);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
*ret_req = req;
return LDB_SUCCESS;
}
+int ldb_build_search_req(struct ldb_request **ret_req,
+ struct ldb_context *ldb,
+ void *mem_ctx,
+ struct ldb_dn *base,
+ enum ldb_scope scope,
+ const char *expression,
+ const char * const *attrs,
+ struct ldb_control **controls,
+ void *context,
+ ldb_request_callback_t callback,
+ struct ldb_request *parent)
+{
+ struct ldb_parse_tree *tree;
+ int ret;
+
+ tree = ldb_parse_tree(mem_ctx, expression);
+ if (tree == NULL) {
+ ldb_set_errstring(ldb, "Unable to parse search expression");
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ ret = ldb_build_search_req_ex(ret_req, ldb, mem_ctx, base,
+ scope, tree, attrs, controls,
+ context, callback, parent);
+ if (ret == LDB_SUCCESS) {
+ talloc_steal(*ret_req, tree);
+ }
+ return ret;
+}
+
int ldb_build_add_req(struct ldb_request **ret_req,
struct ldb_context *ldb,
void *mem_ctx,
const struct ldb_message *message,
struct ldb_control **controls,
void *context,
- ldb_request_callback_t callback)
+ ldb_request_callback_t callback,
+ struct ldb_request *parent)
{
struct ldb_request *req;
req->context = context;
req->callback = callback;
+ ldb_set_timeout_from_prev_req(ldb, parent, req);
+
+ req->handle = ldb_handle_new(req, ldb);
+ if (req->handle == NULL) {
+ ldb_oom(ldb);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
*ret_req = req;
return LDB_SUCCESS;
const struct ldb_message *message,
struct ldb_control **controls,
void *context,
- ldb_request_callback_t callback)
+ ldb_request_callback_t callback,
+ struct ldb_request *parent)
{
struct ldb_request *req;
req->context = context;
req->callback = callback;
+ ldb_set_timeout_from_prev_req(ldb, parent, req);
+
+ req->handle = ldb_handle_new(req, ldb);
+ if (req->handle == NULL) {
+ ldb_oom(ldb);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
*ret_req = req;
return LDB_SUCCESS;
struct ldb_dn *dn,
struct ldb_control **controls,
void *context,
- ldb_request_callback_t callback)
+ ldb_request_callback_t callback,
+ struct ldb_request *parent)
{
struct ldb_request *req;
req->context = context;
req->callback = callback;
+ ldb_set_timeout_from_prev_req(ldb, parent, req);
+
+ req->handle = ldb_handle_new(req, ldb);
+ if (req->handle == NULL) {
+ ldb_oom(ldb);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
*ret_req = req;
return LDB_SUCCESS;
struct ldb_dn *newdn,
struct ldb_control **controls,
void *context,
- ldb_request_callback_t callback)
+ ldb_request_callback_t callback,
+ struct ldb_request *parent)
{
struct ldb_request *req;
req->context = context;
req->callback = callback;
+ ldb_set_timeout_from_prev_req(ldb, parent, req);
+
+ req->handle = ldb_handle_new(req, ldb);
+ if (req->handle == NULL) {
+ ldb_oom(ldb);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
*ret_req = req;
return LDB_SUCCESS;
}
-int ldb_extended_default_callback(struct ldb_context *ldb,
- void *context,
+int ldb_extended_default_callback(struct ldb_request *req,
struct ldb_reply *ares)
{
struct ldb_result *res;
- if (!context) {
- ldb_set_errstring(ldb, "NULL Context in callback");
- return LDB_ERR_OPERATIONS_ERROR;
- }
+ res = talloc_get_type(req->context, struct ldb_result);
- res = talloc_get_type(context, struct ldb_result);
- if (!res || !ares) {
- ldb_set_errstring(ldb, "NULL res or ares in callback");
- goto error;
+ if (!ares) {
+ return ldb_request_done(req, LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_request_done(req, ares->error);
}
- switch (ares->type) {
- case LDB_REPLY_ENTRY:
- case LDB_REPLY_REFERRAL:
- case LDB_REPLY_DONE:
- ldb_set_errstring(ldb, "invalid ares type in callback");
- goto error;
- case LDB_REPLY_EXTENDED:
- /* TODO: we should really support controls on entries and
- * referrals too! */
+ if (ares->type == LDB_REPLY_DONE) {
+
+ /* TODO: we should really support controls on entries and referrals too! */
res->extended = talloc_move(res, &ares->response);
res->controls = talloc_move(res, &ares->controls);
- break;
+
+ talloc_free(ares);
+ return ldb_request_done(req, LDB_SUCCESS);
}
- talloc_free(ares);
- return LDB_SUCCESS;
-error:
talloc_free(ares);
- return LDB_ERR_OPERATIONS_ERROR;
+ ldb_set_errstring(req->handle->ldb, "Invalid reply type!");
+ return ldb_request_done(req, LDB_ERR_OPERATIONS_ERROR);
}
int ldb_build_extended_req(struct ldb_request **ret_req,
void *data,
struct ldb_control **controls,
void *context,
- ldb_request_callback_t callback)
+ ldb_request_callback_t callback,
+ struct ldb_request *parent)
{
struct ldb_request *req;
req->context = context;
req->callback = callback;
+ ldb_set_timeout_from_prev_req(ldb, parent, req);
+
+ req->handle = ldb_handle_new(req, ldb);
+ if (req->handle == NULL) {
+ ldb_oom(ldb);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
*ret_req = req;
return LDB_SUCCESS;
ret = ldb_build_extended_req(&req, ldb, ldb,
oid, data, NULL,
- res, ldb_extended_default_callback);
+ res, ldb_extended_default_callback,
+ NULL);
if (ret != LDB_SUCCESS) goto done;
ldb_set_timeout(ldb, req, 0); /* use default timeout */
note that ldb_search() will automatically replace a NULL 'base' value
with the defaultNamingContext from the rootDSE if available.
*/
-int ldb_search(struct ldb_context *ldb,
- struct ldb_dn *base,
- enum ldb_scope scope,
- const char *expression,
- const char * const *attrs,
- struct ldb_result **_res)
+int ldb_search(struct ldb_context *ldb, TALLOC_CTX *mem_ctx,
+ struct ldb_result **result, struct ldb_dn *base,
+ enum ldb_scope scope, const char * const *attrs,
+ const char *exp_fmt, ...)
{
struct ldb_request *req;
- int ret;
struct ldb_result *res;
+ char *expression;
+ va_list ap;
+ int ret;
- *_res = NULL;
+ expression = NULL;
+ *result = NULL;
+ req = NULL;
- res = talloc_zero(ldb, struct ldb_result);
+ res = talloc_zero(mem_ctx, struct ldb_result);
if (!res) {
return LDB_ERR_OPERATIONS_ERROR;
}
- ret = ldb_build_search_req(&req, ldb, ldb,
+ if (exp_fmt) {
+ va_start(ap, exp_fmt);
+ expression = talloc_vasprintf(mem_ctx, exp_fmt, ap);
+ va_end(ap);
+
+ if (!expression) {
+ talloc_free(res);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ }
+
+ ret = ldb_build_search_req(&req, ldb, mem_ctx,
base?base:ldb_get_default_basedn(ldb),
scope,
expression,
attrs,
NULL,
res,
- ldb_search_default_callback);
+ ldb_search_default_callback,
+ NULL);
if (ret != LDB_SUCCESS) goto done;
- ldb_set_timeout(ldb, req, 0); /* use default timeout */
-
ret = ldb_request(ldb, req);
if (ret == LDB_SUCCESS) {
ret = ldb_wait(req->handle, LDB_WAIT_ALL);
}
- talloc_free(req);
-
done:
if (ret != LDB_SUCCESS) {
talloc_free(res);
- }
-
- *_res = res;
- return ret;
-}
-
-/*
- a useful search function where you can easily define the expression and that
- takes a memory context where results are allocated
-*/
-
-int ldb_search_exp_fmt(struct ldb_context *ldb, TALLOC_CTX *mem_ctx,
- struct ldb_result **result, struct ldb_dn *base,
- enum ldb_scope scope, const char * const *attrs,
- const char *exp_fmt, ...)
-{
- struct ldb_result *res;
- char *expression;
- va_list ap;
- int ret;
-
- res = NULL;
- *result = NULL;
-
- va_start(ap, exp_fmt);
- expression = talloc_vasprintf(mem_ctx, exp_fmt, ap);
- va_end(ap);
-
- if ( ! expression) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- ret = ldb_search(ldb, base, scope, expression, attrs, &res);
-
- if (ret == LDB_SUCCESS) {
- talloc_steal(mem_ctx, res);
- *result = res;
+ res = NULL;
}
talloc_free(expression);
+ talloc_free(req);
+ *result = res;
return ret;
}
/*
- add a record to the database. Will fail if a record with the
- given class and key already exists
+ add a record to the database. Will fail if a record with the given class
+ and key already exists
*/
int ldb_add(struct ldb_context *ldb,
const struct ldb_message *message)
message,
NULL,
NULL,
+ ldb_op_default_callback,
NULL);
if (ret != LDB_SUCCESS) return ret;
- ldb_set_timeout(ldb, req, 0); /* use default timeout */
-
/* do request and autostart a transaction */
ret = ldb_autotransaction_request(ldb, req);
message,
NULL,
NULL,
+ ldb_op_default_callback,
NULL);
if (ret != LDB_SUCCESS) return ret;
- ldb_set_timeout(ldb, req, 0); /* use default timeout */
-
/* do request and autostart a transaction */
ret = ldb_autotransaction_request(ldb, req);
dn,
NULL,
NULL,
+ ldb_op_default_callback,
NULL);
if (ret != LDB_SUCCESS) return ret;
- ldb_set_timeout(ldb, req, 0); /* use default timeout */
-
/* do request and autostart a transaction */
ret = ldb_autotransaction_request(ldb, req);
newdn,
NULL,
NULL,
+ ldb_op_default_callback,
NULL);
if (ret != LDB_SUCCESS) return ret;
- ldb_set_timeout(ldb, req, 0); /* use default timeout */
-
/* do request and autostart a transaction */
ret = ldb_autotransaction_request(ldb, req);
return the global sequence number
*/
int ldb_sequence_number(struct ldb_context *ldb,
- enum ldb_sequence_type type,
- uint64_t *seq_num)
+ enum ldb_sequence_type type, uint64_t *seq_num)
{
struct ldb_request *req;
int ret;
- req = talloc(ldb, struct ldb_request);
+ req = talloc_zero(ldb, struct ldb_request);
if (req == NULL) {
ldb_set_errstring(ldb, "Out of Memory");
return LDB_ERR_OPERATIONS_ERROR;
req->operation = LDB_SEQUENCE_NUMBER;
req->controls = NULL;
req->context = NULL;
- req->callback = NULL;
+ req->callback = ldb_op_default_callback;
ldb_set_timeout(ldb, req, 0); /* use default timeout */
req->op.seq_num.type = type;
* exploded_dn control is used */
dn->special = true;
/* FIXME: add a GUID string to ldb_dn structure */
- } else if (strdn->length >= 8 && strncasecmp((const char *)strdn->data, "<SID=", 8) == 0) {
+ } else if (strdn->length >= 5 && strncasecmp((const char *)strdn->data, "<SID=", 5) == 0) {
/* this is special DN returned when the
* exploded_dn control is used */
dn->special = true;
* exploded_dn control is used */
dn->special = true;
/* FIXME: add a GUID string to ldb_dn structure */
- } else if (strncasecmp(strdn, "<SID=", 8) == 0) {
+ } else if (strncasecmp(strdn, "<SID=", 5) == 0) {
/* this is special DN returned when the
* exploded_dn control is used */
dn->special = true;
/*
ldb database library
- Copyright (C) Simo Sorce 2004
+ Copyright (C) Simo Sorce 2004-2008
** NOTE! The following LGPL license applies to the ldb
** library. This does NOT imply that all of Samba is released
return -1;
}
- ret = ldb_search_exp_fmt(ldb, mods_dn, &res, mods_dn, LDB_SCOPE_BASE, attrs, "@LIST=*");
+ ret = ldb_search(ldb, mods_dn, &res, mods_dn, LDB_SCOPE_BASE, attrs, "@LIST=*");
if (ret == LDB_ERR_NO_SUCH_OBJECT) {
ldb_debug(ldb, LDB_DEBUG_TRACE, "no modules required by the db");
int ldb_next_request(struct ldb_module *module, struct ldb_request *request)
{
int ret;
+
+ if (request->callback == NULL) {
+ ldb_set_errstring(module->ldb, "Requests MUST define callbacks");
+ return LDB_ERR_UNWILLING_TO_PERFORM;
+ }
+
switch (request->operation) {
case LDB_SEARCH:
FIND_OP(module, search);
return module->ops->del_transaction(module);
}
+struct ldb_handle *ldb_handle_new(TALLOC_CTX *mem_ctx, struct ldb_context *ldb)
+{
+ struct ldb_handle *h;
+
+ h = talloc_zero(mem_ctx, struct ldb_handle);
+ if (h == NULL) {
+ ldb_set_errstring(ldb, "Out of Memory");
+ return NULL;
+ }
+
+ h->status = LDB_SUCCESS;
+ h->state = LDB_ASYNC_INIT;
+ h->ldb = ldb;
+
+ return h;
+}
+
+/* calls the request callback to send an entry
+ *
+ * params:
+ * req: the original request passed to your module
+ * msg: reply message (must be a talloc pointer, and it will be stolen
+ * on the ldb_reply that is sent to the callback)
+ */
+
+int ldb_module_send_entry(struct ldb_request *req,
+ struct ldb_message *msg)
+{
+ struct ldb_reply *ares;
+
+ ares = talloc_zero(req, struct ldb_reply);
+ if (!ares) {
+ ldb_oom(req->handle->ldb);
+ req->callback(req, NULL);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ ares->type = LDB_REPLY_ENTRY;
+ ares->message = talloc_steal(ares, msg);
+ ares->error = LDB_SUCCESS;
+
+ return req->callback(req, ares);
+}
+
+/* calls the request callback to send an referrals
+ *
+ * params:
+ * req: the original request passed to your module
+ * ref: referral string (must be a talloc pointeri, steal)
+ */
+
+int ldb_module_send_referral(struct ldb_request *req,
+ char *ref)
+{
+ struct ldb_reply *ares;
+
+ ares = talloc_zero(req, struct ldb_reply);
+ if (!ares) {
+ ldb_oom(req->handle->ldb);
+ req->callback(req, NULL);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ ares->type = LDB_REPLY_REFERRAL;
+ ares->referral = talloc_steal(ares, ref);
+ ares->error = LDB_SUCCESS;
+
+ return req->callback(req, ares);
+}
+
+/* calls the original request callback
+ *
+ * params:
+ * req: the original request passed to your module
+ * ctrls: controls to send in the reply (must be a talloc pointer, steal)
+ * response: results for extended request (steal)
+ * error: LDB_SUCCESS for a succesful return
+ * any other ldb error otherwise
+ */
+int ldb_module_done(struct ldb_request *req,
+ struct ldb_control **ctrls,
+ struct ldb_extended *response,
+ int error)
+{
+ struct ldb_reply *ares;
+
+ ares = talloc_zero(req, struct ldb_reply);
+ if (!ares) {
+ ldb_oom(req->handle->ldb);
+ req->callback(req, NULL);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ ares->type = LDB_REPLY_DONE;
+ ares->controls = talloc_steal(ares, ctrls);
+ ares->response = talloc_steal(ares, response);
+ ares->error = error;
+
+ req->callback(req, ares);
+ return error;
+}
+
+/* to be used *only* in modules init functions.
+ * this function i synchronous and will register
+ * the requested OID in the rootdse module if present
+ * otherwise it will return an error */
+int ldb_mod_register_control(struct ldb_module *module, const char *oid)
+{
+ struct ldb_request *req;
+ int ret;
+
+ req = talloc_zero(module, struct ldb_request);
+ if (req == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ req->operation = LDB_REQ_REGISTER_CONTROL;
+ req->op.reg_control.oid = oid;
+ req->callback = ldb_op_default_callback;
+
+ ldb_set_timeout(module->ldb, req, 0);
+
+ req->handle = ldb_handle_new(req, module->ldb);
+ if (req->handle == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ ret = ldb_request(module->ldb, req);
+ if (ret == LDB_SUCCESS) {
+ ret = ldb_wait(req->handle, LDB_WAIT_ALL);
+ }
+ talloc_free(req);
+
+ return ret;
+}
+
#ifndef STATIC_LIBLDB_MODULES
#ifdef HAVE_LDB_LDAP
TESTS=""
EXTRA_OBJ=""
+m4_include(build_macros.m4)
+BUILD_WITH_SHARED_BUILD_DIR
+
+m4_include(pkg.m4)
m4_include(libpopt.m4)
m4_include(libtalloc.m4)
m4_include(libtdb.m4)
quite fine grained results with the LDAP search syntax, however it is a bit
confusing to start with. See RFC2254.
*/
- if (LDB_SUCCESS != ldb_search(ldb, NULL, LDB_SCOPE_DEFAULT,
- expression, NULL, &resultMsg) ) {
+ if (LDB_SUCCESS != ldb_search(ldb, ldb, &resultMsg,
+ NULL, LDB_SCOPE_DEFAULT, NULL,
+ "%s", expression)) {
printf("Problem in search\n");
exit(-1);
}
-m4_include(pkg.m4)
-EVENTS_OBJ=""
AC_SUBST(EVENTS_OBJ)
-PKG_CHECK_MODULES(EVENTS, events)
+AC_SUBST(EVENTS_CFLAGS)
+AC_SUBST(EVENTS_LIBS)
+
+AC_CHECK_HEADER(events.h,
+ [AC_CHECK_LIB(events, event_context_init, [EVENTS_LIBS="-levents"]) ],
+ [PKG_CHECK_MODULES(EVENTS, events)])
-m4_include(pkg.m4)
-TALLOC_OBJ=""
AC_SUBST(TALLOC_OBJ)
-PKG_CHECK_MODULES(TALLOC, talloc)
+AC_SUBST(TALLOC_CFLAGS)
+AC_SUBST(TALLOC_LIBS)
+
+AC_CHECK_HEADER(talloc.h,
+ [AC_CHECK_LIB(talloc, talloc_init, [TALLOC_LIBS="-ltalloc"]) ],
+ [PKG_CHECK_MODULES(TALLOC, talloc)])
-m4_include(pkg.m4)
-TDB_OBJ=""
AC_SUBST(TDB_OBJ)
-PKG_CHECK_MODULES(TDB, tdb >= 1.1.0)
+AC_SUBST(TDB_CFLAGS)
+AC_SUBST(TDB_LIBS)
+
+AC_CHECK_HEADER(tdb.h,
+ [AC_CHECK_LIB(tdb, tdb_open, [TDB_LIBS="-ltdb"]) ],
+ [PKG_CHECK_MODULES(TDB, tdb >= 1.1.0)])
LDB_SCOPE_SUBTREE=2};
struct ldb_context;
+struct event_context;
/* debugging uses one of the following levels */
enum ldb_debug_level {LDB_DEBUG_FATAL, LDB_DEBUG_ERROR,
enum ldb_reply_type {
LDB_REPLY_ENTRY,
LDB_REPLY_REFERRAL,
- LDB_REPLY_EXTENDED,
LDB_REPLY_DONE
};
struct ldb_extended *response;
char *referral;
struct ldb_control **controls;
+ int error;
};
-struct ldb_handle {
- int status;
- enum ldb_state state;
- void *private_data;
- struct ldb_module *module;
-};
+struct ldb_request;
+struct ldb_handle;
struct ldb_search {
struct ldb_dn *base;
uint32_t flags;
};
-typedef int (*ldb_request_callback_t)(struct ldb_context *, void *, struct ldb_reply *);
+typedef int (*ldb_request_callback_t)(struct ldb_request *, struct ldb_reply *);
+
struct ldb_request {
enum ldb_request_type operation;
};
int ldb_request(struct ldb_context *ldb, struct ldb_request *request);
+int ldb_request_done(struct ldb_request *req, int status);
+bool ldb_request_is_done(struct ldb_request *req);
+int ldb_modules_wait(struct ldb_handle *handle);
int ldb_wait(struct ldb_handle *handle, enum ldb_wait_type type);
int ldb_set_timeout(struct ldb_context *ldb, struct ldb_request *req, int timeout);
(that is, with LDB_FLG_RDONLY). However in read-write mode, the database will be
created if it does not exist.
*/
+
+typedef void (*ldb_async_timeout_fn) (void *);
+typedef bool (*ldb_async_callback_fn) (void *);
+typedef int (*ldb_async_ctx_add_op_fn)(void *, time_t, void *, ldb_async_timeout_fn, ldb_async_callback_fn);
+typedef int (*ldb_async_ctx_wait_op_fn)(void *);
+
+void ldb_async_ctx_set_private_data(struct ldb_context *ldb,
+ void *private_data);
+void ldb_async_ctx_set_add_op(struct ldb_context *ldb,
+ ldb_async_ctx_add_op_fn add_op);
+void ldb_async_ctx_set_wait_op(struct ldb_context *ldb,
+ ldb_async_ctx_wait_op_fn wait_op);
+
int ldb_connect(struct ldb_context *ldb, const char *url, unsigned int flags, const char *options[]);
/*
/**
The default async search callback function
- \param ldb the context associated with the database (from ldb_init())
- \param context the callback context (struct ldb_result *)
+ \param req the request we are callback of
\param ares a single reply from the async core
\return result code (LDB_SUCCESS on success, or a failure code)
- \note this function expects the context to always be an struct ldb_result pointer
+ \note this function expects req->context to always be an struct ldb_result pointer
AND a talloc context, this function will steal on the context each message
from the ares reply passed on by the async core so that in the end all the
messages will be in the context (ldb_result) memory tree.
request that can be freed as sson as the search request is finished)
*/
-int ldb_search_default_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares);
+int ldb_search_default_callback(struct ldb_request *req, struct ldb_reply *ares);
+
+/**
+ The default async extended operation callback function
+
+ \param req the request we are callback of
+ \param ares a single reply from the async core
+
+ \return result code (LDB_SUCCESS on success, or a failure code)
+*/
+int ldb_op_default_callback(struct ldb_request *req, struct ldb_reply *ares);
+
/**
Helper function to build a search request
\param attrs the search attributes for the query (pass NULL if none required)
\param controls an array of controls
\param context the callback function context
- \param callback the callback function to handle the async replies
+ \param the callback function to handle the async replies
+ \param the parent request if any
\return result code (LDB_SUCCESS on success, or a failure code)
*/
const char * const *attrs,
struct ldb_control **controls,
void *context,
- ldb_request_callback_t callback);
+ ldb_request_callback_t callback,
+ struct ldb_request *parent);
+
+int ldb_build_search_req_ex(struct ldb_request **ret_req,
+ struct ldb_context *ldb,
+ TALLOC_CTX *mem_ctx,
+ struct ldb_dn *base,
+ enum ldb_scope scope,
+ struct ldb_parse_tree *tree,
+ const char * const *attrs,
+ struct ldb_control **controls,
+ void *context,
+ ldb_request_callback_t callback,
+ struct ldb_request *parent);
/**
Helper function to build an add request
\param message contains the entry to be added
\param controls an array of controls
\param context the callback function context
- \param callback the callback function to handle the async replies
+ \param the callback function to handle the async replies
+ \param the parent request if any
\return result code (LDB_SUCCESS on success, or a failure code)
*/
const struct ldb_message *message,
struct ldb_control **controls,
void *context,
- ldb_request_callback_t callback);
+ ldb_request_callback_t callback,
+ struct ldb_request *parent);
/**
Helper function to build a modify request
\param message contains the entry to be modified
\param controls an array of controls
\param context the callback function context
- \param callback the callback function to handle the async replies
+ \param the callback function to handle the async replies
+ \param the parent request if any
\return result code (LDB_SUCCESS on success, or a failure code)
*/
const struct ldb_message *message,
struct ldb_control **controls,
void *context,
- ldb_request_callback_t callback);
+ ldb_request_callback_t callback,
+ struct ldb_request *parent);
/**
Helper function to build a delete request
\param dn the DN to be deleted
\param controls an array of controls
\param context the callback function context
- \param callback the callback function to handle the async replies
+ \param the callback function to handle the async replies
+ \param the parent request if any
\return result code (LDB_SUCCESS on success, or a failure code)
*/
struct ldb_dn *dn,
struct ldb_control **controls,
void *context,
- ldb_request_callback_t callback);
+ ldb_request_callback_t callback,
+ struct ldb_request *parent);
/**
Helper function to build a rename request
\param newdn the new DN
\param controls an array of controls
\param context the callback function context
- \param callback the callback function to handle the async replies
+ \param the callback function to handle the async replies
+ \param the parent request if any
\return result code (LDB_SUCCESS on success, or a failure code)
*/
struct ldb_dn *newdn,
struct ldb_control **controls,
void *context,
- ldb_request_callback_t callback);
+ ldb_request_callback_t callback,
+ struct ldb_request *parent);
/**
Add a ldb_control to a ldb_request
records that match an LDAP-like search expression
\param ldb the context associated with the database (from ldb_init())
+ \param mem_ctx the memory context to use for the request and the results
+ \param result the return result
\param base the Base Distinguished Name for the query (use ldb_dn_new() for an empty one)
\param scope the search scope for the query
- \param expression the search expression to use for this query
\param attrs the search attributes for the query (pass NULL if none required)
- \param res the return result
+ \param exp_fmt the search expression to use for this query (printf like)
\return result code (LDB_SUCCESS on success, or a failure code)
\note use talloc_free() to free the ldb_result returned
*/
-int ldb_search(struct ldb_context *ldb,
- struct ldb_dn *base,
- enum ldb_scope scope,
- const char *expression,
- const char * const *attrs, struct ldb_result **res);
-
-/*
- * a useful search function where you can easily define the expression and
- * that takes a memory context where results are allocated
-*/
-
-int ldb_search_exp_fmt(struct ldb_context *ldb, TALLOC_CTX *mem_ctx,
- struct ldb_result **result, struct ldb_dn *base,
- enum ldb_scope scope, const char * const *attrs,
- const char *exp_fmt, ...) PRINTF_ATTRIBUTE(7,8);
+int ldb_search(struct ldb_context *ldb, TALLOC_CTX *mem_ctx,
+ struct ldb_result **result, struct ldb_dn *base,
+ enum ldb_scope scope, const char * const *attrs,
+ const char *exp_fmt, ...) PRINTF_ATTRIBUTE(7,8);
/**
Add a record to the database.
/**
The default async extended operation callback function
- \param ldb the context associated with the database (from ldb_init())
- \param context the callback context (struct ldb_result *)
+ \param req the request we are callback of
\param ares a single reply from the async core
\return result code (LDB_SUCCESS on success, or a failure code)
- \note this function expects the context to always be an struct ldb_result pointer
+ \note this function expects req->context to always be an struct ldb_result pointer
AND a talloc context, this function will steal on the context each message
from the ares reply passed on by the async core so that in the end all the
messages will be in the context (ldb_result) memory tree.
(the request need to be freed separately and the result doe not depend on the
request that can be freed as sson as the search request is finished)
*/
-int ldb_extended_default_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares);
+
+int ldb_extended_default_callback(struct ldb_request *req, struct ldb_reply *ares);
+
/**
Helper function to build a extended request
it needs to be NULL or a valid talloc pointer! talloc_get_type() will be used on it
\param controls an array of controls
\param context the callback function context
- \param callback the callback function to handle the async replies
+ \param the callback function to handle the async replies
+ \param the parent request if any
\return result code (LDB_SUCCESS on success, or a failure code)
*/
void *data,/* NULL or a valid talloc pointer! talloc_get_type() will be used on it */
struct ldb_control **controls,
void *context,
- ldb_request_callback_t callback);
+ ldb_request_callback_t callback,
+ struct ldb_request *parent);
/**
call an extended operation
struct ldb_backend_ops;
+struct ldb_handle {
+ int status;
+ enum ldb_state state;
+ struct ldb_context *ldb;
+};
+
/* basic module structure */
struct ldb_module {
struct ldb_module *prev, *next;
const struct ldb_module_ops *ops;
};
-/*
- these function pointers define the operations that a ldb module must perform
- they correspond exactly to the ldb_*() interface
+/*
+ these function pointers define the operations that a ldb module can intercept
*/
struct ldb_module_ops {
const char *name;
int (*start_transaction)(struct ldb_module *);
int (*end_transaction)(struct ldb_module *);
int (*del_transaction)(struct ldb_module *);
- int (*wait)(struct ldb_handle *, enum ldb_wait_type);
int (*sequence_number)(struct ldb_module *, struct ldb_request *);
+ void *private_data;
};
-
-typedef int (*ldb_connect_fn) (struct ldb_context *ldb, const char *url, unsigned int flags, const char *options[],
- struct ldb_module **module);
-
-
-struct ldb_backend_ops {
- const char *name;
- ldb_connect_fn connect_fn;
-};
-
-const char *ldb_default_modules_dir(void);
-
/*
schema related information needed for matching rules
*/
struct ldb_module **backend_module);
void ldb_set_default_dns(struct ldb_context *ldb);
-/* The following definitions come from lib/ldb/common/ldb_modules.c */
-
-const char **ldb_modules_list_from_string(struct ldb_context *ldb, TALLOC_CTX *mem_ctx, const char *string);
-int ldb_load_modules_list(struct ldb_context *ldb, const char **module_list, struct ldb_module *backend, struct ldb_module **out);
-int ldb_load_modules(struct ldb_context *ldb, const char *options[]);
-int ldb_init_module_chain(struct ldb_context *ldb, struct ldb_module *module);
-int ldb_next_request(struct ldb_module *module, struct ldb_request *request);
-int ldb_next_start_trans(struct ldb_module *module);
-int ldb_next_end_trans(struct ldb_module *module);
-int ldb_next_del_trans(struct ldb_module *module);
-int ldb_next_init(struct ldb_module *module);
-
-void ldb_set_errstring(struct ldb_context *ldb, const char *err_string);
-void ldb_asprintf_errstring(struct ldb_context *ldb, const char *format, ...) PRINTF_ATTRIBUTE(2,3);
-void ldb_reset_err_string(struct ldb_context *ldb);
-
-int ldb_register_module(const struct ldb_module_ops *);
-int ldb_register_backend(const char *url_prefix, ldb_connect_fn);
-void *ldb_dso_load_symbol(struct ldb_context *ldb, const char *name,
- const char *symbol);
-
/* The following definitions come from lib/ldb/common/ldb_debug.c */
void ldb_debug(struct ldb_context *ldb, enum ldb_debug_level level, const char *fmt, ...) PRINTF_ATTRIBUTE(3, 4);
void ldb_debug_set(struct ldb_context *ldb, enum ldb_debug_level level,
#define LDB_SEQ_TIMESTAMP_SEQUENCE 0x02
+/* MODULES specific headers -- SSS */
+
+/* The following definitions come from lib/ldb/common/ldb_modules.c */
+
+const char **ldb_modules_list_from_string(struct ldb_context *ldb, TALLOC_CTX *mem_ctx, const char *string);
+int ldb_load_modules_list(struct ldb_context *ldb, const char **module_list, struct ldb_module *backend, struct ldb_module **out);
+int ldb_load_modules(struct ldb_context *ldb, const char *options[]);
+int ldb_init_module_chain(struct ldb_context *ldb, struct ldb_module *module);
+int ldb_next_request(struct ldb_module *module, struct ldb_request *request);
+int ldb_next_start_trans(struct ldb_module *module);
+int ldb_next_end_trans(struct ldb_module *module);
+int ldb_next_del_trans(struct ldb_module *module);
+int ldb_next_init(struct ldb_module *module);
+
+void ldb_set_errstring(struct ldb_context *ldb, const char *err_string);
+void ldb_asprintf_errstring(struct ldb_context *ldb, const char *format, ...) PRINTF_ATTRIBUTE(2,3);
+void ldb_reset_err_string(struct ldb_context *ldb);
+
+const char *ldb_default_modules_dir(void);
+
+int ldb_register_module(const struct ldb_module_ops *);
+
+typedef int (*ldb_connect_fn)(struct ldb_context *ldb, const char *url,
+ unsigned int flags, const char *options[],
+ struct ldb_module **module);
+
+struct ldb_backend_ops {
+ const char *name;
+ ldb_connect_fn connect_fn;
+};
+
+const char *ldb_default_modules_dir(void);
+
+int ldb_register_backend(const char *url_prefix, ldb_connect_fn);
+
+void *ldb_dso_load_symbol(struct ldb_context *ldb, const char *name,
+ const char *symbol);
+
+struct ldb_handle *ldb_handle_new(TALLOC_CTX *mem_ctx, struct ldb_context *ldb);
+
+int ldb_module_send_entry(struct ldb_request *req,
+ struct ldb_message *msg);
+
+int ldb_module_send_referral(struct ldb_request *req,
+ char *ref);
+
+int ldb_module_done(struct ldb_request *req,
+ struct ldb_control **ctrls,
+ struct ldb_extended *response,
+ int error);
+
+int ldb_mod_register_control(struct ldb_module *module, const char *oid);
+
#endif
typedef struct ldb_dn ldb_dn;
typedef struct ldb_ldif ldb_ldif;
typedef struct ldb_message_element ldb_message_element;
+typedef struct ldb_module ldb_module;
typedef int ldb_error;
typedef int ldb_int_error;
* Wrap struct ldb_result
*/
-%typemap(in,noblock=1,numinputs=0) struct ldb_result **OUT (struct ldb_result *temp_ldb_result) {
+%typemap(in,noblock=1,numinputs=0) struct ldb_result ** (struct ldb_result *temp_ldb_result) {
$1 = &temp_ldb_result;
}
#ifdef SWIGPYTHON
%typemap(argout,noblock=1) struct ldb_result ** (int i) {
- $result = PyList_New((*$1)->count);
- for (i = 0; i < (*$1)->count; i++) {
- PyList_SetItem($result, i,
- SWIG_NewPointerObj((*$1)->msgs[i], SWIGTYPE_p_ldb_message, 0)
- );
+ if ($1 == NULL) {
+ $result = Py_None;
+ } else {
+ $result = PyList_New((*$1)->count);
+ for (i = 0; i < (*$1)->count; i++) {
+ PyList_SetItem($result, i,
+ SWIG_NewPointerObj((*$1)->msgs[i], SWIGTYPE_p_ldb_message, 0)
+ );
+ }
}
}
#endif
-%types(struct ldb_result *);
+%types(struct ldb_result *, struct ldb_parse_tree *);
/*
* Wrap struct ldb_dn
/* Top-level ldb operations */
typedef struct ldb_context {
+ %rename(firstmodule) modules;
+ struct ldb_module *modules;
+
+ %pythoncode {
+ def itermodules(self):
+ m = self.firstmodule
+ while m is not None:
+ yield m
+ m = m.next
+
+ def modules(self):
+ return list(self.itermodules())
+ }
+
%extend {
ldb(void) {
return ldb_init(NULL, event_context_init(NULL));
attrs,
controls,
res,
- ldb_search_default_callback);
+ ldb_search_default_callback,
+ NULL);
if (ret != LDB_SUCCESS) {
talloc_free(res);
return ret;
}
- ldb_set_timeout($self, req, 0); /* use default timeout */
-
ret = ldb_request($self, req);
if (ret == LDB_SUCCESS) {
%typemap(freearg,noblock=1) struct ldb_result **result_as_bool { talloc_free(*$1); }
ldb_error __contains__(ldb_dn *dn, struct ldb_result **result_as_bool)
{
- return ldb_search($self, dn, LDB_SCOPE_BASE, NULL, NULL,
- result_as_bool);
+ return ldb_search($self, $self, result_as_bool, dn, LDB_SCOPE_BASE, NULL, NULL);
}
%feature("docstring") parse_ldif "S.parse_ldif(ldif) -> iter(messages)\n" \
"Parse a LDAP time string into a UNIX timestamp.";
time_t ldb_string_to_time(const char *s);
+typedef struct ldb_module {
+ struct ldb_module *prev, *next;
+
+ %extend {
+#ifdef SWIGPYTHON
+ const char *__str__() {
+ return $self->ops->name;
+ }
+ char *__repr__() {
+ char *ret;
+ asprintf(&ret, "<ldb module '%s'>", $self->ops->name);
+ return ret;
+ }
+#endif
+ int search(struct ldb_dn *base, enum ldb_scope scope, struct ldb_parse_tree *tree, const char * const * attrs, struct ldb_result **res) {
+ int ret;
+ struct ldb_request *req = talloc_zero(NULL, struct ldb_request);
+
+ req->operation = LDB_SEARCH;
+ req->op.search.base = base;
+ req->op.search.scope = scope;
+ req->op.search.tree = tree;
+ req->op.search.attrs = attrs;
+
+ req->op.search.res = talloc_zero(NULL, struct ldb_result);
+
+ ret = $self->ops->search($self, req);
+
+ *res = req->op.search.res;
+
+ talloc_free(req);
+
+ return ret;
+ }
+ ldb_error add(struct ldb_message *message) {
+ struct ldb_request *req = talloc_zero(NULL, struct ldb_request);
+ req->operation = LDB_ADD;
+ req->op.add.message = message;
+
+ return $self->ops->add($self, &req);
+ }
+ ldb_error modify(struct ldb_message *message) {
+ struct ldb_request *req = talloc_zero(NULL, struct ldb_request);
+ req->operation = LDB_MODIFY;
+ req->op.mod.message = message;
+
+ return $self->ops->modify($self, &req);
+ }
+ ldb_error delete(struct ldb_dn *dn) {
+ struct ldb_request *req = talloc_zero(NULL, struct ldb_request);
+ req->operation = LDB_DELETE;
+ req->op.del.dn = dn;
+
+ return $self->ops->del($self, &req);
+
+ }
+ ldb_error rename(struct ldb_dn *olddn, struct ldb_dn *newdn) {
+ struct ldb_request *req = talloc_zero(NULL, struct ldb_request);
+ req->operation = LDB_RENAME;
+ req->op.rename.olddn = olddn;
+ req->op.rename.olddn = newdn;
+
+ return $self->ops->rename($self, &req);
+ }
+ ldb_error start_transaction() {
+ return $self->ops->start_transaction($self);
+ }
+ ldb_error end_transaction() {
+ return $self->ops->end_transaction($self);
+ }
+ ldb_error del_transaction() {
+ return $self->ops->del_transaction($self);
+ }
+ }
+} ldb_module;
+
+%{
+int py_module_search(struct ldb_module *mod, struct ldb_request *req)
+{
+ PyObject *py_ldb = mod->private_data;
+ PyObject *py_result, *py_base, *py_attrs, *py_tree;
+
+ py_base = SWIG_NewPointerObj(req->op.search.base, SWIGTYPE_p_ldb_dn, 0);
+
+ if (py_base == NULL)
+ return LDB_ERR_OPERATIONS_ERROR;
+
+ py_tree = SWIG_NewPointerObj(req->op.search.tree, SWIGTYPE_p_ldb_parse_tree, 0);
+
+ if (py_tree == NULL)
+ return LDB_ERR_OPERATIONS_ERROR;
+
+ if (req->op.search.attrs == NULL) {
+ py_attrs = Py_None;
+ } else {
+ int i, len;
+ for (len = 0; req->op.search.attrs[len]; len++);
+ py_attrs = PyList_New(len);
+ for (i = 0; i < len; i++)
+ PyList_SetItem(py_attrs, i, PyString_FromString(req->op.search.attrs[i]));
+ }
+
+ py_result = PyObject_CallMethod(py_ldb, "search", "OiOO", py_base, req->op.search.scope, py_tree, py_attrs);
+
+ Py_DECREF(py_attrs);
+ Py_DECREF(py_tree);
+ Py_DECREF(py_base);
+
+ if (py_result == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ if (SWIG_ConvertPtr(py_result, &req->op.search.res, SWIGTYPE_p_ldb_result, 0) != 0) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ Py_DECREF(py_result);
+
+ return LDB_SUCCESS;
+}
+
+int py_module_add(struct ldb_module *mod, struct ldb_request *req)
+{
+ PyObject *py_ldb = mod->private_data;
+ PyObject *py_result, *py_msg;
+
+ py_msg = SWIG_NewPointerObj(req->op.add.message, SWIGTYPE_p_ldb_message, 0);
+
+ if (py_msg == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ py_result = PyObject_CallMethod(py_ldb, "add", "O", py_msg);
+
+ Py_DECREF(py_msg);
+
+ if (py_result == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ Py_DECREF(py_result);
+
+ return LDB_SUCCESS;
+}
+
+int py_module_modify(struct ldb_module *mod, struct ldb_request *req)
+{
+ PyObject *py_ldb = mod->private_data;
+ PyObject *py_result, *py_msg;
+
+ py_msg = SWIG_NewPointerObj(req->op.mod.message, SWIGTYPE_p_ldb_message, 0);
+
+ if (py_msg == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ py_result = PyObject_CallMethod(py_ldb, "modify", "O", py_msg);
+
+ Py_DECREF(py_msg);
+
+ if (py_result == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ Py_DECREF(py_result);
+
+ return LDB_SUCCESS;
+}
+
+int py_module_del(struct ldb_module *mod, struct ldb_request *req)
+{
+ PyObject *py_ldb = mod->private_data;
+ PyObject *py_result, *py_dn;
+
+ py_dn = SWIG_NewPointerObj(req->op.del.dn, SWIGTYPE_p_ldb_dn, 0);
+
+ if (py_dn == NULL)
+ return LDB_ERR_OPERATIONS_ERROR;
+
+ py_result = PyObject_CallMethod(py_ldb, "delete", "O", py_dn);
+
+ if (py_result == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ Py_DECREF(py_result);
+
+ return LDB_SUCCESS;
+}
+
+int py_module_rename(struct ldb_module *mod, struct ldb_request *req)
+{
+ PyObject *py_ldb = mod->private_data;
+ PyObject *py_result, *py_olddn, *py_newdn;
+
+ py_olddn = SWIG_NewPointerObj(req->op.rename.olddn, SWIGTYPE_p_ldb_dn, 0);
+
+ if (py_olddn == NULL)
+ return LDB_ERR_OPERATIONS_ERROR;
+
+ py_newdn = SWIG_NewPointerObj(req->op.rename.newdn, SWIGTYPE_p_ldb_dn, 0);
+
+ if (py_newdn == NULL)
+ return LDB_ERR_OPERATIONS_ERROR;
+
+ py_result = PyObject_CallMethod(py_ldb, "rename", "OO", py_olddn, py_newdn);
+
+ Py_DECREF(py_olddn);
+ Py_DECREF(py_newdn);
+
+ if (py_result == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ Py_DECREF(py_result);
+
+ return LDB_SUCCESS;
+}
+
+int py_module_request(struct ldb_module *mod, struct ldb_request *req)
+{
+ PyObject *py_ldb = mod->private_data;
+ PyObject *py_result;
+
+ py_result = PyObject_CallMethod(py_ldb, "request", "");
+
+ return LDB_ERR_OPERATIONS_ERROR;
+}
+
+int py_module_extended(struct ldb_module *mod, struct ldb_request *req)
+{
+ PyObject *py_ldb = mod->private_data;
+ PyObject *py_result;
+
+ py_result = PyObject_CallMethod(py_ldb, "extended", "");
+
+ return LDB_ERR_OPERATIONS_ERROR;
+}
+
+int py_module_start_transaction(struct ldb_module *mod)
+{
+ PyObject *py_ldb = mod->private_data;
+ PyObject *py_result;
+
+ py_result = PyObject_CallMethod(py_ldb, "start_transaction", "");
+
+ if (py_result == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ Py_DECREF(py_result);
+
+ return LDB_SUCCESS;
+}
+
+int py_module_end_transaction(struct ldb_module *mod)
+{
+ PyObject *py_ldb = mod->private_data;
+ PyObject *py_result;
+
+ py_result = PyObject_CallMethod(py_ldb, "end_transaction", "");
+
+ if (py_result == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ Py_DECREF(py_result);
+
+ return LDB_SUCCESS;
+}
+
+int py_module_del_transaction(struct ldb_module *mod)
+{
+ PyObject *py_ldb = mod->private_data;
+ PyObject *py_result;
+
+ py_result = PyObject_CallMethod(py_ldb, "del_transaction", "");
+
+ if (py_result == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ Py_DECREF(py_result);
+
+ return LDB_SUCCESS;
+}
+
+int py_module_sequence_number(struct ldb_module *mod, struct ldb_request *req)
+{
+ PyObject *py_ldb = mod->private_data;
+ PyObject *py_result;
+ int ret;
+
+ py_result = PyObject_CallMethod(py_ldb, "sequence_number", "ili", req->op.seq_num.type, req->op.seq_num.seq_num, req->op.seq_num.flags);
+
+ if (py_result == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ ret = PyInt_AsLong(py_result);
+
+ Py_DECREF(py_result);
+
+ return ret;
+}
+
+static int py_module_destructor(void *_mod)
+{
+ struct ldb_module *mod = _mod;
+ Py_DECREF((PyObject *)mod->private_data);
+ return 0;
+}
+
+int py_module_init (struct ldb_module *mod)
+{
+ PyObject *py_class = mod->ops->private_data;
+ PyObject *py_result, *py_next, *py_ldb;
+
+ py_ldb = SWIG_NewPointerObj(mod->ldb, SWIGTYPE_p_ldb_context, 0);
+
+ if (py_ldb == NULL)
+ return LDB_ERR_OPERATIONS_ERROR;
+
+ py_next = SWIG_NewPointerObj(mod->next, SWIGTYPE_p_ldb_module, 0);
+
+ if (py_next == NULL)
+ return LDB_ERR_OPERATIONS_ERROR;
+
+ py_result = PyObject_CallFunction(py_class, "OO", py_ldb, py_next);
+
+ if (py_result == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ mod->private_data = py_result;
+
+ talloc_set_destructor (mod, py_module_destructor);
+
+ return ldb_next_init(mod);
+}
+%}
+
%typemap(in,noblock=1) const struct ldb_module_ops * {
$1 = talloc_zero(talloc_autofree_context(), struct ldb_module_ops);
- $1->name = (char *)PyObject_GetAttrString($input, (char *)"name");
+ $1->name = talloc_strdup($1, PyString_AsString(PyObject_GetAttrString($input, (char *)"name")));
+
+ Py_INCREF($input);
+ $1->private_data = $input;
+ $1->init_context = py_module_init;
+ $1->search = py_module_search;
+ $1->add = py_module_add;
+ $1->modify = py_module_modify;
+ $1->del = py_module_del;
+ $1->rename = py_module_rename;
+ $1->request = py_module_request;
+ $1->extended = py_module_extended;
+ $1->start_transaction = py_module_start_transaction;
+ $1->end_transaction = py_module_end_transaction;
+ $1->del_transaction = py_module_del_transaction;
+ $1->sequence_number = py_module_sequence_number;
}
%feature("docstring") ldb_register_module "S.register_module(module) -> None\n"
%pythoncode {
__docformat__ = "restructuredText"
+open = Ldb
}
-LDB_LIB = $(STATICLIB)
+LDB_LIB = -Llib -lldb
-LIB_FLAGS=$(LDFLAGS) -Llib $(LDB_LIB) $(LIBS) $(POPT_LIBS) $(TALLOC_LIBS) \
- $(TDB_LIBS) $(LDAP_LIBS) $(LIBDL)
+LIB_FLAGS=$(LDFLAGS) $(LIBS) $(LDB_LIB) $(POPT_LIBS) $(TALLOC_LIBS) \
+ $(TDB_LIBS) $(EVENTS_LIBS) $(LDAP_LIBS) $(LIBDL)
LDB_TDB_DIR=ldb_tdb
LDB_TDB_OBJ=$(LDB_TDB_DIR)/ldb_tdb.o \
sample.$(SHLIBEXT): tests/sample_module.o
$(MDLD) $(MDLD_FLAGS) -o $@ tests/sample_module.o
-bin/ldbadd: tools/ldbadd.o tools/cmdline.o $(LIBS)
+bin/ldbadd: tools/ldbadd.o tools/cmdline.o
$(CC) -o bin/ldbadd tools/ldbadd.o tools/cmdline.o $(LIB_FLAGS) $(LD_EXPORT_DYNAMIC)
-bin/ldbsearch: tools/ldbsearch.o tools/cmdline.o $(LIBS)
+bin/ldbsearch: tools/ldbsearch.o tools/cmdline.o
$(CC) -o bin/ldbsearch tools/ldbsearch.o tools/cmdline.o $(LIB_FLAGS) $(LD_EXPORT_DYNAMIC)
-bin/ldbdel: tools/ldbdel.o tools/cmdline.o $(LIBS)
+bin/ldbdel: tools/ldbdel.o tools/cmdline.o
$(CC) -o bin/ldbdel tools/ldbdel.o tools/cmdline.o $(LIB_FLAGS) $(LD_EXPORT_DYNAMIC)
-bin/ldbmodify: tools/ldbmodify.o tools/cmdline.o $(LIBS)
+bin/ldbmodify: tools/ldbmodify.o tools/cmdline.o
$(CC) -o bin/ldbmodify tools/ldbmodify.o tools/cmdline.o $(LIB_FLAGS) $(LD_EXPORT_DYNAMIC)
-bin/ldbedit: tools/ldbedit.o tools/cmdline.o $(LIBS)
+bin/ldbedit: tools/ldbedit.o tools/cmdline.o
$(CC) -o bin/ldbedit tools/ldbedit.o tools/cmdline.o $(LIB_FLAGS) $(LD_EXPORT_DYNAMIC)
-bin/ldbrename: tools/ldbrename.o tools/cmdline.o $(LIBS)
+bin/ldbrename: tools/ldbrename.o tools/cmdline.o
$(CC) -o bin/ldbrename tools/ldbrename.o tools/cmdline.o $(LIB_FLAGS) $(LD_EXPORT_DYNAMIC)
-bin/ldbtest: tools/ldbtest.o tools/cmdline.o $(LIBS)
+bin/ldbtest: tools/ldbtest.o tools/cmdline.o
$(CC) -o bin/ldbtest tools/ldbtest.o tools/cmdline.o $(LIB_FLAGS) $(LD_EXPORT_DYNAMIC)
-bin/oLschema2ldif: tools/oLschema2ldif.o tools/cmdline.o tools/convert.o $(LIBS)
- $(CC) -o bin/oLschema2ldif tools/oLschema2ldif.o tools/cmdline.o tools/convert.o $(LIB_FLAGS)
-
-examples/ldbreader: examples/ldbreader.o $(LIBS)
+examples/ldbreader: examples/ldbreader.o
$(CC) -o examples/ldbreader examples/ldbreader.o $(LIB_FLAGS)
-examples/ldifreader: examples/ldifreader.o $(LIBS)
+examples/ldifreader: examples/ldifreader.o
$(CC) -o examples/ldifreader examples/ldifreader.o $(LIB_FLAGS)
# Python bindings
ldb_wrap.o: $(ldbdir)/ldb_wrap.c
$(CC) $(PICFLAG) -c $(ldbdir)/ldb_wrap.c $(CFLAGS) `$(PYTHON_CONFIG) --cflags`
-_ldb.$(SHLIBEXT): $(LIBS) ldb_wrap.o
+_ldb.$(SHLIBEXT): ldb_wrap.o
$(SHLD) $(SHLD_FLAGS) -o _ldb.$(SHLIBEXT) ldb_wrap.o $(LIB_FLAGS) `$(PYTHON_CONFIG) --ldflags`
install-python:: build-python
class Ldb(object):
"""Connection to a LDB database."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ firstmodule = _swig_property(_ldb.Ldb_firstmodule_get, _ldb.Ldb_firstmodule_set)
+ def itermodules(self):
+ m = self.firstmodule
+ while m is not None:
+ yield m
+ m = m.next
+
+ def modules(self):
+ return list(self.itermodules())
+
def __init__(self, *args, **kwargs):
_ldb.Ldb_swiginit(self,_ldb.new_Ldb(*args, **kwargs))
def connect(*args, **kwargs):
Parse a LDAP time string into a UNIX timestamp.
"""
return _ldb.string_to_time(*args, **kwargs)
+class ldb_module(object):
+ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ prev = _swig_property(_ldb.ldb_module_prev_get, _ldb.ldb_module_prev_set)
+ next = _swig_property(_ldb.ldb_module_next_get, _ldb.ldb_module_next_set)
+ def __init__(self, *args, **kwargs):
+ _ldb.ldb_module_swiginit(self,_ldb.new_ldb_module(*args, **kwargs))
+ __swig_destroy__ = _ldb.delete_ldb_module
+ldb_module.__str__ = new_instancemethod(_ldb.ldb_module___str__,None,ldb_module)
+ldb_module.__repr__ = new_instancemethod(_ldb.ldb_module___repr__,None,ldb_module)
+ldb_module.search = new_instancemethod(_ldb.ldb_module_search,None,ldb_module)
+ldb_module.add = new_instancemethod(_ldb.ldb_module_add,None,ldb_module)
+ldb_module.modify = new_instancemethod(_ldb.ldb_module_modify,None,ldb_module)
+ldb_module.delete = new_instancemethod(_ldb.ldb_module_delete,None,ldb_module)
+ldb_module.rename = new_instancemethod(_ldb.ldb_module_rename,None,ldb_module)
+ldb_module.start_transaction = new_instancemethod(_ldb.ldb_module_start_transaction,None,ldb_module)
+ldb_module.end_transaction = new_instancemethod(_ldb.ldb_module_end_transaction,None,ldb_module)
+ldb_module.del_transaction = new_instancemethod(_ldb.ldb_module_del_transaction,None,ldb_module)
+ldb_module_swigregister = _ldb.ldb_module_swigregister
+ldb_module_swigregister(ldb_module)
+
def register_module(*args, **kwargs):
"""
"""
return _ldb.register_module(*args, **kwargs)
__docformat__ = "restructuredText"
+open = Ldb
struct ildb_private {
struct ldap_connection *ldap;
- struct ldb_module *module;
+ struct event_context *event_ctx;
};
struct ildb_context {
+ struct ldb_module *module;
+ struct ldb_request *req;
+
struct ildb_private *ildb;
- struct ldb_handle *handle;
- struct ldap_request *req;
- void *context;
- int (*callback)(struct ldb_context *, void *, struct ldb_reply *);
+ struct ldap_request *ireq;
+
+ bool done;
+
+ struct ildb_destructor_ctx *dc;
};
+static void ildb_request_done(struct ildb_context *ctx,
+ struct ldb_control **ctrls, int error)
+{
+ struct ldb_reply *ares;
+
+ ctx->done = true;
+
+ if (ctx->req == NULL) {
+ /* if the req has been freed already just return */
+ return;
+ }
+
+ ares = talloc_zero(ctx->req, struct ldb_reply);
+ if (!ares) {
+ ldb_oom(ctx->req->handle->ldb);
+ ctx->req->callback(ctx->req, NULL);
+ return;
+ }
+ ares->type = LDB_REPLY_DONE;
+ ares->controls = talloc_steal(ares, ctrls);
+ ares->error = error;
+
+ ctx->req->callback(ctx->req, ares);
+}
+
+static void ildb_auto_done_callback(struct event_context *ev,
+ struct timed_event *te,
+ struct timeval t,
+ void *private_data)
+{
+ struct ildb_context *ac;
+
+ ac = talloc_get_type(private_data, struct ildb_context);
+ ildb_request_done(ac, NULL, LDB_SUCCESS);
+}
+
/*
convert a ldb_message structure to a list of ldap_mod structures
ready for ildap_add() or ildap_modify()
/*
map an ildap NTSTATUS to a ldb error code
*/
-static int ildb_map_error(struct ildb_private *ildb, NTSTATUS status)
+static int ildb_map_error(struct ldb_module *module, NTSTATUS status)
{
+ struct ildb_private *ildb = talloc_get_type(module->private_data, struct ildb_private);
+
TALLOC_CTX *mem_ctx = talloc_new(ildb);
if (NT_STATUS_IS_OK(status)) {
return LDB_SUCCESS;
}
if (!mem_ctx) {
- ldb_oom(ildb->module->ldb);
+ ldb_oom(module->ldb);
return LDB_ERR_OPERATIONS_ERROR;
}
- ldb_set_errstring(ildb->module->ldb,
+ ldb_set_errstring(module->ldb,
ldap_errstr(ildb->ldap, mem_ctx, status));
talloc_free(mem_ctx);
if (NT_STATUS_IS_LDAP(status)) {
return LDB_ERR_OPERATIONS_ERROR;
}
-static void ildb_request_timeout(struct event_context *ev,
- struct timed_event *te,
+static void ildb_request_timeout(struct event_context *ev, struct timed_event *te,
struct timeval t, void *private_data)
{
- struct ildb_context *ac;
- struct ldb_handle *handle;
-
- ac = talloc_get_type(private_data, struct ildb_context);
- handle = ac->handle;
-
- ac = talloc_get_type(private_data, struct ildb_context);
+ struct ildb_context *ac = talloc_get_type(private_data, struct ildb_context);
- if (ac->req->state == LDAP_REQUEST_PENDING) {
- DLIST_REMOVE(ac->req->conn->pending, ac->req);
+ if (ac->ireq->state == LDAP_REQUEST_PENDING) {
+ DLIST_REMOVE(ac->ireq->conn->pending, ac->ireq);
}
- handle->status = LDB_ERR_TIME_LIMIT_EXCEEDED;
-
- return;
+ ildb_request_done(ac, NULL, LDB_ERR_TIME_LIMIT_EXCEEDED);
}
static void ildb_callback(struct ldap_request *req)
{
struct ildb_context *ac;
- struct ldb_handle *handle;
- struct ildb_private *ildb;
NTSTATUS status;
+ struct ldap_SearchResEntry *search;
+ struct ldap_message *msg;
+ struct ldb_control **controls;
+ struct ldb_message *ldbmsg;
+ char *referral;
+ bool callback_failed;
+ bool request_done;
+ int ret;
int i;
ac = talloc_get_type(req->async.private_data, struct ildb_context);
- ildb = ac->ildb;
- handle = ac->handle;
- handle->status = LDB_SUCCESS;
+ callback_failed = false;
+ request_done = false;
+ controls = NULL;
if (!NT_STATUS_IS_OK(req->status)) {
- handle->status = ildb_map_error(ildb, req->status);
+ ret = ildb_map_error(ac->module, req->status);
+ ildb_request_done(ac, NULL, ret);
return;
}
if (req->num_replies < 1) {
- handle->status = LDB_ERR_OPERATIONS_ERROR;
+ ret = LDB_ERR_OPERATIONS_ERROR;
+ ildb_request_done(ac, NULL, ret);
return;
}
case LDAP_TAG_ModifyRequest:
if (req->replies[0]->type != LDAP_TAG_ModifyResponse) {
- handle->status = LDB_ERR_PROTOCOL_ERROR;
- return;
+ ret = LDB_ERR_PROTOCOL_ERROR;
+ break;
}
- status = ldap_check_response(req->conn, &req->replies[0]->r.GeneralResult);
- handle->status = ildb_map_error(ildb, status);
- if (ac->callback && handle->status == LDB_SUCCESS) {
- /* FIXME: build a corresponding ares to pass on */
- handle->status = ac->callback(ac->ildb->module->ldb, ac->context, NULL);
- }
- handle->state = LDB_ASYNC_DONE;
+ status = ldap_check_response(ac->ireq->conn, &req->replies[0]->r.GeneralResult);
+ ret = ildb_map_error(ac->module, status);
+ request_done = true;
break;
case LDAP_TAG_AddRequest:
if (req->replies[0]->type != LDAP_TAG_AddResponse) {
- handle->status = LDB_ERR_PROTOCOL_ERROR;
+ ret = LDB_ERR_PROTOCOL_ERROR;
return;
}
- status = ldap_check_response(req->conn, &req->replies[0]->r.GeneralResult);
- handle->status = ildb_map_error(ildb, status);
- if (ac->callback && handle->status == LDB_SUCCESS) {
- /* FIXME: build a corresponding ares to pass on */
- handle->status = ac->callback(ac->ildb->module->ldb, ac->context, NULL);
- }
- handle->state = LDB_ASYNC_DONE;
+ status = ldap_check_response(ac->ireq->conn, &req->replies[0]->r.GeneralResult);
+ ret = ildb_map_error(ac->module, status);
+ request_done = true;
break;
case LDAP_TAG_DelRequest:
if (req->replies[0]->type != LDAP_TAG_DelResponse) {
- handle->status = LDB_ERR_PROTOCOL_ERROR;
+ ret = LDB_ERR_PROTOCOL_ERROR;
return;
}
- status = ldap_check_response(req->conn, &req->replies[0]->r.GeneralResult);
- handle->status = ildb_map_error(ildb, status);
- if (ac->callback && handle->status == LDB_SUCCESS) {
- /* FIXME: build a corresponding ares to pass on */
- handle->status = ac->callback(ac->ildb->module->ldb, ac->context, NULL);
- }
- handle->state = LDB_ASYNC_DONE;
+ status = ldap_check_response(ac->ireq->conn, &req->replies[0]->r.GeneralResult);
+ ret = ildb_map_error(ac->module, status);
+ request_done = true;
break;
case LDAP_TAG_ModifyDNRequest:
if (req->replies[0]->type != LDAP_TAG_ModifyDNResponse) {
- handle->status = LDB_ERR_PROTOCOL_ERROR;
+ ret = LDB_ERR_PROTOCOL_ERROR;
return;
}
- status = ldap_check_response(req->conn, &req->replies[0]->r.GeneralResult);
- handle->status = ildb_map_error(ildb, status);
- if (ac->callback && handle->status == LDB_SUCCESS) {
- /* FIXME: build a corresponding ares to pass on */
- handle->status = ac->callback(ac->ildb->module->ldb, ac->context, NULL);
- }
- handle->state = LDB_ASYNC_DONE;
+ status = ldap_check_response(ac->ireq->conn, &req->replies[0]->r.GeneralResult);
+ ret = ildb_map_error(ac->module, status);
+ request_done = true;
break;
case LDAP_TAG_SearchRequest:
/* loop over all messages */
for (i = 0; i < req->num_replies; i++) {
- struct ldap_SearchResEntry *search;
- struct ldb_reply *ares = NULL;
- struct ldap_message *msg;
- int ret;
-
- ares = talloc_zero(ac, struct ldb_reply);
- if (!ares) {
- handle->status = LDB_ERR_OPERATIONS_ERROR;
- return;
- }
msg = req->replies[i];
switch (msg->type) {
case LDAP_TAG_SearchResultDone:
- status = ldap_check_response(req->conn, &msg->r.GeneralResult);
+ status = ldap_check_response(ac->ireq->conn, &msg->r.GeneralResult);
if (!NT_STATUS_IS_OK(status)) {
- handle->status = ildb_map_error(ildb, status);
- return;
+ ret = ildb_map_error(ac->module, status);
+ break;
}
- ares->controls = talloc_move(ares, &msg->controls);
+ controls = talloc_steal(ac, msg->controls);
if (msg->r.SearchResultDone.resultcode) {
if (msg->r.SearchResultDone.errormessage) {
- ldb_set_errstring(ac->ildb->module->ldb, msg->r.SearchResultDone.errormessage);
+ ldb_set_errstring(ac->module->ldb, msg->r.SearchResultDone.errormessage);
}
}
- handle->status = msg->r.SearchResultDone.resultcode;
- handle->state = LDB_ASYNC_DONE;
- ares->type = LDB_REPLY_DONE;
+ ret = msg->r.SearchResultDone.resultcode;
+ request_done = true;
break;
case LDAP_TAG_SearchResultEntry:
-
- ares->message = ldb_msg_new(ares);
- if (!ares->message) {
- handle->status = LDB_ERR_OPERATIONS_ERROR;
- return;
+ ldbmsg = ldb_msg_new(ac);
+ if (!ldbmsg) {
+ ret = LDB_ERR_OPERATIONS_ERROR;
+ break;
}
search = &(msg->r.SearchResultEntry);
- ares->message->dn = ldb_dn_new(ares->message, ac->ildb->module->ldb, search->dn);
- if ( ! ldb_dn_validate(ares->message->dn)) {
- handle->status = LDB_ERR_OPERATIONS_ERROR;
- return;
+ ldbmsg->dn = ldb_dn_new(ldbmsg, ac->module->ldb, search->dn);
+ if ( ! ldb_dn_validate(ldbmsg->dn)) {
+ ret = LDB_ERR_OPERATIONS_ERROR;
+ break;
}
- ares->message->num_elements = search->num_attributes;
- ares->message->elements = talloc_move(ares->message,
- &search->attributes);
+ ldbmsg->num_elements = search->num_attributes;
+ ldbmsg->elements = talloc_move(ldbmsg, &search->attributes);
- handle->status = LDB_SUCCESS;
- handle->state = LDB_ASYNC_PENDING;
- ares->type = LDB_REPLY_ENTRY;
+ ret = ldb_module_send_entry(ac->req, ldbmsg);
+ if (ret != LDB_SUCCESS) {
+ callback_failed = true;
+ }
break;
case LDAP_TAG_SearchResultReference:
- ares->referral = talloc_strdup(ares, msg->r.SearchResultReference.referral);
+ referral = talloc_strdup(ac, msg->r.SearchResultReference.referral);
- handle->status = LDB_SUCCESS;
- handle->state = LDB_ASYNC_PENDING;
- ares->type = LDB_REPLY_REFERRAL;
+ ret = ldb_module_send_referral(ac->req, referral);
+ if (ret != LDB_SUCCESS) {
+ callback_failed = true;
+ }
break;
default:
/* TAG not handled, fail ! */
- handle->status = LDB_ERR_PROTOCOL_ERROR;
- return;
+ ret = LDB_ERR_PROTOCOL_ERROR;
+ break;
}
- ret = ac->callback(ac->ildb->module->ldb, ac->context, ares);
- if (ret) {
- handle->status = ret;
+ if (ret != LDB_SUCCESS) {
+ break;
}
}
break;
default:
- handle->status = LDB_ERR_PROTOCOL_ERROR;
- return;
+ ret = LDB_ERR_PROTOCOL_ERROR;
+ break;
}
-}
-static struct ildb_context *init_ildb_handle(struct ildb_private *ildb,
- struct ldb_request *req)
-{
- struct ildb_context *ildb_ac;
- struct ldb_handle *h;
+ if (ret != LDB_SUCCESS) {
- h = talloc_zero(req, struct ldb_handle);
- if (h == NULL) {
- ldb_set_errstring(ildb->module->ldb, "Out of Memory");
- return NULL;
+ /* if the callback failed the caller will have freed the
+ * request. Just return and don't try to use it */
+ if ( ! callback_failed) {
+ request_done = true;
+ }
}
- h->module = ildb->module;
-
- ildb_ac = talloc(h, struct ildb_context);
- if (ildb_ac == NULL) {
- ldb_set_errstring(ildb->module->ldb, "Out of Memory");
- talloc_free(h);
- return NULL;
+ if (request_done) {
+ ildb_request_done(ac, controls, ret);
}
-
- h->private_data = ildb_ac;
-
- h->state = LDB_ASYNC_INIT;
- h->status = LDB_SUCCESS;
-
- ildb_ac->ildb = ildb;
- ildb_ac->handle = h;
- ildb_ac->context = req->context;
- ildb_ac->callback = req->callback;
-
- req->handle = h;
- return ildb_ac;
+ return;
}
-static int ildb_request_send(struct ildb_private *ildb, struct ldap_message *msg, struct ldb_request *r)
+static int ildb_request_send(struct ildb_context *ac, struct ldap_message *msg)
{
- struct ildb_context *ildb_ac = init_ildb_handle(ildb, r);
struct ldap_request *req;
- if (!ildb_ac) {
+ if (!ac) {
return LDB_ERR_OPERATIONS_ERROR;
}
- req = ldap_request_send(ildb->ldap, msg);
+ req = ldap_request_send(ac->ildb->ldap, msg);
if (req == NULL) {
- ldb_set_errstring(ildb->module->ldb, "async send request failed");
+ ldb_set_errstring(ac->module->ldb, "async send request failed");
return LDB_ERR_OPERATIONS_ERROR;
}
- ildb_ac->req = talloc_steal(ildb_ac, req);
+ ac->ireq = talloc_steal(ac, req);
- if (!req->conn) {
- ldb_set_errstring(ildb->module->ldb, "connection to remote LDAP server dropped?");
+ if (!ac->ireq->conn) {
+ ldb_set_errstring(ac->module->ldb, "connection to remote LDAP server dropped?");
return LDB_ERR_OPERATIONS_ERROR;
}
talloc_free(req->time_event);
req->time_event = NULL;
- if (r->timeout) {
- req->time_event = event_add_timed(req->conn->event.event_ctx, ildb_ac,
- timeval_current_ofs(r->timeout, 0),
- ildb_request_timeout, ildb_ac);
+ if (ac->req->timeout) {
+ req->time_event = event_add_timed(ac->ildb->event_ctx, ac,
+ timeval_current_ofs(ac->req->timeout, 0),
+ ildb_request_timeout, ac);
}
req->async.fn = ildb_callback;
- req->async.private_data = ildb_ac;
+ req->async.private_data = ac;
return LDB_SUCCESS;
}
-static int ildb_request_noop(struct ildb_private *ildb, struct ldb_request *req)
-{
- struct ildb_context *ildb_ac = init_ildb_handle(ildb, req);
- int ret = LDB_SUCCESS;
-
- if (!ildb_ac) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- if (ildb_ac->callback) {
- ret = ildb_ac->callback(ildb->module->ldb, ildb_ac->context, NULL);
- }
- ildb_ac->handle->state = LDB_ASYNC_DONE;
- return ret;
-}
-
/*
search for matching records using an asynchronous function
*/
-static int ildb_search(struct ldb_module *module, struct ldb_request *req)
+static int ildb_search(struct ildb_context *ac)
{
- struct ildb_private *ildb = talloc_get_type(module->private_data, struct ildb_private);
+ struct ldb_request *req = ac->req;
struct ldap_message *msg;
int n;
- req->handle = NULL;
-
if (!req->callback || !req->context) {
- ldb_set_errstring(module->ldb, "Async interface called with NULL callback function or NULL context");
+ ldb_set_errstring(ac->module->ldb, "Async interface called with NULL callback function or NULL context");
return LDB_ERR_OPERATIONS_ERROR;
}
if (req->op.search.tree == NULL) {
- ldb_set_errstring(module->ldb, "Invalid expression parse tree");
+ ldb_set_errstring(ac->module->ldb, "Invalid expression parse tree");
return LDB_ERR_OPERATIONS_ERROR;
}
msg = new_ldap_message(req);
if (msg == NULL) {
- ldb_set_errstring(module->ldb, "Out of Memory");
+ ldb_set_errstring(ac->module->ldb, "Out of Memory");
return LDB_ERR_OPERATIONS_ERROR;
}
msg->r.SearchRequest.basedn = ldb_dn_alloc_linearized(msg, req->op.search.base);
}
if (msg->r.SearchRequest.basedn == NULL) {
- ldb_set_errstring(module->ldb, "Unable to determine baseDN");
+ ldb_set_errstring(ac->module->ldb, "Unable to determine baseDN");
talloc_free(msg);
return LDB_ERR_OPERATIONS_ERROR;
}
msg->r.SearchRequest.attributes = discard_const(req->op.search.attrs);
msg->controls = req->controls;
- return ildb_request_send(ildb, msg, req);
+ return ildb_request_send(ac, msg);
}
/*
add a record
*/
-static int ildb_add(struct ldb_module *module, struct ldb_request *req)
+static int ildb_add(struct ildb_context *ac)
{
- struct ildb_private *ildb = talloc_get_type(module->private_data, struct ildb_private);
+ struct ldb_request *req = ac->req;
struct ldap_message *msg;
struct ldap_mod **mods;
int i,n;
- req->handle = NULL;
-
- /* ignore ltdb specials */
- if (ldb_dn_is_special(req->op.add.message->dn)) {
- return ildb_request_noop(ildb, req);
- }
-
msg = new_ldap_message(req);
if (msg == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
msg->r.AddRequest.attributes[i] = mods[i]->attrib;
}
- return ildb_request_send(ildb, msg, req);
+ return ildb_request_send(ac, msg);
}
/*
modify a record
*/
-static int ildb_modify(struct ldb_module *module, struct ldb_request *req)
+static int ildb_modify(struct ildb_context *ac)
{
- struct ildb_private *ildb = talloc_get_type(module->private_data, struct ildb_private);
+ struct ldb_request *req = ac->req;
struct ldap_message *msg;
struct ldap_mod **mods;
int i,n;
- req->handle = NULL;
-
- /* ignore ltdb specials */
- if (ldb_dn_is_special(req->op.mod.message->dn)) {
- return ildb_request_noop(ildb, req);
- }
-
msg = new_ldap_message(req);
if (msg == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
msg->r.ModifyRequest.mods[i] = *mods[i];
}
- return ildb_request_send(ildb, msg, req);
+ return ildb_request_send(ac, msg);
}
/*
delete a record
*/
-static int ildb_delete(struct ldb_module *module, struct ldb_request *req)
+static int ildb_delete(struct ildb_context *ac)
{
- struct ildb_private *ildb = talloc_get_type(module->private_data, struct ildb_private);
+ struct ldb_request *req = ac->req;
struct ldap_message *msg;
- req->handle = NULL;
-
- /* ignore ltdb specials */
- if (ldb_dn_is_special(req->op.del.dn)) {
- return ildb_request_noop(ildb, req);
- }
-
msg = new_ldap_message(req);
if (msg == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
return LDB_ERR_INVALID_DN_SYNTAX;
}
- return ildb_request_send(ildb, msg, req);
+ return ildb_request_send(ac, msg);
}
/*
rename a record
*/
-static int ildb_rename(struct ldb_module *module, struct ldb_request *req)
+static int ildb_rename(struct ildb_context *ac)
{
- struct ildb_private *ildb = talloc_get_type(module->private_data, struct ildb_private);
+ struct ldb_request *req = ac->req;
struct ldap_message *msg;
- req->handle = NULL;
-
- /* ignore ltdb specials */
- if (ldb_dn_is_special(req->op.rename.olddn) || ldb_dn_is_special(req->op.rename.newdn)) {
- return ildb_request_noop(ildb, req);
- }
-
msg = new_ldap_message(req);
if (msg == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
msg->r.ModifyDNRequest.deleteolddn = true;
- return ildb_request_send(ildb, msg, req);
+ return ildb_request_send(ac, msg);
}
static int ildb_start_trans(struct ldb_module *module)
return LDB_SUCCESS;
}
-static int ildb_request(struct ldb_module *module, struct ldb_request *req)
+static bool ildb_dn_is_special(struct ldb_request *req)
{
- return LDB_ERR_OPERATIONS_ERROR;
+ struct ldb_dn *dn = NULL;
+
+ switch (req->operation) {
+ case LDB_ADD:
+ dn = req->op.add.message->dn;
+ break;
+ case LDB_MODIFY:
+ dn = req->op.mod.message->dn;
+ break;
+ case LDB_DELETE:
+ dn = req->op.del.dn;
+ break;
+ case LDB_RENAME:
+ dn = req->op.rename.olddn;
+ break;
+ default:
+ break;
+ }
+
+ if (dn && ldb_dn_is_special(dn)) {
+ return true;
+ }
+ return false;
}
-static int ildb_wait(struct ldb_handle *handle, enum ldb_wait_type type)
+static int ildb_handle_request(struct ldb_module *module, struct ldb_request *req)
{
- struct ildb_context *ac = talloc_get_type(handle->private_data, struct ildb_context);
+ struct ildb_private *ildb;
+ struct ildb_context *ac;
+ struct timed_event *te;
+ int ret;
+
+ ildb = talloc_get_type(module->private_data, struct ildb_private);
- if (handle->state == LDB_ASYNC_DONE) {
- return handle->status;
+ if (req->starttime == 0 || req->timeout == 0) {
+ ldb_set_errstring(module->ldb, "Invalid timeout settings");
+ return LDB_ERR_TIME_LIMIT_EXCEEDED;
}
- if (!ac) {
+ ac = talloc_zero(req, struct ildb_context);
+ if (ac == NULL) {
+ ldb_set_errstring(module->ldb, "Out of Memory");
return LDB_ERR_OPERATIONS_ERROR;
}
- handle->state = LDB_ASYNC_INIT;
+ ac->module = module;
+ ac->req = req;
+ ac->ildb = ildb;
+
+ if (ildb_dn_is_special(req)) {
- switch(type) {
- case LDB_WAIT_NONE:
- if (event_loop_once(ac->req->conn->event.event_ctx) != 0) {
- return LDB_ERR_OTHER;
+ te = event_add_timed(ac->ildb->event_ctx,
+ ac, timeval_zero(),
+ ildb_auto_done_callback, ac);
+ if (NULL == te) {
+ return LDB_ERR_OPERATIONS_ERROR;
}
+
+ return LDB_SUCCESS;
+ }
+
+ switch (ac->req->operation) {
+ case LDB_SEARCH:
+ ret = ildb_search(ac);
break;
- case LDB_WAIT_ALL:
- while (handle->status == LDB_SUCCESS && handle->state != LDB_ASYNC_DONE) {
- if (event_loop_once(ac->req->conn->event.event_ctx) != 0) {
- return LDB_ERR_OTHER;
- }
- }
+ case LDB_ADD:
+ ret = ildb_add(ac);
+ break;
+ case LDB_MODIFY:
+ ret = ildb_modify(ac);
+ break;
+ case LDB_DELETE:
+ ret = ildb_delete(ac);
+ break;
+ case LDB_RENAME:
+ ret = ildb_rename(ac);
break;
default:
- return LDB_ERR_OPERATIONS_ERROR;
+ /* no other op supported */
+ ret = LDB_ERR_OPERATIONS_ERROR;
+ break;
}
- return handle->status;
+ return ret;
}
static const struct ldb_module_ops ildb_ops = {
.name = "ldap",
- .search = ildb_search,
- .add = ildb_add,
- .modify = ildb_modify,
- .del = ildb_delete,
- .rename = ildb_rename,
- .request = ildb_request,
+ .search = ildb_handle_request,
+ .add = ildb_handle_request,
+ .modify = ildb_handle_request,
+ .del = ildb_handle_request,
+ .rename = ildb_handle_request,
+/* .request = ildb_handle_request, */
.start_transaction = ildb_start_trans,
.end_transaction = ildb_end_trans,
.del_transaction = ildb_del_trans,
- .wait = ildb_wait
};
/*
struct ildb_private *ildb;
NTSTATUS status;
struct cli_credentials *creds;
- struct event_context *event_ctx;
module = talloc(ldb, struct ldb_module);
if (!module) {
talloc_set_name_const(module, "ldb_ildap backend");
module->ldb = ldb;
module->prev = module->next = NULL;
- module->private_data = NULL;
module->ops = &ildb_ops;
ildb = talloc(module, struct ildb_private);
goto failed;
}
module->private_data = ildb;
- ildb->module = module;
- event_ctx = ldb_get_event_context(ldb);
+ ildb->event_ctx = ldb_get_event_context(ldb);
+
ildb->ldap = ldap4_new_connection(ildb, ldb_get_opaque(ldb, "loadparm"),
- event_ctx);
+ ildb->event_ctx);
if (!ildb->ldap) {
ldb_oom(ldb);
goto failed;
struct lldb_private {
LDAP *ldap;
- struct ldb_module *module;
};
struct lldb_context {
+ struct ldb_module *module;
+ struct ldb_request *req;
+
struct lldb_private *lldb;
- struct ldb_handle *handle;
+
+ struct ldb_control **controls;
int msgid;
- int timeout;
- time_t starttime;
- void *context;
- int (*callback)(struct ldb_context *, void *, struct ldb_reply *);
};
static int lldb_ldap_to_ldb(int err) {
return err;
}
-static struct lldb_context *init_lldb_handle(struct lldb_private *lldb, struct ldb_request *req)
-{
- struct lldb_context *ac;
- struct ldb_handle *h;
-
- h = talloc_zero(req, struct ldb_handle);
- if (h == NULL) {
- ldb_set_errstring(lldb->module->ldb, "Out of Memory");
- return NULL;
- }
-
- h->module = lldb->module;
-
- ac = talloc(h, struct lldb_context);
- if (ac == NULL) {
- ldb_set_errstring(lldb->module->ldb, "Out of Memory");
- talloc_free(h);
- return NULL;
- }
-
- h->private_data = ac;
-
- h->state = LDB_ASYNC_INIT;
- h->status = LDB_SUCCESS;
-
- ac->lldb = lldb;
- ac->handle = h;
- ac->context = req->context;
- ac->callback = req->callback;
- ac->timeout = req->timeout;
- ac->starttime = req->starttime;
- ac->msgid = 0;
-
- req->handle = h;
- return ac;
-}
/*
convert a ldb_message structure to a list of LDAPMod structures
ready for ldap_add() or ldap_modify()
/*
search for matching records
*/
-static int lldb_search(struct ldb_module *module, struct ldb_request *req)
+static int lldb_search(struct lldb_context *lldb_ac)
{
- struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
- struct lldb_context *lldb_ac;
+ struct lldb_private *lldb = lldb_ac->lldb;
+ struct ldb_module *module = lldb_ac->module;
+ struct ldb_request *req = lldb_ac->req;
struct timeval tv;
int ldap_scope;
char *search_base;
ldb_debug(module->ldb, LDB_DEBUG_WARNING, "Controls are not yet supported by ldb_ldap backend!\n");
}
- lldb_ac = init_lldb_handle(lldb, req);
- if (lldb_ac == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
+ req->handle->state = LDB_ASYNC_PENDING;
search_base = ldb_dn_alloc_linearized(lldb_ac, req->op.search.base);
if (req->op.search.base == NULL) {
/*
add a record
*/
-static int lldb_add(struct ldb_module *module, struct ldb_request *req)
+static int lldb_add(struct lldb_context *lldb_ac)
{
- struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
- struct lldb_context *lldb_ac;
+ struct lldb_private *lldb = lldb_ac->lldb;
+ struct ldb_module *module = lldb_ac->module;
+ struct ldb_request *req = lldb_ac->req;
LDAPMod **mods;
char *dn;
int ret;
- /* ltdb specials should not reach this point */
- if (ldb_dn_is_special(req->op.add.message->dn)) {
- return LDB_ERR_INVALID_DN_SYNTAX;
- }
-
- lldb_ac = init_lldb_handle(lldb, req);
- if (lldb_ac == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
+ req->handle->state = LDB_ASYNC_PENDING;
mods = lldb_msg_to_mods(lldb_ac, req->op.add.message, 0);
if (mods == NULL) {
/*
modify a record
*/
-static int lldb_modify(struct ldb_module *module, struct ldb_request *req)
+static int lldb_modify(struct lldb_context *lldb_ac)
{
- struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
- struct lldb_context *lldb_ac;
+ struct lldb_private *lldb = lldb_ac->lldb;
+ struct ldb_module *module = lldb_ac->module;
+ struct ldb_request *req = lldb_ac->req;
LDAPMod **mods;
char *dn;
int ret;
- /* ltdb specials should not reach this point */
- if (ldb_dn_is_special(req->op.mod.message->dn)) {
- return LDB_ERR_INVALID_DN_SYNTAX;
- }
-
- lldb_ac = init_lldb_handle(lldb, req);
- if (req->handle == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
+ req->handle->state = LDB_ASYNC_PENDING;
mods = lldb_msg_to_mods(lldb_ac, req->op.mod.message, 1);
if (mods == NULL) {
/*
delete a record
*/
-static int lldb_delete(struct ldb_module *module, struct ldb_request *req)
+static int lldb_delete(struct lldb_context *lldb_ac)
{
- struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
- struct lldb_context *lldb_ac;
+ struct lldb_private *lldb = lldb_ac->lldb;
+ struct ldb_module *module = lldb_ac->module;
+ struct ldb_request *req = lldb_ac->req;
char *dnstr;
int ret;
-
- /* ltdb specials should not reach this point */
- if (ldb_dn_is_special(req->op.del.dn)) {
- return LDB_ERR_INVALID_DN_SYNTAX;
- }
- lldb_ac = init_lldb_handle(lldb, req);
- if (lldb_ac == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
+ req->handle->state = LDB_ASYNC_PENDING;
dnstr = ldb_dn_alloc_linearized(lldb_ac, req->op.del.dn);
/*
rename a record
*/
-static int lldb_rename(struct ldb_module *module, struct ldb_request *req)
+static int lldb_rename(struct lldb_context *lldb_ac)
{
- struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
- struct lldb_context *lldb_ac;
+ struct lldb_private *lldb = lldb_ac->lldb;
+ struct ldb_module *module = lldb_ac->module;
+ struct ldb_request *req = lldb_ac->req;
char *old_dn;
char *newrdn;
char *parentdn;
int ret;
-
- /* ltdb specials should not reach this point */
- if (ldb_dn_is_special(req->op.rename.olddn) || ldb_dn_is_special(req->op.rename.newdn)) {
- return LDB_ERR_INVALID_DN_SYNTAX;
- }
- lldb_ac = init_lldb_handle(lldb, req);
- if (lldb_ac == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
+ req->handle->state = LDB_ASYNC_PENDING;
old_dn = ldb_dn_alloc_linearized(lldb_ac, req->op.rename.olddn);
if (old_dn == NULL) {
return lldb_ldap_to_ldb(ret);
}
-static int lldb_parse_result(struct lldb_context *ac, LDAPMessage *result)
+static int lldb_start_trans(struct ldb_module *module)
+{
+ /* TODO implement a local transaction mechanism here */
+
+ return LDB_SUCCESS;
+}
+
+static int lldb_end_trans(struct ldb_module *module)
+{
+ /* TODO implement a local transaction mechanism here */
+
+ return LDB_SUCCESS;
+}
+
+static int lldb_del_trans(struct ldb_module *module)
+{
+ /* TODO implement a local transaction mechanism here */
+
+ return LDB_SUCCESS;
+}
+
+void lldb_request_done(struct ldb_request *req,
+ struct ldb_control **ctrls, int error)
+{
+ struct ldb_reply *ares;
+
+ ares = talloc_zero(req, struct ldb_reply);
+ if (!ares) {
+ ldb_oom(req->handle->ldb);
+ req->callback(req, NULL);
+ return;
+ }
+ ares->type = LDB_REPLY_DONE;
+ ares->controls = talloc_steal(ares, ctrls);
+ ares->error = error;
+
+ req->callback(req, ares);
+}
+
+/* return false if the request is still in progress
+ * return true if the request is completed
+ */
+static bool lldb_parse_result(struct lldb_context *ac, LDAPMessage *result)
{
- struct ldb_handle *handle = ac->handle;
struct lldb_private *lldb = ac->lldb;
- struct ldb_reply *ares = NULL;
- LDAPMessage *msg;
- int type;
+ LDAPControl **serverctrlsp = NULL;
+ char **referralsp = NULL;
char *matcheddnp = NULL;
char *errmsgp = NULL;
- char **referralsp = NULL;
- LDAPControl **serverctrlsp = NULL;
- int ret = LDB_SUCCESS;
-
- type = ldap_msgtype(result);
+ LDAPMessage *msg;
+ int type;
+ struct ldb_message *ldbmsg;
+ char *referral;
+ bool callback_failed;
+ bool request_done;
+ bool lret;
+ int ret;
+ int i;
- handle->status = 0;
+ type = ldap_msgtype(result);
+ callback_failed = false;
+ request_done = false;
switch (type) {
-
case LDAP_RES_SEARCH_ENTRY:
+
msg = ldap_first_entry(lldb->ldap, result);
if (msg != NULL) {
BerElement *berptr = NULL;
char *attr, *dn;
- ares = talloc_zero(ac, struct ldb_reply);
- if (!ares) {
- ret = LDB_ERR_OPERATIONS_ERROR;
- goto error;
- }
-
- ares->message = ldb_msg_new(ares);
- if (!ares->message) {
+ ldbmsg = ldb_msg_new(ac);
+ if (!ldbmsg) {
ret = LDB_ERR_OPERATIONS_ERROR;
- goto error;
+ break;
}
dn = ldap_get_dn(lldb->ldap, msg);
if (!dn) {
+ talloc_free(ldbmsg);
ret = LDB_ERR_OPERATIONS_ERROR;
- goto error;
+ break;
}
- ares->message->dn = ldb_dn_new(ares->message, ac->lldb->module->ldb, dn);
- if ( ! ldb_dn_validate(ares->message->dn)) {
+ ldbmsg->dn = ldb_dn_new(ldbmsg, ac->module->ldb, dn);
+ if ( ! ldb_dn_validate(ldbmsg->dn)) {
+ talloc_free(ldbmsg);
ret = LDB_ERR_OPERATIONS_ERROR;
- goto error;
+ break;
}
ldap_memfree(dn);
- ares->message->num_elements = 0;
- ares->message->elements = NULL;
+ ldbmsg->num_elements = 0;
+ ldbmsg->elements = NULL;
/* loop over all attributes */
for (attr=ldap_first_attribute(lldb->ldap, msg, &berptr);
bval = ldap_get_values_len(lldb->ldap, msg, attr);
if (bval) {
- lldb_add_msg_attr(ac->lldb->module->ldb, ares->message, attr, bval);
+ lldb_add_msg_attr(ac->module->ldb, ldbmsg, attr, bval);
ldap_value_free_len(bval);
- }
+ }
}
if (berptr) ber_free(berptr, 0);
+ ret = ldb_module_send_entry(ac->req, ldbmsg);
+ if (ret != LDB_SUCCESS) {
- ares->type = LDB_REPLY_ENTRY;
- ret = ac->callback(ac->lldb->module->ldb, ac->context, ares);
+ callback_failed = true;
+ }
} else {
- handle->status = LDB_ERR_PROTOCOL_ERROR;
- handle->state = LDB_ASYNC_DONE;
+ ret = LDB_ERR_OPERATIONS_ERROR;
}
break;
case LDAP_RES_SEARCH_REFERENCE:
- if (ldap_parse_result(lldb->ldap, result, &handle->status,
+
+ if (ldap_parse_result(lldb->ldap, result, &ret,
&matcheddnp, &errmsgp,
&referralsp, &serverctrlsp, 0) != LDAP_SUCCESS) {
ret = LDB_ERR_OPERATIONS_ERROR;
- goto error;
}
- if (referralsp == NULL) {
- handle->status = LDB_ERR_PROTOCOL_ERROR;
- goto error;
+ if (ret != LDB_SUCCESS) {
+ break;
}
-
- ares = talloc_zero(ac, struct ldb_reply);
- if (!ares) {
- ret = LDB_ERR_OPERATIONS_ERROR;
- goto error;
+ if (referralsp == NULL) {
+ ret = LDB_ERR_PROTOCOL_ERROR;
+ break;
}
- ares->referral = talloc_strdup(ares, *referralsp);
- ares->type = LDB_REPLY_REFERRAL;
- ret = ac->callback(ac->lldb->module->ldb, ac->context, ares);
+ for (i = 0; referralsp[i]; i++) {
+ referral = talloc_strdup(ac, referralsp[i]);
+ ret = ldb_module_send_referral(ac->req, referral);
+ if (ret != LDB_SUCCESS) {
+ callback_failed = true;
+ break;
+ }
+ }
break;
case LDAP_RES_SEARCH_RESULT:
- if (ldap_parse_result(lldb->ldap, result, &handle->status,
+ case LDAP_RES_MODIFY:
+ case LDAP_RES_ADD:
+ case LDAP_RES_DELETE:
+ case LDAP_RES_MODDN:
+
+ if (ldap_parse_result(lldb->ldap, result, &ret,
&matcheddnp, &errmsgp,
&referralsp, &serverctrlsp, 0) != LDAP_SUCCESS) {
- handle->status = LDB_ERR_OPERATIONS_ERROR;
- goto error;
- }
-
- ares = talloc_zero(ac, struct ldb_reply);
- if (!ares) {
ret = LDB_ERR_OPERATIONS_ERROR;
- goto error;
+ }
+ if (ret != LDB_SUCCESS) {
+ break;
}
if (serverctrlsp != NULL) {
/* FIXME: transform the LDAPControl list into an ldb_control one */
- ares->controls = NULL;
+ ac->controls = NULL;
}
-
- ares->type = LDB_REPLY_DONE;
- handle->state = LDB_ASYNC_DONE;
- ret = ac->callback(ac->lldb->module->ldb, ac->context, ares);
-
- break;
- case LDAP_RES_MODIFY:
- case LDAP_RES_ADD:
- case LDAP_RES_DELETE:
- case LDAP_RES_MODDN:
- if (ldap_parse_result(lldb->ldap, result, &handle->status,
- &matcheddnp, &errmsgp,
- &referralsp, &serverctrlsp, 0) != LDAP_SUCCESS) {
- handle->status = LDB_ERR_OPERATIONS_ERROR;
- goto error;
- }
- if (ac->callback && handle->status == LDB_SUCCESS) {
- ares = NULL; /* FIXME: build a corresponding ares to pass on */
- ret = ac->callback(ac->lldb->module->ldb, ac->context, ares);
- }
- handle->state = LDB_ASYNC_DONE;
+ request_done = true;
break;
default:
ret = LDB_ERR_PROTOCOL_ERROR;
- goto error;
+ break;
}
+ if (ret != LDB_SUCCESS) {
+
+ /* if the callback failed the caller will have freed the
+ * request. Just return and don't try to use it */
+ if (callback_failed) {
+
+ /* tell lldb_wait to remove the request from the
+ * queue */
+ lret = true;
+ goto free_and_return;
+ }
+
+ request_done = true;
+ }
+
+ if (request_done) {
+ lldb_request_done(ac->req, ac->controls, ret);
+ lret = true;
+ goto free_and_return;
+ }
+
+ lret = false;
+
+free_and_return:
+
if (matcheddnp) ldap_memfree(matcheddnp);
if (errmsgp && *errmsgp) {
- ldb_set_errstring(ac->lldb->module->ldb, errmsgp);
- } else if (handle->status) {
- ldb_set_errstring(ac->lldb->module->ldb, ldap_err2string(handle->status));
+ ldb_set_errstring(ac->module->ldb, errmsgp);
}
if (errmsgp) {
ldap_memfree(errmsgp);
if (serverctrlsp) ldap_controls_free(serverctrlsp);
ldap_msgfree(result);
- return lldb_ldap_to_ldb(handle->status);
-error:
- handle->state = LDB_ASYNC_DONE;
- ldap_msgfree(result);
- return ret;
+ return lret;
}
-static int lldb_wait(struct ldb_handle *handle, enum ldb_wait_type type)
+static void lldb_timeout(struct event_context *ev,
+ struct timed_event *te,
+ struct timeval t,
+ void *private_data)
{
- struct lldb_context *ac = talloc_get_type(handle->private_data, struct lldb_context);
- struct lldb_private *lldb = ac->lldb;
- struct timeval timeout;
+ struct lldb_context *ac;
+ ac = talloc_get_type(private_data, struct lldb_context);
+
+ lldb_request_done(ac->req, NULL, LDB_ERR_TIME_LIMIT_EXCEEDED);
+}
+
+static void lldb_callback(struct event_context *ev,
+ struct timed_event *te,
+ struct timeval t,
+ void *private_data)
+{
+ struct lldb_context *ac;
+ struct timed_event *lte;
+ struct timeval tv;
LDAPMessage *result;
- int ret, lret;
+ int lret;
+
+ ac = talloc_get_type(private_data, struct lldb_context);
- if (handle->state == LDB_ASYNC_DONE) {
- return handle->status;
+ if (!ac->msgid) {
+ lldb_request_done(ac->req, NULL, LDB_ERR_OPERATIONS_ERROR);
+ return;
}
- if (!ac || !ac->msgid) {
- return LDB_ERR_OPERATIONS_ERROR;
+ tv.tv_sec = 0;
+ tv.tv_usec = 0;
+ lret = ldap_result(ac->lldb->ldap, ac->msgid, 0, &tv, &result);
+ if (lret == 0) {
+ goto respin;
+ }
+ if (lret == -1) {
+ lldb_request_done(ac->req, NULL, LDB_ERR_OPERATIONS_ERROR);
+ return;
}
- handle->state = LDB_ASYNC_PENDING;
- handle->status = LDB_SUCCESS;
+ if ( ! lldb_parse_result(ac, result)) {
+ goto respin;
+ }
- switch(type) {
- case LDB_WAIT_NONE:
+ return;
- if ((ac->timeout != -1) &&
- ((ac->starttime + ac->timeout) > time(NULL))) {
- return LDB_ERR_TIME_LIMIT_EXCEEDED;
- }
+respin:
+ tv.tv_sec = 0;
+ tv.tv_usec = 100;
+ lte = event_add_timed(ev, ac, tv, lldb_callback, ac);
+ if (NULL == lte) {
+ lldb_request_done(ac->req, NULL, LDB_ERR_OPERATIONS_ERROR);
+ }
+}
- timeout.tv_sec = 0;
- timeout.tv_usec = 0;
+static bool lldb_dn_is_special(struct ldb_request *req)
+{
+ struct ldb_dn *dn = NULL;
- lret = ldap_result(lldb->ldap, ac->msgid, 0, &timeout, &result);
- if (lret == -1) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
- if (lret == 0) {
- ret = LDB_SUCCESS;
- goto done;
- }
+ switch (req->operation) {
+ case LDB_ADD:
+ dn = req->op.add.message->dn;
+ break;
+ case LDB_MODIFY:
+ dn = req->op.mod.message->dn;
+ break;
+ case LDB_DELETE:
+ dn = req->op.del.dn;
+ break;
+ case LDB_RENAME:
+ dn = req->op.rename.olddn;
+ break;
+ default:
+ break;
+ }
- return lldb_parse_result(ac, result);
+ if (dn && ldb_dn_is_special(dn)) {
+ return true;
+ }
+ return false;
+}
- case LDB_WAIT_ALL:
- timeout.tv_usec = 0;
- ret = LDB_ERR_OPERATIONS_ERROR;
+static void lldb_auto_done_callback(struct event_context *ev,
+ struct timed_event *te,
+ struct timeval t,
+ void *private_data)
+{
+ struct lldb_context *ac;
- while (handle->status == LDB_SUCCESS && handle->state != LDB_ASYNC_DONE) {
+ ac = talloc_get_type(private_data, struct lldb_context);
+ lldb_request_done(ac->req, NULL, LDB_SUCCESS);
+}
- if (ac->timeout == -1) {
- lret = ldap_result(lldb->ldap, ac->msgid, 0, NULL, &result);
- } else {
- timeout.tv_sec = ac->timeout - (time(NULL) - ac->starttime);
- if (timeout.tv_sec <= 0)
- return LDB_ERR_TIME_LIMIT_EXCEEDED;
- lret = ldap_result(lldb->ldap, ac->msgid, 0, &timeout, &result);
- }
- if (lret == -1) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
- if (lret == 0) {
- return LDB_ERR_TIME_LIMIT_EXCEEDED;
- }
+static int lldb_handle_request(struct ldb_module *module, struct ldb_request *req)
+{
+ struct lldb_private *lldb;
+ struct lldb_context *ac;
+ struct event_context *ev;
+ struct timed_event *te;
+ struct timeval tv;
+ int ret;
- ret = lldb_parse_result(ac, result);
- if (ret != LDB_SUCCESS) {
- return ret;
- }
+ lldb = talloc_get_type(module->private_data, struct lldb_private);
+
+ if (req->starttime == 0 || req->timeout == 0) {
+ ldb_set_errstring(module->ldb, "Invalid timeout settings");
+ return LDB_ERR_TIME_LIMIT_EXCEEDED;
+ }
+
+ ev = ldb_get_event_context(module->ldb);
+ if (NULL == ev) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ ac = talloc_zero(module->ldb, struct lldb_context);
+ if (ac == NULL) {
+ ldb_set_errstring(module->ldb, "Out of Memory");
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ ac->module = module;
+ ac->req = req;
+ ac->lldb = lldb;
+ ac->msgid = 0;
+
+ if (lldb_dn_is_special(req)) {
+ tv.tv_sec = 0;
+ tv.tv_usec = 0;
+ te = event_add_timed(ev, ac, tv,
+ lldb_auto_done_callback, ac);
+ if (NULL == te) {
+ return LDB_ERR_OPERATIONS_ERROR;
}
+ return LDB_SUCCESS;
+ }
+
+ switch (ac->req->operation) {
+ case LDB_SEARCH:
+ ret = lldb_search(ac);
+ break;
+ case LDB_ADD:
+ ret = lldb_add(ac);
+ break;
+ case LDB_MODIFY:
+ ret = lldb_modify(ac);
+ break;
+ case LDB_DELETE:
+ ret = lldb_delete(ac);
+ break;
+ case LDB_RENAME:
+ ret = lldb_rename(ac);
break;
-
default:
- handle->state = LDB_ASYNC_DONE;
+ /* no other op supported */
ret = LDB_ERR_OPERATIONS_ERROR;
+ break;
}
-done:
- return ret;
-}
-
-static int lldb_start_trans(struct ldb_module *module)
-{
- /* TODO implement a local transaction mechanism here */
-
- return LDB_SUCCESS;
-}
+ if (ret != LDB_SUCCESS) {
+ lldb_request_done(req, NULL, ret);
+ return ret;
+ }
-static int lldb_end_trans(struct ldb_module *module)
-{
- /* TODO implement a local transaction mechanism here */
+ tv.tv_sec = 0;
+ tv.tv_usec = 0;
+ te = event_add_timed(ev, ac, tv, lldb_callback, ac);
+ if (NULL == te) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
- return LDB_SUCCESS;
-}
-static int lldb_del_trans(struct ldb_module *module)
-{
- /* TODO implement a local transaction mechanism here */
+ tv.tv_sec = req->starttime + req->timeout;
+ tv.tv_usec = 0;
+ te = event_add_timed(ev, ac, tv, lldb_timeout, ac);
+ if (NULL == te) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
return LDB_SUCCESS;
}
-static int lldb_request(struct ldb_module *module, struct ldb_request *req)
-{
- return LDB_ERR_OPERATIONS_ERROR;
-}
-
static const struct ldb_module_ops lldb_ops = {
.name = "ldap",
- .search = lldb_search,
- .add = lldb_add,
- .modify = lldb_modify,
- .del = lldb_delete,
- .rename = lldb_rename,
- .request = lldb_request,
+ .search = lldb_handle_request,
+ .add = lldb_handle_request,
+ .modify = lldb_handle_request,
+ .del = lldb_handle_request,
+ .rename = lldb_handle_request,
+ .request = lldb_handle_request,
.start_transaction = lldb_start_trans,
.end_transaction = lldb_end_trans,
.del_transaction = lldb_del_trans,
- .wait = lldb_wait
};
connect to the database
*/
static int lldb_connect(struct ldb_context *ldb,
- const char *url,
- unsigned int flags,
+ const char *url,
+ unsigned int flags,
const char *options[],
struct ldb_module **_module)
{
talloc_set_name_const(module, "ldb_ldap backend");
module->ldb = ldb;
module->prev = module->next = NULL;
- module->private_data = NULL;
module->ops = &lldb_ops;
lldb = talloc(module, struct lldb_private);
goto failed;
}
module->private_data = lldb;
- lldb->module = module;
lldb->ldap = NULL;
ret = ldap_initialize(&lldb->ldap, url);
Copyright (C) Jelmer Vernooij 2005
Copyright (C) Martin Kuehl <mkhl@samba.org> 2006
+ Copyright (C) Simo Sorce 2008
** NOTE! The following LGPL license applies to the ldb
** library. This does NOT imply that all of Samba is released
}
/* Create a generic request context. */
-static struct map_context *map_init_context(struct ldb_handle *h, struct ldb_request *req)
+struct map_context *map_init_context(struct ldb_module *module,
+ struct ldb_request *req)
{
struct map_context *ac;
- ac = talloc_zero(h, struct map_context);
+ ac = talloc_zero(req, struct map_context);
if (ac == NULL) {
- map_oom(h->module);
+ ldb_set_errstring(module->ldb, "Out of Memory");
return NULL;
}
- ac->module = h->module;
- ac->orig_req = req;
+ ac->module = module;
+ ac->req = req;
return ac;
}
-/* Create a search request context. */
-struct map_search_context *map_init_search_context(struct map_context *ac, struct ldb_reply *ares)
-{
- struct map_search_context *sc;
-
- sc = talloc_zero(ac, struct map_search_context);
- if (sc == NULL) {
- map_oom(ac->module);
- return NULL;
- }
-
- sc->ac = ac;
- sc->local_res = NULL;
- sc->remote_res = ares;
-
- return sc;
-}
-
-/* Create a request context and handle. */
-struct ldb_handle *map_init_handle(struct ldb_request *req, struct ldb_module *module)
-{
- struct map_context *ac;
- struct ldb_handle *h;
-
- h = talloc_zero(req, struct ldb_handle);
- if (h == NULL) {
- map_oom(module);
- return NULL;
- }
-
- h->module = module;
-
- ac = map_init_context(h, req);
- if (ac == NULL) {
- talloc_free(h);
- return NULL;
- }
-
- h->private_data = (void *)ac;
-
- h->state = LDB_ASYNC_INIT;
- h->status = LDB_SUCCESS;
-
- return h;
-}
-
-
/* Dealing with DNs for different partitions
* ========================================= */
/* Auxiliary request construction
* ============================== */
-/* Store the DN of a single search result in context. */
-static int map_search_self_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
-{
- struct map_context *ac;
-
- if (context == NULL || ares == NULL) {
- ldb_set_errstring(ldb, talloc_asprintf(ldb, "NULL Context or Result in callback"));
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- ac = talloc_get_type(context, struct map_context);
-
- /* We are interested only in the single reply */
- if (ares->type != LDB_REPLY_ENTRY) {
- talloc_free(ares);
- return LDB_SUCCESS;
- }
-
- /* We have already found a remote DN */
- if (ac->local_dn) {
- ldb_set_errstring(ldb, talloc_asprintf(ldb, "Too many results to base search"));
- talloc_free(ares);
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- /* Store local DN */
- ac->local_dn = ares->message->dn;
-
- return LDB_SUCCESS;
-}
-
/* Build a request to search a record by its DN. */
-struct ldb_request *map_search_base_req(struct map_context *ac, struct ldb_dn *dn, const char * const *attrs, const struct ldb_parse_tree *tree, void *context, ldb_search_callback callback)
+struct ldb_request *map_search_base_req(struct map_context *ac, struct ldb_dn *dn, const char * const *attrs, const struct ldb_parse_tree *tree, void *context, ldb_map_callback_t callback)
{
+ const struct ldb_parse_tree *search_tree;
struct ldb_request *req;
-
- req = talloc_zero(ac, struct ldb_request);
- if (req == NULL) {
- map_oom(ac->module);
- return NULL;
- }
-
- req->operation = LDB_SEARCH;
- req->op.search.base = dn;
- req->op.search.scope = LDB_SCOPE_BASE;
- req->op.search.attrs = attrs;
+ int ret;
if (tree) {
- req->op.search.tree = tree;
+ search_tree = tree;
} else {
- req->op.search.tree = ldb_parse_tree(req, NULL);
- if (req->op.search.tree == NULL) {
- talloc_free(req);
+ search_tree = ldb_parse_tree(ac, NULL);
+ if (search_tree == NULL) {
return NULL;
}
}
- req->controls = NULL;
- req->context = context;
- req->callback = callback;
- ldb_set_timeout_from_prev_req(ac->module->ldb, ac->orig_req, req);
-
- return req;
-}
-
-/* Build a request to search the local record by its DN. */
-struct ldb_request *map_search_self_req(struct map_context *ac, struct ldb_dn *dn)
-{
- /* attrs[] is returned from this function in
- * ac->search_req->op.search.attrs, so it must be static, as
- * otherwise the compiler can put it on the stack */
- static const char * const attrs[] = { IS_MAPPED, NULL };
- struct ldb_parse_tree *tree;
-
- /* Limit search to records with 'IS_MAPPED' present */
- /* TODO: `tree = ldb_parse_tree(ac, IS_MAPPED);' won't do. */
- tree = talloc_zero(ac, struct ldb_parse_tree);
- if (tree == NULL) {
- map_oom(ac->module);
+ ret = ldb_build_search_req_ex(&req, ac->module->ldb, ac,
+ dn, LDB_SCOPE_BASE,
+ search_tree, attrs,
+ NULL,
+ context, callback,
+ ac->req);
+ if (ret != LDB_SUCCESS) {
return NULL;
}
- tree->operation = LDB_OP_PRESENT;
- tree->u.present.attr = talloc_strdup(tree, IS_MAPPED);
-
- return map_search_base_req(ac, dn, attrs, tree, ac, map_search_self_callback);
+ return req;
}
/* Build a request to update the 'IS_MAPPED' attribute */
-struct ldb_request *map_build_fixup_req(struct map_context *ac, struct ldb_dn *olddn, struct ldb_dn *newdn)
+struct ldb_request *map_build_fixup_req(struct map_context *ac,
+ struct ldb_dn *olddn,
+ struct ldb_dn *newdn,
+ void *context,
+ ldb_map_callback_t callback)
{
struct ldb_request *req;
struct ldb_message *msg;
const char *dn;
-
- /* Prepare request */
- req = talloc_zero(ac, struct ldb_request);
- if (req == NULL) {
- map_oom(ac->module);
- return NULL;
- }
+ int ret;
/* Prepare message */
- msg = ldb_msg_new(req);
+ msg = ldb_msg_new(ac);
if (msg == NULL) {
map_oom(ac->module);
- goto failed;
+ return NULL;
}
/* Update local 'IS_MAPPED' to the new remote DN */
goto failed;
}
- req->operation = LDB_MODIFY;
- req->op.mod.message = msg;
- req->controls = NULL;
- req->handle = NULL;
- req->context = NULL;
- req->callback = NULL;
+ /* Prepare request */
+ ret = ldb_build_mod_req(&req, ac->module->ldb,
+ ac, msg, NULL,
+ context, callback,
+ ac->req);
+ if (ret != LDB_SUCCESS) {
+ goto failed;
+ }
+ talloc_steal(req, msg);
return req;
-
failed:
- talloc_free(req);
+ talloc_free(msg);
return NULL;
}
-
-/* Asynchronous call structure
- * =========================== */
-
-/* Figure out which request is currently pending. */
-static struct ldb_request *map_get_req(struct map_context *ac)
-{
- switch (ac->step) {
- case MAP_SEARCH_SELF_MODIFY:
- case MAP_SEARCH_SELF_DELETE:
- case MAP_SEARCH_SELF_RENAME:
- return ac->search_req;
-
- case MAP_ADD_REMOTE:
- case MAP_MODIFY_REMOTE:
- case MAP_DELETE_REMOTE:
- case MAP_RENAME_REMOTE:
- return ac->remote_req;
-
- case MAP_RENAME_FIXUP:
- return ac->down_req;
-
- case MAP_ADD_LOCAL:
- case MAP_MODIFY_LOCAL:
- case MAP_DELETE_LOCAL:
- case MAP_RENAME_LOCAL:
- return ac->local_req;
-
- case MAP_SEARCH_REMOTE:
- /* Can't happen */
- break;
- }
-
- return NULL; /* unreachable; silences a warning */
-}
-
-typedef int (*map_next_function)(struct ldb_handle *handle);
-
-/* Figure out the next request to run. */
-static map_next_function map_get_next(struct map_context *ac)
-{
- switch (ac->step) {
- case MAP_SEARCH_REMOTE:
- return NULL;
-
- case MAP_ADD_LOCAL:
- return map_add_do_remote;
- case MAP_ADD_REMOTE:
- return NULL;
-
- case MAP_SEARCH_SELF_MODIFY:
- return map_modify_do_local;
- case MAP_MODIFY_LOCAL:
- return map_modify_do_remote;
- case MAP_MODIFY_REMOTE:
- return NULL;
-
- case MAP_SEARCH_SELF_DELETE:
- return map_delete_do_local;
- case MAP_DELETE_LOCAL:
- return map_delete_do_remote;
- case MAP_DELETE_REMOTE:
- return NULL;
-
- case MAP_SEARCH_SELF_RENAME:
- return map_rename_do_local;
- case MAP_RENAME_LOCAL:
- return map_rename_do_fixup;
- case MAP_RENAME_FIXUP:
- return map_rename_do_remote;
- case MAP_RENAME_REMOTE:
- return NULL;
- }
-
- return NULL; /* unreachable; silences a warning */
-}
-
-/* Wait for the current pending request to finish and continue with the next. */
-static int map_wait_next(struct ldb_handle *handle)
-{
- struct map_context *ac;
- struct ldb_request *req;
- map_next_function next;
- int ret;
-
- if (handle == NULL || handle->private_data == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- if (handle->state == LDB_ASYNC_DONE) {
- return handle->status;
- }
-
- handle->state = LDB_ASYNC_PENDING;
- handle->status = LDB_SUCCESS;
-
- ac = talloc_get_type(handle->private_data, struct map_context);
-
- if (ac->step == MAP_SEARCH_REMOTE) {
- int i;
- for (i = 0; i < ac->num_searches; i++) {
- req = ac->search_reqs[i];
- ret = ldb_wait(req->handle, LDB_WAIT_NONE);
-
- if (ret != LDB_SUCCESS) {
- handle->status = ret;
- goto done;
- }
- if (req->handle->status != LDB_SUCCESS) {
- handle->status = req->handle->status;
- goto done;
- }
- if (req->handle->state != LDB_ASYNC_DONE) {
- return LDB_SUCCESS;
- }
- }
- } else {
-
- req = map_get_req(ac);
-
- ret = ldb_wait(req->handle, LDB_WAIT_NONE);
-
- if (ret != LDB_SUCCESS) {
- handle->status = ret;
- goto done;
- }
- if (req->handle->status != LDB_SUCCESS) {
- handle->status = req->handle->status;
- goto done;
- }
- if (req->handle->state != LDB_ASYNC_DONE) {
- return LDB_SUCCESS;
- }
-
- next = map_get_next(ac);
- if (next) {
- return next(handle);
- }
- }
-
- ret = LDB_SUCCESS;
-
-done:
- handle->state = LDB_ASYNC_DONE;
- return ret;
-}
-
-/* Wait for all current pending requests to finish. */
-static int map_wait_all(struct ldb_handle *handle)
-{
- int ret;
-
- while (handle->state != LDB_ASYNC_DONE) {
- ret = map_wait_next(handle);
- if (ret != LDB_SUCCESS) {
- return ret;
- }
- }
-
- return handle->status;
-}
-
-/* Wait for pending requests to finish. */
-int map_wait(struct ldb_handle *handle, enum ldb_wait_type type)
-{
- if (type == LDB_WAIT_ALL) {
- return map_wait_all(handle);
- } else {
- return map_wait_next(handle);
- }
-}
-
-
/* Module initialization
* ===================== */
return LDB_ERR_OPERATIONS_ERROR;
}
- ret = ldb_search(module->ldb, dn, LDB_SCOPE_BASE, NULL, attrs, &res);
+ ret = ldb_search(module->ldb, data, &res, dn, LDB_SCOPE_BASE, attrs, NULL);
talloc_free(dn);
if (ret != LDB_SUCCESS) {
return ret;
int map_rename(struct ldb_module *module, struct ldb_request *req);
int map_delete(struct ldb_module *module, struct ldb_request *req);
int map_modify(struct ldb_module *module, struct ldb_request *req);
-int map_wait(struct ldb_handle *handle, enum ldb_wait_type type);
#define LDB_MAP_OPS \
.add = map_add, \
.modify = map_modify, \
.del = map_delete, \
.rename = map_rename, \
- .search = map_search, \
- .wait = map_wait,
+ .search = map_search,
#endif /* __LDB_MAP_H__ */
Copyright (C) Jelmer Vernooij 2005
Copyright (C) Martin Kuehl <mkhl@samba.org> 2006
+ Copyright (C) Simo Sorce <idra@samba.org> 2008
** NOTE! The following LGPL license applies to the ldb
** library. This does NOT imply that all of Samba is released
}
-/* Inbound requests: add, modify, rename, delete
- * ============================================= */
+static int map_add_do_local(struct map_context *ac);
+static int map_modify_do_local(struct map_context *ac);
+static int map_delete_do_local(struct map_context *ac);
+static int map_rename_do_local(struct map_context *ac);
+static int map_rename_do_fixup(struct map_context *ac);
+static int map_rename_local_callback(struct ldb_request *req,
+ struct ldb_reply *ares);
-/* Add the remote record. */
-int map_add_do_remote(struct ldb_handle *handle)
+
+/*****************************************************************************
+ * COMMON INBOUND functions
+*****************************************************************************/
+
+/* Store the DN of a single search result in context. */
+static int map_search_self_callback(struct ldb_request *req, struct ldb_reply *ares)
{
struct map_context *ac;
+ int ret;
- ac = talloc_get_type(handle->private_data, struct map_context);
+ ac = talloc_get_type(req->context, struct map_context);
- ldb_set_timeout_from_prev_req(ac->module->ldb, ac->orig_req, ac->remote_req);
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
- ac->step = MAP_ADD_REMOTE;
+ /* We are interested only in the single reply */
+ switch(ares->type) {
+ case LDB_REPLY_ENTRY:
+ /* We have already found a remote DN */
+ if (ac->local_dn) {
+ ldb_set_errstring(ac->module->ldb,
+ "Too many results!");
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
- handle->state = LDB_ASYNC_INIT;
- handle->status = LDB_SUCCESS;
+ /* Store local DN */
+ ac->local_dn = talloc_steal(ac, ares->message->dn);
+ break;
- return ldb_next_remote_request(ac->module, ac->remote_req);
+ case LDB_REPLY_DONE:
+
+ switch (ac->req->operation) {
+ case LDB_MODIFY:
+ ret = map_modify_do_local(ac);
+ break;
+ case LDB_DELETE:
+ ret = map_delete_do_local(ac);
+ break;
+ case LDB_RENAME:
+ ret = map_rename_do_local(ac);
+ break;
+ default:
+ /* if we get here we have definitely a problem */
+ ret = LDB_ERR_OPERATIONS_ERROR;
+ }
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+
+ default:
+ /* ignore referrals */
+ break;
+ }
+
+ talloc_free(ares);
+ return LDB_SUCCESS;
}
-/* Add the local record. */
-int map_add_do_local(struct ldb_handle *handle)
+/* Build a request to search the local record by its DN. */
+static int map_search_self_req(struct ldb_request **req,
+ struct map_context *ac,
+ struct ldb_dn *dn)
+{
+ /* attrs[] is returned from this function in
+ * ac->search_req->op.search.attrs, so it must be static, as
+ * otherwise the compiler can put it on the stack */
+ static const char * const attrs[] = { IS_MAPPED, NULL };
+ struct ldb_parse_tree *tree;
+
+ /* Limit search to records with 'IS_MAPPED' present */
+ tree = ldb_parse_tree(ac, "(" IS_MAPPED "=*)");
+ if (tree == NULL) {
+ map_oom(ac->module);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ *req = map_search_base_req(ac, dn, attrs, tree,
+ ac, map_search_self_callback);
+ if (*req == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ return LDB_SUCCESS;
+}
+
+static int map_op_local_callback(struct ldb_request *req,
+ struct ldb_reply *ares)
{
struct map_context *ac;
+ int ret;
- ac = talloc_get_type(handle->private_data, struct map_context);
+ ac = talloc_get_type(req->context, struct map_context);
- ldb_set_timeout_from_prev_req(ac->module->ldb, ac->orig_req, ac->local_req);
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
- ac->step = MAP_ADD_LOCAL;
+ if (ares->type != LDB_REPLY_DONE) {
+ ldb_set_errstring(req->handle->ldb, "Invalid reply type!");
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
- handle->state = LDB_ASYNC_INIT;
- handle->status = LDB_SUCCESS;
+ /* Do the remote request. */
+ ret = ldb_next_remote_request(ac->module, ac->remote_req);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
- return ldb_next_request(ac->module, ac->local_req);
+ return LDB_SUCCESS;
}
+static int map_op_remote_callback(struct ldb_request *req,
+ struct ldb_reply *ares)
+{
+ struct map_context *ac;
+
+ ac = talloc_get_type(req->context, struct map_context);
+
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
+
+ if (ares->type != LDB_REPLY_DONE) {
+ ldb_set_errstring(req->handle->ldb, "Invalid reply type!");
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+}
+
+
+/*****************************************************************************
+ * ADD operations
+*****************************************************************************/
+
+
/* Add a record. */
int map_add(struct ldb_module *module, struct ldb_request *req)
{
const struct ldb_message *msg = req->op.add.message;
- struct ldb_handle *h;
struct map_context *ac;
- struct ldb_message *local, *remote;
+ struct ldb_message *remote_msg;
const char *dn;
+ int ret;
/* Do not manipulate our control entries */
if (ldb_dn_is_special(msg->dn)) {
}
/* Prepare context and handle */
- h = map_init_handle(req, module);
- if (h == NULL) {
+ ac = map_init_context(module, req);
+ if (ac == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
- ac = talloc_get_type(h->private_data, struct map_context);
-
- /* Prepare the local operation */
- ac->local_req = talloc(ac, struct ldb_request);
- if (ac->local_req == NULL) {
- goto oom;
- }
- *(ac->local_req) = *req; /* copy the request */
-
- ac->local_req->context = NULL;
- ac->local_req->callback = NULL;
-
- /* Prepare the remote operation */
- ac->remote_req = talloc(ac, struct ldb_request);
- if (ac->remote_req == NULL) {
- goto oom;
- }
-
- *(ac->remote_req) = *req; /* copy the request */
-
- ac->remote_req->context = NULL;
- ac->remote_req->callback = NULL;
/* Prepare the local message */
- local = ldb_msg_new(ac->local_req);
- if (local == NULL) {
- goto oom;
+ ac->local_msg = ldb_msg_new(ac);
+ if (ac->local_msg == NULL) {
+ map_oom(module);
+ return LDB_ERR_OPERATIONS_ERROR;
}
- local->dn = msg->dn;
+ ac->local_msg->dn = msg->dn;
/* Prepare the remote message */
- remote = ldb_msg_new(ac->remote_req);
- if (remote == NULL) {
- goto oom;
+ remote_msg = ldb_msg_new(ac);
+ if (remote_msg == NULL) {
+ map_oom(module);
+ return LDB_ERR_OPERATIONS_ERROR;
}
- remote->dn = ldb_dn_map_local(ac->module, remote, msg->dn);
+ remote_msg->dn = ldb_dn_map_local(ac->module, remote_msg, msg->dn);
/* Split local from remote message */
- ldb_msg_partition(module, local, remote, msg);
- ac->local_req->op.add.message = local;
- ac->remote_req->op.add.message = remote;
+ ldb_msg_partition(module, ac->local_msg, remote_msg, msg);
+
+ /* Prepare the remote operation */
+ ret = ldb_build_add_req(&ac->remote_req, module->ldb,
+ ac, remote_msg,
+ req->controls,
+ ac, map_op_remote_callback,
+ req);
+ if (ret != LDB_SUCCESS) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
- if ((local->num_elements == 0) || (!map_check_local_db(ac->module))) {
+ if ((ac->local_msg->num_elements == 0) ||
+ ( ! map_check_local_db(ac->module))) {
/* No local data or db, just run the remote request */
- talloc_free(ac->local_req);
- req->handle = h; /* return our own handle to deal with this call */
- return map_add_do_remote(h);
+ return ldb_next_remote_request(ac->module, ac->remote_req);
}
/* Store remote DN in 'IS_MAPPED' */
/* TODO: use GUIDs here instead */
- dn = ldb_dn_alloc_linearized(local, remote->dn);
- if (ldb_msg_add_string(local, IS_MAPPED, dn) != 0) {
- goto failed;
+ dn = ldb_dn_alloc_linearized(ac->local_msg, remote_msg->dn);
+ if (ldb_msg_add_string(ac->local_msg, IS_MAPPED, dn) != 0) {
+ return LDB_ERR_OPERATIONS_ERROR;
}
- req->handle = h; /* return our own handle to deal with this call */
- return map_add_do_local(h);
-
-oom:
- map_oom(module);
-failed:
- talloc_free(h);
- return LDB_ERR_OPERATIONS_ERROR;
-}
-
-/* Modify the remote record. */
-int map_modify_do_remote(struct ldb_handle *handle)
-{
- struct map_context *ac;
-
- ac = talloc_get_type(handle->private_data, struct map_context);
-
- ldb_set_timeout_from_prev_req(ac->module->ldb, ac->orig_req, ac->remote_req);
-
- ac->step = MAP_MODIFY_REMOTE;
-
- handle->state = LDB_ASYNC_INIT;
- handle->status = LDB_SUCCESS;
-
- return ldb_next_remote_request(ac->module, ac->remote_req);
+ return map_add_do_local(ac);
}
-/* Modify the local record. */
-int map_modify_do_local(struct ldb_handle *handle)
+/* Add the local record. */
+static int map_add_do_local(struct map_context *ac)
{
- struct map_context *ac;
- struct ldb_message *msg;
- char *dn;
-
- ac = talloc_get_type(handle->private_data, struct map_context);
-
- if (ac->local_dn == NULL) {
- /* No local record present, add it instead */
- msg = discard_const_p(struct ldb_message, ac->local_req->op.mod.message);
-
- /* Add local 'IS_MAPPED' */
- /* TODO: use GUIDs here instead */
- if (ldb_msg_add_empty(msg, IS_MAPPED, LDB_FLAG_MOD_ADD, NULL) != 0) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
- dn = ldb_dn_alloc_linearized(msg, ac->remote_req->op.mod.message->dn);
- if (ldb_msg_add_string(msg, IS_MAPPED, dn) != 0) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
+ struct ldb_request *local_req;
+ int ret;
- /* Turn request into 'add' */
- ac->local_req->operation = LDB_ADD;
- ac->local_req->op.add.message = msg;
- /* TODO: Could I just leave msg in there? I think so,
- * but it looks clearer this way. */
+ /* Prepare the local operation */
+ ret = ldb_build_add_req(&local_req, ac->module->ldb, ac,
+ ac->local_msg,
+ ac->req->controls,
+ ac,
+ map_op_local_callback,
+ ac->req);
+ if (ret != LDB_SUCCESS) {
+ return LDB_ERR_OPERATIONS_ERROR;
}
-
- ldb_set_timeout_from_prev_req(ac->module->ldb, ac->orig_req, ac->local_req);
-
- ac->step = MAP_MODIFY_LOCAL;
-
- handle->state = LDB_ASYNC_INIT;
- handle->status = LDB_SUCCESS;
-
- return ldb_next_request(ac->module, ac->local_req);
+ return ldb_next_request(ac->module, local_req);
}
+/*****************************************************************************
+ * MODIFY operations
+*****************************************************************************/
+
/* Modify a record. */
int map_modify(struct ldb_module *module, struct ldb_request *req)
{
const struct ldb_message *msg = req->op.mod.message;
- struct ldb_handle *h;
+ struct ldb_request *search_req;
+ struct ldb_message *remote_msg;
struct map_context *ac;
- struct ldb_message *local, *remote;
+ int ret;
/* Do not manipulate our control entries */
if (ldb_dn_is_special(msg->dn)) {
}
/* Prepare context and handle */
- h = map_init_handle(req, module);
- if (h == NULL) {
+ ac = map_init_context(module, req);
+ if (ac == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
- ac = talloc_get_type(h->private_data, struct map_context);
-
- /* Prepare the local operation */
- ac->local_req = talloc(ac, struct ldb_request);
- if (ac->local_req == NULL) {
- goto oom;
- }
-
- *(ac->local_req) = *req; /* copy the request */
-
- ac->local_req->context = NULL;
- ac->local_req->callback = NULL;
-
- /* Prepare the remote operation */
- ac->remote_req = talloc(ac, struct ldb_request);
- if (ac->remote_req == NULL) {
- goto oom;
- }
-
- *(ac->remote_req) = *req; /* copy the request */
-
- ac->remote_req->context = NULL;
- ac->remote_req->callback = NULL;
/* Prepare the local message */
- local = ldb_msg_new(ac->local_req);
- if (local == NULL) {
- goto oom;
+ ac->local_msg = ldb_msg_new(ac);
+ if (ac->local_msg == NULL) {
+ map_oom(module);
+ return LDB_ERR_OPERATIONS_ERROR;
}
- local->dn = msg->dn;
+ ac->local_msg->dn = msg->dn;
/* Prepare the remote message */
- remote = ldb_msg_new(ac->remote_req);
- if (remote == NULL) {
- goto oom;
+ remote_msg = ldb_msg_new(ac->remote_req);
+ if (remote_msg == NULL) {
+ map_oom(module);
+ return LDB_ERR_OPERATIONS_ERROR;
}
- remote->dn = ldb_dn_map_local(ac->module, remote, msg->dn);
+ remote_msg->dn = ldb_dn_map_local(ac->module, remote_msg, msg->dn);
/* Split local from remote message */
- ldb_msg_partition(module, local, remote, msg);
- ac->local_req->op.mod.message = local;
- ac->remote_req->op.mod.message = remote;
+ ldb_msg_partition(module, ac->local_msg, remote_msg, msg);
+
+ /* Prepare the remote operation */
+ ret = ldb_build_mod_req(&ac->remote_req, module->ldb,
+ ac, remote_msg,
+ req->controls,
+ ac, map_op_remote_callback,
+ req);
+ if (ret != LDB_SUCCESS) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
- if ((local->num_elements == 0) || (!map_check_local_db(ac->module))) {
+ if ((ac->local_msg->num_elements == 0) ||
+ ( ! map_check_local_db(ac->module))) {
/* No local data or db, just run the remote request */
- talloc_free(ac->local_req);
- req->handle = h; /* return our own handle to deal with this call */
- return map_modify_do_remote(h);
+ return ldb_next_remote_request(ac->module, ac->remote_req);
}
/* prepare the search operation */
- ac->search_req = map_search_self_req(ac, msg->dn);
- if (ac->search_req == NULL) {
- goto failed;
+ ret = map_search_self_req(&search_req, ac, msg->dn);
+ if (ret != LDB_SUCCESS) {
+ return LDB_ERR_OPERATIONS_ERROR;
}
- ac->step = MAP_SEARCH_SELF_MODIFY;
-
- req->handle = h; /* return our own handle to deal with this call */
- return ldb_next_request(module, ac->search_req);
-
-oom:
- map_oom(module);
-failed:
- talloc_free(h);
- return LDB_ERR_OPERATIONS_ERROR;
-}
-
-/* Delete the remote record. */
-int map_delete_do_remote(struct ldb_handle *handle)
-{
- struct map_context *ac;
-
- ac = talloc_get_type(handle->private_data, struct map_context);
-
- ldb_set_timeout_from_prev_req(ac->module->ldb, ac->orig_req, ac->remote_req);
-
- ac->step = MAP_DELETE_REMOTE;
-
- handle->state = LDB_ASYNC_INIT;
- handle->status = LDB_SUCCESS;
-
- return ldb_next_remote_request(ac->module, ac->remote_req);
+ return ldb_next_request(module, search_req);
}
-/* Delete the local record. */
-int map_delete_do_local(struct ldb_handle *handle)
+/* Modify the local record. */
+static int map_modify_do_local(struct map_context *ac)
{
- struct map_context *ac;
-
- ac = talloc_get_type(handle->private_data, struct map_context);
+ struct ldb_request *local_req;
+ char *dn;
+ int ret;
- /* No local record, continue remotely */
if (ac->local_dn == NULL) {
- return map_delete_do_remote(handle);
- }
-
- ldb_set_timeout_from_prev_req(ac->module->ldb, ac->orig_req, ac->local_req);
-
- ac->step = MAP_DELETE_LOCAL;
+ /* No local record present, add it instead */
+ /* Add local 'IS_MAPPED' */
+ /* TODO: use GUIDs here instead */
+ if (ldb_msg_add_empty(ac->local_msg, IS_MAPPED,
+ LDB_FLAG_MOD_ADD, NULL) != 0) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ dn = ldb_dn_alloc_linearized(ac->local_msg,
+ ac->remote_req->op.mod.message->dn);
+ if (ldb_msg_add_string(ac->local_msg, IS_MAPPED, dn) != 0) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
- handle->state = LDB_ASYNC_INIT;
- handle->status = LDB_SUCCESS;
+ /* Prepare the local operation */
+ ret = ldb_build_add_req(&local_req, ac->module->ldb, ac,
+ ac->local_msg,
+ ac->req->controls,
+ ac,
+ map_op_local_callback,
+ ac->req);
+ if (ret != LDB_SUCCESS) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ } else {
+ /* Prepare the local operation */
+ ret = ldb_build_mod_req(&local_req, ac->module->ldb, ac,
+ ac->local_msg,
+ ac->req->controls,
+ ac,
+ map_op_local_callback,
+ ac->req);
+ if (ret != LDB_SUCCESS) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ }
- return ldb_next_request(ac->module, ac->local_req);
+ return ldb_next_request(ac->module, local_req);
}
+/*****************************************************************************
+ * DELETE operations
+*****************************************************************************/
+
/* Delete a record. */
int map_delete(struct ldb_module *module, struct ldb_request *req)
{
- struct ldb_handle *h;
+ struct ldb_request *search_req;
struct map_context *ac;
+ int ret;
/* Do not manipulate our control entries */
if (ldb_dn_is_special(req->op.del.dn)) {
return ldb_next_request(module, req);
}
- /* No mapping requested (perhaps no DN mapping specified), skip to next module */
+ /* No mapping requested (perhaps no DN mapping specified).
+ * Skip to next module */
if (!ldb_dn_check_local(module, req->op.del.dn)) {
return ldb_next_request(module, req);
}
/* Prepare context and handle */
- h = map_init_handle(req, module);
- if (h == NULL) {
+ ac = map_init_context(module, req);
+ if (ac == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
- ac = talloc_get_type(h->private_data, struct map_context);
-
- /* Prepare the local operation */
- ac->local_req = talloc(ac, struct ldb_request);
- if (ac->local_req == NULL) {
- goto oom;
- }
-
- *(ac->local_req) = *req; /* copy the request */
- ac->local_req->op.del.dn = req->op.del.dn;
-
- ac->local_req->context = NULL;
- ac->local_req->callback = NULL;
/* Prepare the remote operation */
- ac->remote_req = talloc(ac, struct ldb_request);
- if (ac->remote_req == NULL) {
- goto oom;
+ ret = ldb_build_del_req(&ac->remote_req, module->ldb, ac,
+ ldb_dn_map_local(module, ac, req->op.del.dn),
+ req->controls,
+ ac,
+ map_op_remote_callback,
+ req);
+ if (ret != LDB_SUCCESS) {
+ return LDB_ERR_OPERATIONS_ERROR;
}
- *(ac->remote_req) = *req; /* copy the request */
- ac->remote_req->op.del.dn = ldb_dn_map_local(module, ac->remote_req, req->op.del.dn);
-
/* No local db, just run the remote request */
if (!map_check_local_db(ac->module)) {
- req->handle = h; /* return our own handle to deal with this call */
- return map_delete_do_remote(h);
+ /* Do the remote request. */
+ return ldb_next_remote_request(ac->module, ac->remote_req);
}
- ac->remote_req->context = NULL;
- ac->remote_req->callback = NULL;
-
/* Prepare the search operation */
- ac->search_req = map_search_self_req(ac, req->op.del.dn);
- if (ac->search_req == NULL) {
- goto failed;
+ ret = map_search_self_req(&search_req, ac, req->op.del.dn);
+ if (ret != LDB_SUCCESS) {
+ map_oom(module);
+ return LDB_ERR_OPERATIONS_ERROR;
}
- req->handle = h; /* return our own handle to deal with this call */
-
- ac->step = MAP_SEARCH_SELF_DELETE;
-
- return ldb_next_request(module, ac->search_req);
-
-oom:
- map_oom(module);
-failed:
- talloc_free(h);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_next_request(module, search_req);
}
-/* Rename the remote record. */
-int map_rename_do_remote(struct ldb_handle *handle)
-{
- struct map_context *ac;
-
- ac = talloc_get_type(handle->private_data, struct map_context);
-
- ldb_set_timeout_from_prev_req(ac->module->ldb, ac->orig_req, ac->remote_req);
-
- ac->step = MAP_RENAME_REMOTE;
-
- handle->state = LDB_ASYNC_INIT;
- handle->status = LDB_SUCCESS;
-
- return ldb_next_remote_request(ac->module, ac->remote_req);
-}
-
-/* Update the local 'IS_MAPPED' attribute. */
-int map_rename_do_fixup(struct ldb_handle *handle)
-{
- struct map_context *ac;
-
- ac = talloc_get_type(handle->private_data, struct map_context);
-
- ldb_set_timeout_from_prev_req(ac->module->ldb, ac->orig_req, ac->down_req);
-
- ac->step = MAP_RENAME_FIXUP;
-
- handle->state = LDB_ASYNC_INIT;
- handle->status = LDB_SUCCESS;
-
- return ldb_next_request(ac->module, ac->down_req);
-}
-
-/* Rename the local record. */
-int map_rename_do_local(struct ldb_handle *handle)
+/* Delete the local record. */
+static int map_delete_do_local(struct map_context *ac)
{
- struct map_context *ac;
-
- ac = talloc_get_type(handle->private_data, struct map_context);
+ struct ldb_request *local_req;
+ int ret;
/* No local record, continue remotely */
if (ac->local_dn == NULL) {
- return map_rename_do_remote(handle);
+ /* Do the remote request. */
+ return ldb_next_remote_request(ac->module, ac->remote_req);
}
- ldb_set_timeout_from_prev_req(ac->module->ldb, ac->orig_req, ac->local_req);
-
- ac->step = MAP_RENAME_LOCAL;
-
- handle->state = LDB_ASYNC_INIT;
- handle->status = LDB_SUCCESS;
-
- return ldb_next_request(ac->module, ac->local_req);
+ /* Prepare the local operation */
+ ret = ldb_build_del_req(&local_req, ac->module->ldb, ac,
+ ac->req->op.del.dn,
+ ac->req->controls,
+ ac,
+ map_op_local_callback,
+ ac->req);
+ if (ret != LDB_SUCCESS) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ return ldb_next_request(ac->module, local_req);
}
+/*****************************************************************************
+ * RENAME operations
+*****************************************************************************/
+
/* Rename a record. */
int map_rename(struct ldb_module *module, struct ldb_request *req)
{
- struct ldb_handle *h;
+ struct ldb_request *search_req;
struct map_context *ac;
+ int ret;
/* Do not manipulate our control entries */
if (ldb_dn_is_special(req->op.rename.olddn)) {
return ldb_next_request(module, req);
}
- /* No mapping requested (perhaps no DN mapping specified), skip to next module */
+ /* No mapping requested (perhaps no DN mapping specified).
+ * Skip to next module */
if ((!ldb_dn_check_local(module, req->op.rename.olddn)) &&
(!ldb_dn_check_local(module, req->op.rename.newdn))) {
return ldb_next_request(module, req);
}
/* Prepare context and handle */
- h = map_init_handle(req, module);
- if (h == NULL) {
+ ac = map_init_context(module, req);
+ if (ac == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
- ac = talloc_get_type(h->private_data, struct map_context);
- /* Prepare the local operation */
- ac->local_req = talloc(ac, struct ldb_request);
- if (ac->local_req == NULL) {
- goto oom;
+ /* Prepare the remote operation */
+ ret = ldb_build_rename_req(&ac->remote_req, module->ldb, ac,
+ ldb_dn_map_local(module, ac, req->op.rename.olddn),
+ ldb_dn_map_local(module, ac, req->op.rename.newdn),
+ req->controls,
+ ac, map_op_remote_callback,
+ req);
+ if (ret != LDB_SUCCESS) {
+ return LDB_ERR_OPERATIONS_ERROR;
}
- *(ac->local_req) = *req; /* copy the request */
- ac->local_req->op.rename.olddn = req->op.rename.olddn;
- ac->local_req->op.rename.newdn = req->op.rename.newdn;
+ /* No local db, just run the remote request */
+ if (!map_check_local_db(ac->module)) {
+ /* Do the remote request. */
+ return ldb_next_remote_request(ac->module, ac->remote_req);
+ }
- ac->local_req->context = NULL;
- ac->local_req->callback = NULL;
+ /* Prepare the search operation */
+ ret = map_search_self_req(&search_req, ac, req->op.rename.olddn);
+ if (ret != LDB_SUCCESS) {
+ map_oom(module);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
- /* Prepare the remote operation */
- ac->remote_req = talloc(ac, struct ldb_request);
- if (ac->remote_req == NULL) {
- goto oom;
+ return ldb_next_request(module, search_req);
+}
+
+/* Rename the local record. */
+static int map_rename_do_local(struct map_context *ac)
+{
+ struct ldb_request *local_req;
+ int ret;
+
+ /* No local record, continue remotely */
+ if (ac->local_dn == NULL) {
+ /* Do the remote request. */
+ return ldb_next_remote_request(ac->module, ac->remote_req);
}
- *(ac->remote_req) = *req; /* copy the request */
- ac->remote_req->op.rename.olddn = ldb_dn_map_local(module, ac->remote_req, req->op.rename.olddn);
- ac->remote_req->op.rename.newdn = ldb_dn_map_local(module, ac->remote_req, req->op.rename.newdn);
+ /* Prepare the local operation */
+ ret = ldb_build_rename_req(&local_req, ac->module->ldb, ac,
+ ac->req->op.rename.olddn,
+ ac->req->op.rename.newdn,
+ ac->req->controls,
+ ac,
+ map_rename_local_callback,
+ ac->req);
+ if (ret != LDB_SUCCESS) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
- ac->remote_req->context = NULL;
- ac->remote_req->callback = NULL;
+ return ldb_next_request(ac->module, local_req);
+}
- /* No local db, just run the remote request */
- if (!map_check_local_db(ac->module)) {
- req->handle = h; /* return our own handle to deal with this call */
- return map_rename_do_remote(h);
+static int map_rename_local_callback(struct ldb_request *req,
+ struct ldb_reply *ares)
+{
+ struct map_context *ac;
+ int ret;
+
+ ac = talloc_get_type(req->context, struct map_context);
+
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
}
- /* Prepare the fixup operation */
- /* TODO: use GUIDs here instead -- or skip it when GUIDs are used. */
- ac->down_req = map_build_fixup_req(ac, req->op.rename.newdn, ac->remote_req->op.rename.newdn);
- if (ac->down_req == NULL) {
- goto failed;
+ if (ares->type != LDB_REPLY_DONE) {
+ ldb_set_errstring(req->handle->ldb, "Invalid reply type!");
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
- /* Prepare the search operation */
- ac->search_req = map_search_self_req(ac, req->op.rename.olddn);
- if (ac->search_req == NULL) {
- goto failed;
+ /* proceed with next step */
+ ret = map_rename_do_fixup(ac);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
- req->handle = h; /* return our own handle to deal with this call */
+ return LDB_SUCCESS;
+}
- ac->step = MAP_SEARCH_SELF_RENAME;
+/* Update the local 'IS_MAPPED' attribute. */
+static int map_rename_do_fixup(struct map_context *ac)
+{
+ struct ldb_request *local_req;
- return ldb_next_request(module, ac->search_req);
+ /* Prepare the fixup operation */
+ /* TODO: use GUIDs here instead -- or skip it when GUIDs are used. */
+ local_req = map_build_fixup_req(ac,
+ ac->req->op.rename.newdn,
+ ac->remote_req->op.rename.newdn,
+ ac,
+ map_op_local_callback);
+ if (local_req == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
-oom:
- map_oom(module);
-failed:
- talloc_free(h);
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_next_request(ac->module, local_req);
}
Copyright (C) Jelmer Vernooij 2005
Copyright (C) Martin Kuehl <mkhl@samba.org> 2006
Copyright (C) Andrew Bartlett <abartlet@samba.org> 2006
+ Copyright (C) Simo Sorce <idra@samba.org> 2008
** NOTE! The following LGPL license applies to the ldb
** library. This does NOT imply that all of Samba is released
/* Split subtrees that query attributes in the local partition from
* those that query the remote partition. */
-static int ldb_parse_tree_partition(struct ldb_module *module, void *local_ctx, void *remote_ctx, struct ldb_parse_tree **local_tree, struct ldb_parse_tree **remote_tree, const struct ldb_parse_tree *tree)
+static int ldb_parse_tree_partition(struct ldb_module *module,
+ void *mem_ctx,
+ struct ldb_parse_tree **local_tree,
+ struct ldb_parse_tree **remote_tree,
+ const struct ldb_parse_tree *tree)
{
int ret;
}
/* Generate local tree */
- ret = map_subtree_select_local(module, local_ctx, local_tree, tree);
+ ret = map_subtree_select_local(module, mem_ctx, local_tree, tree);
if (ret) {
return ret;
}
/* Generate remote tree */
- ret = map_subtree_collect_remote(module, remote_ctx, remote_tree, tree);
+ ret = map_subtree_collect_remote(module, mem_ctx, remote_tree, tree);
if (ret) {
talloc_free(*local_tree);
return ret;
/* Outbound requests: search
* ========================= */
-/* Pass a merged search result up the callback chain. */
-int map_up_callback(struct ldb_context *ldb, const struct ldb_request *req, struct ldb_reply *ares)
+static int map_remote_search_callback(struct ldb_request *req,
+ struct ldb_reply *ares);
+static int map_local_merge_callback(struct ldb_request *req,
+ struct ldb_reply *ares);
+static int map_search_local(struct map_context *ac);
+
+static int map_save_entry(struct map_context *ac, struct ldb_reply *ares)
{
- int i;
+ struct map_reply *mr;
- /* No callback registered, stop */
- if (req->callback == NULL) {
- return LDB_SUCCESS;
+ mr = talloc_zero(ac, struct map_reply);
+ if (mr == NULL) {
+ map_oom(ac->module);
+ return LDB_ERR_OPERATIONS_ERROR;
}
-
- /* Only records need special treatment */
- if (ares->type != LDB_REPLY_ENTRY) {
- return req->callback(ldb, req->context, ares);
+ mr->remote = talloc_steal(mr, ares);
+ if (ac->r_current) {
+ ac->r_current->next = mr;
+ } else {
+ /* first entry */
+ ac->r_list = mr;
}
+ ac->r_current = mr;
+
+ return LDB_SUCCESS;
+}
+
+/* Pass a merged search result up the callback chain. */
+int map_return_entry(struct map_context *ac, struct ldb_reply *ares)
+{
+ struct ldb_message_element *el;
+ const char * const *attrs;
+ int i;
/* Merged result doesn't match original query, skip */
- if (!ldb_match_msg(ldb, ares->message, req->op.search.tree, req->op.search.base, req->op.search.scope)) {
- ldb_debug(ldb, LDB_DEBUG_TRACE, "ldb_map: "
+ if (!ldb_match_msg(ac->module->ldb, ares->message,
+ ac->req->op.search.tree,
+ ac->req->op.search.base,
+ ac->req->op.search.scope)) {
+ ldb_debug(ac->module->ldb, LDB_DEBUG_TRACE, "ldb_map: "
"Skipping record '%s': "
"doesn't match original search\n",
ldb_dn_get_linearized(ares->message->dn));
}
/* Limit result to requested attrs */
- if ((req->op.search.attrs) && (!ldb_attr_in_list(req->op.search.attrs, "*"))) {
- for (i = 0; i < ares->message->num_elements; ) {
- struct ldb_message_element *el = &ares->message->elements[i];
- if (!ldb_attr_in_list(req->op.search.attrs, el->name)) {
+ if (ac->req->op.search.attrs &&
+ (! ldb_attr_in_list(ac->req->op.search.attrs, "*"))) {
+
+ attrs = ac->req->op.search.attrs;
+ i = 0;
+
+ while (i < ares->message->num_elements) {
+
+ el = &ares->message->elements[i];
+ if ( ! ldb_attr_in_list(attrs, el->name)) {
ldb_msg_remove_element(ares->message, el);
} else {
i++;
}
}
- return req->callback(ldb, req->context, ares);
-}
-
-/* Merge the remote and local parts of a search result. */
-int map_local_merge_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
-{
- struct map_search_context *sc;
- int ret;
-
- if (context == NULL || ares == NULL) {
- ldb_set_errstring(ldb, talloc_asprintf(ldb, "ldb_map: "
- "NULL Context or Result in `map_local_merge_callback`"));
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- sc = talloc_get_type(context, struct map_search_context);
-
- switch (ares->type) {
- case LDB_REPLY_ENTRY:
- /* We have already found a local record */
- if (sc->local_res) {
- ldb_set_errstring(ldb, talloc_asprintf(ldb, "ldb_map: "
- "Too many results to base search for local entry"));
- talloc_free(ares);
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- /* Store local result */
- sc->local_res = ares;
-
- /* Merge remote into local message */
- ret = ldb_msg_merge_local(sc->ac->module, ares->message, sc->remote_res->message);
- if (ret) {
- talloc_free(ares);
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- return map_up_callback(ldb, sc->ac->orig_req, ares);
-
- case LDB_REPLY_DONE:
- /* No local record found, continue with remote record */
- if (sc->local_res == NULL) {
- return map_up_callback(ldb, sc->ac->orig_req, sc->remote_res);
- }
- return LDB_SUCCESS;
-
- default:
- ldb_set_errstring(ldb, talloc_asprintf(ldb, "ldb_map: "
- "Unexpected result type in base search for local entry"));
- talloc_free(ares);
- return LDB_ERR_OPERATIONS_ERROR;
- }
-}
-
-/* Search the local part of a remote search result. */
-int map_remote_search_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
-{
- struct map_context *ac;
- struct map_search_context *sc;
- struct ldb_request *req;
- int ret;
-
- if (context == NULL || ares == NULL) {
- ldb_set_errstring(ldb, talloc_asprintf(ldb, "ldb_map: "
- "NULL Context or Result in `map_remote_search_callback`"));
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- ac = talloc_get_type(context, struct map_context);
-
- /* It's not a record, stop searching */
- if (ares->type != LDB_REPLY_ENTRY) {
- return map_up_callback(ldb, ac->orig_req, ares);
- }
-
- /* Map result record into a local message */
- ret = map_reply_remote(ac, ares);
- if (ret) {
- talloc_free(ares);
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- /* There is no local db, stop searching */
- if (!map_check_local_db(ac->module)) {
- return map_up_callback(ldb, ac->orig_req, ares);
- }
-
- /* Prepare local search context */
- sc = map_init_search_context(ac, ares);
- if (sc == NULL) {
- talloc_free(ares);
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- /* Prepare local search request */
- /* TODO: use GUIDs here instead? */
-
- ac->search_reqs = talloc_realloc(ac, ac->search_reqs, struct ldb_request *, ac->num_searches + 2);
- if (ac->search_reqs == NULL) {
- talloc_free(ares);
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- ac->search_reqs[ac->num_searches]
- = req = map_search_base_req(ac, ares->message->dn,
- NULL, NULL, sc, map_local_merge_callback);
- if (req == NULL) {
- talloc_free(sc);
- talloc_free(ares);
- return LDB_ERR_OPERATIONS_ERROR;
- }
- ac->num_searches++;
- ac->search_reqs[ac->num_searches] = NULL;
-
- return ldb_next_request(ac->module, req);
+ return ldb_module_send_entry(ac->req, ares->message);
}
/* Search a record. */
int map_search(struct ldb_module *module, struct ldb_request *req)
{
- struct ldb_handle *h;
+ struct ldb_parse_tree *remote_tree;
+ struct ldb_parse_tree *local_tree;
+ struct ldb_request *remote_req;
struct map_context *ac;
- struct ldb_parse_tree *local_tree, *remote_tree;
int ret;
const char *wildcard[] = { "*", NULL };
return ldb_next_request(module, req);
/* Do not manipulate our control entries */
- if (ldb_dn_is_special(req->op.search.base))
+ if (ldb_dn_is_special(req->op.search.base)) {
return ldb_next_request(module, req);
+ }
/* No mapping requested, skip to next module */
if ((req->op.search.base) && (!ldb_dn_check_local(module, req->op.search.base))) {
* targetting when there is no search base? */
/* Prepare context and handle */
- h = map_init_handle(req, module);
- if (h == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
- ac = talloc_get_type(h->private_data, struct map_context);
-
- ac->search_reqs = talloc_array(ac, struct ldb_request *, 2);
- if (ac->search_reqs == NULL) {
- talloc_free(h);
+ ac = map_init_context(module, req);
+ if (ac == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
- ac->num_searches = 1;
- ac->search_reqs[1] = NULL;
-
- /* Prepare the remote operation */
- ac->search_reqs[0] = talloc(ac, struct ldb_request);
- if (ac->search_reqs[0] == NULL) {
- goto oom;
- }
-
- *(ac->search_reqs[0]) = *req; /* copy the request */
-
- ac->search_reqs[0]->handle = h; /* return our own handle to deal with this call */
-
- ac->search_reqs[0]->context = ac;
- ac->search_reqs[0]->callback = map_remote_search_callback;
/* It is easier to deal with the two different ways of
* expressing the wildcard in the same codepath */
ret = map_attrs_collect_and_partition(module, ac,
attrs, req->op.search.tree);
if (ret) {
- goto failed;
+ return LDB_ERR_OPERATIONS_ERROR;
}
- ac->search_reqs[0]->op.search.attrs = ac->remote_attrs;
-
/* Split local from remote tree */
- ret = ldb_parse_tree_partition(module, ac, ac->search_reqs[0],
- &local_tree, &remote_tree,
+ ret = ldb_parse_tree_partition(module, ac,
+ &local_tree, &remote_tree,
req->op.search.tree);
if (ret) {
- goto failed;
+ return LDB_ERR_OPERATIONS_ERROR;
}
if (((local_tree != NULL) && (remote_tree != NULL)) &&
local_tree = talloc_zero(ac, struct ldb_parse_tree);
if (local_tree == NULL) {
map_oom(ac->module);
- goto failed;
+ return LDB_ERR_OPERATIONS_ERROR;
}
local_tree->operation = LDB_OP_PRESENT;
}
if (remote_tree == NULL) {
/* Construct default remote parse tree */
- remote_tree = ldb_parse_tree(ac->search_reqs[0], NULL);
+ remote_tree = ldb_parse_tree(ac, NULL);
if (remote_tree == NULL) {
- goto failed;
+ return LDB_ERR_OPERATIONS_ERROR;
}
}
ac->local_tree = local_tree;
- ac->search_reqs[0]->op.search.tree = remote_tree;
- ldb_set_timeout_from_prev_req(module->ldb, req, ac->search_reqs[0]);
+ /* Prepare the remote operation */
+ ret = ldb_build_search_req_ex(&remote_req, module->ldb, ac,
+ req->op.search.base,
+ req->op.search.scope,
+ remote_tree,
+ ac->remote_attrs,
+ req->controls,
+ ac, map_remote_search_callback,
+ req);
+ if (ret != LDB_SUCCESS) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
- h->state = LDB_ASYNC_INIT;
- h->status = LDB_SUCCESS;
+ return ldb_next_remote_request(module, remote_req);
+}
+
+/* Now, search the local part of a remote search result. */
+static int map_remote_search_callback(struct ldb_request *req,
+ struct ldb_reply *ares)
+{
+ struct map_context *ac;
+ int ret;
- ac->step = MAP_SEARCH_REMOTE;
+ ac = talloc_get_type(req->context, struct map_context);
- ret = ldb_next_remote_request(module, ac->search_reqs[0]);
- if (ret == LDB_SUCCESS) {
- req->handle = h;
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
}
- return ret;
-oom:
- map_oom(module);
-failed:
- talloc_free(h);
- return LDB_ERR_OPERATIONS_ERROR;
+ switch (ares->type) {
+ case LDB_REPLY_REFERRAL:
+
+ /* ignore referrals */
+ talloc_free(ares);
+ return LDB_SUCCESS;
+
+ case LDB_REPLY_ENTRY:
+
+ /* Map result record into a local message */
+ ret = map_reply_remote(ac, ares);
+ if (ret) {
+ talloc_free(ares);
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+
+ /* if we have no local db, then we can just return the reply to
+ * the upper layer, otherwise we must save it and process it
+ * when all replies ahve been gathered */
+ if ( ! map_check_local_db(ac->module)) {
+ ret = map_return_entry(ac, ares);
+ } else {
+ ret = map_save_entry(ac,ares);
+ }
+
+ if (ret != LDB_SUCCESS) {
+ talloc_free(ares);
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ break;
+
+ case LDB_REPLY_DONE:
+
+ if ( ! map_check_local_db(ac->module)) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, LDB_SUCCESS);
+ }
+
+ talloc_free(ares);
+
+ /* reset the pointer to the start of the list */
+ ac->r_current = ac->r_list;
+
+ /* no entry just return */
+ if (ac->r_current == NULL) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, LDB_SUCCESS);
+ }
+
+ ret = map_search_local(ac);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL, ret);
+ }
+ }
+
+ return LDB_SUCCESS;
+}
+
+static int map_search_local(struct map_context *ac)
+{
+ struct ldb_request *search_req;
+
+ if (ac->r_current == NULL || ac->r_current->remote == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ /* Prepare local search request */
+ /* TODO: use GUIDs here instead? */
+ search_req = map_search_base_req(ac,
+ ac->r_current->remote->message->dn,
+ NULL, NULL,
+ ac, map_local_merge_callback);
+ if (search_req == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ return ldb_next_request(ac->module, search_req);
+}
+
+/* Merge the remote and local parts of a search result. */
+int map_local_merge_callback(struct ldb_request *req, struct ldb_reply *ares)
+{
+ struct map_context *ac;
+ int ret;
+
+ ac = talloc_get_type(req->context, struct map_context);
+
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
+
+ switch (ares->type) {
+ case LDB_REPLY_ENTRY:
+ /* We have already found a local record */
+ if (ac->r_current->local) {
+ talloc_free(ares);
+ ldb_set_errstring(ac->module->ldb, "ldb_map: Too many results!");
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+
+ /* Store local result */
+ ac->r_current->local = talloc_steal(ac->r_current, ares);
+
+ break;
+
+ case LDB_REPLY_REFERRAL:
+ /* ignore referrals */
+ talloc_free(ares);
+ break;
+
+ case LDB_REPLY_DONE:
+ talloc_free(ares);
+
+ /* No local record found, map and send remote record */
+ if (ac->r_current->local != NULL) {
+ /* Merge remote into local message */
+ ret = ldb_msg_merge_local(ac->module,
+ ac->r_current->local->message,
+ ac->r_current->remote->message);
+ if (ret == LDB_SUCCESS) {
+ ret = map_return_entry(ac, ac->r_current->local);
+ }
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ } else {
+ ret = map_return_entry(ac, ac->r_current->remote);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req,
+ NULL, NULL, ret);
+ }
+ }
+
+ if (ac->r_current->next != NULL) {
+ ac->r_current = ac->r_current->next;
+ if (ac->r_current->remote->type == LDB_REPLY_ENTRY) {
+ ret = map_search_local(ac);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req,
+ NULL, NULL, ret);
+ }
+ break;
+ }
+ }
+
+ /* ok we are done with all search, finally it is time to
+ * finish operations for this module */
+ return ldb_module_done(ac->req,
+ ac->r_current->remote->controls,
+ ac->r_current->remote->response,
+ ac->r_current->remote->error);
+ }
+
+ return LDB_SUCCESS;
}
#define map_oom(module) ldb_set_errstring(module->ldb, talloc_asprintf(module, "Out of Memory"));
/* The type of search callback functions */
-typedef int (*ldb_search_callback)(struct ldb_context *, void *, struct ldb_reply *);
+typedef int (*ldb_map_callback_t)(struct ldb_request *, struct ldb_reply *);
/* The special DN from which the local and remote base DNs are fetched */
#define MAP_DN_NAME "@MAP"
/* Private data structures
* ======================= */
+struct map_reply {
+ struct map_reply *next;
+ struct ldb_reply *remote;
+ struct ldb_reply *local;
+};
+
/* Context data for mapped requests */
struct map_context {
- enum map_step {
- MAP_SEARCH_REMOTE,
- MAP_ADD_REMOTE,
- MAP_ADD_LOCAL,
- MAP_SEARCH_SELF_MODIFY,
- MAP_MODIFY_REMOTE,
- MAP_MODIFY_LOCAL,
- MAP_SEARCH_SELF_DELETE,
- MAP_DELETE_REMOTE,
- MAP_DELETE_LOCAL,
- MAP_SEARCH_SELF_RENAME,
- MAP_RENAME_REMOTE,
- MAP_RENAME_FIXUP,
- MAP_RENAME_LOCAL
- } step;
struct ldb_module *module;
+ struct ldb_request *req;
struct ldb_dn *local_dn;
const struct ldb_parse_tree *local_tree;
const char * const *remote_attrs;
const char * const *all_attrs;
- struct ldb_request *orig_req;
- struct ldb_request *local_req;
+ struct ldb_message *local_msg;
struct ldb_request *remote_req;
- struct ldb_request *down_req;
- struct ldb_request *search_req;
-
- /* for search, we may have a lot of contexts */
- int num_searches;
- struct ldb_request **search_reqs;
-};
-/* Context data for mapped search requests */
-struct map_search_context {
- struct map_context *ac;
- struct ldb_reply *local_res;
- struct ldb_reply *remote_res;
+ struct map_reply *r_list;
+ struct map_reply *r_current;
};
-
/* Common operations
* ================= */
/* The following definitions come from lib/ldb/modules/ldb_map.c */
const struct ldb_map_context *map_get_context(struct ldb_module *module);
-struct map_search_context *map_init_search_context(struct map_context *ac, struct ldb_reply *ares);
-struct ldb_handle *map_init_handle(struct ldb_request *req, struct ldb_module *module);
+struct map_context *map_init_context(struct ldb_module *module,
+ struct ldb_request *req);
int ldb_next_remote_request(struct ldb_module *module, struct ldb_request *request);
struct ldb_dn *ldb_dn_map_remote(struct ldb_module *module, void *mem_ctx, struct ldb_dn *dn);
struct ldb_dn *ldb_dn_map_rebase_remote(struct ldb_module *module, void *mem_ctx, struct ldb_dn *dn);
-struct ldb_request *map_search_base_req(struct map_context *ac, struct ldb_dn *dn, const char * const *attrs, const struct ldb_parse_tree *tree, void *context, ldb_search_callback callback);
-struct ldb_request *map_search_self_req(struct map_context *ac, struct ldb_dn *dn);
-struct ldb_request *map_build_fixup_req(struct map_context *ac, struct ldb_dn *olddn, struct ldb_dn *newdn);
-
-int map_subtree_collect_remote_simple(struct ldb_module *module, void *mem_ctx, struct ldb_parse_tree **new, const struct ldb_parse_tree *tree, const struct ldb_map_attribute *map);
-
-/* LDB Requests
- * ============ */
-
-/* The following definitions come from lib/ldb/modules/ldb_map_inbound.c */
-int map_add_do_remote(struct ldb_handle *handle);
-int map_add_do_local(struct ldb_handle *handle);
-
-int map_modify_do_remote(struct ldb_handle *handle);
-int map_modify_do_local(struct ldb_handle *handle);
-
-int map_delete_do_remote(struct ldb_handle *handle);
-int map_delete_do_local(struct ldb_handle *handle);
-
-int map_rename_do_remote(struct ldb_handle *handle);
-int map_rename_do_fixup(struct ldb_handle *handle);
-int map_rename_do_local(struct ldb_handle *handle);
+struct ldb_request *map_search_base_req(struct map_context *ac,
+ struct ldb_dn *dn,
+ const char * const *attrs,
+ const struct ldb_parse_tree *tree,
+ void *context,
+ ldb_map_callback_t callback);
+struct ldb_request *map_build_fixup_req(struct map_context *ac,
+ struct ldb_dn *olddn,
+ struct ldb_dn *newdn,
+ void *context,
+ ldb_map_callback_t callback);
+int map_subtree_collect_remote_simple(struct ldb_module *module, void *mem_ctx,
+ struct ldb_parse_tree **new,
+ const struct ldb_parse_tree *tree,
+ const struct ldb_map_attribute *map);
+int map_return_fatal_error(struct ldb_request *req,
+ struct ldb_reply *ares);
+int map_return_normal_error(struct ldb_request *req,
+ struct ldb_reply *ares,
+ int error);
struct lsql_context {
struct ldb_module *module;
+ struct ldb_request *req;
/* search stuff */
long long current_eid;
const char * const * attrs;
struct ldb_reply *ares;
-
- /* async stuff */
- void *context;
- int (*callback)(struct ldb_context *, void *, struct ldb_reply *);
};
-static struct ldb_handle *init_handle(struct lsqlite3_private *lsqlite3,
- struct ldb_module *module,
- struct ldb_request *req)
-{
- struct lsql_context *ac;
- struct ldb_handle *h;
-
- h = talloc_zero(lsqlite3, struct ldb_handle);
- if (h == NULL) {
- ldb_set_errstring(module->ldb, "Out of Memory");
- return NULL;
- }
-
- h->module = module;
-
- ac = talloc(h, struct lsql_context);
- if (ac == NULL) {
- ldb_set_errstring(module->ldb, "Out of Memory");
- talloc_free(h);
- return NULL;
- }
-
- h->private_data = (void *)ac;
-
- h->state = LDB_ASYNC_INIT;
- h->status = LDB_SUCCESS;
-
- ac->module = module;
- ac->context = req->context;
- ac->callback = req->callback;
-
- return h;
-}
-
/*
* Macros used throughout
*/
char *query = NULL;
int ret;
- req->handle = init_handle(lsqlite3, module, req);
- if (req->handle == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
lsql_ac = talloc_get_type(req->handle->private_data, struct lsql_context);
if ((( ! ldb_dn_is_valid(req->op.search.base)) || ldb_dn_is_null(req->op.search.base)) &&
int i;
int ret = LDB_SUCCESS;
- req->handle = init_handle(lsqlite3, module, req);
- if (req->handle == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
lsql_ac = talloc_get_type(req->handle->private_data, struct lsql_context);
req->handle->state = LDB_ASYNC_DONE;
req->handle->status = LDB_SUCCESS;
int i;
int ret = LDB_SUCCESS;
- req->handle = init_handle(lsqlite3, module, req);
- if (req->handle == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
lsql_ac = talloc_get_type(req->handle->private_data, struct lsql_context);
req->handle->state = LDB_ASYNC_DONE;
req->handle->status = LDB_SUCCESS;
int ret = LDB_SUCCESS;
- req->handle = init_handle(lsqlite3, module, req);
- if (req->handle == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
lsql_ac = talloc_get_type(req->handle->private_data, struct lsql_context);
req->handle->state = LDB_ASYNC_DONE;
req->handle->status = LDB_SUCCESS;
char *query;
int ret = LDB_SUCCESS;
- req->handle = init_handle(lsqlite3, module, req);
- if (req->handle == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
lsql_ac = talloc_get_type(req->handle->private_data, struct lsql_context);
req->handle->state = LDB_ASYNC_DONE;
req->handle->status = LDB_SUCCESS;
return LDB_ERR_OPERATIONS_ERROR;
}
-static int lsql_wait(struct ldb_handle *handle, enum ldb_wait_type type)
+static int lsql_run_request(struct ldb_module *module, struct ldb_request *req)
+{
+ switch (req->operation) {
+ case LDB_SEARCH:
+ return lsql_search(module, req);
+ break;
+ case LDB_ADD:
+ return lsql_add(module, req);
+ break;
+ case LDB_MODIFY:
+ return lsql_modify(module, req);
+ break;
+ case LDB_DELETE:
+ return lsql_delete(module, req);
+ break;
+ case LDB_RENAME:
+ return lsql_rename(module, req);
+ break;
+/* TODO:
+ case LDB_SEQUENCE_NUMBER:
+ return lsql_sequence_number(module, req);
+ break;
+ */
+ default:
+ return lsql_request(module, req);
+ break;
+ }
+
+ return LDB_ERR_OPERATIONS_ERROR;
+}
+
+static int lsql_handle_request(struct ldb_module *module, struct ldb_request *req)
{
- return handle->status;
+ struct lsql_context *ac;
+
+ if (check_critical_controls(req->controls)) {
+ return LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION;
+ }
+
+ ac = talloc_zero(req, struct lsql_context);
+ if (ac == NULL) {
+ ldb_set_errstring(module->ldb, "Out of Memory");
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ ac->module = module;
+ ac->req = req;
+
+ req->handle = ldb_handle_new(req, lsql_run_request, ac);
+ if (req->handle == NULL) {
+ talloc_free(ac);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ return LDB_SUCCESS;
}
/*
*/
static const struct ldb_module_ops lsqlite3_ops = {
.name = "sqlite",
- .search = lsql_search,
- .add = lsql_add,
- .modify = lsql_modify,
- .del = lsql_delete,
- .rename = lsql_rename,
- .request = lsql_request,
+ .search = lsql_handle_request,
+ .add = lsql_handle_request,
+ .modify = lsql_handle_request,
+ .del = lsql_handle_request,
+ .rename = lsql_handle_request,
+ .request = lsql_handle_request,
.start_transaction = lsql_start_trans,
.end_transaction = lsql_end_trans,
.del_transaction = lsql_del_trans,
- .wait = lsql_wait,
+ /* TODO: .sequence_number = lsql_handle_request */
};
/*
extracting just the given attributes
*/
static int ltdb_index_filter(const struct dn_list *dn_list,
- struct ldb_handle *handle)
+ struct ltdb_context *ac)
{
- struct ltdb_context *ac = talloc_get_type(handle->private_data, struct ltdb_context);
- struct ldb_reply *ares = NULL;
+ struct ldb_message *msg;
unsigned int i;
for (i = 0; i < dn_list->count; i++) {
struct ldb_dn *dn;
int ret;
- ares = talloc_zero(ac, struct ldb_reply);
- if (!ares) {
- handle->status = LDB_ERR_OPERATIONS_ERROR;
- handle->state = LDB_ASYNC_DONE;
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- ares->message = ldb_msg_new(ares);
- if (!ares->message) {
- handle->status = LDB_ERR_OPERATIONS_ERROR;
- handle->state = LDB_ASYNC_DONE;
- talloc_free(ares);
+ msg = ldb_msg_new(ac);
+ if (!msg) {
return LDB_ERR_OPERATIONS_ERROR;
}
-
- dn = ldb_dn_new(ares->message, ac->module->ldb, dn_list->dn[i]);
+ dn = ldb_dn_new(msg, ac->module->ldb, dn_list->dn[i]);
if (dn == NULL) {
- talloc_free(ares);
+ talloc_free(msg);
return LDB_ERR_OPERATIONS_ERROR;
}
- ret = ltdb_search_dn1(ac->module, dn, ares->message);
+ ret = ltdb_search_dn1(ac->module, dn, msg);
talloc_free(dn);
if (ret == LDB_ERR_NO_SUCH_OBJECT) {
/* the record has disappeared? yes, this can happen */
- talloc_free(ares);
+ talloc_free(msg);
continue;
}
if (ret != LDB_SUCCESS && ret != LDB_ERR_NO_SUCH_OBJECT) {
/* an internal error */
- talloc_free(ares);
+ talloc_free(msg);
return LDB_ERR_OPERATIONS_ERROR;
}
- if (!ldb_match_msg(ac->module->ldb, ares->message, ac->tree, ac->base, ac->scope)) {
- talloc_free(ares);
+ if (!ldb_match_msg(ac->module->ldb, msg,
+ ac->tree, ac->base, ac->scope)) {
+ talloc_free(msg);
continue;
}
/* filter the attributes that the user wants */
- ret = ltdb_filter_attrs(ares->message, ac->attrs);
+ ret = ltdb_filter_attrs(msg, ac->attrs);
if (ret == -1) {
- handle->status = LDB_ERR_OPERATIONS_ERROR;
- handle->state = LDB_ASYNC_DONE;
- talloc_free(ares);
+ talloc_free(msg);
return LDB_ERR_OPERATIONS_ERROR;
}
- ares->type = LDB_REPLY_ENTRY;
- handle->state = LDB_ASYNC_PENDING;
- handle->status = ac->callback(ac->module->ldb, ac->context, ares);
-
- if (handle->status != LDB_SUCCESS) {
- handle->state = LDB_ASYNC_DONE;
- return handle->status;
+ ret = ldb_module_send_entry(ac->req, msg);
+ if (ret != LDB_SUCCESS) {
+ ac->callback_failed = true;
+ return ret;
}
}
returns -1 if an indexed search is not possible, in which
case the caller should call ltdb_search_full()
*/
-int ltdb_search_indexed(struct ldb_handle *handle)
+int ltdb_search_indexed(struct ltdb_context *ac)
{
- struct ltdb_context *ac = talloc_get_type(handle->private_data, struct ltdb_context);
struct ltdb_private *ltdb = talloc_get_type(ac->module->private_data, struct ltdb_private);
struct dn_list *dn_list;
int ret, idxattr, idxone;
ret = LDB_ERR_OPERATIONS_ERROR;
- dn_list = talloc_zero(handle, struct dn_list);
+ dn_list = talloc_zero(ac, struct dn_list);
if (dn_list == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
if (ret == LDB_SUCCESS) {
/* we've got a candidate list - now filter by the full tree
and extract the needed attributes */
- ret = ltdb_index_filter(dn_list, handle);
- handle->status = ret;
- handle->state = LDB_ASYNC_DONE;
+ ret = ltdb_index_filter(dn_list, ac);
}
talloc_free(dn_list);
*/
static int search_func(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *state)
{
- struct ldb_handle *handle = talloc_get_type(state, struct ldb_handle);
- struct ltdb_context *ac = talloc_get_type(handle->private_data, struct ltdb_context);
- struct ldb_reply *ares = NULL;
+ struct ltdb_context *ac;
+ struct ldb_message *msg;
int ret;
+ ac = talloc_get_type(state, struct ltdb_context);
+
if (key.dsize < 4 ||
strncmp((char *)key.dptr, "DN=", 3) != 0) {
return 0;
}
- ares = talloc_zero(ac, struct ldb_reply);
- if (!ares) {
- handle->status = LDB_ERR_OPERATIONS_ERROR;
- handle->state = LDB_ASYNC_DONE;
- return -1;
- }
-
- ares->message = ldb_msg_new(ares);
- if (!ares->message) {
- handle->status = LDB_ERR_OPERATIONS_ERROR;
- handle->state = LDB_ASYNC_DONE;
- talloc_free(ares);
+ msg = ldb_msg_new(ac);
+ if (!msg) {
return -1;
}
/* unpack the record */
- ret = ltdb_unpack_data(ac->module, &data, ares->message);
+ ret = ltdb_unpack_data(ac->module, &data, msg);
if (ret == -1) {
- talloc_free(ares);
+ talloc_free(msg);
return -1;
}
- if (!ares->message->dn) {
- ares->message->dn = ldb_dn_new(ares->message, ac->module->ldb, (char *)key.dptr + 3);
- if (ares->message->dn == NULL) {
- handle->status = LDB_ERR_OPERATIONS_ERROR;
- handle->state = LDB_ASYNC_DONE;
- talloc_free(ares);
+ if (!msg->dn) {
+ msg->dn = ldb_dn_new(msg, ac->module->ldb,
+ (char *)key.dptr + 3);
+ if (msg->dn == NULL) {
+ talloc_free(msg);
return -1;
}
}
/* see if it matches the given expression */
- if (!ldb_match_msg(ac->module->ldb, ares->message, ac->tree,
- ac->base, ac->scope)) {
- talloc_free(ares);
+ if (!ldb_match_msg(ac->module->ldb, msg,
+ ac->tree, ac->base, ac->scope)) {
+ talloc_free(msg);
return 0;
}
/* filter the attributes that the user wants */
- ret = ltdb_filter_attrs(ares->message, ac->attrs);
+ ret = ltdb_filter_attrs(msg, ac->attrs);
if (ret == -1) {
- handle->status = LDB_ERR_OPERATIONS_ERROR;
- handle->state = LDB_ASYNC_DONE;
- talloc_free(ares);
+ talloc_free(msg);
return -1;
}
- ares->type = LDB_REPLY_ENTRY;
- handle->state = LDB_ASYNC_PENDING;
- handle->status = ac->callback(ac->module->ldb, ac->context, ares);
-
- if (handle->status != LDB_SUCCESS) {
- /* don't try to free ares here, the callback is in charge of that */
+ ret = ldb_module_send_entry(ac->req, msg);
+ if (ret != LDB_SUCCESS) {
+ ac->callback_failed = true;
+ /* the callback failed, abort the operation */
return -1;
}
search the database with a LDAP-like expression.
this is the "full search" non-indexed variant
*/
-static int ltdb_search_full(struct ldb_handle *handle)
+static int ltdb_search_full(struct ltdb_context *ctx)
{
- struct ltdb_context *ac = talloc_get_type(handle->private_data, struct ltdb_context);
- struct ltdb_private *ltdb = talloc_get_type(ac->module->private_data, struct ltdb_private);
+ struct ltdb_private *ltdb = talloc_get_type(ctx->module->private_data, struct ltdb_private);
int ret;
if (ltdb->in_transaction != 0) {
- ret = tdb_traverse(ltdb->tdb, search_func, handle);
+ ret = tdb_traverse(ltdb->tdb, search_func, ctx);
} else {
- ret = tdb_traverse_read(ltdb->tdb, search_func, handle);
+ ret = tdb_traverse_read(ltdb->tdb, search_func, ctx);
}
if (ret == -1) {
- handle->status = LDB_ERR_OPERATIONS_ERROR;
+ return LDB_ERR_OPERATIONS_ERROR;
}
- handle->state = LDB_ASYNC_DONE;
return LDB_SUCCESS;
}
search the database with a LDAP-like expression.
choses a search method
*/
-int ltdb_search(struct ldb_module *module, struct ldb_request *req)
+int ltdb_search(struct ltdb_context *ctx)
{
+ struct ldb_module *module = ctx->module;
+ struct ldb_request *req = ctx->req;
struct ltdb_private *ltdb = talloc_get_type(module->private_data, struct ltdb_private);
- struct ltdb_context *ltdb_ac;
- struct ldb_reply *ares;
int ret;
+ req->handle->state = LDB_ASYNC_PENDING;
+
if (ltdb_lock_read(module) != 0) {
return LDB_ERR_OPERATIONS_ERROR;
}
return LDB_ERR_OPERATIONS_ERROR;
}
- req->handle = init_ltdb_handle(ltdb, module, req);
- if (req->handle == NULL) {
- ltdb_unlock_read(module);
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
if ((req->op.search.base == NULL) || (ldb_dn_is_null(req->op.search.base) == true)) {
/* Check what we should do with a NULL dn */
ret = LDB_SUCCESS;
}
- ltdb_ac = talloc_get_type(req->handle->private_data, struct ltdb_context);
-
- ltdb_ac->tree = req->op.search.tree;
- ltdb_ac->scope = req->op.search.scope;
- ltdb_ac->base = req->op.search.base;
- ltdb_ac->attrs = req->op.search.attrs;
-
+ ctx->tree = req->op.search.tree;
+ ctx->scope = req->op.search.scope;
+ ctx->base = req->op.search.base;
+ ctx->attrs = req->op.search.attrs;
if (ret == LDB_SUCCESS) {
- ret = ltdb_search_indexed(req->handle);
+ ret = ltdb_search_indexed(ctx);
if (ret == LDB_ERR_NO_SUCH_OBJECT) {
/* Not in the index, therefore OK! */
ret = LDB_SUCCESS;
- } else if (ret == LDB_ERR_OPERATIONS_ERROR) {
+ }
+ /* Check if we got just a normal error.
+ * In that case proceed to a full search unless we got a
+ * callback error */
+ if ( ! ctx->callback_failed && ret != LDB_SUCCESS) {
/* Not indexed, so we need to do a full scan */
- ret = ltdb_search_full(req->handle);
+ ret = ltdb_search_full(ctx);
if (ret != LDB_SUCCESS) {
ldb_set_errstring(module->ldb, "Indexed and full searches both failed!\n");
}
}
}
- if (ret != LDB_SUCCESS) {
- req->handle->state = LDB_ASYNC_DONE;
- req->handle->status = ret;
- }
-
- /* Finally send an LDB_REPLY_DONE packet when searching is finished */
-
- ares = talloc_zero(req, struct ldb_reply);
- if (!ares) {
- ltdb_unlock_read(module);
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- req->handle->state = LDB_ASYNC_DONE;
-
- if (ret == LDB_SUCCESS) {
- ares->type = LDB_REPLY_DONE;
-
- ret = req->callback(module->ldb, req->context, ares);
- req->handle->status = ret;
- }
-
ltdb_unlock_read(module);
- return LDB_SUCCESS;
+ return ret;
}
Copyright (C) Andrew Tridgell 2004
Copyright (C) Stefan Metzmacher 2004
- Copyright (C) Simo Sorce 2006
+ Copyright (C) Simo Sorce 2006-2008
** NOTE! The following LGPL license applies to the ldb
* - description: make the module use asyncronous calls
* date: Feb 2006
* Author: Simo Sorce
+ *
+ * - description: make it possible to use event contexts
+ * date: Jan 2008
+ * Author: Simo Sorce
*/
#include "ldb_includes.h"
}
-struct ldb_handle *init_ltdb_handle(struct ltdb_private *ltdb,
- struct ldb_module *module,
- struct ldb_request *req)
-{
- struct ltdb_context *ac;
- struct ldb_handle *h;
-
- h = talloc_zero(req, struct ldb_handle);
- if (h == NULL) {
- ldb_set_errstring(module->ldb, "Out of Memory");
- return NULL;
- }
-
- h->module = module;
-
- ac = talloc_zero(h, struct ltdb_context);
- if (ac == NULL) {
- ldb_set_errstring(module->ldb, "Out of Memory");
- talloc_free(h);
- return NULL;
- }
-
- h->private_data = (void *)ac;
-
- h->state = LDB_ASYNC_INIT;
- h->status = LDB_SUCCESS;
-
- ac->module = module;
- ac->context = req->context;
- ac->callback = req->callback;
-
- return h;
-}
-
/*
form a TDB_DATA for a record key
caller frees
/*
add a record to the database
*/
-static int ltdb_add(struct ldb_module *module, struct ldb_request *req)
+static int ltdb_add(struct ltdb_context *ctx)
{
- struct ltdb_private *ltdb;
- struct ltdb_context *ltdb_ac;
- int tret, ret = LDB_SUCCESS;
-
- ltdb = talloc_get_type(module->private_data, struct ltdb_private);
-
- if (check_critical_controls(req->controls)) {
- return LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION;
- }
+ struct ldb_module *module = ctx->module;
+ struct ldb_request *req = ctx->req;
+ int tret;
- req->handle = init_ltdb_handle(ltdb, module, req);
- if (req->handle == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
- ltdb_ac = talloc_get_type(req->handle->private_data, struct ltdb_context);
+ req->handle->state = LDB_ASYNC_PENDING;
tret = ltdb_add_internal(module, req->op.add.message);
if (tret != LDB_SUCCESS) {
- req->handle->status = tret;
- goto done;
+ return tret;
}
- if (ltdb_ac->callback) {
- ret = ltdb_ac->callback(module->ldb, ltdb_ac->context, NULL);
- }
-done:
- req->handle->state = LDB_ASYNC_DONE;
- return ret;
+ return LDB_SUCCESS;
}
/*
/*
delete a record from the database
*/
-static int ltdb_delete(struct ldb_module *module, struct ldb_request *req)
+static int ltdb_delete(struct ltdb_context *ctx)
{
- struct ltdb_private *ltdb;
- struct ltdb_context *ltdb_ac;
- int tret, ret = LDB_SUCCESS;
-
- ltdb = talloc_get_type(module->private_data, struct ltdb_private);
-
- if (check_critical_controls(req->controls)) {
- return LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION;
- }
+ struct ldb_module *module = ctx->module;
+ struct ldb_request *req = ctx->req;
+ int tret;
- req->handle = NULL;
+ req->handle->state = LDB_ASYNC_PENDING;
if (ltdb_cache_load(module) != 0) {
return LDB_ERR_OPERATIONS_ERROR;
}
- req->handle = init_ltdb_handle(ltdb, module, req);
- if (req->handle == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
- ltdb_ac = talloc_get_type(req->handle->private_data, struct ltdb_context);
-
tret = ltdb_delete_internal(module, req->op.del.dn);
if (tret != LDB_SUCCESS) {
- req->handle->status = tret;
- goto done;
+ return tret;
}
- if (ltdb_ac->callback) {
- ret = ltdb_ac->callback(module->ldb, ltdb_ac->context, NULL);
- }
-done:
- req->handle->state = LDB_ASYNC_DONE;
- return ret;
+ return LDB_SUCCESS;
}
/*
/*
modify a record
*/
-static int ltdb_modify(struct ldb_module *module, struct ldb_request *req)
+static int ltdb_modify(struct ltdb_context *ctx)
{
- struct ltdb_private *ltdb;
- struct ltdb_context *ltdb_ac;
- int tret, ret = LDB_SUCCESS;
-
- ltdb = talloc_get_type(module->private_data, struct ltdb_private);
-
- if (check_critical_controls(req->controls)) {
- return LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION;
- }
-
- req->handle = NULL;
+ struct ldb_module *module = ctx->module;
+ struct ldb_request *req = ctx->req;
+ int tret;
- req->handle = init_ltdb_handle(ltdb, module, req);
- if (req->handle == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
- ltdb_ac = talloc_get_type(req->handle->private_data, struct ltdb_context);
+ req->handle->state = LDB_ASYNC_PENDING;
tret = ltdb_check_special_dn(module, req->op.mod.message);
if (tret != LDB_SUCCESS) {
- req->handle->status = tret;
- goto done;
+ return tret;
}
if (ltdb_cache_load(module) != 0) {
- ret = LDB_ERR_OPERATIONS_ERROR;
- goto done;
+ return LDB_ERR_OPERATIONS_ERROR;
}
tret = ltdb_modify_internal(module, req->op.mod.message);
if (tret != LDB_SUCCESS) {
- req->handle->status = tret;
- goto done;
+ return tret;
}
- if (ltdb_ac->callback) {
- ret = ltdb_ac->callback(module->ldb, ltdb_ac->context, NULL);
- }
-done:
- req->handle->state = LDB_ASYNC_DONE;
- return ret;
+ return LDB_SUCCESS;
}
/*
rename a record
*/
-static int ltdb_rename(struct ldb_module *module, struct ldb_request *req)
+static int ltdb_rename(struct ltdb_context *ctx)
{
- struct ltdb_private *ltdb;
- struct ltdb_context *ltdb_ac;
+ struct ldb_module *module = ctx->module;
+ struct ldb_request *req = ctx->req;
struct ldb_message *msg;
- int tret, ret = LDB_SUCCESS;
-
- ltdb = talloc_get_type(module->private_data, struct ltdb_private);
-
- if (check_critical_controls(req->controls)) {
- return LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION;
- }
-
- req->handle = NULL;
+ int tret;
- if (ltdb_cache_load(module) != 0) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
+ req->handle->state = LDB_ASYNC_PENDING;
- req->handle = init_ltdb_handle(ltdb, module, req);
- if (req->handle == NULL) {
+ if (ltdb_cache_load(ctx->module) != 0) {
return LDB_ERR_OPERATIONS_ERROR;
}
- ltdb_ac = talloc_get_type(req->handle->private_data, struct ltdb_context);
- msg = talloc(ltdb_ac, struct ldb_message);
+ msg = talloc(ctx, struct ldb_message);
if (msg == NULL) {
- ret = LDB_ERR_OPERATIONS_ERROR;
- goto done;
+ return LDB_ERR_OPERATIONS_ERROR;
}
/* in case any attribute of the message was indexed, we need
tret = ltdb_search_dn1(module, req->op.rename.olddn, msg);
if (tret != LDB_SUCCESS) {
/* not finding the old record is an error */
- req->handle->status = tret;
- goto done;
+ return tret;
}
msg->dn = ldb_dn_copy(msg, req->op.rename.newdn);
if (!msg->dn) {
- ret = LDB_ERR_OPERATIONS_ERROR;
- goto done;
+ return LDB_ERR_OPERATIONS_ERROR;
}
if (ldb_dn_compare(req->op.rename.olddn, req->op.rename.newdn) == 0) {
The only drawback to this is that if the delete
succeeds but the add fails, we rely on the
transaction to roll this all back. */
- ret = ltdb_delete_internal(module, req->op.rename.olddn);
- if (ret != LDB_SUCCESS) {
- goto done;
+ tret = ltdb_delete_internal(module, req->op.rename.olddn);
+ if (tret != LDB_SUCCESS) {
+ return tret;
}
- ret = ltdb_add_internal(module, msg);
- if (ret != LDB_SUCCESS) {
- goto done;
+ tret = ltdb_add_internal(module, msg);
+ if (tret != LDB_SUCCESS) {
+ return tret;
}
} else {
/* The rename operation is changing DNs. Try to add the new
DN first to avoid clobbering another DN not related to
this rename operation. */
- ret = ltdb_add_internal(module, msg);
- if (ret != LDB_SUCCESS) {
- goto done;
+ tret = ltdb_add_internal(module, msg);
+ if (tret != LDB_SUCCESS) {
+ return tret;
}
tret = ltdb_delete_internal(module, req->op.rename.olddn);
if (tret != LDB_SUCCESS) {
ltdb_delete_internal(module, req->op.rename.newdn);
- ret = LDB_ERR_OPERATIONS_ERROR;
- goto done;
+ return LDB_ERR_OPERATIONS_ERROR;
}
}
- if (ltdb_ac->callback) {
- ret = ltdb_ac->callback(module->ldb, ltdb_ac->context, NULL);
- }
-done:
- req->handle->state = LDB_ASYNC_DONE;
- return ret;
+ return LDB_SUCCESS;
}
static int ltdb_start_trans(struct ldb_module *module)
return LDB_SUCCESS;
}
-static int ltdb_wait(struct ldb_handle *handle, enum ldb_wait_type type)
-{
- return handle->status;
-}
-
-static int ltdb_request(struct ldb_module *module, struct ldb_request *req)
-{
- /* check for oustanding critical controls
- * and return an error if found */
- if (check_critical_controls(req->controls)) {
- return LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION;
- }
-
- /* search, add, modify, delete, rename are handled by their own,
- * no other op supported */
- return LDB_ERR_OPERATIONS_ERROR;
-}
-
/*
return sequenceNumber from @BASEINFO
*/
talloc_free(tmp_ctx);
/* zero is as good as anything when we don't know */
req->op.seq_num.seq_num = 0;
- return LDB_SUCCESS;
+ return tret;
}
switch (req->op.seq_num.type) {
}
break;
}
+
talloc_free(tmp_ctx);
+
+ return LDB_SUCCESS;
+}
+
+void ltdb_request_done(struct ldb_request *req, int error)
+{
+ struct ldb_reply *ares;
+
+ /* if we already returned an error just return */
+ if (req->handle->status != LDB_SUCCESS) {
+ return;
+ }
+
+ ares = talloc_zero(req, struct ldb_reply);
+ if (!ares) {
+ ldb_oom(req->handle->ldb);
+ req->callback(req, NULL);
+ return;
+ }
+ ares->type = LDB_REPLY_DONE;
+ ares->error = error;
+
+ req->callback(req, ares);
+}
+
+static void ltdb_timeout(struct event_context *ev,
+ struct timed_event *te,
+ struct timeval t,
+ void *private_data)
+{
+ struct ltdb_context *ctx;
+ ctx = talloc_get_type(private_data, struct ltdb_context);
+
+ ltdb_request_done(ctx->req, LDB_ERR_TIME_LIMIT_EXCEEDED);
+}
+
+static void ltdb_callback(struct event_context *ev,
+ struct timed_event *te,
+ struct timeval t,
+ void *private_data)
+{
+ struct ltdb_context *ctx;
+ int ret;
+
+ ctx = talloc_get_type(private_data, struct ltdb_context);
+
+ switch (ctx->req->operation) {
+ case LDB_SEARCH:
+ ret = ltdb_search(ctx);
+ break;
+ case LDB_ADD:
+ ret = ltdb_add(ctx);
+ break;
+ case LDB_MODIFY:
+ ret = ltdb_modify(ctx);
+ break;
+ case LDB_DELETE:
+ ret = ltdb_delete(ctx);
+ break;
+ case LDB_RENAME:
+ ret = ltdb_rename(ctx);
+ break;
+ default:
+ /* no other op supported */
+ ret = LDB_ERR_UNWILLING_TO_PERFORM;
+ }
+
+ if (!ctx->callback_failed) {
+ ltdb_request_done(ctx->req, ret);
+ }
+}
+
+static int ltdb_handle_request(struct ldb_module *module,
+ struct ldb_request *req)
+{
+ struct event_context *ev;
+ struct ltdb_context *ac;
+ struct timed_event *te;
+ struct timeval tv;
+
+ if (check_critical_controls(req->controls)) {
+ return LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION;
+ }
+
+ if (req->starttime == 0 || req->timeout == 0) {
+ ldb_set_errstring(module->ldb, "Invalid timeout settings");
+ return LDB_ERR_TIME_LIMIT_EXCEEDED;
+ }
+
+ ev = ldb_get_event_context(module->ldb);
+
+ ac = talloc_zero(req, struct ltdb_context);
+ if (ac == NULL) {
+ ldb_set_errstring(module->ldb, "Out of Memory");
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ ac->module = module;
+ ac->req = req;
+
+ tv.tv_sec = 0;
+ tv.tv_usec = 0;
+ te = event_add_timed(ev, ac, tv, ltdb_callback, ac);
+ if (NULL == te) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+
+ tv.tv_sec = req->starttime + req->timeout;
+ te = event_add_timed(ev, ac, tv, ltdb_timeout, ac);
+ if (NULL == te) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
return LDB_SUCCESS;
}
static const struct ldb_module_ops ltdb_ops = {
.name = "tdb",
- .search = ltdb_search,
- .add = ltdb_add,
- .modify = ltdb_modify,
- .del = ltdb_delete,
- .rename = ltdb_rename,
- .request = ltdb_request,
+ .search = ltdb_handle_request,
+ .add = ltdb_handle_request,
+ .modify = ltdb_handle_request,
+ .del = ltdb_handle_request,
+ .rename = ltdb_handle_request,
+/* .request = ltdb_handle_request, */
.start_transaction = ltdb_start_trans,
.end_transaction = ltdb_end_trans,
.del_transaction = ltdb_del_trans,
- .wait = ltdb_wait,
.sequence_number = ltdb_sequence_number
};
ltdb->sequence_number = 0;
*module = talloc(ldb, struct ldb_module);
- if (!module) {
+ if ((*module) == NULL) {
ldb_oom(ldb);
talloc_free(ltdb);
return -1;
*/
struct ltdb_context {
struct ldb_module *module;
+ struct ldb_request *req;
+
+ bool callback_failed;
/* search stuff */
const struct ldb_parse_tree *tree;
struct ldb_dn *base;
enum ldb_scope scope;
const char * const *attrs;
-
- /* async stuff */
- void *context;
- int (*callback)(struct ldb_context *, void *, struct ldb_reply *);
};
/* special record types */
struct ldb_parse_tree;
-int ltdb_search_indexed(struct ldb_handle *handle);
+int ltdb_search_indexed(struct ltdb_context *ctx);
int ltdb_index_add(struct ldb_module *module, const struct ldb_message *msg);
int ltdb_index_del(struct ldb_module *module, const struct ldb_message *msg);
int ltdb_index_one(struct ldb_module *module, const struct ldb_message *msg, int add);
unsigned int *count,
struct ldb_message ***res);
int ltdb_filter_attrs(struct ldb_message *msg, const char * const *attrs);
-int ltdb_search(struct ldb_module *module, struct ldb_request *req);
+int ltdb_search(struct ltdb_context *ctx);
/* The following definitions come from lib/ldb/ldb_tdb/ldb_tdb.c */
-struct ldb_handle *init_ltdb_handle(struct ltdb_private *ltdb, struct ldb_module *module,
- struct ldb_request *req);
struct TDB_DATA ltdb_key(struct ldb_module *module, struct ldb_dn *dn);
int ltdb_store(struct ldb_module *module, const struct ldb_message *msg, int flgs);
int ltdb_delete_noindex(struct ldb_module *module, struct ldb_dn *dn);
const char *path, int hash_size, int tdb_flags,
int open_flags, mode_t mode,
struct ldb_context *ldb);
-
struct ldb_context *ldb = talloc_get_type(tdb_get_logging_private(tdb), struct ldb_context);
enum ldb_debug_level ldb_level;
char *message;
+
+ if (ldb == NULL)
+ return;
+
va_start(ap, fmt);
message = talloc_vasprintf(ldb, fmt, ap);
va_end(ap);
#define SWIGTYPE_p_ldb_ldif swig_types[6]
#define SWIGTYPE_p_ldb_message swig_types[7]
#define SWIGTYPE_p_ldb_message_element swig_types[8]
-#define SWIGTYPE_p_ldb_module_ops swig_types[9]
-#define SWIGTYPE_p_ldb_result swig_types[10]
-#define SWIGTYPE_p_ldb_val swig_types[11]
-#define SWIGTYPE_p_long_long swig_types[12]
-#define SWIGTYPE_p_p_char swig_types[13]
-#define SWIGTYPE_p_p_ldb_control swig_types[14]
-#define SWIGTYPE_p_p_ldb_result swig_types[15]
-#define SWIGTYPE_p_short swig_types[16]
-#define SWIGTYPE_p_signed_char swig_types[17]
-#define SWIGTYPE_p_unsigned_char swig_types[18]
-#define SWIGTYPE_p_unsigned_int swig_types[19]
-#define SWIGTYPE_p_unsigned_long swig_types[20]
-#define SWIGTYPE_p_unsigned_long_long swig_types[21]
-#define SWIGTYPE_p_unsigned_short swig_types[22]
-#define SWIGTYPE_p_void swig_types[23]
-static swig_type_info *swig_types[25];
-static swig_module_info swig_module = {swig_types, 24, 0, 0, 0, 0};
+#define SWIGTYPE_p_ldb_module swig_types[9]
+#define SWIGTYPE_p_ldb_module_ops swig_types[10]
+#define SWIGTYPE_p_ldb_parse_tree swig_types[11]
+#define SWIGTYPE_p_ldb_result swig_types[12]
+#define SWIGTYPE_p_ldb_val swig_types[13]
+#define SWIGTYPE_p_long_long swig_types[14]
+#define SWIGTYPE_p_p_char swig_types[15]
+#define SWIGTYPE_p_p_ldb_control swig_types[16]
+#define SWIGTYPE_p_p_ldb_result swig_types[17]
+#define SWIGTYPE_p_short swig_types[18]
+#define SWIGTYPE_p_signed_char swig_types[19]
+#define SWIGTYPE_p_unsigned_char swig_types[20]
+#define SWIGTYPE_p_unsigned_int swig_types[21]
+#define SWIGTYPE_p_unsigned_long swig_types[22]
+#define SWIGTYPE_p_unsigned_long_long swig_types[23]
+#define SWIGTYPE_p_unsigned_short swig_types[24]
+#define SWIGTYPE_p_void swig_types[25]
+static swig_type_info *swig_types[27];
+static swig_module_info swig_module = {swig_types, 26, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
typedef struct ldb_dn ldb_dn;
typedef struct ldb_ldif ldb_ldif;
typedef struct ldb_message_element ldb_message_element;
+typedef struct ldb_module ldb_module;
typedef int ldb_error;
typedef int ldb_int_error;
attrs,
controls,
res,
- ldb_search_default_callback);
+ ldb_search_default_callback,
+ NULL);
if (ret != 0) {
talloc_free(res);
return ret;
}
- ldb_set_timeout(self, req, 0); /* use default timeout */
-
ret = ldb_request(self, req);
if (ret == 0) {
return ret;
}
SWIGINTERN ldb_error ldb___contains__(ldb *self,ldb_dn *dn,struct ldb_result **result_as_bool){
- return ldb_search(self, dn, LDB_SCOPE_BASE, NULL, NULL,
- result_as_bool);
+ return ldb_search(self, self, result_as_bool, dn, LDB_SCOPE_BASE, NULL, NULL);
}
SWIGINTERN PyObject *ldb_parse_ldif(ldb *self,char const *s){
PyObject *list = PyList_New(0);
return result;
}
+SWIGINTERN char const *ldb_module___str__(ldb_module *self){
+ return self->ops->name;
+ }
+SWIGINTERN char *ldb_module___repr__(ldb_module *self){
+ char *ret;
+ asprintf(&ret, "<ldb module '%s'>", self->ops->name);
+ return ret;
+ }
+SWIGINTERN int ldb_module_search(ldb_module *self,struct ldb_dn *base,enum ldb_scope scope,struct ldb_parse_tree *tree,char const *const *attrs,struct ldb_result **res){
+ int ret;
+ struct ldb_request *req = talloc_zero(NULL, struct ldb_request);
+
+ req->operation = LDB_SEARCH;
+ req->op.search.base = base;
+ req->op.search.scope = scope;
+ req->op.search.tree = tree;
+ req->op.search.attrs = attrs;
+
+ req->op.search.res = talloc_zero(NULL, struct ldb_result);
+
+ ret = self->ops->search(self, req);
+
+ *res = req->op.search.res;
+
+ talloc_free(req);
+
+ return ret;
+ }
+SWIGINTERN ldb_error ldb_module_add(ldb_module *self,struct ldb_message *message){
+ struct ldb_request *req = talloc_zero(NULL, struct ldb_request);
+ req->operation = LDB_ADD;
+ req->op.add.message = message;
+
+ return self->ops->add(self, &req);
+ }
+SWIGINTERN ldb_error ldb_module_modify(ldb_module *self,struct ldb_message *message){
+ struct ldb_request *req = talloc_zero(NULL, struct ldb_request);
+ req->operation = LDB_MODIFY;
+ req->op.mod.message = message;
+
+ return self->ops->modify(self, &req);
+ }
+SWIGINTERN ldb_error ldb_module_delete(ldb_module *self,struct ldb_dn *dn){
+ struct ldb_request *req = talloc_zero(NULL, struct ldb_request);
+ req->operation = LDB_DELETE;
+ req->op.del.dn = dn;
+
+ return self->ops->del(self, &req);
+
+ }
+SWIGINTERN ldb_error ldb_module_rename(ldb_module *self,struct ldb_dn *olddn,struct ldb_dn *newdn){
+ struct ldb_request *req = talloc_zero(NULL, struct ldb_request);
+ req->operation = LDB_RENAME;
+ req->op.rename.olddn = olddn;
+ req->op.rename.olddn = newdn;
+
+ return self->ops->rename(self, &req);
+ }
+SWIGINTERN ldb_error ldb_module_start_transaction(ldb_module *self){
+ return self->ops->start_transaction(self);
+ }
+SWIGINTERN ldb_error ldb_module_end_transaction(ldb_module *self){
+ return self->ops->end_transaction(self);
+ }
+SWIGINTERN ldb_error ldb_module_del_transaction(ldb_module *self){
+ return self->ops->del_transaction(self);
+ }
+
+int py_module_search(struct ldb_module *mod, struct ldb_request *req)
+{
+ PyObject *py_ldb = mod->private_data;
+ PyObject *py_result, *py_base, *py_attrs, *py_tree;
+
+ py_base = SWIG_NewPointerObj(req->op.search.base, SWIGTYPE_p_ldb_dn, 0);
+
+ if (py_base == NULL)
+ return LDB_ERR_OPERATIONS_ERROR;
+
+ py_tree = SWIG_NewPointerObj(req->op.search.tree, SWIGTYPE_p_ldb_parse_tree, 0);
+
+ if (py_tree == NULL)
+ return LDB_ERR_OPERATIONS_ERROR;
+
+ if (req->op.search.attrs == NULL) {
+ py_attrs = Py_None;
+ } else {
+ int i, len;
+ for (len = 0; req->op.search.attrs[len]; len++);
+ py_attrs = PyList_New(len);
+ for (i = 0; i < len; i++)
+ PyList_SetItem(py_attrs, i, PyString_FromString(req->op.search.attrs[i]));
+ }
+
+ py_result = PyObject_CallMethod(py_ldb, "search", "OiOO", py_base, req->op.search.scope, py_tree, py_attrs);
+
+ Py_DECREF(py_attrs);
+ Py_DECREF(py_tree);
+ Py_DECREF(py_base);
+
+ if (py_result == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ if (SWIG_ConvertPtr(py_result, &req->op.search.res, SWIGTYPE_p_ldb_result, 0) != 0) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ Py_DECREF(py_result);
+
+ return LDB_SUCCESS;
+}
+
+int py_module_add(struct ldb_module *mod, struct ldb_request *req)
+{
+ PyObject *py_ldb = mod->private_data;
+ PyObject *py_result, *py_msg;
+
+ py_msg = SWIG_NewPointerObj(req->op.add.message, SWIGTYPE_p_ldb_message, 0);
+
+ if (py_msg == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ py_result = PyObject_CallMethod(py_ldb, "add", "O", py_msg);
+
+ Py_DECREF(py_msg);
+
+ if (py_result == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ Py_DECREF(py_result);
+
+ return LDB_SUCCESS;
+}
+
+int py_module_modify(struct ldb_module *mod, struct ldb_request *req)
+{
+ PyObject *py_ldb = mod->private_data;
+ PyObject *py_result, *py_msg;
+
+ py_msg = SWIG_NewPointerObj(req->op.mod.message, SWIGTYPE_p_ldb_message, 0);
+
+ if (py_msg == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ py_result = PyObject_CallMethod(py_ldb, "modify", "O", py_msg);
+
+ Py_DECREF(py_msg);
+
+ if (py_result == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ Py_DECREF(py_result);
+
+ return LDB_SUCCESS;
+}
+
+int py_module_del(struct ldb_module *mod, struct ldb_request *req)
+{
+ PyObject *py_ldb = mod->private_data;
+ PyObject *py_result, *py_dn;
+
+ py_dn = SWIG_NewPointerObj(req->op.del.dn, SWIGTYPE_p_ldb_dn, 0);
+
+ if (py_dn == NULL)
+ return LDB_ERR_OPERATIONS_ERROR;
+
+ py_result = PyObject_CallMethod(py_ldb, "delete", "O", py_dn);
+
+ if (py_result == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ Py_DECREF(py_result);
+
+ return LDB_SUCCESS;
+}
+
+int py_module_rename(struct ldb_module *mod, struct ldb_request *req)
+{
+ PyObject *py_ldb = mod->private_data;
+ PyObject *py_result, *py_olddn, *py_newdn;
+
+ py_olddn = SWIG_NewPointerObj(req->op.rename.olddn, SWIGTYPE_p_ldb_dn, 0);
+
+ if (py_olddn == NULL)
+ return LDB_ERR_OPERATIONS_ERROR;
+
+ py_newdn = SWIG_NewPointerObj(req->op.rename.newdn, SWIGTYPE_p_ldb_dn, 0);
+
+ if (py_newdn == NULL)
+ return LDB_ERR_OPERATIONS_ERROR;
+
+ py_result = PyObject_CallMethod(py_ldb, "rename", "OO", py_olddn, py_newdn);
+
+ Py_DECREF(py_olddn);
+ Py_DECREF(py_newdn);
+
+ if (py_result == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ Py_DECREF(py_result);
+
+ return LDB_SUCCESS;
+}
+
+int py_module_request(struct ldb_module *mod, struct ldb_request *req)
+{
+ PyObject *py_ldb = mod->private_data;
+ PyObject *py_result;
+
+ py_result = PyObject_CallMethod(py_ldb, "request", "");
+
+ return LDB_ERR_OPERATIONS_ERROR;
+}
+
+int py_module_extended(struct ldb_module *mod, struct ldb_request *req)
+{
+ PyObject *py_ldb = mod->private_data;
+ PyObject *py_result;
+
+ py_result = PyObject_CallMethod(py_ldb, "extended", "");
+
+ return LDB_ERR_OPERATIONS_ERROR;
+}
+
+int py_module_start_transaction(struct ldb_module *mod)
+{
+ PyObject *py_ldb = mod->private_data;
+ PyObject *py_result;
+
+ py_result = PyObject_CallMethod(py_ldb, "start_transaction", "");
+
+ if (py_result == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ Py_DECREF(py_result);
+
+ return LDB_SUCCESS;
+}
+
+int py_module_end_transaction(struct ldb_module *mod)
+{
+ PyObject *py_ldb = mod->private_data;
+ PyObject *py_result;
+
+ py_result = PyObject_CallMethod(py_ldb, "end_transaction", "");
+
+ if (py_result == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ Py_DECREF(py_result);
+
+ return LDB_SUCCESS;
+}
+
+int py_module_del_transaction(struct ldb_module *mod)
+{
+ PyObject *py_ldb = mod->private_data;
+ PyObject *py_result;
+
+ py_result = PyObject_CallMethod(py_ldb, "del_transaction", "");
+
+ if (py_result == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ Py_DECREF(py_result);
+
+ return LDB_SUCCESS;
+}
+
+int py_module_sequence_number(struct ldb_module *mod, struct ldb_request *req)
+{
+ PyObject *py_ldb = mod->private_data;
+ PyObject *py_result;
+ int ret;
+
+ py_result = PyObject_CallMethod(py_ldb, "sequence_number", "ili", req->op.seq_num.type, req->op.seq_num.seq_num, req->op.seq_num.flags);
+
+ if (py_result == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ ret = PyInt_AsLong(py_result);
+
+ Py_DECREF(py_result);
+
+ return ret;
+}
+
+static int py_module_destructor(void *_mod)
+{
+ struct ldb_module *mod = _mod;
+ Py_DECREF((PyObject *)mod->private_data);
+ return 0;
+}
+
+int py_module_init (struct ldb_module *mod)
+{
+ PyObject *py_class = mod->ops->private_data;
+ PyObject *py_result, *py_next, *py_ldb;
+
+ py_ldb = SWIG_NewPointerObj(mod->ldb, SWIGTYPE_p_ldb_context, 0);
+
+ if (py_ldb == NULL)
+ return LDB_ERR_OPERATIONS_ERROR;
+
+ py_next = SWIG_NewPointerObj(mod->next, SWIGTYPE_p_ldb_module, 0);
+
+ if (py_next == NULL)
+ return LDB_ERR_OPERATIONS_ERROR;
+
+ py_result = PyObject_CallFunction(py_class, "OO", py_ldb, py_next);
+
+ if (py_result == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ mod->private_data = py_result;
+
+ talloc_set_destructor (mod, py_module_destructor);
+
+ return ldb_next_init(mod);
+}
+
#ifdef __cplusplus
extern "C" {
#endif
}
+SWIGINTERN PyObject *_wrap_Ldb_firstmodule_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ ldb *arg1 = (ldb *) 0 ;
+ struct ldb_module *arg2 = (struct ldb_module *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+
+ if (!SWIG_Python_UnpackTuple(args,"Ldb_firstmodule_set",2,2,swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_firstmodule_set" "', argument " "1"" of type '" "ldb *""'");
+ }
+ arg1 = (ldb *)(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ldb_module, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_firstmodule_set" "', argument " "2"" of type '" "struct ldb_module *""'");
+ }
+ arg2 = (struct ldb_module *)(argp2);
+ if (arg1 == NULL)
+ SWIG_exception(SWIG_ValueError,
+ "ldb context must be non-NULL");
+ if (arg1) (arg1)->modules = arg2;
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Ldb_firstmodule_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ ldb *arg1 = (ldb *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ struct ldb_module *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_firstmodule_get" "', argument " "1"" of type '" "ldb *""'");
+ }
+ arg1 = (ldb *)(argp1);
+ if (arg1 == NULL)
+ SWIG_exception(SWIG_ValueError,
+ "ldb context must be non-NULL");
+ result = (struct ldb_module *) ((arg1)->modules);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_module, 0 | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
SWIGINTERN PyObject *_wrap_new_Ldb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
ldb *result = 0 ;
SWIG_fail;
}
resultobj = Py_None;
- resultobj = PyList_New((*arg8)->count);
- for (i8 = 0; i8 < (*arg8)->count; i8++) {
- PyList_SetItem(resultobj, i8,
- SWIG_NewPointerObj((*arg8)->msgs[i8], SWIGTYPE_p_ldb_message, 0)
- );
+ if (arg8 == NULL) {
+ resultobj = Py_None;
+ } else {
+ resultobj = PyList_New((*arg8)->count);
+ for (i8 = 0; i8 < (*arg8)->count; i8++) {
+ PyList_SetItem(resultobj, i8,
+ SWIG_NewPointerObj((*arg8)->msgs[i8], SWIGTYPE_p_ldb_message, 0)
+ );
+ }
}
talloc_free(arg3);
if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
}
-SWIGINTERN PyObject *_wrap_register_module(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
+SWIGINTERN PyObject *_wrap_ldb_module_prev_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- struct ldb_module_ops *arg1 = (struct ldb_module_ops *) 0 ;
- PyObject * obj0 = 0 ;
- char * kwnames[] = {
- (char *)"arg1", NULL
- };
- ldb_int_error result;
+ ldb_module *arg1 = (ldb_module *) 0 ;
+ struct ldb_module *arg2 = (struct ldb_module *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:register_module",kwnames,&obj0)) SWIG_fail;
- arg1 = talloc_zero(talloc_autofree_context(), struct ldb_module_ops);
+ if (!SWIG_Python_UnpackTuple(args,"ldb_module_prev_set",2,2,swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_module, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_prev_set" "', argument " "1"" of type '" "ldb_module *""'");
+ }
+ arg1 = (ldb_module *)(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ldb_module, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ldb_module_prev_set" "', argument " "2"" of type '" "struct ldb_module *""'");
+ }
+ arg2 = (struct ldb_module *)(argp2);
+ if (arg1) (arg1)->prev = arg2;
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ldb_module_prev_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ ldb_module *arg1 = (ldb_module *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ struct ldb_module *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_module, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_prev_get" "', argument " "1"" of type '" "ldb_module *""'");
+ }
+ arg1 = (ldb_module *)(argp1);
+ result = (struct ldb_module *) ((arg1)->prev);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_module, 0 | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ldb_module_next_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ ldb_module *arg1 = (ldb_module *) 0 ;
+ struct ldb_module *arg2 = (struct ldb_module *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+
+ if (!SWIG_Python_UnpackTuple(args,"ldb_module_next_set",2,2,swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_module, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_next_set" "', argument " "1"" of type '" "ldb_module *""'");
+ }
+ arg1 = (ldb_module *)(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ldb_module, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ldb_module_next_set" "', argument " "2"" of type '" "struct ldb_module *""'");
+ }
+ arg2 = (struct ldb_module *)(argp2);
+ if (arg1) (arg1)->next = arg2;
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ldb_module_next_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ ldb_module *arg1 = (ldb_module *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ struct ldb_module *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_module, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_next_get" "', argument " "1"" of type '" "ldb_module *""'");
+ }
+ arg1 = (ldb_module *)(argp1);
+ result = (struct ldb_module *) ((arg1)->next);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_module, 0 | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ldb_module___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ ldb_module *arg1 = (ldb_module *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ char *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_module, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module___str__" "', argument " "1"" of type '" "ldb_module *""'");
+ }
+ arg1 = (ldb_module *)(argp1);
+ result = (char *)ldb_module___str__(arg1);
+ resultobj = SWIG_FromCharPtr((const char *)result);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ldb_module___repr__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ ldb_module *arg1 = (ldb_module *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ char *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_module, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module___repr__" "', argument " "1"" of type '" "ldb_module *""'");
+ }
+ arg1 = (ldb_module *)(argp1);
+ result = (char *)ldb_module___repr__(arg1);
+ resultobj = SWIG_FromCharPtr((const char *)result);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ldb_module_search(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
+ PyObject *resultobj = 0;
+ ldb_module *arg1 = (ldb_module *) 0 ;
+ struct ldb_dn *arg2 = (struct ldb_dn *) 0 ;
+ enum ldb_scope arg3 ;
+ struct ldb_parse_tree *arg4 = (struct ldb_parse_tree *) 0 ;
+ char **arg5 = (char **) 0 ;
+ struct ldb_result **arg6 = (struct ldb_result **) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ struct ldb_result *temp_ldb_result6 ;
+ int i6 ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+ PyObject * obj2 = 0 ;
+ PyObject * obj3 = 0 ;
+ PyObject * obj4 = 0 ;
+ char * kwnames[] = {
+ (char *) "self",(char *) "base",(char *) "scope",(char *) "tree",(char *) "attrs", NULL
+ };
+ int result;
+
+ arg6 = &temp_ldb_result6;
+ if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:ldb_module_search",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_module, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_search" "', argument " "1"" of type '" "ldb_module *""'");
+ }
+ arg1 = (ldb_module *)(argp1);
+ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_dn, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ldb_module_search" "', argument " "2"" of type '" "struct ldb_dn *""'");
+ }
+ arg2 = (struct ldb_dn *)(argp2);
+ ecode3 = SWIG_AsVal_int(obj2, &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ldb_module_search" "', argument " "3"" of type '" "enum ldb_scope""'");
+ }
+ arg3 = (enum ldb_scope)(val3);
+ res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_ldb_parse_tree, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ldb_module_search" "', argument " "4"" of type '" "struct ldb_parse_tree *""'");
+ }
+ arg4 = (struct ldb_parse_tree *)(argp4);
+ if (obj4 == Py_None) {
+ arg5 = NULL;
+ } else if (PySequence_Check(obj4)) {
+ int i;
+ arg5 = talloc_array(NULL, char *, PySequence_Size(obj4)+1);
+ for(i = 0; i < PySequence_Size(obj4); i++)
+ arg5[i] = PyString_AsString(PySequence_GetItem(obj4, i));
+ arg5[i] = NULL;
+ } else {
+ SWIG_exception(SWIG_TypeError, "expected sequence");
+ }
+ result = (int)ldb_module_search(arg1,arg2,arg3,arg4,(char const *const *)arg5,arg6);
+ resultobj = SWIG_From_int((int)(result));
+ if (arg6 == NULL) {
+ resultobj = Py_None;
+ } else {
+ resultobj = PyList_New((*arg6)->count);
+ for (i6 = 0; i6 < (*arg6)->count; i6++) {
+ PyList_SetItem(resultobj, i6,
+ SWIG_NewPointerObj((*arg6)->msgs[i6], SWIGTYPE_p_ldb_message, 0)
+ );
+ }
+ }
+ talloc_free(arg5);
+ return resultobj;
+fail:
+ talloc_free(arg5);
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ldb_module_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
+ PyObject *resultobj = 0;
+ ldb_module *arg1 = (ldb_module *) 0 ;
+ struct ldb_message *arg2 = (struct ldb_message *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+ char * kwnames[] = {
+ (char *) "self",(char *) "message", NULL
+ };
+ ldb_error result;
+
+ if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ldb_module_add",kwnames,&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_module, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_add" "', argument " "1"" of type '" "ldb_module *""'");
+ }
+ arg1 = (ldb_module *)(argp1);
+ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_message, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ldb_module_add" "', argument " "2"" of type '" "struct ldb_message *""'");
+ }
+ arg2 = (struct ldb_message *)(argp2);
+ result = ldb_module_add(arg1,arg2);
+ if (result != 0) {
+ PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
+ SWIG_fail;
+ }
+ resultobj = Py_None;
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ldb_module_modify(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
+ PyObject *resultobj = 0;
+ ldb_module *arg1 = (ldb_module *) 0 ;
+ struct ldb_message *arg2 = (struct ldb_message *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+ char * kwnames[] = {
+ (char *) "self",(char *) "message", NULL
+ };
+ ldb_error result;
+
+ if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ldb_module_modify",kwnames,&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_module, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_modify" "', argument " "1"" of type '" "ldb_module *""'");
+ }
+ arg1 = (ldb_module *)(argp1);
+ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_message, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ldb_module_modify" "', argument " "2"" of type '" "struct ldb_message *""'");
+ }
+ arg2 = (struct ldb_message *)(argp2);
+ result = ldb_module_modify(arg1,arg2);
+ if (result != 0) {
+ PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
+ SWIG_fail;
+ }
+ resultobj = Py_None;
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ldb_module_delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
+ PyObject *resultobj = 0;
+ ldb_module *arg1 = (ldb_module *) 0 ;
+ struct ldb_dn *arg2 = (struct ldb_dn *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+ char * kwnames[] = {
+ (char *) "self",(char *) "dn", NULL
+ };
+ ldb_error result;
+
+ if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ldb_module_delete",kwnames,&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_module, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_delete" "', argument " "1"" of type '" "ldb_module *""'");
+ }
+ arg1 = (ldb_module *)(argp1);
+ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_dn, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ldb_module_delete" "', argument " "2"" of type '" "struct ldb_dn *""'");
+ }
+ arg2 = (struct ldb_dn *)(argp2);
+ result = ldb_module_delete(arg1,arg2);
+ if (result != 0) {
+ PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
+ SWIG_fail;
+ }
+ resultobj = Py_None;
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ldb_module_rename(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
+ PyObject *resultobj = 0;
+ ldb_module *arg1 = (ldb_module *) 0 ;
+ struct ldb_dn *arg2 = (struct ldb_dn *) 0 ;
+ struct ldb_dn *arg3 = (struct ldb_dn *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+ PyObject * obj2 = 0 ;
+ char * kwnames[] = {
+ (char *) "self",(char *) "olddn",(char *) "newdn", NULL
+ };
+ ldb_error result;
+
+ if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ldb_module_rename",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_module, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_rename" "', argument " "1"" of type '" "ldb_module *""'");
+ }
+ arg1 = (ldb_module *)(argp1);
+ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_dn, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ldb_module_rename" "', argument " "2"" of type '" "struct ldb_dn *""'");
+ }
+ arg2 = (struct ldb_dn *)(argp2);
+ res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_ldb_dn, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ldb_module_rename" "', argument " "3"" of type '" "struct ldb_dn *""'");
+ }
+ arg3 = (struct ldb_dn *)(argp3);
+ result = ldb_module_rename(arg1,arg2,arg3);
+ if (result != 0) {
+ PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
+ SWIG_fail;
+ }
+ resultobj = Py_None;
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ldb_module_start_transaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ ldb_module *arg1 = (ldb_module *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ ldb_error result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_module, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_start_transaction" "', argument " "1"" of type '" "ldb_module *""'");
+ }
+ arg1 = (ldb_module *)(argp1);
+ result = ldb_module_start_transaction(arg1);
+ if (result != 0) {
+ PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
+ SWIG_fail;
+ }
+ resultobj = Py_None;
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ldb_module_end_transaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ ldb_module *arg1 = (ldb_module *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ ldb_error result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_module, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_end_transaction" "', argument " "1"" of type '" "ldb_module *""'");
+ }
+ arg1 = (ldb_module *)(argp1);
+ result = ldb_module_end_transaction(arg1);
+ if (result != 0) {
+ PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
+ SWIG_fail;
+ }
+ resultobj = Py_None;
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ldb_module_del_transaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ ldb_module *arg1 = (ldb_module *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ ldb_error result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_module, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_del_transaction" "', argument " "1"" of type '" "ldb_module *""'");
+ }
+ arg1 = (ldb_module *)(argp1);
+ result = ldb_module_del_transaction(arg1);
+ if (result != 0) {
+ PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
+ SWIG_fail;
+ }
+ resultobj = Py_None;
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ldb_module(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ ldb_module *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args,"new_ldb_module",0,0,0)) SWIG_fail;
+ result = (ldb_module *)calloc(1, sizeof(ldb_module));
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_module, SWIG_POINTER_NEW | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_ldb_module(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ ldb_module *arg1 = (ldb_module *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_module, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ldb_module" "', argument " "1"" of type '" "ldb_module *""'");
+ }
+ arg1 = (ldb_module *)(argp1);
+ free((char *) arg1);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *ldb_module_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *obj;
+ if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
+ SWIG_TypeNewClientData(SWIGTYPE_p_ldb_module, SWIG_NewClientData(obj));
+ return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *ldb_module_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ return SWIG_Python_InitShadowInstance(args);
+}
+
+SWIGINTERN PyObject *_wrap_register_module(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
+ PyObject *resultobj = 0;
+ struct ldb_module_ops *arg1 = (struct ldb_module_ops *) 0 ;
+ PyObject * obj0 = 0 ;
+ char * kwnames[] = {
+ (char *)"arg1", NULL
+ };
+ ldb_int_error result;
+
+ if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:register_module",kwnames,&obj0)) SWIG_fail;
+ arg1 = talloc_zero(talloc_autofree_context(), struct ldb_module_ops);
+
+ arg1->name = talloc_strdup(arg1, PyString_AsString(PyObject_GetAttrString(obj0, (char *)"name")));
- arg1->name = (char *)PyObject_GetAttrString(obj0, (char *)"name");
+ Py_INCREF(obj0);
+ arg1->private_data = obj0;
+ arg1->init_context = py_module_init;
+ arg1->search = py_module_search;
+ arg1->add = py_module_add;
+ arg1->modify = py_module_modify;
+ arg1->del = py_module_del;
+ arg1->rename = py_module_rename;
+ arg1->request = py_module_request;
+ arg1->extended = py_module_extended;
+ arg1->start_transaction = py_module_start_transaction;
+ arg1->end_transaction = py_module_end_transaction;
+ arg1->del_transaction = py_module_del_transaction;
+ arg1->sequence_number = py_module_sequence_number;
result = ldb_register_module((struct ldb_module_ops const *)arg1);
if (result != 0) {
PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_strerror(result)));
{ (char *)"Message_swigregister", Message_swigregister, METH_VARARGS, NULL},
{ (char *)"Message_swiginit", Message_swiginit, METH_VARARGS, NULL},
{ (char *)"ldb_ldif_to_pyobject", (PyCFunction) _wrap_ldb_ldif_to_pyobject, METH_VARARGS | METH_KEYWORDS, NULL},
+ { (char *)"Ldb_firstmodule_set", _wrap_Ldb_firstmodule_set, METH_VARARGS, NULL},
+ { (char *)"Ldb_firstmodule_get", (PyCFunction)_wrap_Ldb_firstmodule_get, METH_O, NULL},
{ (char *)"new_Ldb", (PyCFunction)_wrap_new_Ldb, METH_NOARGS, NULL},
{ (char *)"Ldb_connect", (PyCFunction) _wrap_Ldb_connect, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
"S.connect(url,flags=0,options=None) -> None\n"
"S.string_to_time(string) -> int\n"
"Parse a LDAP time string into a UNIX timestamp.\n"
""},
+ { (char *)"ldb_module_prev_set", _wrap_ldb_module_prev_set, METH_VARARGS, NULL},
+ { (char *)"ldb_module_prev_get", (PyCFunction)_wrap_ldb_module_prev_get, METH_O, NULL},
+ { (char *)"ldb_module_next_set", _wrap_ldb_module_next_set, METH_VARARGS, NULL},
+ { (char *)"ldb_module_next_get", (PyCFunction)_wrap_ldb_module_next_get, METH_O, NULL},
+ { (char *)"ldb_module___str__", (PyCFunction)_wrap_ldb_module___str__, METH_O, NULL},
+ { (char *)"ldb_module___repr__", (PyCFunction)_wrap_ldb_module___repr__, METH_O, NULL},
+ { (char *)"ldb_module_search", (PyCFunction) _wrap_ldb_module_search, METH_VARARGS | METH_KEYWORDS, NULL},
+ { (char *)"ldb_module_add", (PyCFunction) _wrap_ldb_module_add, METH_VARARGS | METH_KEYWORDS, NULL},
+ { (char *)"ldb_module_modify", (PyCFunction) _wrap_ldb_module_modify, METH_VARARGS | METH_KEYWORDS, NULL},
+ { (char *)"ldb_module_delete", (PyCFunction) _wrap_ldb_module_delete, METH_VARARGS | METH_KEYWORDS, NULL},
+ { (char *)"ldb_module_rename", (PyCFunction) _wrap_ldb_module_rename, METH_VARARGS | METH_KEYWORDS, NULL},
+ { (char *)"ldb_module_start_transaction", (PyCFunction)_wrap_ldb_module_start_transaction, METH_O, NULL},
+ { (char *)"ldb_module_end_transaction", (PyCFunction)_wrap_ldb_module_end_transaction, METH_O, NULL},
+ { (char *)"ldb_module_del_transaction", (PyCFunction)_wrap_ldb_module_del_transaction, METH_O, NULL},
+ { (char *)"new_ldb_module", (PyCFunction)_wrap_new_ldb_module, METH_NOARGS, NULL},
+ { (char *)"delete_ldb_module", (PyCFunction)_wrap_delete_ldb_module, METH_O, NULL},
+ { (char *)"ldb_module_swigregister", ldb_module_swigregister, METH_VARARGS, NULL},
+ { (char *)"ldb_module_swiginit", ldb_module_swiginit, METH_VARARGS, NULL},
{ (char *)"register_module", (PyCFunction) _wrap_register_module, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
"S.register_module(module) -> None\n"
"Register a LDB module.\n"
static swig_type_info _swigt__p_ldb_ldif = {"_p_ldb_ldif", "struct ldb_ldif *|ldb_ldif *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ldb_message = {"_p_ldb_message", "ldb_msg *|struct ldb_message *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ldb_message_element = {"_p_ldb_message_element", "struct ldb_message_element *|ldb_message_element *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_ldb_module = {"_p_ldb_module", "struct ldb_module *|ldb_module *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ldb_module_ops = {"_p_ldb_module_ops", "struct ldb_module_ops *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_ldb_parse_tree = {"_p_ldb_parse_tree", "struct ldb_parse_tree *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ldb_result = {"_p_ldb_result", "struct ldb_result *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ldb_val = {"_p_ldb_val", "struct ldb_val *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_long_long = {"_p_long_long", "int_least64_t *|int_fast64_t *|int64_t *|long long *|intmax_t *", 0, 0, (void*)0, 0};
&_swigt__p_ldb_ldif,
&_swigt__p_ldb_message,
&_swigt__p_ldb_message_element,
+ &_swigt__p_ldb_module,
&_swigt__p_ldb_module_ops,
+ &_swigt__p_ldb_parse_tree,
&_swigt__p_ldb_result,
&_swigt__p_ldb_val,
&_swigt__p_long_long,
static swig_cast_info _swigc__p_ldb_ldif[] = { {&_swigt__p_ldb_ldif, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ldb_message[] = { {&_swigt__p_ldb_message, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ldb_message_element[] = { {&_swigt__p_ldb_message_element, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_ldb_module[] = { {&_swigt__p_ldb_module, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ldb_module_ops[] = { {&_swigt__p_ldb_module_ops, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_ldb_parse_tree[] = { {&_swigt__p_ldb_parse_tree, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ldb_result[] = { {&_swigt__p_ldb_result, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ldb_val[] = { {&_swigt__p_ldb_val, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_long_long[] = { {&_swigt__p_long_long, 0, 0, 0},{0, 0, 0, 0}};
_swigc__p_ldb_ldif,
_swigc__p_ldb_message,
_swigc__p_ldb_message_element,
+ _swigc__p_ldb_module,
_swigc__p_ldb_module_ops,
+ _swigc__p_ldb_parse_tree,
_swigc__p_ldb_result,
_swigc__p_ldb_val,
_swigc__p_long_long,
# disable ldb_sqlite3 by default
SMB_ENABLE(ldb_sqlite3, NO)
-if test x"$with_sqlite3_support" = x"yes"; then
- SMB_ENABLE(ldb_sqlite3, YES)
-fi
+#if test x"$with_sqlite3_support" = x"yes"; then
+# SMB_ENABLE(ldb_sqlite3, YES)
+#fi
/*
ldb database library
- Copyright (C) Simo Sorce 2005
+ Copyright (C) Simo Sorce 2005-2008
** NOTE! The following LGPL license applies to the ldb
** library. This does NOT imply that all of Samba is released
struct asq_context {
- enum {ASQ_INIT, ASQ_SEARCH_BASE, ASQ_SEARCH_MULTI} step;
+ enum {ASQ_SEARCH_BASE, ASQ_SEARCH_MULTI} step;
struct ldb_module *module;
- struct ldb_request *orig_req;
+ struct ldb_request *req;
struct ldb_asq_control *asq_ctrl;
ASQ_CTRL_AFFECTS_MULTIPLE_DSA = 71
} asq_ret;
- struct ldb_request *base_req;
struct ldb_reply *base_res;
struct ldb_request **reqs;
struct ldb_control **controls;
};
-static struct ldb_handle *init_handle(struct ldb_request *req, struct ldb_module *module)
+static struct asq_context *asq_context_init(struct ldb_module *module, struct ldb_request *req)
{
struct asq_context *ac;
- struct ldb_handle *h;
-
- h = talloc_zero(req, struct ldb_handle);
- if (h == NULL) {
- ldb_set_errstring(module->ldb, "Out of Memory");
- return NULL;
- }
- h->module = module;
-
- ac = talloc_zero(h, struct asq_context);
+ ac = talloc_zero(req, struct asq_context);
if (ac == NULL) {
- ldb_set_errstring(module->ldb, "Out of Memory");
- talloc_free(h);
+ ldb_oom(module->ldb);
return NULL;
}
- h->private_data = (void *)ac;
-
- h->state = LDB_ASYNC_INIT;
- h->status = LDB_SUCCESS;
-
- ac->step = ASQ_INIT;
ac->module = module;
- ac->orig_req = req;
+ ac->req = req;
- return h;
+ return ac;
}
-static int asq_terminate(struct ldb_handle *handle)
+static int asq_search_continue(struct asq_context *ac);
+
+static int asq_search_terminate(struct asq_context *ac)
{
- struct asq_context *ac;
- struct ldb_reply *ares;
struct ldb_asq_control *asq;
int i;
- ac = talloc_get_type(handle->private_data, struct asq_context);
- if (ac == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- handle->status = LDB_SUCCESS;
- handle->state = LDB_ASYNC_DONE;
-
- ares = talloc_zero(ac, struct ldb_reply);
- if (ares == NULL)
- return LDB_ERR_OPERATIONS_ERROR;
-
- ares->type = LDB_REPLY_DONE;
-
if (ac->controls) {
- for (i = 0; ac->controls[i]; i++);
- ares->controls = talloc_move(ares, &ac->controls);
+ for (i = 0; ac->controls[i]; i++) /* count em */ ;
} else {
i = 0;
}
- ares->controls = talloc_realloc(ares, ares->controls, struct ldb_control *, i + 2);
-
- if (ares->controls == NULL)
+ ac->controls = talloc_realloc(ac, ac->controls, struct ldb_control *, i + 2);
+
+ if (ac->controls == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
+ }
- ares->controls[i] = talloc(ares->controls, struct ldb_control);
- if (ares->controls[i] == NULL)
+ ac->controls[i] = talloc(ac->controls, struct ldb_control);
+ if (ac->controls[i] == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
+ }
- ares->controls[i]->oid = LDB_CONTROL_ASQ_OID;
- ares->controls[i]->critical = 0;
+ ac->controls[i]->oid = LDB_CONTROL_ASQ_OID;
+ ac->controls[i]->critical = 0;
- asq = talloc_zero(ares->controls[i], struct ldb_asq_control);
+ asq = talloc_zero(ac->controls[i], struct ldb_asq_control);
if (asq == NULL)
return LDB_ERR_OPERATIONS_ERROR;
asq->result = ac->asq_ret;
-
- ares->controls[i]->data = asq;
- ares->controls[i + 1] = NULL;
+ ac->controls[i]->data = asq;
- ac->orig_req->callback(ac->module->ldb, ac->orig_req->context, ares);
+ ac->controls[i + 1] = NULL;
- return LDB_SUCCESS;
+ return ldb_module_done(ac->req, ac->controls, NULL, LDB_SUCCESS);
}
-static int asq_base_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
+static int asq_base_callback(struct ldb_request *req, struct ldb_reply *ares)
{
struct asq_context *ac;
+ int ret;
- if (!context || !ares) {
- ldb_set_errstring(ldb, "NULL Context or Result in callback");
- goto error;
- }
+ ac = talloc_get_type(req->context, struct asq_context);
- ac = talloc_get_type(context, struct asq_context);
- if (ac == NULL) {
- goto error;
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
}
- /* we are interested only in the single reply (base search) we receive here */
- if (ares->type == LDB_REPLY_ENTRY) {
+ switch (ares->type) {
+ case LDB_REPLY_ENTRY:
ac->base_res = talloc_move(ac, &ares);
- } else {
+ break;
+
+ case LDB_REPLY_REFERRAL:
+ /* ignore referrals */
talloc_free(ares);
- }
+ break;
+ case LDB_REPLY_DONE:
+
+ talloc_free(ares);
+
+ /* next step */
+ ret = asq_search_continue(ac);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL, ret);
+ }
+ break;
+
+ }
return LDB_SUCCESS;
-error:
- talloc_free(ares);
- return LDB_ERR_OPERATIONS_ERROR;
}
-static int asq_reqs_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
+static int asq_reqs_callback(struct ldb_request *req, struct ldb_reply *ares)
{
struct asq_context *ac;
+ int ret;
- if (!context || !ares) {
- ldb_set_errstring(ldb, "NULL Context or Result in callback");
- goto error;
- }
+ ac = talloc_get_type(req->context, struct asq_context);
- ac = talloc_get_type(context, struct asq_context);
- if (ac == NULL) {
- goto error;
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
}
- /* we are interested only in the single reply (base search) we receive here */
- if (ares->type == LDB_REPLY_ENTRY) {
-
+ switch (ares->type) {
+ case LDB_REPLY_ENTRY:
/* pass the message up to the original callback as we
* do not have to elaborate on it any further */
- return ac->orig_req->callback(ac->module->ldb, ac->orig_req->context, ares);
-
- } else { /* ignore any REFERRAL or DONE reply */
+ ret = ldb_module_send_entry(ac->req, ares->message);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL, ret);
+ }
+ talloc_free(ares);
+ break;
+
+ case LDB_REPLY_REFERRAL:
+ /* ignore referrals */
+ talloc_free(ares);
+ break;
+
+ case LDB_REPLY_DONE:
+
talloc_free(ares);
+
+ ret = asq_search_continue(ac);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL, ret);
+ }
+ break;
}
return LDB_SUCCESS;
-error:
- talloc_free(ares);
- return LDB_ERR_OPERATIONS_ERROR;
}
-static int asq_build_first_request(struct asq_context *ac)
+static int asq_build_first_request(struct asq_context *ac, struct ldb_request **base_req)
{
- char **base_attrs;
+ const char **base_attrs;
+ int ret;
- ac->base_req = talloc_zero(ac, struct ldb_request);
- if (ac->base_req == NULL) return LDB_ERR_OPERATIONS_ERROR;
+ ac->req_attrs = ac->req->op.search.attrs;
+ ac->req_attribute = talloc_strdup(ac, ac->asq_ctrl->source_attribute);
+ if (ac->req_attribute == NULL)
+ return LDB_ERR_OPERATIONS_ERROR;
- ac->base_req->operation = ac->orig_req->operation;
- ac->base_req->op.search.base = ac->orig_req->op.search.base;
- ac->base_req->op.search.scope = LDB_SCOPE_BASE;
- ac->base_req->op.search.tree = ac->orig_req->op.search.tree;
- base_attrs = talloc_array(ac->base_req, char *, 2);
+ base_attrs = talloc_array(ac, const char *, 2);
if (base_attrs == NULL) return LDB_ERR_OPERATIONS_ERROR;
base_attrs[0] = talloc_strdup(base_attrs, ac->asq_ctrl->source_attribute);
if (base_attrs[0] == NULL) return LDB_ERR_OPERATIONS_ERROR;
base_attrs[1] = NULL;
- ac->base_req->op.search.attrs = (const char * const *)base_attrs;
- ac->base_req->context = ac;
- ac->base_req->callback = asq_base_callback;
- ldb_set_timeout_from_prev_req(ac->module->ldb, ac->orig_req, ac->base_req);
+ ret = ldb_build_search_req_ex(base_req, ac->module->ldb, ac,
+ ac->req->op.search.base,
+ LDB_SCOPE_BASE,
+ ac->req->op.search.tree,
+ (const char * const *)base_attrs,
+ NULL,
+ ac, asq_base_callback,
+ ac->req);
+ if (ret != LDB_SUCCESS) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
return LDB_SUCCESS;
}
-static int asq_build_multiple_requests(struct asq_context *ac, struct ldb_handle *handle)
+static int asq_build_multiple_requests(struct asq_context *ac, bool *terminated)
{
+ struct ldb_control **saved_controls;
+ struct ldb_control *control;
+ struct ldb_dn *dn;
struct ldb_message_element *el;
- int i;
+ int ret, i;
- /* look up the DNs */
if (ac->base_res == NULL) {
return LDB_ERR_NO_SUCH_OBJECT;
}
+
el = ldb_msg_find_element(ac->base_res->message, ac->req_attribute);
/* no values found */
if (el == NULL) {
ac->asq_ret = ASQ_CTRL_SUCCESS;
- return asq_terminate(handle);
+ *terminated = true;
+ return asq_search_terminate(ac);
}
ac->num_reqs = el->num_values;
for (i = 0; i < el->num_values; i++) {
- ac->reqs[i] = talloc_zero(ac->reqs, struct ldb_request);
- if (ac->reqs[i] == NULL)
- return LDB_ERR_OPERATIONS_ERROR;
- ac->reqs[i]->operation = LDB_SEARCH;
- ac->reqs[i]->op.search.base = ldb_dn_new(ac->reqs[i], ac->module->ldb, (const char *)el->values[i].data);
- if ( ! ldb_dn_validate(ac->reqs[i]->op.search.base)) {
+ dn = ldb_dn_new(ac, ac->module->ldb,
+ (const char *)el->values[i].data);
+ if ( ! ldb_dn_validate(dn)) {
ac->asq_ret = ASQ_CTRL_INVALID_ATTRIBUTE_SYNTAX;
- return asq_terminate(handle);
+ *terminated = true;
+ return asq_search_terminate(ac);
+ }
+
+ ret = ldb_build_search_req_ex(&ac->reqs[i],
+ ac->module->ldb, ac,
+ dn, LDB_SCOPE_BASE,
+ ac->req->op.search.tree,
+ ac->req_attrs,
+ ac->req->controls,
+ ac, asq_reqs_callback,
+ ac->req);
+ if (ret != LDB_SUCCESS) {
+ return LDB_ERR_OPERATIONS_ERROR;
}
- ac->reqs[i]->op.search.scope = LDB_SCOPE_BASE;
- ac->reqs[i]->op.search.tree = ac->base_req->op.search.tree;
- ac->reqs[i]->op.search.attrs = ac->req_attrs;
- ac->reqs[i]->context = ac;
- ac->reqs[i]->callback = asq_reqs_callback;
- ldb_set_timeout_from_prev_req(ac->module->ldb, ac->base_req, ac->reqs[i]);
+ /* remove the ASQ control itself */
+ control = ldb_request_get_control(ac->req, LDB_CONTROL_ASQ_OID);
+ if (!save_controls(control, ac->reqs[i], &saved_controls)) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
}
return LDB_SUCCESS;
}
-static int asq_search_continue(struct ldb_handle *handle)
+static int asq_search_continue(struct asq_context *ac)
{
- struct asq_context *ac;
+ bool terminated = false;
int ret;
-
- if (!handle || !handle->private_data) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- if (handle->state == LDB_ASYNC_DONE) {
- return handle->status;
- }
-
- ac = talloc_get_type(handle->private_data, struct asq_context);
- if (ac == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
switch (ac->step) {
- case ASQ_INIT:
- /* check the search is well formed */
- if (ac->orig_req->op.search.scope != LDB_SCOPE_BASE) {
- ac->asq_ret = ASQ_CTRL_UNWILLING_TO_PERFORM;
- return asq_terminate(handle);
- }
-
- ac->req_attrs = ac->orig_req->op.search.attrs;
- ac->req_attribute = talloc_strdup(ac, ac->asq_ctrl->source_attribute);
- if (ac->req_attribute == NULL)
- return LDB_ERR_OPERATIONS_ERROR;
-
- /* get the object to retrieve the DNs to search */
- ret = asq_build_first_request(ac);
- if (ret != LDB_SUCCESS) {
- return ret;
- }
-
- ac->step = ASQ_SEARCH_BASE;
-
- handle->state = LDB_ASYNC_PENDING;
- handle->status = LDB_SUCCESS;
-
- return ldb_request(ac->module->ldb, ac->base_req);
-
case ASQ_SEARCH_BASE:
- ret = ldb_wait(ac->base_req->handle, LDB_WAIT_NONE);
-
- if (ret != LDB_SUCCESS) {
- handle->status = ret;
- goto done;
- }
-
- if (ac->base_req->handle->status != LDB_SUCCESS) {
- handle->status = ac->base_req->handle->status;
- goto done;
+ /* build up the requests call chain */
+ ret = asq_build_multiple_requests(ac, &terminated);
+ if (ret != LDB_SUCCESS || terminated) {
+ return ret;
}
- if (ac->base_req->handle->state == LDB_ASYNC_DONE) {
+ ac->step = ASQ_SEARCH_MULTI;
- /* build up the requests call chain */
- ret = asq_build_multiple_requests(ac, handle);
- if (ret != LDB_SUCCESS) {
- return ret;
- }
- if (handle->state == LDB_ASYNC_DONE) {
- return LDB_SUCCESS;
- }
-
- ac->step = ASQ_SEARCH_MULTI;
-
- return ldb_request(ac->module->ldb, ac->reqs[ac->cur_req]);
- }
-
- /* request still pending, return to cycle again */
- return LDB_SUCCESS;
+ return ldb_request(ac->module->ldb, ac->reqs[ac->cur_req]);
case ASQ_SEARCH_MULTI:
- ret = ldb_wait(ac->reqs[ac->cur_req]->handle, LDB_WAIT_NONE);
-
- if (ret != LDB_SUCCESS) {
- handle->status = ret;
- goto done;
- }
- if (ac->reqs[ac->cur_req]->handle->status != LDB_SUCCESS) {
- handle->status = ac->reqs[ac->cur_req]->handle->status;
- }
-
- if (ac->reqs[ac->cur_req]->handle->state == LDB_ASYNC_DONE) {
- ac->cur_req++;
+ ac->cur_req++;
- if (ac->cur_req < ac->num_reqs) {
- return ldb_request(ac->module->ldb, ac->reqs[ac->cur_req]);
- }
-
- return asq_terminate(handle);
+ if (ac->cur_req == ac->num_reqs) {
+ /* done */
+ return asq_search_terminate(ac);
}
- /* request still pending, return to cycle again */
- return LDB_SUCCESS;
-
- default:
- ret = LDB_ERR_OPERATIONS_ERROR;
- break;
+ return ldb_request(ac->module->ldb, ac->reqs[ac->cur_req]);
}
-done:
- handle->state = LDB_ASYNC_DONE;
- return ret;
+ return LDB_ERR_OPERATIONS_ERROR;
}
static int asq_search(struct ldb_module *module, struct ldb_request *req)
{
+ struct ldb_request *base_req;
struct ldb_control *control;
struct asq_context *ac;
- struct ldb_handle *h;
+ int ret;
/* check if there's a paged request control */
control = ldb_request_get_control(req, LDB_CONTROL_ASQ_OID);
return ldb_next_request(module, req);
}
- req->handle = NULL;
-
- if (!req->callback || !req->context) {
- ldb_set_errstring(module->ldb,
- "Async interface called with NULL callback function or NULL context");
+ ac = asq_context_init(module, req);
+ if (!ac) {
return LDB_ERR_OPERATIONS_ERROR;
}
- h = init_handle(req, module);
- if (!h) {
- return LDB_ERR_OPERATIONS_ERROR;
+ /* check the search is well formed */
+ if (req->op.search.scope != LDB_SCOPE_BASE) {
+ ac->asq_ret = ASQ_CTRL_UNWILLING_TO_PERFORM;
+ return asq_search_terminate(ac);
}
- ac = talloc_get_type(h->private_data, struct asq_context);
ac->asq_ctrl = talloc_get_type(control->data, struct ldb_asq_control);
if (!ac->asq_ctrl) {
return LDB_ERR_PROTOCOL_ERROR;
}
- req->handle = h;
-
- return asq_search_continue(h);
-}
-
-static int asq_wait(struct ldb_handle *handle, enum ldb_wait_type type)
-{
- int ret;
-
- if (!handle || !handle->private_data) {
- return LDB_ERR_OPERATIONS_ERROR;
+ ret = asq_build_first_request(ac, &base_req);
+ if (ret != LDB_SUCCESS) {
+ return ret;
}
- if (type == LDB_WAIT_ALL) {
- while (handle->state != LDB_ASYNC_DONE) {
- ret = asq_search_continue(handle);
- if (ret != LDB_SUCCESS) {
- return ret;
- }
- }
-
- return handle->status;
- }
+ ac->step = ASQ_SEARCH_BASE;
- return asq_search_continue(handle);
+ return ldb_request(module->ldb, base_req);
}
static int asq_init(struct ldb_module *module)
{
- struct ldb_request *req;
int ret;
- req = talloc_zero(module, struct ldb_request);
- if (req == NULL) {
- ldb_debug(module->ldb, LDB_DEBUG_ERROR, "asq: Out of memory!\n");
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- req->operation = LDB_REQ_REGISTER_CONTROL;
- req->op.reg_control.oid = LDB_CONTROL_ASQ_OID;
-
- ret = ldb_request(module->ldb, req);
+ ret = ldb_mod_register_control(module, LDB_CONTROL_ASQ_OID);
if (ret != LDB_SUCCESS) {
ldb_debug(module->ldb, LDB_DEBUG_WARNING, "asq: Unable to register control with rootdse!\n");
}
const struct ldb_module_ops ldb_asq_module_ops = {
.name = "asq",
.search = asq_search,
- .wait = asq_wait,
.init_context = asq_init
};
ldb database library
Copyright (C) Andrew Tridgell 2005
- Copyright (C) Simo Sorce 2006
+ Copyright (C) Simo Sorce 2006-2008
** NOTE! The following LGPL license applies to the ldb
** library. This does NOT imply that all of Samba is released
*/
struct operational_context {
-
struct ldb_module *module;
- void *up_context;
- int (*up_callback)(struct ldb_context *, void *, struct ldb_reply *);
+ struct ldb_request *req;
const char * const *attrs;
};
-static int operational_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
+static int operational_callback(struct ldb_request *req, struct ldb_reply *ares)
{
struct operational_context *ac;
+ int ret;
- if (!context || !ares) {
- ldb_set_errstring(ldb, "NULL Context or Result in callback");
- goto error;
- }
+ ac = talloc_get_type(req->context, struct operational_context);
- ac = talloc_get_type(context, struct operational_context);
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
- if (ares->type == LDB_REPLY_ENTRY) {
+ switch (ares->type) {
+ case LDB_REPLY_ENTRY:
/* for each record returned post-process to add any derived
attributes that have been asked for */
- if (operational_search_post_process(ac->module, ares->message, ac->attrs) != 0) {
- goto error;
+ ret = operational_search_post_process(ac->module,
+ ares->message,
+ ac->attrs);
+ if (ret != 0) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
- }
+ return ldb_module_send_entry(ac->req, ares->message);
- return ac->up_callback(ldb, ac->up_context, ares);
+ case LDB_REPLY_REFERRAL:
+ /* ignore referrals */
+ break;
+
+ case LDB_REPLY_DONE:
+
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, LDB_SUCCESS);
+ }
-error:
talloc_free(ares);
- return LDB_ERR_OPERATIONS_ERROR;
+ return LDB_SUCCESS;
}
static int operational_search(struct ldb_module *module, struct ldb_request *req)
struct operational_context *ac;
struct ldb_request *down_req;
const char **search_attrs = NULL;
- int i, a, ret;
-
- req->handle = NULL;
+ int i, a;
+ int ret;
ac = talloc(req, struct operational_context);
if (ac == NULL) {
}
ac->module = module;
- ac->up_context = req->context;
- ac->up_callback = req->callback;
+ ac->req = req;
ac->attrs = req->op.search.attrs;
- down_req = talloc_zero(req, struct ldb_request);
- if (down_req == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- down_req->operation = req->operation;
- down_req->op.search.base = req->op.search.base;
- down_req->op.search.scope = req->op.search.scope;
- down_req->op.search.tree = req->op.search.tree;
-
- /* FIXME: I hink we should copy the tree and keep the original
+ /* FIXME: We must copy the tree and keep the original
* unmodified. SSS */
/* replace any attributes in the parse tree that are
searchable, but are stored using a different name in the
}
}
}
-
- /* use new set of attrs if any */
- if (search_attrs) down_req->op.search.attrs = search_attrs;
- else down_req->op.search.attrs = req->op.search.attrs;
-
- down_req->controls = req->controls;
-
- down_req->context = ac;
- down_req->callback = operational_callback;
- ldb_set_timeout_from_prev_req(module->ldb, req, down_req);
- /* perform the search */
- ret = ldb_next_request(module, down_req);
+ /* use new set of attrs if any */
+ if (search_attrs == NULL) {
+ search_attrs = req->op.search.attrs;
+ }
- /* do not free down_req as the call results may be linked to it,
- * it will be freed when the upper level request get freed */
- if (ret == LDB_SUCCESS) {
- req->handle = down_req->handle;
+ ret = ldb_build_search_req_ex(&down_req, module->ldb, ac,
+ req->op.search.base,
+ req->op.search.scope,
+ req->op.search.tree,
+ (const char * const *)search_attrs,
+ req->controls,
+ ac, operational_callback,
+ req);
+ if (ret != LDB_SUCCESS) {
+ return LDB_ERR_OPERATIONS_ERROR;
}
- return ret;
+ /* perform the search */
+ return ldb_next_request(module, down_req);
}
static int operational_init(struct ldb_module *ctx)
/*
ldb database library
- Copyright (C) Simo Sorce 2005-2006
+ Copyright (C) Simo Sorce 2005-2008
** NOTE! The following LGPL license applies to the ldb
** library. This does NOT imply that all of Samba is released
char *cookie;
time_t timestamp;
- struct results_store *prev;
struct results_store *next;
-
+
struct message_store *first;
struct message_store *last;
int num_entries;
struct message_store *last_ref;
struct ldb_control **controls;
-
- struct ldb_request *req;
};
struct private_data {
};
-int store_destructor(struct results_store *store)
+int store_destructor(struct results_store *del)
{
- if (store->prev) {
- store->prev->next = store->next;
- }
- if (store->next) {
- store->next->prev = store->prev;
+ struct private_data *priv = del->priv;
+ struct results_store *loop;
+
+ if (priv->store == del) {
+ priv->store = del->next;
+ return 0;
}
- if (store == store->priv->store) {
- store->priv->store = NULL;
+ for (loop = priv->store; loop; loop = loop->next) {
+ if (loop->next == del) {
+ loop->next = del->next;
+ return 0;
+ }
}
- return 0;
+ /* is not in list ? */
+ return -1;
}
static struct results_store *new_store(struct private_data *priv)
newr->first_ref = NULL;
newr->controls = NULL;
- /* put this entry as first */
- newr->prev = NULL;
newr->next = priv->store;
- if (priv->store != NULL) priv->store->prev = newr;
priv->store = newr;
talloc_set_destructor(newr, store_destructor);
struct paged_context {
struct ldb_module *module;
- void *up_context;
- int (*up_callback)(struct ldb_context *, void *, struct ldb_reply *);
-
- int size;
+ struct ldb_request *req;
struct results_store *store;
+ int size;
+ struct ldb_control **controls;
};
-static struct ldb_handle *init_handle(void *mem_ctx, struct ldb_module *module,
- void *context,
- int (*callback)(struct ldb_context *, void *, struct ldb_reply *))
+static int paged_results(struct paged_context *ac)
{
- struct paged_context *ac;
- struct ldb_handle *h;
+ struct ldb_paged_control *paged;
+ struct message_store *msg;
+ int i, num_ctrls, ret;
- h = talloc_zero(mem_ctx, struct ldb_handle);
- if (h == NULL) {
- ldb_set_errstring(module->ldb, "Out of Memory");
- return NULL;
+ if (ac->store == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
}
- h->module = module;
+ while (ac->store->num_entries > 0 && ac->size > 0) {
+ msg = ac->store->first;
+ ret = ldb_module_send_entry(ac->req, msg->r->message);
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
- ac = talloc_zero(h, struct paged_context);
- if (ac == NULL) {
- ldb_set_errstring(module->ldb, "Out of Memory");
- talloc_free(h);
- return NULL;
+ ac->store->first = msg->next;
+ talloc_free(msg);
+ ac->store->num_entries--;
+ ac->size--;
}
- h->private_data = (void *)ac;
+ while (ac->store->first_ref != NULL) {
+ msg = ac->store->first_ref;
+ ret = ldb_module_send_referral(ac->req, msg->r->referral);
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
- h->state = LDB_ASYNC_INIT;
- h->status = LDB_SUCCESS;
+ ac->store->first_ref = msg->next;
+ talloc_free(msg);
+ }
- ac->module = module;
- ac->up_context = context;
- ac->up_callback = callback;
+ /* return result done */
+ num_ctrls = 1;
+ i = 0;
+
+ if (ac->store->controls != NULL) {
+ while (ac->store->controls[i]) i++; /* counting */
+
+ num_ctrls += i;
+ }
+
+ ac->controls = talloc_array(ac, struct ldb_control *, num_ctrls +1);
+ if (ac->controls == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+ ac->controls[num_ctrls] = NULL;
+
+ for (i = 0; i < (num_ctrls -1); i++) {
+ ac->controls[i] = talloc_reference(ac->controls, ac->store->controls[i]);
+ }
+
+ ac->controls[i] = talloc(ac->controls, struct ldb_control);
+ if (ac->controls[i] == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
- return h;
+ ac->controls[i]->oid = talloc_strdup(ac->controls[i],
+ LDB_CONTROL_PAGED_RESULTS_OID);
+ if (ac->controls[i]->oid == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ ac->controls[i]->critical = 0;
+
+ paged = talloc(ac->controls[i], struct ldb_paged_control);
+ if (paged == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ ac->controls[i]->data = paged;
+
+ if (ac->size > 0) {
+ paged->size = 0;
+ paged->cookie = NULL;
+ paged->cookie_len = 0;
+ } else {
+ paged->size = ac->store->num_entries;
+ paged->cookie = talloc_strdup(paged, ac->store->cookie);
+ paged->cookie_len = strlen(paged->cookie) + 1;
+ }
+
+ return LDB_SUCCESS;
}
-static int paged_search_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
+static int paged_search_callback(struct ldb_request *req, struct ldb_reply *ares)
{
- struct paged_context *ac = NULL;
+ struct paged_context *ac ;
+ struct message_store *msg_store;
+ int ret;
- if (!context || !ares) {
- ldb_set_errstring(ldb, "NULL Context or Result in callback");
- goto error;
+ ac = talloc_get_type(req->context, struct paged_context);
+
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
}
- ac = talloc_get_type(context, struct paged_context);
+ switch (ares->type) {
+ case LDB_REPLY_ENTRY:
+ msg_store = talloc(ac->store, struct message_store);
+ if (msg_store == NULL) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ msg_store->next = NULL;
+ msg_store->r = talloc_steal(msg_store, ares);
- if (ares->type == LDB_REPLY_ENTRY) {
if (ac->store->first == NULL) {
- ac->store->first = ac->store->last = talloc(ac->store, struct message_store);
+ ac->store->first = msg_store;
} else {
- ac->store->last->next = talloc(ac->store, struct message_store);
- ac->store->last = ac->store->last->next;
- }
- if (ac->store->last == NULL) {
- goto error;
+ ac->store->last->next = msg_store;
}
+ ac->store->last = msg_store;
ac->store->num_entries++;
- ac->store->last->r = talloc_steal(ac->store->last, ares);
- ac->store->last->next = NULL;
- }
+ break;
+
+ case LDB_REPLY_REFERRAL:
+ msg_store = talloc(ac->store, struct message_store);
+ if (msg_store == NULL) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ msg_store->next = NULL;
+ msg_store->r = talloc_steal(msg_store, ares);
- if (ares->type == LDB_REPLY_REFERRAL) {
if (ac->store->first_ref == NULL) {
- ac->store->first_ref = ac->store->last_ref = talloc(ac->store, struct message_store);
+ ac->store->first_ref = msg_store;
} else {
- ac->store->last_ref->next = talloc(ac->store, struct message_store);
- ac->store->last_ref = ac->store->last_ref->next;
- }
- if (ac->store->last_ref == NULL) {
- goto error;
+ ac->store->last_ref->next = msg_store;
}
+ ac->store->last_ref = msg_store;
- ac->store->last_ref->r = talloc_steal(ac->store->last, ares);
- ac->store->last_ref->next = NULL;
- }
+ break;
- if (ares->type == LDB_REPLY_DONE) {
+ case LDB_REPLY_DONE:
ac->store->controls = talloc_move(ac->store, &ares->controls);
- talloc_free(ares);
+ ret = paged_results(ac);
+ return ldb_module_done(ac->req, ac->controls,
+ ares->response, ret);
}
return LDB_SUCCESS;
-
-error:
- talloc_free(ares);
- return LDB_ERR_OPERATIONS_ERROR;
}
static int paged_search(struct ldb_module *module, struct ldb_request *req)
struct private_data *private_data;
struct ldb_paged_control *paged_ctrl;
struct ldb_control **saved_controls;
+ struct ldb_request *search_req;
struct paged_context *ac;
- struct ldb_handle *h;
int ret;
/* check if there's a paged request control */
return ldb_next_request(module, req);
}
- private_data = talloc_get_type(module->private_data, struct private_data);
-
- req->handle = NULL;
-
- if (!req->callback || !req->context) {
- ldb_set_errstring(module->ldb,
- "Async interface called with NULL callback function or NULL context");
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
paged_ctrl = talloc_get_type(control->data, struct ldb_paged_control);
if (!paged_ctrl) {
return LDB_ERR_PROTOCOL_ERROR;
}
- h = init_handle(req, module, req->context, req->callback);
- if (!h) {
+ private_data = talloc_get_type(module->private_data, struct private_data);
+
+ ac = talloc_zero(req, struct paged_context);
+ if (ac == NULL) {
+ ldb_set_errstring(module->ldb, "Out of Memory");
return LDB_ERR_OPERATIONS_ERROR;
}
- ac = talloc_get_type(h->private_data, struct paged_context);
+ ac->module = module;
+ ac->req = req;
ac->size = paged_ctrl->size;
/* check if it is a continuation search the store */
if (paged_ctrl->cookie_len == 0) {
-
- ac->store = new_store(private_data);
- if (ac->store == NULL) {
- talloc_free(h);
- return LDB_ERR_UNWILLING_TO_PERFORM;
+ if (paged_ctrl->size == 0) {
+ return LDB_ERR_OPERATIONS_ERROR;
}
- ac->store->req = talloc(ac->store, struct ldb_request);
- if (!ac->store->req)
+ ac->store = new_store(private_data);
+ if (ac->store == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
+ }
- ac->store->req->operation = req->operation;
- ac->store->req->op.search.base = req->op.search.base;
- ac->store->req->op.search.scope = req->op.search.scope;
- ac->store->req->op.search.tree = req->op.search.tree;
- ac->store->req->op.search.attrs = req->op.search.attrs;
- ac->store->req->controls = req->controls;
+ ret = ldb_build_search_req_ex(&search_req, module->ldb, ac,
+ req->op.search.base,
+ req->op.search.scope,
+ req->op.search.tree,
+ req->op.search.attrs,
+ req->controls,
+ ac,
+ paged_search_callback,
+ req);
/* save it locally and remove it from the list */
/* we do not need to replace them later as we
* are keeping the original req intact */
- if (!save_controls(control, ac->store->req, &saved_controls)) {
+ if (!save_controls(control, search_req, &saved_controls)) {
return LDB_ERR_OPERATIONS_ERROR;
}
- ac->store->req->context = ac;
- ac->store->req->callback = paged_search_callback;
- ldb_set_timeout_from_prev_req(module->ldb, req, ac->store->req);
-
- ret = ldb_next_request(module, ac->store->req);
+ return ldb_next_request(module, search_req);
} else {
struct results_store *current = NULL;
+ /* TODO: age out old outstanding requests */
for (current = private_data->store; current; current = current->next) {
if (strcmp(current->cookie, paged_ctrl->cookie) == 0) {
current->timestamp = time(NULL);
}
}
if (current == NULL) {
- talloc_free(h);
return LDB_ERR_UNWILLING_TO_PERFORM;
}
ac->store = current;
- ret = LDB_SUCCESS;
- }
-
- req->handle = h;
-
- /* check if it is an abandon */
- if (ac->size == 0) {
- talloc_free(ac->store);
- h->status = LDB_SUCCESS;
- h->state = LDB_ASYNC_DONE;
- return LDB_SUCCESS;
- }
-
- /* TODO: age out old outstanding requests */
-
- return ret;
-
-}
-
-static int paged_results(struct ldb_handle *handle)
-{
- struct paged_context *ac;
- struct ldb_paged_control *paged;
- struct ldb_reply *ares;
- struct message_store *msg;
- int i, num_ctrls, ret;
-
- ac = talloc_get_type(handle->private_data, struct paged_context);
-
- if (ac->store == NULL)
- return LDB_ERR_OPERATIONS_ERROR;
- while (ac->store->num_entries > 0 && ac->size > 0) {
- msg = ac->store->first;
- ret = ac->up_callback(ac->module->ldb, ac->up_context, msg->r);
- if (ret != LDB_SUCCESS) {
- handle->status = ret;
- handle->state = LDB_ASYNC_DONE;
- return ret;
+ /* check if it is an abandon */
+ if (ac->size == 0) {
+ return ldb_module_done(req, NULL, NULL,
+ LDB_SUCCESS);
}
- ac->store->first = msg->next;
- talloc_free(msg);
- ac->store->num_entries--;
- ac->size--;
- }
-
- handle->state = LDB_ASYNC_DONE;
-
- while (ac->store->first_ref != NULL) {
- msg = ac->store->first_ref;
- ret = ac->up_callback(ac->module->ldb, ac->up_context, msg->r);
+ ret = paged_results(ac);
if (ret != LDB_SUCCESS) {
- handle->status = ret;
- handle->state = LDB_ASYNC_DONE;
- return ret;
+ return ldb_module_done(req, NULL, NULL, ret);
}
-
- ac->store->first_ref = msg->next;
- talloc_free(msg);
- }
-
- ares = talloc_zero(ac->store, struct ldb_reply);
- if (ares == NULL) {
- handle->status = LDB_ERR_OPERATIONS_ERROR;
- return handle->status;
- }
- num_ctrls = 2;
- i = 0;
-
- if (ac->store->controls != NULL) {
- ares->controls = ac->store->controls;
- while (ares->controls[i]) i++; /* counting */
-
- ares->controls = talloc_move(ares, &ac->store->controls);
- num_ctrls += i;
- }
-
- ares->controls = talloc_realloc(ares, ares->controls, struct ldb_control *, num_ctrls);
- if (ares->controls == NULL) {
- handle->status = LDB_ERR_OPERATIONS_ERROR;
- return handle->status;
+ return ldb_module_done(req, ac->controls, NULL,
+ LDB_SUCCESS);
}
-
- ares->controls[i] = talloc(ares->controls, struct ldb_control);
- if (ares->controls[i] == NULL) {
- handle->status = LDB_ERR_OPERATIONS_ERROR;
- return handle->status;
- }
-
- ares->controls[i]->oid = talloc_strdup(ares->controls[i], LDB_CONTROL_PAGED_RESULTS_OID);
- if (ares->controls[i]->oid == NULL) {
- handle->status = LDB_ERR_OPERATIONS_ERROR;
- return handle->status;
- }
-
- ares->controls[i]->critical = 0;
- ares->controls[i + 1] = NULL;
-
- paged = talloc(ares->controls[i], struct ldb_paged_control);
- if (paged == NULL) {
- handle->status = LDB_ERR_OPERATIONS_ERROR;
- return handle->status;
- }
-
- ares->controls[i]->data = paged;
-
- if (ac->size > 0) {
- paged->size = 0;
- paged->cookie = NULL;
- paged->cookie_len = 0;
- } else {
- paged->size = ac->store->num_entries;
- paged->cookie = talloc_strdup(paged, ac->store->cookie);
- paged->cookie_len = strlen(paged->cookie) + 1;
- }
-
- ares->type = LDB_REPLY_DONE;
-
- ret = ac->up_callback(ac->module->ldb, ac->up_context, ares);
-
- handle->status = ret;
-
- return ret;
-}
-
-static int paged_wait_once(struct ldb_handle *handle) {
- struct paged_context *ac;
- int ret;
-
- if (!handle || !handle->private_data) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- if (handle->state == LDB_ASYNC_DONE) {
- return handle->status;
- }
-
- handle->state = LDB_ASYNC_PENDING;
-
- ac = talloc_get_type(handle->private_data, struct paged_context);
-
- if (ac->store->req->handle->state == LDB_ASYNC_DONE) {
- /* if lower level is finished we do not need to call it anymore */
- /* return all we have until size == 0 or we empty storage */
- ret = paged_results(handle);
-
- /* we are done, if num_entries is zero free the storage
- * as that mean we delivered the last batch */
- if (ac->store->num_entries == 0) {
- talloc_free(ac->store);
- }
-
- return ret;
- }
-
- ret = ldb_wait(ac->store->req->handle, LDB_WAIT_NONE);
- if (ret != LDB_SUCCESS) {
- handle->state = LDB_ASYNC_DONE;
- handle->status = ret;
- return ret;
- }
-
- handle->status = ret;
-
- if (ac->store->num_entries >= ac->size ||
- ac->store->req->handle->state == LDB_ASYNC_DONE) {
-
- ret = paged_results(handle);
-
- /* we are done, if num_entries is zero free the storage
- * as that mean we delivered the last batch */
- if (ac->store->num_entries == 0) {
- talloc_free(ac->store);
- }
- }
-
- return ret;
-}
-
-static int paged_wait(struct ldb_handle *handle, enum ldb_wait_type type)
-{
- int ret;
-
- if (!handle || !handle->private_data) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- if (type == LDB_WAIT_ALL) {
- while (handle->state != LDB_ASYNC_DONE) {
- ret = paged_wait_once(handle);
- if (ret != LDB_SUCCESS) {
- return ret;
- }
- }
-
- return handle->status;
- }
-
- return paged_wait_once(handle);
}
static int paged_request_init(struct ldb_module *module)
{
struct private_data *data;
- struct ldb_request *req;
int ret;
data = talloc(module, struct private_data);
if (data == NULL) {
return LDB_ERR_OTHER;
}
-
+
data->next_free_id = 1;
data->store = NULL;
module->private_data = data;
- req = talloc(module, struct ldb_request);
- if (req == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- req->operation = LDB_REQ_REGISTER_CONTROL;
- req->op.reg_control.oid = LDB_CONTROL_PAGED_RESULTS_OID;
- req->controls = NULL;
-
- ret = ldb_request(module->ldb, req);
+ ret = ldb_mod_register_control(module, LDB_CONTROL_PAGED_RESULTS_OID);
if (ret != LDB_SUCCESS) {
- ldb_debug(module->ldb, LDB_DEBUG_WARNING, "paged_request: Unable to register control with rootdse!\n");
+ ldb_debug(module->ldb, LDB_DEBUG_WARNING,
+ "paged_request:"
+ "Unable to register control with rootdse!\n");
}
- talloc_free(req);
return ldb_next_init(module);
}
const struct ldb_module_ops ldb_paged_results_module_ops = {
.name = "paged_results",
.search = paged_search,
- .wait = paged_wait,
.init_context = paged_request_init
};
/*
ldb database library
- Copyright (C) Simo Sorce 2005-2006
+ Copyright (C) Simo Sorce 2005-2008
** NOTE! The following LGPL license applies to the ldb
** library. This does NOT imply that all of Samba is released
struct ps_context {
struct ldb_module *module;
- void *up_context;
- int (*up_callback)(struct ldb_context *, void *, struct ldb_reply *);
-
- struct ldb_request *orig_req;
-
- struct ldb_request *new_req;
+ struct ldb_request *req;
bool pending;
int num_referrals;
};
-static struct ldb_handle *init_handle(void *mem_ctx, struct ldb_module *module,
- void *context,
- int (*callback)(struct ldb_context *, void *, struct ldb_reply *))
+static int check_ps_continuation(struct ldb_request *req, struct ldb_reply *ares)
{
struct ps_context *ac;
- struct ldb_handle *h;
-
- h = talloc_zero(mem_ctx, struct ldb_handle);
- if (h == NULL) {
- ldb_set_errstring(module->ldb, "Out of Memory");
- return NULL;
- }
-
- h->module = module;
-
- ac = talloc_zero(h, struct ps_context);
- if (ac == NULL) {
- ldb_set_errstring(module->ldb, "Out of Memory");
- talloc_free(h);
- return NULL;
- }
-
- h->private_data = (void *)ac;
-
- h->state = LDB_ASYNC_INIT;
- h->status = LDB_SUCCESS;
-
- ac->module = module;
- ac->up_context = context;
- ac->up_callback = callback;
-
- ac->pending = false;
-
-
-
- ac->saved_referrals = NULL;
- ac->num_referrals = 0;
-
- return h;
-}
-
-static int check_ps_continuation(struct ldb_reply *ares, struct ps_context *ac)
-{
struct ldb_paged_control *rep_control, *req_control;
+ ac = talloc_get_type(req->context, struct ps_context);
+
/* look up our paged control */
if (!ares->controls || strcmp(LDB_CONTROL_PAGED_RESULTS_OID, ares->controls[0]->oid) != 0) {
/* something wrong here */
/* if there's a reply control we must find a request
* control matching it */
- if (strcmp(LDB_CONTROL_PAGED_RESULTS_OID, ac->new_req->controls[0]->oid) != 0) {
+ if (strcmp(LDB_CONTROL_PAGED_RESULTS_OID, req->controls[0]->oid) != 0) {
/* something wrong here */
return LDB_ERR_OPERATIONS_ERROR;
}
- req_control = talloc_get_type(ac->new_req->controls[0]->data, struct ldb_paged_control);
+ req_control = talloc_get_type(req->controls[0]->data, struct ldb_paged_control);
if (req_control->cookie) {
talloc_free(req_control->cookie);
return LDB_SUCCESS;
}
-static int store_referral(char *referral, struct ps_context *ac)
+static int store_referral(struct ps_context *ac, char *referral)
{
ac->saved_referrals = talloc_realloc(ac, ac->saved_referrals, char *, ac->num_referrals + 2);
if (!ac->saved_referrals) {
return LDB_SUCCESS;
}
-static int send_referrals(struct ldb_context *ldb, struct ps_context *ac)
+static int send_referrals(struct ps_context *ac)
{
struct ldb_reply *ares;
+ int ret;
int i;
for (i = 0; i < ac->num_referrals; i++) {
- ares = talloc_zero(ac, struct ldb_reply);
+ ares = talloc_zero(ac->req, struct ldb_reply);
if (!ares) {
return LDB_ERR_OPERATIONS_ERROR;
}
ares->type = LDB_REPLY_REFERRAL;
ares->referral = ac->saved_referrals[i];
- ac->up_callback(ldb, ac->up_context, ares);
+ ret = ldb_module_send_referral(ac->req, ares->referral);
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
}
return LDB_SUCCESS;
}
-static int ps_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
+static int ps_next_request(struct ps_context *ac);
+
+static int ps_callback(struct ldb_request *req, struct ldb_reply *ares)
{
- struct ps_context *ac = NULL;
- int ret = LDB_ERR_OPERATIONS_ERROR;
+ struct ps_context *ac;
+ int ret;
- if (!context || !ares) {
- ldb_set_errstring(ldb, "NULL Context or Result in callback");
- goto error;
- }
+ ac = talloc_get_type(req->context, struct ps_context);
- ac = talloc_get_type(context, struct ps_context);
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
switch (ares->type) {
case LDB_REPLY_ENTRY:
- ac->up_callback(ldb, ac->up_context, ares);
+ ret = ldb_module_send_entry(ac->req, ares->message);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL, ret);
+ }
break;
case LDB_REPLY_REFERRAL:
- ret = store_referral(ares->referral, ac);
+ ret = store_referral(ac, ares->referral);
if (ret != LDB_SUCCESS) {
- goto error;
+ return ldb_module_done(ac->req, NULL, NULL, ret);
}
break;
case LDB_REPLY_DONE:
- ret = check_ps_continuation(ares, ac);
+
+ ret = check_ps_continuation(req, ares);
if (ret != LDB_SUCCESS) {
- goto error;
+ return ldb_module_done(ac->req, NULL, NULL, ret);
}
- if (!ac->pending) {
+
+ if (ac->pending) {
+
+ ret = ps_next_request(ac);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req,
+ NULL, NULL, ret);
+ }
+
+ } else {
+
/* send referrals */
- ret = send_referrals(ldb, ac);
+ ret = send_referrals(ac);
if (ret != LDB_SUCCESS) {
- goto error;
+ return ldb_module_done(ac->req,
+ NULL, NULL, ret);
}
/* send REPLY_DONE */
- ac->up_callback(ldb, ac->up_context, ares);
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, LDB_SUCCESS);
}
break;
- default:
- goto error;
}
- return LDB_SUCCESS;
-
-error:
talloc_free(ares);
- return ret;
+ return LDB_SUCCESS;
}
static int ps_search(struct ldb_module *module, struct ldb_request *req)
{
struct private_data *private_data;
- struct ldb_paged_control *control;
struct ps_context *ac;
- struct ldb_handle *h;
private_data = talloc_get_type(module->private_data, struct private_data);
return ldb_next_request(module, req);
}
- if (!req->callback || !req->context) {
- ldb_set_errstring(module->ldb,
- "Async interface called with NULL callback function or NULL context");
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- h = init_handle(req, module, req->context, req->callback);
- if (!h) {
+ ac = talloc_zero(req, struct ps_context);
+ if (ac == NULL) {
+ ldb_oom(module->ldb);
return LDB_ERR_OPERATIONS_ERROR;
}
- ac = talloc_get_type(h->private_data, struct ps_context);
-
- ac->new_req = talloc(ac, struct ldb_request);
- if (!ac->new_req) return LDB_ERR_OPERATIONS_ERROR;
-
- ac->new_req->controls = talloc_array(ac->new_req, struct ldb_control *, 2);
- if (!ac->new_req->controls) return LDB_ERR_OPERATIONS_ERROR;
-
- ac->new_req->controls[0] = talloc(ac->new_req->controls, struct ldb_control);
- if (!ac->new_req->controls[0]) return LDB_ERR_OPERATIONS_ERROR;
-
- control = talloc(ac->new_req->controls[0], struct ldb_paged_control);
- if (!control) return LDB_ERR_OPERATIONS_ERROR;
-
- control->size = PS_DEFAULT_PAGE_SIZE;
- control->cookie = NULL;
- control->cookie_len = 0;
-
- ac->new_req->controls[0]->oid = LDB_CONTROL_PAGED_RESULTS_OID;
- ac->new_req->controls[0]->critical = 1;
- ac->new_req->controls[0]->data = control;
-
- ac->new_req->controls[1] = NULL;
- ac->new_req->operation = req->operation;
- ac->new_req->op.search.base = req->op.search.base;
- ac->new_req->op.search.scope = req->op.search.scope;
- ac->new_req->op.search.tree = req->op.search.tree;
- ac->new_req->op.search.attrs = req->op.search.attrs;
- ac->new_req->context = ac;
- ac->new_req->callback = ps_callback;
- ldb_set_timeout_from_prev_req(module->ldb, req, ac->new_req);
-
- req->handle = h;
+ ac->module = module;
+ ac->req = req;
+ ac->pending = false;
+ ac->saved_referrals = NULL;
+ ac->num_referrals = 0;
- return ldb_next_request(module, ac->new_req);
+ return ps_next_request(ac);
}
-static int ps_continuation(struct ldb_handle *handle)
-{
- struct ps_context *ac;
+static int ps_next_request(struct ps_context *ac) {
- if (!handle || !handle->private_data) {
+ struct ldb_paged_control *control;
+ struct ldb_control **controls;
+ struct ldb_request *new_req;
+ int ret;
+
+ controls = talloc_array(ac, struct ldb_control *, 2);
+ if (!controls) {
return LDB_ERR_OPERATIONS_ERROR;
}
- ac = talloc_get_type(handle->private_data, struct ps_context);
-
- /* reset the requests handle */
- ac->new_req->handle = NULL;
-
- return ldb_next_request(handle->module, ac->new_req);
-}
-
-static int ps_wait_once(struct ldb_handle *handle)
-{
- struct ps_context *ac;
- int ret;
-
- if (!handle || !handle->private_data) {
+ controls[0] = talloc(controls, struct ldb_control);
+ if (!controls[0]) {
return LDB_ERR_OPERATIONS_ERROR;
}
- if (handle->state == LDB_ASYNC_DONE) {
- return handle->status;
+ control = talloc(controls[0], struct ldb_paged_control);
+ if (!control) {
+ return LDB_ERR_OPERATIONS_ERROR;
}
- handle->state = LDB_ASYNC_PENDING;
- handle->status = LDB_SUCCESS;
-
- ac = talloc_get_type(handle->private_data, struct ps_context);
-
- ret = ldb_wait(ac->new_req->handle, LDB_WAIT_NONE);
+ control->size = PS_DEFAULT_PAGE_SIZE;
+ control->cookie = NULL;
+ control->cookie_len = 0;
+ controls[0]->oid = LDB_CONTROL_PAGED_RESULTS_OID;
+ controls[0]->critical = 1;
+ controls[0]->data = control;
+ controls[1] = NULL;
+
+ ret = ldb_build_search_req_ex(&new_req, ac->module->ldb, ac,
+ ac->req->op.search.base,
+ ac->req->op.search.scope,
+ ac->req->op.search.tree,
+ ac->req->op.search.attrs,
+ controls,
+ ac,
+ ps_callback,
+ ac->req);
if (ret != LDB_SUCCESS) {
- handle->status = ret;
- goto done;
- }
-
- if (ac->new_req->handle->status != LDB_SUCCESS) {
- handle->status = ac->new_req->handle->status;
- goto done;
- }
-
- if (ac->new_req->handle->state != LDB_ASYNC_DONE) {
- return LDB_SUCCESS;
- }
-
- /* see if we need to send another request for the next batch */
- if (ac->pending) {
- ret = ps_continuation(handle);
- if (ret != LDB_SUCCESS) {
- handle->status = ret;
- goto done;
- }
-
- /* continue the search with the next request */
- return LDB_SUCCESS;
+ return ret;
}
+ talloc_steal(new_req, controls);
- ret = LDB_SUCCESS;
-
-done:
- handle->state = LDB_ASYNC_DONE;
- return ret;
+ return ldb_next_request(ac->module, new_req);
}
-static int ps_wait(struct ldb_handle *handle, enum ldb_wait_type type)
+static int check_supported_paged(struct ldb_request *req,
+ struct ldb_reply *ares)
{
- int ret;
-
- if (!handle || !handle->private_data) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
+ struct private_data *data;
- if (type == LDB_WAIT_ALL) {
- while (handle->state != LDB_ASYNC_DONE) {
- ret = ps_wait_once(handle);
- if (ret != LDB_SUCCESS) {
- return ret;
- }
- }
+ data = talloc_get_type(req->context, struct private_data);
- return handle->status;
+ if (!ares) {
+ return ldb_request_done(req, LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_request_done(req, LDB_ERR_OPERATIONS_ERROR);
}
- return ps_wait_once(handle);
-}
-static int check_supported_paged(struct ldb_context *ldb, void *context,
- struct ldb_reply *ares)
-{
- struct private_data *data;
- data = talloc_get_type(context,
- struct private_data);
- if (ares->type == LDB_REPLY_ENTRY) {
+ switch (ares->type) {
+ case LDB_REPLY_ENTRY:
if (ldb_msg_check_string_attribute(ares->message,
"supportedControl",
LDB_CONTROL_PAGED_RESULTS_OID)) {
data->paged_supported = true;
}
+ break;
+
+ case LDB_REPLY_REFERRAL:
+ /* ignore */
+ break;
+
+ case LDB_REPLY_DONE:
+ return ldb_request_done(req, LDB_SUCCESS);
}
+
+ talloc_free(ares);
return LDB_SUCCESS;
}
-
static int ps_init(struct ldb_module *module)
{
static const char *attrs[] = { "supportedControl", NULL };
struct private_data *data;
+ struct ldb_dn *base;
int ret;
struct ldb_request *req;
data = talloc(module, struct private_data);
if (data == NULL) {
- ldb_set_errstring(module->ldb, "Out of Memory");
- return LDB_ERR_OTHER;
+ ldb_oom(module->ldb);
+ return LDB_ERR_OPERATIONS_ERROR;
}
module->private_data = data;
data->paged_supported = false;
- req = talloc(module, struct ldb_request);
- if (req == NULL) {
- ldb_set_errstring(module->ldb, "Out of Memory");
+ base = ldb_dn_new(module, module->ldb, "");
+ if (base == NULL) {
+ ldb_oom(module->ldb);
return LDB_ERR_OPERATIONS_ERROR;
}
-
- req->operation = LDB_SEARCH;
- req->op.search.base = ldb_dn_new(req, module->ldb, "");
- req->op.search.scope = LDB_SCOPE_BASE;
-
- req->op.search.tree = ldb_parse_tree(req, "objectClass=*");
- if (req->op.search.tree == NULL) {
- ldb_set_errstring(module->ldb, "Unable to parse search expression");
- talloc_free(req);
- return LDB_ERR_OPERATIONS_ERROR;
+ ret = ldb_build_search_req(&req, module->ldb, module,
+ base, LDB_SCOPE_BASE,
+ "(objectClass=*)",
+ attrs, NULL,
+ data, check_supported_paged,
+ NULL);
+ if (ret != LDB_SUCCESS) {
+ return ret;
}
- req->op.search.attrs = attrs;
- req->controls = NULL;
- req->context = data;
- req->callback = check_supported_paged;
- ldb_set_timeout(module->ldb, req, 0); /* use default timeout */
-
ret = ldb_next_request(module, req);
-
if (ret == LDB_SUCCESS) {
ret = ldb_wait(req->handle, LDB_WAIT_ALL);
}
-
- talloc_free(req);
if (ret != LDB_SUCCESS) {
return ret;
}
+ talloc_free(base);
+ talloc_free(req);
+
return ldb_next_init(module);
}
_PUBLIC_ const struct ldb_module_ops ldb_paged_searches_module_ops = {
.name = "paged_searches",
.search = ps_search,
- .wait = ps_wait,
.init_context = ps_init
};
ldb database library
Copyright (C) Andrew Bartlet 2005
- Copyright (C) Simo Sorce 2006
+ Copyright (C) Simo Sorce 2006-2008
** NOTE! The following LGPL license applies to the ldb
** library. This does NOT imply that all of Samba is released
#include "ldb_includes.h"
+struct rename_context {
+
+ struct ldb_module *module;
+ struct ldb_request *req;
+
+ struct ldb_reply *ares;
+};
+
static struct ldb_message_element *rdn_name_find_attribute(const struct ldb_message *msg, const char *name)
{
int i;
return NULL;
}
+static int rdn_name_add_callback(struct ldb_request *req,
+ struct ldb_reply *ares)
+{
+ struct rename_context *ac;
+
+ ac = talloc_get_type(req->context, struct rename_context);
+
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
+
+ if (ares->type != LDB_REPLY_DONE) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, LDB_SUCCESS);
+}
+
static int rdn_name_add(struct ldb_module *module, struct ldb_request *req)
{
struct ldb_request *down_req;
+ struct rename_context *ac;
struct ldb_message *msg;
struct ldb_message_element *attribute;
+ const struct ldb_schema_attribute *a;
const char *rdn_name;
struct ldb_val rdn_val;
int i, ret;
return ldb_next_request(module, req);
}
- down_req = talloc(req, struct ldb_request);
- if (down_req == NULL) {
+ ac = talloc_zero(req, struct rename_context);
+ if (ac == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
- *down_req = *req;
+ ac->module = module;
+ ac->req = req;
- down_req->op.add.message = msg = ldb_msg_copy_shallow(down_req, req->op.add.message);
+ msg = ldb_msg_copy_shallow(req, req->op.add.message);
if (msg == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
rdn_name = ldb_dn_get_rdn_name(msg->dn);
if (rdn_name == NULL) {
- talloc_free(down_req);
+ talloc_free(ac);
return LDB_ERR_OPERATIONS_ERROR;
}
}
if (ldb_msg_add_value(msg, "name", &rdn_val, NULL) != 0) {
- talloc_free(down_req);
+ talloc_free(ac);
return LDB_ERR_OPERATIONS_ERROR;
}
if (!attribute) {
if (ldb_msg_add_value(msg, rdn_name, &rdn_val, NULL) != 0) {
- talloc_free(down_req);
+ talloc_free(ac);
return LDB_ERR_OPERATIONS_ERROR;
}
} else {
- const struct ldb_schema_attribute *a = ldb_schema_attribute_by_name(module->ldb, rdn_name);
+ a = ldb_schema_attribute_by_name(module->ldb, rdn_name);
for (i = 0; i < attribute->num_values; i++) {
- if (a->syntax->comparison_fn(module->ldb, msg, &rdn_val, &attribute->values[i]) == 0) {
+ ret = a->syntax->comparison_fn(module->ldb, msg,
+ &rdn_val, &attribute->values[i]);
+ if (ret == 0) {
/* overwrite so it matches in case */
attribute->values[i] = rdn_val;
break;
ldb_debug_set(module->ldb, LDB_DEBUG_FATAL,
"RDN mismatch on %s: %s (%s)",
ldb_dn_get_linearized(msg->dn), rdn_name, rdn_val.data);
- talloc_free(down_req);
+ talloc_free(ac);
/* Match AD's error here */
return LDB_ERR_INVALID_DN_SYNTAX;
}
}
- /* go on with the call chain */
- ret = ldb_next_request(module, down_req);
-
- /* do not free down_req as the call results may be linked to it,
- * it will be freed when the upper level request get freed */
- if (ret == LDB_SUCCESS) {
- req->handle = down_req->handle;
+ ret = ldb_build_add_req(&down_req, module->ldb, req,
+ msg,
+ req->controls,
+ ac, rdn_name_add_callback,
+ req);
+ if (ret != LDB_SUCCESS) {
+ return ret;
}
- return ret;
-}
-
-struct rename_context {
+ talloc_steal(down_req, msg);
- enum {RENAME_RENAME, RENAME_MODIFY} step;
- struct ldb_request *orig_req;
- struct ldb_request *down_req;
- struct ldb_request *mod_req;
-};
+ /* go on with the call chain */
+ return ldb_next_request(module, down_req);
+}
-static int rdn_name_rename(struct ldb_module *module, struct ldb_request *req)
+static int rdn_modify_callback(struct ldb_request *req, struct ldb_reply *ares)
{
- struct ldb_handle *h;
struct rename_context *ac;
- ldb_debug(module->ldb, LDB_DEBUG_TRACE, "rdn_name_rename\n");
+ ac = talloc_get_type(req->context, struct rename_context);
- /* do not manipulate our control entries */
- if (ldb_dn_is_special(req->op.rename.newdn)) {
- return ldb_next_request(module, req);
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
-
- h = talloc_zero(req, struct ldb_handle);
- if (h == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
}
- h->module = module;
-
- ac = talloc_zero(h, struct rename_context);
- if (ac == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ /* the only supported reply right now is a LDB_REPLY_DONE */
+ if (ares->type != LDB_REPLY_DONE) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
- h->private_data = (void *)ac;
-
- h->state = LDB_ASYNC_INIT;
- h->status = LDB_SUCCESS;
-
- ac->orig_req = req;
- ac->down_req = talloc(req, struct ldb_request);
- if (ac->down_req == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- *(ac->down_req) = *req;
-
- ac->step = RENAME_RENAME;
-
- req->handle = h;
-
- /* rename first, modify "name" if rename is ok */
- return ldb_next_request(module, ac->down_req);
+ /* send saved controls eventually */
+ return ldb_module_done(ac->req, ac->ares->controls,
+ ac->ares->response, LDB_SUCCESS);
}
-static int rdn_name_rename_do_mod(struct ldb_handle *h) {
-
+static int rdn_rename_callback(struct ldb_request *req, struct ldb_reply *ares)
+{
struct rename_context *ac;
+ struct ldb_request *mod_req;
const char *rdn_name;
struct ldb_val rdn_val;
struct ldb_message *msg;
+ int ret;
- ac = talloc_get_type(h->private_data, struct rename_context);
+ ac = talloc_get_type(req->context, struct rename_context);
- ac->mod_req = talloc_zero(ac, struct ldb_request);
+ if (!ares) {
+ goto error;
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
- ac->mod_req->operation = LDB_MODIFY;
- ac->mod_req->op.mod.message = msg = ldb_msg_new(ac->mod_req);
- if (msg == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ /* the only supported reply right now is a LDB_REPLY_DONE */
+ if (ares->type != LDB_REPLY_DONE) {
+ goto error;
}
- msg->dn = ldb_dn_copy(msg, ac->orig_req->op.rename.newdn);
+ /* save reply for caller */
+ ac->ares = talloc_steal(ac, ares);
+
+ msg = ldb_msg_new(ac);
+ if (msg == NULL) {
+ goto error;
+ }
+ msg->dn = ldb_dn_copy(msg, ac->req->op.rename.newdn);
if (msg->dn == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ goto error;
}
-
- rdn_name = ldb_dn_get_rdn_name(ac->orig_req->op.rename.newdn);
+ rdn_name = ldb_dn_get_rdn_name(ac->req->op.rename.newdn);
if (rdn_name == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ goto error;
}
- rdn_val = ldb_val_dup(msg, ldb_dn_get_rdn_val(ac->orig_req->op.rename.newdn));
+ rdn_val = ldb_val_dup(msg, ldb_dn_get_rdn_val(ac->req->op.rename.newdn));
if (ldb_msg_add_empty(msg, rdn_name, LDB_FLAG_MOD_REPLACE, NULL) != 0) {
- return LDB_ERR_OPERATIONS_ERROR;
+ goto error;
}
if (ldb_msg_add_value(msg, rdn_name, &rdn_val, NULL) != 0) {
- return LDB_ERR_OPERATIONS_ERROR;
+ goto error;
}
if (ldb_msg_add_empty(msg, "name", LDB_FLAG_MOD_REPLACE, NULL) != 0) {
- return LDB_ERR_OPERATIONS_ERROR;
+ goto error;
}
if (ldb_msg_add_value(msg, "name", &rdn_val, NULL) != 0) {
- return LDB_ERR_OPERATIONS_ERROR;
+ goto error;
}
- ldb_set_timeout_from_prev_req(h->module->ldb, ac->orig_req, ac->mod_req);
-
- ac->step = RENAME_MODIFY;
+ ret = ldb_build_mod_req(&mod_req, ac->module->ldb,
+ ac, msg, NULL,
+ ac, rdn_modify_callback,
+ req);
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, NULL, NULL, ret);
+ }
+ talloc_steal(mod_req, msg);
/* do the mod call */
- return ldb_request(h->module->ldb, ac->mod_req);
+ return ldb_request(ac->module->ldb, mod_req);
+
+error:
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
-static int rdn_name_wait_once(struct ldb_handle *handle)
+static int rdn_name_rename(struct ldb_module *module, struct ldb_request *req)
{
struct rename_context *ac;
+ struct ldb_request *down_req;
int ret;
-
- if (!handle || !handle->private_data) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- if (handle->state == LDB_ASYNC_DONE) {
- return handle->status;
- }
- handle->state = LDB_ASYNC_PENDING;
- handle->status = LDB_SUCCESS;
-
- ac = talloc_get_type(handle->private_data, struct rename_context);
-
- switch(ac->step) {
- case RENAME_RENAME:
- ret = ldb_wait(ac->down_req->handle, LDB_WAIT_NONE);
- if (ret != LDB_SUCCESS) {
- handle->status = ret;
- goto done;
- }
- if (ac->down_req->handle->status != LDB_SUCCESS) {
- handle->status = ac->down_req->handle->status;
- goto done;
- }
-
- if (ac->down_req->handle->state != LDB_ASYNC_DONE) {
- return LDB_SUCCESS;
- }
-
- /* rename operation done */
- return rdn_name_rename_do_mod(handle);
-
- case RENAME_MODIFY:
- ret = ldb_wait(ac->mod_req->handle, LDB_WAIT_NONE);
- if (ret != LDB_SUCCESS) {
- handle->status = ret;
- goto done;
- }
- if (ac->mod_req->handle->status != LDB_SUCCESS) {
- handle->status = ac->mod_req->handle->status;
- goto done;
- }
-
- if (ac->mod_req->handle->state != LDB_ASYNC_DONE) {
- return LDB_SUCCESS;
- }
-
- break;
+ ldb_debug(module->ldb, LDB_DEBUG_TRACE, "rdn_name_rename\n");
- default:
- ret = LDB_ERR_OPERATIONS_ERROR;
- goto done;
+ /* do not manipulate our control entries */
+ if (ldb_dn_is_special(req->op.rename.newdn)) {
+ return ldb_next_request(module, req);
}
- ret = LDB_SUCCESS;
-
-done:
- handle->state = LDB_ASYNC_DONE;
- return ret;
-}
-
-static int rdn_name_wait(struct ldb_handle *handle, enum ldb_wait_type type)
-{
- int ret;
-
- if (!handle || !handle->private_data) {
+ ac = talloc_zero(req, struct rename_context);
+ if (ac == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
- if (type == LDB_WAIT_ALL) {
- while (handle->state != LDB_ASYNC_DONE) {
- ret = rdn_name_wait_once(handle);
- if (ret != LDB_SUCCESS) {
- return ret;
- }
- }
+ ac->module = module;
+ ac->req = req;
- return handle->status;
+ ret = ldb_build_rename_req(&down_req,
+ module->ldb,
+ ac,
+ req->op.rename.olddn,
+ req->op.rename.newdn,
+ req->controls,
+ ac,
+ rdn_rename_callback,
+ req);
+
+ if (ret != LDB_SUCCESS) {
+ return LDB_ERR_OPERATIONS_ERROR;
}
- return rdn_name_wait_once(handle);
+ /* rename first, modify "name" if rename is ok */
+ return ldb_next_request(module, down_req);
}
const struct ldb_module_ops ldb_rdn_name_module_ops = {
.name = "rdn_name",
.add = rdn_name_add,
.rename = rdn_name_rename,
- .wait = rdn_name_wait
};
/*
ldb database library
- Copyright (C) Simo Sorce 2005
+ Copyright (C) Simo Sorce 2005-2008
** NOTE! The following LGPL license applies to the ldb
** library. This does NOT imply that all of Samba is released
struct sort_context {
struct ldb_module *module;
- void *up_context;
- int (*up_callback)(struct ldb_context *, void *, struct ldb_reply *);
char *attributeName;
char *orderingRule;
struct ldb_request *req;
struct ldb_message **msgs;
char **referrals;
- struct ldb_control **controls;
int num_msgs;
int num_refs;
int sort_result;
};
-static struct ldb_handle *init_handle(void *mem_ctx, struct ldb_module *module,
- void *context,
- int (*callback)(struct ldb_context *, void *, struct ldb_reply *))
-{
- struct sort_context *ac;
- struct ldb_handle *h;
-
- h = talloc_zero(mem_ctx, struct ldb_handle);
- if (h == NULL) {
- ldb_set_errstring(module->ldb, "Out of Memory");
- return NULL;
- }
-
- h->module = module;
-
- ac = talloc_zero(h, struct sort_context);
- if (ac == NULL) {
- ldb_set_errstring(module->ldb, "Out of Memory");
- talloc_free(h);
- return NULL;
- }
-
- h->private_data = (void *)ac;
-
- h->state = LDB_ASYNC_INIT;
- h->status = LDB_SUCCESS;
-
- ac->module = module;
- ac->up_context = context;
- ac->up_callback = callback;
-
- return h;
-}
-
static int build_response(void *mem_ctx, struct ldb_control ***ctrls, int result, const char *desc)
{
struct ldb_control **controls;
struct sort_context *ac = talloc_get_type(opaque, struct sort_context);
struct ldb_message_element *el1, *el2;
- if (ac->sort_result != 0) {
+ if (!ac || ac->sort_result != 0) {
/* an error occurred previously,
* let's exit the sorting by returning always 0 */
return 0;
if (!el1 || !el2) {
/* the attribute was not found return and
* set an error */
- ac->sort_result = 53;
+ ac->sort_result = LDB_ERR_UNWILLING_TO_PERFORM;
return 0;
}
return ac->a->syntax->comparison_fn(ac->module->ldb, ac, &el1->values[0], &el2->values[0]);
}
-static int server_sort_search_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
+static int server_sort_results(struct sort_context *ac)
{
- struct sort_context *ac = NULL;
-
- if (!context || !ares) {
- ldb_set_errstring(ldb, "NULL Context or Result in callback");
- goto error;
- }
+ struct ldb_reply *ares;
+ int i, ret;
+
+ ac->a = ldb_schema_attribute_by_name(ac->module->ldb, ac->attributeName);
+ ac->sort_result = 0;
+
+ ldb_qsort(ac->msgs, ac->num_msgs,
+ sizeof(struct ldb_message *),
+ ac, (ldb_qsort_cmp_fn_t)sort_compare);
+
+ if (ac->sort_result != LDB_SUCCESS) {
+ return ac->sort_result;
+ }
+
+ for (i = 0; i < ac->num_msgs; i++) {
+ ares = talloc_zero(ac, struct ldb_reply);
+ if (!ares) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ ares->type = LDB_REPLY_ENTRY;
+ ares->message = talloc_move(ares, &ac->msgs[i]);
+
+ ret = ldb_module_send_entry(ac->req, ares->message);
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
+ }
+
+ for (i = 0; i < ac->num_refs; i++) {
+ ares = talloc_zero(ac, struct ldb_reply);
+ if (!ares) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ ares->type = LDB_REPLY_REFERRAL;
+ ares->referral = talloc_move(ares, &ac->referrals[i]);
+
+ ret = ldb_module_send_referral(ac->req, ares->referral);
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
+ }
+
+ return LDB_SUCCESS;
+}
+
+static int server_sort_search_callback(struct ldb_request *req, struct ldb_reply *ares)
+{
+ struct sort_context *ac;
+ int ret;
- ac = talloc_get_type(context, struct sort_context);
+ ac = talloc_get_type(req->context, struct sort_context);
- if (ares->type == LDB_REPLY_ENTRY) {
+ if (!ares) {
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ares->error);
+ }
+
+ switch (ares->type) {
+ case LDB_REPLY_ENTRY:
ac->msgs = talloc_realloc(ac, ac->msgs, struct ldb_message *, ac->num_msgs + 2);
if (! ac->msgs) {
- goto error;
+ talloc_free(ares);
+ ldb_oom(ac->module->ldb);
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
- ac->msgs[ac->num_msgs + 1] = NULL;
-
- ac->msgs[ac->num_msgs] = talloc_move(ac->msgs, &ares->message);
+ ac->msgs[ac->num_msgs] = talloc_steal(ac->msgs, ares->message);
ac->num_msgs++;
- }
+ ac->msgs[ac->num_msgs] = NULL;
- if (ares->type == LDB_REPLY_REFERRAL) {
+ break;
+
+ case LDB_REPLY_REFERRAL:
ac->referrals = talloc_realloc(ac, ac->referrals, char *, ac->num_refs + 2);
if (! ac->referrals) {
- goto error;
+ talloc_free(ares);
+ ldb_oom(ac->module->ldb);
+ return ldb_module_done(ac->req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
- ac->referrals[ac->num_refs + 1] = NULL;
- ac->referrals[ac->num_refs] = talloc_move(ac->referrals, &ares->referral);
-
+ ac->referrals[ac->num_refs] = talloc_steal(ac->referrals, ares->referral);
ac->num_refs++;
- }
+ ac->referrals[ac->num_refs] = NULL;
- if (ares->type == LDB_REPLY_DONE) {
- ac->controls = talloc_move(ac, &ares->controls);
+ break;
+
+ case LDB_REPLY_DONE:
+
+ ret = server_sort_results(ac);
+ return ldb_module_done(ac->req, ares->controls,
+ ares->response, ret);
}
talloc_free(ares);
return LDB_SUCCESS;
-
-error:
- talloc_free(ares);
- return LDB_ERR_OPERATIONS_ERROR;
}
static int server_sort_search(struct ldb_module *module, struct ldb_request *req)
struct ldb_control *control;
struct ldb_server_sort_control **sort_ctrls;
struct ldb_control **saved_controls;
+ struct ldb_control **controls;
+ struct ldb_request *down_req;
struct sort_context *ac;
- struct ldb_handle *h;
int ret;
/* check if there's a paged request control */
return ldb_next_request(module, req);
}
- req->handle = NULL;
-
- if (!req->callback || !req->context) {
- ldb_set_errstring(module->ldb,
- "Async interface called with NULL callback function or NULL context");
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- h = init_handle(req, module, req->context, req->callback);
- if (!h) {
+ ac = talloc_zero(req, struct sort_context);
+ if (ac == NULL) {
+ ldb_oom(module->ldb);
return LDB_ERR_OPERATIONS_ERROR;
}
- ac = talloc_get_type(h->private_data, struct sort_context);
+
+ ac->module = module;
+ ac->req = req;
sort_ctrls = talloc_get_type(control->data, struct ldb_server_sort_control *);
if (!sort_ctrls) {
if (sort_ctrls[1] != NULL) {
if (control->critical) {
- struct ldb_reply *ares;
-
- ares = talloc_zero(req, struct ldb_reply);
- if (!ares)
- return LDB_ERR_OPERATIONS_ERROR;
- /* 53 = unwilling to perform */
- ares->type = LDB_REPLY_DONE;
- if ((ret = build_response(ares, &ares->controls, 53, "sort control is not complete yet")) != LDB_SUCCESS) {
- return ret;
+ /* callback immediately */
+ ret = build_response(req, &controls,
+ LDB_ERR_UNWILLING_TO_PERFORM,
+ "sort control is not complete yet");
+ if (ret != LDB_SUCCESS) {
+ return ldb_module_done(req, NULL, NULL,
+ LDB_ERR_OPERATIONS_ERROR);
}
- h->status = LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION;
- h->state = LDB_ASYNC_DONE;
- ret = ac->up_callback(module->ldb, ac->up_context, ares);
-
- return ret;
+ return ldb_module_done(req, controls, NULL, ret);
} else {
/* just pass the call down and don't do any sorting */
- ldb_next_request(module, req);
+ return ldb_next_request(module, req);
}
}
ac->orderingRule = sort_ctrls[0]->orderingRule;
ac->reverse = sort_ctrls[0]->reverse;
- ac->req = talloc(req, struct ldb_request);
- if (!ac->req)
+ ret = ldb_build_search_req_ex(&down_req, module->ldb, ac,
+ req->op.search.base,
+ req->op.search.scope,
+ req->op.search.tree,
+ req->op.search.attrs,
+ req->controls,
+ ac,
+ server_sort_search_callback,
+ req);
+ if (ret != LDB_SUCCESS) {
return LDB_ERR_OPERATIONS_ERROR;
-
- ac->req->operation = req->operation;
- ac->req->op.search.base = req->op.search.base;
- ac->req->op.search.scope = req->op.search.scope;
- ac->req->op.search.tree = req->op.search.tree;
- ac->req->op.search.attrs = req->op.search.attrs;
- ac->req->controls = req->controls;
+ }
/* save it locally and remove it from the list */
/* we do not need to replace them later as we
* are keeping the original req intact */
- if (!save_controls(control, ac->req, &saved_controls)) {
+ if (!save_controls(control, down_req, &saved_controls)) {
return LDB_ERR_OPERATIONS_ERROR;
}
- ac->req->context = ac;
- ac->req->callback = server_sort_search_callback;
- ldb_set_timeout_from_prev_req(module->ldb, req, ac->req);
-
- req->handle = h;
-
- return ldb_next_request(module, ac->req);
-}
-
-static int server_sort_results(struct ldb_handle *handle)
-{
- struct sort_context *ac;
- struct ldb_reply *ares;
- int i, ret;
-
- ac = talloc_get_type(handle->private_data, struct sort_context);
-
- ac->a = ldb_schema_attribute_by_name(ac->module->ldb, ac->attributeName);
- ac->sort_result = 0;
-
- ldb_qsort(ac->msgs, ac->num_msgs,
- sizeof(struct ldb_message *),
- ac, (ldb_qsort_cmp_fn_t)sort_compare);
-
- for (i = 0; i < ac->num_msgs; i++) {
- ares = talloc_zero(ac, struct ldb_reply);
- if (!ares) {
- handle->status = LDB_ERR_OPERATIONS_ERROR;
- return handle->status;
- }
-
- ares->type = LDB_REPLY_ENTRY;
- ares->message = talloc_move(ares, &ac->msgs[i]);
-
- handle->status = ac->up_callback(ac->module->ldb, ac->up_context, ares);
- if (handle->status != LDB_SUCCESS) {
- return handle->status;
- }
- }
-
- for (i = 0; i < ac->num_refs; i++) {
- ares = talloc_zero(ac, struct ldb_reply);
- if (!ares) {
- handle->status = LDB_ERR_OPERATIONS_ERROR;
- return handle->status;
- }
-
- ares->type = LDB_REPLY_REFERRAL;
- ares->referral = talloc_move(ares, &ac->referrals[i]);
-
- handle->status = ac->up_callback(ac->module->ldb, ac->up_context, ares);
- if (handle->status != LDB_SUCCESS) {
- return handle->status;
- }
- }
-
- ares = talloc_zero(ac, struct ldb_reply);
- if (!ares) {
- handle->status = LDB_ERR_OPERATIONS_ERROR;
- return handle->status;
- }
-
- ares->type = LDB_REPLY_DONE;
- ares->controls = talloc_move(ares, &ac->controls);
-
- handle->status = ac->up_callback(ac->module->ldb, ac->up_context, ares);
- if (handle->status != LDB_SUCCESS) {
- return handle->status;
- }
-
- if ((ret = build_response(ac, &ac->controls, ac->sort_result, "sort control is not complete yet")) != LDB_SUCCESS) {
- return ret;
- }
-
- return LDB_SUCCESS;
-}
-
-static int server_sort_wait_once(struct ldb_handle *handle)
-{
- struct sort_context *ac;
- int ret;
-
- if (!handle || !handle->private_data) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- ac = talloc_get_type(handle->private_data, struct sort_context);
-
- ret = ldb_wait(ac->req->handle, LDB_WAIT_NONE);
-
- if (ret != LDB_SUCCESS) {
- handle->status = ret;
- return ret;
- }
-
- handle->state = ac->req->handle->state;
- handle->status = ac->req->handle->status;
-
- if (handle->status != LDB_SUCCESS) {
- return handle->status;
- }
-
- if (handle->state == LDB_ASYNC_DONE) {
- ret = server_sort_results(handle);
- }
-
- return ret;
-}
-
-static int server_sort_wait(struct ldb_handle *handle, enum ldb_wait_type type)
-{
- int ret;
-
- if (!handle || !handle->private_data) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- if (type == LDB_WAIT_ALL) {
- while (handle->state != LDB_ASYNC_DONE) {
- ret = server_sort_wait_once(handle);
- if (ret != LDB_SUCCESS) {
- return ret;
- }
- }
-
- return handle->status;
- }
-
- return server_sort_wait_once(handle);
+ return ldb_next_request(module, down_req);
}
static int server_sort_init(struct ldb_module *module)
{
- struct ldb_request *req;
int ret;
- req = talloc(module, struct ldb_request);
- if (req == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- req->operation = LDB_REQ_REGISTER_CONTROL;
- req->op.reg_control.oid = LDB_CONTROL_SERVER_SORT_OID;
- req->controls = NULL;
-
- ret = ldb_request(module->ldb, req);
+ ret = ldb_mod_register_control(module, LDB_CONTROL_SERVER_SORT_OID);
if (ret != LDB_SUCCESS) {
- ldb_debug(module->ldb, LDB_DEBUG_WARNING, "server_sort: Unable to register control with rootdse!\n");
+ ldb_debug(module->ldb, LDB_DEBUG_WARNING,
+ "server_sort:"
+ "Unable to register control with rootdse!\n");
}
- talloc_free(req);
return ldb_next_init(module);
}
const struct ldb_module_ops ldb_server_sort_module_ops = {
.name = "server_sort",
.search = server_sort_search,
- .wait = server_sort_wait,
.init_context = server_sort_init
};
}
ret = ldb_search(_ldb_nss_ctx->ldb,
+ _ldb_nss_ctx->ldb,
+ &_ldb_nss_ctx->gr_res,
_ldb_nss_ctx->base,
LDB_SCOPE_SUBTREE,
- _LDB_NSS_GRENT_FILTER,
_ldb_nss_gr_attrs,
- &_ldb_nss_ctx->gr_res);
+ _LDB_NSS_GRENT_FILTER);
if (ret != LDB_SUCCESS) {
return NSS_STATUS_UNAVAIL;
}
/* search the entry */
ret = ldb_search(_ldb_nss_ctx->ldb,
+ _ldb_nss_ctx->ldb,
+ &gr_res,
_ldb_nss_ctx->base,
LDB_SCOPE_SUBTREE,
- filter,
_ldb_nss_gr_attrs,
- &gr_res);
+ filter);
if (ret != LDB_SUCCESS) {
/* this is a fatal error */
*errnop = errno = ENOENT;
/* search the entry */
ret = ldb_search(_ldb_nss_ctx->ldb,
+ _ldb_nss_ctx->ldb,
+ &gr_res,
_ldb_nss_ctx->base,
LDB_SCOPE_SUBTREE,
- filter,
_ldb_nss_gr_attrs,
- &gr_res);
+ filter);
if (ret != LDB_SUCCESS) {
/* this is a fatal error */
*errnop = errno = ENOENT;
/* search the entry */
ret = ldb_search(_ldb_nss_ctx->ldb,
+ _ldb_nss_ctx->ldb,
+ &uid_res,
_ldb_nss_ctx->base,
LDB_SCOPE_SUBTREE,
- filter,
attrs,
- &uid_res);
+ filter);
if (ret != LDB_SUCCESS) {
/* this is a fatal error */
*errnop = errno = ENOENT;
}
ret = ldb_search(_ldb_nss_ctx->ldb,
+ _ldb_nss_ctx->ldb,
+ &_ldb_nss_ctx->pw_res,
_ldb_nss_ctx->base,
LDB_SCOPE_SUBTREE,
- _LDB_NSS_PWENT_FILTER,
_ldb_nss_pw_attrs,
- &_ldb_nss_ctx->pw_res);
+ _LDB_NSS_PWENT_FILTER);
if (ret != LDB_SUCCESS) {
return NSS_STATUS_UNAVAIL;
}
/* search the entry */
ret = ldb_search(_ldb_nss_ctx->ldb,
+ _ldb_nss_ctx->ldb,
+ &res,
_ldb_nss_ctx->base,
LDB_SCOPE_SUBTREE,
- filter,
_ldb_nss_pw_attrs,
- &res);
+ filter);
if (ret != LDB_SUCCESS) {
/* this is a fatal error */
*errnop = errno = ENOENT;
/* search the entry */
ret = ldb_search(_ldb_nss_ctx->ldb,
+ _ldb_nss_ctx->ldb,
+ &res,
_ldb_nss_ctx->base,
LDB_SCOPE_SUBTREE,
- filter,
_ldb_nss_pw_attrs,
- &res);
+ filter);
if (ret != LDB_SUCCESS) {
/* this is a fatal error */
*errnop = errno = ENOENT;
# Simple tests for the ldb python bindings.
# Copyright (C) 2007 Jelmer Vernooij <jelmer@samba.org>
-import sys
+import os, sys
import unittest
# Required for the standalone LDB build
x = ldb.Ldb()
x.set_modules_dir("/tmp")
+ def test_modules_none(self):
+ x = ldb.Ldb()
+ self.assertEquals([], x.modules())
+
+ def test_modules_tdb(self):
+ x = ldb.Ldb("bar.ldb")
+ self.assertEquals("[<ldb module 'tdb'>]", repr(x.modules()))
+
def test_search(self):
l = ldb.Ldb("foo.ldb")
self.assertEquals(len(l.search()), 1)
x = ldb.MessageElement(["foo"])
self.assertEquals("foo", x)
-class ExampleModule:
- name = "example"
-
class ModuleTests(unittest.TestCase):
def test_register_module(self):
- ldb.register_module(ExampleModule())
+ class ExampleModule:
+ name = "example"
+ ldb.register_module(ExampleModule)
+
+ def test_use_module(self):
+ ops = []
+ class ExampleModule:
+ name = "bla"
+
+ def __init__(self, ldb, next):
+ ops.append("init")
+ self.next = next
+
+ def search(self, *args, **kwargs):
+ return self.next.search(*args, **kwargs)
+
+ ldb.register_module(ExampleModule)
+ if os.path.exists("usemodule.ldb"):
+ os.unlink("usemodule.ldb")
+ l = ldb.Ldb("usemodule.ldb")
+ l.add({"dn": "@MODULES", "@LIST": "bla"})
+ self.assertEquals([], ops)
+ l = ldb.Ldb("usemodule.ldb")
+ self.assertEquals(["init"], ops)
if __name__ == '__main__':
import unittest
import time
sys.path.append("bin/python")
+sys.path.append("../lib/subunit/python")
import samba.getopt as options
self.assertTrue("objectGuid" not in res[0])
self.assertTrue("whenCreated" in res[0])
self.assertTrue("nTSecurityDescriptor" in res[0])
- self.assertEquals(res[0]["member"][0].upper(), ("CN=ldaptestuser2,CN=Users," + self.base_dn).upper())
+ memberUP = []
+ for m in res[0]["member"]:
+ memberUP.append(m.upper())
+ self.assertTrue(("CN=ldaptestuser2,CN=Users," + self.base_dn).upper() in memberUP)
ldb.modify_ldif("""
dn: cn=ldaptestgroup2,cn=users,""" + self.base_dn + """
const char *attrs[] = { NULL };
struct ldb_result *res;
- ret = ldb_search(ldb, dn, LDB_SCOPE_SUBTREE, "distinguishedName=*", attrs, &res);
+ ret = ldb_search(ldb, ldb, &res, dn, LDB_SCOPE_SUBTREE, attrs, "distinguishedName=*");
if (ret != LDB_SUCCESS) return -1;
for (i = 0; i < res->count; i++) {
}
}
- ret = ldb_search(ldb, basedn, options->scope, expression, attrs, &result);
+ ret = ldb_search(ldb, ldb, &result, basedn, options->scope, attrs, "%s", expression);
if (ret != LDB_SUCCESS) {
printf("search failed - %s\n", ldb_errstring(ldb));
exit(1);
}
struct search_context {
+ struct ldb_context *ldb;
struct ldb_control **req_ctrls;
int sort;
return 0;
}
-static int display_message(struct ldb_context *ldb, struct ldb_message *msg, struct search_context *sctx) {
+static int display_message(struct ldb_message *msg, struct search_context *sctx) {
struct ldb_ldif ldif;
sctx->entries++;
ldb_msg_sort_elements(ldif.msg);
}
- ldb_ldif_write_file(ldb, stdout, &ldif);
+ ldb_ldif_write_file(sctx->ldb, stdout, &ldif);
return 0;
}
return 0;
}
-static int search_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
+static int search_callback(struct ldb_request *req, struct ldb_reply *ares)
{
- struct search_context *sctx = talloc_get_type(context, struct search_context);
+ struct search_context *sctx;
int ret;
+
+ sctx = talloc_get_type(req->context, struct search_context);
+
+ if (!ares) {
+ return ldb_request_done(req, LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_request_done(req, ares->error);
+ }
switch (ares->type) {
-
case LDB_REPLY_ENTRY:
if (sctx->sort) {
ret = store_message(ares->message, sctx);
} else {
- ret = display_message(ldb, ares->message, sctx);
+ ret = display_message(ares->message, sctx);
}
break;
} else {
ret = display_referral(ares->referral, sctx);
}
+ if (ret) {
+ return ldb_request_done(req, LDB_ERR_OPERATIONS_ERROR);
+ }
break;
case LDB_REPLY_DONE:
if (handle_controls_reply(ares->controls, sctx->req_ctrls) == 1)
sctx->pending = 1;
}
- ret = 0;
- break;
-
- default:
- fprintf(stderr, "unknown Reply Type\n");
- return LDB_ERR_OTHER;
- }
-
- if (talloc_free(ares) == -1) {
- fprintf(stderr, "talloc_free failed\n");
- sctx->pending = 0;
- return LDB_ERR_OPERATIONS_ERROR;
+ talloc_free(ares);
+ return ldb_request_done(req, LDB_SUCCESS);
}
+ talloc_free(ares);
if (ret) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_request_done(req, LDB_ERR_OPERATIONS_ERROR);
}
return LDB_SUCCESS;
struct search_context *sctx;
int ret;
- req = talloc(ldb, struct ldb_request);
- if (!req) return -1;
+ req = NULL;
- sctx = talloc(req, struct search_context);
+ sctx = talloc(ldb, struct search_context);
if (!sctx) return -1;
+ sctx->ldb = ldb;
sctx->sort = options->sorted;
sctx->num_stored = 0;
sctx->refs_stored = 0;
basedn = ldb_get_default_basedn(ldb);
}
- req->operation = LDB_SEARCH;
- req->op.search.base = basedn;
- req->op.search.scope = options->scope;
- req->op.search.tree = ldb_parse_tree(req, expression);
- if (req->op.search.tree == NULL) return -1;
- req->op.search.attrs = attrs;
- req->controls = sctx->req_ctrls;
- req->context = sctx;
- req->callback = &search_callback;
- ldb_set_timeout(ldb, req, 0); /* TODO: make this settable by command line */
-
again:
+ /* free any previous requests */
+ if (req) talloc_free(req);
+
+ ret = ldb_build_search_req(&req, ldb, ldb,
+ basedn, options->scope,
+ expression, attrs,
+ sctx->req_ctrls,
+ sctx, search_callback,
+ NULL);
+ if (ret != LDB_SUCCESS) {
+ talloc_free(sctx);
+ printf("allocating request failed: %s\n", ldb_errstring(ldb));
+ return -1;
+ }
+
sctx->pending = 0;
ret = ldb_request(ldb, req);
ldb, (ldb_qsort_cmp_fn_t)do_compare_msg);
}
for (i = 0; i < sctx->num_stored; i++) {
- display_message(ldb, sctx->store[i], sctx);
+ display_message(sctx->store[i], sctx);
}
for (i = 0; i < sctx->refs_stored; i++) {
printf("# returned %d records\n# %d entries\n# %d referrals\n",
sctx->entries + sctx->refs, sctx->entries, sctx->refs);
+ talloc_free(sctx);
talloc_free(req);
return 0;
int ret;
expr = talloc_asprintf(ldb, "(uid=TEST%d)", uid);
- ret = ldb_search(ldb, basedn, LDB_SCOPE_SUBTREE, expr, NULL, &res);
+ ret = ldb_search(ldb, ldb, &res, basedn, LDB_SCOPE_SUBTREE, NULL, "%s", expr);
if (ret != LDB_SUCCESS || (uid < nrecords && res->count != 1)) {
printf("Failed to find %s - %s\n", expr, ldb_errstring(ldb));
basedn = ldb_dn_new(*ldb, *ldb, options->basedn);
- ret = ldb_search(*ldb, basedn, LDB_SCOPE_SUBTREE, "uid=test", NULL, &res);
+ ret = ldb_search(*ldb, *ldb, &res, basedn, LDB_SCOPE_SUBTREE, NULL, "uid=test");
if (ret != LDB_SUCCESS) {
printf("Search with (uid=test) filter failed!\n");
exit(1);
static int ldb_wrap_destructor(struct ldb_context *ldb)
{
size_t *startup_blocks = (size_t *)ldb_get_opaque(ldb, "startup_blocks");
+
if (startup_blocks &&
talloc_total_blocks(ldb) > *startup_blocks + 400) {
DEBUG(0,("WARNING: probable memory leak in ldb %s - %lu blocks (startup %lu) %lu bytes\n",
"%s/ldb",
lp_modulesdir(lp_ctx)));
-#if 0
- if (ev) {
- ldb_event_sys_op_init(ldb, ev);
- } else {
- talloc_free(ldb);
- return NULL;
- }
-#endif
-
if (ldb_set_opaque(ldb, "sessionInfo", session_info)) {
talloc_free(ldb);
return NULL;
return ldb;
}
-
-
-
struct ldb_result *res;
int ret;
- ret = ldb_search(c, kd->dn, LDB_SCOPE_ONELEVEL, "(key=*)", NULL, &res);
+ ret = ldb_search(c, c, &res, kd->dn, LDB_SCOPE_ONELEVEL, NULL, "(key=*)");
if (ret != LDB_SUCCESS) {
DEBUG(0, ("Error getting subkeys for '%s': %s\n",
struct ldb_result *res;
int ret;
- ret = ldb_search(c, kd->dn, LDB_SCOPE_ONELEVEL,
- "(value=*)", NULL, &res);
+ ret = ldb_search(c, c, &res, kd->dn, LDB_SCOPE_ONELEVEL,
+ NULL, "(value=*)");
if (ret != LDB_SUCCESS) {
DEBUG(0, ("Error getting values for '%s': %s\n",
int ret;
char *query = talloc_asprintf(mem_ctx, "(value=%s)", name);
- ret = ldb_search(c, kd->dn, LDB_SCOPE_ONELEVEL, query, NULL, &res);
+ ret = ldb_search(c, mem_ctx, &res, kd->dn, LDB_SCOPE_ONELEVEL, NULL, "%s", query);
talloc_free(query);
if (ret != LDB_SUCCESS) {
DEBUG(0, ("Error getting values for '%s': %s\n",
ldb_dn_get_linearized(kd->dn), ldb_errstring(c)));
+ talloc_free(res);
return WERR_FOOBAR;
}
- if (res->count == 0)
+ if (res->count == 0) {
+ talloc_free(res);
return WERR_BADFILE;
+ }
reg_ldb_unpack_value(mem_ctx, lp_iconv_convenience(global_loadparm), res->msgs[0], NULL, data_type, data);
+ talloc_free(res);
return WERR_OK;
}
ldap_path = reg_path_to_ldb(mem_ctx, h, name, NULL);
- ret = ldb_search(c, ldap_path, LDB_SCOPE_BASE, "(key=*)", NULL, &res);
+ ret = ldb_search(c, mem_ctx, &res, ldap_path, LDB_SCOPE_BASE, NULL, "(key=*)");
if (ret != LDB_SUCCESS) {
DEBUG(3, ("Error opening key '%s': %s\n",
}
/* Search for subkeys */
- ret = ldb_search(c, ldap_path, LDB_SCOPE_ONELEVEL,
- "(key=*)", NULL, &res_keys);
+ ret = ldb_search(c, mem_ctx, &res_keys, ldap_path, LDB_SCOPE_ONELEVEL,
+ NULL, "(key=*)");
if (ret != LDB_SUCCESS) {
DEBUG(0, ("Error getting subkeys for '%s': %s\n",
}
/* Search for values */
- ret = ldb_search(c, ldap_path, LDB_SCOPE_ONELEVEL,
- "(value=*)", NULL, &res_vals);
+ ret = ldb_search(c, mem_ctx, &res_vals, ldap_path, LDB_SCOPE_ONELEVEL,
+ NULL, "(value=*)");
if (ret != LDB_SUCCESS) {
DEBUG(0, ("Error getting values for '%s': %s\n",
Copyright (C) Jelmer Vernooij 2004-2007
Copyright (C) Wilco Baan Hofman 2006
+ Copyright (C) Matthias Dieter Wallnöfer 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
&old_num_subkeys, &old_num_values,
NULL, NULL, NULL, NULL);
if (!W_ERROR_IS_OK(error)) {
- DEBUG(0, ("Error occured while getting key info: %s\n",
+ DEBUG(0, ("Error occurred while getting key info: %s\n",
win_errstr(error)));
+ talloc_free(mem_ctx);
return error;
}
} else {
old_num_values = 0;
}
- /* Subkeys that were deleted */
+ /* Subkeys that were changed or deleted */
for (i = 0; i < old_num_subkeys; i++) {
error1 = reg_key_get_subkey_by_index(mem_ctx, oldkey, i,
- &keyname1,
- NULL, NULL);
+ &keyname1, NULL, NULL);
if (!W_ERROR_IS_OK(error1)) {
- DEBUG(0, ("Error occured while getting subkey by index: %s\n",
- win_errstr(error2)));
+ DEBUG(0, ("Error occurred while getting subkey by index: %s\n",
+ win_errstr(error1)));
continue;
}
if (newkey != NULL) {
error2 = reg_open_key(mem_ctx, newkey, keyname1, &t2);
-
- if (W_ERROR_IS_OK(error2))
- continue;
} else {
error2 = WERR_BADFILE;
t2 = NULL;
}
- if (!W_ERROR_EQUAL(error2, WERR_BADFILE)) {
+ if (!W_ERROR_IS_OK(error2) && !W_ERROR_EQUAL(error2, WERR_BADFILE)) {
DEBUG(0, ("Error occured while getting subkey by name: %s\n",
win_errstr(error2)));
talloc_free(mem_ctx);
return error2;
}
- /* newkey didn't have such a subkey, add del diff */
+ /* if "error2" is going to be "WERR_BADFILE", then newkey */
+ /* didn't have such a subkey and therefore add a del diff */
tmppath = talloc_asprintf(mem_ctx, "%s\\%s", path, keyname1);
- callbacks->del_key(callback_data, tmppath);
+ if (!W_ERROR_IS_OK(error2))
+ callbacks->del_key(callback_data, tmppath);
+
+ /* perform here also the recursive invocation */
+ error1 = reg_open_key(mem_ctx, oldkey, keyname1, &t1);
+ if (!W_ERROR_IS_OK(error1)) {
+ DEBUG(0, ("Error occured while getting subkey by name: %s\n",
+ win_errstr(error1)));
+ talloc_free(mem_ctx);
+ return error1;
+ }
+ reg_generate_diff_key(t1, t2, tmppath, callbacks, callback_data);
+
talloc_free(tmppath);
}
&new_num_subkeys, &new_num_values,
NULL, NULL, NULL, NULL);
if (!W_ERROR_IS_OK(error)) {
- DEBUG(0, ("Error occured while getting key info: %s\n",
+ DEBUG(0, ("Error occurred while getting key info: %s\n",
win_errstr(error)));
+ talloc_free(mem_ctx);
return error;
}
} else {
/* Subkeys that were added */
for(i = 0; i < new_num_subkeys; i++) {
- error1 = reg_key_get_subkey_by_index(mem_ctx, newkey,
- i, &keyname1,
- NULL, NULL);
+ error1 = reg_key_get_subkey_by_index(mem_ctx, newkey, i,
+ &keyname1, NULL, NULL);
if (!W_ERROR_IS_OK(error1)) {
- DEBUG(0, ("Error occured while getting subkey by index: %s\n",
+ DEBUG(0, ("Error occurred while getting subkey by index: %s\n",
win_errstr(error1)));
talloc_free(mem_ctx);
return error1;
if (W_ERROR_IS_OK(error2))
continue;
} else {
+ error2 = WERR_BADFILE;
t1 = NULL;
- error2 = WERR_BADFILE;
}
if (!W_ERROR_EQUAL(error2, WERR_BADFILE)) {
- DEBUG(0, ("Error occured while getting subkey by name: %s\n",
+ DEBUG(0, ("Error occurred while getting subkey by name: %s\n",
win_errstr(error2)));
talloc_free(mem_ctx);
return error2;
tmppath = talloc_asprintf(mem_ctx, "%s\\%s", path, keyname1);
callbacks->add_key(callback_data, tmppath);
- W_ERROR_NOT_OK_RETURN(
- reg_open_key(mem_ctx, newkey, keyname1, &t2));
+ /* perform here also the recursive invocation */
+ error1 = reg_open_key(mem_ctx, newkey, keyname1, &t2);
+ if (!W_ERROR_IS_OK(error1)) {
+ DEBUG(0, ("Error occured while getting subkey by name: %s\n",
+ win_errstr(error1)));
+ talloc_free(mem_ctx);
+ return error1;
+ }
+ reg_generate_diff_key(t1, t2, tmppath, callbacks, callback_data);
- reg_generate_diff_key(t1, t2, tmppath,
- callbacks, callback_data);
talloc_free(tmppath);
}
- /* Values that were changed */
+ /* Values that were added or changed */
for(i = 0; i < new_num_values; i++) {
const char *name;
uint32_t type1, type2;
error1 = reg_key_get_value_by_index(mem_ctx, newkey, i,
&name, &type1, &contents1);
if (!W_ERROR_IS_OK(error1)) {
- DEBUG(0, ("Unable to get key by index: %s\n",
+ DEBUG(0, ("Unable to get value by index: %s\n",
win_errstr(error1)));
talloc_free(mem_ctx);
return error1;
} else
error2 = WERR_BADFILE;
- if(!W_ERROR_IS_OK(error2) &&
- !W_ERROR_EQUAL(error2, WERR_BADFILE)) {
- DEBUG(0, ("Error occured while getting value by name: %s\n",
+ if (!W_ERROR_IS_OK(error2)
+ && !W_ERROR_EQUAL(error2, WERR_BADFILE)) {
+ DEBUG(0, ("Error occurred while getting value by name: %s\n",
win_errstr(error2)));
talloc_free(mem_ctx);
return error2;
}
- if (W_ERROR_IS_OK(error2) &&
- data_blob_cmp(&contents1, &contents2) == 0)
+ if (W_ERROR_IS_OK(error2)
+ && (data_blob_cmp(&contents1, &contents2) == 0)
+ && (type1 == type2))
continue;
callbacks->set_value(callback_data, path, name,
/* Values that were deleted */
for (i = 0; i < old_num_values; i++) {
const char *name;
+ uint32_t type;
+ DATA_BLOB contents;
+
error1 = reg_key_get_value_by_index(mem_ctx, oldkey, i, &name,
- NULL, NULL);
+ &type, &contents);
if (!W_ERROR_IS_OK(error1)) {
- DEBUG(0, ("Error ocurred getting value by index: %s\n",
+ DEBUG(0, ("Unable to get value by index: %s\n",
win_errstr(error1)));
talloc_free(mem_ctx);
return error1;
}
- error2 = reg_key_get_value_by_name(mem_ctx, newkey, name, NULL,
- NULL);
+ if (newkey != NULL)
+ error2 = reg_key_get_value_by_name(mem_ctx, newkey,
+ name, &type, &contents);
+ else
+ error2 = WERR_BADFILE;
if (W_ERROR_IS_OK(error2))
continue;
if (!W_ERROR_EQUAL(error2, WERR_BADFILE)) {
- DEBUG(0, ("Error occured while getting value by name: %s\n",
+ DEBUG(0, ("Error occurred while getting value by name: %s\n",
win_errstr(error2)));
+ talloc_free(mem_ctx);
return error2;
}
int i;
WERROR error;
- for(i = HKEY_FIRST; i <= HKEY_LAST; i++) {
+ for (i = 0; reg_predefined_keys[i].name; i++) {
struct registry_key *r1 = NULL, *r2 = NULL;
- error = reg_get_predefined_key(ctx1, i, &r1);
+
+ error = reg_get_predefined_key(ctx1,
+ reg_predefined_keys[i].handle, &r1);
if (!W_ERROR_IS_OK(error) &&
!W_ERROR_EQUAL(error, WERR_BADFILE)) {
DEBUG(0, ("Unable to open hive %s for backend 1\n",
- reg_get_predef_name(i)));
+ reg_predefined_keys[i].name));
+ continue;
}
- error = reg_get_predefined_key(ctx2, i, &r2);
+ error = reg_get_predefined_key(ctx2,
+ reg_predefined_keys[i].handle, &r2);
if (!W_ERROR_IS_OK(error) &&
!W_ERROR_EQUAL(error, WERR_BADFILE)) {
DEBUG(0, ("Unable to open hive %s for backend 2\n",
- reg_get_predef_name(i)));
- }
-
- if (r1 == NULL && r2 == NULL)
+ reg_predefined_keys[i].name));
continue;
+ }
- error = reg_generate_diff_key(r1, r2, reg_get_predef_name(i),
- callbacks, callback_data);
+ error = reg_generate_diff_key(r1, r2,
+ reg_predefined_keys[i].name, callbacks,
+ callback_data);
if (!W_ERROR_IS_OK(error)) {
DEBUG(0, ("Unable to determine diff: %s\n",
win_errstr(error)));
static WERROR reg_diff_apply_del_key(void *_ctx, const char *key_name)
{
struct registry_context *ctx = (struct registry_context *)_ctx;
- WERROR error;
- error = reg_key_del_abs(ctx, key_name);
+ /* We can't proof here for success, because a common superkey could */
+ /* have been deleted before the subkey's (diff order). This removed */
+ /* therefore all childs recursively and the "WERR_BADFILE" result is */
+ /* expected. */
- if(!W_ERROR_IS_OK(error)) {
- DEBUG(0, ("Unable to delete key '%s'\n", key_name));
- return error;
- }
+ reg_key_del_abs(ctx, key_name);
return WERR_OK;
}
struct registry_context *ctx = (struct registry_context *)_ctx;
struct registry_key *key;
WERROR error;
- int i;
- uint32_t num_values;
+ const char* value_name;
error = reg_open_key_abs(ctx, ctx, key_name, &key);
}
W_ERROR_NOT_OK_RETURN(reg_key_get_info(ctx, key, NULL,
- NULL, &num_values, NULL, NULL, NULL, NULL));
+ NULL, NULL, NULL, NULL, NULL, NULL));
- for (i = 0; i < num_values; i++) {
- const char *name;
- W_ERROR_NOT_OK_RETURN(reg_key_get_value_by_index(ctx, key, i,
- &name,
- NULL, NULL));
- W_ERROR_NOT_OK_RETURN(reg_del_value(key, name));
+ while (W_ERROR_IS_OK(reg_key_get_value_by_index(
+ ctx, key, 0, &value_name, NULL, NULL))) {
+ error = reg_del_value(key, value_name);
+ if (!W_ERROR_IS_OK(error)) {
+ DEBUG(0, ("Error deleting value '%s'\n", value_name));
+ return error;
+ }
}
return WERR_OK;
}
%import "stdint.i"
-%import "../../lib/talloc/talloc.i"
+%import "../../../lib/talloc/talloc.i"
%import "../../auth/credentials/credentials.i"
%import "../../param/param.i"
%import "../events/events.i"
Samba Unix/Linux SMB implementation
RPC backend for the registry library
Copyright (C) 2003-2007 Jelmer Vernooij, jelmer@samba.org
+ Copyright (C) 2008 Matthias Dieter Wallnöfer, mwallnoefer@yahoo.de
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
#include "registry.h"
#include "librpc/gen_ndr/ndr_winreg_c.h"
+#define MAX_NAMESIZE 512
+#define MAX_VALSIZE 32768
+
struct rpc_key {
struct registry_key key;
struct policy_handle pol;
struct dcerpc_pipe *pipe;
- uint32_t num_values;
+ const char* classname;
uint32_t num_subkeys;
+ uint32_t max_subkeylen;
+ uint32_t max_subkeysize;
+ uint32_t num_values;
uint32_t max_valnamelen;
- uint32_t max_valdatalen;
- uint32_t max_subkeynamelen;
+ uint32_t max_valbufsize;
+ uint32_t secdescsize;
+ NTTIME last_changed_time;
};
struct rpc_registry_context {
* This is the RPC backend for the registry library.
*/
-static void init_winreg_String(struct winreg_String *name, const char *s)
-{
- name->name = s;
-}
-
-
#define openhive(u) static WERROR open_ ## u(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct policy_handle *hnd) \
{ \
struct winreg_Open ## u r; \
NTSTATUS status; \
- \
+\
+ ZERO_STRUCT(r); \
r.in.system_name = NULL; \
r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED; \
r.out.handle = hnd;\
- \
+\
status = dcerpc_winreg_Open ## u(p, mem_ctx, &r); \
- if (NT_STATUS_IS_ERR(status)) {\
- DEBUG(0,("Error executing open\n"));\
- return ntstatus_to_werror(status);\
- }\
+\
+ if (!NT_STATUS_IS_OK(status)) { \
+ DEBUG(1, ("OpenHive failed - %s\n", nt_errstr(status))); \
+ return ntstatus_to_werror(status); \
+ } \
\
return r.out.result;\
}
{ 0, NULL }
};
-static WERROR rpc_query_key(const struct registry_key *k);
+static WERROR rpc_query_key(TALLOC_CTX *mem_ctx, const struct registry_key *k);
static WERROR rpc_get_predefined_key(struct registry_context *ctx,
uint32_t hkey_type,
struct winreg_OpenKey r;
struct rpc_key_data *mykeydata;
- k->backend_data = mykeydata = talloc(mem_ctx, struct rpc_key_data);
+ k->backend_data = mykeydata = talloc_zero(mem_ctx, struct rpc_key_data);
mykeydata->num_values = -1;
mykeydata->num_subkeys = -1;
/* Then, open the handle using the hive */
- memset(&r, 0, sizeof(struct winreg_OpenKey));
+ ZERO_STRUCT(r);
r.in.handle = &(((struct rpc_key_data *)k->hive->root->backend_data)->pol);
- init_winreg_String(&r.in.keyname, k->path);
+ r.in.keyname.name = k->path;
r.in.unknown = 0x00000000;
r.in.access_mask = 0x02000000;
r.out.handle = &mykeydata->pol;
struct winreg_OpenKey r;
NTSTATUS status;
- mykeydata = talloc(mem_ctx, struct rpc_key);
-
+ mykeydata = talloc_zero(mem_ctx, struct rpc_key);
mykeydata->key.context = parentkeydata->key.context;
mykeydata->pipe = talloc_reference(mykeydata, parentkeydata->pipe);
mykeydata->num_values = -1;
/* Then, open the handle using the hive */
ZERO_STRUCT(r);
r.in.parent_handle = &parentkeydata->pol;
- init_winreg_String(&r.in.keyname, name);
+ r.in.keyname.name = name;
r.in.unknown = 0x00000000;
r.in.access_mask = 0x02000000;
r.out.handle = &mykeydata->pol;
status = dcerpc_winreg_OpenKey(mykeydata->pipe, mem_ctx, &r);
- if (NT_STATUS_IS_ERR(status)) {
- DEBUG(0,("Error executing openkey: %s\n", nt_errstr(status)));
+
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(1, ("OpenKey failed - %s\n", nt_errstr(status)));
return ntstatus_to_werror(status);
}
DATA_BLOB *data)
{
struct rpc_key *mykeydata = talloc_get_type(parent, struct rpc_key);
- WERROR error;
struct winreg_EnumValue r;
- uint32_t in_type = 0;
- NTSTATUS status;
struct winreg_StringBuf name;
+ uint8_t value;
+ uint32_t val_size = MAX_VALSIZE;
uint32_t zero = 0;
-
- ZERO_STRUCT(r);
+ WERROR error;
+ NTSTATUS status;
if (mykeydata->num_values == -1) {
- error = rpc_query_key(parent);
+ error = rpc_query_key(mem_ctx, parent);
if(!W_ERROR_IS_OK(error)) return error;
}
- name.length = 0;
- name.size = mykeydata->max_valnamelen * 2;
- name.name = NULL;
+ name.name = "";
+ name.size = MAX_NAMESIZE;
+ ZERO_STRUCT(r);
r.in.handle = &mykeydata->pol;
r.in.enum_index = n;
r.in.name = &name;
- r.in.type = &in_type;
- r.in.value = talloc_zero_array(mem_ctx, uint8_t, 0);
+ r.in.type = type;
+ r.in.value = &value;
+ r.in.size = &val_size;
r.in.length = &zero;
- r.in.size = &mykeydata->max_valdatalen;
r.out.name = &name;
r.out.type = type;
+ r.out.value = &value;
+ r.out.size = &val_size;
+ r.out.length = &zero;
status = dcerpc_winreg_EnumValue(mykeydata->pipe, mem_ctx, &r);
- if(NT_STATUS_IS_ERR(status)) {
- DEBUG(0, ("Error in EnumValue: %s\n", nt_errstr(status)));
- return WERR_GENERAL_FAILURE;
+
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(1, ("EnumValue failed - %s\n", nt_errstr(status)));
+ return ntstatus_to_werror(status);
}
- if(NT_STATUS_IS_OK(status) &&
- W_ERROR_IS_OK(r.out.result) && r.out.length) {
- *value_name = talloc_strdup(mem_ctx, r.out.name->name);
- *data = data_blob_talloc(mem_ctx, r.out.value, *r.out.length);
- return WERR_OK;
+ *value_name = talloc_reference(mem_ctx, r.out.name->name);
+ *type = *(r.out.type);
+ *data = data_blob_talloc(mem_ctx, r.out.value, *r.out.length);
+
+ return r.out.result;
+}
+
+static WERROR rpc_get_value_by_name(TALLOC_CTX *mem_ctx,
+ const struct registry_key *parent,
+ const char *value_name,
+ uint32_t *type,
+ DATA_BLOB *data)
+{
+ struct rpc_key *mykeydata = talloc_get_type(parent, struct rpc_key);
+ struct winreg_QueryValue r;
+ struct winreg_String name;
+ uint8_t value;
+ uint32_t val_size = MAX_VALSIZE;
+ uint32_t zero = 0;
+ WERROR error;
+ NTSTATUS status;
+
+ if (mykeydata->num_values == -1) {
+ error = rpc_query_key(mem_ctx, parent);
+ if(!W_ERROR_IS_OK(error)) return error;
+ }
+
+ name.name = value_name;
+
+ ZERO_STRUCT(r);
+ r.in.handle = &mykeydata->pol;
+ r.in.value_name = name;
+ r.in.type = type;
+ r.in.data = &value;
+ r.in.size = &val_size;
+ r.in.length = &zero;
+ r.out.type = type;
+ r.out.data = &value;
+ r.out.size = &val_size;
+ r.out.length = &zero;
+
+ status = dcerpc_winreg_QueryValue(mykeydata->pipe, mem_ctx, &r);
+
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(1, ("QueryValue failed - %s\n", nt_errstr(status)));
+ return ntstatus_to_werror(status);
}
+ *type = *(r.out.type);
+ *data = data_blob_talloc(mem_ctx, r.out.data, *r.out.length);
+
return r.out.result;
}
{
struct winreg_EnumKey r;
struct rpc_key *mykeydata = talloc_get_type(parent, struct rpc_key);
- NTSTATUS status;
struct winreg_StringBuf namebuf, classbuf;
NTTIME change_time = 0;
+ NTSTATUS status;
- ZERO_STRUCT(r);
-
- namebuf.length = 0;
- namebuf.size = 1024;
- namebuf.name = NULL;
- classbuf.length = 0;
- classbuf.size = 0;
- classbuf.name = NULL;
+ namebuf.name = "";
+ namebuf.size = MAX_NAMESIZE;
+ classbuf.name = NULL;
+ classbuf.size = 0;
+ ZERO_STRUCT(r);
r.in.handle = &mykeydata->pol;
r.in.enum_index = n;
r.in.name = &namebuf;
r.in.keyclass = &classbuf;
r.in.last_changed_time = &change_time;
-
r.out.name = &namebuf;
+ r.out.keyclass = &classbuf;
+ r.out.last_changed_time = &change_time;
status = dcerpc_winreg_EnumKey(mykeydata->pipe, mem_ctx, &r);
- if (NT_STATUS_IS_OK(status) && W_ERROR_IS_OK(r.out.result)) {
- *name = talloc_strdup(mem_ctx, r.out.name->name);
- if (keyclass != NULL)
- *keyclass = talloc_strdup(mem_ctx, r.out.keyclass->name);
+
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(1, ("EnumKey failed - %s\n", nt_errstr(status)));
+ return ntstatus_to_werror(status);
}
+ if (name != NULL)
+ *name = talloc_reference(mem_ctx, r.out.name->name);
+ if (keyclass != NULL)
+ *keyclass = talloc_reference(mem_ctx, r.out.keyclass->name);
+ if (last_changed_time != NULL)
+ *last_changed_time = *(r.out.last_changed_time);
+
return r.out.result;
}
struct security_descriptor *sec,
struct registry_key **key)
{
- NTSTATUS status;
struct winreg_CreateKey r;
struct rpc_key *parentkd = talloc_get_type(parent, struct rpc_key);
struct rpc_key *rpck = talloc(mem_ctx, struct rpc_key);
+
+ NTSTATUS status;
- init_winreg_String(&r.in.name, name);
- init_winreg_String(&r.in.keyclass, NULL);
-
+ ZERO_STRUCT(r);
r.in.handle = &parentkd->pol;
- r.out.new_handle = &rpck->pol;
+ r.in.name.name = name;
+ r.in.keyclass.name = NULL;
r.in.options = 0;
- r.in.access_mask = SEC_STD_ALL;
+ r.in.access_mask = 0x02000000;
r.in.secdesc = NULL;
+ r.in.action_taken = NULL;
+ r.out.new_handle = &rpck->pol;
+ r.out.action_taken = NULL;
status = dcerpc_winreg_CreateKey(parentkd->pipe, mem_ctx, &r);
return ntstatus_to_werror(status);
}
- if (W_ERROR_IS_OK(r.out.result)) {
- rpck->pipe = talloc_reference(rpck, parentkd->pipe);
- *key = (struct registry_key *)rpck;
- }
+ rpck->pipe = talloc_reference(rpck, parentkd->pipe);
+ *key = (struct registry_key *)rpck;
return r.out.result;
}
-static WERROR rpc_query_key(const struct registry_key *k)
+static WERROR rpc_query_key(TALLOC_CTX *mem_ctx, const struct registry_key *k)
{
- NTSTATUS status;
struct winreg_QueryInfoKey r;
struct rpc_key *mykeydata = talloc_get_type(k, struct rpc_key);
- TALLOC_CTX *mem_ctx = talloc_init("query_key");
- uint32_t max_subkeysize;
- uint32_t secdescsize;
- NTTIME last_changed_time;
+ struct winreg_String classname;
+ NTSTATUS status;
- ZERO_STRUCT(r.out);
+ classname.name = NULL;
+ ZERO_STRUCT(r);
+ r.in.handle = &mykeydata->pol;
+ r.in.classname = &classname;
+ r.out.classname = &classname;
r.out.num_subkeys = &mykeydata->num_subkeys;
- r.out.max_subkeylen = &mykeydata->max_subkeynamelen;
- r.out.max_valnamelen = &mykeydata->max_valnamelen;
- r.out.max_valbufsize = &mykeydata->max_valdatalen;
- r.out.max_subkeysize = &max_subkeysize;
+ r.out.max_subkeylen = &mykeydata->max_subkeylen;
+ r.out.max_subkeysize = &mykeydata->max_subkeysize;
r.out.num_values = &mykeydata->num_values;
- r.out.secdescsize = &secdescsize;
- r.out.last_changed_time = &last_changed_time;
-
- r.out.classname = r.in.classname = talloc_zero(mem_ctx, struct winreg_String);
- init_winreg_String(r.in.classname, NULL);
- r.in.handle = &mykeydata->pol;
+ r.out.max_valnamelen = &mykeydata->max_valnamelen;
+ r.out.max_valbufsize = &mykeydata->max_valbufsize;
+ r.out.secdescsize = &mykeydata->secdescsize;
+ r.out.last_changed_time = &mykeydata->last_changed_time;
status = dcerpc_winreg_QueryInfoKey(mykeydata->pipe, mem_ctx, &r);
- talloc_free(mem_ctx);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(1, ("QueryInfoKey failed - %s\n", nt_errstr(status)));
return ntstatus_to_werror(status);
}
- if (W_ERROR_IS_OK(r.out.result)) {
- }
+ mykeydata->classname = talloc_reference(mem_ctx, r.out.classname->name);
return r.out.result;
}
struct winreg_DeleteKey r;
TALLOC_CTX *mem_ctx = talloc_init("del_key");
+ ZERO_STRUCT(r);
r.in.handle = &mykeydata->pol;
- init_winreg_String(&r.in.key, name);
+ r.in.key.name = name;
status = dcerpc_winreg_DeleteKey(mykeydata->pipe, mem_ctx, &r);
talloc_free(mem_ctx);
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(1, ("DeleteKey failed - %s\n", nt_errstr(status)));
+ return ntstatus_to_werror(status);
+ }
+
return r.out.result;
}
static WERROR rpc_get_info(TALLOC_CTX *mem_ctx, const struct registry_key *key,
const char **classname,
- uint32_t *numsubkeys,
- uint32_t *numvalue,
+ uint32_t *num_subkeys,
+ uint32_t *num_values,
NTTIME *last_changed_time,
- uint32_t *max_subkeynamelen,
+ uint32_t *max_subkeylen,
uint32_t *max_valnamelen,
uint32_t *max_valbufsize)
{
WERROR error;
if (mykeydata->num_values == -1) {
- error = rpc_query_key(key);
+ error = rpc_query_key(mem_ctx, key);
if(!W_ERROR_IS_OK(error)) return error;
}
- /* FIXME: *classname = talloc_strdup(mem_ctx, mykeydata->classname); */
- /* FIXME: *last_changed_time = mykeydata->last_changed_time */
+ if (classname != NULL)
+ *classname = mykeydata->classname;
+
+ if (num_subkeys != NULL)
+ *num_subkeys = mykeydata->num_subkeys;
- if (numvalue != NULL)
- *numvalue = mykeydata->num_values;
+ if (num_values != NULL)
+ *num_values = mykeydata->num_values;
- if (numsubkeys != NULL)
- *numsubkeys = mykeydata->num_subkeys;
+ if (last_changed_time != NULL)
+ *last_changed_time = mykeydata->last_changed_time;
+
+ if (max_subkeylen != NULL)
+ *max_subkeylen = mykeydata->max_subkeylen;
if (max_valnamelen != NULL)
*max_valnamelen = mykeydata->max_valnamelen;
if (max_valbufsize != NULL)
- *max_valbufsize = mykeydata->max_valdatalen;
-
- if (max_subkeynamelen != NULL)
- *max_subkeynamelen = mykeydata->max_subkeynamelen;
+ *max_valbufsize = mykeydata->max_valbufsize;
return WERR_OK;
}
.get_predefined_key = rpc_get_predefined_key,
.enum_key = rpc_get_subkey_by_index,
.enum_value = rpc_get_value_by_index,
+ .get_value = rpc_get_value_by_name,
.create_key = rpc_add_key,
.delete_key = rpc_del_key,
.get_key_info = rpc_get_info,
static bool test_reg_val_data_string_sz(struct torture_context *ctx)
{
DATA_BLOB db;
- db.length = convert_string_talloc(ctx, lp_iconv_convenience(ctx->lp_ctx), CH_UNIX, CH_UTF16,
+ db.length = convert_string_talloc(ctx, lp_iconv_convenience(ctx->lp_ctx), CH_UTF8, CH_UTF16,
"bla", 3, (void **)&db.data);
torture_assert_str_equal(ctx, "bla",
reg_val_data_string(ctx, lp_iconv_convenience(ctx->lp_ctx), REG_SZ, db),
static bool test_reg_val_description(struct torture_context *ctx)
{
DATA_BLOB data;
- data.length = convert_string_talloc(ctx, lp_iconv_convenience(ctx->lp_ctx), CH_UNIX, CH_UTF16,
+ data.length = convert_string_talloc(ctx, lp_iconv_convenience(ctx->lp_ctx), CH_UTF8, CH_UTF16,
"stationary traveller",
strlen("stationary traveller"),
(void **)&data.data);
static bool test_reg_val_description_nullname(struct torture_context *ctx)
{
DATA_BLOB data;
- data.length = convert_string_talloc(ctx, lp_iconv_convenience(ctx->lp_ctx), CH_UNIX, CH_UTF16,
+ data.length = convert_string_talloc(ctx, lp_iconv_convenience(ctx->lp_ctx), CH_UTF8, CH_UTF16,
"west berlin",
strlen("west berlin"),
(void **)&data.data);
break;
case REG_REMOTE:
error = reg_open_remote(&ctx, NULL, cmdline_credentials, lp_ctx,
- remote_host, NULL);
+ remote_host, ev_ctx);
break;
case REG_NULL:
error = reg_open_local(NULL, &ctx);
{
int i;
WERROR error;
- uint32_t data_type;
- DATA_BLOB data;
+ uint32_t valuetype;
+ DATA_BLOB valuedata;
const char *name = NULL;
for (i = 0; W_ERROR_IS_OK(error = reg_key_get_subkey_by_index(ctx,
}
if (!W_ERROR_EQUAL(error, WERR_NO_MORE_ITEMS)) {
- DEBUG(0, ("Error occured while browsing thru keys: %s\n",
- win_errstr(error)));
+ fprintf(stderr, "Error occured while browsing thru keys: %s\n",
+ win_errstr(error));
+ return error;
}
for (i = 0; W_ERROR_IS_OK(error = reg_key_get_value_by_index(ctx,
- ctx->current,
- i,
- &name,
- &data_type,
- &data)); i++) {
- printf("V \"%s\" %s %s\n", name, str_regtype(data_type),
- reg_val_data_string(ctx, lp_iconv_convenience(cmdline_lp_ctx), data_type, data));
- }
+ ctx->current, i, &name, &valuetype, &valuedata)); i++)
+ printf("V \"%s\" %s %s\n", name, str_regtype(valuetype),
+ reg_val_data_string(ctx, lp_iconv_convenience(cmdline_lp_ctx), valuetype, valuedata));
return WERR_OK;
}
error = reg_key_add_name(ctx, ctx->current, argv[1], 0, NULL, &tmp);
if (!W_ERROR_IS_OK(error)) {
- fprintf(stderr, "Error adding new subkey '%s'\n", argv[1]);
+ fprintf(stderr, "Error adding new subkey '%s': %s\n", argv[1],
+ win_errstr(error));
return error;
}
len = strlen(text);
for(i = 0; j < MAX_COMPLETIONS-1; i++) {
status = reg_key_get_subkey_by_index(mem_ctx, base, i,
- &subkeyname, NULL, NULL);
+ &subkeyname, NULL, NULL);
if(W_ERROR_IS_OK(status)) {
if(!strncmp(text, subkeyname, len)) {
matches[j] = strdup(subkeyname);
if (ctx->current == NULL) {
int i;
- for (i = 0; reg_predefined_keys[i].handle; i++) {
+ for (i = 0; (reg_predefined_keys[i].handle != 0) &&
+ (ctx->current == NULL); i++) {
WERROR err;
err = reg_get_predefined_key(ctx->registry,
reg_predefined_keys[i].handle,
bool fullpath, bool novals)
{
struct registry_key *subkey;
- const char *valuename;
- const char *keyname;
- uint32_t value_type;
- DATA_BLOB value_data;
+ const char *valuename, *keyname;
+ uint32_t valuetype;
+ DATA_BLOB valuedata;
struct security_descriptor *sec_desc;
WERROR error;
int i;
if (!novals) {
mem_ctx = talloc_init("print_tree");
- for(i = 0; W_ERROR_IS_OK(error = reg_key_get_value_by_index(mem_ctx,
- p,
- i,
- &valuename,
- &value_type,
- &value_data)); i++) {
+ for(i = 0; W_ERROR_IS_OK(error = reg_key_get_value_by_index(
+ mem_ctx, p, i, &valuename, &valuetype, &valuedata));
+ i++) {
int j;
- char *desc;
for(j = 0; j < level+1; j++) putchar(' ');
- desc = reg_val_description(mem_ctx, lp_iconv_convenience(cmdline_lp_ctx), valuename,
- value_type, value_data);
- printf("%s\n", desc);
+ printf("%s\n", reg_val_description(mem_ctx,
+ lp_iconv_convenience(cmdline_lp_ctx), valuename,
+ valuetype, valuedata));
}
talloc_free(mem_ctx);
#include "includes.h"
#include "system/filesys.h"
-#include "lib/crypto/crypto.h"
+#include "../lib/crypto/crypto.h"
#include "system/locale.h"
/**
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
+ the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
int n, m, sh;
struct idr_layer *p, *new;
struct idr_layer *pa[MAX_LEVEL];
- int l, id;
+ int l, id, oid;
uint32_t bm;
memset(pa, 0, sizeof(pa));
id = *starting_id;
+restart:
p = idp->top;
l = idp->layers;
pa[l--] = NULL;
if (m == IDR_SIZE) {
/* no space available go back to previous layer. */
l++;
+ oid = id;
id = (id | ((1 << (IDR_BITS*l))-1)) + 1;
+
+ /* if already at the top layer, we need to grow */
if (!(p = pa[l])) {
*starting_id = id;
return -2;
}
+
+ /* If we need to go up one layer, continue the
+ * loop; otherwise, restart from the top.
+ */
+ sh = IDR_BITS * (l + 1);
+ if (oid >> sh == id >> sh)
continue;
+ else
+ goto restart;
}
if (m != n) {
sh = IDR_BITS*l;
res = NULL;
- ret = ldb_search(ldb, basedn, scope, expr, attrs, &res);
+ ret = ldb_search(ldb, mem_ctx, &res, basedn, scope, attrs,
+ expr?"%s":NULL, expr);
if (ret == LDB_SUCCESS) {
talloc_steal(mem_ctx, res->msgs);
/** FIXME: Use credentials struct rather than user/password here */
WERROR WBEM_ConnectServer(struct com_context *ctx, const char *server, const char *nspace,
- const char *user, const char *password,
+ struct cli_credentials *credentials,
const char *locale, uint32_t flags, const char *authority,
struct IWbemContext* wbem_ctx, struct IWbemServices** services);
const char *wmi_errstr(WERROR werror);
/** FIXME: Use credentials struct rather than user/password here */
WERROR WBEM_ConnectServer(struct com_context *ctx, const char *server, const uint16_t *nspace,
- const char *user, const char *password,
+ struct cli_credentials *credentials,
const char *locale, uint32_t flags, const char *authority,
struct IWbemContext* wbem_ctx, struct IWbemServices** services)
{
struct IUnknown **mqi;
struct IWbemLevel1Login *pL;
- if (user) {
- char *cred;
- struct cli_credentials *cc;
-
- cred = talloc_asprintf(NULL, "%s%%%s", user, password);
- cc = cli_credentials_init(cred);
- cli_credentials_set_conf(cc, global_loadparm);
- cli_credentials_parse_string(cc, cred, CRED_SPECIFIED);
- dcom_add_server_credentials(ctx, server, cc);
- talloc_free(cred);
- }
-
GUID_from_string(CLSID_WBEMLEVEL1LOGIN, &clsid);
GUID_from_string(COM_IWBEMLEVEL1LOGIN_UUID, &iid);
result = dcom_create_object(ctx, &clsid, server, 1, &iid, &mqi, &coresult);
#include "includes.h"
#include "system/time.h"
#include "auth/auth.h"
-#include "lib/crypto/crypto.h"
+#include "../lib/crypto/crypto.h"
#include "libcli/auth/libcli_auth.h"
/*
#include "system/time.h"
#include "auth/ntlmssp/ntlmssp.h"
#include "auth/ntlmssp/msrpc_parse.h"
-#include "lib/crypto/crypto.h"
+#include "../lib/crypto/crypto.h"
#include "libcli/auth/libcli_auth.h"
#include "pstring.h"
#include "param/param.h"
returned password including termination.
************************************************************/
bool decode_pw_buffer(uint8_t in_buffer[516], char *new_pwrd,
- int new_pwrd_size, uint32_t *new_pw_len,
- int string_flags)
+ int new_pwrd_size, int string_flags)
{
int byte_len=0;
+ ssize_t converted_pw_len;
/* the incoming buffer can be any alignment. */
string_flags |= STR_NOALIGN;
}
/* decode into the return buffer. Buffer length supplied */
- *new_pw_len = pull_string(lp_iconv_convenience(global_loadparm), new_pwrd, &in_buffer[512 - byte_len], new_pwrd_size,
+ converted_pw_len = pull_string(lp_iconv_convenience(global_loadparm), new_pwrd, &in_buffer[512 - byte_len], new_pwrd_size,
byte_len, string_flags);
+ if (converted_pw_len == -1) {
+ return false;
+ }
+
#ifdef DEBUG_PASSWORD
DEBUG(100,("decode_pw_buffer: new_pwrd: "));
- dump_data(100, (const uint8_t *)new_pwrd, *new_pw_len);
- DEBUG(100,("multibyte len:%d\n", *new_pw_len));
+ dump_data(100, (const uint8_t *)new_pwrd, converted_pw_len);
+ DEBUG(100,("multibyte len:%d\n", converted_pw_len));
DEBUG(100,("original char len:%d\n", byte_len/2));
#endif
*/
#include "lib/util/asn1.h"
-#include "libcli/netlogon.h"
+#include "../libcli/netlogon.h"
struct ldap_message;
/* wrapper around smb_raw_sesssetup() */
NTSTATUS smbcli_session_setup(struct smbcli_state *cli,
struct cli_credentials *credentials,
- const char *workgroup)
+ const char *workgroup,
+ struct smbcli_session_options options)
{
struct smb_composite_sesssetup setup;
NTSTATUS status;
- cli->session = smbcli_session_init(cli->transport, cli, true);
+ cli->session = smbcli_session_init(cli->transport, cli, true,
+ options);
if (!cli->session) return NT_STATUS_UNSUCCESSFUL;
setup.in.sesskey = cli->transport->negotiate.sesskey;
struct cli_credentials *credentials,
struct resolve_context *resolve_ctx,
struct event_context *ev,
- struct smbcli_options *options)
+ struct smbcli_options *options,
+ struct smbcli_session_options *session_options)
{
struct smbcli_tree *tree;
NTSTATUS status;
&tree, host, ports,
sharename, devtype,
credentials, resolve_ctx, ev,
- options);
+ options,
+ session_options);
if (!NT_STATUS_IS_OK(status)) {
goto done;
}
{
char *mask;
struct delete_state dstate;
+ NTSTATUS status;
dstate.tree = tree;
dstate.total_deleted = 0;
dstate.failed = false;
/* it might be a file */
+ status = smbcli_unlink(tree, dname);
if (NT_STATUS_IS_OK(smbcli_unlink(tree, dname))) {
return 1;
}
NT_STATUS_EQUAL(smbcli_nt_error(tree), NT_STATUS_NO_SUCH_FILE)) {
return 0;
}
+ if (NT_STATUS_EQUAL(status, NT_STATUS_CANNOT_DELETE)) {
+ /* it could be read-only */
+ status = smbcli_setatr(tree, dname, FILE_ATTRIBUTE_NORMAL, 0);
+ if (NT_STATUS_IS_OK(smbcli_unlink(tree, dname))) {
+ return 1;
+ }
+ }
asprintf(&mask, "%s\\*", dname);
smbcli_unlink(dstate.tree, mask);
FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM,
delete_fn, &dstate);
free(mask);
- if (NT_STATUS_IS_ERR(smbcli_rmdir(dstate.tree, dname))) {
+
+ status = smbcli_rmdir(dstate.tree, dname);
+ if (NT_STATUS_EQUAL(status, NT_STATUS_CANNOT_DELETE)) {
+ /* it could be read-only */
+ status = smbcli_setatr(dstate.tree, dname, FILE_ATTRIBUTE_NORMAL, 0);
+ status = smbcli_rmdir(dstate.tree, dname);
+ }
+ if (NT_STATUS_IS_ERR(status)) {
DEBUG(2,("Failed to delete %s - %s\n",
dname, smbcli_errstr(dstate.tree)));
return -1;
#include "libcli/composite/composite.h"
#include "lib/messaging/irpc.h"
#include "librpc/rpc/dcerpc.h"
-#include "libcli/nbt/libnbt.h"
+#include "../libcli/nbt/libnbt.h"
/*
create a new composite_context structure
{
if (composite_nomem(new_req, ctx)) return;
new_req->async.fn = continuation;
- new_req->async.private = private_data;
+ new_req->async.private_data = private_data;
}
[SUBSYSTEM::NDR_NBT_BUF]
-NDR_NBT_BUF_OBJ_FILES = $(libclisrcdir)/nbt/nbtname.o
+NDR_NBT_BUF_OBJ_FILES = $(libclinbtsrcdir)/nbtname.o
-$(eval $(call proto_header_template,$(libclisrcdir)/nbt/nbtname.h,$(NDR_NBT_BUF_OBJ_FILES:.o=.c)))
+$(eval $(call proto_header_template,$(libclinbtsrcdir)/nbtname.h,$(NDR_NBT_BUF_OBJ_FILES:.o=.c)))
[SUBSYSTEM::LIBCLI_NBT]
PUBLIC_DEPENDENCIES = LIBNDR NDR_NBT LIBCLI_COMPOSITE LIBEVENTS \
NDR_SECURITY samba-socket LIBSAMBA-UTIL
-LIBCLI_NBT_OBJ_FILES = $(addprefix $(libclisrcdir)/nbt/, \
+LIBCLI_NBT_OBJ_FILES = $(addprefix $(libclinbtsrcdir)/, \
nbtsocket.o \
namequery.o \
nameregister.o \
namerefresh.o \
namerelease.o)
-$(eval $(call proto_header_template,$(libclisrcdir)/nbt/nbt_proto.h,$(LIBCLI_NBT_OBJ_FILES:.o=.c)))
+[BINARY::nmblookup]
+INSTALLDIR = BINDIR
+PRIVATE_DEPENDENCIES = \
+ LIBSAMBA-HOSTCONFIG \
+ LIBSAMBA-UTIL \
+ LIBCLI_NBT \
+ LIBPOPT \
+ POPT_SAMBA \
+ LIBNETIF \
+ LIBCLI_RESOLVE
+
+nmblookup_OBJ_FILES = $(libclinbtsrcdir)/tools/nmblookup.o
+MANPAGES += $(libclinbtsrcdir)/man/nmblookup.1
[SUBSYSTEM::LIBCLI_NDR_NETLOGON]
PUBLIC_DEPENDENCIES = LIBNDR \
NDR_SECURITY
-LIBCLI_NDR_NETLOGON_OBJ_FILES = $(addprefix $(libclisrcdir)/, ndr_netlogon.o)
-
-$(eval $(call proto_header_template,$(libclisrcdir)/ndr_netlogon_proto.h,$(LIBCLI_NDR_NETLOGON_OBJ_FILES:.o=.c)))
+LIBCLI_NDR_NETLOGON_OBJ_FILES = $(addprefix $(libclinbtsrcdir)/../, ndr_netlogon.o)
[SUBSYSTEM::LIBCLI_NETLOGON]
PUBLIC_DEPENDENCIES = LIBSAMBA-UTIL LIBCLI_NDR_NETLOGON
-LIBCLI_NETLOGON_OBJ_FILES = $(addprefix $(libclisrcdir)/, \
- netlogon.o)
-
-$(eval $(call proto_header_template,$(libclisrcdir)/netlogon_proto.h,$(LIBCLI_NETLOGON_OBJ_FILES:.o=.c)))
-
-[SUBSYSTEM::LIBCLI_DRSBLOBS]
-PUBLIC_DEPENDENCIES = LIBNDR
-
-LIBCLI_DRSBLOBS_OBJ_FILES = $(addprefix $(libclisrcdir)/, \
- drsblobs.o)
-
-$(eval $(call proto_header_template,$(libclisrcdir)/drsblobs_proto.h,$(LIBCLI_DRSBLOBS_OBJ_FILES:.o=.c)))
+LIBCLI_NETLOGON_OBJ_FILES = $(addprefix $(libclinbtsrcdir)/, \
+ ../netlogon.o)
[PYTHON::python_netbios]
LIBRARY_REALNAME = samba/netbios.$(SHLIBEXT)
PUBLIC_DEPENDENCIES = LIBCLI_NBT DYNCONFIG LIBSAMBA-HOSTCONFIG
-python_netbios_OBJ_FILES = $(libclisrcdir)/nbt/pynbt.o
+python_netbios_OBJ_FILES = $(libclinbtsrcdir)/pynbt.o
$(python_libcli_nbt_OBJ_FILES): CFLAGS+=$(CFLAG_NO_UNUSED_MACROS) $(CFLAG_NO_CAST_QUAL)
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
-#include "libcli/netlogon.h"
+#include "../libcli/netlogon.h"
/*
a datagram name request
static void fallback_node_status_replied(struct nbt_name_request *name_req)
{
int i;
- struct finddcs_state *state = talloc_get_type(name_req->async.private, struct finddcs_state);
+ struct finddcs_state *state = talloc_get_type(name_req->async.private_data, struct finddcs_state);
state->ctx->status = nbt_name_status_recv(name_req, state, &state->node_status);
if (!composite_is_ok(state->ctx)) return;
if (NT_STATUS_IS_OK(status)) {
struct socket_context *sasl_socket;
status = gensec_socket_init(conn->gensec,
+ conn,
conn->sock,
conn->event.event_ctx,
ldap_read_io_handler,
{
struct ldap_request *req;
+ talloc_free(conn->sock); /* this will also free event.fde */
+ talloc_free(conn->packet);
+ conn->sock = NULL;
+ conn->event.fde = NULL;
+ conn->packet = NULL;
+
/* return an error for any pending request ... */
while (conn->pending) {
req = conn->pending;
req->async.fn(req);
}
}
-
- talloc_free(conn->sock); /* this will also free event.fde */
- talloc_free(conn->packet);
- conn->sock = NULL;
- conn->event.fde = NULL;
- conn->packet = NULL;
}
static void ldap_reconnect(struct ldap_connection *conn);
talloc_steal(conn, conn->sock);
if (conn->ldaps) {
struct socket_context *tls_socket;
+ struct socket_context *tmp_socket;
char *cafile = private_path(conn->sock, conn->lp_ctx, lp_tls_cafile(conn->lp_ctx));
if (!cafile || !*cafile) {
talloc_free(conn->sock);
return;
}
- talloc_unlink(conn, conn->sock);
- conn->sock = tls_socket;
- talloc_steal(conn, conn->sock);
+
+ /* the original socket, must become a child of the tls socket */
+ tmp_socket = conn->sock;
+ conn->sock = talloc_steal(conn, tls_socket);
+ talloc_steal(conn->sock, tmp_socket);
}
conn->packet = packet_init(conn);
packet_set_error_handler(conn->packet, ldap_error_handler);
packet_set_event_context(conn->packet, conn->event.event_ctx);
packet_set_fde(conn->packet, conn->event.fde);
- packet_set_serialise(conn->packet);
+/* packet_set_serialise(conn->packet); */
composite_done(ctx);
}
+++ /dev/null
-/*
- Unix SMB/CIFS implementation.
-
- a raw async NBT library
-
- Copyright (C) Andrew Tridgell 2005
-
- 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 __LIBNBT_H__
-#define __LIBNBT_H__
-
-#include "librpc/gen_ndr/nbt.h"
-#include "librpc/ndr/libndr.h"
-
-/*
- possible states for pending requests
-*/
-enum nbt_request_state {NBT_REQUEST_SEND,
- NBT_REQUEST_WAIT,
- NBT_REQUEST_DONE,
- NBT_REQUEST_TIMEOUT,
- NBT_REQUEST_ERROR};
-
-/*
- a nbt name request
-*/
-struct nbt_name_request {
- struct nbt_name_request *next, *prev;
-
- enum nbt_request_state state;
-
- NTSTATUS status;
-
- /* the socket this was on */
- struct nbt_name_socket *nbtsock;
-
- /* where to send the request */
- struct socket_address *dest;
-
- /* timeout between retries */
- int timeout;
-
- /* how many retries to send on timeout */
- int num_retries;
-
- /* whether we have received a WACK */
- bool received_wack;
-
- /* the timeout event */
- struct timed_event *te;
-
- /* the name transaction id */
- uint16_t name_trn_id;
-
- /* is it a reply? */
- bool is_reply;
-
- /* the encoded request */
- DATA_BLOB encoded;
-
- /* shall we allow multiple replies? */
- bool allow_multiple_replies;
-
- unsigned int num_replies;
- struct nbt_name_reply {
- struct nbt_name_packet *packet;
- struct socket_address *dest;
- } *replies;
-
- /* information on what to do on completion */
- struct {
- void (*fn)(struct nbt_name_request *);
- void *private;
- } async;
-};
-
-
-
-/*
- context structure for operations on name queries
-*/
-struct nbt_name_socket {
- struct socket_context *sock;
- struct event_context *event_ctx;
- struct smb_iconv_convenience *iconv_convenience;
-
- /* a queue of requests pending to be sent */
- struct nbt_name_request *send_queue;
-
- /* the fd event */
- struct fd_event *fde;
-
- /* mapping from name_trn_id to pending event */
- struct idr_context *idr;
-
- /* how many requests are waiting for a reply */
- uint16_t num_pending;
-
- /* what to do with incoming request packets */
- struct {
- void (*handler)(struct nbt_name_socket *, struct nbt_name_packet *,
- struct socket_address *);
- void *private;
- } incoming;
-
- /* what to do with unexpected replies */
- struct {
- void (*handler)(struct nbt_name_socket *, struct nbt_name_packet *,
- struct socket_address *);
- void *private;
- } unexpected;
-};
-
-
-/* a simple name query */
-struct nbt_name_query {
- struct {
- struct nbt_name name;
- const char *dest_addr;
- uint16_t dest_port;
- bool broadcast;
- bool wins_lookup;
- int timeout; /* in seconds */
- int retries;
- } in;
- struct {
- const char *reply_from;
- struct nbt_name name;
- int16_t num_addrs;
- const char **reply_addrs;
- } out;
-};
-
-/* a simple name status query */
-struct nbt_name_status {
- struct {
- struct nbt_name name;
- const char *dest_addr;
- uint16_t dest_port;
- int timeout; /* in seconds */
- int retries;
- } in;
- struct {
- const char *reply_from;
- struct nbt_name name;
- struct nbt_rdata_status status;
- } out;
-};
-
-/* a name registration request */
-struct nbt_name_register {
- struct {
- struct nbt_name name;
- const char *dest_addr;
- uint16_t dest_port;
- const char *address;
- uint16_t nb_flags;
- bool register_demand;
- bool broadcast;
- bool multi_homed;
- uint32_t ttl;
- int timeout; /* in seconds */
- int retries;
- } in;
- struct {
- const char *reply_from;
- struct nbt_name name;
- const char *reply_addr;
- uint8_t rcode;
- } out;
-};
-
-/* a send 3 times then demand name broadcast name registration */
-struct nbt_name_register_bcast {
- struct {
- struct nbt_name name;
- const char *dest_addr;
- uint16_t dest_port;
- const char *address;
- uint16_t nb_flags;
- uint32_t ttl;
- } in;
-};
-
-
-/* wins name register with multiple wins servers to try and multiple
- addresses to register */
-struct nbt_name_register_wins {
- struct {
- struct nbt_name name;
- const char **wins_servers;
- uint16_t wins_port;
- const char **addresses;
- uint16_t nb_flags;
- uint32_t ttl;
- } in;
- struct {
- const char *wins_server;
- uint8_t rcode;
- } out;
-};
-
-
-
-/* a name refresh request */
-struct nbt_name_refresh {
- struct {
- struct nbt_name name;
- const char *dest_addr;
- uint16_t dest_port;
- const char *address;
- uint16_t nb_flags;
- bool broadcast;
- uint32_t ttl;
- int timeout; /* in seconds */
- int retries;
- } in;
- struct {
- const char *reply_from;
- struct nbt_name name;
- const char *reply_addr;
- uint8_t rcode;
- } out;
-};
-
-/* wins name refresh with multiple wins servers to try and multiple
- addresses to register */
-struct nbt_name_refresh_wins {
- struct {
- struct nbt_name name;
- const char **wins_servers;
- uint16_t wins_port;
- const char **addresses;
- uint16_t nb_flags;
- uint32_t ttl;
- } in;
- struct {
- const char *wins_server;
- uint8_t rcode;
- } out;
-};
-
-
-/* a name release request */
-struct nbt_name_release {
- struct {
- struct nbt_name name;
- const char *dest_addr;
- uint16_t dest_port;
- const char *address;
- uint16_t nb_flags;
- bool broadcast;
- int timeout; /* in seconds */
- int retries;
- } in;
- struct {
- const char *reply_from;
- struct nbt_name name;
- const char *reply_addr;
- uint8_t rcode;
- } out;
-};
-
-struct nbt_name_socket *nbt_name_socket_init(TALLOC_CTX *mem_ctx,
- struct event_context *event_ctx,
- struct smb_iconv_convenience *iconv_convenience);
-struct nbt_name_request *nbt_name_query_send(struct nbt_name_socket *nbtsock,
- struct nbt_name_query *io);
-NTSTATUS nbt_name_query_recv(struct nbt_name_request *req,
- TALLOC_CTX *mem_ctx, struct nbt_name_query *io);
-NTSTATUS nbt_name_query(struct nbt_name_socket *nbtsock,
- TALLOC_CTX *mem_ctx, struct nbt_name_query *io);
-struct nbt_name_request *nbt_name_status_send(struct nbt_name_socket *nbtsock,
- struct nbt_name_status *io);
-NTSTATUS nbt_name_status_recv(struct nbt_name_request *req,
- TALLOC_CTX *mem_ctx, struct nbt_name_status *io);
-NTSTATUS nbt_name_status(struct nbt_name_socket *nbtsock,
- TALLOC_CTX *mem_ctx, struct nbt_name_status *io);
-
-NTSTATUS nbt_name_dup(TALLOC_CTX *mem_ctx, struct nbt_name *name, struct nbt_name *newname);
-NTSTATUS nbt_name_to_blob(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, DATA_BLOB *blob, struct nbt_name *name);
-NTSTATUS nbt_name_from_blob(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob, struct nbt_name *name);
-void nbt_choose_called_name(TALLOC_CTX *mem_ctx, struct nbt_name *n, const char *name, int type);
-char *nbt_name_string(TALLOC_CTX *mem_ctx, const struct nbt_name *name);
-NTSTATUS nbt_name_register(struct nbt_name_socket *nbtsock,
- TALLOC_CTX *mem_ctx, struct nbt_name_register *io);
-NTSTATUS nbt_name_refresh(struct nbt_name_socket *nbtsock,
- TALLOC_CTX *mem_ctx, struct nbt_name_refresh *io);
-NTSTATUS nbt_name_release(struct nbt_name_socket *nbtsock,
- TALLOC_CTX *mem_ctx, struct nbt_name_release *io);
-NTSTATUS nbt_name_register_wins(struct nbt_name_socket *nbtsock,
- TALLOC_CTX *mem_ctx,
- struct nbt_name_register_wins *io);
-NTSTATUS nbt_name_refresh_wins(struct nbt_name_socket *nbtsock,
- TALLOC_CTX *mem_ctx,
- struct nbt_name_refresh_wins *io);
-NTSTATUS nbt_name_register_recv(struct nbt_name_request *req,
- TALLOC_CTX *mem_ctx, struct nbt_name_register *io);
-struct nbt_name_request *nbt_name_register_send(struct nbt_name_socket *nbtsock,
- struct nbt_name_register *io);
-NTSTATUS nbt_name_release_recv(struct nbt_name_request *req,
- TALLOC_CTX *mem_ctx, struct nbt_name_release *io);
-
-struct nbt_name_request *nbt_name_release_send(struct nbt_name_socket *nbtsock,
- struct nbt_name_release *io);
-
-NTSTATUS nbt_name_refresh_recv(struct nbt_name_request *req,
- TALLOC_CTX *mem_ctx, struct nbt_name_refresh *io);
-
-NTSTATUS nbt_set_incoming_handler(struct nbt_name_socket *nbtsock,
- void (*handler)(struct nbt_name_socket *, struct nbt_name_packet *,
- struct socket_address *),
- void *private);
-NTSTATUS nbt_name_reply_send(struct nbt_name_socket *nbtsock,
- struct socket_address *dest,
- struct nbt_name_packet *request);
-
-
-NDR_SCALAR_PROTO(wrepl_nbt_name, const struct nbt_name *)
-NDR_SCALAR_PROTO(nbt_string, const char *)
-NDR_BUFFER_PROTO(nbt_name, struct nbt_name)
-NTSTATUS nbt_rcode_to_ntstatus(uint8_t rcode);
-
-struct composite_context;
-struct composite_context *nbt_name_register_bcast_send(struct nbt_name_socket *nbtsock,
- struct nbt_name_register_bcast *io);
-NTSTATUS nbt_name_register_bcast_recv(struct composite_context *c);
-struct composite_context *nbt_name_register_wins_send(struct nbt_name_socket *nbtsock,
- struct nbt_name_register_wins *io);
-NTSTATUS nbt_name_refresh_wins_recv(struct composite_context *c, TALLOC_CTX *mem_ctx,
- struct nbt_name_refresh_wins *io);
-struct composite_context *nbt_name_refresh_wins_send(struct nbt_name_socket *nbtsock,
- struct nbt_name_refresh_wins *io);
-NTSTATUS nbt_name_register_wins_recv(struct composite_context *c, TALLOC_CTX *mem_ctx,
- struct nbt_name_register_wins *io);
-
-
-#endif /* __LIBNBT_H__ */
--- /dev/null
+<?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="nmblookup">
+
+<refmeta>
+ <refentrytitle>nmblookup</refentrytitle>
+ <manvolnum>1</manvolnum>
+ <refmiscinfo class="source">Samba</refmiscinfo>
+ <refmiscinfo class="manual">User Commands</refmiscinfo>
+ <refmiscinfo class="version">3.2</refmiscinfo>
+</refmeta>
+
+
+<refnamediv>
+ <refname>nmblookup</refname>
+ <refpurpose>NetBIOS over TCP/IP client used to lookup NetBIOS
+ names</refpurpose>
+</refnamediv>
+
+<refsynopsisdiv>
+ <cmdsynopsis>
+ <command>nmblookup</command>
+ <arg choice="opt">-M</arg>
+ <arg choice="opt">-R</arg>
+ <arg choice="opt">-S</arg>
+ <arg choice="opt">-r</arg>
+ <arg choice="opt">-A</arg>
+ <arg choice="opt">-h</arg>
+ <arg choice="opt">-B <broadcast address></arg>
+ <arg choice="opt">-U <unicast address></arg>
+ <arg choice="opt">-d <debug level></arg>
+ <arg choice="opt">-s <smb config file></arg>
+ <arg choice="opt">-i <NetBIOS scope></arg>
+ <arg choice="opt">-T</arg>
+ <arg choice="opt">-f</arg>
+ <arg choice="req">name</arg>
+ </cmdsynopsis>
+</refsynopsisdiv>
+
+<refsect1>
+ <title>DESCRIPTION</title>
+
+ <para>This tool is part of the <citerefentry><refentrytitle>samba</refentrytitle>
+ <manvolnum>7</manvolnum></citerefentry> suite.</para>
+
+ <para><command>nmblookup</command> is used to query NetBIOS names
+ and map them to IP addresses in a network using NetBIOS over TCP/IP
+ queries. The options allow the name queries to be directed at a
+ particular IP broadcast area or to a particular machine. All queries
+ are done over UDP.</para>
+</refsect1>
+
+<refsect1>
+ <title>OPTIONS</title>
+
+ <variablelist>
+ <varlistentry>
+ <term>-M</term>
+ <listitem><para>Searches for a master browser by looking
+ up the NetBIOS name <replaceable>name</replaceable> with a
+ type of <constant>0x1d</constant>. If <replaceable>
+ name</replaceable> is "-" then it does a lookup on the special name
+ <constant>__MSBROWSE__</constant>. Please note that in order to
+ use the name "-", you need to make sure "-" isn't parsed as an
+ argument, e.g. use :
+ <userinput>nmblookup -M -- -</userinput>.</para></listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>-R</term>
+ <listitem><para>Set the recursion desired bit in the packet
+ to do a recursive lookup. This is used when sending a name
+ query to a machine running a WINS server and the user wishes
+ to query the names in the WINS server. If this bit is unset
+ the normal (broadcast responding) NetBIOS processing code
+ on a machine is used instead. See RFC1001, RFC1002 for details.
+ </para></listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>-S</term>
+ <listitem><para>Once the name query has returned an IP
+ address then do a node status query as well. A node status
+ query returns the NetBIOS names registered by a host.
+ </para></listitem>
+ </varlistentry>
+
+
+ <varlistentry>
+ <term>-r</term>
+ <listitem><para>Try and bind to UDP port 137 to send and receive UDP
+ datagrams. The reason for this option is a bug in Windows 95
+ where it ignores the source port of the requesting packet
+ and only replies to UDP port 137. Unfortunately, on most UNIX
+ systems root privilege is needed to bind to this port, and
+ in addition, if the <citerefentry><refentrytitle>nmbd</refentrytitle>
+ <manvolnum>8</manvolnum></citerefentry> daemon is running on this machine it also binds to this port.
+ </para></listitem>
+ </varlistentry>
+
+
+ <varlistentry>
+ <term>-A</term>
+ <listitem><para>Interpret <replaceable>name</replaceable> as
+ an IP Address and do a node status query on this address.</para>
+ </listitem>
+ </varlistentry>
+
+
+
+ &popt.common.connection;
+ &stdarg.help;
+
+ <varlistentry>
+ <term>-B <broadcast address></term>
+ <listitem><para>Send the query to the given broadcast address. Without
+ this option the default behavior of nmblookup is to send the
+ query to the broadcast address of the network interfaces as
+ either auto-detected or defined in the <ulink
+ url="smb.conf.5.html#INTERFACES"><parameter>interfaces</parameter>
+ </ulink> parameter of the <citerefentry><refentrytitle>smb.conf</refentrytitle>
+ <manvolnum>5</manvolnum></citerefentry> file.
+ </para></listitem>
+ </varlistentry>
+
+
+
+ <varlistentry>
+ <term>-U <unicast address></term>
+ <listitem><para>Do a unicast query to the specified address or
+ host <replaceable>unicast address</replaceable>. This option
+ (along with the <parameter>-R</parameter> option) is needed to
+ query a WINS server.</para></listitem>
+ </varlistentry>
+
+ &stdarg.server.debug;
+ &popt.common.samba;
+
+ <varlistentry>
+ <term>-T</term>
+ <listitem><para>This causes any IP addresses found in the
+ lookup to be looked up via a reverse DNS lookup into a
+ DNS name, and printed out before each</para>
+
+ <para><emphasis>IP address .... NetBIOS name</emphasis></para>
+
+ <para> pair that is the normal output.</para></listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>-f</term>
+ <listitem><para>
+ Show which flags apply to the name that has been looked up. Possible
+ answers are zero or more of: Response, Authoritative,
+ Truncated, Recursion_Desired, Recursion_Available, Broadcast.
+ </para></listitem>
+ </varlistentry>
+
+
+ <varlistentry>
+ <term>name</term>
+ <listitem><para>This is the NetBIOS name being queried. Depending
+ upon the previous options this may be a NetBIOS name or IP address.
+ If a NetBIOS name then the different name types may be specified
+ by appending '#<type>' to the name. This name may also be
+ '*', which will return all registered names within a broadcast
+ area.</para></listitem>
+ </varlistentry>
+ </variablelist>
+</refsect1>
+
+
+<refsect1>
+ <title>EXAMPLES</title>
+
+ <para><command>nmblookup</command> can be used to query
+ a WINS server (in the same way <command>nslookup</command> is
+ used to query DNS servers). To query a WINS server, <command>nmblookup</command>
+ must be called like this:</para>
+
+ <para><command>nmblookup -U server -R 'name'</command></para>
+
+ <para>For example, running :</para>
+
+ <para><command>nmblookup -U samba.org -R 'IRIX#1B'</command></para>
+
+ <para>would query the WINS server samba.org for the domain
+ master browser (1B name type) for the IRIX workgroup.</para>
+</refsect1>
+
+<refsect1>
+ <title>VERSION</title>
+
+ <para>This man page is correct for version 3 of
+ the Samba suite.</para>
+</refsect1>
+
+<refsect1>
+ <title>SEE ALSO</title>
+ <para><citerefentry><refentrytitle>nmbd</refentrytitle>
+ <manvolnum>8</manvolnum></citerefentry>, <citerefentry><refentrytitle>samba</refentrytitle>
+ <manvolnum>7</manvolnum></citerefentry>, and <citerefentry><refentrytitle>smb.conf</refentrytitle>
+ <manvolnum>5</manvolnum></citerefentry>.</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>
+
+ <para>The original Samba man pages were written by Karl Auer.
+ The man page sources were converted to YODL format (another
+ excellent piece of Open Source software, available at <ulink url="ftp://ftp.icce.rug.nl/pub/unix/">
+ ftp://ftp.icce.rug.nl/pub/unix/</ulink>) and updated for the Samba 2.0
+ release by Jeremy Allison. The conversion to DocBook for
+ Samba 2.2 was done by Gerald Carter. The conversion to DocBook
+ XML 4.2 for Samba 3.0 was done by Alexander Bokovoy.</para>
+</refsect1>
+
+</refentry>
#include "system/locale.h"
#include "lib/socket/netif.h"
#include "librpc/gen_ndr/nbt.h"
-#include "libcli/nbt/libnbt.h"
+#include "../libcli/nbt/libnbt.h"
#include "param/param.h"
/* command line options */
Initialize the session context
****************************************************************************/
struct smbcli_session *smbcli_session_init(struct smbcli_transport *transport,
- TALLOC_CTX *parent_ctx, bool primary)
+ TALLOC_CTX *parent_ctx, bool primary,
+ struct smbcli_session_options options)
{
struct smbcli_session *session;
uint16_t flags2;
}
session->pid = (uint16_t)getpid();
session->vuid = UID_FIELD_INVALID;
- session->options.lanman_auth = lp_client_lanman_auth(global_loadparm);
- session->options.ntlmv2_auth = lp_client_ntlmv2_auth(global_loadparm);
- session->options.plaintext_auth = lp_client_plaintext_auth(global_loadparm);
+ session->options = options;
capabilities = transport->negotiate.capabilities;
#include "lib/stream/packet.h"
#include "librpc/gen_ndr/ndr_nbt.h"
#include "param/param.h"
-#include "libcli/nbt/libnbt.h"
+#include "../libcli/nbt/libnbt.h"
/*
struct cli_credentials *credentials,
struct resolve_context *resolve_ctx,
struct event_context *ev,
- struct smbcli_options *options)
+ struct smbcli_options *options,
+ struct smbcli_session_options *session_options)
{
struct smb_composite_connect io;
NTSTATUS status;
* is complete -- abartlet 2008-04-28 */
io.in.workgroup = lp_workgroup(global_loadparm);
io.in.options = *options;
+ io.in.session_options = *session_options;
status = smb_composite_connect(&io, parent_ctx, resolve_ctx, ev);
if (NT_STATUS_IS_OK(status)) {
RAW_SFILEINFO_UNIX_HLINK = SMB_SFILEINFO_UNIX_HLINK,
RAW_SFILEINFO_BASIC_INFORMATION = SMB_SFILEINFO_BASIC_INFORMATION,
RAW_SFILEINFO_RENAME_INFORMATION = SMB_SFILEINFO_RENAME_INFORMATION,
+ RAW_SFILEINFO_LINK_INFORMATION = SMB_SFILEINFO_LINK_INFORMATION,
RAW_SFILEINFO_DISPOSITION_INFORMATION = SMB_SFILEINFO_DISPOSITION_INFORMATION,
RAW_SFILEINFO_POSITION_INFORMATION = SMB_SFILEINFO_POSITION_INFORMATION,
RAW_SFILEINFO_FULL_EA_INFORMATION = SMB_SFILEINFO_FULL_EA_INFORMATION,
NTTIME write_time;
NTTIME change_time;
uint32_t attrib;
+ uint32_t reserved;
} in;
} basic_info;
} in;
} rename_information;
+ /* RAW_SFILEINFO_LINK_INFORMATION interface */
+ struct {
+ enum smb_setfileinfo_level level;
+ struct {
+ union smb_handle_or_path file;
+ uint8_t overwrite;
+ uint64_t root_fid;
+ const char *new_name;
+ } in;
+ } link_information;
+
/* RAW_SFILEINFO_POSITION_INFORMATION interface */
struct {
enum smb_setfileinfo_level level;
struct security_descriptor *sd;
} in;
} set_secdesc;
+
+ /* RAW_SFILEINFO_FULL_EA_INFORMATION */
+ struct {
+ enum smb_setfileinfo_level level;
+ struct {
+ union smb_handle_or_path file;
+ struct smb_ea_list eas;
+ } in;
+ } full_ea_information;
};
counter by one */
uint_t sign_single_increment:1;
+ /* the caller wants to do the signing check */
+ bool sign_caller_checks;
+
+ /* give the caller a chance to prevent the talloc_free() in the _recv() function */
+ bool do_not_free;
+
/* the mid of this packet - used to match replies */
uint16_t mid;
}
status = req->status;
- talloc_free(req);
+
+ if (!req->do_not_free) {
+ talloc_free(req);
+ }
+
return status;
}
#define NEED_BLOB(n) do { \
*blob = data_blob_talloc(mem_ctx, NULL, n); \
- if (blob->data == NULL) return false; \
+ if (blob->data == NULL && n != 0) return false; \
} while (0)
switch (level) {
return true;
}
+ case RAW_SFILEINFO_FULL_EA_INFORMATION:
+ printf("num_eas=%d\n", parms->full_ea_information.in.eas.num_eas);
+ NEED_BLOB(ea_list_size_chained(
+ parms->full_ea_information.in.eas.num_eas,
+ parms->full_ea_information.in.eas.eas, 4));
+ ea_put_list_chained(blob->data,
+ parms->full_ea_information.in.eas.num_eas,
+ parms->full_ea_information.in.eas.eas, 4);
+ return true;
+
/* Unhandled levels */
case RAW_SFILEINFO_PIPE_INFORMATION:
case RAW_SFILEINFO_VALID_DATA_INFORMATION:
#include "smb.h"
#include "libcli/raw/libcliraw.h"
#include "libcli/raw/raw_proto.h"
-#include "lib/crypto/crypto.h"
+#include "../lib/crypto/crypto.h"
#include "param/param.h"
/***********************************************************
{
bool good;
+ if (!req->transport->negotiate.sign_info.doing_signing &&
+ req->sign_caller_checks) {
+ return true;
+ }
+
+ req->sign_caller_checks = false;
+
switch (req->transport->negotiate.sign_info.signing_state)
{
case SMB_SIGNING_ENGINE_OFF:
return true;
case SMB_SIGNING_ENGINE_BSRSPYL:
+ return true;
+
case SMB_SIGNING_ENGINE_ON:
{
if (req->in.size < (HDR_SS_FIELD + 8)) {
dump_data_pw("Started Signing with key:\n", sign_info->mac_key.data, sign_info->mac_key.length);
sign_info->signing_state = SMB_SIGNING_ENGINE_ON;
+ sign_info->next_seq_num = 2;
return true;
}
NTSTATUS resolve_name_bcast_recv(struct composite_context *c,
TALLOC_CTX *mem_ctx, const char **reply_addr)
{
- return resolve_name_nbtlist_recv(c, mem_ctx, reply_addr);
+ NTSTATUS status = resolve_name_nbtlist_recv(c, mem_ctx, reply_addr);
+ if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
+ /* this makes much more sense for a bcast name resolution
+ timeout */
+ status = NT_STATUS_OBJECT_NAME_NOT_FOUND;
+ }
+ return status;
}
/*
#include "system/network.h"
#include "lib/socket/netif.h"
#include "librpc/gen_ndr/ndr_nbt.h"
-#include "libcli/nbt/libnbt.h"
+#include "../libcli/nbt/libnbt.h"
#include "param/param.h"
struct nbtlist_state {
*/
static void nbtlist_handler(struct nbt_name_request *req)
{
- struct composite_context *c = talloc_get_type(req->async.private,
+ struct composite_context *c = talloc_get_type(req->async.private_data,
struct composite_context);
struct nbtlist_state *state = talloc_get_type(c->private_data, struct nbtlist_state);
struct nbt_name_query *q;
if (composite_nomem(state->queries[i], c)) return c;
state->queries[i]->async.fn = nbtlist_handler;
- state->queries[i]->async.private = c;
+ state->queries[i]->async.private_data = c;
}
return c;
}
state->method = ctx->methods;
+ if (state->method == NULL) {
+ composite_error(c, NT_STATUS_BAD_NETWORK_NAME);
+ return c;
+ }
state->creq = setup_next_method(c);
if (composite_nomem(state->creq, c)) return c;
#ifndef __RESOLVE_H__
#define __RESOLVE_H__
-#include "libcli/nbt/libnbt.h"
+#include "../libcli/nbt/libnbt.h"
typedef struct composite_context *(*resolve_name_send_fn)(TALLOC_CTX *mem_ctx, struct event_context *, void *privdata, struct nbt_name *);
typedef NTSTATUS (*resolve_name_recv_fn)(struct composite_context *, TALLOC_CTX *, const char **);
#include "libcli/resolve/proto.h"
*/
#include "includes.h"
-#include "libcli/nbt/libnbt.h"
+#include "../libcli/nbt/libnbt.h"
#include "libcli/resolve/resolve.h"
#include "param/param.h"
#include "lib/socket/netif.h"
granted |= SEC_STD_DELETE;
}
+ if (sd->dacl == NULL) {
+ return granted & ~denied;
+ }
+
for (i = 0;i<sd->dacl->num_aces; i++) {
struct security_ace *ace = &sd->dacl->aces[i];
return NT_STATUS_OK;
}
- /* empty dacl denies access */
+#if 0
+ /* tridge: previously we had empty dacl denying access, but
+ that can lead to undeletable directories, where
+ nobody can change the ACL on a directory */
if (sd->dacl == NULL || sd->dacl->num_aces == 0) {
return NT_STATUS_ACCESS_DENIED;
}
+#endif
/* the owner always gets SEC_STD_WRITE_DAC, SEC_STD_READ_CONTROL and SEC_STD_DELETE */
if ((bits_remaining & (SEC_STD_WRITE_DAC|SEC_STD_READ_CONTROL|SEC_STD_DELETE)) &&
bits_remaining &= ~SEC_STD_DELETE;
}
+ if (sd->dacl == NULL) {
+ goto done;
+ }
+
/* check each ace in turn. */
for (i=0; bits_remaining && i < sd->dacl->num_aces; i++) {
struct security_ace *ace = &sd->dacl->aces[i];
}
}
+done:
if (bits_remaining != 0) {
return NT_STATUS_ACCESS_DENIED;
}
typedef struct security_descriptor security_descriptor;
%}
-%import "../../lib/talloc/talloc.i"
-%import "../util/errors.i"
+%import "../lib/talloc/talloc.i"
+%include "../util/errors.i"
%import "stdint.i"
enum sec_privilege {
%talloctype(dom_sid);
typedef struct dom_sid {
+ %immutable;
+ uint8_t sid_rev_num;
+ int8_t num_auths;/* [range(0,15)] */
+ uint8_t id_auth[6];
+ uint32_t *sub_auths;
+ %mutable;
%extend {
dom_sid(TALLOC_CTX *mem_ctx, const char *text) {
return dom_sid_parse_talloc(mem_ctx, text);
#endif
bool equal(const struct dom_sid *other);
}
+%pythoncode {
+ def __repr__(self):
+ return "Sid(%r)" % str(self)
+}
} dom_sid;
%feature("docstring") random_sid "random_sid() -> sid\n" \
# This file was automatically generated by SWIG (http://www.swig.org).
-# Version 1.3.35
+# Version 1.3.36
#
# Don't modify this file, modify the SWIG interface instead.
class Sid(object):
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
+ sid_rev_num = _swig_property(_security.Sid_sid_rev_num_get)
+ num_auths = _swig_property(_security.Sid_num_auths_get)
+ id_auth = _swig_property(_security.Sid_id_auth_get)
+ sub_auths = _swig_property(_security.Sid_sub_auths_get)
def __init__(self, *args, **kwargs):
_security.Sid_swiginit(self,_security.new_Sid(*args, **kwargs))
+ def __repr__(self):
+ return "Sid(%r)" % str(self)
+
__swig_destroy__ = _security.delete_Sid
Sid.__str__ = new_instancemethod(_security.Sid___str__,None,Sid)
Sid.__eq__ = new_instancemethod(_security.Sid___eq__,None,Sid)
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
- * Version 1.3.35
+ * Version 1.3.36
*
* This file is not intended to be easily readable and contains a number of
* coding conventions designed to improve portability and efficiency. Do not make
# endif
#endif
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+# pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
# define SWIGUNUSEDPARM(p)
#define SWIG_name "_security"
-#define SWIGVERSION 0x010335
+#define SWIGVERSION 0x010336
#define SWIG_VERSION SWIGVERSION
typedef struct security_descriptor security_descriptor;
+#include "libcli/util/pyerrors.h"
+
+
#define SWIG_From_long PyInt_FromLong
SWIGINTERN security_descriptor *new_security_descriptor(TALLOC_CTX *mem_ctx){ return security_descriptor_initialise(mem_ctx); }
SWIGINTERN void delete_security_descriptor(security_descriptor *self){ talloc_free(self); }
+SWIGINTERNINLINE PyObject*
+SWIG_From_unsigned_SS_long (unsigned long value)
+{
+ return (value > LONG_MAX) ?
+ PyLong_FromUnsignedLong(value) : PyInt_FromLong((long)(value));
+}
+
+
+SWIGINTERNINLINE PyObject *
+SWIG_From_unsigned_SS_char (unsigned char value)
+{
+ return SWIG_From_unsigned_SS_long (value);
+}
+
+
+SWIGINTERNINLINE PyObject *
+SWIG_From_signed_SS_char (signed char value)
+{
+ return SWIG_From_long (value);
+}
+
+
SWIGINTERN swig_type_info*
SWIG_pchar_descriptor(void)
{
PyObject *resultobj = 0;
security_token *arg1 = (security_token *) 0 ;
struct dom_sid *arg2 = (struct dom_sid *) 0 ;
- bool result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
char * kwnames[] = {
(char *) "self",(char *) "sid", NULL
};
+ bool result;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SecurityToken_is_sid",kwnames,&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_token, 0 | 0 );
SWIGINTERN PyObject *_wrap_SecurityToken_is_system(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
security_token *arg1 = (security_token *) 0 ;
- bool result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
+ bool result;
if (!args) SWIG_fail;
swig_obj[0] = args;
SWIGINTERN PyObject *_wrap_SecurityToken_is_anonymous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
security_token *arg1 = (security_token *) 0 ;
- bool result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
+ bool result;
if (!args) SWIG_fail;
swig_obj[0] = args;
PyObject *resultobj = 0;
security_token *arg1 = (security_token *) 0 ;
struct dom_sid *arg2 = (struct dom_sid *) 0 ;
- bool result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
char * kwnames[] = {
(char *) "self",(char *) "sid", NULL
};
+ bool result;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SecurityToken_has_sid",kwnames,&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_token, 0 | 0 );
SWIGINTERN PyObject *_wrap_SecurityToken_has_builtin_administrators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
security_token *arg1 = (security_token *) 0 ;
- bool result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
+ bool result;
if (!args) SWIG_fail;
swig_obj[0] = args;
SWIGINTERN PyObject *_wrap_SecurityToken_has_nt_authenticated_users(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
security_token *arg1 = (security_token *) 0 ;
- bool result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
+ bool result;
if (!args) SWIG_fail;
swig_obj[0] = args;
PyObject *resultobj = 0;
security_token *arg1 = (security_token *) 0 ;
enum sec_privilege arg2 ;
- bool result;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
char * kwnames[] = {
(char *) "self",(char *) "privilege", NULL
};
+ bool result;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SecurityToken_has_privilege",kwnames,&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_token, 0 | 0 );
}
arg1 = (security_token *)(argp1);
delete_security_token(arg1);
-
resultobj = SWIG_Py_Void();
return resultobj;
fail:
PyObject *resultobj = 0;
security_descriptor *arg1 = (security_descriptor *) 0 ;
struct security_ace *arg2 = (struct security_ace *) 0 ;
- NTSTATUS result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
char * kwnames[] = {
(char *) "self",(char *) "ace", NULL
};
+ NTSTATUS result;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:security_descriptor_sacl_add",kwnames,&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_descriptor, 0 | 0 );
arg2 = (struct security_ace *)(argp2);
result = security_descriptor_sacl_add(arg1,(struct security_ace const *)arg2);
if (NT_STATUS_IS_ERR(result)) {
- PyObject *obj = Py_BuildValue((char *)"(i,s)", NT_STATUS_V(result), nt_errstr(result));
- PyErr_SetObject(PyExc_RuntimeError, obj);
+ PyErr_SetNTSTATUS(result);
SWIG_fail;
} else if (resultobj == NULL) {
resultobj = Py_None;
PyObject *resultobj = 0;
security_descriptor *arg1 = (security_descriptor *) 0 ;
struct security_ace *arg2 = (struct security_ace *) 0 ;
- NTSTATUS result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
char * kwnames[] = {
(char *) "self",(char *) "ace", NULL
};
+ NTSTATUS result;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:security_descriptor_dacl_add",kwnames,&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_descriptor, 0 | 0 );
arg2 = (struct security_ace *)(argp2);
result = security_descriptor_dacl_add(arg1,(struct security_ace const *)arg2);
if (NT_STATUS_IS_ERR(result)) {
- PyObject *obj = Py_BuildValue((char *)"(i,s)", NT_STATUS_V(result), nt_errstr(result));
- PyErr_SetObject(PyExc_RuntimeError, obj);
+ PyErr_SetNTSTATUS(result);
SWIG_fail;
} else if (resultobj == NULL) {
resultobj = Py_None;
PyObject *resultobj = 0;
security_descriptor *arg1 = (security_descriptor *) 0 ;
struct dom_sid *arg2 = (struct dom_sid *) 0 ;
- NTSTATUS result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
char * kwnames[] = {
(char *) "self",(char *) "trustee", NULL
};
+ NTSTATUS result;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:security_descriptor_dacl_del",kwnames,&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_descriptor, 0 | 0 );
arg2 = (struct dom_sid *)(argp2);
result = security_descriptor_dacl_del(arg1,(struct dom_sid const *)arg2);
if (NT_STATUS_IS_ERR(result)) {
- PyObject *obj = Py_BuildValue((char *)"(i,s)", NT_STATUS_V(result), nt_errstr(result));
- PyErr_SetObject(PyExc_RuntimeError, obj);
+ PyErr_SetNTSTATUS(result);
SWIG_fail;
} else if (resultobj == NULL) {
resultobj = Py_None;
PyObject *resultobj = 0;
security_descriptor *arg1 = (security_descriptor *) 0 ;
struct dom_sid *arg2 = (struct dom_sid *) 0 ;
- NTSTATUS result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
char * kwnames[] = {
(char *) "self",(char *) "trustee", NULL
};
+ NTSTATUS result;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:security_descriptor_sacl_del",kwnames,&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_descriptor, 0 | 0 );
arg2 = (struct dom_sid *)(argp2);
result = security_descriptor_sacl_del(arg1,(struct dom_sid const *)arg2);
if (NT_STATUS_IS_ERR(result)) {
- PyObject *obj = Py_BuildValue((char *)"(i,s)", NT_STATUS_V(result), nt_errstr(result));
- PyErr_SetObject(PyExc_RuntimeError, obj);
+ PyErr_SetNTSTATUS(result);
SWIG_fail;
} else if (resultobj == NULL) {
resultobj = Py_None;
PyObject *resultobj = 0;
security_descriptor *arg1 = (security_descriptor *) 0 ;
struct security_descriptor *arg2 = (struct security_descriptor *) 0 ;
- bool result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
char * kwnames[] = {
(char *) "self",(char *) "other", NULL
};
+ bool result;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:security_descriptor___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_security_descriptor, 0 | 0 );
}
arg1 = (security_descriptor *)(argp1);
delete_security_descriptor(arg1);
-
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return SWIG_Python_InitShadowInstance(args);
}
+SWIGINTERN PyObject *_wrap_Sid_sid_rev_num_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ dom_sid *arg1 = (dom_sid *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ uint8_t result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_dom_sid, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sid_sid_rev_num_get" "', argument " "1"" of type '" "dom_sid *""'");
+ }
+ arg1 = (dom_sid *)(argp1);
+ result = (uint8_t) ((arg1)->sid_rev_num);
+ resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Sid_num_auths_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ dom_sid *arg1 = (dom_sid *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ int8_t result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_dom_sid, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sid_num_auths_get" "', argument " "1"" of type '" "dom_sid *""'");
+ }
+ arg1 = (dom_sid *)(argp1);
+ result = (int8_t) ((arg1)->num_auths);
+ resultobj = SWIG_From_signed_SS_char((signed char)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Sid_id_auth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ dom_sid *arg1 = (dom_sid *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ uint8_t *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_dom_sid, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sid_id_auth_get" "', argument " "1"" of type '" "dom_sid *""'");
+ }
+ arg1 = (dom_sid *)(argp1);
+ result = (uint8_t *)(uint8_t *) ((arg1)->id_auth);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Sid_sub_auths_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ dom_sid *arg1 = (dom_sid *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ uint32_t *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_dom_sid, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sid_sub_auths_get" "', argument " "1"" of type '" "dom_sid *""'");
+ }
+ arg1 = (dom_sid *)(argp1);
+ result = (uint32_t *) ((arg1)->sub_auths);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
SWIGINTERN PyObject *_wrap_new_Sid(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
TALLOC_CTX *arg1 = (TALLOC_CTX *) 0 ;
char *arg2 = (char *) 0 ;
- dom_sid *result = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
char * kwnames[] = {
(char *) "text", NULL
};
+ dom_sid *result = 0 ;
arg1 = NULL;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Sid",kwnames,&obj0)) SWIG_fail;
PyObject *resultobj = 0;
dom_sid *arg1 = (dom_sid *) 0 ;
TALLOC_CTX *arg2 = (TALLOC_CTX *) 0 ;
- char *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
+ char *result = 0 ;
arg2 = NULL;
if (!args) SWIG_fail;
PyObject *resultobj = 0;
dom_sid *arg1 = (dom_sid *) 0 ;
struct dom_sid *arg2 = (struct dom_sid *) 0 ;
- bool result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
char * kwnames[] = {
(char *) "self",(char *) "other", NULL
};
+ bool result;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sid___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_dom_sid, 0 | 0 );
}
arg1 = (dom_sid *)(argp1);
delete_dom_sid(arg1);
-
resultobj = SWIG_Py_Void();
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_privilege_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
enum sec_privilege arg1 ;
- char *result = 0 ;
int val1 ;
int ecode1 = 0 ;
PyObject * obj0 = 0 ;
char * kwnames[] = {
(char *) "privilege", NULL
};
+ char *result = 0 ;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:privilege_name",kwnames,&obj0)) SWIG_fail;
ecode1 = SWIG_AsVal_int(obj0, &val1);
SWIGINTERN PyObject *_wrap_privilege_id(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
char *arg1 = (char *) 0 ;
- enum sec_privilege result;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
char * kwnames[] = {
(char *) "name", NULL
};
+ enum sec_privilege result;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:privilege_id",kwnames,&obj0)) SWIG_fail;
res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
{ (char *)"delete_security_descriptor", (PyCFunction)_wrap_delete_security_descriptor, METH_O, NULL},
{ (char *)"security_descriptor_swigregister", security_descriptor_swigregister, METH_VARARGS, NULL},
{ (char *)"security_descriptor_swiginit", security_descriptor_swiginit, METH_VARARGS, NULL},
+ { (char *)"Sid_sid_rev_num_get", (PyCFunction)_wrap_Sid_sid_rev_num_get, METH_O, NULL},
+ { (char *)"Sid_num_auths_get", (PyCFunction)_wrap_Sid_num_auths_get, METH_O, NULL},
+ { (char *)"Sid_id_auth_get", (PyCFunction)_wrap_Sid_id_auth_get, METH_O, NULL},
+ { (char *)"Sid_sub_auths_get", (PyCFunction)_wrap_Sid_sub_auths_get, METH_O, NULL},
{ (char *)"new_Sid", (PyCFunction) _wrap_new_Sid, METH_VARARGS | METH_KEYWORDS, NULL},
{ (char *)"Sid___str__", (PyCFunction)_wrap_Sid___str__, METH_O, NULL},
{ (char *)"Sid___eq__", (PyCFunction) _wrap_Sid___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
sid = security.random_sid()
self.assertTrue(str(sid).startswith("S-1-5-21-"))
+ def test_repr(self):
+ sid = security.random_sid()
+ self.assertTrue(repr(sid).startswith("Sid('S-1-5-21-"))
+
class PrivilegeTests(unittest.TestCase):
def test_privilege_name(self):
}
state->negprot.in.capabilities = 0;
unix_to_nt_time(&state->negprot.in.start_time, time(NULL));
- dialects[0] = 0;
- dialects[1] = SMB2_DIALECT_REVISION;
+ dialects[0] = SMB2_DIALECT_REVISION;
+ dialects[1] = 0;
state->negprot.in.dialects = dialects;
req = smb2_negprot_send(transport, &state->negprot);
struct smb2_connect_state *state = talloc_get_type(c->private_data,
struct smb2_connect_state);
const char *addr;
- const char *ports[2] = { "445", NULL };
+ const char **ports;
+ const char *default_ports[] = { "445", NULL };
+
+ ports = lp_parm_string_list(state, global_loadparm, NULL, "smb2", "ports", NULL);
+ if (ports == NULL) {
+ ports = default_ports;
+ }
c->status = resolve_name_recv(creq, state, &addr);
if (!composite_is_ok(c)) return;
{
uint16_t ofs, size;
if (smb2_oob(buf, ptr, 4)) {
- return NT_STATUS_BUFFER_TOO_SMALL;
+ return NT_STATUS_INVALID_PARAMETER;
}
ofs = SVAL(ptr, 0);
size = SVAL(ptr, 2);
return NT_STATUS_OK;
}
if (smb2_oob(buf, buf->hdr + ofs, size)) {
- return NT_STATUS_BUFFER_TOO_SMALL;
+ return NT_STATUS_INVALID_PARAMETER;
}
*blob = data_blob_talloc(mem_ctx, buf->hdr + ofs, size);
NT_STATUS_HAVE_NO_MEMORY(blob->data);
/* we have only 16 bit for the size */
if (blob.length > 0xFFFF) {
- return NT_STATUS_BUFFER_TOO_SMALL;
+ return NT_STATUS_INVALID_PARAMETER;
}
/* check if there're enough room for ofs and size */
if (smb2_oob(buf, ptr, 4)) {
- return NT_STATUS_BUFFER_TOO_SMALL;
+ return NT_STATUS_INVALID_PARAMETER;
}
if (blob.data == NULL) {
/* check if there're enough room for ofs and size */
if (smb2_oob(buf, ptr, 6)) {
- return NT_STATUS_BUFFER_TOO_SMALL;
+ return NT_STATUS_INVALID_PARAMETER;
}
if (blob.data == NULL) {
/* check if there're enough room for ofs and size */
if (smb2_oob(buf, ptr, 8)) {
- return NT_STATUS_BUFFER_TOO_SMALL;
+ return NT_STATUS_INVALID_PARAMETER;
}
if (blob.data == NULL) {
/* check if there're enough room for ofs and size */
if (smb2_oob(buf, ptr, 8)) {
- return NT_STATUS_BUFFER_TOO_SMALL;
+ return NT_STATUS_INVALID_PARAMETER;
}
if (blob.data == NULL) {
uint32_t size;
if (smb2_oob(buf, ptr, 6)) {
- return NT_STATUS_BUFFER_TOO_SMALL;
+ return NT_STATUS_INVALID_PARAMETER;
}
ofs = SVAL(ptr, 0);
size = IVAL(ptr, 2);
return NT_STATUS_OK;
}
if (smb2_oob(buf, buf->hdr + ofs, size)) {
- return NT_STATUS_BUFFER_TOO_SMALL;
+ return NT_STATUS_INVALID_PARAMETER;
}
*blob = data_blob_talloc(mem_ctx, buf->hdr + ofs, size);
NT_STATUS_HAVE_NO_MEMORY(blob->data);
{
uint32_t ofs, size;
if (smb2_oob(buf, ptr, 8)) {
- return NT_STATUS_BUFFER_TOO_SMALL;
+ return NT_STATUS_INVALID_PARAMETER;
}
ofs = IVAL(ptr, 0);
size = IVAL(ptr, 4);
return NT_STATUS_OK;
}
if (smb2_oob(buf, buf->hdr + ofs, size)) {
- return NT_STATUS_BUFFER_TOO_SMALL;
+ return NT_STATUS_INVALID_PARAMETER;
}
*blob = data_blob_talloc(mem_ctx, buf->hdr + ofs, size);
NT_STATUS_HAVE_NO_MEMORY(blob->data);
{
uint32_t ofs, size;
if (smb2_oob(buf, ptr, 8)) {
- return NT_STATUS_BUFFER_TOO_SMALL;
+ return NT_STATUS_INVALID_PARAMETER;
}
ofs = SVAL(ptr, 0);
size = IVAL(ptr, 4);
return NT_STATUS_OK;
}
if (smb2_oob(buf, buf->hdr + ofs, size)) {
- return NT_STATUS_BUFFER_TOO_SMALL;
+ return NT_STATUS_INVALID_PARAMETER;
}
*blob = data_blob_talloc(mem_ctx, buf->hdr + ofs, size);
NT_STATUS_HAVE_NO_MEMORY(blob->data);
{
uint32_t ofs, size;
if (smb2_oob(buf, ptr, 8)) {
- return NT_STATUS_BUFFER_TOO_SMALL;
+ return NT_STATUS_INVALID_PARAMETER;
}
size = IVAL(ptr, 0);
ofs = IVAL(ptr, 4);
return NT_STATUS_OK;
}
if (smb2_oob(buf, buf->hdr + ofs, size)) {
- return NT_STATUS_BUFFER_TOO_SMALL;
+ return NT_STATUS_INVALID_PARAMETER;
+ }
+ *blob = data_blob_talloc(mem_ctx, buf->hdr + ofs, size);
+ NT_STATUS_HAVE_NO_MEMORY(blob->data);
+ return NT_STATUS_OK;
+}
+
+/*
+ pull a uint32_t length/ uint16_t ofs/blob triple from a data blob
+ the ptr points to the start of the offset/length pair
+*/
+NTSTATUS smb2_pull_s32o16_blob(struct smb2_request_buffer *buf, TALLOC_CTX *mem_ctx, uint8_t *ptr, DATA_BLOB *blob)
+{
+ uint32_t ofs, size;
+ if (smb2_oob(buf, ptr, 8)) {
+ return NT_STATUS_INVALID_PARAMETER;
+ }
+ size = IVAL(ptr, 0);
+ ofs = SVAL(ptr, 4);
+ if (ofs == 0) {
+ *blob = data_blob(NULL, 0);
+ return NT_STATUS_OK;
+ }
+ if (smb2_oob(buf, buf->hdr + ofs, size)) {
+ return NT_STATUS_INVALID_PARAMETER;
}
*blob = data_blob_talloc(mem_ctx, buf->hdr + ofs, size);
NT_STATUS_HAVE_NO_MEMORY(blob->data);
#include "libcli/raw/libcliraw.h"
#include "libcli/smb2/smb2.h"
#include "libcli/smb2/smb2_calls.h"
-#include "lib/crypto/crypto.h"
+#include "../lib/crypto/crypto.h"
/*
sign an outgoing message
#define SMB2_MIN_SIZE 0x42
+#define SMB2_MIN_SIZE_NO_BODY 0x40
/* offsets into header elements for a sync SMB2 request */
#define SMB2_HDR_PROTOCOL_ID 0x00
}
ZERO_STRUCT(create_parm);
- create_parm.in.desired_access = SEC_FLAG_MAXIMUM_ALLOWED;
+ create_parm.in.desired_access = SEC_FILE_READ_DATA;
create_parm.in.share_access =
NTCREATEX_SHARE_ACCESS_READ|
NTCREATEX_SHARE_ACCESS_WRITE;
smb2_util_close(tree, create_parm.out.file.handle);
status = smb2_util_rmdir(tree, dname);
+ if (NT_STATUS_EQUAL(status, NT_STATUS_CANNOT_DELETE)) {
+ /* it could be read-only */
+ status = smb2_util_setatr(tree, dname, FILE_ATTRIBUTE_NORMAL);
+ status = smb2_util_rmdir(tree, dname);
+ }
+
if (NT_STATUS_IS_ERR(status)) {
DEBUG(2,("Failed to delete %s - %s\n",
dname, nt_errstr(status)));
NT_STATUS_NOT_OK_RETURN(status);
/* next step is a session setup */
- state->session = smbcli_session_init(state->transport, state, true);
+ state->session = smbcli_session_init(state->transport, state, true, io->in.session_options);
NT_STATUS_HAVE_NO_MEMORY(state->session);
/* setup for a tconx (or at least have the structure ready to
state->connect->in.workgroup = io->in.workgroup;
state->connect->in.options = io->in.options;
+ state->connect->in.session_options = io->in.session_options;
state->creq = smb_composite_connect_send(state->connect, state,
io->in.resolve_ctx, event_ctx);
composite fsinfo call - connects to a tree and queries a file system information
*/
struct composite_context *smb_composite_fsinfo_send(struct smbcli_tree *tree,
- struct smb_composite_fsinfo *io)
+ struct smb_composite_fsinfo *io,
+ struct resolve_context *resolve_ctx)
{
struct composite_context *c;
struct fsinfo_state *state;
state->connect->in.workgroup = io->in.workgroup;
state->connect->in.options = tree->session->transport->options;
+ state->connect->in.session_options = tree->session->options;
c->state = COMPOSITE_STATE_IN_PROGRESS;
state->stage = FSINFO_CONNECT;
c->private_data = state;
state->creq = smb_composite_connect_send(state->connect, state,
- lp_resolve_context(global_loadparm), c->event_ctx);
+ resolve_ctx, c->event_ctx);
if (state->creq == NULL) goto failed;
*/
NTSTATUS smb_composite_fsinfo(struct smbcli_tree *tree,
TALLOC_CTX *mem_ctx,
- struct smb_composite_fsinfo *io)
+ struct smb_composite_fsinfo *io,
+ struct resolve_context *resolve_ctx)
{
- struct composite_context *c = smb_composite_fsinfo_send(tree, io);
+ struct composite_context *c = smb_composite_fsinfo_send(tree, io, resolve_ctx);
return smb_composite_fsinfo_recv(c, mem_ctx);
}
struct sesssetup_state {
union smb_sesssetup setup;
+ NTSTATUS remote_status;
NTSTATUS gensec_status;
struct smb_composite_sesssetup *io;
struct smbcli_request *req;
DATA_BLOB session_key = data_blob(NULL, 0);
DATA_BLOB null_data_blob = data_blob(NULL, 0);
NTSTATUS session_key_err, nt_status;
+ struct smbcli_request *check_req = NULL;
- c->status = smb_raw_sesssetup_recv(req, state, &state->setup);
+ if (req->sign_caller_checks) {
+ req->do_not_free = true;
+ check_req = req;
+ }
+
+ state->remote_status = smb_raw_sesssetup_recv(req, state, &state->setup);
+ c->status = state->remote_status;
state->req = NULL;
+ /*
+ * we only need to check the signature if the
+ * NT_STATUS_OK is returned
+ */
+ if (!NT_STATUS_IS_OK(state->remote_status)) {
+ talloc_free(check_req);
+ check_req = NULL;
+ }
+
switch (state->setup.old.level) {
case RAW_SESSSETUP_OLD:
state->io->out.vuid = state->setup.old.out.vuid;
state->io,
&state->req);
if (NT_STATUS_IS_OK(nt_status)) {
+ talloc_free(check_req);
c->status = nt_status;
composite_continue_smb(c, state->req, request_handler, c);
return;
state->io,
&state->req);
if (NT_STATUS_IS_OK(nt_status)) {
+ talloc_free(check_req);
c->status = nt_status;
composite_continue_smb(c, state->req, request_handler, c);
return;
state->io,
&state->req);
if (NT_STATUS_IS_OK(nt_status)) {
+ talloc_free(check_req);
c->status = nt_status;
composite_continue_smb(c, state->req, request_handler, c);
return;
state->setup.spnego.in.secblob = data_blob(NULL, 0);
}
- /* we need to do another round of session setup. We keep going until both sides
- are happy */
- session_key_err = gensec_session_key(session->gensec, &session_key);
- if (NT_STATUS_IS_OK(session_key_err)) {
- set_user_session_key(session, &session_key);
- smbcli_transport_simple_set_signing(session->transport, session_key, null_data_blob);
+ if (NT_STATUS_IS_OK(state->remote_status)) {
+ if (state->setup.spnego.in.secblob.length) {
+ c->status = NT_STATUS_INTERNAL_ERROR;
+ break;
+ }
+ session_key_err = gensec_session_key(session->gensec, &session_key);
+ if (NT_STATUS_IS_OK(session_key_err)) {
+ set_user_session_key(session, &session_key);
+ smbcli_transport_simple_set_signing(session->transport, session_key, null_data_blob);
+ }
}
if (state->setup.spnego.in.secblob.length) {
session->vuid = state->io->out.vuid;
state->req = smb_raw_sesssetup_send(session, &state->setup);
session->vuid = vuid;
+ if (state->req) {
+ state->req->sign_caller_checks = true;
+ }
composite_continue_smb(c, state->req, request_handler, c);
return;
}
break;
}
+ if (check_req) {
+ check_req->sign_caller_checks = false;
+ if (!smbcli_request_check_sign_mac(check_req)) {
+ c->status = NT_STATUS_ACCESS_DENIED;
+ }
+ talloc_free(check_req);
+ check_req = NULL;
+ }
+
/* enforce the local signing required flag */
if (NT_STATUS_IS_OK(c->status) && !cli_credentials_is_anonymous(state->io->in.credentials)) {
if (!session->transport->negotiate.sign_info.doing_signing
struct smb_composite_sesssetup *io,
struct smbcli_request **req)
{
- NTSTATUS nt_status;
+ NTSTATUS nt_status = NT_STATUS_INTERNAL_ERROR;
struct sesssetup_state *state = talloc_get_type(c->private_data, struct sesssetup_state);
DATA_BLOB names_blob = NTLMv2_generate_names_blob(state, lp_iconv_convenience(global_loadparm), session->transport->socket->hostname, lp_workgroup(global_loadparm));
- DATA_BLOB session_key;
+ DATA_BLOB session_key = data_blob(NULL, 0);
int flags = CLI_CRED_NTLM_AUTH;
+
+ smbcli_temp_set_signing(session->transport);
+
if (session->options.lanman_auth) {
flags |= CLI_CRED_LANMAN_AUTH;
}
&state->setup.nt1.in.password2,
NULL, &session_key);
NT_STATUS_NOT_OK_RETURN(nt_status);
-
- smbcli_transport_simple_set_signing(session->transport, session_key,
- state->setup.nt1.in.password2);
- set_user_session_key(session, &session_key);
-
- data_blob_free(&session_key);
} else if (session->options.plaintext_auth) {
const char *password = cli_credentials_get_password(io->in.credentials);
state->setup.nt1.in.password1 = data_blob_talloc(state, password, strlen(password));
if (!*req) {
return NT_STATUS_NO_MEMORY;
}
+
+ if (NT_STATUS_IS_OK(nt_status)) {
+ smbcli_transport_simple_set_signing(session->transport, session_key,
+ state->setup.nt1.in.password2);
+ set_user_session_key(session, &session_key);
+
+ data_blob_free(&session_key);
+ }
+
return (*req)->status;
}
struct smbcli_request **req)
{
struct sesssetup_state *state = talloc_get_type(c->private_data, struct sesssetup_state);
- NTSTATUS status, session_key_err;
- DATA_BLOB session_key = data_blob(NULL, 0);
- DATA_BLOB null_data_blob = data_blob(NULL, 0);
+ NTSTATUS status;
const char *chosen_oid = NULL;
state->setup.spnego.level = RAW_SESSSETUP_SPNEGO;
}
state->gensec_status = status;
- session_key_err = gensec_session_key(session->gensec, &session_key);
- if (NT_STATUS_IS_OK(session_key_err)) {
- smbcli_transport_simple_set_signing(session->transport, session_key, null_data_blob);
- }
-
*req = smb_raw_sesssetup_send(session, &state->setup);
if (!*req) {
return NT_STATUS_NO_MEMORY;
}
+
+ /*
+ * we need to check the signature ourself
+ * as the session key might be the acceptor subkey
+ * which comes within the response itself
+ */
+ (*req)->sign_caller_checks = true;
+
return (*req)->status;
}
const char *workgroup;
const char *filename;
struct smbcli_options options;
+ struct smbcli_session_options session_options;
struct resolve_context *resolve_ctx;
} in;
struct {
bool fallback_to_anonymous;
const char *workgroup;
struct smbcli_options options;
+ struct smbcli_session_options session_options;
} in;
struct {
struct smbcli_tree *tree;
%module libcli_smb
-%import "../../lib/talloc/talloc.i"
+%import "../../../lib/talloc/talloc.i"
%import "../../lib/events/events.i"
%{
# This file was automatically generated by SWIG (http://www.swig.org).
-# Version 1.3.35
+# Version 1.3.36
#
# Don't modify this file, modify the SWIG interface instead.
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
- * Version 1.3.35
+ * Version 1.3.36
*
* This file is not intended to be easily readable and contains a number of
* coding conventions designed to improve portability and efficiency. Do not make
# endif
#endif
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+# pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
# define SWIGUNUSEDPARM(p)
#define SWIG_name "_libcli_smb"
-#define SWIGVERSION 0x010335
+#define SWIGVERSION 0x010336
#define SWIG_VERSION SWIGVERSION
TALLOC_CTX *arg3 = (TALLOC_CTX *) 0 ;
struct resolve_context *arg4 = (struct resolve_context *) 0 ;
struct event_context *arg5 = (struct event_context *) 0 ;
- struct smbcli_socket *result = 0 ;
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
char * kwnames[] = {
(char *) "host",(char *) "ports",(char *) "resolve_ctx",(char *) "event_ctx", NULL
};
+ struct smbcli_socket *result = 0 ;
- arg5 = s4_event_context_init(NULL);
+ arg5 = event_context_init(NULL);
arg3 = NULL;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:smbcli_sock_connect_byname",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
c->status = cldap_netlogon_recv(req, s, &s->cldap.io);
if (!composite_is_ok(c)) return;
- s->cldap.netlogon = s->cldap.io.out.netlogon.nt5_ex;
+ s->cldap.netlogon = s->cldap.io.out.netlogon.data.nt5_ex;
s->domain.dns_name = s->cldap.netlogon.dns_domain;
s->domain.netbios_name = s->cldap.netlogon.domain;
basedn = ldb_dn_new(s, s->ldap1.ldb, NULL);
NT_STATUS_HAVE_NO_MEMORY(basedn);
- ret = ldb_search(s->ldap1.ldb, basedn, LDB_SCOPE_BASE,
- "(objectClass=*)", attrs, &r);
+ ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_BASE, attrs,
+ "(objectClass=*)");
talloc_free(basedn);
if (ret != LDB_SUCCESS) {
return NT_STATUS_LDAP(ret);
talloc_free(r);
return NT_STATUS_INVALID_NETWORK_RESPONSE;
}
- talloc_steal(s, r);
s->ldap1.rootdse = r->msgs[0];
basedn = ldb_dn_new(s, s->ldap1.ldb, s->forest.config_dn_str);
NT_STATUS_HAVE_NO_MEMORY(basedn);
- ret = ldb_search(s->ldap1.ldb, basedn, LDB_SCOPE_ONELEVEL,
- "(cn=Partitions)", attrs, &r);
+ ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_ONELEVEL, attrs,
+ "(cn=Partitions)");
talloc_free(basedn);
if (ret != LDB_SUCCESS) {
return NT_STATUS_LDAP(ret);
basedn = ldb_dn_new(s, s->ldap1.ldb, s->domain.dn_str);
NT_STATUS_HAVE_NO_MEMORY(basedn);
- ret = ldb_search(s->ldap1.ldb, basedn, LDB_SCOPE_BASE,
- "(objectClass=*)", attrs, &r);
+ ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_BASE, attrs,
+ "(objectClass=*)");
talloc_free(basedn);
if (ret != LDB_SUCCESS) {
return NT_STATUS_LDAP(ret);
basedn = ldb_dn_new(s, s->ldap1.ldb, s->forest.schema_dn_str);
NT_STATUS_HAVE_NO_MEMORY(basedn);
- ret = ldb_search(s->ldap1.ldb, basedn, LDB_SCOPE_BASE,
- "(objectClass=*)", attrs, &r);
+ ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_BASE, attrs,
+ "(objectClass=*)");
talloc_free(basedn);
if (ret != LDB_SUCCESS) {
return NT_STATUS_LDAP(ret);
s->domain.dn_str);
NT_STATUS_HAVE_NO_MEMORY(basedn);
- ret = ldb_search(s->ldap1.ldb, basedn, LDB_SCOPE_BASE,
- "(objectClass=*)", attrs, &r);
+ ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_BASE, attrs,
+ "(objectClass=*)");
talloc_free(basedn);
if (ret == LDB_ERR_NO_SUCH_OBJECT) {
/* w2k doesn't have this object */
s->domain.dn_str);
NT_STATUS_HAVE_NO_MEMORY(basedn);
- ret = ldb_search(s->ldap1.ldb, basedn, LDB_SCOPE_BASE,
- "(objectClass=*)", _1_1_attrs, &r);
+ ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_BASE,
+ _1_1_attrs, "(objectClass=*)");
talloc_free(basedn);
if (ret != LDB_SUCCESS) {
return NT_STATUS_LDAP(ret);
basedn = talloc_steal(s, r->msgs[0]->dn);
talloc_free(r);
- ret = ldb_search(s->ldap1.ldb, basedn, LDB_SCOPE_BASE,
- "(objectClass=*)", fsmo_attrs, &r);
+ ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_BASE,
+ fsmo_attrs, "(objectClass=*)");
talloc_free(basedn);
if (ret != LDB_SUCCESS) {
return NT_STATUS_LDAP(ret);
s->infrastructure_fsmo.server_dn_str = ldb_dn_alloc_linearized(s, server_dn);
NT_STATUS_HAVE_NO_MEMORY(s->infrastructure_fsmo.server_dn_str);
- ret = ldb_search(s->ldap1.ldb, server_dn, LDB_SCOPE_BASE,
- "(objectClass=*)", dns_attrs, &r);
+ ret = ldb_search(s->ldap1.ldb, s, &r, server_dn, LDB_SCOPE_BASE,
+ dns_attrs, "(objectClass=*)");
if (ret != LDB_SUCCESS) {
return NT_STATUS_LDAP(ret);
} else if (r->count != 1) {
talloc_free(r);
- ret = ldb_search(s->ldap1.ldb, ntds_dn, LDB_SCOPE_BASE,
- "(objectClass=*)", guid_attrs, &r);
+ ret = ldb_search(s->ldap1.ldb, s, &r, ntds_dn, LDB_SCOPE_BASE,
+ guid_attrs, "(objectClass=*)");
if (ret != LDB_SUCCESS) {
return NT_STATUS_LDAP(ret);
} else if (r->count != 1) {
basedn = ldb_dn_new(s, s->ldap1.ldb, s->domain.dn_str);
NT_STATUS_HAVE_NO_MEMORY(basedn);
- ret = ldb_search(s->ldap1.ldb, basedn, LDB_SCOPE_BASE,
- "(objectClass=*)", rid_attrs, &r);
+ ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_BASE,
+ rid_attrs, "(objectClass=*)");
talloc_free(basedn);
if (ret != LDB_SUCCESS) {
return NT_STATUS_LDAP(ret);
talloc_free(r);
- ret = ldb_search(s->ldap1.ldb, basedn, LDB_SCOPE_BASE,
- "(objectClass=*)", fsmo_attrs, &r);
+ ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_BASE,
+ fsmo_attrs, "(objectClass=*)");
talloc_free(basedn);
if (ret != LDB_SUCCESS) {
return NT_STATUS_LDAP(ret);
s->rid_manager_fsmo.server_dn_str = ldb_dn_alloc_linearized(s, server_dn);
NT_STATUS_HAVE_NO_MEMORY(s->rid_manager_fsmo.server_dn_str);
- ret = ldb_search(s->ldap1.ldb, server_dn, LDB_SCOPE_BASE,
- "(objectClass=*)", dns_attrs, &r);
+ ret = ldb_search(s->ldap1.ldb, s, &r, server_dn, LDB_SCOPE_BASE,
+ dns_attrs, "(objectClass=*)");
if (ret != LDB_SUCCESS) {
return NT_STATUS_LDAP(ret);
} else if (r->count != 1) {
talloc_free(r);
- ret = ldb_search(s->ldap1.ldb, ntds_dn, LDB_SCOPE_BASE,
- "(objectClass=*)", guid_attrs, &r);
+ ret = ldb_search(s->ldap1.ldb, s, &r, ntds_dn, LDB_SCOPE_BASE,
+ guid_attrs, "(objectClass=*)");
if (ret != LDB_SUCCESS) {
return NT_STATUS_LDAP(ret);
} else if (r->count != 1) {
s->forest.config_dn_str);
NT_STATUS_HAVE_NO_MEMORY(basedn);
- ret = ldb_search(s->ldap1.ldb, basedn, LDB_SCOPE_BASE,
- "(objectClass=*)", NULL, &r);
+ ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_BASE,
+ NULL, "(objectClass=*)");
talloc_free(basedn);
if (ret != LDB_SUCCESS) {
return NT_STATUS_LDAP(ret);
int ret;
struct ldb_result *r;
struct ldb_dn *basedn;
- char *filter;
static const char *attrs[] = {
"distinguishedName",
"userAccountControl",
basedn = ldb_dn_new(s, s->ldap1.ldb, s->domain.dn_str);
NT_STATUS_HAVE_NO_MEMORY(basedn);
- filter = talloc_asprintf(basedn, "(&(|(objectClass=user)(objectClass=computer))(sAMAccountName=%s$))",
- s->dest_dsa.netbios_name);
- NT_STATUS_HAVE_NO_MEMORY(filter);
-
- ret = ldb_search(s->ldap1.ldb, basedn, LDB_SCOPE_SUBTREE,
- filter, attrs, &r);
+ ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_SUBTREE, attrs,
+ "(&(|(objectClass=user)(objectClass=computer))(sAMAccountName=%s$))",
+ s->dest_dsa.netbios_name);
talloc_free(basedn);
if (ret != LDB_SUCCESS) {
return NT_STATUS_LDAP(ret);
s->forest.config_dn_str);
NT_STATUS_HAVE_NO_MEMORY(basedn);
- ret = ldb_search(s->ldap1.ldb, basedn, LDB_SCOPE_BASE,
- "(objectClass=*)", NULL, &r);
+ ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_BASE,
+ NULL, "(objectClass=*)");
talloc_free(basedn);
if (ret == LDB_ERR_NO_SUCH_OBJECT) {
/* if the object doesn't exist, we'll create it later */
basedn = ldb_dn_new(s, s->ldap1.ldb, s->dest_dsa.computer_dn_str);
NT_STATUS_HAVE_NO_MEMORY(basedn);
- ret = ldb_search(s->ldap1.ldb, basedn, LDB_SCOPE_BASE,
- "(objectClass=*)", attrs, &r);
+ ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_BASE,
+ attrs, "(objectClass=*)");
talloc_free(basedn);
if (ret != LDB_SUCCESS) {
return NT_STATUS_LDAP(ret);
s->domain.dn_str);
NT_STATUS_HAVE_NO_MEMORY(basedn);
- ret = ldb_search(s->ldap2.ldb, basedn, LDB_SCOPE_BASE,
- "(objectClass=*)", _1_1_attrs, &r);
+ ret = ldb_search(s->ldap2.ldb, s, &r, basedn, LDB_SCOPE_BASE,
+ _1_1_attrs, "(objectClass=*)");
talloc_free(basedn);
if (ret != LDB_SUCCESS) {
return NT_STATUS_LDAP(ret);
}
/* search for the user's record */
- ret = ldb_search(remote_ldb, account_dn, LDB_SCOPE_BASE,
- NULL, attrs, &res);
+ ret = ldb_search(remote_ldb, tmp_ctx, &res,
+ account_dn, LDB_SCOPE_BASE, attrs, NULL);
if (ret != LDB_SUCCESS) {
r->out.error_string = talloc_asprintf(r, "ldb_search for %s failed - %s",
account_dn_str, ldb_errstring(remote_ldb));
return NT_STATUS_UNSUCCESSFUL;
}
- talloc_steal(tmp_ctx, res);
-
if (res->count != 1) {
r->out.error_string = talloc_asprintf(r, "ldb_search for %s failed - found %d entries",
account_dn_str, res->count);
#include "includes.h"
#include "libnet/libnet.h"
-#include "lib/crypto/crypto.h"
+#include "../lib/crypto/crypto.h"
#include "libcli/auth/libcli_auth.h"
#include "librpc/gen_ndr/ndr_samr_c.h"
return NT_STATUS_OK;
}
+struct libnet_samdump_keytab_data {
+ const char *keytab_name;
+ struct loadparm_context *lp_ctx;
+};
+
static NTSTATUS libnet_samdump_keytab_fn(TALLOC_CTX *mem_ctx,
void *private,
enum netr_SamDatabaseID database,
char **error_string)
{
NTSTATUS nt_status = NT_STATUS_OK;
- const char *keytab_name = private;
-
+ struct libnet_samdump_keytab_data *data = private;
*error_string = NULL;
switch (delta->delta_type) {
case NETR_DELTA_USER:
if (database == SAM_DATABASE_DOMAIN) {
nt_status = samdump_keytab_handle_user(mem_ctx,
event_context_find(mem_ctx),
- global_loadparm,
- keytab_name,
+ data->lp_ctx,
+ data->keytab_name,
delta);
break;
}
NTSTATUS libnet_SamDump_keytab(struct libnet_context *ctx, TALLOC_CTX *mem_ctx, struct libnet_SamDump_keytab *r)
{
NTSTATUS nt_status;
+ struct libnet_samdump_keytab_data data;
struct libnet_SamSync r2;
+ data.keytab_name = r->in.keytab_name;
+ data.lp_ctx = ctx->lp_ctx;
+
r2.out.error_string = NULL;
r2.in.binding_string = r->in.binding_string;
r2.in.rid_crypt = true;
r2.in.init_fn = NULL;
r2.in.delta_fn = libnet_samdump_keytab_fn;
- r2.in.fn_ctx = discard_const(r->in.keytab_name);
+ r2.in.fn_ctx = &data;
r2.in.machine_account = r->in.machine_account;
nt_status = libnet_SamSync_netlogon(ctx, mem_ctx, &r2);
r->out.error_string = r2.out.error_string;
search.in.version = NETLOGON_NT_VERSION_5 | NETLOGON_NT_VERSION_5EX;
search.in.map_response = true;
- cldap = cldap_socket_init(tmp_ctx, lctx->event_ctx, lp_iconv_convenience(global_loadparm));
+ cldap = cldap_socket_init(tmp_ctx, lctx->event_ctx, lp_iconv_convenience(lctx->lp_ctx));
status = cldap_netlogon(cldap, tmp_ctx, &search);
- if (!NT_STATUS_IS_OK(status) || !search.out.netlogon.nt5_ex.client_site) {
+ if (!NT_STATUS_IS_OK(status)
+ || !search.out.netlogon.data.nt5_ex.client_site) {
/*
If cldap_netlogon() returns in error,
default to using Default-First-Site-Name.
}
} else {
site_name_str = talloc_asprintf(tmp_ctx, "%s",
- search.out.netlogon.nt5_ex.client_site);
+ search.out.netlogon.data.nt5_ex.client_site);
if (!site_name_str) {
r->out.error_string = NULL;
talloc_free(tmp_ctx);
c->status = cldap_netlogon_recv(req, s, &s->cldap.io);
if (!composite_is_ok(c)) return;
- s->cldap.netlogon = s->cldap.io.out.netlogon.nt5_ex;
+ s->cldap.netlogon = s->cldap.io.out.netlogon.data.nt5_ex;
s->domain.dns_name = s->cldap.netlogon.dns_domain;
s->domain.netbios_name = s->cldap.netlogon.domain;
basedn = ldb_dn_new(s, s->ldap.ldb, NULL);
NT_STATUS_HAVE_NO_MEMORY(basedn);
- ret = ldb_search(s->ldap.ldb, basedn, LDB_SCOPE_BASE,
- "(objectClass=*)", attrs, &r);
+ ret = ldb_search(s->ldap.ldb, s, &r, basedn, LDB_SCOPE_BASE, attrs,
+ "(objectClass=*)");
talloc_free(basedn);
if (ret != LDB_SUCCESS) {
return NT_STATUS_LDAP(ret);
talloc_free(r);
return NT_STATUS_INVALID_NETWORK_RESPONSE;
}
- talloc_steal(s, r);
s->domain.dn_str = ldb_msg_find_attr_as_string(r->msgs[0], "defaultNamingContext", NULL);
if (!s->domain.dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
int ret;
struct ldb_result *r;
struct ldb_dn *basedn;
- char *filter;
static const char *attrs[] = {
"distinguishedName",
"userAccountControl",
basedn = ldb_dn_new(s, s->ldap.ldb, s->domain.dn_str);
NT_STATUS_HAVE_NO_MEMORY(basedn);
- filter = talloc_asprintf(basedn, "(&(|(objectClass=user)(objectClass=computer))(sAMAccountName=%s$))",
- s->dest_dsa.netbios_name);
- NT_STATUS_HAVE_NO_MEMORY(filter);
-
- ret = ldb_search(s->ldap.ldb, basedn, LDB_SCOPE_SUBTREE,
- filter, attrs, &r);
+ ret = ldb_search(s->ldap.ldb, s, &r, basedn, LDB_SCOPE_SUBTREE, attrs,
+ "(&(|(objectClass=user)(objectClass=computer))(sAMAccountName=%s$))",
+ s->dest_dsa.netbios_name);
talloc_free(basedn);
if (ret != LDB_SUCCESS) {
return NT_STATUS_LDAP(ret);
s->domain.dn_str);
NT_STATUS_HAVE_NO_MEMORY(basedn);
- ret = ldb_search(s->ldap.ldb, basedn, LDB_SCOPE_BASE,
- "(objectClass=*)", _1_1_attrs, &r);
+ ret = ldb_search(s->ldap.ldb, s, &r, basedn, LDB_SCOPE_BASE,
+ _1_1_attrs, "(objectClass=*)");
talloc_free(basedn);
if (ret != LDB_SUCCESS) {
return NT_STATUS_LDAP(ret);
r->in.level = 1;
r->in.req.req1.server_dn= s->dest_dsa.server_dn_str;
r->in.req.req1.domain_dn= s->domain.dn_str;
- r->in.req.req1.unknown = 0x00000001;
+ r->in.req.req1.commit = true;
req = dcerpc_drsuapi_DsRemoveDSServer_send(s->drsuapi.pipe, s, r);
composite_continue_rpc(c, req, unbecomeDC_drsuapi_remove_ds_server_recv, s);
composite_error(c, NT_STATUS_INVALID_NETWORK_RESPONSE);
return;
}
-
- if (!W_ERROR_IS_OK(r->out.res.res1.status)) {
- composite_error(c, werror_to_ntstatus(r->out.res.res1.status));
- return;
- }
composite_done(c);
}
NDR_DRSUAPI_OBJ_FILES = $(gen_ndrsrcdir)/ndr_drsuapi.o $(ndrsrcdir)/ndr_drsuapi.o
[SUBSYSTEM::NDR_DRSBLOBS]
-PUBLIC_DEPENDENCIES = LIBNDR NDR_MISC NDR_DRSUAPI LIBCLI_DRSBLOBS
+PUBLIC_DEPENDENCIES = LIBNDR NDR_MISC NDR_DRSUAPI
-NDR_DRSBLOBS_OBJ_FILES = $(gen_ndrsrcdir)/ndr_drsblobs.o
+NDR_DRSBLOBS_OBJ_FILES = $(gen_ndrsrcdir)/ndr_drsblobs.o $(ndrsrcdir)/ndr_drsblobs.o
[SUBSYSTEM::NDR_SASL_HELPERS]
PUBLIC_DEPENDENCIES = LIBNDR
[PYTHON::python_dcerpc_nbt]
LIBRARY_REALNAME = samba/nbt.$(SHLIBEXT)
-PRIVATE_DEPENDENCIES = NDR_NBT PYTALLOC param swig_credentials python_dcerpc
+PRIVATE_DEPENDENCIES = NDR_NBT PYTALLOC param swig_credentials python_dcerpc python_dcerpc_misc python_dcerpc_security
python_dcerpc_nbt_OBJ_FILES = $(gen_ndrsrcdir)/py_nbt.o
$(IDL_HEADER_FILES) $(IDL_NDR_PARSE_H_FILES) $(IDL_NDR_PARSE_C_FILES) \
$(IDL_NDR_CLIENT_C_FILES) $(IDL_NDR_CLIENT_H_FILES) \
$(IDL_NDR_SERVER_C_FILES) $(IDL_SWIG_FILES) \
- $(IDL_NDR_EJS_C_FILES) $(IDL_NDR_EJS_H_FILES) \
$(IDL_NDR_PY_C_FILES) $(IDL_NDR_PY_H_FILES): idl
idl_full:: $(pidldir)/lib/Parse/Pidl/IDL.pm $(pidldir)/lib/Parse/Pidl/Expr.pm
const uint8 DCERPC_PFC_FLAG_OBJECT_UUID = 0x80; /* on valid guid is in the optional object field */
/* these offsets are needed by the signing code */
+ const uint8 DCERPC_PFC_OFFSET = 3;
const uint8 DCERPC_DREP_OFFSET = 4;
const uint8 DCERPC_FRAG_LEN_OFFSET = 8;
const uint8 DCERPC_AUTH_LEN_OFFSET = 10;
[size_is(1)] AuthenticationInformation array[];
} AuthenticationInformationArray;
+ /* This is nopull,nopush because we pass count down to the
+ * manual parser of AuthenticationInformationArray */
typedef [public,nopull,nopush,noprint,gensize] struct {
uint32 count;
[relative] AuthenticationInformationArray *current;
[relative] AuthenticationInformationArray *previous;
} trustAuthInOutBlob;
- typedef [public] struct {
- uint8 confounder[512];
- trustAuthInOutBlob outgoing;
- trustAuthInOutBlob incoming;
- [value(ndr_size_trustAuthInOutBlob(&outgoing, ndr->flags))] uint32 outgoing_size;
- [value(ndr_size_trustAuthInOutBlob(&incoming, ndr->flags))] uint32 incoming_size;
- } trustAuthInAndOutBlob;
-
void decode_trustAuthInOut(
[in] trustAuthInOutBlob blob
);
+ typedef [public,gensize] struct {
+ uint32 count;
+ [relative] AuthenticationInformation *current[count];
+ } trustCurrentPasswords;
+
+ typedef [public,nopull] struct {
+ uint8 confounder[512];
+ [subcontext(0),subcontext_size(outgoing_size)] trustCurrentPasswords outgoing;
+ [subcontext(0),subcontext_size(incoming_size)] trustCurrentPasswords incoming;
+ [value(ndr_size_trustCurrentPasswords(&outgoing, ndr->flags))] uint32 outgoing_size;
+ [value(ndr_size_trustCurrentPasswords(&incoming, ndr->flags))] uint32 incoming_size;
+ } trustDomainPasswords;
+
+ void decode_trustDomainPasswords(
+ [in] trustDomainPasswords blob
+ );
+
typedef [public] struct {
uint32 marker;
DATA_BLOB data;
} drsuapi_DsNameFlags;
typedef [v1_enum] enum {
- DRSUAPI_DS_NAME_FORMAT_UKNOWN = 0,
+ DRSUAPI_DS_NAME_FORMAT_UNKNOWN = 0,
DRSUAPI_DS_NAME_FORMAT_FQDN_1779 = 1,
DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT = 2,
DRSUAPI_DS_NAME_FORMAT_DISPLAY = 3,
typedef struct {
[charset(UTF16),string] uint16 *server_dn;
[charset(UTF16),string] uint16 *domain_dn;
- uint32 unknown; /* 0x000000001 */
+ boolean32 commit;
} drsuapi_DsRemoveDSServerRequest1;
typedef [switch_type(int32)] union {
} drsuapi_DsRemoveDSServerRequest;
typedef struct {
- WERROR status;
+ boolean32 last_dc_in_domain;
} drsuapi_DsRemoveDSServerResult1;
typedef [switch_type(int32)] union {
typedef struct {
uint32 percent_full;
- uint32 log_size;
- NTTIME retention_time;
+ uint32 maximum_log_size;
+ hyper retention_time;
uint8 shutdown_in_progress;
- NTTIME time_to_shutdown;
+ hyper time_to_shutdown;
uint32 next_audit_record;
- uint32 unknown;
} lsa_AuditLogInfo;
typedef [v1_enum] enum {
lsa_String name;
} lsa_PDAccountInfo;
+ typedef [v1_enum] enum {
+ LSA_ROLE_BACKUP=2,
+ LSA_ROLE_PRIMARY=3
+ } lsa_Role;
+
typedef struct {
- uint16 unknown; /* an midl padding bug? */
- uint16 role;
+ lsa_Role role;
} lsa_ServerRole;
typedef struct {
typedef struct {
hyper modified_id;
- NTTIME db_create_time;
+ NTTIME_hyper db_create_time;
} lsa_ModificationInfo;
typedef struct {
} lsa_AuditFullSetInfo;
typedef struct {
- uint16 unknown; /* an midl padding bug? */
uint8 shutdown_on_full;
uint8 log_is_full;
} lsa_AuditFullQueryInfo;
LSA_POLICY_INFO_DB=9,
LSA_POLICY_INFO_AUDIT_FULL_SET=10,
LSA_POLICY_INFO_AUDIT_FULL_QUERY=11,
- LSA_POLICY_INFO_DNS=12
+ LSA_POLICY_INFO_DNS=12,
+ LSA_POLICY_INFO_DNS_INT=13
} lsa_PolicyInfo;
typedef [switch_type(uint16)] union {
[case(LSA_POLICY_INFO_AUDIT_FULL_SET)] lsa_AuditFullSetInfo auditfullset;
[case(LSA_POLICY_INFO_AUDIT_FULL_QUERY)] lsa_AuditFullQueryInfo auditfullquery;
[case(LSA_POLICY_INFO_DNS)] lsa_DnsDomainInfo dns;
+ [case(LSA_POLICY_INFO_DNS_INT)] lsa_DnsDomainInfo dns;
} lsa_PolicyInformation;
NTSTATUS lsa_QueryInfoPolicy (
LSA_LOOKUP_NAMES_PRIMARY_DOMAIN_ONLY = 3,
LSA_LOOKUP_NAMES_UPLEVEL_TRUSTS_ONLY = 4,
LSA_LOOKUP_NAMES_FOREST_TRUSTS_ONLY = 5,
- LSA_LOOKUP_NAMES_UPLEVEL_TRUSTS_ONLY2 = 6
+ LSA_LOOKUP_NAMES_UPLEVEL_TRUSTS_ONLY2 = 6,
+ LSA_LOOKUP_NAMES_RODC_REFERRAL_TO_FULL_DC = 7
} lsa_LookupNamesLevel;
[public] NTSTATUS lsa_LookupNames (
[in,out] lsa_TransSidArray2 *sids,
[in] lsa_LookupNamesLevel level,
[in,out] uint32 *count,
- [in] uint32 unknown1,
- [in] uint32 unknown2
+ [in] uint32 lookup_options,
+ [in] uint32 client_revision /* LSA_CLIENT_REVISION* */
);
/* Function 0x3b */
lsa_SidType sid_type;
dom_sid2 *sid;
uint32 sid_index;
- uint32 unknown;
+ uint32 flags;
} lsa_TranslatedSid3;
typedef struct {
[in,out] lsa_TransSidArray3 *sids,
[in] lsa_LookupNamesLevel level,
[in,out] uint32 *count,
- [in] uint32 unknown1,
- [in] uint32 unknown2
+ [in] uint32 lookup_options,
+ [in] uint32 client_revision /* LSA_CLIENT_REVISION* */
);
/* Function 0x45 */
[in] uint32 unknown2
);
+ const int LSA_CLIENT_REVISION_NO_DNS = 0x00000001;
+ const int LSA_CLIENT_REVISION_DNS = 0x00000002;
+
+ const int LSA_LOOKUP_OPTIONS_NO_ISOLATED = 0x80000000;
+
/* Function 0x4d */
NTSTATUS lsa_LookupNames4(
[in,range(0,1000)] uint32 num_names,
[in,out] lsa_TransSidArray3 *sids,
[in] lsa_LookupNamesLevel level,
[in,out] uint32 *count,
- [in] uint32 unknown1,
- [in] uint32 unknown2
+ [in] uint32 lookup_options,
+ [in] uint32 client_revision /* LSA_CLIENT_REVISION* */
);
/* Function 0x4e */
/* Only SEC_CHAN_WKSTA can forward requests to other domains. */
typedef [public] enum {
- SEC_CHAN_WKSTA = 2,
- SEC_CHAN_DOMAIN = 4,
- SEC_CHAN_BDC = 6
+ SEC_CHAN_NULL = 0,
+ SEC_CHAN_WKSTA = 2,
+ SEC_CHAN_DNS_DOMAIN = 3,
+ SEC_CHAN_DOMAIN = 4,
+ SEC_CHAN_BDC = 6
} netr_SchannelType;
/* SAM database types */
import "misc.idl", "security.idl", "svcctl.idl", "samr.idl";
[
- helper("libcli/netlogon.h", "libcli/nbt/libnbt.h")
+ helper("../libcli/netlogon.h", "../libcli/nbt/libnbt.h")
]
interface nbt
{
/****************/
/* Function 0x1d */
+ typedef [bitmap32bit] bitmap {
+ NETR_TRUST_FLAG_IN_FOREST = 0x00000001,
+ NETR_TRUST_FLAG_OUTBOUND = 0x00000002,
+ NETR_TRUST_FLAG_TREEROOT = 0x00000004,
+ NETR_TRUST_FLAG_PRIMARY = 0x00000008,
+ NETR_TRUST_FLAG_NATIVE = 0x00000010,
+ NETR_TRUST_FLAG_INBOUND = 0x00000020,
+ NETR_TRUST_FLAG_MIT_KRB5 = 0x00000080,
+ NETR_TRUST_FLAG_AES = 0x00000100
+ } netr_TrustFlags;
typedef [flag(NDR_PAHEX)] struct {
uint16 length;
[case(2)] netr_DomainQuery1 *query1;
} netr_DomainQuery;
+ typedef struct {
+ /* these first 3 values come from the fact windows
+ actually encodes this structure as a UNICODE_STRING
+ - see MS-NRPC section 2.2.1.3.9 */
+ [value(8)] uint32 length;
+ [value(0)] uint32 dummy;
+ [value(8)] uint32 size;
+ netr_TrustFlags flags;
+ uint32 parent_index;
+ uint32 trust_type;
+ uint32 trust_attributes;
+ } netr_trust_extension;
+
+ typedef struct {
+ uint16 length; /* value is 16 when info != NULL, otherwise 0 */
+ [value(length)] uint16 size; /* value is 16 when info != NULL, otherwise 0 */
+ netr_trust_extension *info;
+ } netr_trust_extension_container;
+
typedef struct {
lsa_String domainname;
lsa_String fulldomainname;
lsa_String forest;
GUID guid;
dom_sid2 *sid;
- netr_BinaryString unknown1[4];
- uint32 unknown[4];
+ netr_trust_extension_container trust_extension;
+ lsa_String dummystring[3];
+ uint32 dummy[4];
} netr_DomainTrustInfo;
+ typedef struct {
+ uint32 policy_size;
+ [size_is(policy_size)] uint8 *policy;
+ } netr_LsaPolicyInfo;
+
+ typedef [public,bitmap32bit] bitmap {
+ NETR_WS_FLAG_HANDLES_INBOUND_TRUSTS = 0x00000001,
+ NETR_WS_FLAG_HANDLES_SPN_UPDATE = 0x00000002
+ } netr_WorkstationFlags;
+
typedef struct {
netr_DomainTrustInfo domaininfo;
uint32 num_trusts;
[size_is(num_trusts)] netr_DomainTrustInfo *trusts;
- uint32 unknown[14]; /* room for expansion? */
+ netr_LsaPolicyInfo lsa_policy;
+ lsa_String dns_hostname;
+ lsa_String dummystring[3];
+ netr_WorkstationFlags workstation_flags;
+ uint32 supported_enc_types;
+ uint32 dummy[2];
} netr_DomainInfo1;
typedef union {
[case(1)] netr_DomainInfo1 *info1;
- [case(2)] netr_DomainInfo1 *info1;
+ [case(2)] netr_DomainInfo1 *info2;
} netr_DomainInfo;
NTSTATUS netr_LogonGetDomainInfo(
/****************/
/* Function 0x24 */
- typedef [bitmap32bit] bitmap {
- NETR_TRUST_FLAG_IN_FOREST = 0x00000001,
- NETR_TRUST_FLAG_OUTBOUND = 0x00000002,
- NETR_TRUST_FLAG_TREEROOT = 0x00000004,
- NETR_TRUST_FLAG_PRIMARY = 0x00000008,
- NETR_TRUST_FLAG_NATIVE = 0x00000010,
- NETR_TRUST_FLAG_INBOUND = 0x00000020
- } netr_TrustFlags;
typedef [v1_enum] enum {
NETR_TRUST_TYPE_DOWNLEVEL = 1,
const string SID_CREATOR_OWNER_DOMAIN = "S-1-3";
const string SID_CREATOR_OWNER = "S-1-3-0";
const string SID_CREATOR_GROUP = "S-1-3-1";
+ const string SID_OWNER_RIGHTS = "S-1-3-4";
/* SECURITY_NT_AUTHORITY */
const string NAME_NT_AUTHORITY = "NT AUTHORITY";
const string SID_NT_TERMINAL_SERVER_USERS = "S-1-5-13";
const string SID_NT_REMOTE_INTERACTIVE = "S-1-5-14";
const string SID_NT_THIS_ORGANISATION = "S-1-5-15";
+ const string SID_NT_IUSR = "S-1-5-17";
const string SID_NT_SYSTEM = "S-1-5-18";
const string SID_NT_LOCAL_SERVICE = "S-1-5-19";
const string SID_NT_NETWORK_SERVICE = "S-1-5-20";
+ const string SID_NT_DIGEST_AUTHENTICATION = "S-1-5-64-21";
+ const string SID_NT_NTLM_AUTHENTICATION = "S-1-5-64-10";
+ const string SID_NT_SCHANNEL_AUTHENTICATION = "S-1-5-64-14";
+ const string SID_NT_OTHER_ORGANISATION = "S-1-5-1000";
/* SECURITY_BUILTIN_DOMAIN_RID */
const string NAME_BUILTIN = "BUILTIN";
*/
#include "includes.h"
-#include "libcli/drsblobs.h"
+#include "librpc/gen_ndr/ndr_drsblobs.h"
/* parser auto-generated by pidl, then hand-modified by abartlet */
ndr->depth--;
}
+_PUBLIC_ enum ndr_err_code ndr_pull_trustDomainPasswords(struct ndr_pull *ndr, int ndr_flags, struct trustDomainPasswords *r)
+{
+ if (ndr_flags & NDR_SCALARS) {
+ uint32_t offset;
+ NDR_PULL_ALIGN(ndr, 4);
+ NDR_PULL_NEED_BYTES(ndr, 8);
+
+ offset = ndr->offset;
+ ndr->offset = ndr->data_size - 8;
+
+ NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->outgoing_size));
+ NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->incoming_size));
+
+ ndr->offset = offset;
+ NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->confounder, 512));
+ {
+ struct ndr_pull *_ndr_outgoing;
+ NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_outgoing, 0, r->outgoing_size));
+ NDR_CHECK(ndr_pull_trustCurrentPasswords(_ndr_outgoing, NDR_SCALARS|NDR_BUFFERS, &r->outgoing));
+ NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_outgoing, 0, r->outgoing_size));
+ }
+ {
+ struct ndr_pull *_ndr_incoming;
+ NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_incoming, 0, r->incoming_size));
+ NDR_CHECK(ndr_pull_trustCurrentPasswords(_ndr_incoming, NDR_SCALARS|NDR_BUFFERS, &r->incoming));
+ NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_incoming, 0, r->incoming_size));
+ }
+ NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->outgoing_size));
+ NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->incoming_size));
+ }
+ if (ndr_flags & NDR_BUFFERS) {
+ }
+ return NDR_ERR_SUCCESS;
+}
_PUBLIC_ NTSTATUS dcerpc_init(void)
{
- gensec_init(global_loadparm);
-
- return NT_STATUS_OK;
+ return gensec_init(global_loadparm);
}
static void dcerpc_connection_dead(struct dcerpc_connection *conn, NTSTATUS status);
DATA_BLOB creds2;
size_t payload_length;
enum ndr_err_code ndr_err;
+ size_t hdr_size = DCERPC_REQUEST_LENGTH;
/* non-signed packets are simpler */
if (sig_size == 0) {
if (pkt->pfc_flags & DCERPC_PFC_FLAG_OBJECT_UUID) {
ndr->flags |= LIBNDR_FLAG_OBJECT_PRESENT;
+ hdr_size += 16;
}
ndr_err = ndr_push_ncacn_packet(ndr, NDR_SCALARS|NDR_BUFFERS, pkt);
case DCERPC_AUTH_LEVEL_PRIVACY:
status = gensec_seal_packet(c->security_state.generic_state,
mem_ctx,
- blob->data + DCERPC_REQUEST_LENGTH,
+ blob->data + hdr_size,
payload_length,
blob->data,
blob->length,
case DCERPC_AUTH_LEVEL_INTEGRITY:
status = gensec_sign_packet(c->security_state.generic_state,
mem_ctx,
- blob->data + DCERPC_REQUEST_LENGTH,
+ blob->data + hdr_size,
payload_length,
blob->data,
blob->length,
conn->in.workgroup = lp_workgroup(lp_ctx);
lp_smbcli_options(lp_ctx, &conn->in.options);
+ lp_smbcli_session_options(lp_ctx, &conn->in.session_options);
/*
* provide proper credentials - user supplied, but allow a
/* send smb connect request */
conn_req = smb_composite_connect_send(conn, s->io.pipe->conn,
- lp_resolve_context(lp_ctx),
+ s->io.resolve_ctx,
s->io.pipe->conn->event_ctx);
if (composite_nomem(conn_req, c)) return c;
s->binding->host,
s->binding->target_hostname,
atoi(s->binding->endpoint),
- lp_resolve_context(global_loadparm));
+ dcerpc_resolve_ctx(s->pipe->conn));
composite_continue(c, pipe_tcp_req, continue_open_tcp, c);
return c;
case NCALRPC:
- pipe_ncalrpc_req = dcerpc_pipe_open_pipe_send(s->pipe2->conn, lp_ncalrpc_dir(global_loadparm),
- s->binding->endpoint);
+ case NCACN_UNIX_STREAM:
+ pipe_ncalrpc_req = dcerpc_pipe_open_unix_stream_send(s->pipe2->conn,
+ dcerpc_unix_socket_path(s->pipe->conn));
composite_continue(c, pipe_ncalrpc_req, continue_open_pipe, c);
return c;
struct packet_context *packet;
uint32_t pending_reads;
+
+ struct resolve_context *resolve_ctx;
+ const char *path; /* For ncacn_unix_sock and ncalrpc */
};
struct resolve_context *resolve_context,
struct socket_address *server,
const char *target_hostname,
+ const char *full_path,
enum dcerpc_transport_t transport)
{
struct composite_context *c;
talloc_steal(s->sock, s->socket_ctx);
+ s->sock->resolve_ctx = resolve_context;
+ s->sock->path = talloc_reference(s->sock, full_path);
+
conn_req = socket_connect_send(s->socket_ctx, NULL, s->server, 0,
resolve_context,
c->event_ctx);
sock_ipv4_req = dcerpc_pipe_open_socket_send(c, s->conn,
s->resolve_ctx,
s->srvaddr, s->target_hostname,
+ NULL,
NCACN_IP_TCP);
composite_continue(c, sock_ipv4_req, continue_ipv4_open_socket, c);
}
sock_unix_req = dcerpc_pipe_open_socket_send(c, s->conn,
NULL,
s->srvaddr, NULL,
+ s->path,
NCALRPC);
composite_continue(c, sock_unix_req, continue_unix_open_socket, c);
return c;
}
-struct pipe_np_state {
- char *full_path;
- struct socket_address *srvaddr;
- struct dcerpc_connection *conn;
-};
-
-
/*
Stage 2 of dcerpc_pipe_open_pipe_send: receive socket open request
*/
struct composite_context *c;
struct composite_context *sock_np_req;
- struct pipe_np_state *s;
+ struct pipe_unix_state *s;
/* composite context allocation and setup */
c = composite_create(conn, conn->event_ctx);
if (c == NULL) return NULL;
- s = talloc_zero(c, struct pipe_np_state);
+ s = talloc_zero(c, struct pipe_unix_state);
if (composite_nomem(s, c)) return c;
c->private_data = s;
s->conn = conn;
string_replace(canon, '/', '\\');
- s->full_path = talloc_asprintf(canon, "%s/%s", ncalrpc_dir, canon);
- if (composite_nomem(s->full_path, c)) return c;
+ s->path = talloc_asprintf(canon, "%s/%s", ncalrpc_dir, canon);
+ if (composite_nomem(s->path, c)) return c;
/* prepare server address using path and transport name */
- s->srvaddr = socket_address_from_strings(conn, "unix", s->full_path, 0);
+ s->srvaddr = socket_address_from_strings(conn, "unix", s->path, 0);
if (composite_nomem(s->srvaddr, c)) return c;
/* send socket open request */
- sock_np_req = dcerpc_pipe_open_socket_send(c, s->conn, NULL, s->srvaddr, NULL, NCALRPC);
+ sock_np_req = dcerpc_pipe_open_socket_send(c, s->conn, NULL, s->srvaddr, NULL, s->path, NCALRPC);
composite_continue(c, sock_np_req, continue_np_open_socket, c);
return c;
}
struct composite_context *c = dcerpc_pipe_open_pipe_send(conn, ncalrpc_dir, identifier);
return dcerpc_pipe_open_pipe_recv(c);
}
+
+const char *dcerpc_unix_socket_path(struct dcerpc_connection *p)
+{
+ struct sock_private *sock = (struct sock_private *)p->transport.private_data;
+ return sock->path;
+}
+
+struct resolve_context *dcerpc_resolve_ctx(struct dcerpc_connection *p)
+{
+ struct sock_private *sock = (struct sock_private *)p->transport.private_data;
+ return sock->resolve_ctx;
+}
failed=0
-samba4bindir=`dirname $0`/../../source4/bin
+samba4bindir=`dirname $0`/../../bin
ndrdump=$samba4bindir/ndrdump
-files=`dirname $0`/ndrdump
+files=`dirname $0`/
testit "ndrdump with in" $VALGRIND $ndrdump samr samr_CreateUser in $files/samr-CreateUser-in.dat $@ || failed=`expr $failed + 1`
testit "ndrdump with out" $VALGRIND $ndrdump samr samr_CreateUser out $files/samr-CreateUser-out.dat $@ || failed=`expr $failed + 1`
mkinclude lib/cmdline/config.mk
mkinclude ../lib/socket_wrapper/config.mk
mkinclude ../lib/nss_wrapper/config.mk
-mkinclude lib/appweb/config.mk
mkinclude lib/stream/config.mk
mkinclude lib/util/config.mk
mkinclude lib/tdr/config.mk
mkinclude lib/dbwrap/config.mk
-mkinclude lib/crypto/config.mk
+mkinclude ../lib/crypto/config.mk
mkinclude lib/torture/config.mk
mkinclude lib/basic.mk
mkinclude lib/com/config.mk
mkinclude librpc/config.mk
mkinclude client/config.mk
mkinclude libcli/config.mk
-mkinclude scripting/ejs/config.mk
mkinclude scripting/python/config.mk
mkinclude kdc/config.mk
[MODULE::service_nbtd]
INIT_FUNCTION = server_service_nbtd_init
-SUBSYSTEM = smbd
+SUBSYSTEM = samba
PRIVATE_DEPENDENCIES = NBT_SERVER process_model
service_nbtd_OBJ_FILES = \
{
struct nbtd_iface_name *iname;
struct nbt_name *name;
- struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private,
+ struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private_data,
struct nbtd_interface);
/*
/* setup a GETDC reply */
ZERO_STRUCT(netlogon_response);
netlogon_response.response_type = NETLOGON_GET_PDC;
- pdc = &netlogon_response.get_pdc;
+ pdc = &netlogon_response.data.get_pdc;
pdc->command = NETLOGON_RESPONSE_FROM_PDC;
pdc->pdc_name = lp_netbios_name(iface->nbtsrv->task->lp_ctx);
status = fill_netlogon_samlogon_response(samctx, packet, NULL, name->name, sid, NULL,
netlogon->req.logon.user_name, netlogon->req.logon.acct_control, src->addr,
- netlogon->req.logon.nt_version, iface->nbtsrv->task->lp_ctx, &netlogon_response.samlogon);
+ netlogon->req.logon.nt_version, iface->nbtsrv->task->lp_ctx, &netlogon_response.data.samlogon);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(2,("NBT netlogon query failed domain=%s sid=%s version=%d - %s\n",
name->name, dom_sid_string(packet, sid), netlogon->req.logon.nt_version, nt_errstr(status)));
struct nbt_name_packet *packet,
struct socket_address *src)
{
- struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private,
+ struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private_data,
struct nbtd_interface);
struct nbtd_server *nbtsrv = iface->nbtsrv;
/* We asked for version 1 only */
if (netlogon.response_type == NETLOGON_SAMLOGON
- && netlogon.samlogon.ntver != NETLOGON_NT_VERSION_1) {
+ && netlogon.data.samlogon.ntver != NETLOGON_NT_VERSION_1) {
status = NT_STATUS_INVALID_NETWORK_RESPONSE;
goto done;
}
- p = netlogon.samlogon.nt4.server;
+ p = netlogon.data.samlogon.data.nt4.server;
DEBUG(10, ("NTLOGON_SAM_LOGON_REPLY: server: %s, user: %s, "
- "domain: %s\n", p, netlogon.samlogon.nt4.user_name,
- netlogon.samlogon.nt4.domain));
+ "domain: %s\n", p,
+ netlogon.data.samlogon.data.nt4.user_name,
+ netlogon.data.samlogon.data.nt4.domain));
if (*p == '\\') p += 1;
if (*p == '\\') p += 1;
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
-#include "libcli/nbt/libnbt.h"
+#include "../libcli/nbt/libnbt.h"
#include "libcli/wrepl/winsrepl.h"
#include "libcli/dgram/libdgram.h"
#include "librpc/gen_ndr/irpc.h"
{
struct nbt_name *name;
struct nbtd_iface_name *iname;
- struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private,
+ struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private_data,
struct nbtd_interface);
NBTD_ASSERT_PACKET(packet, src, packet->qdcount == 1);
struct nbt_name_packet *packet,
const struct socket_address *src)
{
- struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private,
+ struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private_data,
struct nbtd_interface);
/* if its not a broadcast then its not considered a self packet */
struct nbt_name_packet *packet,
const struct socket_address *src)
{
- struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private,
+ struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private_data,
struct nbtd_interface);
struct nbtd_server *nbtsrv = iface->nbtsrv;
{
struct nbt_name_packet *packet;
size_t num_addresses = str_list_length(addresses);
- struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private,
+ struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private_data,
struct nbtd_interface);
struct nbtd_server *nbtsrv = iface->nbtsrv;
int i;
{
struct nbt_name_packet *packet;
struct nbt_name *name = &request_packet->questions[0].name;
- struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private,
+ struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private_data,
struct nbtd_interface);
struct nbtd_server *nbtsrv = iface->nbtsrv;
{
struct nbt_name_packet *packet;
struct nbt_name *name = &request_packet->questions[0].name;
- struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private,
+ struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private_data,
struct nbtd_interface);
struct nbtd_server *nbtsrv = iface->nbtsrv;
{
struct nbt_name_packet *packet;
struct nbt_name *name = &request_packet->questions[0].name;
- struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private,
+ struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private_data,
struct nbtd_interface);
struct nbtd_server *nbtsrv = iface->nbtsrv;
{
struct nbt_name_packet *packet;
struct nbt_name *name = &request_packet->questions[0].name;
- struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private,
+ struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private_data,
struct nbtd_interface);
struct nbtd_server *nbtsrv = iface->nbtsrv;
{
struct nbtd_iface_name *iname;
struct nbt_name *name;
- struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private,
+ struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private_data,
struct nbtd_interface);
/* see if its a node status query */
*/
static void refresh_completion_handler(struct nbt_name_request *req)
{
- struct nbtd_iface_name *iname = talloc_get_type(req->async.private,
+ struct nbtd_iface_name *iname = talloc_get_type(req->async.private_data,
struct nbtd_iface_name);
NTSTATUS status;
struct nbt_name_refresh io;
if (req == NULL) return;
req->async.fn = refresh_completion_handler;
- req->async.private = iname;
+ req->async.private_data = iname;
}
struct socket_address *src)
{
struct nbt_name *name = &packet->questions[0].name;
- struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private,
+ struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private_data,
struct nbtd_interface);
struct wins_dns_proxy_state *s;
struct composite_context *creq;
if (!dn) goto failed;
/* find the record in the WINS database */
- ret = ldb_search(ldb, dn, LDB_SCOPE_BASE,
- NULL, NULL, &res);
+ ret = ldb_search(ldb, tmp_ctx, &res, dn, LDB_SCOPE_BASE, NULL, NULL);
if (ret != LDB_SUCCESS) goto failed;
- talloc_steal(tmp_ctx, res);
if (res->count > 1) goto failed;
if (res->count == 1) {
if (!dn) goto failed;
/* find the record in the WINS database */
- ret = ldb_search(wins_db, dn, LDB_SCOPE_BASE, NULL, NULL, &res);
-
+ ret = ldb_search(wins_db, tmp_ctx, &res, dn, LDB_SCOPE_BASE, NULL, NULL);
if (ret != LDB_SUCCESS) goto failed;
- talloc_steal(tmp_ctx, res);
if (res->count > 1) goto failed;
- talloc_steal(tmp_ctx, res);
-
if (res->count == 1) {
oldMaxVersion = ldb_msg_find_attr_as_uint64(res->msgs[0], "maxVersion", 0);
}
if (!dn) goto failed;
/* find the record in the WINS database */
- ret = ldb_search(ldb, dn, LDB_SCOPE_BASE,
- NULL, NULL, &res);
+ ret = ldb_search(ldb, tmp_ctx, &res, dn, LDB_SCOPE_BASE, NULL, NULL);
if (ret != LDB_SUCCESS) goto failed;
- talloc_steal(tmp_ctx, res);
if (res->count > 1) goto failed;
if (res->count == 1) {
time_t now = time(NULL);
/* find the record in the WINS database */
- ret = ldb_search(wins_db, winsdb_dn(tmp_ctx, wins_db, name), LDB_SCOPE_BASE,
- NULL, NULL, &res);
+ ret = ldb_search(wins_db, tmp_ctx, &res,
+ winsdb_dn(tmp_ctx, wins_db, name),
+ LDB_SCOPE_BASE, NULL, NULL);
- talloc_steal(tmp_ctx, res);
if (ret != LDB_SUCCESS || res->count > 1) {
status = NT_STATUS_INTERNAL_DB_CORRUPTION;
goto failed;
if (!dn) goto failed;
/* find the record in the WINS database */
- ret = ldb_search(h->ldb, dn, LDB_SCOPE_BASE, NULL, NULL, &res);
+ ret = ldb_search(h->ldb, tmp_ctx, &res, dn, LDB_SCOPE_BASE, NULL, NULL);
if (ret != LDB_SUCCESS) goto failed;
- talloc_steal(tmp_ctx, res);
if (res->count > 0) goto skip;
const struct socket_address *src,
enum wrepl_name_type type)
{
- struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private,
+ struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private_data,
struct nbtd_interface);
struct wins_server *winssrv = iface->nbtsrv->winssrv;
struct nbt_name *name = &packet->questions[0].name;
struct winsdb_addr *winsdb_addr,
const struct socket_address *src)
{
- struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private,
+ struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private_data,
struct nbtd_interface);
struct wins_server *winssrv = iface->nbtsrv->winssrv;
uint32_t ttl = wins_server_ttl(winssrv, packet->additional[0].ttl);
const char *address,
const struct socket_address *src)
{
- struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private,
+ struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private_data,
struct nbtd_interface);
struct wins_server *winssrv = iface->nbtsrv->winssrv;
uint32_t ttl = wins_server_ttl(winssrv, packet->additional[0].ttl);
struct socket_address *src,
enum wrepl_name_type new_type)
{
- struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private,
+ struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private_data,
struct nbtd_interface);
struct wins_server *winssrv = iface->nbtsrv->winssrv;
struct wack_state *s;
struct socket_address *src)
{
NTSTATUS status;
- struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private,
+ struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private_data,
struct nbtd_interface);
struct wins_server *winssrv = iface->nbtsrv->winssrv;
struct nbt_name *name = &packet->questions[0].name;
struct socket_address *src)
{
NTSTATUS status;
- struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private,
+ struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private_data,
struct nbtd_interface);
struct wins_server *winssrv = iface->nbtsrv->winssrv;
struct nbt_name *name = &packet->questions[0].name;
struct socket_address *src)
{
NTSTATUS status;
- struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private,
+ struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private_data,
struct nbtd_interface);
struct wins_server *winssrv = iface->nbtsrv->winssrv;
struct nbt_name *name = &packet->questions[0].name;
struct nbt_name_packet *packet,
struct socket_address *src)
{
- struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private,
+ struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private_data,
struct nbtd_interface);
struct wins_server *winssrv = iface->nbtsrv->winssrv;
if ((packet->operation & NBT_FLAG_BROADCAST) || winssrv == NULL) {
static void wins_challenge_handler(struct nbt_name_request *req)
{
- struct composite_context *ctx = talloc_get_type(req->async.private, struct composite_context);
+ struct composite_context *ctx = talloc_get_type(req->async.private_data, struct composite_context);
struct wins_challenge_state *state = talloc_get_type(ctx->private_data, struct wins_challenge_state);
ctx->status = nbt_name_query_recv(req, state, &state->query);
if (req == NULL) goto failed;
req->async.fn = wins_challenge_handler;
- req->async.private = result;
+ req->async.private_data = result;
return result;
failed:
static void wins_release_demand_handler(struct nbt_name_request *req)
{
- struct composite_context *ctx = talloc_get_type(req->async.private, struct composite_context);
+ struct composite_context *ctx = talloc_get_type(req->async.private_data, struct composite_context);
struct wins_release_demand_state *state = talloc_get_type(ctx->private_data, struct wins_release_demand_state);
ctx->status = nbt_name_release_recv(req, state, &state->release);
if (req == NULL) goto failed;
req->async.fn = wins_release_demand_handler;
- req->async.private = result;
+ req->async.private_data = result;
return result;
failed:
echo "$DOMAIN/$USERNAME resolved to $admin_sid"
testit "wbinfo -s $admin_sid against $TARGET" $wbinfo -s $admin_sid || failed=`expr $failed + 1`
-admin_name=`wbinfo -s $admin_sid | cut -d " " -f1| tr a-z A-Z`
+admin_name=`$wbinfo -s $admin_sid | cut -d " " -f1| tr a-z A-Z`
echo "$admin_sid resolved to $admin_name"
tested_name=`echo $DOMAIN/$USERNAME | tr a-z A-Z`
echo "success: wbinfo -U check for sane mapping"
fi
-admin_uid=`wbinfo -U $admin_sid`
+admin_uid=`$wbinfo -U $admin_sid`
testit "wbinfo -G against $TARGET" $wbinfo -G 30000 || failed=`expr $failed + 1`
testit "wbinfo --own-domain against $TARGET" $wbinfo --own-domain || failed=`expr $failed + 1`
echo "test: wbinfo --own-domain against $TARGET check output"
-own_domain=`wbinfo --own-domain`
+own_domain=`$wbinfo --own-domain`
if test x$own_domain = x$DOMAIN; then
echo "success: wbinfo --own-domain against $TARGET check output"
else
# Start SUBSYSTEM NTP_signd
[MODULE::NTP_SIGND]
INIT_FUNCTION = server_service_ntp_signd_init
-SUBSYSTEM = smbd
+SUBSYSTEM = samba
PRIVATE_DEPENDENCIES = \
SAMDB NDR_NTP_SIGND
# End SUBSYSTEM NTP_SIGND
#include "libcli/security/security.h"
#include "lib/ldb/include/ldb.h"
#include "lib/ldb/include/ldb_errors.h"
-#include "lib/crypto/md5.h"
+#include "../lib/crypto/md5.h"
#include "system/passwd.h"
/*
return signing_failure(ntp_signdconn, sign_request.packet_id);
}
- ret = ldb_search_exp_fmt(ntp_signdconn->ntp_signd->samdb, tmp_ctx,
+ ret = ldb_search(ntp_signdconn->ntp_signd->samdb, tmp_ctx,
&res, samdb_base_dn(ntp_signdconn->ntp_signd->samdb),
LDB_SCOPE_SUBTREE, attrs, "(&(objectSid=%s)(objectClass=user))",
dom_sid_string(tmp_ctx, sid));
/* within the ntp_signd task we want to be a single process, so
ask for the single process model ops and pass these to the
stream_setup_socket() call. */
- model_ops = process_model_byname("single");
+ model_ops = process_model_startup(task->event_ctx, "single");
if (!model_ops) {
DEBUG(0,("Can't find 'single' process model_ops\n"));
return;
io.in.service = remote_share;
io.in.service_type = "?????";
lp_smbcli_options(ntvfs->ctx->lp_ctx, &io.in.options);
+ lp_smbcli_session_options(ntvfs->ctx->lp_ctx, &io.in.session_options);
if (!(ntvfs->ctx->client_caps & NTVFS_CLIENT_CAP_LEVEL_II_OPLOCKS)) {
io.in.options.use_level2_oplocks = false;
/* we need to check these bits before we check the private mask */
if (io2->generic.in.create_options & SMB2_CREATE_OPTIONS_NOT_SUPPORTED_MASK) {
+ DEBUG(2,(__location__ " create_options 0x%x not supported\n",
+ io2->generic.in.create_options));
status = NT_STATUS_NOT_SUPPORTED;
break;
}
NTSTATUS status;
struct security_descriptor *sd;
+ /* on SMB2 a blank access mask is always denied */
+ if (pvfs->ntvfs->ctx->protocol == PROTOCOL_SMB2 &&
+ *access_mask == 0) {
+ return NT_STATUS_ACCESS_DENIED;
+ }
+
if (pvfs_read_only(pvfs, *access_mask)) {
return NT_STATUS_ACCESS_DENIED;
}
create_options &= ~create_options_must_ignore_mask;
if (create_options & NTCREATEX_OPTIONS_NOT_SUPPORTED_MASK) {
+ DEBUG(2,(__location__ " create_options 0x%x not supported\n",
+ create_options));
return NT_STATUS_NOT_SUPPORTED;
}
if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_SUPPORTED)||
NT_STATUS_EQUAL(status, NT_STATUS_NOT_IMPLEMENTED)||
NT_STATUS_EQUAL(status, NT_STATUS_INVALID_SYSTEM_SERVICE)) {
- DEBUG(5,("pvfs_xattr: xattr not supported in filesystem: %s\n", nt_errstr(status)));
+ DEBUG(2,("pvfs_xattr: xattr not supported in filesystem: %s\n", nt_errstr(status)));
pvfs->flags &= ~PVFS_FLAG_XATTR_ENABLE;
status = NT_STATUS_NOT_FOUND;
}
char *szWINS_CONFIG_URL;
char *szWINS_URL;
char *szPrivateDir;
- const char **jsInclude;
- char *jsonrpcServicesDir;
const char **szPasswordServers;
char *szSocketOptions;
char *szRealm;
{"lock directory", P_STRING, P_GLOBAL, GLOBAL_VAR(szLockDir), NULL, NULL},
{"modules dir", P_STRING, P_GLOBAL, GLOBAL_VAR(szModulesDir), NULL, NULL},
{"pid directory", P_STRING, P_GLOBAL, GLOBAL_VAR(szPidDir), NULL, NULL},
- {"js include", P_LIST, P_GLOBAL, GLOBAL_VAR(jsInclude), NULL, NULL},
{"setup directory", P_STRING, P_GLOBAL, GLOBAL_VAR(szSetupDir), NULL, NULL},
{"socket address", P_STRING, P_GLOBAL, GLOBAL_VAR(szSocketAddress), NULL, NULL},
_PUBLIC_ FN_GLOBAL_INTEGER(lp_security, security)
_PUBLIC_ FN_GLOBAL_BOOL(lp_paranoid_server_security, paranoid_server_security)
_PUBLIC_ FN_GLOBAL_INTEGER(lp_announce_as, announce_as)
-_PUBLIC_ FN_GLOBAL_LIST(lp_js_include, jsInclude)
const char *lp_servicename(const struct loadparm_service *service)
{
return lp_string((const char *)service->szService);
lp_do_global_parameter(lp_ctx, "tls keyfile", "tls/key.pem");
lp_do_global_parameter(lp_ctx, "tls certfile", "tls/cert.pem");
lp_do_global_parameter(lp_ctx, "tls cafile", "tls/ca.pem");
- lp_do_global_parameter_var(lp_ctx, "js include", "%s", dyn_JSDIR);
lp_do_global_parameter_var(lp_ctx, "setup directory", "%s",
dyn_SETUPDIR);
options->use_oplocks = true;
options->use_level2_oplocks = true;
}
+
+void lp_smbcli_session_options(struct loadparm_context *lp_ctx,
+ struct smbcli_session_options *options)
+{
+ options->lanman_auth = lp_client_lanman_auth(lp_ctx);
+ options->ntlmv2_auth = lp_client_ntlmv2_auth(lp_ctx);
+ options->plaintext_auth = lp_client_plaintext_auth(lp_ctx);
+}
struct loadparm_context;
struct loadparm_service;
struct smbcli_options;
+struct smbcli_session_options;
void reload_charcnv(struct loadparm_context *lp_ctx);
struct smb_iconv_convenience *lp_iconv_convenience(struct loadparm_context *lp_ctx);
void lp_smbcli_options(struct loadparm_context *lp_ctx,
struct smbcli_options *options);
+void lp_smbcli_session_options(struct loadparm_context *lp_ctx,
+ struct smbcli_session_options *options);
/* The following definitions come from param/generic.c */
# This file was automatically generated by SWIG (http://www.swig.org).
-# Version 1.3.35
+# Version 1.3.36
#
# Don't modify this file, modify the SWIG interface instead.
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
- * Version 1.3.35
+ * Version 1.3.36
*
* This file is not intended to be easily readable and contains a number of
* coding conventions designed to improve portability and efficiency. Do not make
# endif
#endif
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+# pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
# define SWIGUNUSEDPARM(p)
#define SWIGTYPE_p_int swig_types[2]
#define SWIGTYPE_p_loadparm_context swig_types[3]
#define SWIGTYPE_p_loadparm_service swig_types[4]
-#define SWIGTYPE_p_long swig_types[5]
+#define SWIGTYPE_p_long_long swig_types[5]
#define SWIGTYPE_p_param_context swig_types[6]
#define SWIGTYPE_p_param_opt swig_types[7]
#define SWIGTYPE_p_param_section swig_types[8]
#define SWIGTYPE_p_signed_char swig_types[10]
#define SWIGTYPE_p_unsigned_char swig_types[11]
#define SWIGTYPE_p_unsigned_int swig_types[12]
-#define SWIGTYPE_p_unsigned_long swig_types[13]
+#define SWIGTYPE_p_unsigned_long_long swig_types[13]
#define SWIGTYPE_p_unsigned_short swig_types[14]
static swig_type_info *swig_types[16];
static swig_module_info swig_module = {swig_types, 15, 0, 0, 0, 0};
#define SWIG_name "_param"
-#define SWIGVERSION 0x010335
+#define SWIGVERSION 0x010336
#define SWIG_VERSION SWIGVERSION
SWIGINTERN PyObject *_wrap_LoadParm_default_service(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
loadparm_context *arg1 = (loadparm_context *) 0 ;
- struct loadparm_service *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char * kwnames[] = {
(char *) "self", NULL
};
+ struct loadparm_service *result = 0 ;
arg1 = loadparm_init(NULL);
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:LoadParm_default_service",kwnames,&obj0)) SWIG_fail;
PyObject *resultobj = 0;
loadparm_context *arg1 = (loadparm_context *) 0 ;
char *arg2 = (char *) 0 ;
- bool result;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char * kwnames[] = {
(char *) "self",(char *) "filename", NULL
};
+ bool result;
arg1 = loadparm_init(NULL);
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:LoadParm_load",kwnames,&obj0,&obj1)) SWIG_fail;
SWIGINTERN PyObject *_wrap_LoadParm_load_default(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
loadparm_context *arg1 = (loadparm_context *) 0 ;
- bool result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char * kwnames[] = {
(char *) "self", NULL
};
+ bool result;
arg1 = loadparm_init(NULL);
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:LoadParm_load_default",kwnames,&obj0)) SWIG_fail;
SWIGINTERN PyObject *_wrap_LoadParm___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
loadparm_context *arg1 = (loadparm_context *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char * kwnames[] = {
(char *) "self", NULL
};
+ int result;
arg1 = loadparm_init(NULL);
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:LoadParm___len__",kwnames,&obj0)) SWIG_fail;
PyObject *resultobj = 0;
loadparm_context *arg1 = (loadparm_context *) 0 ;
char *arg2 = (char *) 0 ;
- struct loadparm_service *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char * kwnames[] = {
(char *) "self",(char *) "name", NULL
};
+ struct loadparm_service *result = 0 ;
arg1 = loadparm_init(NULL);
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:LoadParm___getitem__",kwnames,&obj0,&obj1)) SWIG_fail;
SWIGINTERN PyObject *_wrap_LoadParm_configfile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
loadparm_context *arg1 = (loadparm_context *) 0 ;
- char *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject * obj0 = 0 ;
char * kwnames[] = {
(char *) "self", NULL
};
+ char *result = 0 ;
arg1 = loadparm_init(NULL);
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:LoadParm_configfile",kwnames,&obj0)) SWIG_fail;
PyObject *resultobj = 0;
loadparm_context *arg1 = (loadparm_context *) 0 ;
char *arg2 = (char *) 0 ;
- bool result;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char * kwnames[] = {
(char *) "self",(char *) "domain", NULL
};
+ bool result;
arg1 = loadparm_init(NULL);
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:LoadParm_is_mydomain",kwnames,&obj0,&obj1)) SWIG_fail;
PyObject *resultobj = 0;
loadparm_context *arg1 = (loadparm_context *) 0 ;
char *arg2 = (char *) 0 ;
- bool result;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char * kwnames[] = {
(char *) "self",(char *) "name", NULL
};
+ bool result;
arg1 = loadparm_init(NULL);
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:LoadParm_is_myname",kwnames,&obj0,&obj1)) SWIG_fail;
PyObject *resultobj = 0;
loadparm_context *arg1 = (loadparm_context *) 0 ;
struct param_context *arg2 = (struct param_context *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
char * kwnames[] = {
(char *) "self",(char *) "param_ctx", NULL
};
+ int result;
arg1 = loadparm_init(NULL);
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:LoadParm_use",kwnames,&obj0,&obj1)) SWIG_fail;
loadparm_context *arg1 = (loadparm_context *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
- bool result;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char * kwnames[] = {
(char *) "self",(char *) "parm_name",(char *) "parm_value", NULL
};
+ bool result;
arg1 = loadparm_init(NULL);
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:LoadParm_set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
loadparm_context *arg1 = (loadparm_context *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
- PyObject *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char * kwnames[] = {
(char *) "self",(char *) "param_name",(char *) "service_name", NULL
};
+ PyObject *result = 0 ;
arg1 = loadparm_init(NULL);
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:LoadParm_get",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
arg1 = (loadparm_context *)(argp1);
}
delete_loadparm_context(arg1);
-
resultobj = SWIG_Py_Void();
return resultobj;
fail:
PyObject *resultobj = 0;
loadparm_service *arg1 = (loadparm_service *) 0 ;
struct loadparm_service *arg2 = (struct loadparm_service *) 0 ;
- char *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
char * kwnames[] = {
(char *) "self",(char *) "sDefault", NULL
};
+ char *result = 0 ;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:loadparm_service_volume_label",kwnames,&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_loadparm_service, 0 | 0 );
PyObject *resultobj = 0;
loadparm_service *arg1 = (loadparm_service *) 0 ;
struct loadparm_service *arg2 = (struct loadparm_service *) 0 ;
- char *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
char * kwnames[] = {
(char *) "self",(char *) "sDefault", NULL
};
+ char *result = 0 ;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:loadparm_service_printername",kwnames,&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_loadparm_service, 0 | 0 );
PyObject *resultobj = 0;
loadparm_service *arg1 = (loadparm_service *) 0 ;
struct loadparm_service *arg2 = (struct loadparm_service *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
char * kwnames[] = {
(char *) "self",(char *) "sDefault", NULL
};
+ int result;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:loadparm_service_maxprintjobs",kwnames,&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_loadparm_service, 0 | 0 );
PyObject *resultobj = 0;
param *arg1 = (param *) 0 ;
char *arg2 = (char *) 0 ;
- struct param_section *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char * kwnames[] = {
(char *) "self",(char *) "name", NULL
};
+ struct param_section *result = 0 ;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ParamFile_get_section",kwnames,&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_param_context, 0 | 0 );
PyObject *resultobj = 0;
param *arg1 = (param *) 0 ;
char *arg2 = (char *) 0 ;
- struct param_section *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char * kwnames[] = {
(char *) "self",(char *) "name", NULL
};
+ struct param_section *result = 0 ;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ParamFile_add_section",kwnames,&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_param_context, 0 | 0 );
param *arg1 = (param *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) "global" ;
- struct param_opt *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char * kwnames[] = {
(char *) "self",(char *) "name",(char *) "section_name", NULL
};
+ struct param_opt *result = 0 ;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ParamFile_get",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_param_context, 0 | 0 );
param *arg1 = (param *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) "global" ;
- char *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char * kwnames[] = {
(char *) "self",(char *) "name",(char *) "section_name", NULL
};
+ char *result = 0 ;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ParamFile_get_string",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_param_context, 0 | 0 );
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
char *arg4 = (char *) "global" ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char * kwnames[] = {
(char *) "self",(char *) "param",(char *) "value",(char *) "section", NULL
};
+ int result;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ParamFile_set_string",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_param_context, 0 | 0 );
char *arg2 = (char *) 0 ;
PyObject *arg3 = (PyObject *) 0 ;
char *arg4 = (char *) "global" ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char * kwnames[] = {
(char *) "self",(char *) "parameter",(char *) "ob",(char *) "section_name", NULL
};
+ int result;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ParamFile_set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_param_context, 0 | 0 );
SWIGINTERN PyObject *_wrap_ParamFile_first_section(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
param *arg1 = (param *) 0 ;
- struct param_section *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
+ struct param_section *result = 0 ;
if (!args) SWIG_fail;
swig_obj[0] = args;
PyObject *resultobj = 0;
param *arg1 = (param *) 0 ;
struct param_section *arg2 = (struct param_section *) 0 ;
- struct param_section *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
char * kwnames[] = {
(char *) "self",(char *) "s", NULL
};
+ struct param_section *result = 0 ;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ParamFile_next_section",kwnames,&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_param_context, 0 | 0 );
PyObject *resultobj = 0;
param *arg1 = (param *) 0 ;
char *arg2 = (char *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char * kwnames[] = {
(char *) "self",(char *) "fn", NULL
};
+ int result;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ParamFile_read",kwnames,&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_param_context, 0 | 0 );
PyObject *resultobj = 0;
param *arg1 = (param *) 0 ;
char *arg2 = (char *) 0 ;
- int result;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char * kwnames[] = {
(char *) "self",(char *) "fn", NULL
};
+ int result;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ParamFile_write",kwnames,&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_param_context, 0 | 0 );
}
arg1 = (param *)(argp1);
delete_param(arg1);
-
resultobj = SWIG_Py_Void();
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_param_opt_key_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
param_opt *arg1 = (param_opt *) 0 ;
- char *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
+ char *result = 0 ;
if (!args) SWIG_fail;
swig_obj[0] = args;
SWIGINTERN PyObject *_wrap_param_opt_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
param_opt *arg1 = (param_opt *) 0 ;
- char *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
+ char *result = 0 ;
if (!args) SWIG_fail;
swig_obj[0] = args;
SWIGINTERN PyObject *_wrap_param_opt___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
param_opt *arg1 = (param_opt *) 0 ;
- char *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
+ char *result = 0 ;
if (!args) SWIG_fail;
swig_obj[0] = args;
}
arg1 = (param_opt *)(argp1);
delete_param_opt(arg1);
-
resultobj = SWIG_Py_Void();
return resultobj;
fail:
SWIGINTERN PyObject *_wrap_param_section_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
param_section *arg1 = (param_section *) 0 ;
- char *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
+ char *result = 0 ;
if (!args) SWIG_fail;
swig_obj[0] = args;
PyObject *resultobj = 0;
param_section *arg1 = (param_section *) 0 ;
char *arg2 = (char *) 0 ;
- struct param_opt *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 ;
char * kwnames[] = {
(char *) "self",(char *) "name", NULL
};
+ struct param_opt *result = 0 ;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:param_section_get",kwnames,&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_param_section, 0 | 0 );
SWIGINTERN PyObject *_wrap_param_section_first_parameter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
param_section *arg1 = (param_section *) 0 ;
- struct param_opt *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
+ struct param_opt *result = 0 ;
if (!args) SWIG_fail;
swig_obj[0] = args;
PyObject *resultobj = 0;
param_section *arg1 = (param_section *) 0 ;
struct param_opt *arg2 = (struct param_opt *) 0 ;
- struct param_opt *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
char * kwnames[] = {
(char *) "self",(char *) "s", NULL
};
+ struct param_opt *result = 0 ;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:param_section_next_parameter",kwnames,&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_param_section, 0 | 0 );
}
arg1 = (param_section *)(argp1);
free((char *) arg1);
-
resultobj = SWIG_Py_Void();
return resultobj;
fail:
static swig_type_info _swigt__p_TALLOC_CTX = {"_p_TALLOC_CTX", "TALLOC_CTX *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_int = {"_p_int", "int *|int_least32_t *|int32_t *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_int = {"_p_int", "intptr_t *|int *|int_least32_t *|int_fast32_t *|int32_t *|int_fast16_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_loadparm_context = {"_p_loadparm_context", "struct loadparm_context *|loadparm_context *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_loadparm_service = {"_p_loadparm_service", "struct loadparm_service *|loadparm_service *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_long = {"_p_long", "intptr_t *|int_least64_t *|int_fast32_t *|int_fast64_t *|int64_t *|long *|int_fast16_t *|intmax_t *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_long_long = {"_p_long_long", "int_least64_t *|int_fast64_t *|int64_t *|long long *|intmax_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_param_context = {"_p_param_context", "struct param_context *|param *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_param_opt = {"_p_param_opt", "struct param_opt *|param_opt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_param_section = {"_p_param_section", "struct param_section *|param_section *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_short = {"_p_short", "short *|int_least16_t *|int16_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_signed_char = {"_p_signed_char", "signed char *|int_least8_t *|int_fast8_t *|int8_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|uint_least8_t *|uint_fast8_t *|uint8_t *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "uint_least32_t *|uint32_t *|unsigned int *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "uintptr_t *|uint_least64_t *|uint_fast32_t *|uint_fast64_t *|uint64_t *|unsigned long *|uint_fast16_t *|uintmax_t *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "uintptr_t *|uint_least32_t *|uint_fast32_t *|uint32_t *|unsigned int *|uint_fast16_t *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_long_long = {"_p_unsigned_long_long", "uint_least64_t *|uint_fast64_t *|uint64_t *|unsigned long long *|uintmax_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|uint_least16_t *|uint16_t *", 0, 0, (void*)0, 0};
static swig_type_info *swig_type_initial[] = {
&_swigt__p_int,
&_swigt__p_loadparm_context,
&_swigt__p_loadparm_service,
- &_swigt__p_long,
+ &_swigt__p_long_long,
&_swigt__p_param_context,
&_swigt__p_param_opt,
&_swigt__p_param_section,
&_swigt__p_signed_char,
&_swigt__p_unsigned_char,
&_swigt__p_unsigned_int,
- &_swigt__p_unsigned_long,
+ &_swigt__p_unsigned_long_long,
&_swigt__p_unsigned_short,
};
static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_loadparm_context[] = { {&_swigt__p_loadparm_context, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_loadparm_service[] = { {&_swigt__p_loadparm_service, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_long_long[] = { {&_swigt__p_long_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_param_context[] = { {&_swigt__p_param_context, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_param_opt[] = { {&_swigt__p_param_opt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_param_section[] = { {&_swigt__p_param_section, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_signed_char[] = { {&_swigt__p_signed_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_long_long[] = { {&_swigt__p_unsigned_long_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_short[] = { {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info *swig_cast_initial[] = {
_swigc__p_int,
_swigc__p_loadparm_context,
_swigc__p_loadparm_service,
- _swigc__p_long,
+ _swigc__p_long_long,
_swigc__p_param_context,
_swigc__p_param_opt,
_swigc__p_param_section,
_swigc__p_signed_char,
_swigc__p_unsigned_char,
_swigc__p_unsigned_int,
- _swigc__p_unsigned_long,
+ _swigc__p_unsigned_long_long,
_swigc__p_unsigned_short,
};
ldb = talloc_get_type(ctx->priv_data, struct ldb_context);
- ret = ldb_search(ldb, ldb_dn_new(tmp_ctx, ldb, "CN=SHARES"), LDB_SCOPE_SUBTREE, "(name=*)", NULL, &res);
- talloc_steal(tmp_ctx, res);
+ ret = ldb_search(ldb, tmp_ctx, &res, ldb_dn_new(tmp_ctx, ldb, "CN=SHARES"),
+ LDB_SCOPE_SUBTREE, NULL, "(name=*)");
if (ret != LDB_SUCCESS) {
talloc_free(tmp_ctx);
return NT_STATUS_INTERNAL_DB_CORRUPTION;
ldb = talloc_get_type(ctx->priv_data, struct ldb_context);
- ret = ldb_search_exp_fmt(ldb, tmp_ctx, &res,
+ ret = ldb_search(ldb, tmp_ctx, &res,
ldb_dn_new(tmp_ctx, ldb, "CN=SHARES"), LDB_SCOPE_SUBTREE, NULL,
"(name=%s)", name);
if (ret != LDB_SUCCESS || res->count > 1) {
[MODULE::DCESRV]
INIT_FUNCTION = server_service_rpc_init
-SUBSYSTEM = smbd
+SUBSYSTEM = samba
PRIVATE_DEPENDENCIES = dcerpc_server
DCESRV_OBJ_FILES = $(rpc_serversrcdir)/service_rpc.o
call->context = context;
call->ndr_pull = pull;
- if (call->pkt.pfc_flags & DCERPC_PFC_FLAG_OBJECT_UUID) {
- pull->flags |= LIBNDR_FLAG_OBJECT_PRESENT;
- }
-
if (!(call->pkt.drep[0] & DCERPC_DREP_LE)) {
pull->flags |= LIBNDR_FLAG_BIGENDIAN;
}
ndr->flags |= LIBNDR_FLAG_BIGENDIAN;
}
+ if (CVAL(blob.data, DCERPC_PFC_OFFSET) & DCERPC_PFC_FLAG_OBJECT_UUID) {
+ ndr->flags |= LIBNDR_FLAG_OBJECT_PRESENT;
+ }
+
ndr_err = ndr_pull_ncacn_packet(ndr, NDR_SCALARS|NDR_BUFFERS, &call->pkt);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(dce_conn->partial_input.data);
return false;
}
+ if (call->conn->state_flags & DCESRV_CALL_STATE_FLAG_HEADER_SIGNING) {
+ gensec_want_feature(auth->gensec_security, GENSEC_FEATURE_SIGN_PKT_HEADER);
+ }
+
return true;
}
struct ndr_pull *ndr;
NTSTATUS status;
enum ndr_err_code ndr_err;
+ size_t hdr_size = DCERPC_REQUEST_LENGTH;
if (!dce_conn->auth_state.auth_info ||
!dce_conn->auth_state.gensec_security) {
ndr->flags |= LIBNDR_FLAG_BIGENDIAN;
}
+ if (pkt->pfc_flags & DCERPC_PFC_FLAG_OBJECT_UUID) {
+ ndr->flags |= LIBNDR_FLAG_OBJECT_PRESENT;
+ hdr_size += 16;
+ }
+
ndr_err = ndr_pull_dcerpc_auth(ndr, NDR_SCALARS|NDR_BUFFERS, &auth);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(ndr);
case DCERPC_AUTH_LEVEL_PRIVACY:
status = gensec_unseal_packet(dce_conn->auth_state.gensec_security,
call,
- full_packet->data + DCERPC_REQUEST_LENGTH,
+ full_packet->data + hdr_size,
pkt->u.request.stub_and_verifier.length,
full_packet->data,
full_packet->length-auth.credentials.length,
&auth.credentials);
memcpy(pkt->u.request.stub_and_verifier.data,
- full_packet->data + DCERPC_REQUEST_LENGTH,
+ full_packet->data + hdr_size,
pkt->u.request.stub_and_verifier.length);
break;
server_site_dn = samdb_server_site_dn(b_state->sam_ctx, mem_ctx);
W_ERROR_HAVE_NO_MEMORY(server_site_dn);
- ret = ldb_search_exp_fmt(b_state->sam_ctx, mem_ctx, &site_res,
+ ret = ldb_search(b_state->sam_ctx, mem_ctx, &site_res,
server_site_dn, LDB_SCOPE_BASE, site_attrs,
"(objectClass=*)");
if (ret != LDB_SUCCESS) {
ntds_dn = samdb_ntds_settings_dn(b_state->sam_ctx);
W_ERROR_HAVE_NO_MEMORY(ntds_dn);
- ret = ldb_search_exp_fmt(b_state->sam_ctx, mem_ctx, &ntds_res,
+ ret = ldb_search(b_state->sam_ctx, mem_ctx, &ntds_res,
ntds_dn, LDB_SCOPE_BASE, ntds_attrs,
"(objectClass=*)");
if (ret != LDB_SUCCESS) {
return WERR_UNKNOWN_LEVEL;
}
- ret = ldb_search_exp_fmt(b_state->sam_ctx, mem_ctx, &res, sites_dn, LDB_SCOPE_SUBTREE, attrs,
+ ret = ldb_search(b_state->sam_ctx, mem_ctx, &res, sites_dn, LDB_SCOPE_SUBTREE, attrs,
"objectClass=server");
if (ret) {
return WERR_NOMEM;
}
- ret = ldb_search_exp_fmt(b_state->sam_ctx, mem_ctx, &res_account, ref_dn,
+ ret = ldb_search(b_state->sam_ctx, mem_ctx, &res_account, ref_dn,
LDB_SCOPE_BASE, attrs_account_1, "objectClass=computer");
if (ret == LDB_SUCCESS && res_account->count == 1) {
const char *errstr;
&domain_dn, &errstr);
if (ret == LDB_SUCCESS) {
- ret = ldb_search_exp_fmt(b_state->sam_ctx, mem_ctx, &res_domain, domain_dn,
+ ret = ldb_search(b_state->sam_ctx, mem_ctx, &res_domain, domain_dn,
LDB_SCOPE_BASE, attrs_none, "fSMORoleOwner=%s",
ldb_dn_get_linearized(ntds_dn));
if (ret) {
return WERR_NOMEM;
}
- ret = ldb_search_exp_fmt(b_state->sam_ctx, mem_ctx, &res_ntds, ntds_dn,
+ ret = ldb_search(b_state->sam_ctx, mem_ctx, &res_ntds, ntds_dn,
LDB_SCOPE_BASE, attrs_ntds, "objectClass=nTDSDSA");
if (ret == LDB_SUCCESS && res_ntds->count == 1) {
ctr2->array[i].is_gc
ldb_dn_get_linearized(ntds_dn), ldb_errstring(b_state->sam_ctx)));
}
- ret = ldb_search_exp_fmt(b_state->sam_ctx, mem_ctx, &res_site, site_dn,
+ ret = ldb_search(b_state->sam_ctx, mem_ctx, &res_site, site_dn,
LDB_SCOPE_BASE, attrs_site, "objectClass=site");
if (ret == LDB_SUCCESS && res_site->count == 1) {
ctr2->array[i].site_guid
ldb_dn_get_linearized(site_dn), ldb_errstring(b_state->sam_ctx)));
}
- ret = ldb_search_exp_fmt(b_state->sam_ctx, mem_ctx, &res_account, ref_dn,
+ ret = ldb_search(b_state->sam_ctx, mem_ctx, &res_account, ref_dn,
LDB_SCOPE_BASE, attrs_account_2, "objectClass=computer");
if (ret == LDB_SUCCESS && res_account->count == 1) {
const char *errstr;
&domain_dn, &errstr);
if (ret == LDB_SUCCESS) {
- ret = ldb_search_exp_fmt(b_state->sam_ctx, mem_ctx, &res_domain, domain_dn,
+ ret = ldb_search(b_state->sam_ctx, mem_ctx, &res_domain, domain_dn,
LDB_SCOPE_BASE, attrs_none, "fSMORoleOwner=%s",
ldb_dn_get_linearized(ntds_dn));
if (ret == LDB_SUCCESS && res_domain->count == 1) {
static int dcesrv_handle_destructor(struct dcesrv_handle *h)
{
DLIST_REMOVE(h->context->handles, h);
- talloc_free(h);
return 0;
}
+/* need access mask/acl implementation */
+
/*
Unix SMB/CIFS implementation.
#include "auth/kerberos/kerberos.h"
#include "librpc/gen_ndr/ndr_drsblobs.h"
#include "librpc/gen_ndr/ndr_lsa.h"
-#include "lib/crypto/crypto.h"
+#include "../lib/crypto/crypto.h"
/*
this type allows us to distinguish handle types
return NT_STATUS_OK;
} else if (h->wire_handle.handle_type == LSA_HANDLE_TRUSTED_DOMAIN) {
- struct lsa_trusted_domain_state *trusted_domain_state = h->data;
+ struct lsa_trusted_domain_state *trusted_domain_state =
+ talloc_get_type(h->data, struct lsa_trusted_domain_state);
ret = ldb_transaction_start(trusted_domain_state->policy->sam_ldb);
if (ret != 0) {
return NT_STATUS_INTERNAL_DB_CORRUPTION;
r2.in.sid = astate->account_sid;
r2.out.rights = rights;
+ /* dcesrv_lsa_EnumAccountRights takes a LSA_HANDLE_POLICY,
+ but we have a LSA_HANDLE_ACCOUNT here, so this call
+ will always fail */
status = dcesrv_lsa_EnumAccountRights(dce_call, mem_ctx, &r2);
if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
return NT_STATUS_OK;
ZERO_STRUCTP(r->out.info);
switch (r->in.level) {
+ case LSA_POLICY_INFO_AUDIT_LOG:
+ /* we don't need to fill in any of this */
+ ZERO_STRUCT(r->out.info->audit_log);
+ return NT_STATUS_OK;
+ case LSA_POLICY_INFO_AUDIT_EVENTS:
+ /* we don't need to fill in any of this */
+ ZERO_STRUCT(r->out.info->audit_events);
+ return NT_STATUS_OK;
+ case LSA_POLICY_INFO_PD:
+ /* we don't need to fill in any of this */
+ ZERO_STRUCT(r->out.info->pd);
+ return NT_STATUS_OK;
case LSA_POLICY_INFO_DOMAIN:
case LSA_POLICY_INFO_ACCOUNT_DOMAIN:
return dcesrv_lsa_info_AccountDomain(state, mem_ctx, &r->out.info->account_domain);
+ case LSA_POLICY_INFO_ROLE:
+ r->out.info->role.role = LSA_ROLE_PRIMARY;
+ return NT_STATUS_OK;
case LSA_POLICY_INFO_DNS:
+ case LSA_POLICY_INFO_DNS_INT:
return dcesrv_lsa_info_DNS(state, mem_ctx, &r->out.info->dns);
- case LSA_POLICY_INFO_DB:
+
+ case LSA_POLICY_INFO_REPLICA:
+ ZERO_STRUCT(r->out.info->replica);
+ return NT_STATUS_OK;
+
+ case LSA_POLICY_INFO_QUOTA:
+ ZERO_STRUCT(r->out.info->quota);
+ return NT_STATUS_OK;
+
case LSA_POLICY_INFO_AUDIT_FULL_SET:
+ case LSA_POLICY_INFO_DB:
case LSA_POLICY_INFO_AUDIT_FULL_QUERY:
+ /* windows gives INVALID_PARAMETER */
+ r->out.info = NULL;
return NT_STATUS_INVALID_PARAMETER;
}
+ r->out.info = NULL;
return NT_STATUS_INVALID_INFO_CLASS;
}
struct lsa_QueryInfoPolicy2 r2;
NTSTATUS status;
+ ZERO_STRUCT(r2);
+
r2.in.handle = r->in.handle;
r2.in.level = r->in.level;
static NTSTATUS dcesrv_lsa_SetInfoPolicy(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
struct lsa_SetInfoPolicy *r)
{
+ /* need to support this */
DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
}
lsa_CreateAccount
This call does not seem to have any long-term effects, hence no database operations
+
+ we need to talk to the MS product group to find out what this account database means!
+
+ answer is that the lsa database is totally separate from the SAM and
+ ldap databases. We are going to need a separate ldb to store these
+ accounts. The SIDs on this account bear no relation to the SIDs in
+ AD
*/
static NTSTATUS dcesrv_lsa_CreateAccount(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
struct lsa_CreateAccount *r)
const char *name;
DATA_BLOB session_key = data_blob(NULL, 0);
DATA_BLOB trustAuthIncoming, trustAuthOutgoing, auth_blob;
- struct trustAuthInAndOutBlob auth_struct;
+ struct trustDomainPasswords auth_struct;
int ret;
NTSTATUS nt_status;
enum ndr_err_code ndr_err;
dns_name = r->in.info->domain_name.string;
- trusted_domain_state = talloc(mem_ctx, struct lsa_trusted_domain_state);
+ trusted_domain_state = talloc_zero(mem_ctx, struct lsa_trusted_domain_state);
if (!trusted_domain_state) {
return NT_STATUS_NO_MEMORY;
}
ndr_err = ndr_pull_struct_blob(&auth_blob, mem_ctx,
lp_iconv_convenience(dce_call->conn->dce_ctx->lp_ctx),
&auth_struct,
- (ndr_pull_flags_fn_t)ndr_pull_trustAuthInAndOutBlob);
+ (ndr_pull_flags_fn_t)ndr_pull_trustDomainPasswords);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return NT_STATUS_INVALID_PARAMETER;
}
+
+ if (op == NDR_LSA_CREATETRUSTEDDOMAINEX) {
+ if (auth_struct.incoming.count > 1) {
+ return NT_STATUS_INVALID_PARAMETER;
+ }
+ }
}
if (auth_struct.incoming.count) {
+ int i;
+ struct trustAuthInOutBlob incoming;
+
+ incoming.count = auth_struct.incoming.count;
+ incoming.current = talloc(mem_ctx, struct AuthenticationInformationArray);
+ if (!incoming.current) {
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ incoming.current->array = *auth_struct.incoming.current;
+ if (!incoming.current->array) {
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ incoming.previous = talloc(mem_ctx, struct AuthenticationInformationArray);
+ if (!incoming.previous) {
+ return NT_STATUS_NO_MEMORY;
+ }
+ incoming.previous->array = talloc_array(mem_ctx, struct AuthenticationInformation, incoming.count);
+ if (!incoming.previous->array) {
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ for (i = 0; i < incoming.count; i++) {
+ incoming.previous->array[i].LastUpdateTime = 0;
+ incoming.previous->array[i].AuthType = 0;
+ }
ndr_err = ndr_push_struct_blob(&trustAuthIncoming, mem_ctx,
lp_iconv_convenience(dce_call->conn->dce_ctx->lp_ctx),
- &auth_struct.incoming,
+ &incoming,
(ndr_push_flags_fn_t)ndr_push_trustAuthInOutBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return NT_STATUS_INVALID_PARAMETER;
}
if (auth_struct.outgoing.count) {
+ int i;
+ struct trustAuthInOutBlob outgoing;
+
+ outgoing.count = auth_struct.outgoing.count;
+ outgoing.current = talloc(mem_ctx, struct AuthenticationInformationArray);
+ if (!outgoing.current) {
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ outgoing.current->array = *auth_struct.outgoing.current;
+ if (!outgoing.current->array) {
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ outgoing.previous = talloc(mem_ctx, struct AuthenticationInformationArray);
+ if (!outgoing.previous) {
+ return NT_STATUS_NO_MEMORY;
+ }
+ outgoing.previous->array = talloc_array(mem_ctx, struct AuthenticationInformation, outgoing.count);
+ if (!outgoing.previous->array) {
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ for (i = 0; i < outgoing.count; i++) {
+ outgoing.previous->array[i].LastUpdateTime = 0;
+ outgoing.previous->array[i].AuthType = 0;
+ }
ndr_err = ndr_push_struct_blob(&trustAuthOutgoing, mem_ctx,
lp_iconv_convenience(dce_call->conn->dce_ctx->lp_ctx),
- &auth_struct.outgoing,
+ &outgoing,
(ndr_push_flags_fn_t)ndr_push_trustAuthInOutBlob);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return NT_STATUS_INVALID_PARAMETER;
if (auth_struct.incoming.count) {
int i;
for (i=0; i < auth_struct.incoming.count; i++ ) {
- if (auth_struct.incoming.current->array[i].AuthType == TRUST_AUTH_TYPE_NT4OWF) {
+ if (auth_struct.incoming.current[i]->AuthType == TRUST_AUTH_TYPE_NT4OWF) {
samdb_msg_add_hash(trusted_domain_state->policy->sam_ldb,
mem_ctx, msg_user, "unicodePwd",
- &auth_struct.incoming.current->array[i].AuthInfo.nt4owf.password);
- } else if (auth_struct.incoming.current->array[i].AuthType == TRUST_AUTH_TYPE_CLEAR) {
+ &auth_struct.incoming.current[i]->AuthInfo.nt4owf.password);
+ } else if (auth_struct.incoming.current[i]->AuthType == TRUST_AUTH_TYPE_CLEAR) {
struct samr_Password hash;
/*
. We cannot do this, as windows chooses to send in random passwords here, that won't convert to UTF8
mem_ctx, msg_user, "userPassword",
auth_struct.incoming.current->array[i].AuthInfo.clear.password);
*/
- mdfour(hash.hash, auth_struct.incoming.current->array[i].AuthInfo.clear.password,
- auth_struct.incoming.current->array[i].AuthInfo.clear.size);
+ mdfour(hash.hash, auth_struct.incoming.current[i]->AuthInfo.clear.password,
+ auth_struct.incoming.current[i]->AuthInfo.clear.size);
samdb_msg_add_hash(trusted_domain_state->policy->sam_ldb,
mem_ctx, msg_user, "unicodePwd",
&hash);
ZERO_STRUCTP(r->out.trustdom_handle);
policy_state = policy_handle->data;
- trusted_domain_state = talloc(mem_ctx, struct lsa_trusted_domain_state);
+ trusted_domain_state = talloc_zero(mem_ctx, struct lsa_trusted_domain_state);
if (!trusted_domain_state) {
return NT_STATUS_NO_MEMORY;
}
return NT_STATUS_INVALID_PARAMETER;
}
- trusted_domain_state = talloc(mem_ctx, struct lsa_trusted_domain_state);
+ trusted_domain_state = talloc_zero(mem_ctx, struct lsa_trusted_domain_state);
if (!trusted_domain_state) {
return NT_STATUS_NO_MEMORY;
}
DCESRV_PULL_HANDLE(h, r->in.trustdom_handle, LSA_HANDLE_TRUSTED_DOMAIN);
- trusted_domain_state = h->data;
+ trusted_domain_state = talloc_get_type(h->data, struct lsa_trusted_domain_state);
/* pull all the user attributes */
ret = gendb_search_dn(trusted_domain_state->policy->sam_ldb, mem_ctx,
TALLOC_CTX *mem_ctx,
struct lsa_SetInfoPolicy2 *r)
{
+ /* need to support these */
DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
}
return NT_STATUS_NO_MEMORY;
}
- ret = ldb_search(state->sam_ldb, state->domain_dn, LDB_SCOPE_BASE, NULL, dom_attrs, &dom_res);
-
+ ret = ldb_search(state->sam_ldb, mem_ctx, &dom_res,
+ state->domain_dn, LDB_SCOPE_BASE, dom_attrs, NULL);
if (ret != LDB_SUCCESS) {
return NT_STATUS_INVALID_SYSTEM_SERVICE;
}
- talloc_steal(mem_ctx, dom_res);
if (dom_res->count != 1) {
return NT_STATUS_NO_SUCH_DOMAIN;
}
talloc_free(dom_res);
- ret = ldb_search_exp_fmt(state->sam_ldb, state, &ref_res,
+ ret = ldb_search(state->sam_ldb, state, &ref_res,
partitions_basedn, LDB_SCOPE_SUBTREE, ref_attrs,
"(&(objectclass=crossRef)(ncName=%s))",
ldb_dn_get_linearized(state->domain_dn));
talloc_free(ref_res);
- ret = ldb_search_exp_fmt(state->sam_ldb, state, &forest_ref_res,
+ ret = ldb_search(state->sam_ldb, state, &forest_ref_res,
partitions_basedn, LDB_SCOPE_SUBTREE, ref_attrs,
"(&(objectclass=crossRef)(ncName=%s))",
ldb_dn_get_linearized(state->forest_dn));
ZERO_STRUCTP(r->out.handle);
+ if (r->in.attr != NULL &&
+ r->in.attr->root_dir != NULL) {
+ /* MS-LSAD 3.1.4.4.1 */
+ return NT_STATUS_INVALID_PARAMETER;
+ }
+
status = dcesrv_lsa_get_policy_state(dce_call, mem_ctx, &state);
if (!NT_STATUS_IS_OK(status)) {
return status;
handle->data = talloc_steal(handle, state);
+ /* need to check the access mask against - need ACLs - fails
+ WSPP test */
state->access_mask = r->in.access_mask;
state->handle = handle;
*r->out.handle = handle->wire_handle;
.sid = SID_CREATOR_GROUP,
.rtype = SID_NAME_WKN_GRP,
},
+ {
+ .name = "Owner Rights",
+ .sid = SID_OWNER_RIGHTS,
+ .rtype = SID_NAME_WKN_GRP,
+ },
{
.domain = "NT AUTHORITY",
.name = "Dialup",
},
{
.domain = "NT AUTHORITY",
- .name = "Termainal Server User",
+ .name = "Terminal Server User",
.sid = SID_NT_TERMINAL_SERVER_USERS,
.rtype = SID_NAME_WKN_GRP,
},
.sid = SID_NT_NETWORK_SERVICE,
.rtype = SID_NAME_WKN_GRP,
},
+ {
+ .domain = "NT AUTHORITY",
+ .name = "Digest Authentication",
+ .sid = SID_NT_DIGEST_AUTHENTICATION,
+ .rtype = SID_NAME_WKN_GRP,
+ },
+ {
+ .domain = "NT AUTHORITY",
+ .name = "Enterprise Domain Controllers",
+ .sid = SID_NT_ENTERPRISE_DCS,
+ .rtype = SID_NAME_WKN_GRP,
+ },
+ {
+ .domain = "NT AUTHORITY",
+ .name = "NTLM Authentication",
+ .sid = SID_NT_NTLM_AUTHENTICATION,
+ .rtype = SID_NAME_WKN_GRP,
+ },
+ {
+ .domain = "NT AUTHORITY",
+ .name = "Other Organization",
+ .sid = SID_NT_OTHER_ORGANISATION,
+ .rtype = SID_NAME_WKN_GRP,
+ },
+ {
+ .domain = "NT AUTHORITY",
+ .name = "SChannel Authentication",
+ .sid = SID_NT_SCHANNEL_AUTHENTICATION,
+ .rtype = SID_NAME_WKN_GRP,
+ },
+ {
+ .domain = "NT AUTHORITY",
+ .name = "IUSR",
+ .sid = SID_NT_IUSR,
+ .rtype = SID_NAME_WKN_GRP,
+ },
{
.sid = NULL,
}
int i;
NTSTATUS status = NT_STATUS_OK;
+ if (r->in.level < LSA_LOOKUP_NAMES_ALL ||
+ r->in.level > LSA_LOOKUP_NAMES_RODC_REFERRAL_TO_FULL_DC) {
+ return NT_STATUS_INVALID_PARAMETER;
+ }
+
r->out.domains = NULL;
+ /* NOTE: the WSPP test suite tries SIDs with invalid revision numbers,
+ and expects NT_STATUS_INVALID_PARAMETER back - we just treat it as
+ an unknown SID. We could add a SID validator here. (tridge)
+ MS-DTYP 2.4.2
+ */
+
status = dcesrv_lsa_get_policy_state(dce_call, mem_ctx, &state);
if (!NT_STATUS_IS_OK(status)) {
return status;
authority_name, sid,
r->out.domains, &sid_index);
if (!NT_STATUS_IS_OK(status2)) {
- return status2;
+ continue;
}
r->out.names->names[i].sid_type = rtype;
NTSTATUS status;
struct dcesrv_handle *h;
+ ZERO_STRUCT(r2);
+
/* No policy handle on the wire, so make one up here */
r2.in.handle = talloc(mem_ctx, struct policy_handle);
if (!r2.in.handle) {
r2.out.names = r->out.names;
status = dcesrv_lsa_LookupSids2(dce_call, mem_ctx, &r2);
- if (dce_call->fault_code != 0) {
- return status;
- }
r->out.domains = r2.out.domains;
r->out.names = r2.out.names;
NTSTATUS status;
int i;
+ ZERO_STRUCT(r2);
+
r2.in.handle = r->in.handle;
r2.in.sids = r->in.sids;
r2.in.names = NULL;
r2.out.names = NULL;
status = dcesrv_lsa_LookupSids2(dce_call, mem_ctx, &r2);
- if (dce_call->fault_code != 0) {
- return status;
- }
+ /* we deliberately don't check for error from the above,
+ as even on error we are supposed to return the names */
r->out.domains = r2.out.domains;
if (!r2.out.names) {
DCESRV_PULL_HANDLE(policy_handle, r->in.handle, LSA_HANDLE_POLICY);
+ if (r->in.level < LSA_LOOKUP_NAMES_ALL ||
+ r->in.level > LSA_LOOKUP_NAMES_RODC_REFERRAL_TO_FULL_DC) {
+ return NT_STATUS_INVALID_PARAMETER;
+ }
+
policy_state = policy_handle->data;
r->out.domains = NULL;
r->out.sids->sids[i].sid_type = SID_NAME_UNKNOWN;
r->out.sids->sids[i].sid = NULL;
r->out.sids->sids[i].sid_index = 0xFFFFFFFF;
- r->out.sids->sids[i].unknown = 0;
+ r->out.sids->sids[i].flags = 0;
status2 = dcesrv_lsa_lookup_name(dce_call->event_ctx, lp_ctx, policy_state, mem_ctx, name, &authority_name, &sid, &rtype);
if (!NT_STATUS_IS_OK(status2) || sid->num_auths == 0) {
status2 = dcesrv_lsa_authority_list(policy_state, mem_ctx, rtype, authority_name,
sid, r->out.domains, &sid_index);
if (!NT_STATUS_IS_OK(status2)) {
- return status2;
+ continue;
}
r->out.sids->sids[i].sid_type = rtype;
r->out.sids->sids[i].sid = sid;
r->out.sids->sids[i].sid_index = sid_index;
- r->out.sids->sids[i].unknown = 0;
+ r->out.sids->sids[i].flags = 0;
(*r->out.count)++;
}
NTSTATUS status;
struct dcesrv_handle *h;
+ ZERO_STRUCT(r2);
+
/* No policy handle on the wire, so make one up here */
r2.in.handle = talloc(mem_ctx, struct policy_handle);
if (!r2.in.handle) {
r2.in.num_names = r->in.num_names;
r2.in.names = r->in.names;
+ r2.in.level = r->in.level;
r2.in.sids = r->in.sids;
r2.in.count = r->in.count;
- r2.in.unknown1 = r->in.unknown1;
- r2.in.unknown2 = r->in.unknown2;
+ r2.in.lookup_options = r->in.lookup_options;
+ r2.in.client_revision = r->in.client_revision;
r2.out.domains = r->out.domains;
r2.out.sids = r->out.sids;
r2.out.count = r->out.count;
status = dcesrv_lsa_LookupNames3(dce_call, mem_ctx, &r2);
- if (dce_call->fault_code != 0) {
- return status;
- }
r->out.domains = r2.out.domains;
r->out.sids = r2.out.sids;
DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_POLICY);
+ if (r->in.level < LSA_LOOKUP_NAMES_ALL ||
+ r->in.level > LSA_LOOKUP_NAMES_RODC_REFERRAL_TO_FULL_DC) {
+ return NT_STATUS_INVALID_PARAMETER;
+ }
+
state = h->data;
r->out.domains = talloc_zero(mem_ctx, struct lsa_RefDomainList);
r->out.sids->count++;
r->out.sids->sids[i].sid_type = SID_NAME_UNKNOWN;
- r->out.sids->sids[i].rid = 0xFFFFFFFF;
+ /* MS-LSAT 3.1.4.7 - rid zero is considered equivalent
+ to sid NULL - so we should return 0 rid for
+ unmapped entries */
+ r->out.sids->sids[i].rid = 0;
r->out.sids->sids[i].sid_index = 0xFFFFFFFF;
r->out.sids->sids[i].unknown = 0;
status2 = dcesrv_lsa_authority_list(state, mem_ctx, rtype, authority_name,
sid, r->out.domains, &sid_index);
if (!NT_STATUS_IS_OK(status2)) {
- return status2;
+ continue;
}
r->out.sids->sids[i].sid_type = rtype;
NTSTATUS status;
int i;
+ ZERO_STRUCT(r2);
+
r2.in.handle = r->in.handle;
r2.in.num_names = r->in.num_names;
r2.in.names = r->in.names;
r2.in.sids = NULL;
r2.in.level = r->in.level;
r2.in.count = r->in.count;
- r2.in.unknown1 = 0;
- r2.in.unknown2 = 0;
+ r2.in.lookup_options = 0;
+ r2.in.client_revision = 0;
r2.out.count = r->out.count;
status = dcesrv_lsa_LookupNames2(dce_call, mem_ctx, &r2);
- if (dce_call->fault_code != 0) {
+ if (r2.out.sids == NULL) {
return status;
}
#include "param/param.h"
#include "lib/messaging/irpc.h"
#include "librpc/gen_ndr/ndr_irpc.h"
+#include "librpc/gen_ndr/ndr_netlogon.h"
struct server_pipe_state {
struct netr_Credential client_challenge;
const char *attrs[] = {"unicodePwd", "userAccountControl",
"objectSid", NULL};
+ const char *trust_dom_attrs[] = {"flatname", NULL};
+ const char *account_name;
+
ZERO_STRUCTP(r->out.credentials);
*r->out.rid = 0;
*r->out.negotiate_flags = *r->in.negotiate_flags;
if (sam_ctx == NULL) {
return NT_STATUS_INVALID_SYSTEM_SERVICE;
}
+
+ if (r->in.secure_channel_type == SEC_CHAN_DNS_DOMAIN) {
+ char *encoded_account = ldb_binary_encode_string(mem_ctx, r->in.account_name);
+ char *flatname;
+ if (!encoded_account) {
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ /* Kill the trailing dot */
+ if (encoded_account[strlen(encoded_account)-1] == '.') {
+ encoded_account[strlen(encoded_account)-1] = '\0';
+ }
+
+ /* pull the user attributes */
+ num_records = gendb_search(sam_ctx, mem_ctx, NULL, &msgs, trust_dom_attrs,
+ "(&(trustPartner=%s)(objectclass=trustedDomain))",
+ encoded_account);
+
+ if (num_records == 0) {
+ DEBUG(3,("Couldn't find trust [%s] in samdb.\n",
+ encoded_account));
+ return NT_STATUS_ACCESS_DENIED;
+ }
+
+ if (num_records > 1) {
+ DEBUG(0,("Found %d records matching user [%s]\n", num_records, r->in.account_name));
+ return NT_STATUS_INTERNAL_DB_CORRUPTION;
+ }
+
+ flatname = ldb_msg_find_attr_as_string(msgs[0], "flatname", NULL);
+ if (!flatname) {
+ /* No flatname for this trust - we can't proceed */
+ return NT_STATUS_ACCESS_DENIED;
+ }
+ account_name = talloc_asprintf(mem_ctx, "%s$", flatname);
+
+ if (!account_name) {
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ } else {
+ account_name = r->in.account_name;
+ }
+
/* pull the user attributes */
num_records = gendb_search(sam_ctx, mem_ctx, NULL, &msgs, attrs,
"(&(sAMAccountName=%s)(objectclass=user))",
- r->in.account_name);
+ ldb_binary_encode_string(mem_ctx, account_name));
if (num_records == 0) {
DEBUG(3,("Couldn't find user [%s] in samdb.\n",
DEBUG(1, ("Client asked for a workstation secure channel, but is not a workstation (member server) acb flags: 0x%x\n", user_account_control));
return NT_STATUS_ACCESS_DENIED;
}
- } else if (r->in.secure_channel_type == SEC_CHAN_DOMAIN) {
+ } else if (r->in.secure_channel_type == SEC_CHAN_DOMAIN ||
+ r->in.secure_channel_type == SEC_CHAN_DNS_DOMAIN) {
if (!(user_account_control & UF_INTERDOMAIN_TRUST_ACCOUNT)) {
DEBUG(1, ("Client asked for a trusted domain secure channel, but is not a trusted domain: acb flags: 0x%x\n", user_account_control));
struct ldb_context *sam_ctx;
NTSTATUS nt_status;
char new_pass[512];
- uint32_t new_pass_len;
bool ret;
struct samr_CryptPassword password_buf;
creds_arcfour_crypt(creds, password_buf.data, 516);
ret = decode_pw_buffer(password_buf.data, new_pass, sizeof(new_pass),
- &new_pass_len, STR_UNICODE);
+ STR_UNICODE);
if (!ret) {
DEBUG(3,("netr_ServerPasswordSet2: failed to decode password buffer\n"));
return NT_STATUS_ACCESS_DENIED;
struct ldb_message *res,
struct ldb_message *ref_res,
struct netr_DomainTrustInfo *info,
- bool is_local)
+ bool is_local, bool is_trust_list)
{
ZERO_STRUCTP(info);
+ info->trust_extension.info = talloc_zero(mem_ctx, struct netr_trust_extension);
+ info->trust_extension.length = 16;
+ info->trust_extension.info->flags =
+ NETR_TRUST_FLAG_TREEROOT |
+ NETR_TRUST_FLAG_IN_FOREST |
+ NETR_TRUST_FLAG_PRIMARY;
+ info->trust_extension.info->parent_index = 0; /* should be index into array
+ of parent */
+ info->trust_extension.info->trust_type = LSA_TRUST_TYPE_UPLEVEL; /* should be based on ldb search for trusts */
+ info->trust_extension.info->trust_attributes = LSA_TRUST_ATTRIBUTE_NON_TRANSITIVE; /* needs to be based on ldb search */
+
+ if (is_trust_list) {
+ /* MS-NRPC 3.5.4.3.9 - must be set to NULL for trust list */
+ info->forest.string = NULL;
+ } else {
+ /* TODO: we need a common function for pulling the forest */
+ info->forest.string = samdb_result_string(ref_res, "dnsRoot", NULL);
+ }
+
if (is_local) {
info->domainname.string = samdb_result_string(ref_res, "nETBIOSName", NULL);
info->fulldomainname.string = samdb_result_string(ref_res, "dnsRoot", NULL);
- info->forest.string = NULL;
info->guid = samdb_result_guid(res, "objectGUID");
info->sid = samdb_result_dom_sid(mem_ctx, res, "objectSid");
} else {
info->domainname.string = samdb_result_string(res, "flatName", NULL);
info->fulldomainname.string = samdb_result_string(res, "trustPartner", NULL);
- info->forest.string = NULL;
info->guid = samdb_result_guid(res, "objectGUID");
info->sid = samdb_result_dom_sid(mem_ctx, res, "securityIdentifier");
}
r->in.credential,
r->out.return_authenticator,
NULL);
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(0,(__location__ " Bad credentials - error\n"));
+ }
NT_STATUS_NOT_OK_RETURN(status);
sam_ctx = samdb_connect(mem_ctx, dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, dce_call->conn->auth_state.session_info);
info1->num_trusts);
NT_STATUS_HAVE_NO_MEMORY(info1->trusts);
- status = fill_domain_trust_info(mem_ctx, res1[0], ref_res[0], &info1->domaininfo, true);
+ status = fill_domain_trust_info(mem_ctx, res1[0], ref_res[0], &info1->domaininfo,
+ true, false);
NT_STATUS_NOT_OK_RETURN(status);
for (i=0;i<ret2;i++) {
- status = fill_domain_trust_info(mem_ctx, res2[i], NULL, &info1->trusts[i], false);
+ status = fill_domain_trust_info(mem_ctx, res2[i], NULL, &info1->trusts[i],
+ false, true);
NT_STATUS_NOT_OK_RETURN(status);
}
- status = fill_domain_trust_info(mem_ctx, res1[0], ref_res[0], &info1->trusts[i], true);
+ status = fill_domain_trust_info(mem_ctx, res1[0], ref_res[0], &info1->trusts[i],
+ true, true);
NT_STATUS_NOT_OK_RETURN(status);
+ info1->dns_hostname.string = samdb_result_string(ref_res[0], "dnsRoot", NULL);
+ info1->workstation_flags =
+ NETR_WS_FLAG_HANDLES_INBOUND_TRUSTS | NETR_WS_FLAG_HANDLES_SPN_UPDATE;
+ info1->supported_enc_types = 0; /* w2008 gives this 0 */
+
r->out.info.info1 = info1;
return NT_STATUS_OK;
partitions_basedn = samdb_partitions_dn(c_state->sam_ctx, mem_ctx);
- ret = ldb_search_exp_fmt(c_state->sam_ctx, mem_ctx, &dom_res, ldb_get_default_basedn(c_state->sam_ctx),
+ ret = ldb_search(c_state->sam_ctx, mem_ctx, &dom_res, ldb_get_default_basedn(c_state->sam_ctx),
LDB_SCOPE_SUBTREE, dom_attrs, "(|(|(objectClass=domain)(objectClass=builtinDomain))(objectClass=samba4LocalDomain))");
if (ret != LDB_SUCCESS) {
DEBUG(0,("samdb: unable to find domains: %s\n", ldb_errstring(c_state->sam_ctx)));
for (i=0;i<dom_res->count-start_i;i++) {
array->entries[i].idx = start_i + i;
/* try and find the domain */
- ret = ldb_search_exp_fmt(c_state->sam_ctx, mem_ctx, &ref_res, partitions_basedn,
+ ret = ldb_search(c_state->sam_ctx, mem_ctx, &ref_res, partitions_basedn,
LDB_SCOPE_SUBTREE, ref_attrs, "(&(objectClass=crossRef)(ncName=%s))",
ldb_dn_get_linearized(dom_res->msgs[i]->dn));
d_state = h->data;
/* don't have to worry about users in the builtin domain, as there are none */
- ret = ldb_search_exp_fmt(d_state->sam_ctx, mem_ctx, &res, d_state->domain_dn, LDB_SCOPE_SUBTREE, attrs, "objectClass=user");
+ ret = ldb_search(d_state->sam_ctx, mem_ctx, &res, d_state->domain_dn, LDB_SCOPE_SUBTREE, attrs, "objectClass=user");
if (ret != LDB_SUCCESS) {
DEBUG(3, ("Failed to search for Domain Users in %s: %s\n",
a_state = h->data;
- ret = ldb_search_exp_fmt(a_state->sam_ctx, mem_ctx, &res, a_state->account_dn, LDB_SCOPE_SUBTREE, attrs, "objectClass=*");
+ ret = ldb_search(a_state->sam_ctx, mem_ctx, &res, a_state->account_dn, LDB_SCOPE_SUBTREE, attrs, "objectClass=*");
if (ret == LDB_ERR_NO_SUCH_OBJECT) {
return NT_STATUS_NO_SUCH_GROUP;
/* In native mode, AD can also nest domain groups. Not sure yet
* whether this is also available via RPC. */
- ret = ldb_search_exp_fmt(d_state->sam_ctx, mem_ctx, &res,
+ ret = ldb_search(d_state->sam_ctx, mem_ctx, &res,
d_state->domain_dn, LDB_SCOPE_SUBTREE, attrs,
"(&(objectSid=%s)(objectclass=user))",
ldap_encode_ndr_dom_sid(mem_ctx, membersid));
/* In native mode, AD can also nest domain groups. Not sure yet
* whether this is also available via RPC. */
- ret = ldb_search_exp_fmt(d_state->sam_ctx, mem_ctx, &res,
+ ret = ldb_search(d_state->sam_ctx, mem_ctx, &res,
d_state->domain_dn, LDB_SCOPE_SUBTREE, attrs,
"(&(objectSid=%s)(objectclass=user))",
ldap_encode_ndr_dom_sid(mem_ctx, membersid));
#include "rpc_server/common/common.h"
#include "rpc_server/samr/dcesrv_samr.h"
#include "system/time.h"
-#include "lib/crypto/crypto.h"
+#include "../lib/crypto/crypto.h"
#include "dsdb/common/flags.h"
#include "libcli/ldap/ldap.h"
#include "dsdb/samdb/samdb.h"
data_blob_free(&lm_pwd_blob);
if (!decode_pw_buffer(pwbuf->data, new_pass, sizeof(new_pass),
- &new_pass_len, STR_ASCII)) {
+ STR_ASCII)) {
ldb_transaction_cancel(sam_ctx);
DEBUG(3,("samr: failed to decode password buffer\n"));
return NT_STATUS_WRONG_PASSWORD;
{
NTSTATUS status;
char new_pass[512];
- uint32_t new_pass_len;
struct ldb_context *sam_ctx = NULL;
struct ldb_dn *user_dn;
int ret;
data_blob_free(&nt_pwd_blob);
if (!decode_pw_buffer(r->in.nt_password->data, new_pass, sizeof(new_pass),
- &new_pass_len, STR_UNICODE)) {
+ STR_UNICODE)) {
DEBUG(3,("samr: failed to decode password buffer\n"));
status = NT_STATUS_WRONG_PASSWORD;
goto failed;
{
NTSTATUS nt_status;
char new_pass[512];
- uint32_t new_pass_len;
DATA_BLOB session_key = data_blob(NULL, 0);
nt_status = dcesrv_fetch_session_key(dce_call->conn, &session_key);
arcfour_crypt_blob(pwbuf->data, 516, &session_key);
if (!decode_pw_buffer(pwbuf->data, new_pass, sizeof(new_pass),
- &new_pass_len, STR_UNICODE)) {
+ STR_UNICODE)) {
DEBUG(3,("samr: failed to decode password buffer\n"));
return NT_STATUS_WRONG_PASSWORD;
}
arcfour_crypt_blob(pwbuf->data, 516, &co_session_key);
if (!decode_pw_buffer(pwbuf->data, new_pass, sizeof(new_pass),
- &new_pass_len, STR_UNICODE)) {
+ STR_UNICODE)) {
DEBUG(3,("samr: failed to decode password buffer\n"));
return NT_STATUS_WRONG_PASSWORD;
}
NTSTATUS status;
struct dcesrv_context *dce_ctx;
struct dcesrv_endpoint *e;
+ extern NTSTATUS dcerpc_server_wkssvc_init(void);
+ extern NTSTATUS dcerpc_server_drsuapi_init(void);
+ extern NTSTATUS dcerpc_server_winreg_init(void);
+ extern NTSTATUS dcerpc_server_spoolss_init(void);
+ extern NTSTATUS dcerpc_server_epmapper_init(void);
+ extern NTSTATUS dcerpc_server_srvsvc_init(void);
+ extern NTSTATUS dcerpc_server_netlogon_init(void);
+ extern NTSTATUS dcerpc_server_rpcecho_init(void);
+ extern NTSTATUS dcerpc_server_unixinfo_init(void);
+ extern NTSTATUS dcerpc_server_samr_init(void);
+ extern NTSTATUS dcerpc_server_remote_init(void);
+ extern NTSTATUS dcerpc_server_lsa_init(void);
+ init_module_fn static_init[] = { STATIC_DCESRV_MODULES };
+ init_module_fn *shared_init = load_samba_modules(NULL, task->lp_ctx, "dcerpc_server");
+
+ run_init_functions(static_init);
+ run_init_functions(shared_init);
+
+ talloc_free(shared_init);
task_server_set_title(task, "task[dcesrv]");
NTSTATUS server_service_rpc_init(void)
{
- extern NTSTATUS dcerpc_server_wkssvc_init(void);
- extern NTSTATUS dcerpc_server_drsuapi_init(void);
- extern NTSTATUS dcerpc_server_winreg_init(void);
- extern NTSTATUS dcerpc_server_spoolss_init(void);
- extern NTSTATUS dcerpc_server_epmapper_init(void);
- extern NTSTATUS dcerpc_server_srvsvc_init(void);
- extern NTSTATUS dcerpc_server_netlogon_init(void);
- extern NTSTATUS dcerpc_server_rpcecho_init(void);
- extern NTSTATUS dcerpc_server_unixinfo_init(void);
- extern NTSTATUS dcerpc_server_samr_init(void);
- extern NTSTATUS dcerpc_server_remote_init(void);
- extern NTSTATUS dcerpc_server_lsa_init(void);
- init_module_fn static_init[] = { STATIC_DCESRV_MODULES };
- init_module_fn *shared_init = load_samba_modules(NULL, global_loadparm, "dcerpc_server");
- run_init_functions(static_init);
- run_init_functions(shared_init);
-
- talloc_free(shared_init);
-
return register_server_service("rpc", dcesrv_task_init);
}
+++ /dev/null
-#!/usr/bin/perl
-#
-# Create ejs interfaces for structures in a C header file
-#
-
-use File::Basename;
-use Data::Dumper;
-
-#
-# Generate parse tree for header file
-#
-
-my $file = shift;
-require smb_interfaces;
-my $parser = new smb_interfaces;
-$header = $parser->parse($file);
-
-#
-# Make second pass over tree to make it easier to process.
-#
-
-sub flatten_structs($) {
- my $obj = shift;
- my $s = { %$obj };
-
- # Map NAME, STRUCT_NAME and UNION_NAME elements into a more likeable
- # property.
-
- if (defined($obj->{STRUCT_NAME}) or defined($obj->{UNION_NAME})) {
-
- $s->{TYPE_DEFINED} = defined($obj->{STRUCT_NAME}) ? $obj->{STRUCT_NAME}
- : $obj->{UNION_NAME};
-
- delete $s->{STRUCT_NAME};
- delete $s->{UNION_NAME};
- }
-
- # Create a new list of structure fields with flattened names
-
- foreach my $elt (@{$obj->{DATA}}) {
- foreach my $name (@{$elt->{NAME}}) {
- my $new_elt = { %$elt };
- $new_elt->{NAME} = $name;
-# $new_elt->{PARENT} = $s;
- push(@{$s->{FIELDS}}, flatten_structs($new_elt));
- }
- }
-
- delete $s->{DATA};
-
- return $s;
-}
-
-@newheader = map { flatten_structs($_) } @{$header};
-
-#
-# Generate implementation
-#
-
-my $basename = basename($file, ".h");
-stat "libcli/gen_raw" || mkdir("libcli/gen_raw") || die("mkdir");
-
-open(FILE, ">libcli/gen_raw/ejs_${basename}.c");
-
-print FILE "/* EJS wrapper functions auto-generated by build_smb_interfaces.pl */\n\n";
-
-print FILE "#include \"includes.h\"\n";
-print FILE "#include \"scripting/ejs/smbcalls.h\"\n";
-print FILE "#include \"lib/appweb/ejs/ejs.h\"\n";
-print FILE "#include \"scripting/ejs/ejsrpc.h\"\n"; # TODO: remove this
-print FILE "\n";
-
-sub transfer_element($$$) {
- my $dir = shift;
- my $prefix = shift;
- my $elt = shift;
-
- $type = $elt->{TYPE};
- $type =~ s/_t$//;
-
- print FILE "\tNDR_CHECK(ejs_${dir}_$type(ejs, v, \"$prefix.$elt->{NAME}\"));\n";
-}
-
-sub transfer_struct($$) {
- my $dir = shift;
- my $struct = shift;
-
- foreach my $field (@{$struct->{FIELDS}}) {
- next if $dir eq "pull" and $field->{NAME} eq "out";
- next if $dir eq "push" and $field->{NAME} eq "in";
-
- if ($field->{TYPE} eq "struct") {
- foreach $subfield (@{$field->{FIELDS}}) {
- transfer_element($dir, $field->{NAME}, $subfield);
- }
- } else {
- transfer_element($dir, $struct->{NAME}, $field);
- }
- }
-}
-
-# Top level call functions
-
-foreach my $s (@newheader) {
-
- if ($s->{TYPE} eq "struct") {
-
- # Push/pull top level struct
-
- print FILE "NTSTATUS ejs_pull_$s->{TYPE_DEFINED}(struct ejs_rpc *ejs, struct MprVar *v, struct $s->{TYPE_DEFINED} *r)\n";
- print FILE "{\n";
-
- transfer_struct("pull", $s);
-
- print FILE "\n\treturn NT_STATUS_OK;\n";
- print FILE "}\n\n";
-
- print FILE "NTSTATUS ejs_push_$s->{TYPE_DEFINED}(struct ejs_rpc *ejs, struct MprVar *v, const struct $s->{TYPE_DEFINED} *r)\n";
- print FILE "{\n";
-
- transfer_struct("push", $s);
-
- print FILE "\n\treturn NT_STATUS_OK;\n";
- print FILE "}\n\n";
-
- # Function call
-
- print FILE "static int ejs_$s->{TYPE_DEFINED}(int eid, int argc, struct MprVar **argv)\n";
- print FILE "{\n";
- print FILE "\treturn ejs_raw_call(eid, argc, argv, (ejs_pull_function_t)ejs_pull_$s->{TYPE_DEFINED}, (ejs_push_function_t)ejs_push_$s->{TYPE_DEFINED});\n";
- print FILE "}\n\n";
-
- } else {
-
- # Top level union
-
- foreach my $arm (@{$s->{FIELDS}}) {
-
- # Push/pull union arm
-
- print FILE "NTSTATUS ejs_pull_$s->{TYPE_DEFINED}_$arm->{NAME}(struct ejs_rpc *ejs, struct MprVar *v, union $s->{TYPE_DEFINED} *r)\n";
- print FILE "{\n";
-
- transfer_struct("pull", $arm);
-
- print FILE "\n\treturn NT_STATUS_OK;\n";
- print FILE "}\n\n";
-
- print FILE "NTSTATUS ejs_push_$s->{TYPE_DEFINED}_$arm->{NAME}(struct ejs_rpc *ejs, struct MprVar *v, const union $s->{TYPE_DEFINED} *r)\n";
- print FILE "{\n";
-
- transfer_struct("push", $arm);
-
- print FILE "\n\treturn NT_STATUS_OK;\n";
- print FILE "}\n\n";
-
- }
- }
-}
-
-close(FILE);
# First, make a list of defines in configure
$in = shift;
-open(IN, $in);
-while(<IN>) {
- my $line = $_;
- while($line =~ /^\b([a-zA-Z0-9_][a-zA-Z0-9_]*)\b[ \t]*=.*/sgm) {
- $defines{$1} = 1;
- }
- while($line =~ /\$\(([a-zA-Z0-9_][a-zA-Z0-9_]*)\)/sgm) {
- $references{$1} = 1;
+sub process_file($)
+{
+ my ($fn) = @_;
+ open(IN, $fn);
+ while(<IN>) {
+ my $line = $_;
+ while($line =~ /^\b([a-zA-Z0-9_][a-zA-Z0-9_]*)\b[ \t]*=.*/sgm) {
+ $defines{$1} = 1;
+ }
+ while($line =~ /\$\(([a-zA-Z0-9_][a-zA-Z0-9_]*)\)/sgm) {
+ $references{$1} = 1;
+ }
+ while ($line =~ /^include (.*)/sgm) {
+ process_file($1);
+ }
}
+ close IN;
}
-close IN;
+
+process_file($in);
print "##### DEFINED BUT UNUSED: #####\n";
foreach(%defines) {
mv $LIBDIR/$p2 $LIBDIR/$p2.old
fi
cp $p $LIBDIR/
- ln -sf $p2 $LIBDIR/$lnname
+ if [ $p2 != $lnname ]; then
+ ln -sf $p2 $LIBDIR/$lnname
+ fi
done
cat << EOF
# install miscellaneous files
SRCDIR="$1"
-JSDIR="$2"
-SETUPDIR="$3"
-BINDIR="$4"
+SETUPDIR="$2"
cd $SRCDIR || exit 1
-echo "Installing js libs"
-mkdir -p $JSDIR || exit 1
-cp scripting/libjs/*.js $JSDIR || exit 1
-
echo "Installing setup templates"
mkdir -p $SETUPDIR || exit 1
cp setup/schema-map-* $SETUPDIR || exit 1
cp setup/provision.smb.conf.member $SETUPDIR || exit 1
cp setup/provision.smb.conf.standalone $SETUPDIR || exit 1
-echo "Installing script tools"
-mkdir -p "$BINDIR"
-rm -f scripting/bin/*~
-cp scripting/bin/* $BINDIR/ || exit 1
-
exit 0
+++ /dev/null
-#!/bin/sh
-
-INSTALLPERMS=$1
-LIBDIR=$2
-shift
-shift
-shift
-
-if [ ! -d $LIBDIR ]; then
-mkdir $LIBDIR
-if [ ! -d $LIBDIR ]; then
- echo Failed to make directory $LIBDIR
- exit 1
-fi
-fi
-
-for p in $*; do
- p2=`basename $p`
- echo Installing $p as $LIBDIR/$p2
- cp -f $p $LIBDIR/
- chmod $INSTALLPERMS $LIBDIR/$p2
-done
-
-
-cat << EOF
-======================================================================
-The modules are installed. You may uninstall the modules using the
-command "make uninstallmodules" or "make uninstall" to uninstall
-binaries, man pages, shell scripts and modules.
-======================================================================
-EOF
-
-exit 0
+++ /dev/null
-#!/bin/sh
-# this script courtesy of James_K._Foote.PARC@xerox.com
-# 5 July 96 Dan.Shearer@UniSA.Edu.Au Don't hardcode script names, get from Make
-
-INSTALLPERMS=$1
-BINDIR=$2
-
-shift
-shift
-
-echo Installing scripts in $BINDIR
-
-for d in $BINDIR; do
- if [ ! -d $d ]; then
- mkdir $d
- if [ ! -d $d ]; then
- echo Failed to make directory $d
- echo Have you run installbin first?
- exit 1
- fi
- fi
-done
-
-for p in $*; do
- p2=`basename $p`
- echo Installing $BINDIR/$p2
- if [ -f $BINDIR/$p2 ]; then
- rm -f $BINDIR/$p2.old
- mv $BINDIR/$p2 $BINDIR/$p2.old
- fi
- cp $p $BINDIR/
- chmod $INSTALLPERMS $BINDIR/$p2
- if [ ! -f $BINDIR/$p2 ]; then
- echo Cannot copy $p2... does $USER have privileges?
- fi
-done
-
-cat << EOF
-======================================================================
-The scripts have been installed. You may uninstall them using
-the command "make uninstallscripts" or "make install" to install binaries,
-man pages and shell scripts. You may recover the previous version (if any
-by "make revert".
-======================================================================
-EOF
-
-exit 0
+++ /dev/null
-#!/bin/sh
-# based on uninstallbin.sh:
-# 4 July 96 Dan.Shearer@UniSA.edu.au
-
-INCLUDEDIR=$1
-shift
-
-if [ ! -d $INCLUDEDIR ]; then
- echo Directory $INCLUDEDIR does not exist!
- echo Do a "make installbin" or "make install" first.
- exit 1
-fi
-
-for p in $*; do
- p2=`basename $p`
- if [ -f $INCLUDEDIR/$p2 ]; then
- echo Removing $INCLUDEDIR/$p2
- rm -f $INCLUDEDIR/$p2
- if [ -f $INCLUDEDIR/$p2 ]; then
- echo Cannot remove $INCLUDEDIR/$p2 ... does $USER have privileges?
- fi
- fi
-done
-
-
-cat << EOF
-======================================================================
-The headers have been uninstalled. You may restore the headers using
-the command "make installheader" or "make install" to install binaries,
-man pages, modules and shell scripts. You can restore a previous
-version of the headers (if there were any) using "make revert".
-======================================================================
-EOF
-
-exit 0
+++ /dev/null
-#!/bin/sh
-#4 July 96 Dan.Shearer@UniSA.edu.au
-
-INSTALLPERMS=$1
-BASEDIR=$2
-LIBDIR=$3
-shift
-shift
-shift
-
-if [ ! -d $LIBDIR ]; then
- echo Directory $LIBDIR does not exist!
- echo Do a "make installmodules" or "make install" first.
- exit 1
-fi
-
-for p in $*; do
- p2=`basename $p`
- if [ -f $LIBDIR/$p2 ]; then
- echo Removing $LIBDIR/$p2
- rm -f $LIBDIR/$p2
- if [ -f $LIBDIR/$p2 ]; then
- echo Cannot remove $LIBDIR/$p2 ... does $USER have privileges?
- fi
- fi
-done
-
-
-cat << EOF
-======================================================================
-The modules have been uninstalled. You may restore the modules using
-the command "make installmodules" or "make install" to install
-binaries, modules, man pages and shell scripts.
-======================================================================
-EOF
-
-exit 0
+++ /dev/null
-#!/bin/sh
-# 5 July 96 Dan.Shearer@UniSA.Edu.Au - almost identical to uninstallbin.sh
-
-INSTALLPERMS=$1
-BINDIR=$2
-
-shift
-shift
-
-if [ ! -d $BINDIR ]; then
- echo Directory $BINDIR does not exist!
- echo Do a "make installscripts" or "make install" first.
- exit 1
-fi
-
-for p in $*; do
- p2=`basename $p`
- if [ -f $BINDIR/$p2 ]; then
- echo Removing $BINDIR/$p2
- rm -f $BINDIR/$p2
- if [ -f $BINDIR/$p2 ]; then
- echo Cannot remove $BINDIR/$p2 ... does $USER have privileges?
- fi
- fi
-done
-
-cat << EOF
-======================================================================
-The scripts have been uninstalled. You may reinstall them using
-the command "make installscripts" or "make install" to install binaries,
-man pages and shell scripts. You may recover a previous version (if any
-with "make revert".
-======================================================================
-EOF
-
-exit 0
sys.path.insert(0, "bin/python")
import samba
-from samba import getopt as options
+from samba import getopt as options, Ldb
+from ldb import SCOPE_SUBTREE, SCOPE_BASE, LdbError
import sys
parser = optparse.OptionParser("minschema <URL> <classfile>")
(url, classfile) = args
-creds = credopts.get_credentials()
+lp_ctx = sambaopts.get_loadparm()
+
+creds = credopts.get_credentials(lp_ctx)
ldb = Ldb(url, credentials=creds)
objectclasses = []
# 2: abstract
# 3: auxiliary
-#
-# print only if verbose is set
-#
-def dprintf(text):
- if verbose is not None:
- print text
-
def get_object_cn(ldb, name):
attrs = ["cn"]
- res = ldb.search("(ldapDisplayName=%s)" % name, rootDse["schemaNamingContext"], ldb.SCOPE_SUBTREE, attrs)
+ res = ldb.search("(ldapDisplayName=%s)" % name, rootDse["schemaNamingContext"], SCOPE_SUBTREE, attrs)
assert len(res) == 1
return res[0]["cn"]
"""the properties of an objectclass"""
res = ldb.search(
expression="(ldapDisplayName=%s)" % o.name,
- basedn=rootDse["schemaNamingContext"], scope=ldb.SCOPE_SUBTREE, attrs=class_attrs)
+ base=rootDse["schemaNamingContext"], scope=SCOPE_SUBTREE, attrs=class_attrs)
assert(len(res) == 1)
msg = res[0]
for a in msg:
"""find the properties of an attribute"""
res = ldb.search(
expression="(ldapDisplayName=%s)" % o.name,
- basedn=rootDse["schemaNamingContext"], scope=ldb.SCOPE_SUBTREE,
+ base=rootDse["schemaNamingContext"], scope=SCOPE_SUBTREE,
attrs=attrib_attrs)
assert(len(res) == 1)
msg = res[0]
print "%s\n" % ldif
return
- res = ldb.search("", testdn, ldb.SCOPE_BASE)
+ res = ldb.search(base=testdn, scope=ldb.SCOPE_BASE)
ldb.delete(testdn)
for a in res.msgs[0]:
"subClassOf"]
res = ldb.search(
expression="(&(objectClass=classSchema)(ldapDisplayName=%s))" % o.name,
- basedn=rootDse["schemaNamingContext"], scope=ldb.SCOPE_SUBTREE,
+ base=rootDse["schemaNamingContext"], scope=SCOPE_SUBTREE,
attrs=attrs)
print "Expanding class %s\n" % o.name
assert(len(res) == 1)
# get a list of all possible attributes for this object
attrs = ["allowedAttributes"]
try:
- res = ldb.search("objectClass=*", dn, ldb.SCOPE_BASE, attrs)
+ res = ldb.search("objectClass=*", dn, SCOPE_BASE, attrs)
except LdbError, e:
print "Unable to fetch allowedAttributes for '%s' - %r\n" % (dn, e)
return
allattrs = res[0]["allowedAttributes"]
try:
- res = ldb.search("objectClass=*", dn, ldb.SCOPE_BASE, allattrs)
+ res = ldb.search("objectClass=*", dn, SCOPE_BASE, allattrs)
except LdbError, e:
print "Unable to fetch all attributes for '%s' - %s\n" % (dn, e)
return
def walk_naming_context(ldb, namingContext):
"""walk a naming context, looking for all records"""
try:
- res = ldb.search("objectClass=*", namingContext, ldb.SCOPE_DEFAULT,
+ res = ldb.search("objectClass=*", namingContext, SCOPE_DEFAULT,
["objectClass"])
except LdbError, e:
print "Unable to fetch objectClasses for '%s' - %s\n" % (namingContext, e)
try:
res = ldb.search(
expression="(&(objectClass=classSchema)(ldapDisplayName=%s))" % name,
- basedn=rootDse["schemaNamingContext"], scope=ldb.SCOPE_SUBTREE,
+ base=rootDse["schemaNamingContext"], scope=SCOPE_SUBTREE,
attrs=attrs)
except LdbError, e:
print "unknown class '%s'\n" % name
def load_list(file):
"""load a list from a file"""
- return open(file, 'r').splitlines()
+ return open(file, 'r').readlines()
# get the rootDSE
-res = ldb.search("", "", ldb.SCOPE_BASE)
+res = ldb.search(base="", expression="", scope=SCOPE_BASE, attrs=["schemaNamingContext"])
rootDse = res[0]
# load the list of classes we are interested in
sessions = conn.smbsrv_information(irpc.SMBSRV_INFO_SESSIONS).next()
print "User Client Connected at"
- print "-------------------------------------------------------------------------------"
+ print "-" * 79
for session in sessions:
fulluser = "%s/%s" % (session.account_name, session.domain_name)
print "%-30s %16s %s" % (fulluser, session.client_ip, sys.httptime(session.connect_time))
conn = open_connection("smb_server")
tcons = conn.smbsrv_information(irpc.SMBSRV_INFO_TCONS).next()
print "Share Client Connected at"
- print "-------------------------------------------------------------------------------"
+ print "-" * 79
for tcon in tcons:
print "%-30s %16s %s" % (tcon.share_name, tcon.client_ip, sys.httptime(tcon.connect_time))
try:
conn = open_connection("smb_server")
except RuntimeError, (num, msg):
- if msg == 'NT_STATUS_OBJECT_NAME_NOT_FOUND':
+ if msg == 'NT_STATUS_OBJECT_NAME_NOT_FOUND':
print "No active connections"
else:
show_sessions(conn)
# Find right directory when running from source tree
sys.path.insert(0, "bin/python")
+sys.path.insert(1, "../lib/subunit/python")
from subunit import SubunitTestRunner
from unittest import TestProgram
+++ /dev/null
-[MODULE::smbcalls_config]
-OUTPUT_TYPE = MERGED_OBJ
-SUBSYSTEM = smbcalls
-INIT_FUNCTION = smb_setup_ejs_config
-
-smbcalls_config_OBJ_FILES = $(ejsscriptsrcdir)/smbcalls_config.o
-
-[MODULE::smbcalls_ldb]
-OUTPUT_TYPE = MERGED_OBJ
-SUBSYSTEM = smbcalls
-INIT_FUNCTION = smb_setup_ejs_ldb
-PRIVATE_DEPENDENCIES = LIBLDB SAMDB LIBNDR
-
-smbcalls_ldb_OBJ_FILES = $(ejsscriptsrcdir)/smbcalls_ldb.o
-
-[MODULE::smbcalls_auth]
-OUTPUT_TYPE = MERGED_OBJ
-SUBSYSTEM = smbcalls
-INIT_FUNCTION = smb_setup_ejs_auth
-PRIVATE_DEPENDENCIES = service_auth
-
-smbcalls_auth_OBJ_FILES = $(ejsscriptsrcdir)/smbcalls_auth.o
-
-smbcalls_auth_OBJ_FILES = $(ejsscriptsrcdir)/smbcalls_auth.o
-
-[MODULE::smbcalls_string]
-SUBSYSTEM = smbcalls
-OUTPUT_TYPE = MERGED_OBJ
-INIT_FUNCTION = smb_setup_ejs_string
-
-smbcalls_string_OBJ_FILES = $(ejsscriptsrcdir)/smbcalls_string.o
-
-[MODULE::smbcalls_sys]
-SUBSYSTEM = smbcalls
-OUTPUT_TYPE = MERGED_OBJ
-INIT_FUNCTION = smb_setup_ejs_system
-
-smbcalls_sys_OBJ_FILES = $(ejsscriptsrcdir)/smbcalls_sys.o
-
-[SUBSYSTEM::smbcalls]
-PRIVATE_DEPENDENCIES = \
- EJS LIBSAMBA-UTIL \
- MESSAGING \
- LIBSAMBA-NET LIBCLI_SMB LIBPOPT \
- CREDENTIALS POPT_CREDENTIALS POPT_SAMBA \
- NDR_TABLE
-
-smbcalls_OBJ_FILES = $(addprefix $(ejsscriptsrcdir)/, \
- smbcalls.o \
- smbcalls_options.o \
- smbcalls_creds.o \
- mprutil.o)
-
-$(eval $(call proto_header_template,$(ejsscriptsrcdir)/proto.h,$(smbcalls_OBJ_FILES:.o=.c)))
-
-#######################
-# Start BINARY SMBSCRIPT
-[BINARY::smbscript]
-PRIVATE_DEPENDENCIES = EJS LIBSAMBA-UTIL smbcalls LIBSAMBA-HOSTCONFIG
-# End BINARY SMBSCRIPT
-#######################
-
-smbscript_OBJ_FILES = $(ejsscriptsrcdir)/smbscript.o
+++ /dev/null
-/*
- Unix SMB/CIFS implementation.
-
- utility functions for manipulating mpr variables in ejs calls
-
- Copyright (C) Andrew Tridgell 2005
-
- 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 "lib/appweb/ejs/ejs.h"
-#include "lib/ldb/include/ldb.h"
-#include "scripting/ejs/smbcalls.h"
-
-/*
- return a default mpr object
-*/
-struct MprVar mprObject(const char *name)
-{
- return ejsCreateObj(name && *name?name:"(NULL)", MPR_DEFAULT_HASH_SIZE);
-}
-
-/*
- return a empty mpr array
-*/
-struct MprVar mprArray(const char *name)
-{
- return ejsCreateArray(name && *name?name:"(NULL)", 0);
-}
-
-/*
- find a mpr component, allowing for sub objects, using the '.' convention
-*/
- NTSTATUS mprGetVar(struct MprVar **v, const char *name)
-{
- const char *p = strchr(name, '.');
- char *objname;
- NTSTATUS status;
- if (p == NULL) {
- *v = mprGetProperty(*v, name, NULL);
- if (*v == NULL) {
- DEBUG(1,("mprGetVar unable to find '%s'\n", name));
- return NT_STATUS_INVALID_PARAMETER;
- }
- return NT_STATUS_OK;
- }
- objname = talloc_strndup(mprMemCtx(), name, p-name);
- NT_STATUS_HAVE_NO_MEMORY(objname);
- *v = mprGetProperty(*v, objname, NULL);
- NT_STATUS_HAVE_NO_MEMORY(*v);
- status = mprGetVar(v, p+1);
- talloc_free(objname);
- return status;
-}
-
-
-/*
- set a mpr component, allowing for sub objects, using the '.' convention
- destroys 'val' after setting
-*/
- NTSTATUS mprSetVar(struct MprVar *v, const char *name, struct MprVar val)
-{
- const char *p = strchr(name, '.');
- char *objname;
- struct MprVar *v2;
- NTSTATUS status;
- if (p == NULL) {
- v2 = mprSetProperty(v, name, &val);
- if (v2 == NULL) {
- DEBUG(1,("mprSetVar unable to set '%s'\n", name));
- return NT_STATUS_INVALID_PARAMETER_MIX;
- }
- mprDestroyVar(&val);
- return NT_STATUS_OK;
- }
- objname = talloc_strndup(mprMemCtx(), name, p-name);
- if (objname == NULL) {
- return NT_STATUS_NO_MEMORY;
- }
- v2 = mprGetProperty(v, objname, NULL);
- if (v2 == NULL) {
- mprSetVar(v, objname, mprObject(objname));
- v2 = mprGetProperty(v, objname, NULL);
- }
- status = mprSetVar(v2, p+1, val);
- talloc_free(objname);
- return status;
-}
-
-
-
-/*
- add an indexed array element to a property
-*/
- void mprAddArray(struct MprVar *var, int i, struct MprVar v)
-{
- char idx[16];
- mprItoa(i, idx, sizeof(idx));
- mprSetVar(var, idx, v);
-}
-
-/*
- construct a MprVar from a list
-*/
-struct MprVar mprList(const char *name, const char **list)
-{
- struct MprVar var;
- int i;
-
- var = mprArray(name);
- for (i=0;list && list[i];i++) {
- mprAddArray(&var, i, mprString(list[i]));
- }
- return var;
-}
-
-/*
- construct a MprVar from a string, using NULL if needed
-*/
-struct MprVar mprString(const char *s)
-{
- if (s == NULL) {
- return mprCreatePtrVar(NULL);
- }
- return mprCreateStringVar(s, true);
-}
-
-/*
- construct a string MprVar from a lump of data
-*/
-struct MprVar mprData(const uint8_t *p, size_t length)
-{
- struct MprVar var;
- char *s = talloc_strndup(mprMemCtx(), (const char *)p, length);
- if (s == NULL) {
- return mprCreateUndefinedVar();
- }
- var = mprString(s);
- talloc_free(s);
- return var;
-}
-
-/*
- turn a ldb_message into a ejs object variable
-*/
-static struct MprVar mprLdbMessage(struct ldb_context *ldb, struct ldb_message *msg)
-{
- struct MprVar var;
- int i;
- /* we force some attributes to always be an array in the
- returned structure. This makes the scripting easier, as you don't
- need a special case for the single value case */
- const char *multivalued[] = { "objectClass", "memberOf", "privilege",
- "member", NULL };
-
- var = mprObject(ldb_dn_alloc_linearized(msg, msg->dn));
-
- for (i=0;i<msg->num_elements;i++) {
- struct ldb_message_element *el = &msg->elements[i];
- struct MprVar val;
- const struct ldb_schema_attribute *a;
- struct ldb_val v;
-
- a = ldb_schema_attribute_by_name(ldb, el->name);
- if (a == NULL) {
- goto failed;
- }
-
- if (el->num_values == 1 &&
- !str_list_check_ci(multivalued, el->name)) {
- if (a->syntax->ldif_write_fn(ldb, msg, &el->values[0], &v) != 0) {
- goto failed;
- }
- /* FIXME: nasty hack, remove me when ejs will support
- * arbitrary string and does not truncate on \0 */
- if (strlen((char *)v.data) != v.length) {
- val = mprDataBlob(v);
- } else {
- val = mprData(v.data, v.length);
- }
- } else {
- int j;
- val = mprArray(el->name);
- for (j=0;j<el->num_values;j++) {
- if (a->syntax->ldif_write_fn(ldb, msg,
- &el->values[j], &v) != 0) {
- goto failed;
- }
- /* FIXME: nasty hack, remove me when ejs will support
- * arbitrary string and does not truncate on \0 */
- if (strlen((char *)v.data) != v.length) {
- mprAddArray(&val, j, mprDataBlob(v));
- } else {
- mprAddArray(&val, j, mprData(v.data, v.length));
- }
- }
- }
- mprSetVar(&var, el->name, val);
- }
-
- /* add the dn if it is not already specified */
- if (mprGetProperty(&var, "dn", 0) == 0) {
- mprSetVar(&var, "dn", mprString(ldb_dn_alloc_linearized(msg, msg->dn)));
- }
-
- return var;
-failed:
- return mprCreateUndefinedVar();
-}
-
-
-/*
- build a MprVar result object for ldb operations with lots of funky properties
-*/
-struct MprVar mprLdbResult(struct ldb_context *ldb, int err, struct ldb_result *result)
-{
- struct MprVar ret;
- struct MprVar ary;
-
- ret = mprObject("ldbret");
-
- mprSetVar(&ret, "error", mprCreateIntegerVar(err));
- mprSetVar(&ret, "errstr", mprString(ldb_errstring(ldb)));
-
- ary = mprArray("ldb_message");
- if (result) {
- int i;
-
- for (i = 0; i < result->count; i++) {
- mprAddArray(&ary, i, mprLdbMessage(ldb, result->msgs[i]));
- }
- }
-
- mprSetVar(&ret, "msgs", ary);
-
- /* TODO: add referrals, exteded ops, and controls */
-
- return ret;
-}
-
-
-/*
- turn a MprVar string variable into a const char *
- */
-const char *mprToString(struct MprVar *v)
-{
- if (v->trigger) {
- mprReadProperty(v, 0);
- }
- if (!mprVarIsString(v->type)) return NULL;
- return v->string;
-}
-
-/*
- turn a MprVar integer variable into an int
- */
-int mprToInt(struct MprVar *v)
-{
- if (v->trigger) {
- mprReadProperty(v, 0);
- }
- if (!mprVarIsNumber(v->type)) return 0;
- return mprVarToNumber(v);
-}
-
-/*
- turn a MprVar object variable into a string list
- this assumes the object variable consists only of strings
-*/
-const char **mprToList(TALLOC_CTX *mem_ctx, struct MprVar *v)
-{
- const char **list = NULL;
- struct MprVar *el;
-
- if (v->type != MPR_TYPE_OBJECT ||
- v->properties == NULL) {
- return NULL;
- }
- for (el=mprGetFirstProperty(v, MPR_ENUM_DATA);
- el;
- el=mprGetNextProperty(v, el, MPR_ENUM_DATA)) {
- const char *s = mprToString(el);
- if (s) {
- list = str_list_add(list, s);
- }
- }
- talloc_steal(mem_ctx, list);
- return list;
-}
-
-
-/*
- turn a MprVar object variable into a string list
- this assumes the object variable is an array of strings
-*/
-const char **mprToArray(TALLOC_CTX *mem_ctx, struct MprVar *v)
-{
- const char **list = NULL;
- struct MprVar *len;
- int length, i;
-
- len = mprGetProperty(v, "length", NULL);
- if (len == NULL) {
- return NULL;
- }
- length = mprToInt(len);
-
- for (i=0;i<length;i++) {
- char idx[16];
- struct MprVar *vs;
- mprItoa(i, idx, sizeof(idx));
- vs = mprGetProperty(v, idx, NULL);
- if (vs == NULL || vs->type != MPR_TYPE_STRING) {
- talloc_free(list);
- return NULL;
- }
- list = str_list_add(list, mprToString(vs));
- }
- talloc_steal(mem_ctx, list);
- return list;
-}
-
-/*
- turn a NTSTATUS into a MprVar object with lots of funky properties
-*/
-struct MprVar mprNTSTATUS(NTSTATUS status)
-{
- struct MprVar res;
-
- res = mprObject("ntstatus");
-
- mprSetVar(&res, "errstr", mprString(nt_errstr(status)));
- mprSetVar(&res, "v", mprCreateIntegerVar(NT_STATUS_V(status)));
- mprSetVar(&res, "is_ok", mprCreateBoolVar(NT_STATUS_IS_OK(status)));
- mprSetVar(&res, "is_err", mprCreateBoolVar(NT_STATUS_IS_ERR(status)));
-
- return res;
-}
-
-/*
- create a data-blob in a mpr variable
-*/
-struct MprVar mprDataBlob(DATA_BLOB blob)
-{
- struct MprVar res;
- struct datablob *pblob = talloc(mprMemCtx(), struct datablob);
- *pblob = data_blob_talloc(pblob, blob.data, blob.length);
-
- res = mprObject("DATA_BLOB");
-
- mprSetVar(&res, "size", mprCreateIntegerVar(blob.length));
- mprSetPtrChild(&res, "blob", pblob);
-
- return res;
-}
-
-/*
- return a data blob from a mpr var created using mprDataBlob
-*/
-struct datablob *mprToDataBlob(struct MprVar *v)
-{
- return talloc_get_type(mprGetPtr(v, "blob"), struct datablob);
-}
-
-/*
- turn a WERROR into a MprVar object with lots of funky properties
-*/
-struct MprVar mprWERROR(WERROR status)
-{
- struct MprVar res;
-
- res = mprObject("werror");
-
- mprSetVar(&res, "errstr", mprString(win_errstr(status)));
- mprSetVar(&res, "v", mprCreateIntegerVar(W_ERROR_V(status)));
- mprSetVar(&res, "is_ok", mprCreateBoolVar(W_ERROR_IS_OK(status)));
- mprSetVar(&res, "is_err", mprCreateBoolVar(!W_ERROR_IS_OK(status)));
-
- return res;
-}
-
-
-/*
- set a pointer in a existing MprVar
-*/
-void mprSetPtr(struct MprVar *v, const char *propname, const void *p)
-{
- mprSetVar(v, propname, mprCreatePtrVar(discard_const(p)));
-}
-
-/*
- set a pointer in a existing MprVar, freeing it when the property goes away
-*/
-void mprSetPtrChild(struct MprVar *v, const char *propname, const void *p)
-{
- mprSetVar(v, propname, mprCreatePtrVar(discard_const(p)));
- v = mprGetProperty(v, propname, NULL);
- v->allocatedData = 1;
- talloc_steal(mprMemCtx(), p);
-}
-
-/*
- get a pointer from a MprVar
-*/
-void *mprGetPtr(struct MprVar *v, const char *propname)
-{
- struct MprVar *val;
- val = mprGetProperty(v, propname, NULL);
- if (val == NULL) {
- return NULL;
- }
- if (val->type != MPR_TYPE_PTR) {
- return NULL;
- }
- return val->ptr;
-}
-
-/*
- set the return value then free the variable
-*/
- void mpr_Return(int eid, struct MprVar v)
-{
- ejsSetReturnValue(eid, v);
- mprDestroyVar(&v);
-}
-
-/*
- set the return value then free the variable
-*/
-void mpr_ReturnString(int eid, const char *s)
-{
- mpr_Return(eid, mprString(s));
-}
-
-
-/*
- set a C function in a variable
-*/
- void mprSetCFunction(struct MprVar *obj, const char *name, MprCFunction fn)
-{
- mprSetVar(obj, name, mprCreateCFunctionVar(fn, obj, MPR_VAR_SCRIPT_HANDLE));
-}
-
-/*
- set a string C function in a variable
-*/
- void mprSetStringCFunction(struct MprVar *obj, const char *name, MprStringCFunction fn)
-{
- mprSetVar(obj, name, mprCreateStringCFunctionVar(fn, obj, MPR_VAR_SCRIPT_HANDLE));
-}
-
-/*
- get a pointer in the current object
-*/
-void *mprGetThisPtr(int eid, const char *name)
-{
- struct MprVar *this = mprGetProperty(ejsGetLocalObject(eid), "this", 0);
- return mprGetPtr(this, name);
-}
-
-/*
- set a pointer as a child of the local object
-*/
-void mprSetThisPtr(int eid, const char *name, void *ptr)
-{
- struct MprVar *this = mprGetProperty(ejsGetLocalObject(eid), "this", 0);
- mprSetPtrChild(this, name, ptr);
-}
-
-/*
- used by object xxx_init() routines to allow for the caller
- to supply a pre-existing object to add properties to,
- or create a new object. This makes inheritance easy
-*/
-struct MprVar *mprInitObject(int eid, const char *name, int argc, struct MprVar **argv)
-{
- if (argc > 0 && mprVarIsObject(argv[0]->type)) {
- return argv[0];
- }
- mpr_Return(eid, mprObject(name));
- return ejsGetReturnValue(eid);
-}
+++ /dev/null
-/*
- Unix SMB/CIFS implementation.
-
- provide hooks into smbd C calls from ejs scripts
-
- Copyright (C) Andrew Tridgell 2005
- Copyright (C) Tim Potter 2005
-
- 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 "param/param.h"
-#include "scripting/ejs/smbcalls.h"
-#include "version.h"
-
-/*
- return the type of a variable
-*/
-static int ejs_typeof(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- const struct {
- MprType type;
- const char *name;
- } types[] = {
- { MPR_TYPE_UNDEFINED, "undefined" },
- { MPR_TYPE_NULL, "object" },
- { MPR_TYPE_BOOL, "boolean" },
- { MPR_TYPE_CFUNCTION, "function" },
- { MPR_TYPE_FLOAT, "number" },
- { MPR_TYPE_INT, "number" },
- { MPR_TYPE_INT64, "number" },
- { MPR_TYPE_OBJECT, "object" },
- { MPR_TYPE_FUNCTION, "function" },
- { MPR_TYPE_STRING, "string" },
- { MPR_TYPE_STRING_CFUNCTION, "function" },
- { MPR_TYPE_PTR, "pointer" }
- };
- int i;
- const char *type = NULL;
-
- if (argc != 1) return -1;
-
- for (i=0;i<ARRAY_SIZE(types);i++) {
- if (argv[0]->type == types[i].type) {
- type = types[i].name;
- break;
- }
- }
- if (type == NULL) return -1;
-
- mpr_ReturnString(eid, type);
- return 0;
-}
-
-/*
- return the native type of a variable
-*/
-static int ejs_typeof_native(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- const struct {
- MprType type;
- const char *name;
- } types[] = {
- { MPR_TYPE_UNDEFINED, "undefined" },
- { MPR_TYPE_NULL, "null" },
- { MPR_TYPE_BOOL, "boolean" },
- { MPR_TYPE_CFUNCTION, "c_function" },
- { MPR_TYPE_FLOAT, "float" },
- { MPR_TYPE_INT, "integer" },
- { MPR_TYPE_INT64, "integer64" },
- { MPR_TYPE_OBJECT, "object" },
- { MPR_TYPE_FUNCTION, "js_function" },
- { MPR_TYPE_STRING, "string" },
- { MPR_TYPE_STRING_CFUNCTION, "string_c_function" },
- { MPR_TYPE_PTR, "pointer" }
- };
- int i;
- const char *type = NULL;
-
- if (argc != 1) return -1;
-
- for (i=0;i<ARRAY_SIZE(types);i++) {
- if (argv[0]->type == types[i].type) {
- type = types[i].name;
- break;
- }
- }
- if (type == NULL) return -1;
-
- mpr_ReturnString(eid, type);
- return 0;
-}
-
-/*
- libinclude() allows you to include js files using a search path specified
- in "js include =" in smb.conf.
-*/
-static int ejs_libinclude(int eid, int argc, char **argv)
-{
- int i, j;
- const char **js_include = lp_js_include(mprLpCtx());
-
- if (js_include == NULL || js_include[0] == NULL) {
- ejsSetErrorMsg(eid, "js include path not set");
- return -1;
- }
-
- for (i = 0; i < argc; i++) {
- const char *script = argv[i];
- struct MprVar result;
- char *path, *emsg;
- int ret;
-
- /* use specfied path to search for requested file */
- for (j=0;js_include[j];j++) {
- path = talloc_asprintf(mprMemCtx(), "%s/%s", js_include[j], script);
- if (path == NULL) {
- return -1;
- }
- if (file_exist(path)) {
-
- ret = ejsEvalFile(eid, path, &result, &emsg);
- talloc_free(path);
- if (ret < 0) {
- ejsSetErrorMsg(eid, "%s: %s", script, emsg);
- return -1;
- }
- break;
- }
- talloc_free(path);
- }
-
- if (js_include[j] == NULL) {
- ejsSetErrorMsg(eid, "unable to include '%s'", script);
- return -1;
- }
- }
- return 0;
-}
-
-/*
- return the current version
-*/
-static int ejs_version(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- mpr_ReturnString(eid, SAMBA_VERSION_STRING);
- return 0;
-}
-
-
-static void (*ejs_exception_handler) (const char *) = NULL;
-
-_PUBLIC_ void ejs_exception(const char *reason)
-{
- ejs_exception_handler(reason);
-}
-
-/*
- setup C functions that be called from ejs
-*/
-void smb_setup_ejs_functions(void (*exception_handler)(const char *))
-{
- extern NTSTATUS ejs_init_security(void);
- extern NTSTATUS ejs_init_initshutdown(void);
- extern NTSTATUS smb_setup_ejs_reg(void);
- extern NTSTATUS smb_setup_ejs_string(void);
- extern NTSTATUS ejs_init_lsarpc(void);
- extern NTSTATUS ejs_init_rpcecho(void);
- extern NTSTATUS ejs_init_winreg(void);
- extern NTSTATUS smb_setup_ejs_random(void);
- extern NTSTATUS smb_setup_ejs_config(void);
- extern NTSTATUS ejs_init_misc(void);
- extern NTSTATUS ejs_init_netdfs(void);
- extern NTSTATUS smb_setup_ejs_datablob(void);
- extern NTSTATUS smb_setup_ejs_auth(void);
- extern NTSTATUS smb_setup_ejs_nss(void);
- extern NTSTATUS ejs_init_samr(void);
- extern NTSTATUS ejs_init_wkssvc(void);
- extern NTSTATUS smb_setup_ejs_system(void);
- extern NTSTATUS smb_setup_ejs_ldb(void);
- extern NTSTATUS ejs_init_svcctl(void);
- extern NTSTATUS smb_setup_ejs_net(void);
- extern NTSTATUS ejs_init_srvsvc(void);
- extern NTSTATUS ejs_init_netlogon(void);
- extern NTSTATUS ejs_init_drsuapi(void);
- extern NTSTATUS ejs_init_irpc(void);
- extern NTSTATUS ejs_init_eventlog(void);
- init_module_fn static_init[] = { STATIC_smbcalls_MODULES };
- init_module_fn *shared_init;
-
- ejs_exception_handler = exception_handler;
-
- smb_setup_ejs_options();
- smb_setup_ejs_credentials();
-
- shared_init = load_samba_modules(NULL, mprLpCtx(), "smbcalls");
-
- run_init_functions(static_init);
- run_init_functions(shared_init);
-
- talloc_free(shared_init);
-
- ejsDefineCFunction(-1, "typeof", ejs_typeof, NULL, MPR_VAR_SCRIPT_HANDLE);
- ejsDefineCFunction(-1, "nativeTypeOf", ejs_typeof_native, NULL, MPR_VAR_SCRIPT_HANDLE);
- ejsDefineStringCFunction(-1, "libinclude", ejs_libinclude, NULL, MPR_VAR_SCRIPT_HANDLE);
- ejsDefineCFunction(-1, "version", ejs_version, NULL, MPR_VAR_SCRIPT_HANDLE);
-}
-
+++ /dev/null
-/*
- Unix SMB/CIFS implementation.
-
- provide hooks into smbd C calls from ejs scripts
-
- Copyright (C) Andrew Tridgell 2005
-
- 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 "lib/appweb/ejs/ejs.h"
-#include "lib/ldb/include/ldb.h"
-
-void mpr_Return(int eid, struct MprVar);
-NTSTATUS mprSetVar(struct MprVar *v, const char *name, struct MprVar val);
-NTSTATUS mprGetVar(struct MprVar **v, const char *name);
-void mprAddArray(struct MprVar *var, int i, struct MprVar v);
-void mprSetCFunction(struct MprVar *obj, const char *name, MprCFunction fn);
-void mprSetStringCFunction(struct MprVar *obj, const char *name, MprStringCFunction fn);
-
-struct smbcalls_context {
- struct event_context *event_ctx;
- struct messaging_context *msg_ctx;
-};
-
-struct ldb_context;
-struct ldb_message;
-struct cli_credentials;
-
-#include "param/param.h"
-#include "scripting/ejs/proto.h"
+++ /dev/null
-/*
- Unix SMB/CIFS implementation.
-
- ejs auth functions
-
- Copyright (C) Simo Sorce 2005
- Copyright (C) Andrew Tridgell 2005
-
- 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 "lib/appweb/ejs/ejs.h"
-#include "auth/auth.h"
-#include "auth/credentials/credentials.h"
-#include "scripting/ejs/smbcalls.h"
-#include "lib/events/events.h"
-#include "lib/messaging/irpc.h"
-#include "libcli/security/security.h"
-
-static int ejs_doauth(MprVarHandle eid,
- TALLOC_CTX *tmp_ctx, struct MprVar *auth,
- const char *username, const char *password,
- const char *domain, const char *workstation,
- struct socket_address *remote_host,
- const char **auth_types)
-{
- struct auth_usersupplied_info *user_info = NULL;
- struct auth_serversupplied_info *server_info = NULL;
- struct auth_session_info *session_info = NULL;
- struct auth_context *auth_context;
- struct MprVar *session_info_obj;
- NTSTATUS nt_status;
- bool set;
-
- struct smbcalls_context *c;
- struct event_context *ev;
- struct messaging_context *msg;
-
- /* Hope we can find an smbcalls_context somewhere up there... */
- c = talloc_find_parent_bytype(tmp_ctx, struct smbcalls_context);
- if (c) {
- ev = c->event_ctx;
- msg = c->msg_ctx;
- } else {
- /* Hope we can find the event context somewhere up there... */
- ev = mprEventCtx();
- msg = messaging_client_init(tmp_ctx, lp_messaging_path(tmp_ctx, mprLpCtx()),
- lp_iconv_convenience(mprLpCtx()), ev);
- }
-
- if (auth_types) {
- nt_status = auth_context_create_methods(tmp_ctx, auth_types, ev, msg, mprLpCtx(), &auth_context);
- } else {
- nt_status = auth_context_create(tmp_ctx, ev, msg, mprLpCtx(), &auth_context);
- }
- if (!NT_STATUS_IS_OK(nt_status)) {
- mprSetPropertyValue(auth, "result", mprCreateBoolVar(false));
- mprSetPropertyValue(auth, "report", mprString("Auth System Failure"));
- goto done;
- }
-
- user_info = talloc(tmp_ctx, struct auth_usersupplied_info);
- if (!user_info) {
- mprSetPropertyValue(auth, "result", mprCreateBoolVar(false));
- mprSetPropertyValue(auth, "report", mprString("talloc failed"));
- goto done;
- }
-
- user_info->mapped_state = true;
- user_info->client.account_name = username;
- user_info->mapped.account_name = username;
- user_info->client.domain_name = domain;
- user_info->mapped.domain_name = domain;
-
- user_info->workstation_name = workstation;
-
- user_info->remote_host = remote_host;
-
- user_info->password_state = AUTH_PASSWORD_PLAIN;
- user_info->password.plaintext = talloc_strdup(user_info, password);
-
- user_info->flags = USER_INFO_CASE_INSENSITIVE_USERNAME |
- USER_INFO_DONT_CHECK_UNIX_ACCOUNT;
-
- user_info->logon_parameters = 0;
-
- nt_status = auth_check_password(auth_context, tmp_ctx, user_info, &server_info);
-
- /* Don't give the game away (any difference between no such
- * user and wrong password) */
- nt_status = auth_nt_status_squash(nt_status);
-
- if (!NT_STATUS_IS_OK(nt_status)) {
- mprSetPropertyValue(auth, "report",
- mprString(talloc_strdup(mprMemCtx(), get_friendly_nt_error_msg(nt_status))));
- mprSetPropertyValue(auth, "result", mprCreateBoolVar(false));
- goto done;
- }
-
- nt_status = auth_generate_session_info(tmp_ctx, mprEventCtx(), mprLpCtx(), server_info, &session_info);
- if (!NT_STATUS_IS_OK(nt_status)) {
- mprSetPropertyValue(auth, "report", mprString("Session Info generation failed"));
- mprSetPropertyValue(auth, "result", mprCreateBoolVar(false));
- goto done;
- }
-
- if (security_token_has_nt_authenticated_users(session_info->security_token)) {
- mprSetPropertyValue(auth, "user_class", mprString("USER"));
- set = true;
- }
-
- if (security_token_has_builtin_administrators(session_info->security_token)) {
- mprSetPropertyValue(auth, "user_class", mprString("ADMINISTRATOR"));
- set = true;
- }
-
- if (security_token_is_system(session_info->security_token)) {
- mprSetPropertyValue(auth, "user_class", mprString("SYSTEM"));
- set = true;
- }
-
- if (security_token_is_anonymous(session_info->security_token)) {
- mprSetPropertyValue(auth, "report", mprString("Anonymous login not permitted"));
- mprSetPropertyValue(auth, "result", mprCreateBoolVar(false));
- goto done;
- }
-
- if (!set) {
- mprSetPropertyValue(auth, "report", mprString("Session Info generation failed"));
- mprSetPropertyValue(auth, "result", mprCreateBoolVar(false));
- }
-
- session_info_obj = mprInitObject(eid, "session_info", 0, NULL);
-
- mprSetPtrChild(session_info_obj, "session_info", session_info);
- talloc_steal(mprMemCtx(), session_info);
-
- mprSetProperty(auth, "session_info", session_info_obj);
- mprSetPropertyValue(auth, "result", mprCreateBoolVar(server_info->authenticated));
- mprSetPropertyValue(auth, "username", mprString(server_info->account_name));
- mprSetPropertyValue(auth, "domain", mprString(server_info->domain_name));
-
-done:
- return 0;
-}
-
-/*
- perform user authentication, returning an array of results
-
-*/
-static int ejs_userAuth(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- TALLOC_CTX *tmp_ctx;
- const char *username;
- const char *password;
- const char *domain;
- const char *workstation;
- struct MprVar auth;
- struct cli_credentials *creds;
- struct socket_address *remote_host;
- const char *auth_types_unix[] = { "unix", NULL };
-
- if (argc != 2 || argv[0]->type != MPR_TYPE_OBJECT || argv[1]->type != MPR_TYPE_OBJECT) {
- ejsSetErrorMsg(eid, "userAuth invalid arguments, this function requires an object.");
- return -1;
- }
-
- /* get credential values from credentials object */
- creds = mprGetPtr(argv[0], "creds");
- if (creds == NULL) {
- ejsSetErrorMsg(eid, "userAuth requires a 'creds' first parameter");
- return -1;
- }
-
- remote_host = (struct socket_address *)mprGetPtr(argv[1], "socket_address");
- if (remote_host == NULL) {
- ejsSetErrorMsg(eid, "userAuth requires a socket address second parameter");
- return -1;
- }
-
- tmp_ctx = talloc_new(mprMemCtx());
-
- username = cli_credentials_get_username(creds);
- password = cli_credentials_get_password(creds);
- domain = cli_credentials_get_domain(creds);
- workstation = cli_credentials_get_workstation(creds);
-
- if (username == NULL || password == NULL || domain == NULL) {
- mpr_Return(eid, mprCreateUndefinedVar());
- talloc_free(tmp_ctx);
- return 0;
- }
-
- auth = mprObject("auth");
-
- if (domain && (strcmp("SYSTEM USER", domain) == 0)) {
- ejs_doauth(eid, tmp_ctx, &auth, username, password, domain, workstation, remote_host, auth_types_unix);
- } else {
- ejs_doauth(eid, tmp_ctx, &auth, username, password, domain, workstation, remote_host, NULL);
- }
-
- mpr_Return(eid, auth);
- talloc_free(tmp_ctx);
- return 0;
-}
-
-/*
- initialise credentials ejs object
-*/
-static int ejs_system_session(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- struct MprVar *obj = mprInitObject(eid, "session_info", argc, argv);
- struct auth_session_info *session_info = system_session(mprMemCtx(), mprLpCtx());
-
- if (session_info == NULL) {
- return -1;
- }
-
- mprSetPtrChild(obj, "session_info", session_info);
- return 0;
-}
-
-/*
- setup C functions that be called from ejs
-*/
-NTSTATUS smb_setup_ejs_auth(void)
-{
- ejsDefineCFunction(-1, "userAuth", ejs_userAuth, NULL, MPR_VAR_SCRIPT_HANDLE);
- ejsDefineCFunction(-1, "system_session", ejs_system_session, NULL, MPR_VAR_SCRIPT_HANDLE);
- return NT_STATUS_OK;
-}
+++ /dev/null
-/*
- Unix SMB/CIFS implementation.
-
- provide hooks into smbd C calls from ejs scripts
-
- Copyright (C) Andrew Tridgell 2005
-
- 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 "scripting/ejs/smbcalls.h"
-#include "lib/appweb/ejs/ejs.h"
-#include "param/loadparm.h"
-#include "system/network.h"
-#include "lib/socket/netif.h"
-#include "param/param.h"
-
-/*
- return a list of defined services
-*/
-static int ejs_lpServices(MprVarHandle eid, int argc, char **argv)
-{
- int i;
- const char **list = NULL;
- if (argc != 0) return -1;
-
- for (i=0;i<lp_numservices(mprLpCtx());i++) {
- list = str_list_add(list, lp_servicename(lp_servicebynum(mprLpCtx(), i)));
- }
- talloc_steal(mprMemCtx(), list);
- mpr_Return(eid, mprList("services", list));
- return 0;
-}
-
-
-/*
- allow access to loadparm variables from inside ejs scripts in web apps
-
- can be called in 4 ways:
-
- v = lp.get("type:parm"); gets a parametric variable
- v = lp.get("share", "type:parm"); gets a parametric variable on a share
- v = lp.get("parm"); gets a global variable
- v = lp.get("share", "parm"); gets a share variable
-
- the returned variable is a ejs object. It is an array object for lists.
-*/
-static int ejs_lpGet(MprVarHandle eid, int argc, char **argv)
-{
- struct parm_struct *parm = NULL;
- void *parm_ptr = NULL;
- int i;
-
- if (argc < 1) return -1;
-
- if (argc == 2) {
- struct loadparm_service *service;
- /* its a share parameter */
- service = lp_service(mprLpCtx(), argv[0]);
- if (service == NULL) {
- mpr_Return(eid, mprCreateUndefinedVar());
- return 0;
- }
- if (strchr(argv[1], ':')) {
- /* its a parametric option on a share */
- const char *type = talloc_strndup(mprMemCtx(),
- argv[1],
- strcspn(argv[1], ":"));
- const char *option = strchr(argv[1], ':') + 1;
- const char *value;
- if (type == NULL || option == NULL) {
- mpr_Return(eid, mprCreateUndefinedVar());
- return 0;
- }
- value = lp_get_parametric(mprLpCtx(), service, type, option);
- if (value == NULL) {
- mpr_Return(eid, mprCreateUndefinedVar());
- return 0;
- }
- mpr_ReturnString(eid, value);
- return 0;
- }
-
- parm = lp_parm_struct(argv[1]);
- if (parm == NULL || parm->class == P_GLOBAL) {
- mpr_Return(eid, mprCreateUndefinedVar());
- return 0;
- }
- parm_ptr = lp_parm_ptr(mprLpCtx(), service, parm);
- } else if (strchr(argv[0], ':')) {
- /* its a global parametric option */
- const char *type = talloc_strndup(mprMemCtx(),
- argv[0], strcspn(argv[0], ":"));
- const char *option = strchr(argv[0], ':') + 1;
- const char *value;
- if (type == NULL || option == NULL) {
- mpr_Return(eid, mprCreateUndefinedVar());
- return 0;
- }
- value = lp_get_parametric(mprLpCtx(), NULL, type, option);
- if (value == NULL) {
- mpr_Return(eid, mprCreateUndefinedVar());
- return 0;
- }
- mpr_ReturnString(eid, value);
- return 0;
- } else {
- /* its a global parameter */
- parm = lp_parm_struct(argv[0]);
- if (parm == NULL) {
- mpr_Return(eid, mprCreateUndefinedVar());
- return 0;
- }
- parm_ptr = lp_parm_ptr(mprLpCtx(), NULL, parm);
- }
-
- if (parm == NULL || parm_ptr == NULL) {
- mpr_Return(eid, mprCreateUndefinedVar());
- return 0;
- }
-
- /* construct and return the right type of ejs object */
- switch (parm->type) {
- case P_STRING:
- case P_USTRING:
- mpr_ReturnString(eid, *(char **)parm_ptr);
- break;
- case P_BOOL:
- mpr_Return(eid, mprCreateBoolVar(*(bool *)parm_ptr));
- break;
- case P_INTEGER:
- case P_OCTAL:
- case P_BYTES:
- mpr_Return(eid, mprCreateIntegerVar(*(int *)parm_ptr));
- break;
- case P_ENUM:
- for (i=0; parm->enum_list[i].name; i++) {
- if (*(int *)parm_ptr == parm->enum_list[i].value) {
- mpr_ReturnString(eid, parm->enum_list[i].name);
- return 0;
- }
- }
- mpr_Return(eid, mprCreateUndefinedVar());
- return 0;
- case P_LIST:
- mpr_Return(eid, mprList(parm->label, *(const char ***)parm_ptr));
- break;
- }
- return 0;
-}
-
-/*
- v = lp.filename(); obtain filename
-*/
-static int ejs_lpFilename(MprVarHandle eid, int argc, char **argv)
-{
- mpr_ReturnString(eid, lp_configfile(mprLpCtx()));
- return 0;
-}
-
-/*
- set a smb.conf parameter. Only sets in memory, not permanent
-
- can be called in 4 ways:
-
- ok = lp.set("parm", "value");
-*/
-static int ejs_lpSet(MprVarHandle eid, int argc, char **argv)
-{
- if (argc != 2) {
- ejsSetErrorMsg(eid, "lp.set invalid arguments");
- return -1;
- }
-
- mpr_Return(eid, mprCreateBoolVar(lp_set_cmdline(mprLpCtx(), argv[0], argv[1])));
- return 0;
-}
-
-/*
- reload smb.conf
-
- ok = lp.reload();
-*/
-static int ejs_lpReload(MprVarHandle eid, int argc, char **argv)
-{
- bool ret;
- const char *filename = lp_configfile(mprLpCtx());
-
- ret = lp_load(mprLpCtx(), filename);
- mpr_Return(eid, mprCreateBoolVar(ret));
- return 0;
-}
-
-/*
- initialise loadparm ejs subsystem
-*/
-static int ejs_loadparm_init(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- struct MprVar *obj = mprInitObject(eid, "loadparm", argc, argv);
-
- mprSetStringCFunction(obj, "get", ejs_lpGet);
- mprSetStringCFunction(obj, "set", ejs_lpSet);
- mprSetStringCFunction(obj, "reload", ejs_lpReload);
- mprSetStringCFunction(obj, "services", ejs_lpServices);
- mprSetStringCFunction(obj, "filename", ejs_lpFilename);
- return 0;
-}
-
-/*
- setup C functions that be called from ejs
-*/
-NTSTATUS smb_setup_ejs_config(void)
-{
- ejsDefineCFunction(-1, "loadparm_init", ejs_loadparm_init, NULL, MPR_VAR_SCRIPT_HANDLE);
- return NT_STATUS_OK;
-}
+++ /dev/null
-/*
- Unix SMB/CIFS implementation.
-
- provide hooks credentials calls
-
- Copyright (C) Andrew Tridgell 2005
-
- 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 "scripting/ejs/smbcalls.h"
-#include "lib/appweb/ejs/ejs.h"
-#include "lib/cmdline/popt_common.h"
-#include "auth/credentials/credentials.h"
-
-/*
- helper function to get the local objects credentials ptr
-*/
-static struct cli_credentials *ejs_creds_get_credentials(int eid)
-{
- struct cli_credentials *creds = (struct cli_credentials *)mprGetThisPtr(eid, "creds");
- if (creds == NULL) {
- ejsSetErrorMsg(eid, "NULL ejs credentials");
- }
- return creds;
-}
-
-/*
- get a domain
-*/
-static int ejs_creds_get_domain(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- struct cli_credentials *creds = ejs_creds_get_credentials(eid);
-
- mpr_Return(eid, mprString(cli_credentials_get_domain(creds)));
- return 0;
-}
-
-
-/*
- set a domain
-*/
-static int ejs_creds_set_domain(MprVarHandle eid, int argc, char **argv)
-{
- struct cli_credentials *creds = ejs_creds_get_credentials(eid);
- if (argc != 1) {
- ejsSetErrorMsg(eid, "bad arguments to set_domain");
- return -1;
- }
-
- cli_credentials_set_domain(creds, argv[0], CRED_SPECIFIED);
- mpr_Return(eid, mprCreateBoolVar(true));
- return 0;
-}
-
-
-/*
- get a username
-*/
-static int ejs_creds_get_username(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- struct cli_credentials *creds = ejs_creds_get_credentials(eid);
-
- mpr_Return(eid, mprString(cli_credentials_get_username(creds)));
- return 0;
-}
-
-
-/*
- set a username
-*/
-static int ejs_creds_set_username(MprVarHandle eid, int argc, char **argv)
-{
- struct cli_credentials *creds = ejs_creds_get_credentials(eid);
- if (argc != 1) {
- ejsSetErrorMsg(eid, "bad arguments to set_username");
- return -1;
- }
-
- cli_credentials_set_username(creds, argv[0], CRED_SPECIFIED);
- mpr_Return(eid, mprCreateBoolVar(true));
- return 0;
-}
-
-
-/*
- get user password
-*/
-static int ejs_creds_get_password(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- struct cli_credentials *creds = ejs_creds_get_credentials(eid);
-
- mpr_Return(eid, mprString(cli_credentials_get_password(creds)));
- return 0;
-}
-
-
-/*
- set user password
-*/
-static int ejs_creds_set_password(MprVarHandle eid, int argc, char **argv)
-{
- struct cli_credentials *creds = ejs_creds_get_credentials(eid);
- if (argc != 1) {
- ejsSetErrorMsg(eid, "bad arguments to set_password");
- return -1;
- }
-
- cli_credentials_set_password(creds, argv[0], CRED_SPECIFIED);
- mpr_Return(eid, mprCreateBoolVar(true));
- return 0;
-}
-
-
-/*
- set realm
-*/
-static int ejs_creds_set_realm(MprVarHandle eid, int argc, char **argv)
-{
- struct cli_credentials *creds = ejs_creds_get_credentials(eid);
- if (argc != 1) {
- ejsSetErrorMsg(eid, "bad arguments to set_realm");
- return -1;
- }
-
- cli_credentials_set_realm(creds, argv[0], CRED_SPECIFIED);
- mpr_Return(eid, mprCreateBoolVar(true));
- return 0;
-}
-
-
-/*
- get realm
-*/
-static int ejs_creds_get_realm(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- struct cli_credentials *creds = ejs_creds_get_credentials(eid);
-
- mpr_Return(eid, mprString(cli_credentials_get_realm(creds)));
- return 0;
-}
-
-
-/*
- set workstation
-*/
-static int ejs_creds_set_workstation(MprVarHandle eid, int argc, char **argv)
-{
- struct cli_credentials *creds = ejs_creds_get_credentials(eid);
- if (argc != 1) {
- ejsSetErrorMsg(eid, "bad arguments to set_workstation");
- return -1;
- }
-
- cli_credentials_set_workstation(creds, argv[0], CRED_SPECIFIED);
- mpr_Return(eid, mprCreateBoolVar(true));
- return 0;
-}
-
-
-/*
- get workstation
-*/
-static int ejs_creds_get_workstation(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- struct cli_credentials *creds = ejs_creds_get_credentials(eid);
-
- mpr_Return(eid, mprString(cli_credentials_get_workstation(creds)));
- return 0;
-}
-
-/*
- set machine account
-*/
-static int ejs_creds_set_machine_account(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- struct cli_credentials *creds = ejs_creds_get_credentials(eid);
- if (argc != 0) {
- ejsSetErrorMsg(eid, "bad arguments to set_machine_account");
- return -1;
- }
-
- if (NT_STATUS_IS_OK(cli_credentials_set_machine_account(creds, mprLpCtx()))) {
- mpr_Return(eid, mprCreateBoolVar(true));
- } else {
- mpr_Return(eid, mprCreateBoolVar(false));
- }
- return 0;
-}
-
-
-/*
- initialise credentials ejs object
-*/
-static int ejs_credentials_obj(struct MprVar *obj, struct cli_credentials *creds)
-{
- mprSetPtrChild(obj, "creds", creds);
-
- /* setup our object methods */
- mprSetCFunction(obj, "get_domain", ejs_creds_get_domain);
- mprSetStringCFunction(obj, "set_domain", ejs_creds_set_domain);
- mprSetCFunction(obj, "get_username", ejs_creds_get_username);
- mprSetStringCFunction(obj, "set_username", ejs_creds_set_username);
- mprSetCFunction(obj, "get_password", ejs_creds_get_password);
- mprSetStringCFunction(obj, "set_password", ejs_creds_set_password);
- mprSetCFunction(obj, "get_realm", ejs_creds_get_realm);
- mprSetStringCFunction(obj, "set_realm", ejs_creds_set_realm);
- mprSetCFunction(obj, "get_workstation", ejs_creds_get_workstation);
- mprSetStringCFunction(obj, "set_workstation", ejs_creds_set_workstation);
- mprSetCFunction(obj, "set_machine_account", ejs_creds_set_machine_account);
-
- return 0;
-}
-
-
-struct MprVar mprCredentials(struct cli_credentials *creds)
-{
- struct MprVar mpv = mprObject("credentials");
-
- ejs_credentials_obj(&mpv, creds);
-
- return mpv;
-}
-
-
-/*
- initialise credentials ejs object
-*/
-static int ejs_credentials_init(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- struct cli_credentials *creds;
- struct MprVar *obj = mprInitObject(eid, "credentials", argc, argv);
-
- creds = cli_credentials_init(mprMemCtx());
- if (creds == NULL) {
- return -1;
- }
-
- cli_credentials_set_conf(creds, mprLpCtx());
-
- return ejs_credentials_obj(obj, creds);
-}
-
-/*
- initialise cmdline credentials ejs object
-*/
-int ejs_credentials_cmdline(int eid, int argc, struct MprVar **argv)
-{
- struct MprVar *obj = mprInitObject(eid, "credentials", argc, argv);
- if (talloc_reference(mprMemCtx(), cmdline_credentials) == NULL) {
- return -1;
- }
- return ejs_credentials_obj(obj, cmdline_credentials);
-}
-
-/*
- setup C functions that be called from ejs
-*/
-void smb_setup_ejs_credentials(void)
-{
- ejsDefineCFunction(-1, "credentials_init", ejs_credentials_init, NULL, MPR_VAR_SCRIPT_HANDLE);
-}
-
+++ /dev/null
-/*
- Unix SMB/CIFS implementation.
-
- provide hooks into smbd C calls from ejs scripts
-
- Copyright (C) Andrew Tridgell 2005
- Copyright (C) Jelmer Vernooij 2005
-
- 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 "scripting/ejs/smbcalls.h"
-#include "lib/appweb/ejs/ejs.h"
-#include "lib/ldb/include/ldb.h"
-#include "lib/ldb/include/ldb_errors.h"
-#include "ldb_wrap.h"
-#include "dsdb/samdb/samdb.h"
-#include "librpc/ndr/libndr.h"
-#include "libcli/security/security.h"
-
-/*
- get the connected db
- */
-static struct ldb_context *ejs_get_ldb_context(int eid)
-{
- struct ldb_context *ldb = (struct ldb_context *)mprGetThisPtr(eid, "db");
- if (ldb == NULL) {
- ejsSetErrorMsg(eid, "invalid ldb connection");
- }
- return ldb;
-}
-
-/*
- perform an ldb search, returning an array of results
-
- syntax:
- res = ldb.search("expression");
- var attrs = new Array("attr1", "attr2", "attr3");
- ldb.search("expression", attrs);
- var basedn = "cn=this,dc=is,dc=a,dc=test";
- ldb.search("expression", basedn, ldb.SCOPE_SUBTREE, attrs);
- ldb.search("expression", basedn, ldb.SCOPE_SUBTREE, attrs, controls);
-*/
-static int ejs_ldbSearch(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- const char **attrs = NULL;
- const char *expression;
- const char *base = NULL;
- struct ldb_dn *basedn = NULL;
- int scope = LDB_SCOPE_DEFAULT;
- TALLOC_CTX *tmp_ctx = talloc_new(mprMemCtx());
- struct ldb_context *ldb;
- int ret;
- struct ldb_control **parsed_controls = NULL;
- struct ldb_result *res=NULL;
- struct ldb_request *req;
-
- /* validate arguments */
- if (argc < 1 || argc > 5) {
- ejsSetErrorMsg(eid, "ldb.search invalid number of arguments");
- goto failed;
- }
- if (argc > 3 && argv[3]->type != MPR_TYPE_OBJECT) {
- ejsSetErrorMsg(eid, "ldb.search attributes must be an object");
- goto failed;
- }
-
- ldb = ejs_get_ldb_context(eid);
- if (ldb == NULL) {
- return -1;
- }
-
- expression = mprToString(argv[0]);
- if (argc > 1) {
- base = mprToString(argv[1]);
- /* a null basedn is valid */
- }
- if (base != NULL) {
- basedn = ldb_dn_new(tmp_ctx, ldb, base);
- if ( ! ldb_dn_validate(basedn)) {
- ejsSetErrorMsg(eid, "ldb.search malformed base dn");
- goto failed;
- }
- } else {
- basedn = ldb_get_default_basedn(ldb);
- }
- if (argc > 2) {
- scope = mprToInt(argv[2]);
- switch (scope) {
- case LDB_SCOPE_DEFAULT:
- case LDB_SCOPE_BASE:
- case LDB_SCOPE_ONELEVEL:
- case LDB_SCOPE_SUBTREE:
- break; /* ok */
- default:
- ejsSetErrorMsg(eid, "ldb.search invalid scope");
- goto failed;
- }
- }
- if (argc > 3) {
- attrs = mprToList(tmp_ctx, argv[3]);
- }
- if (argc > 4) {
- const char **controls;
- controls = mprToList(tmp_ctx, argv[4]);
- if (controls) {
- parsed_controls = ldb_parse_control_strings(ldb, tmp_ctx, controls);
- if (!parsed_controls) {
- ejsSetErrorMsg(eid, "ldb.search cannot parse controls: %s",
- ldb_errstring(ldb));
- goto failed;
- }
- }
- }
-
- res = talloc_zero(tmp_ctx, struct ldb_result);
- if (!res) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- ret = ldb_build_search_req(&req, ldb, tmp_ctx,
- basedn,
- scope,
- expression,
- attrs,
- parsed_controls,
- res,
- ldb_search_default_callback);
-
- if (ret == LDB_SUCCESS) {
-
- ldb_set_timeout(ldb, req, 0); /* use default timeout */
-
- ret = ldb_request(ldb, req);
-
- if (ret == LDB_SUCCESS) {
- ret = ldb_wait(req->handle, LDB_WAIT_ALL);
- }
- }
-
- if (ret != LDB_SUCCESS) {
- ejsSetErrorMsg(eid, "ldb.search failed - %s", ldb_errstring(ldb));
- mpr_Return(eid, mprLdbResult(ldb, ret, NULL));
- } else {
- mpr_Return(eid, mprLdbResult(ldb, ret, res));
- }
-
- talloc_free(tmp_ctx);
- return 0;
-
-failed:
- talloc_free(tmp_ctx);
- return -1;
-}
-
-
-/*
- perform an ldb add or modify
-*/
-static int ejs_ldbAddModify(MprVarHandle eid, int argc, struct MprVar **argv,
- int fn(struct ldb_context *, const struct ldb_message *))
-{
- const char *ldifstring;
- struct ldb_context *ldb;
- struct ldb_ldif *ldif;
- int ret = 0, count=0;
-
- if (argc != 1) {
- ejsSetErrorMsg(eid, "ldb.add/modify invalid arguments");
- return -1;
- }
-
- ldifstring = mprToString(argv[0]);
- if (ldifstring == NULL) {
- ejsSetErrorMsg(eid, "ldb.add/modify invalid arguments");
- return -1;
- }
-
- ldb = ejs_get_ldb_context(eid);
- if (ldb == NULL) {
- return -1;
- }
-
- while ((ldif = ldb_ldif_read_string(ldb, &ldifstring))) {
- count++;
- ret = fn(ldb, ldif->msg);
- talloc_free(ldif);
- if (ret != 0) break;
- }
-
- if (count == 0) {
- ejsSetErrorMsg(eid, "ldb.add/modify invalid ldif");
- return -1;
- }
-
- mpr_Return(eid, mprLdbResult(ldb, ret, NULL));
- return 0;
-}
-
-
-/*
- perform an ldb delete
- usage:
- ok = ldb.delete(dn);
-*/
-static int ejs_ldbDelete(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- struct ldb_dn *dn;
- struct ldb_context *ldb;
- int ret;
-
- if (argc != 1) {
- ejsSetErrorMsg(eid, "ldb.delete invalid arguments");
- return -1;
- }
-
- ldb = ejs_get_ldb_context(eid);
- if (ldb == NULL) {
- return -1;
- }
-
- dn = ldb_dn_new(ldb, ldb, mprToString(argv[0]));
- if ( ! ldb_dn_validate(dn)) {
- ejsSetErrorMsg(eid, "ldb.delete malformed dn");
- return -1;
- }
-
- ret = ldb_delete(ldb, dn);
-
- talloc_free(dn);
-
- mpr_Return(eid, mprLdbResult(ldb, ret, NULL));
- return 0;
-}
-
-/*
- perform an ldb rename
- usage:
- ok = ldb.rename(dn1, dn2);
-*/
-static int ejs_ldbRename(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- struct ldb_dn *dn1, *dn2;
- struct ldb_context *ldb;
- int ret;
-
- if (argc != 2) {
- ejsSetErrorMsg(eid, "ldb.rename invalid arguments");
- return -1;
- }
-
- ldb = ejs_get_ldb_context(eid);
- if (ldb == NULL) {
- return -1;
- }
-
- dn1 = ldb_dn_new(ldb, ldb, mprToString(argv[0]));
- dn2 = ldb_dn_new(ldb, ldb, mprToString(argv[1]));
- if ( ! ldb_dn_validate(dn1) || ! ldb_dn_validate(dn2)) {
- ejsSetErrorMsg(eid, "ldb.rename invalid or malformed arguments");
- return -1;
- }
-
- ret = ldb_rename(ldb, dn1, dn2);
-
- talloc_free(dn1);
- talloc_free(dn2);
-
- mpr_Return(eid, mprLdbResult(ldb, ret, NULL));
- return 0;
-}
-
-/*
- get last error message
- usage:
- ok = ldb.errstring();
-*/
-static int ejs_ldbErrstring(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- struct ldb_context *ldb;
-
- ldb = ejs_get_ldb_context(eid);
- if (ldb == NULL) {
- return -1;
- }
-
- mpr_Return(eid, mprString(ldb_errstring(ldb)));
- return 0;
-}
-
-/*
- base64 encode
- usage:
- dataout = ldb.encode(datain)
- */
-static int ejs_base64encode(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- char *ret;
-
- if (argc != 1) {
- ejsSetErrorMsg(eid, "ldb.base64encode invalid argument count");
- return -1;
- }
-
- if (argv[0]->type == MPR_TYPE_STRING) {
- const char *orig = mprToString(argv[0]);
- ret = ldb_base64_encode(mprMemCtx(), orig, strlen(orig));
- } else {
- DATA_BLOB *blob;
-
- blob = mprToDataBlob(argv[0]);
- mprAssert(blob);
- ret = ldb_base64_encode(mprMemCtx(), (char *)blob->data, blob->length);
- }
-
- if (!ret) {
- mpr_Return(eid, mprCreateUndefinedVar());
- } else {
- mpr_Return(eid, mprString(ret));
- }
-
- talloc_free(ret);
-
- return 0;
-}
-
-/*
- base64 decode
- usage:
- dataout = ldb.decode(datain)
- */
-static int ejs_base64decode(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- char *tmp;
- int ret;
-
- if (argc != 1) {
- ejsSetErrorMsg(eid, "ldb.base64encode invalid argument count");
- return -1;
- }
-
- tmp = talloc_strdup(mprMemCtx(), mprToString(argv[0]));
- ret = ldb_base64_decode(tmp);
- if (ret == -1) {
- mpr_Return(eid, mprCreateUndefinedVar());
- } else {
- DATA_BLOB blob;
- blob.data = (uint8_t *)tmp;
- blob.length = ret;
- mpr_Return(eid, mprDataBlob(blob));
- }
-
- talloc_free(tmp);
-
- return 0;
-}
-
-/*
- escape a DN
- usage:
- dataout = ldb.dn_escape(datain)
- */
-static int ejs_dn_escape(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- char *ret;
- struct ldb_val val;
-
- if (argc != 1) {
- ejsSetErrorMsg(eid, "ldb.dn_escape invalid argument count");
- return -1;
- }
-
- val = data_blob_string_const(mprToString(argv[0]));
-
- ret = ldb_dn_escape_value(mprMemCtx(), val);
- if (ret == NULL) {
- mpr_Return(eid, mprCreateUndefinedVar());
- } else {
- mpr_Return(eid, mprString(ret));
- talloc_free(ret);
- }
-
- return 0;
-}
-
-/*
- perform an ldb add
-
- syntax:
- ok = ldb.add(ldifstring);
-*/
-static int ejs_ldbAdd(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- return ejs_ldbAddModify(eid, argc, argv, ldb_add);
-}
-
-/*
- perform an ldb modify
-
- syntax:
- ok = ldb.modify(ldifstring);
-*/
-static int ejs_ldbModify(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- return ejs_ldbAddModify(eid, argc, argv, ldb_modify);
-}
-
-/*
- connect to a database
- usage:
- ok = ldb.connect(dbfile);
- ok = ldb.connect(dbfile, "modules:modlist");
-
- ldb.credentials or ldb.session_info may be setup first
-
-*/
-static int ejs_ldbConnect(MprVarHandle eid, int argc, char **argv)
-{
- struct ldb_context *ldb;
- struct auth_session_info *session_info = NULL;
- struct cli_credentials *creds = NULL;
- struct MprVar *credentials, *session;
- struct MprVar *this = mprGetProperty(ejsGetLocalObject(eid), "this", 0);
-
- const char *dbfile;
-
- if (argc < 1) {
- ejsSetErrorMsg(eid, "ldb.connect invalid arguments");
- return -1;
- }
-
- credentials = mprGetProperty(this, "credentials", NULL);
- if (credentials) {
- creds = talloc_get_type(mprGetPtr(credentials, "creds"), struct cli_credentials);
- }
-
- session = mprGetProperty(this, "session_info", NULL);
- if (session) {
- session_info = talloc_get_type(mprGetPtr(session, "session_info"), struct auth_session_info);
- }
-
- dbfile = argv[0];
-
- ldb = ldb_wrap_connect(mprMemCtx(), mprEventCtx(), mprLpCtx(), dbfile,
- session_info, creds,
- 0, (const char **)(argv+1));
- if (ldb == NULL) {
- ejsSetErrorMsg(eid, "ldb.connect failed to open %s", dbfile);
- }
-
- mprSetThisPtr(eid, "db", ldb);
- mpr_Return(eid, mprCreateBoolVar(ldb != NULL));
- return 0;
-}
-
-
-/*
- close a db connection
-*/
-static int ejs_ldbClose(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- struct ldb_context *ldb;
-
- if (argc != 0) {
- ejsSetErrorMsg(eid, "ldb.close invalid arguments");
- return -1;
- }
-
- ldb = ejs_get_ldb_context(eid);
- if (ldb == NULL) {
- return -1;
- }
-
- mprSetThisPtr(eid, "db", NULL);
- mpr_Return(eid, mprCreateBoolVar(true));
- return 0;
-}
-
-
-/*
- start a ldb transaction
- usage:
- ok = ldb.transaction_start();
-*/
-static int ejs_ldbTransactionStart(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- struct ldb_context *ldb;
- int ret;
-
- if (argc != 0) {
- ejsSetErrorMsg(eid, "ldb.transaction_start invalid arguments");
- return -1;
- }
-
- ldb = ejs_get_ldb_context(eid);
- if (ldb == NULL) {
- return -1;
- }
-
- ret = ldb_transaction_start(ldb);
-
- mpr_Return(eid, mprCreateBoolVar(ret == 0));
- return 0;
-}
-
-/*
- cancel a ldb transaction
- usage:
- ok = ldb.transaction_cancel();
-*/
-static int ejs_ldbTransactionCancel(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- struct ldb_context *ldb;
- int ret;
-
- if (argc != 0) {
- ejsSetErrorMsg(eid, "ldb.transaction_cancel invalid arguments");
- return -1;
- }
-
- ldb = ejs_get_ldb_context(eid);
- if (ldb == NULL) {
- return -1;
- }
-
- ret = ldb_transaction_cancel(ldb);
-
- mpr_Return(eid, mprCreateBoolVar(ret == 0));
- return 0;
-}
-
-/*
- commit a ldb transaction
- usage:
- ok = ldb.transaction_commit();
-*/
-static int ejs_ldbTransactionCommit(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- struct ldb_context *ldb;
- int ret;
-
- if (argc != 0) {
- ejsSetErrorMsg(eid, "ldb.transaction_commit invalid arguments");
- return -1;
- }
-
- ldb = ejs_get_ldb_context(eid);
- if (ldb == NULL) {
- return -1;
- }
-
- ret = ldb_transaction_commit(ldb);
-
- mpr_Return(eid, mprCreateBoolVar(ret == 0));
- return 0;
-}
-
-/*
- commit a ldb attach a dsdb_schema from ldif files
- usage:
- ok = ldb.attach_dsdb_schema_from_ldif("prefixMap ldif content", "definition ldif content")
-*/
-static int ejs_ldb_attach_dsdb_schema_from_ldif(MprVarHandle eid, int argc, char **argv)
-{
- struct ldb_context *ldb;
- WERROR status;
- const char *pf;
- const char *df;
-
- if (argc != 2) {
- ejsSetErrorMsg(eid, "ldb.attach_dsdb_schema_from_ldif invalid arguments");
- return -1;
- }
-
- ldb = ejs_get_ldb_context(eid);
- if (ldb == NULL) {
- return -1;
- }
-
- pf = argv[0];
- df = argv[1];
-
- status = dsdb_attach_schema_from_ldif_file(ldb, pf, df);
-
- mpr_Return(eid, mprWERROR(status));
- return 0;
-}
-
-/*
- set a particular invocationId against the running LDB
- usage:
- ok = ldb.set_ntds_invocationId("7729aa4b-f990-41ad-b81a-8b6a14090f41");
-*/
-static int ejs_ldb_set_ntds_invocationId(MprVarHandle eid, int argc, char **argv)
-{
- struct ldb_context *ldb;
- NTSTATUS status;
- struct GUID guid;
- char *guid_str;
- bool ok;
-
- if (argc != 1) {
- ejsSetErrorMsg(eid, "ldb.set_ntds_invocationId invalid arguments");
- return -1;
- }
-
- ldb = ejs_get_ldb_context(eid);
- if (ldb == NULL) {
- return -1;
- }
-
- guid_str = argv[0];
-
- status = GUID_from_string(guid_str, &guid);
- if (!NT_STATUS_IS_OK(status)) {
- ejsSetErrorMsg(eid, "ldb.set_ntds_invocationId - failed to parse GUID '%s' %s\n",
- guid_str, nt_errstr(status));
- return -1;
- }
-
- ok = samdb_set_ntds_invocation_id(ldb, &guid);
- if (!ok) {
- ejsSetErrorMsg(eid, "ldb.set_ntds_invocationId - failed to set cached ntds invocationId\n");
- return -1;
- }
-
- mpr_Return(eid, mprCreateBoolVar(ok));
- return 0;
-}
-
-/*
- attach a particular ntds objectGUID against the current ldb
- usage:
- ok = ldb.set_ntds_objectGUID("7729aa4b-f990-41ad-b81a-8b6a14090f41");
-*/
-static int ejs_ldb_set_ntds_objectGUID(MprVarHandle eid, int argc, char **argv)
-{
- struct ldb_context *ldb;
- NTSTATUS status;
- struct GUID guid;
- char *guid_str;
- bool ok;
-
- if (argc != 1) {
- ejsSetErrorMsg(eid, "ldb.set_ntds_objectGUID invalid arguments");
- return -1;
- }
-
- ldb = ejs_get_ldb_context(eid);
- if (ldb == NULL) {
- return -1;
- }
-
- guid_str = argv[0];
-
- status = GUID_from_string(guid_str, &guid);
- if (!NT_STATUS_IS_OK(status)) {
- ejsSetErrorMsg(eid, "ldb.set_ntds_objectGUID - failed to parse GUID '%s' %s\n",
- guid_str, nt_errstr(status));
- return -1;
- }
-
- ok = samdb_set_ntds_invocation_id(ldb, &guid);
- if (!ok) {
- ejsSetErrorMsg(eid, "ldb.set_ntds_objectGUID - failed to set cached ntds invocationId\n");
- return -1;
- }
-
- mpr_Return(eid, mprCreateBoolVar(ok));
- return 0;
-}
-
-/*
- attach a particular domain SID against the current ldb
- usage:
- ok = ldb.set_domain_sid("S-S-1-5-21-3065342217-3567412576-2214182334");
-*/
-static int ejs_ldb_set_domain_sid(MprVarHandle eid, int argc, char **argv)
-{
- struct ldb_context *ldb;
- struct dom_sid *dom_sid;
- char *dom_sid_str;
- bool ok;
-
- if (argc != 1) {
- ejsSetErrorMsg(eid, "ldb.set_domain_sid invalid arguments");
- return -1;
- }
-
- ldb = ejs_get_ldb_context(eid);
- if (ldb == NULL) {
- return -1;
- }
-
- dom_sid_str = argv[0];
-
- dom_sid = dom_sid_parse_talloc(NULL, dom_sid_str);
- if (!dom_sid) {
- ejsSetErrorMsg(eid, "ldb.set_domain_sid - failed to parse domain sid '%s'\n",
- dom_sid_str);
- return -1;
- }
-
- ok = samdb_set_domain_sid(ldb, dom_sid);
- talloc_free(dom_sid);
- if (!ok) {
- ejsSetErrorMsg(eid, "ldb.set_domain_sid - failed to set cached ntds invocationId\n");
- return -1;
- }
-
- mpr_Return(eid, mprCreateBoolVar(ok));
- return 0;
-}
-
-/*
- initialise ldb ejs subsystem
-*/
-static int ejs_ldb_init(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- struct MprVar *ldb = mprInitObject(eid, "ldb", argc, argv);
-
- mprSetStringCFunction(ldb, "connect", ejs_ldbConnect);
- mprSetCFunction(ldb, "search", ejs_ldbSearch);
- mprSetCFunction(ldb, "add", ejs_ldbAdd);
- mprSetCFunction(ldb, "modify", ejs_ldbModify);
- mprSetCFunction(ldb, "del", ejs_ldbDelete);
- mprSetCFunction(ldb, "rename", ejs_ldbRename);
- mprSetCFunction(ldb, "errstring", ejs_ldbErrstring);
- mprSetCFunction(ldb, "encode", ejs_base64encode);
- mprSetCFunction(ldb, "decode", ejs_base64decode);
- mprSetCFunction(ldb, "dn_escape", ejs_dn_escape);
- mprSetCFunction(ldb, "close", ejs_ldbClose);
- mprSetCFunction(ldb, "transaction_start", ejs_ldbTransactionStart);
- mprSetCFunction(ldb, "transaction_cancel", ejs_ldbTransactionCancel);
- mprSetCFunction(ldb, "transaction_commit", ejs_ldbTransactionCommit);
- mprSetStringCFunction(ldb, "attach_dsdb_schema_from_ldif",
- ejs_ldb_attach_dsdb_schema_from_ldif);
- mprSetStringCFunction(ldb, "set_ntds_invocationId",
- ejs_ldb_set_ntds_invocationId);
- mprSetStringCFunction(ldb, "set_ntds_objectGUID",
- ejs_ldb_set_ntds_objectGUID);
- mprSetStringCFunction(ldb, "set_domain_sid",
- ejs_ldb_set_domain_sid);
- mprSetVar(ldb, "SCOPE_BASE", mprCreateNumberVar(LDB_SCOPE_BASE));
- mprSetVar(ldb, "SCOPE_ONE", mprCreateNumberVar(LDB_SCOPE_ONELEVEL));
- mprSetVar(ldb, "SCOPE_SUBTREE", mprCreateNumberVar(LDB_SCOPE_SUBTREE));
- mprSetVar(ldb, "SCOPE_DEFAULT", mprCreateNumberVar(LDB_SCOPE_DEFAULT));
-
- return 0;
-}
-
-
-/*
- setup C functions that be called from ejs
-*/
-NTSTATUS smb_setup_ejs_ldb(void)
-{
- ejsDefineCFunction(-1, "ldb_init", ejs_ldb_init, NULL, MPR_VAR_SCRIPT_HANDLE);
- return NT_STATUS_OK;
-}
+++ /dev/null
-/*
- Unix SMB/CIFS implementation.
-
- provide a command line options parsing function for ejs
-
- Copyright (C) Andrew Tridgell 2005
-
- 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 "lib/cmdline/popt_common.h"
-#include "scripting/ejs/smbcalls.h"
-
-
-/*
- usage:
- options = GetOptions(argv,
- "realm=s",
- "enablexx",
- "myint=i");
-
- the special options POPT_COMMON_* options are recognised and replaced
- with the Samba internal options
-
- resulting parsed options are placed in the options object
-
- additional command line arguments are placed in options.ARGV
-*/
-
-static int ejs_GetOptions(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- poptContext pc;
- int opt;
- struct {
- const char *name;
- struct poptOption *table;
- const char *description;
- } tables[] = {
- { "POPT_AUTOHELP", poptHelpOptions, "Help options:" },
- { "POPT_COMMON_SAMBA", popt_common_samba, "Common Samba options:" },
- { "POPT_COMMON_CONNECTION", popt_common_connection, "Connection options:" },
- { "POPT_COMMON_CREDENTIALS", popt_common_credentials, "Authentication options:" },
- { "POPT_COMMON_VERSION", popt_common_version, "Common Samba options:" }
- };
-
- struct MprVar *options = mprInitObject(eid, "options", 0, NULL);
-
- TALLOC_CTX *tmp_ctx = talloc_new(mprMemCtx());
- struct poptOption *long_options = NULL;
- int i, num_options = 0;
- int opt_argc;
- const char **opt_argv;
- const char **opt_names = NULL;
- const int BASE_OPTNUM = 0x100000;
-
- /* validate arguments */
- if (argc < 1 || argv[0]->type != MPR_TYPE_OBJECT) {
- ejsSetErrorMsg(eid, "GetOptions invalid arguments");
- return -1;
- }
-
- opt_argv = mprToArray(tmp_ctx, argv[0]);
- opt_argc = str_list_length(opt_argv);
-
- long_options = talloc_array(tmp_ctx, struct poptOption, 1);
- if (long_options == NULL) {
- return -1;
- }
-
- /* create the long_options array */
- for (i=1;i<argc;i++) {
- const char *optstr = mprToString(argv[i]);
- int t, opt_type = POPT_ARG_NONE;
- const char *s;
- if (argv[i]->type != MPR_TYPE_STRING) {
- ejsSetErrorMsg(eid, "GetOptions string argument");
- return -1;
- }
-
- long_options = talloc_realloc(tmp_ctx, long_options,
- struct poptOption, num_options+2);
- if (long_options == NULL) {
- return -1;
- }
- ZERO_STRUCT(long_options[num_options]);
-
- /* see if its one of the special samba option tables */
- for (t=0;t<ARRAY_SIZE(tables);t++) {
- if (strcmp(tables[t].name, optstr) == 0) {
- break;
- }
- }
- if (t < ARRAY_SIZE(tables)) {
- opt_names = str_list_add(opt_names, optstr);
- talloc_steal(tmp_ctx, opt_names);
- long_options[num_options].argInfo = POPT_ARG_INCLUDE_TABLE;
- long_options[num_options].arg = tables[t].table;
- long_options[num_options].descrip = tables[t].description;
- num_options++;
- continue;
- }
-
- s = strchr(optstr, '=');
- if (s) {
- char *name = talloc_strndup(tmp_ctx, optstr, (int)(s-optstr));
- opt_names = str_list_add(opt_names, name);
- if (s[1] == 's') {
- opt_type = POPT_ARG_STRING;
- } else if (s[1] == 'i') {
- opt_type = POPT_ARG_INT;
- } else {
- ejsSetErrorMsg(eid, "GetOptions invalid option type");
- return -1;
- }
- talloc_free(name);
- } else {
- opt_names = str_list_add(opt_names, optstr);
- }
- talloc_steal(tmp_ctx, opt_names);
- if (strlen(opt_names[num_options]) == 1) {
- long_options[num_options].shortName = opt_names[num_options][0];
- } else {
- long_options[num_options].longName = opt_names[num_options];
- }
- long_options[num_options].argInfo = opt_type;
- long_options[num_options].val = num_options + BASE_OPTNUM;
- num_options++;
- }
-
- ZERO_STRUCT(long_options[num_options]);
-
- pc = poptGetContext("smbscript", opt_argc, opt_argv, long_options, 0);
-
- /* parse the options */
- while((opt = poptGetNextOpt(pc)) != -1) {
- const char *arg;
-
- if (opt < BASE_OPTNUM || opt >= num_options + BASE_OPTNUM) {
- char *err;
- err = talloc_asprintf(tmp_ctx, "%s: %s",
- poptBadOption(pc, POPT_BADOPTION_NOALIAS),
- poptStrerror(opt));
- mprSetVar(options, "ERROR", mprString(err));
- talloc_free(tmp_ctx);
- mpr_Return(eid, mprCreateUndefinedVar());
- return 0;
- }
- opt -= BASE_OPTNUM;
- arg = poptGetOptArg(pc);
- if (arg == NULL) {
- mprSetVar(options, opt_names[opt], mprCreateBoolVar(1));
- } else if (long_options[opt].argInfo == POPT_ARG_INT) {
- int v = strtol(arg, NULL, 0);
- mprSetVar(options, opt_names[opt], mprCreateIntegerVar(v));
- } else {
- mprSetVar(options, opt_names[opt], mprString(arg));
- }
- }
-
- /* setup options.argv list */
- mprSetVar(options, "ARGV", mprList("ARGV", poptGetArgs(pc)));
-
- poptFreeContext(pc);
-
- talloc_free(tmp_ctx);
-
- /* setup methods */
- mprSetCFunction(options, "get_credentials", ejs_credentials_cmdline);
-
- return 0;
-}
-
-
-
-/*
- setup C functions that be called from ejs
-*/
-void smb_setup_ejs_options(void)
-{
- ejsDefineCFunction(-1, "GetOptions", ejs_GetOptions, NULL, MPR_VAR_SCRIPT_HANDLE);
-}
+++ /dev/null
-/*
- Unix SMB/CIFS implementation.
-
- provide access to string functions
-
- Copyright (C) Andrew Tridgell 2005
- Copyright (C) Jelmer Vernooij 2005 (substr)
-
- 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 "scripting/ejs/smbcalls.h"
-#include "lib/appweb/ejs/ejs.h"
-
-/*
- usage:
- var len = strlen(str);
-*/
-static int ejs_strlen(MprVarHandle eid, int argc, char **argv)
-{
- if (argc != 1) {
- ejsSetErrorMsg(eid, "strlen invalid arguments");
- return -1;
- }
- mpr_Return(eid, mprCreateIntegerVar(strlen_m(argv[0])));
- return 0;
-}
-
-/*
- usage:
- var s = strlower("UPPER");
-*/
-static int ejs_strlower(MprVarHandle eid, int argc, char **argv)
-{
- char *s;
- if (argc != 1) {
- ejsSetErrorMsg(eid, "strlower invalid arguments");
- return -1;
- }
- s = strlower_talloc(mprMemCtx(), argv[0]);
- mpr_Return(eid, mprString(s));
- talloc_free(s);
- return 0;
-}
-
-/*
- usage:
- var s = strupper("lower");
-*/
-static int ejs_strupper(MprVarHandle eid, int argc, char **argv)
-{
- char *s;
- if (argc != 1) {
- ejsSetErrorMsg(eid, "strupper invalid arguments");
- return -1;
- }
- s = strupper_talloc(mprMemCtx(), argv[0]);
- mpr_Return(eid, mprString(s));
- talloc_free(s);
- return 0;
-}
-
-/*
- usage:
- var s = strstr(string, substring);
-*/
-static int ejs_strstr(MprVarHandle eid, int argc, char **argv)
-{
- char *s;
- if (argc != 2) {
- ejsSetErrorMsg(eid, "strstr invalid arguments");
- return -1;
- }
- s = strstr(argv[0], argv[1]);
- mpr_Return(eid, mprString(s));
- return 0;
-}
-
-/*
- usage:
- var s = strspn(string, legal_chars_string);
-*/
-static int ejs_strspn(MprVarHandle eid, int argc, char **argv)
-{
- int len;
- if (argc != 2) {
- ejsSetErrorMsg(eid, "strspn invalid arguments");
- return -1;
- }
- len = strspn(argv[0], argv[1]);
- mpr_Return(eid, mprCreateIntegerVar(len));
- return 0;
-}
-
-/*
- usage:
- list = split(".", "a.foo.bar");
- list = split(".", "a.foo.bar", count);
-
- count is an optional count of how many splits to make
-
- NOTE: does not take a regular expression, unlike perl split()
-*/
-static int ejs_split(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- const char *separator, *s;
- char *p;
- struct MprVar ret;
- int count = 0, maxcount=0;
- TALLOC_CTX *tmp_ctx = talloc_new(mprMemCtx());
- if (argc < 2 ||
- argv[0]->type != MPR_TYPE_STRING ||
- argv[1]->type != MPR_TYPE_STRING) {
- ejsSetErrorMsg(eid, "split invalid arguments");
- return -1;
- }
- separator = mprToString(argv[0]);
- s = mprToString(argv[1]);
- if (argc == 3) {
- maxcount = mprToInt(argv[2]);
- }
-
- ret = mprArray("list");
-
- while ((p = strstr(s, separator))) {
- char *s2 = talloc_strndup(tmp_ctx, s, (int)(p-s));
- mprAddArray(&ret, count++, mprString(s2));
- talloc_free(s2);
- s = p + strlen(separator);
- if (maxcount != 0 && count >= maxcount) {
- break;
- }
- }
- if (*s) {
- mprAddArray(&ret, count++, mprString(s));
- }
- talloc_free(tmp_ctx);
- mpr_Return(eid, ret);
- return 0;
-}
-
-/*
- usage:
- str = substr(orig[, start_offset[, length]]);
-
- special cases:
- if start_offset < 0 then start_offset+=strlen(orig)
- if length < 0 then length+=strlen(orig)-start_offset
-
- (as found in many other languages)
-*/
-static int ejs_substr(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- int start_offset = 0;
- int length = 0;
- const char *orig;
- char *target;
-
- if (argc < 1 || argc > 3 ||
- argv[0]->type != MPR_TYPE_STRING) {
- ejsSetErrorMsg(eid, "substr invalid arguments");
- return -1;
- }
-
- if (argc == 1) {
- mpr_Return(eid, *argv[0]);
- return 0;
- }
-
- orig = mprToString(argv[0]);
- start_offset = mprToInt(argv[1]);
- length = strlen(orig);
- if (start_offset < 0) start_offset += strlen(orig);
- if (start_offset < 0 || start_offset > strlen(orig)) {
- ejsSetErrorMsg(eid, "substr arg 2 out of bounds ([%s], %d)", orig, start_offset);
- return -1;
- }
-
- if (argc == 3) {
- length = mprToInt(argv[2]);
- if (length < 0) length += strlen(orig) - start_offset;
- if (length < 0 || length+start_offset > strlen(orig)) {
- ejsSetErrorMsg(eid, "substr arg 3 out of bounds ([%s], %d, %d)", orig, start_offset, length);
- return -1;
- }
- }
-
- target = talloc_strndup(mprMemCtx(), orig+start_offset, length);
-
- mpr_Return(eid, mprString(target));
-
- talloc_free(target);
-
- return 0;
-}
-
-/*
- usage:
- str = join("DC=", list);
-*/
-static int ejs_join(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- int i;
- const char *separator;
- char *ret = NULL;
- const char **list;
- TALLOC_CTX *tmp_ctx = talloc_new(mprMemCtx());
- if (argc != 2 ||
- argv[0]->type != MPR_TYPE_STRING ||
- argv[1]->type != MPR_TYPE_OBJECT) {
- ejsSetErrorMsg(eid, "join invalid arguments");
- return -1;
- }
-
- separator = mprToString(argv[0]);
- list = mprToArray(tmp_ctx, argv[1]);
-
- if (list == NULL || list[0] == NULL) {
- talloc_free(tmp_ctx);
- mpr_Return(eid, mprString(NULL));
- return 0;
- }
-
- ret = talloc_strdup(tmp_ctx, list[0]);
- if (ret == NULL) {
- goto failed;
- }
- for (i=1;list[i];i++) {
- ret = talloc_asprintf_append_buffer(ret, "%s%s", separator, list[i]);
- if (ret == NULL) {
- goto failed;
- }
- }
- mpr_Return(eid, mprString(ret));
- talloc_free(tmp_ctx);
- return 0;
-failed:
- ejsSetErrorMsg(eid, "out of memory");
- return -1;
-}
-
-
-/*
- blergh, C certainly makes this hard!
- usage:
- str = sprintf("i=%d s=%7s", 7, "foo");
-*/
-typedef char *(*_asprintf_append_t)(char *, const char *, ...);
-static int ejs_sprintf(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- const char *format;
- const char *p;
- char *ret;
- int a = 1;
- _asprintf_append_t _asprintf_append;
- TALLOC_CTX *tmp_ctx;
- if (argc < 1 || argv[0]->type != MPR_TYPE_STRING) {
- ejsSetErrorMsg(eid, "sprintf invalid arguments");
- return -1;
- }
- format = mprToString(argv[0]);
- tmp_ctx = talloc_new(mprMemCtx());
- ret = talloc_strdup(tmp_ctx, "");
-
- /* avoid all the format string warnings */
- _asprintf_append = (_asprintf_append_t)talloc_asprintf_append_buffer;
-
- /*
- hackity hack ...
- */
- while ((p = strchr(format, '%'))) {
- char *fmt2;
- int len, len_count=0;
- char *tstr;
- ret = talloc_asprintf_append_buffer(ret, "%*.*s",
- (int)(p-format), (int)(p-format),
- format);
- if (ret == NULL) goto failed;
- format += (int)(p-format);
- len = strcspn(p+1, "dxuiofgGpXeEFcs%") + 1;
- fmt2 = talloc_strndup(tmp_ctx, p, len+1);
- if (fmt2 == NULL) goto failed;
- len_count = count_chars(fmt2, '*');
- /* find the type string */
- tstr = &fmt2[len];
- while (tstr > fmt2 && isalpha((unsigned char)tstr[-1])) {
- tstr--;
- }
- if (strcmp(tstr, "%") == 0) {
- ret = talloc_asprintf_append_buffer(ret, "%%");
- if (ret == NULL) {
- goto failed;
- }
- format += len+1;
- continue;
- }
- if (len_count > 2 ||
- argc < a + len_count + 1) {
- ejsSetErrorMsg(eid, "sprintf: not enough arguments for format");
- goto failed;
- }
-#define FMT_ARG(fn, type) do { \
- switch (len_count) { \
- case 0: \
- ret = _asprintf_append(ret, fmt2, \
- (type)fn(argv[a])); \
- break; \
- case 1: \
- ret = _asprintf_append(ret, fmt2, \
- (int)mprVarToNumber(argv[a]), \
- (type)fn(argv[a+1])); \
- break; \
- case 2: \
- ret = _asprintf_append(ret, fmt2, \
- (int)mprVarToNumber(argv[a]), \
- (int)mprVarToNumber(argv[a+1]), \
- (type)fn(argv[a+2])); \
- break; \
- } \
- a += len_count + 1; \
- if (ret == NULL) { \
- goto failed; \
- } \
-} while (0)
-
- if (strcmp(tstr, "s")==0) FMT_ARG(mprToString, const char *);
- else if (strcmp(tstr, "c")==0) FMT_ARG(*mprToString, char);
- else if (strcmp(tstr, "d")==0) FMT_ARG(mprVarToNumber, int);
- else if (strcmp(tstr, "ld")==0) FMT_ARG(mprVarToNumber, long);
- else if (strcmp(tstr, "lld")==0) FMT_ARG(mprVarToNumber, long long);
- else if (strcmp(tstr, "x")==0) FMT_ARG(mprVarToNumber, int);
- else if (strcmp(tstr, "lx")==0) FMT_ARG(mprVarToNumber, long);
- else if (strcmp(tstr, "llx")==0) FMT_ARG(mprVarToNumber, long long);
- else if (strcmp(tstr, "X")==0) FMT_ARG(mprVarToNumber, int);
- else if (strcmp(tstr, "lX")==0) FMT_ARG(mprVarToNumber, long);
- else if (strcmp(tstr, "llX")==0) FMT_ARG(mprVarToNumber, long long);
- else if (strcmp(tstr, "u")==0) FMT_ARG(mprVarToNumber, int);
- else if (strcmp(tstr, "lu")==0) FMT_ARG(mprVarToNumber, long);
- else if (strcmp(tstr, "llu")==0) FMT_ARG(mprVarToNumber, long long);
- else if (strcmp(tstr, "i")==0) FMT_ARG(mprVarToNumber, int);
- else if (strcmp(tstr, "li")==0) FMT_ARG(mprVarToNumber, long);
- else if (strcmp(tstr, "lli")==0) FMT_ARG(mprVarToNumber, long long);
- else if (strcmp(tstr, "o")==0) FMT_ARG(mprVarToNumber, int);
- else if (strcmp(tstr, "lo")==0) FMT_ARG(mprVarToNumber, long);
- else if (strcmp(tstr, "llo")==0) FMT_ARG(mprVarToNumber, long long);
- else if (strcmp(tstr, "f")==0) FMT_ARG(mprVarToFloat, double);
- else if (strcmp(tstr, "lf")==0) FMT_ARG(mprVarToFloat, double);
- else if (strcmp(tstr, "g")==0) FMT_ARG(mprVarToFloat, double);
- else if (strcmp(tstr, "lg")==0) FMT_ARG(mprVarToFloat, double);
- else if (strcmp(tstr, "e")==0) FMT_ARG(mprVarToFloat, double);
- else if (strcmp(tstr, "le")==0) FMT_ARG(mprVarToFloat, double);
- else if (strcmp(tstr, "E")==0) FMT_ARG(mprVarToFloat, double);
- else if (strcmp(tstr, "lE")==0) FMT_ARG(mprVarToFloat, double);
- else if (strcmp(tstr, "F")==0) FMT_ARG(mprVarToFloat, double);
- else if (strcmp(tstr, "lF")==0) FMT_ARG(mprVarToFloat, double);
- else {
- ejsSetErrorMsg(eid, "sprintf: unknown format string '%s'", fmt2);
- goto failed;
- }
- format += len+1;
- }
-
- ret = talloc_asprintf_append_buffer(ret, "%s", format);
- mpr_Return(eid, mprString(ret));
- talloc_free(tmp_ctx);
- return 0;
-
-failed:
- talloc_free(tmp_ctx);
- return -1;
-}
-
-/*
- used to build your own print function
- str = vsprintf(args);
-*/
-static int ejs_vsprintf(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- struct MprVar **args, *len, *v;
- int i, ret, length;
- if (argc != 1 || argv[0]->type != MPR_TYPE_OBJECT) {
- ejsSetErrorMsg(eid, "vsprintf invalid arguments");
- return -1;
- }
- v = argv[0];
- len = mprGetProperty(v, "length", NULL);
- if (len == NULL) {
- ejsSetErrorMsg(eid, "vsprintf takes an array");
- return -1;
- }
- length = mprToInt(len);
- args = talloc_array(mprMemCtx(), struct MprVar *, length);
- if (args == NULL) {
- return -1;
- }
-
- for (i=0;i<length;i++) {
- char idx[16];
- mprItoa(i, idx, sizeof(idx));
- args[i] = mprGetProperty(v, idx, NULL);
- }
-
- ret = ejs_sprintf(eid, length, args);
- talloc_free(args);
- return ret;
-}
-
-
-/*
- encode a string, replacing all non-alpha with %02x form
-*/
-static int ejs_encodeURIComponent(MprVarHandle eid, int argc, char **argv)
-{
- int i, j, count=0;
- const char *s;
- char *ret;
- if (argc != 1) {
- ejsSetErrorMsg(eid, "encodeURIComponent invalid arguments");
- return -1;
- }
-
- s = argv[0];
-
- for (i=0;s[i];i++) {
- if (!isalnum(s[i])) count++;
- }
-
- ret = talloc_array(mprMemCtx(), char, i + count*2 + 1);
- if (ret == NULL) {
- return -1;
- }
- for (i=j=0;s[i];i++,j++) {
- if (!isalnum(s[i])) {
- snprintf(ret+j, 4, "%%%02X", (unsigned)s[i]);
- j += 2;
- } else {
- ret[j] = s[i];
- }
- }
- ret[j] = 0;
- mpr_Return(eid, mprString(ret));
- talloc_free(ret);
- return 0;
-}
-
-/*
- encode a string, replacing all non-alpha of %02x form
-*/
-static int ejs_decodeURIComponent(MprVarHandle eid, int argc, char **argv)
-{
- int i, j, count=0;
- const char *s;
- char *ret;
- if (argc != 1) {
- ejsSetErrorMsg(eid, "decodeURIComponent invalid arguments");
- return -1;
- }
-
- s = argv[0];
-
- ret = talloc_array(mprMemCtx(), char, strlen(s) + 1);
- if (ret == NULL) {
- return -1;
- }
-
- for (i=j=0;s[i];i++,j++) {
- if (s[i] == '%') {
- unsigned c;
- if (sscanf(s+i+1, "%02X", &c) != 1) {
- ejsSetErrorMsg(eid, "decodeURIComponent bad format");
- return -1;
- }
- ret[j] = c;
- i += 2;
- } else {
- ret[j] = s[i];
- }
- if (!isalnum(s[i])) count++;
- }
-
- ret[j] = 0;
- mpr_Return(eid, mprString(ret));
- talloc_free(ret);
- return 0;
-}
-
-/*
- initialise string ejs subsystem
-*/
-static int ejs_string_init(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- struct MprVar *obj = mprInitObject(eid, "string", argc, argv);
-
- mprSetCFunction(obj, "substr", ejs_substr);
- mprSetStringCFunction(obj, "strlen", ejs_strlen);
- mprSetStringCFunction(obj, "strlower", ejs_strlower);
- mprSetStringCFunction(obj, "strupper", ejs_strupper);
- mprSetStringCFunction(obj, "strstr", ejs_strstr);
- mprSetStringCFunction(obj, "strspn", ejs_strspn);
- mprSetCFunction(obj, "split", ejs_split);
- mprSetCFunction(obj, "join", ejs_join);
- mprSetCFunction(obj, "sprintf", ejs_sprintf);
- mprSetCFunction(obj, "vsprintf", ejs_vsprintf);
- mprSetStringCFunction(obj, "encodeURIComponent", ejs_encodeURIComponent);
- mprSetStringCFunction(obj, "decodeURIComponent", ejs_decodeURIComponent);
-
- return 0;
-}
-
-/*
- setup C functions that be called from ejs
-*/
-NTSTATUS smb_setup_ejs_string(void)
-{
- ejsDefineCFunction(-1, "string_init", ejs_string_init, NULL, MPR_VAR_SCRIPT_HANDLE);
- return NT_STATUS_OK;
-}
+++ /dev/null
-/*
- Unix SMB/CIFS implementation.
-
- provide access to system functions
-
- Copyright (C) Andrew Tridgell 2005
-
- 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 "scripting/ejs/smbcalls.h"
-#include "lib/appweb/ejs/ejs.h"
-#include "lib/ldb/include/ldb.h"
-#include "system/time.h"
-#include "system/network.h"
-#include "lib/socket/netif.h"
-
-/*
- return the list of configured network interfaces
-*/
-static int ejs_sys_interfaces(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- int i, count;
- struct MprVar ret = mprArray("interfaces");
- struct interface *ifaces;
-
- load_interfaces(NULL, lp_interfaces(mprLpCtx()), &ifaces);
-
- count = iface_count(ifaces);
- for (i=0;i<count;i++) {
- mprAddArray(&ret, i, mprString(iface_n_ip(ifaces, i)));
- }
-
- talloc_free(ifaces);
- mpr_Return(eid, ret);
- return 0;
-}
-
-/*
- return the hostname from gethostname()
-*/
-static int ejs_sys_hostname(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- char name[200];
- if (gethostname(name, sizeof(name)-1) == -1) {
- ejsSetErrorMsg(eid, "gethostname failed - %s", strerror(errno));
- return -1;
- }
- mpr_Return(eid, mprString(name));
- return 0;
-}
-
-
-/*
- return current time as seconds and microseconds
-*/
-static int ejs_sys_gettimeofday(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- struct timeval tv = timeval_current();
- struct MprVar v = mprObject("timeval");
- struct MprVar sec = mprCreateIntegerVar(tv.tv_sec);
- struct MprVar usec = mprCreateIntegerVar(tv.tv_usec);
-
- mprCreateProperty(&v, "sec", &sec);
- mprCreateProperty(&v, "usec", &usec);
- mpr_Return(eid, v);
- return 0;
-}
-
-/*
- return current time as a 64 bit nttime value
-*/
-static int ejs_sys_nttime(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- struct timeval tv = timeval_current();
- struct MprVar v = mprCreateNumberVar(timeval_to_nttime(&tv));
- mpr_Return(eid, v);
- return 0;
-}
-
-/*
- return time as a 64 bit nttime value from a 32 bit time_t value
-*/
-static int ejs_sys_unix2nttime(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- NTTIME nt;
- struct MprVar v;
- if (argc != 1 || !mprVarIsNumber(argv[0]->type)) {
- ejsSetErrorMsg(eid, "sys_unix2nttime invalid arguments");
- return -1;
- }
- unix_to_nt_time(&nt, mprVarToNumber(argv[0]));
- v = mprCreateNumberVar(nt);
- mpr_Return(eid, v);
- return 0;
-}
-
-/*
- return the GMT time represented by the struct tm argument, as a time_t value
-*/
-static int ejs_sys_gmmktime(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- struct MprVar *o;
- struct tm tm;
- if (argc != 1 || !mprVarIsObject(argv[0]->type)) {
- ejsSetErrorMsg(eid, "sys_gmmktime invalid arguments");
- return -1;
- }
-
- o = argv[0];
-#define TM_EL(n) tm.n = mprVarToNumber(mprGetProperty(o, #n, NULL))
- TM_EL(tm_sec);
- TM_EL(tm_min);
- TM_EL(tm_hour);
- TM_EL(tm_mday);
- TM_EL(tm_mon);
- TM_EL(tm_year);
- TM_EL(tm_wday);
- TM_EL(tm_yday);
- TM_EL(tm_isdst);
-#undef TM_EL
-
- mpr_Return(eid, mprCreateIntegerVar(mktime(&tm)));
- return 0;
-}
-
-/*
- return the given time as a gmtime structure
-*/
-static int ejs_sys_gmtime(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- time_t t;
- struct MprVar ret;
- struct tm *tm;
- if (argc != 1 || !mprVarIsNumber(argv[0]->type)) {
- ejsSetErrorMsg(eid, "sys_gmtime invalid arguments");
- return -1;
- }
- t = (time_t) mprVarToNumber(argv[0]);
- tm = gmtime(&t);
- if (tm == NULL) {
- mpr_Return(eid, mprCreateUndefinedVar());
- return 0;
- }
- ret = mprObject("gmtime");
-#define TM_EL(n) mprSetVar(&ret, #n, mprCreateIntegerVar(tm->n))
- TM_EL(tm_sec);
- TM_EL(tm_min);
- TM_EL(tm_hour);
- TM_EL(tm_mday);
- TM_EL(tm_mon);
- TM_EL(tm_year);
- TM_EL(tm_wday);
- TM_EL(tm_yday);
- TM_EL(tm_isdst);
-#undef TM_EL
-
- mpr_Return(eid, ret);
- return 0;
-}
-
-/*
- return the given NT time as a time_t value
-*/
-static int ejs_sys_nttime2unix(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- time_t t;
- struct MprVar v;
- if (argc != 1 || !mprVarIsNumber(argv[0]->type)) {
- ejsSetErrorMsg(eid, "sys_ntgmtime invalid arguments");
- return -1;
- }
- t = nt_time_to_unix(mprVarToNumber(argv[0]));
- v = mprCreateNumberVar(t);
- mpr_Return(eid, v);
- return 0;
-}
-
-/*
- return the given NT time as a gmtime structure
-*/
-static int ejs_sys_ntgmtime(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- time_t t;
- struct MprVar ret;
- struct tm *tm;
- if (argc != 1 || !mprVarIsNumber(argv[0]->type)) {
- ejsSetErrorMsg(eid, "sys_ntgmtime invalid arguments");
- return -1;
- }
- t = nt_time_to_unix(mprVarToNumber(argv[0]));
- tm = gmtime(&t);
- if (tm == NULL) {
- mpr_Return(eid, mprCreateUndefinedVar());
- return 0;
- }
- ret = mprObject("gmtime");
-#define TM_EL(n) mprSetVar(&ret, #n, mprCreateIntegerVar(tm->n))
- TM_EL(tm_sec);
- TM_EL(tm_min);
- TM_EL(tm_hour);
- TM_EL(tm_mday);
- TM_EL(tm_mon);
- TM_EL(tm_year);
- TM_EL(tm_wday);
- TM_EL(tm_yday);
- TM_EL(tm_isdst);
-#undef TM_EL
-
- mpr_Return(eid, ret);
- return 0;
-}
-
-/*
- return a ldap time string from a nttime
-*/
-static int ejs_sys_ldaptime(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- char *s;
- time_t t;
- if (argc != 1 || !mprVarIsNumber(argv[0]->type)) {
- ejsSetErrorMsg(eid, "sys_ldaptime invalid arguments");
- return -1;
- }
- t = nt_time_to_unix(mprVarToNumber(argv[0]));
- s = ldb_timestring(mprMemCtx(), t);
- mpr_Return(eid, mprString(s));
- talloc_free(s);
- return 0;
-}
-
-/*
- return a http time string from a nttime
-*/
-static int ejs_sys_httptime(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- char *s;
- time_t t;
- if (argc != 1 || !mprVarIsNumber(argv[0]->type)) {
- ejsSetErrorMsg(eid, "sys_httptime invalid arguments");
- return -1;
- }
- t = nt_time_to_unix(mprVarToNumber(argv[0]));
- s = http_timestring(mprMemCtx(), t);
- mpr_Return(eid, mprString(s));
- talloc_free(s);
- return 0;
-}
-
-/*
- unlink a file
- ok = sys.unlink(fname);
-*/
-static int ejs_sys_unlink(MprVarHandle eid, int argc, char **argv)
-{
- int ret;
- if (argc != 1) {
- ejsSetErrorMsg(eid, "sys_unlink invalid arguments");
- return -1;
- }
- ret = unlink(argv[0]);
- mpr_Return(eid, mprCreateBoolVar(ret == 0));
- return 0;
-}
-
-/*
- load a file as a string
- usage:
- string = sys.file_load(filename);
-*/
-static int ejs_sys_file_load(MprVarHandle eid, int argc, char **argv)
-{
- char *s;
- if (argc != 1) {
- ejsSetErrorMsg(eid, "sys_file_load invalid arguments");
- return -1;
- }
-
- s = file_load(argv[0], NULL, mprMemCtx());
- mpr_Return(eid, mprString(s));
- talloc_free(s);
- return 0;
-}
-
-/*
- save a file from a string
- usage:
- ok = sys.file_save(filename, str);
-*/
-static int ejs_sys_file_save(MprVarHandle eid, int argc, char **argv)
-{
- bool ret;
- if (argc != 2) {
- ejsSetErrorMsg(eid, "sys_file_save invalid arguments");
- return -1;
- }
- ret = file_save(argv[0], argv[1], strlen(argv[1]));
- mpr_Return(eid, mprCreateBoolVar(ret));
- return 0;
-}
-
-/*
- mkdir()
- usage:
- ok = sys.mkdir(dirname, mode);
-*/
-static int ejs_sys_mkdir(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- bool ret;
- char *name;
- if (argc != 2) {
- ejsSetErrorMsg(eid, "sys_mkdir invalid arguments, need mkdir(dirname, mode)");
- return -1;
- }
- if (!mprVarIsString(argv[0]->type)) {
- ejsSetErrorMsg(eid, "sys_mkdir dirname not a string");
- return -1;
- }
- if (!mprVarIsNumber(argv[1]->type)) {
- ejsSetErrorMsg(eid, "sys_mkdir mode not a number");
- return -1;
- }
- mprVarToString(&name, 0, NULL, argv[0]);
- ret = mkdir(name, mprVarToNumber(argv[1]));
- mpr_Return(eid, mprCreateBoolVar(ret == 0));
- return 0;
-}
-
-
-/*
- return fields of a stat() call
-*/
-static struct MprVar mpr_stat(struct stat *st)
-{
- struct MprVar ret;
- ret = mprObject("stat");
-
-#define ST_EL(n) mprSetVar(&ret, #n, mprCreateNumberVar(st->n))
- ST_EL(st_dev);
- ST_EL(st_ino);
- ST_EL(st_mode);
- ST_EL(st_nlink);
- ST_EL(st_uid);
- ST_EL(st_gid);
- ST_EL(st_rdev);
- ST_EL(st_size);
- ST_EL(st_blksize);
- ST_EL(st_blocks);
- ST_EL(st_atime);
- ST_EL(st_mtime);
- ST_EL(st_ctime);
-
- return ret;
-}
-
-/*
- usage:
- var st = sys.stat(filename);
- returns an object containing struct stat elements
-*/
-static int ejs_sys_stat(MprVarHandle eid, int argc, char **argv)
-{
- struct stat st;
- /* validate arguments */
- if (argc != 1) {
- ejsSetErrorMsg(eid, "sys.stat invalid arguments");
- return -1;
- }
- if (stat(argv[0], &st) != 0) {
- mpr_Return(eid, mprCreateUndefinedVar());
- } else {
- mpr_Return(eid, mpr_stat(&st));
- }
- return 0;
-}
-
-/*
- usage:
- var st = sys.lstat(filename);
- returns an object containing struct stat elements
-*/
-static int ejs_sys_lstat(MprVarHandle eid, int argc, char **argv)
-{
- struct stat st;
- /* validate arguments */
- if (argc != 1) {
- ejsSetErrorMsg(eid, "sys.stat invalid arguments");
- return -1;
- }
- if (lstat(argv[0], &st) != 0) {
- mpr_Return(eid, mprCreateUndefinedVar());
- } else {
- mpr_Return(eid, mpr_stat(&st));
- }
- return 0;
-}
-
-/*
- bitwise AND
- usage:
- var z = sys.bitAND(x, 0x70);
-*/
-static int ejs_sys_bitAND(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- int x, y, z;
-
- if (argc != 2 ||
- !mprVarIsNumber(argv[0]->type) ||
- !mprVarIsNumber(argv[1]->type)) {
- ejsSetErrorMsg(eid, "bitand invalid arguments");
- return -1;
- }
- x = mprToInt(argv[0]);
- y = mprToInt(argv[1]);
- z = x & y;
-
- mpr_Return(eid, mprCreateIntegerVar(z));
- return 0;
-}
-
-/*
- bitwise OR
- usage:
- var z = sys.bitOR(x, 0x70);
-*/
-static int ejs_sys_bitOR(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- int x, y, z;
-
- if (argc != 2 ||
- !mprVarIsNumber(argv[0]->type) ||
- !mprVarIsNumber(argv[1]->type)) {
- ejsSetErrorMsg(eid, "bitand invalid arguments");
- return -1;
- }
- x = mprToInt(argv[0]);
- y = mprToInt(argv[1]);
- z = x | y;
-
- mpr_Return(eid, mprCreateIntegerVar(z));
- return 0;
-}
-
-/*
- initialise sys ejs subsystem
-*/
-static int ejs_sys_init(MprVarHandle eid, int argc, struct MprVar **argv)
-{
- struct MprVar *obj = mprInitObject(eid, "sys", argc, argv);
-
- mprSetCFunction(obj, "interfaces", ejs_sys_interfaces);
- mprSetCFunction(obj, "hostname", ejs_sys_hostname);
- mprSetCFunction(obj, "nttime", ejs_sys_nttime);
- mprSetCFunction(obj, "gettimeofday", ejs_sys_gettimeofday);
- mprSetCFunction(obj, "unix2nttime", ejs_sys_unix2nttime);
- mprSetCFunction(obj, "gmmktime", ejs_sys_gmmktime);
- mprSetCFunction(obj, "gmtime", ejs_sys_gmtime);
- mprSetCFunction(obj, "nttime2unix", ejs_sys_nttime2unix);
- mprSetCFunction(obj, "ntgmtime", ejs_sys_ntgmtime);
- mprSetCFunction(obj, "ldaptime", ejs_sys_ldaptime);
- mprSetCFunction(obj, "httptime", ejs_sys_httptime);
- mprSetCFunction(obj, "mkdir", ejs_sys_mkdir);
- mprSetStringCFunction(obj, "unlink", ejs_sys_unlink);
- mprSetStringCFunction(obj, "file_load", ejs_sys_file_load);
- mprSetStringCFunction(obj, "file_save", ejs_sys_file_save);
- mprSetStringCFunction(obj, "stat", ejs_sys_stat);
- mprSetStringCFunction(obj, "lstat", ejs_sys_lstat);
- mprSetCFunction(obj, "bitAND", ejs_sys_bitAND);
- mprSetCFunction(obj, "bitOR", ejs_sys_bitOR);
-
- return 0;
-}
-
-
-/*
- setup C functions that be called from ejs
-*/
-NTSTATUS smb_setup_ejs_system(void)
-{
- ejsDefineCFunction(-1, "sys_init", ejs_sys_init, NULL, MPR_VAR_SCRIPT_HANDLE);
- return NT_STATUS_OK;
-}
+++ /dev/null
-/*
- Unix SMB/CIFS implementation.
-
- Standalone client for ejs scripting.
-
- Copyright (C) Tim Potter <tpot@samba.org> 2005
- Copyright (C) Andrew Tridgell 2005
-
- 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 "lib/appweb/ejs/ejs.h"
-#include "lib/appweb/ejs/ejsInternal.h"
-#include "scripting/ejs/smbcalls.h"
-#include "auth/gensec/gensec.h"
-#include "ldb/include/ldb.h"
-#include "dynconfig/dynconfig.h"
-
-static EjsId eid;
-
-_NORETURN_ static void smbscript_ejs_exception(const char *reason)
-{
- Ejs *ep = ejsPtr(eid);
- ejsSetErrorMsg(eid, "%s", reason);
- fprintf(stderr, "%s", ep->error);
- exit(127);
-}
-
-int main(int argc, const char **argv)
-{
- EjsHandle handle = 0;
- MprVar result;
- char *emsg, *script;
- size_t script_size;
- TALLOC_CTX *mem_ctx = talloc_new(NULL);
- const char **argv_list = NULL;
- const char *fname;
- struct MprVar *return_var;
- int exit_status, i;
- struct loadparm_context *lp_ctx;
-
- fault_setup(argv[0]);
-
- global_loadparm = lp_ctx = loadparm_init(talloc_autofree_context());
-
- if (getenv("SMB_CONF_PATH")) {
- lp_load(lp_ctx, getenv("SMB_CONF_PATH"));
- } else {
- lp_load(lp_ctx, dyn_CONFIGFILE);
- }
-
- gensec_init(lp_ctx);
- mprSetCtx(mem_ctx);
-
-
- if (argc < 2) {
- fprintf(stderr, "You must supply a script name\n");
- exit(1);
- }
-
- fname = argv[1];
-
- if (ejsOpen(NULL, NULL, NULL) != 0) {
- fprintf(stderr, "smbscript: ejsOpen(): unable to initialise "
- "EJS subsystem\n");
- exit(127);
- }
-
- smb_setup_ejs_functions(smbscript_ejs_exception);
-
- if ((eid = ejsOpenEngine(handle, 0)) == (EjsId)-1) {
- fprintf(stderr, "smbscript: ejsOpenEngine(): unable to "
- "initialise an EJS engine\n");
- exit(127);
- }
-
- /* setup ARGV[] in the ejs environment */
- for (i=1;argv[i];i++) {
- argv_list = str_list_add(argv_list, argv[i]);
- }
- talloc_steal(mem_ctx, argv_list);
- mprSetVar(ejsGetGlobalObject(eid), "ARGV", mprList("ARGV", argv_list));
-
- /* load the script and advance past interpreter line*/
- script = file_load(fname, &script_size, mem_ctx);
-
- if (!script) {
- fprintf(stderr, "Unable to load script from '%s'\n", fname);
- exit(1);
- }
-
- /* allow scriptable js */
- if (strncmp(script, "#!", 2) == 0) {
- script += strcspn(script, "\r\n");
- script += strspn(script, "\r\n");
- }
- /* and this copes with the ugly exec hack */
- if (strncmp(script, "exec ", 5) == 0) {
- script += strcspn(script, "\r\n");
- script += strspn(script, "\r\n");
- }
-
- /* run the script */
- if (ejsEvalScript(eid, script, &result, &emsg) == -1) {
- fprintf(stderr, "smbscript: ejsEvalScript(): %s\n", emsg);
- exit(127);
- }
-
- return_var = ejsGetReturnValue(eid);
- exit_status = mprVarToNumber(return_var);
-
- ejsClose();
-
- talloc_free(mem_ctx);
-
- return exit_status;
-}
+++ /dev/null
-/*
- base js library functions
- Copyright Andrew Tridgell 2005
- released under the GNU GPL version 3 or later
-*/
-
-if (global["HAVE_BASE_JS"] != undefined) {
- return;
-}
-HAVE_BASE_JS=1
-
-/* bring the string functions into the global frame */
-string_init(global);
-
-/*
- an essential function!
-*/
-function printf()
-{
- print(vsprintf(arguments));
-}
-
-/*
- substitute strings of the form ${NAME} in str, replacing
- with substitutions from subobj
-*/
-function substitute_var(str, subobj)
-{
- var list = split("${", str);
- var i;
- for (i=1;i<list.length;i++) {
- var list2 = split("}", list[i], 1);
- if ((list2.length < 2) && (list2[0] + "}" != list[i])) {
- return undefined;
- }
- var key = list2[0];
- var val;
- if (typeof(subobj[key]) == "undefined") {
- val = "${" + key + "}";
- } else if (typeof(subobj[key]) == "string") {
- val = subobj[key];
- } else {
- var fn = subobj[key];
- val = fn(key);
- }
- list2[0] = "" + val;
- list[i] = join("", list2);
- }
- return join("", list);
-}
will be appended to the Python interpreter
canonical name.])
-AC_PROG_SWIG(1.3.35)
+AC_PROG_SWIG(1.3.36)
AC_PATH_PROG([PYTHON],[python[$PYTHON_VERSION]])
if test -z "$PYTHON"; then
$(python_misc_OBJ_FILES): CFLAGS+=$(CFLAG_NO_UNUSED_MACROS) $(CFLAG_NO_CAST_QUAL)
-_PY_FILES = $(shell find $(pyscriptsrcdir)/samba $(pyscriptsrcdir)/subunit -name "*.py")
+_PY_FILES = $(shell find $(pyscriptsrcdir)/samba ../lib/subunit/python -name "*.py")
$(foreach pyfile, $(_PY_FILES),$(eval $(call python_py_module_template,$(patsubst $(pyscriptsrcdir)/%,%,$(pyfile)),$(pyfile))))
EPYDOC_OPTIONS = --no-private --url http://www.samba.org/ --no-sourcecode
epydoc:: pythonmods
- PYTHONPATH=$(pythonbuilddir) epydoc $(EPYDOC_OPTIONS) samba tdb ldb subunit
+ PYTHONPATH=$(pythonbuilddir):../lib/subunit/python epydoc $(EPYDOC_OPTIONS) samba tdb ldb subunit
install:: installpython
%import "stdint.i"
%include "exception.i"
-%import "../../lib/talloc/talloc.i"
+%import "../../../lib/talloc/talloc.i"
%import "../../lib/ldb/ldb.i"
%import "../../auth/credentials/credentials.i"
%import "../../param/param.i"
#define SWIGTYPE_p_ldb_ldif swig_types[8]
#define SWIGTYPE_p_ldb_message swig_types[9]
#define SWIGTYPE_p_ldb_message_element swig_types[10]
-#define SWIGTYPE_p_ldb_result swig_types[11]
-#define SWIGTYPE_p_loadparm_context swig_types[12]
-#define SWIGTYPE_p_loadparm_service swig_types[13]
-#define SWIGTYPE_p_long_long swig_types[14]
-#define SWIGTYPE_p_param_context swig_types[15]
-#define SWIGTYPE_p_param_opt swig_types[16]
-#define SWIGTYPE_p_param_section swig_types[17]
-#define SWIGTYPE_p_security_descriptor swig_types[18]
-#define SWIGTYPE_p_security_token swig_types[19]
-#define SWIGTYPE_p_short swig_types[20]
-#define SWIGTYPE_p_signed_char swig_types[21]
-#define SWIGTYPE_p_unsigned_char swig_types[22]
-#define SWIGTYPE_p_unsigned_int swig_types[23]
-#define SWIGTYPE_p_unsigned_long swig_types[24]
-#define SWIGTYPE_p_unsigned_long_long swig_types[25]
-#define SWIGTYPE_p_unsigned_short swig_types[26]
-static swig_type_info *swig_types[28];
-static swig_module_info swig_module = {swig_types, 27, 0, 0, 0, 0};
+#define SWIGTYPE_p_ldb_module swig_types[11]
+#define SWIGTYPE_p_ldb_parse_tree swig_types[12]
+#define SWIGTYPE_p_ldb_result swig_types[13]
+#define SWIGTYPE_p_loadparm_context swig_types[14]
+#define SWIGTYPE_p_loadparm_service swig_types[15]
+#define SWIGTYPE_p_long_long swig_types[16]
+#define SWIGTYPE_p_param_context swig_types[17]
+#define SWIGTYPE_p_param_opt swig_types[18]
+#define SWIGTYPE_p_param_section swig_types[19]
+#define SWIGTYPE_p_security_descriptor swig_types[20]
+#define SWIGTYPE_p_security_token swig_types[21]
+#define SWIGTYPE_p_short swig_types[22]
+#define SWIGTYPE_p_signed_char swig_types[23]
+#define SWIGTYPE_p_unsigned_char swig_types[24]
+#define SWIGTYPE_p_unsigned_int swig_types[25]
+#define SWIGTYPE_p_unsigned_long swig_types[26]
+#define SWIGTYPE_p_unsigned_long_long swig_types[27]
+#define SWIGTYPE_p_unsigned_short swig_types[28]
+static swig_type_info *swig_types[30];
+static swig_module_info swig_module = {swig_types, 29, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
static swig_type_info _swigt__p_ldb_ldif = {"_p_ldb_ldif", "struct ldb_ldif *|ldb_ldif *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ldb_message = {"_p_ldb_message", "ldb_msg *|struct ldb_message *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ldb_message_element = {"_p_ldb_message_element", "struct ldb_message_element *|ldb_message_element *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_ldb_module = {"_p_ldb_module", "struct ldb_module *|ldb_module *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_ldb_parse_tree = {"_p_ldb_parse_tree", "struct ldb_parse_tree *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ldb_result = {"_p_ldb_result", "struct ldb_result *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_loadparm_context = {"_p_loadparm_context", "struct loadparm_context *|loadparm_context *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_loadparm_service = {"_p_loadparm_service", "struct loadparm_service *|loadparm_service *", 0, 0, (void*)0, 0};
&_swigt__p_ldb_ldif,
&_swigt__p_ldb_message,
&_swigt__p_ldb_message_element,
+ &_swigt__p_ldb_module,
+ &_swigt__p_ldb_parse_tree,
&_swigt__p_ldb_result,
&_swigt__p_loadparm_context,
&_swigt__p_loadparm_service,
static swig_cast_info _swigc__p_ldb_ldif[] = { {&_swigt__p_ldb_ldif, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ldb_message[] = { {&_swigt__p_ldb_message, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ldb_message_element[] = { {&_swigt__p_ldb_message_element, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_ldb_module[] = { {&_swigt__p_ldb_module, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_ldb_parse_tree[] = { {&_swigt__p_ldb_parse_tree, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ldb_result[] = { {&_swigt__p_ldb_result, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_loadparm_context[] = { {&_swigt__p_loadparm_context, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_loadparm_service[] = { {&_swigt__p_loadparm_service, 0, 0, 0},{0, 0, 0, 0}};
_swigc__p_ldb_ldif,
_swigc__p_ldb_message,
_swigc__p_ldb_message_element,
+ _swigc__p_ldb_module,
+ _swigc__p_ldb_parse_tree,
_swigc__p_ldb_result,
_swigc__p_loadparm_context,
_swigc__p_loadparm_service,
samdb = SamDB(path, session_info=session_info,
credentials=credentials, lp=lp)
+ if fill == FILL_DRS:
+ return samdb
message("Pre-loading the Samba 4 and AD schema")
samdb.set_domain_sid(domainsid)
class RpcEchoTests(RpcInterfaceTestCase):
def setUp(self):
- self.conn = echo.rpcecho("ncalrpc:", self.get_loadparm())
+ self.conn = echo.rpcecho("ncalrpc:", self.get_loadparm(),
+ self.get_credentials())
def test_two_contexts(self):
self.conn2 = echo.rpcecho("ncalrpc:", self.get_loadparm(), basis_connection=self.conn)
testenv:: everything
$(SELFTEST) $(SELFTEST_NOSLOW_OPTS) --socket-wrapper --testenv
+testenv-%:: everything
+ SELFTEST_TESTENV=$* $(SELFTEST) $(SELFTEST_NOSLOW_OPTS) --socket-wrapper --testenv
+
valgrindtest:: valgrindtest-all
valgrindtest-quick:: all
- SMBD_VALGRIND="xterm -n smbd -e $(srcdir)/script/valgrind_run $(LD_LIBPATH_OVERRIDE)" \
+ SMBD_VALGRIND="xterm -n server -e $(srcdir)/script/valgrind_run $(LD_LIBPATH_OVERRIDE)" \
VALGRIND="valgrind -q --num-callers=30 --log-file=${selftest_prefix}/valgrind.log" \
$(SELFTEST) $(SELFTEST_QUICK_OPTS) --immediate --socket-wrapper $(TESTS)
valgrindtest-all:: everything
- SMBD_VALGRIND="xterm -n smbd -e $(srcdir)/script/valgrind_run $(LD_LIBPATH_OVERRIDE)" \
+ SMBD_VALGRIND="xterm -n server -e $(srcdir)/script/valgrind_run $(LD_LIBPATH_OVERRIDE)" \
VALGRIND="valgrind -q --num-callers=30 --log-file=${selftest_prefix}/valgrind.log" \
$(SELFTEST) $(SELFTEST_NOSLOW_OPTS) --immediate --socket-wrapper $(TESTS)
valgrindtest-env:: everything
- SMBD_VALGRIND="xterm -n smbd -e $(srcdir)/script/valgrind_run $(LD_LIBPATH_OVERRIDE)" \
+ SMBD_VALGRIND="xterm -n server -e $(srcdir)/script/valgrind_run $(LD_LIBPATH_OVERRIDE)" \
VALGRIND="valgrind -q --num-callers=30 --log-file=${selftest_prefix}/valgrind.log" \
$(SELFTEST) $(SELFTEST_NOSLOW_OPTS) --socket-wrapper --testenv
gdbtest:: gdbtest-all
gdbtest-quick:: all
- SMBD_VALGRIND="xterm -n smbd -e $(srcdir)/script/gdb_run $(LD_LIBPATH_OVERRIDE)" \
+ SMBD_VALGRIND="xterm -n server -e $(srcdir)/script/gdb_run $(LD_LIBPATH_OVERRIDE)" \
$(SELFTEST) $(SELFTEST_QUICK_OPTS) --immediate --socket-wrapper $(TESTS)
gdbtest-all:: everything
- SMBD_VALGRIND="xterm -n smbd -e $(srcdir)/script/gdb_run $(LD_LIBPATH_OVERRIDE)" \
+ SMBD_VALGRIND="xterm -n server -e $(srcdir)/script/gdb_run $(LD_LIBPATH_OVERRIDE)" \
$(SELFTEST) $(SELFTEST_NOSLOW_OPTS) --immediate --socket-wrapper $(TESTS)
gdbtest-env:: everything
- SMBD_VALGRIND="xterm -n smbd -e $(srcdir)/script/gdb_run $(LD_LIBPATH_OVERRIDE)" \
+ SMBD_VALGRIND="xterm -n server -e $(srcdir)/script/gdb_run $(LD_LIBPATH_OVERRIDE)" \
$(SELFTEST) $(SELFTEST_NOSLOW_OPTS) --socket-wrapper --testenv
rpc.join
rpc.handles
rpc.echo
+smb.signing
^samba4.net.domopen.*$ # Hangs for some reason
^samba4.net.api.become.dc.*$ # Fails
nss.test # Fails
-samba4.samba3sam.python # Conversion from EJS not yet finished
raw.offline # Samba 4 doesn't have much offline support yet
-winreg* #Does not authenticate against the target server
testit "$name" smb $WINTEST_DIR/wintest_net.sh $SMBTORTURE_REMOTE_HOST \
$SMBTORTURE_USERNAME $SMBTORTURE_PASSWORD $SMBTORTURE_WORKGROUP
-name="Windows 2003 against smbd"
+name="Windows 2003 against samba"
testit "$name" smb $WINTEST_DIR/wintest_client.sh $SMBTORTURE_REMOTE_HOST
dc_tests="RPC-DRSUAPI ncacn_np ncacn_ip_tcp"
samba4srcdir=.
samba4bindir=$samba4srcdir/bin
-SCRIPTDIR=$samba4srcdir/../testprogs/ejs
smb4torture="$samba4bindir/smbtorture $TORTURE_OPTIONS"
-plantest "js.base" dc "$SCRIPTDIR/base.js" $CONFIGURATION
-plantest "js.ldb" none "$SCRIPTDIR/ldb.js" `pwd` $CONFIGURATION -d 10
-
# Simple tests for LDAP and CLDAP
for options in "" "--option=socket:testnonblock=true" "-U\$USERNAME%\$PASSWORD --option=socket:testnonblock=true" "-U\$USERNAME%\$PASSWORD"; do
# that they stay passing
ncacn_np_tests="RPC-SCHANNEL RPC-JOIN RPC-LSA RPC-DSSETUP RPC-ALTERCONTEXT RPC-MULTIBIND RPC-NETLOGON RPC-HANDLES RPC-SAMSYNC RPC-SAMBA3SESSIONKEY RPC-SAMBA3-GETUSERNAME RPC-SAMBA3-LSA RPC-BINDSAMBA3 RPC-NETLOGSAMBA3 RPC-ASYNCBIND RPC-LSALOOKUP RPC-LSA-GETUSER RPC-SCHANNEL2 RPC-AUTHCONTEXT"
ncalrpc_tests="RPC-SCHANNEL RPC-JOIN RPC-LSA RPC-DSSETUP RPC-ALTERCONTEXT RPC-MULTIBIND RPC-NETLOGON RPC-DRSUAPI RPC-ASYNCBIND RPC-LSALOOKUP RPC-LSA-GETUSER RPC-SCHANNEL2 RPC-AUTHCONTEXT"
-ncacn_ip_tcp_tests="RPC-SCHANNEL RPC-JOIN RPC-LSA RPC-DSSETUP RPC-ALTERCONTEXT RPC-MULTIBIND RPC-NETLOGON RPC-HANDLES RPC-DSSYNC RPC-ASYNCBIND RPC-LSALOOKUP RPC-LSA-GETUSER RPC-SCHANNEL2 RPC-AUTHCONTEXT"
+ncacn_ip_tcp_tests="RPC-SCHANNEL RPC-JOIN RPC-LSA RPC-DSSETUP RPC-ALTERCONTEXT RPC-MULTIBIND RPC-NETLOGON RPC-HANDLES RPC-DSSYNC RPC-ASYNCBIND RPC-LSALOOKUP RPC-LSA-GETUSER RPC-SCHANNEL2 RPC-AUTHCONTEXT RPC-OBJECTUUID"
slow_ncacn_np_tests="RPC-SAMLOGON RPC-SAMR RPC-SAMR-USERS RPC-SAMR-PASSWORDS"
slow_ncalrpc_tests="RPC-SAMR RPC-SAMR-PASSWORDS"
slow_ncacn_ip_tcp_tests="RPC-SAMR RPC-SAMR-PASSWORDS RPC-CRACKNAMES"
echo "Skipping pidl tests - PIDL_TESTS_SKIP=yes"
elif $PERL -e 'eval require Test::More;' > /dev/null 2>&1; then
for f in $samba4srcdir/../pidl/tests/*.pl; do
- plantest "pidl.`basename $f .pl`" none $PERL $f "|" $samba4srcdir/script/harness2subunit.pl
+ plantest "pidl.`basename $f .pl`" none $PERL $f "|" $samba4srcdir/../lib/subunit/harness2subunit.pl
done
else
echo "Skipping pidl tests - Test::More not installed"
bbdir=../testprogs/blackbox
-plantest "blackbox.ndrdump" dc $samba4srcdir/librpc/tests/test_ndrdump.sh
+plantest "blackbox.ndrdump" none $samba4srcdir/librpc/tests/test_ndrdump.sh
plantest "blackbox.net" dc $samba4srcdir/utils/tests/test_net.sh "\$SERVER" "\$USERNAME" "\$PASSWORD" "\$DOMAIN"
plantest "blackbox.kinit" dc $bbdir/test_kinit.sh "\$SERVER" "\$USERNAME" "\$PASSWORD" "\$REALM" "\$DOMAIN" "$PREFIX" $CONFIGURATION
plantest "blackbox.cifsdd" dc $samba4srcdir/client/tests/test_cifsdd.sh "\$SERVER" "\$USERNAME" "\$PASSWORD" "\$DOMAIN"
plantest "ntvfs.simple.`normalize_testname $t`" dc $VALGRIND $smb4torture $ADDARGS //\$SERVER/simple -U"\$USERNAME"%"\$PASSWORD" $t
done
-DATADIR=$samba4srcdir/../testdata
-
-plantest "js.samba3sam" none $samba4bindir/smbscript $SCRIPTDIR/samba3sam.js $CONFIGURATION `pwd` $DATADIR/samba3/
-
# Domain Member Tests
plantest "rpc.echo against member server with local creds" member $VALGRIND $smb4torture ncacn_np:"\$NETBIOSNAME" -U"\$NETBIOSNAME/\$USERNAME"%"\$PASSWORD" RPC-ECHO "$*"
plantest "rpc.samr.passwords against member server with local creds" member $VALGRIND $smb4torture ncacn_np:"\$NETBIOSNAME" -U"\$NETBIOSNAME/\$USERNAME"%"\$PASSWORD" "RPC-SAMR-PASSWORDS" "$*"
plantest "blackbox.smbclient against member server with local creds" member $samba4srcdir/client/tests/test_smbclient.sh "\$NETBIOSNAME" "\$USERNAME" "\$PASSWORD" "\$NETBIOSNAME" "$PREFIX"
+# Tests SMB signing
+
+for mech in \
+ "-k no" \
+ "-k no --option=usespnego=no" \
+ "-k no --option=gensec:spengo=no" \
+ "-k yes" \
+ "-k yes --option=gensec:fake_gssapi_krb5=yes --option=gensec:gssapi_krb5=no"; do
+ for signing in \
+ "--signing=on" \
+ "--signing=required"; do
+
+ signoptions="$mech $signing"
+ name="smb.signing on with $signoptions"
+ plantest "$name" dc $VALGRIND $smb4torture //"\$NETBIOSNAME"/tmp $signoptions -U"\$USERNAME"%"\$PASSWORD" BASE-XCOPY "$*"
+ done
+done
+
+for mech in \
+ "-k no" \
+ "-k no --option=usespnego=no" \
+ "-k no --option=gensec:spengo=no" \
+ "-k yes" \
+ "-k yes --option=gensec:fake_gssapi_krb5=yes --option=gensec:gssapi_krb5=no"; do
+ signoptions="$mech --signing=off"
+ name="smb.signing on with $signoptions"
+ plantest "$name domain-creds" member $VALGRIND $smb4torture //"\$NETBIOSNAME"/tmp $signoptions -U"\$DC_USERNAME"%"\$DC_PASSWORD" BASE-XCOPY "$*"
+done
+for mech in \
+ "-k no" \
+ "-k no --option=usespnego=no" \
+ "-k no --option=gensec:spengo=no"; do
+ signoptions="$mech --signing=off"
+ name="smb.signing on with $signoptions"
+ plantest "$name local-creds" member $VALGRIND $smb4torture //"\$NETBIOSNAME"/tmp $signoptions -U"\$NETBIOSNAME/\$USERNAME"%"\$PASSWORD" BASE-XCOPY "$*"
+done
+plantest "smb.signing --signing=yes anon" dc $VALGRIND $smb4torture //"\$NETBIOSNAME"/tmp -k no --signing=yes -U% BASE-XCOPY "$*"
+plantest "smb.signing --signing=required anon" dc $VALGRIND $smb4torture //"\$NETBIOSNAME"/tmp -k no --signing=required -U% BASE-XCOPY "$*"
+plantest "smb.signing --signing=no anon" member $VALGRIND $smb4torture //"\$NETBIOSNAME"/tmp -k no --signing=no -U% BASE-XCOPY "$*"
+
NBT_TESTS=`$smb4torture --list | grep "^NBT-" | xargs`
for t in $NBT_TESTS; do
plantest "events.python" none PYTHONPATH="$PYTHONPATH:lib/events" $SUBUNITRUN tests
plantest "messaging.python" none PYTHONPATH="$PYTHONPATH:lib/messaging/tests" $SUBUNITRUN bindings
plantest "samba3sam.python" none PYTHONPATH="$PYTHONPATH:dsdb/samdb/ldb_modules/tests" $SUBUNITRUN samba3sam
+plantest "subunit.python" none $SUBUNITRUN subunit
plantest "rpcecho.python" dc $SUBUNITRUN samba.tests.dcerpc.rpcecho
plantest "winreg.python" dc $SUBUNITRUN -U\$USERNAME%\$PASSWORD samba.tests.dcerpc.registry
plantest "ldap.python" dc $PYTHON $samba4srcdir/lib/ldb/tests/python/ldap.py $CONFIGURATION \$SERVER -U\$USERNAME%\$PASSWORD -W \$DOMAIN
replace: gPLink
gPLink: [LDAP://CN={${POLICYGUID}},CN=Policies,CN=System,${DOMAINDN};0]
-
+replace: wellKnownObjects
+wellKnownObjects: B:32:22b70c67d56e4efb91e9300fca3dc1aa:CN=ForeignSecurityPrincipals,${DOMAINDN}
+wellKnownObjects: B:32:2fbac1870ade11d297c400c04fd8d5cd:CN=Infrastructure,${DOMAINDN}
+wellKnownObjects: B:32:ab1d30f3768811d1aded00c04fd8d5cd:CN=System,${DOMAINDN}
+wellKnownObjects: B:32:a361b2ffffd211d1aa4b00c04fd7d83a:OU=Domain Controllers,${DOMAINDN}
+wellKnownObjects: B:32:aa312825768811d1aded00c04fd8d5cd:CN=Computers,${DOMAINDN}
+wellKnownObjects: B:32:a9d1ca15768811d1aded00c04fd8d5cd:CN=Users,${DOMAINDN}
+-
${DOMAINGUID_MOD}
groupType: -2147483644
isCriticalSystemObject: TRUE
+dn: CN=Read-Only Domain Controllers,CN=Users,${DOMAINDN}
+objectClass: top
+objectClass: group
+cn: Read-Only Domain Controllers
+description: read-only domain controllers
+objectSid: ${DOMAINSID}-521
+sAMAccountName: Read-Only Domain Controllers
+groupType: -2147483644
+isCriticalSystemObject: TRUE
+
+dn: CN=Enterprise Read-Only Domain Controllers,CN=Users,${DOMAINDN}
+objectClass: top
+objectClass: group
+cn: Enterprise Read-Only Domain Controllers
+description: enterprise read-only domain controllers
+objectSid: ${DOMAINSID}-498
+sAMAccountName: Enterprise Read-Only Domain Controllers
+groupType: -2147483644
+isCriticalSystemObject: TRUE
+
+dn: CN=Certificate Service DCOM Access,CN=Users,${DOMAINDN}
+objectClass: top
+objectClass: group
+cn: Certificate Service DCOM Access
+description: Certificate Service DCOM Access
+objectSid: ${DOMAINSID}-574
+sAMAccountName: Certificate Service DCOM Access
+groupType: -2147483644
+isCriticalSystemObject: TRUE
+
+dn: CN=Cryptographic Operators,CN=Users,${DOMAINDN}
+objectClass: top
+objectClass: group
+cn: Cryptographic Operators
+description: Cryptographic Operators
+objectSid: ${DOMAINSID}-569
+sAMAccountName: Cryptographic Operators
+groupType: -2147483644
+isCriticalSystemObject: TRUE
+
+dn: CN=Event Log Readers,CN=Users,${DOMAINDN}
+objectClass: top
+objectClass: group
+cn: Event Log Readers
+description: Event Log Readers
+objectSid: ${DOMAINSID}-573
+sAMAccountName: Event Log Readers
+groupType: -2147483644
+isCriticalSystemObject: TRUE
+
+dn: CN=IIS_IUSRS,CN=Users,${DOMAINDN}
+objectClass: top
+objectClass: group
+cn: IIS_IUSRS
+description: IIS_IUSRS
+objectSid: ${DOMAINSID}-568
+sAMAccountName: IIS_IUSRS
+groupType: -2147483644
+isCriticalSystemObject: TRUE
+
dn: CN=Administrators,CN=Builtin,${DOMAINDN}
objectClass: top
objectClass: group
#Allocated: DSDB_CONTROL_CURRENT_PARTITION_OID 1.3.6.1.4.1.7165.4.3.2
+#Allocated: DSDB_CONTROL_REPLICATED_UPDATE_OID 1.3.6.1.4.1.7165.4.3.3
+
#Allocated: DSDB_EXTENDED_REPLICATED_OBJECTS_OID 1.3.6.1.4.1.7165.4.4.1
#Allocated: (middleName) attributeID: 1.3.6.1.4.1.7165.4.255.1
sAMAccountName: krbtgt
objectSid: ${DOMAINSID}
servicePrincipalName: kadmin/changepw
-krb5Keytab: HDB:ldb:${SAM_LDB}:
+krb5Keytab: HDB:samba4:${SAM_LDB}:
#The trailing : here is a HACK, but it matches the Heimdal format.
# A hook from our credentials system into HDB, as we must be on a KDC,
#define BLOB_CHECK_MIN_SIZE(blob, size) do { \
if ((blob)->length < (size)) { \
- return NT_STATUS_INFO_LENGTH_MISMATCH; \
+ return NT_STATUS_INVALID_PARAMETER; \
} \
} while (0)
switch (level) {
case SMB_SFILEINFO_BASIC_INFORMATION:
- BLOB_CHECK_MIN_SIZE(blob, 36);
+ BLOB_CHECK_MIN_SIZE(blob, 40);
st->basic_info.in.create_time = pull_nttime(blob->data, 0);
st->basic_info.in.access_time = pull_nttime(blob->data, 8);
st->basic_info.in.write_time = pull_nttime(blob->data, 16);
st->basic_info.in.change_time = pull_nttime(blob->data, 24);
- st->basic_info.in.attrib = IVAL(blob->data, 32);
+ st->basic_info.in.attrib = IVAL(blob->data, 32);
+ st->basic_info.in.reserved = IVAL(blob->data, 36);
return NT_STATUS_OK;
return NT_STATUS_OK;
+
+ case RAW_SFILEINFO_LINK_INFORMATION:
+ if (!bufinfo) {
+ return NT_STATUS_INTERNAL_ERROR;
+ }
+ BLOB_CHECK_MIN_SIZE(blob, 20);
+ st->link_information.in.overwrite = CVAL(blob->data, 0);
+ st->link_information.in.root_fid = IVAL(blob->data, 8);
+ len = IVAL(blob->data, 16);
+ ofs = 20;
+ str_blob = *blob;
+ str_blob.length = MIN(str_blob.length, ofs+len);
+ smbsrv_blob_pull_string(bufinfo, &str_blob, ofs,
+ &st->link_information.in.new_name,
+ STR_UNICODE);
+ if (st->link_information.in.new_name == NULL) {
+ return NT_STATUS_FOOBAR;
+ }
+
+ return NT_STATUS_OK;
+
case RAW_SFILEINFO_RENAME_INFORMATION_SMB2:
/* SMB2 uses a different format for rename information */
if (!bufinfo) {
#
[MODULE::SERVICE_SMB]
INIT_FUNCTION = server_service_smb_init
-SUBSYSTEM = smbd
+SUBSYSTEM = samba
PRIVATE_DEPENDENCIES = SMB_SERVER
SERVICE_SMB_OBJ_FILES = $(smb_serversrcdir)/smb_server.o
$(eval $(call proto_header_template,$(smb_serversrcdir)/service_smb_proto.h,$(SERVICE_SMB_OBJ_FILES:.o=.c)))
+# samba3 SMB server subsystem
+#
+[MODULE::SERVICE_SAMBA3_SMB]
+INIT_FUNCTION = server_service_samba3_smb_init
+SUBSYSTEM = samba
+
+SERVICE_SAMBA3_SMB_OBJ_FILES = $(smb_serversrcdir)/smb_samba3.o
+
#######################
# Start SUBSYSTEM SMB
[SUBSYSTEM::SMB_SERVER]
flags2 = FLAGS2_LONG_PATH_COMPONENTS |
FLAGS2_EXTENDED_ATTRIBUTES |
FLAGS2_IS_LONG_NAME;
- flags2 |= (req->flags2 & (FLAGS2_UNICODE_STRINGS|FLAGS2_EXTENDED_SECURITY));
+#define _SMB_FLAGS2_ECHOED_FLAGS ( \
+ FLAGS2_UNICODE_STRINGS | \
+ FLAGS2_EXTENDED_SECURITY | \
+ FLAGS2_SMB_SECURITY_SIGNATURES \
+)
+ flags2 |= (req->flags2 & _SMB_FLAGS2_ECHOED_FLAGS);
if (req->smb_conn->negotiate.client_caps & CAP_STATUS32) {
flags2 |= FLAGS2_32_BIT_ERROR_CODES;
}
goto done;
}
- /* Force check of the request packet, now we know the session key */
- smbsrv_signing_check_incoming(req);
-/* TODO: why don't we check the result here? */
-
- /* Unfortunetly win2k3 as a client doesn't sign the request
- * packet here, so we have to force signing to start again */
-
- smbsrv_signing_restart(req->smb_conn, &session_info->session_key, &sess->nt1.in.password2,
- session_info->server_info->authenticated);
-
done:
status = NT_STATUS_OK;
failed:
if (!NT_STATUS_IS_OK(status)) goto failed;
skey_status = gensec_session_key(smb_sess->gensec_ctx, &session_key);
- if (NT_STATUS_IS_OK(skey_status) &&
- smbsrv_setup_signing(req->smb_conn, &session_key, NULL)) {
- /* Force check of the request packet, now we know the session key */
- smbsrv_signing_check_incoming(req);
-
- smbsrv_signing_restart(req->smb_conn, &session_key, NULL,
- session_info->server_info->authenticated);
+ if (NT_STATUS_IS_OK(skey_status)) {
+ smbsrv_setup_signing(req->smb_conn, &session_key, NULL);
}
/* Ensure this is marked as a 'real' vuid, not one
&smb_conn->signing, session_key, response);
}
-void smbsrv_signing_restart(struct smbsrv_connection *smb_conn,
- DATA_BLOB *session_key,
- DATA_BLOB *response,
- bool authenticated_session)
-{
- if (!smb_conn->signing.seen_valid) {
- DEBUG(5, ("Client did not send a valid signature on "
- "SPNEGO session setup - ignored, expect good next time\n"));
- /* force things back on (most clients do not sign this packet)... */
- smbsrv_setup_signing(smb_conn, session_key, response);
- smb_conn->signing.next_seq_num = 2;
-
- /* If mandetory_signing is set, and this was an authenticated logon, then force on */
- if (smb_conn->signing.mandatory_signing && authenticated_session) {
- DEBUG(5, ("Configured for mandatory signing, 'good packet seen' forced on\n"));
- /* if this is mandatory, then
- * pretend we have seen a
- * valid packet, so we don't
- * turn it off */
- smb_conn->signing.seen_valid = true;
- }
- }
-}
-
bool smbsrv_init_signing(struct smbsrv_connection *smb_conn)
{
smb_conn->signing.mac_key = data_blob(NULL, 0);
smb_conn->signing.mandatory_signing = true;
break;
case SMB_SIGNING_AUTO:
+ /* If we are a domain controller, SMB signing is
+ * really important, as it can prevent a number of
+ * attacks on communications between us and the
+ * clients */
+
if (lp_server_role(smb_conn->lp_ctx) == ROLE_DOMAIN_CONTROLLER) {
smb_conn->signing.allow_smb_signing = true;
smb_conn->signing.mandatory_signing = true;
} else {
+ /* However, it really sucks (no sendfile, CPU
+ * overhead) performance-wise when used on a
+ * file server, so disable it by default (auto
+ * is the default) on non-DCs */
smb_conn->signing.allow_smb_signing = false;
}
break;
SMB2SRV_SETUP_NTVFS_REQUEST(smb2srv_setinfo_send, NTVFS_ASYNC_STATE_MAY_ASYNC);
info->in.level = SVAL(req->in.body, 0x02);
- SMB2SRV_CHECK(smb2_pull_s32o32_blob(&req->in, info, req->in.body+0x04, &info->in.blob));
+ SMB2SRV_CHECK(smb2_pull_s32o16_blob(&req->in, info, req->in.body+0x04, &info->in.blob));
info->in.flags = IVAL(req->in.body, 0x0C);
info->in.file.ntvfs = smb2srv_pull_handle(req, req->in.body, 0x10);
union smb_read *io;
SMB2SRV_CHECK_BODY_SIZE(req, 0x30, true);
+
+ /* MS-SMB2 2.2.19 read must have a single byte of zero */
+ if (req->in.body_size - req->in.body_fixed < 1) {
+ smb2srv_send_error(req, NT_STATUS_INVALID_PARAMETER);
+ return;
+ }
SMB2SRV_TALLOC_IO_PTR(io, union smb_read);
SMB2SRV_SETUP_NTVFS_REQUEST(smb2srv_read_send, NTVFS_ASYNC_STATE_MAY_ASYNC);
{
uint16_t _pad;
- if (req->in.body_size < 0x04) {
- smb2srv_send_error(req, NT_STATUS_FOOBAR);
+ if (req->in.body_size != 0x04) {
+ smb2srv_send_error(req, NT_STATUS_INVALID_PARAMETER);
+ return;
+ }
+
+ if (SVAL(req->in.body, 0x00) != 0x04) {
+ smb2srv_send_error(req, NT_STATUS_INVALID_PARAMETER);
return;
}
enum ndr_err_code ndr_err;
if (req->in.body_size < 0x26) {
- smb2srv_send_error(req, NT_STATUS_FOOBAR);
+ smbsrv_terminate_connection(req->smb_conn, "Bad body size in SMB2 negprot");
return;
}
io->in.capabilities = IVAL(req->in.body, 0x08);
ndr_err = smbcli_pull_guid(req->in.body, 0xC, &io->in.client_guid);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
- smbsrv_terminate_connection(req->smb_conn, nt_errstr(NT_STATUS_FOOBAR));
+ smbsrv_terminate_connection(req->smb_conn, "Bad GUID in SMB2 negprot");
talloc_free(req);
return;
}
chain_offset = p_req->chain_offset;
p_req->chain_offset = 0;
- if (p_req->in.size < (NBT_HDR_SIZE + chain_offset + SMB2_MIN_SIZE)) {
+ if (p_req->in.size < (NBT_HDR_SIZE + chain_offset + SMB2_MIN_SIZE_NO_BODY)) {
DEBUG(2,("Invalid SMB2 chained packet at offset 0x%X\n",
chain_offset));
smbsrv_terminate_connection(p_req->smb_conn, "Invalid SMB2 chained packet");
req->in.body_size = req->in.size - (NBT_HDR_SIZE+ chain_offset + SMB2_HDR_BODY);
req->in.dynamic = NULL;
+ req->seqnum = BVAL(req->in.hdr, SMB2_HDR_MESSAGE_ID);
+
+ if (req->in.body_size < 2) {
+ /* error handling for this is different for negprot to
+ other packet types */
+ uint16_t opcode = SVAL(req->in.hdr, SMB2_HDR_OPCODE);
+ if (opcode == SMB2_OP_NEGPROT) {
+ smbsrv_terminate_connection(req->smb_conn, "Bad body size in SMB2 negprot");
+ } else {
+ smb2srv_send_error(req, NT_STATUS_INVALID_PARAMETER);
+ }
+ }
+
buffer_code = SVAL(req->in.body, 0);
req->in.body_fixed = (buffer_code & ~1);
dynamic_size = req->in.body_size - req->in.body_fixed;
uint64_t uid;
uint32_t flags;
+ if (SVAL(req->in.hdr, SMB2_HDR_LENGTH) != SMB2_HDR_BODY) {
+ smbsrv_terminate_connection(req->smb_conn, "Invalid SMB2 header length");
+ return NT_STATUS_INVALID_PARAMETER;
+ }
opcode = SVAL(req->in.hdr, SMB2_HDR_OPCODE);
req->chain_offset = IVAL(req->in.hdr, SMB2_HDR_NEXT_COMMAND);
req->seqnum = BVAL(req->in.hdr, SMB2_HDR_MESSAGE_ID);
uid = BVAL(req->in.hdr, SMB2_HDR_SESSION_ID);
flags = IVAL(req->in.hdr, SMB2_HDR_FLAGS);
+ if (req->smb_conn->highest_smb2_seqnum != 0 &&
+ req->seqnum <= req->smb_conn->highest_smb2_seqnum) {
+ smbsrv_terminate_connection(req->smb_conn, "Invalid SMB2 sequence number");
+ return NT_STATUS_INVALID_PARAMETER;
+ }
+ req->smb_conn->highest_smb2_seqnum = req->seqnum;
+
req->session = smbsrv_session_find(req->smb_conn, uid, req->request_time);
req->tcon = smbsrv_smb2_tcon_find(req->session, tid, req->request_time);
return NT_STATUS_OK;
}
- if (blob.length < (NBT_HDR_SIZE + SMB2_MIN_SIZE)) {
+ if (blob.length < (NBT_HDR_SIZE + SMB2_MIN_SIZE_NO_BODY)) {
DEBUG(2,("Invalid SMB2 packet length count %ld\n", (long)blob.length));
smbsrv_terminate_connection(smb_conn, "Invalid SMB2 packet");
return NT_STATUS_OK;
req->in.body_size = req->in.size - (SMB2_HDR_BODY+NBT_HDR_SIZE);
req->in.dynamic = NULL;
+ req->seqnum = BVAL(req->in.hdr, SMB2_HDR_MESSAGE_ID);
+
+ if (req->in.body_size < 2) {
+ /* error handling for this is different for negprot to
+ other packet types */
+ uint16_t opcode = SVAL(req->in.hdr, SMB2_HDR_OPCODE);
+ if (opcode == SMB2_OP_NEGPROT) {
+ smbsrv_terminate_connection(req->smb_conn, "Bad body size in SMB2 negprot");
+ } else {
+ smb2srv_send_error(req, NT_STATUS_INVALID_PARAMETER);
+ }
+ }
+
buffer_code = SVAL(req->in.body, 0);
req->in.body_fixed = (buffer_code & ~1);
dynamic_size = req->in.body_size - req->in.body_fixed;
/* useful way of catching field size errors with file and line number */
#define SMB2SRV_CHECK_BODY_SIZE(req, size, dynamic) do { \
size_t is_size = req->in.body_size; \
- uint16_t field_size = SVAL(req->in.body, 0); \
+ uint16_t field_size; \
uint16_t want_size = ((dynamic)?(size)+1:(size)); \
if (is_size < (size)) { \
DEBUG(0,("%s: buffer too small 0x%x. Expected 0x%x\n", \
smb2srv_send_error(req, NT_STATUS_INVALID_PARAMETER); \
return; \
}\
+ field_size = SVAL(req->in.body, 0); \
if (field_size != want_size) { \
DEBUG(0,("%s: unexpected fixed body size 0x%x. Expected 0x%x\n", \
__location__, (unsigned)field_size, (unsigned)want_size)); \
--- /dev/null
+/*
+ Unix SMB/CIFS implementation.
+
+ process incoming connections and fork a samba3 in inetd mode
+
+ Copyright (C) Stefan Metzmacher 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.
+
+ 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 "smbd/service_task.h"
+#include "smbd/service_stream.h"
+#include "smbd/service.h"
+#include "lib/messaging/irpc.h"
+#include "lib/stream/packet.h"
+#include "lib/socket/socket.h"
+#include "libcli/smb2/smb2.h"
+#include "smb_server/smb2/smb2_server.h"
+#include "system/network.h"
+#include "lib/socket/netif.h"
+#include "param/share.h"
+#include "dsdb/samdb/samdb.h"
+#include "param/param.h"
+#include "dynconfig/dynconfig.h"
+#include "smbd/process_model.h"
+
+/*
+ initialise a server_context from a open socket and register a event handler
+ for reading from that socket
+*/
+static void samba3_smb_accept(struct stream_connection *conn)
+{
+ int i;
+ int fd = socket_get_fd(conn->socket);
+ const char *prog;
+ char *argv[2];
+ char *reason;
+
+ close(0);
+ close(1);
+ dup2(fd, 0);
+ dup2(fd, 1);
+ dup2(fd, 2);
+ for (i=3;i<256;i++) {
+ close(i);
+ }
+
+ prog = lp_parm_string(conn->lp_ctx, NULL, "samba3", "smbd");
+
+ if (prog == NULL) {
+ argv[0] = talloc_asprintf(conn, "%s/%s", dyn_BINDIR, "smbd3");
+ }
+ else {
+ argv[0] = talloc_strdup(conn, prog);
+ }
+
+ if (argv[0] == NULL) {
+ stream_terminate_connection(conn, "out of memory");
+ return;
+ }
+ argv[1] = NULL;
+
+ execve(argv[0], argv, environ);
+
+ /*
+ * Should never get here
+ */
+ reason = talloc_asprintf(conn, "Could not execute %s", argv[0]);
+ if (reason == NULL) {
+ stream_terminate_connection(conn, "out of memory");
+ return;
+ }
+ stream_terminate_connection(conn, reason);
+ talloc_free(reason);
+}
+
+static const struct stream_server_ops samba3_smb_stream_ops = {
+ .name = "samba3",
+ .accept_connection = samba3_smb_accept,
+};
+
+/*
+ setup a listening socket on all the SMB ports for a particular address
+*/
+static NTSTATUS samba3_add_socket(struct event_context *event_context,
+ struct loadparm_context *lp_ctx,
+ const struct model_ops *model_ops,
+ const char *address)
+{
+ const char **ports = lp_smb_ports(lp_ctx);
+ int i;
+ NTSTATUS status;
+
+ for (i=0;ports[i];i++) {
+ uint16_t port = atoi(ports[i]);
+ if (port == 0) continue;
+ status = stream_setup_socket(event_context, lp_ctx,
+ model_ops, &samba3_smb_stream_ops,
+ "ip", address, &port,
+ lp_socket_options(lp_ctx),
+ NULL);
+ NT_STATUS_NOT_OK_RETURN(status);
+ }
+
+ return NT_STATUS_OK;
+}
+
+
+/*
+ open the smb server sockets
+*/
+static void samba3_smb_task_init(struct task_server *task)
+{
+ NTSTATUS status;
+ const struct model_ops *model_ops;
+
+ model_ops = process_model_startup(task->event_ctx, "standard");
+
+ if (model_ops == NULL) {
+ goto failed;
+ }
+
+ task_server_set_title(task, "task[samba3_smb]");
+
+ if (lp_interfaces(task->lp_ctx)
+ && lp_bind_interfaces_only(task->lp_ctx)) {
+ int num_interfaces;
+ int i;
+ struct interface *ifaces;
+
+ load_interfaces(task, lp_interfaces(task->lp_ctx), &ifaces);
+
+ num_interfaces = iface_count(ifaces);
+
+ /* We have been given an interfaces line, and been
+ told to only bind to those interfaces. Create a
+ socket per interface and bind to only these.
+ */
+ for(i = 0; i < num_interfaces; i++) {
+ const char *address = iface_n_ip(ifaces, i);
+ status = samba3_add_socket(task->event_ctx,
+ task->lp_ctx,
+ model_ops, address);
+ if (!NT_STATUS_IS_OK(status)) goto failed;
+ }
+ } else {
+ /* Just bind to lp_socket_address() (usually 0.0.0.0) */
+ status = samba3_add_socket(task->event_ctx, task->lp_ctx,
+ model_ops,
+ lp_socket_address(task->lp_ctx));
+ if (!NT_STATUS_IS_OK(status)) goto failed;
+ }
+
+ return;
+failed:
+ task_server_terminate(task, "Failed to startup samba3 smb task");
+}
+
+/* called at smbd startup - register ourselves as a server service */
+NTSTATUS server_service_samba3_smb_init(void)
+{
+ return register_server_service("samba3_smb", samba3_smb_task_init);
+}
struct loadparm_context *lp_ctx;
bool smb2_signing_required;
+
+ uint64_t highest_smb2_seqnum;
};
struct model_ops;
$(eval $(call proto_header_template,$(smbdsrcdir)/pidfile.h,$(PIDFILE_OBJ_FILES:.o=.c)))
-#################################
-# Start BINARY smbd
-[BINARY::smbd]
+[BINARY::samba]
INSTALLDIR = SBINDIR
PRIVATE_DEPENDENCIES = \
process_model \
share \
CLUSTER
-smbd_OBJ_FILES = $(smbdsrcdir)/server.o
+samba_OBJ_FILES = $(smbdsrcdir)/server.o
-MANPAGES += $(smbdsrcdir)/smbd.8
-# End BINARY smbd
-#################################
+MANPAGES += $(smbdsrcdir)/samba.8
#include "smbd/process_model.h"
#include "param/param.h"
+static const struct model_ops *process_model_byname(const char *name);
+
/*
setup the events for the chosen process model
*/
/*
return the operations structure for a named backend of the specified type
*/
-_PUBLIC_ const struct model_ops *process_model_byname(const char *name)
+static const struct model_ops *process_model_byname(const char *name)
{
int i;
void *);
/* function to terminate a connection or task */
- void (*terminate)(struct event_context *, const char *reason);
+ void (*terminate)(struct event_context *, struct loadparm_context *lp_ctx,
+ const char *reason);
/* function to set a title for the connection or task */
void (*set_title)(struct event_context *, const char *title);
extern const struct model_ops single_ops;
const struct model_ops *process_model_startup(struct event_context *ev, const char *model);
-const struct model_ops *process_model_byname(const char *name);
NTSTATUS register_process_model(const void *_ops);
NTSTATUS process_model_init(struct loadparm_context *lp_ctx);
/* called when a task goes down */
-_NORETURN_ static void prefork_terminate(struct event_context *ev, const char *reason)
+_NORETURN_ static void prefork_terminate(struct event_context *ev, struct loadparm_context *lp_ctx, const char *reason)
{
DEBUG(2,("prefork_terminate: reason[%s]\n",reason));
}
/* called when a task goes down */
-static void single_terminate(struct event_context *ev, const char *reason)
+static void single_terminate(struct event_context *ev, struct loadparm_context *lp_ctx, const char *reason)
{
DEBUG(2,("single_terminate: reason[%s]\n",reason));
}
/* called when a task goes down */
-_NORETURN_ static void standard_terminate(struct event_context *ev, const char *reason)
+_NORETURN_ static void standard_terminate(struct event_context *ev, struct loadparm_context *lp_ctx,
+ const char *reason)
{
DEBUG(2,("standard_terminate: reason[%s]\n",reason));
/* this reload_charcnv() has the effect of freeing the iconv context memory,
which makes leak checking easier */
- reload_charcnv(global_loadparm);
+ reload_charcnv(lp_ctx);
talloc_free(ev);
}
/* called when a task goes down */
-static void thread_terminate(struct event_context *event_ctx, const char *reason)
+static void thread_terminate(struct event_context *event_ctx, struct loadparm_context *lp_ctx, const char *reason)
{
DEBUG(10,("thread_terminate: reason[%s]\n",reason));
<?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="smbd.8">
+<refentry id="samba.8">
<refmeta>
- <refentrytitle>smbd</refentrytitle>
+ <refentrytitle>samba</refentrytitle>
<manvolnum>8</manvolnum>
</refmeta>
<refnamediv>
- <refname>smbd</refname>
+ <refname>samba</refname>
<refpurpose>server to provide filesharing- and directory services to clients</refpurpose>
</refnamediv>
<refsynopsisdiv>
<cmdsynopsis>
- <command>smbd</command>
+ <command>samba</command>
<arg choice="opt">-i</arg>
<arg choice="opt">-M model</arg>
</cmdsynopsis>
<para>This program is part of the <citerefentry><refentrytitle>samba</refentrytitle>
<manvolnum>7</manvolnum></citerefentry> suite.</para>
- <para><command>smbd</command> is the server daemon that
+ <para><command>samba</command> is the server daemon that
provides filesharing and directory services to Windows clients.
The server provides filespace and directory services to
clients using the SMB (or CIFS) protocol and other
<manvolnum>5</manvolnum></citerefentry> manual page should be regarded as mandatory reading before
proceeding with installation.</para>
- <para>As of Samba 4, smbd also incorporates all the functionality of
- nmbd.</para>
+ <para>As of Samba 4, there is a single daemon that incorporates the
+ functionality of both smbd and nmbd that are present in older versions
+ of Samba.</para>
</refsect1>
server to run "interactively", not as a daemon, even if the
server is executed on the command line of a shell. Setting this
parameter negates the implicit deamon mode when run from the
- command line. <command>smbd</command> also logs to standard
+ command line. <command>samba</command> also logs to standard
output, as if the <command>-S</command> parameter had been
given.
</para></listitem>
<varlistentry>
<term>-M model</term>
<listitem><para>This parameter can be used to specify the
- "process model" smbd should use. This determines
+ "process model" samba should use. This determines
how concurrent clients are handled. Available process
models include <emphasis>single</emphasis> (everything in
a single process), <emphasis>standard</emphasis> (similar
extern NTSTATUS server_service_drepl_init(void);
extern NTSTATUS server_service_rpc_init(void);
extern NTSTATUS server_service_ntp_signd_init(void);
- init_module_fn static_init[] = { STATIC_smbd_MODULES };
+ extern NTSTATUS server_service_samba3_smb_init(void);
+ init_module_fn static_init[] = { STATIC_samba_MODULES };
init_module_fn *shared_init;
struct event_context *event_ctx;
uint16_t stdin_event_flags;
if (!reason) reason = "unknown reason";
+ DEBUG(3,("Terminating connection - '%s'\n", reason));
+
srv_conn->terminate = reason;
if (srv_conn->processing) {
talloc_free(srv_conn->event.fde);
srv_conn->event.fde = NULL;
+ model_ops->terminate(event_ctx, srv_conn->lp_ctx, reason);
talloc_free(srv_conn);
- model_ops->terminate(event_ctx, reason);
}
/**
struct event_context *event_ctx = task->event_ctx;
const struct model_ops *model_ops = task->model_ops;
DEBUG(0,("task_server_terminate: [%s]\n", reason));
- model_ops->terminate(event_ctx, reason);
+ model_ops->terminate(event_ctx, task->lp_ctx, reason);
/* don't free this above, it might contain the 'reason' being printed */
talloc_free(task);
smb->in.fallback_to_anonymous=false;
smb->in.workgroup=workgroup;
lp_smbcli_options(tctx->lp_ctx, &smb->in.options);
+ lp_smbcli_session_options(tctx->lp_ctx, &smb->in.session_options);
return smb_composite_connect_send(smb,mem_ctx,
lp_resolve_context(tctx->lp_ctx),ev);
NTSTATUS status;
struct smb_composite_sesssetup setup;
struct smbcli_session *session;
+ struct smbcli_session_options options;
- session = smbcli_session_init(cli->transport, cli, false);
+ lp_smbcli_session_options(tctx->lp_ctx, &options);
+
+ session = smbcli_session_init(cli->transport, cli, false, options);
setup.in.sesskey = cli->transport->negotiate.sesskey;
setup.in.capabilities = cli->transport->negotiate.capabilities;
setup.in.workgroup = lp_workgroup(tctx->lp_ctx);
eventlog.o epmapper.o winreg.o initshutdown.o oxidresolve.o remact.o mgmt.o \
scanner.o autoidl.o countcalls.o testjoin.o schannel.o netlogon.o remote_pac.o samlogon.o \
samsync.o bind.o dssetup.o alter_context.o bench.o samba3rpc.o rpc.o async_bind.o \
- handles.o frsapi.o)
+ handles.o frsapi.o object_uuid.o)
$(eval $(call proto_header_template,$(torturesrcdir)/rpc/proto.h,$(torture_rpc_OBJ_FILES:.o=.c)))
for (j=0;j<NINSTANCES;j++) {
NTSTATUS status;
struct smbcli_options smb_options;
+ struct smbcli_session_options smb_session_options;
lp_smbcli_options(lp_ctx, &smb_options);
+ lp_smbcli_session_options(lp_ctx, &smb_session_options);
printf("Connecting to \\\\%s\\%s as %s - instance %d\n",
servers[i].server_name, servers[i].share_name,
servers[i].share_name, "A:",
servers[i].credentials,
lp_resolve_context(lp_ctx), ev,
- &smb_options);
+ &smb_options,
+ &smb_session_options);
}
if (!NT_STATUS_IS_OK(status)) {
printf("Failed to connect to \\\\%s\\%s - %s\n",
*/
static bool compare_status(NTSTATUS status1, NTSTATUS status2)
{
+ char *s;
+
if (NT_STATUS_EQUAL(status1, status2)) return true;
/* one code being an error and the other OK is always an error */
ignore_pattern(nt_errstr(status2))) {
return true;
}
+
+ /* also support ignore patterns of the form NT_STATUS_XX:NT_STATUS_YY
+ meaning that the first server returns NT_STATUS_XX and the 2nd
+ returns NT_STATUS_YY */
+ s = talloc_asprintf(current_op.mem_ctx, "%s:%s",
+ nt_errstr(status1),
+ nt_errstr(status2));
+ if (ignore_pattern(s)) {
+ return true;
+ }
+
current_op.mismatch = nt_errstr(status1);
return false;
}
} \
current_op.status = status[0]; \
for (i=1;i<NSERVERS;i++) { \
- if (!compare_status(status[i], status[0])) { \
+ if (!compare_status(status[0], status[1])) { \
printf("status different in %s - %s %s\n", #call, \
nt_errstr(status[0]), nt_errstr(status[i])); \
current_op.mismatch = nt_errstr(status[0]); \
case RAW_SFILEINFO_MODE_INFORMATION:
info->mode_information.in.mode = gen_bits_mask(0xFFFFFFFF);
break;
+ case RAW_SFILEINFO_FULL_EA_INFORMATION:
+ info->full_ea_information.in.eas = gen_ea_list();
+ break;
case RAW_SFILEINFO_GENERIC:
case RAW_SFILEINFO_SEC_DESC:
case RAW_SFILEINFO_UNIX_BASIC:
do {
i = gen_int_range(0, num_levels-1);
} while (ignore_pattern(levels[i].name));
-
+
+ ZERO_STRUCTP(info);
info->generic.level = levels[i].level;
switch (info->generic.level) {
case RAW_SFILEINFO_MODE_INFORMATION:
info->mode_information.in.mode = gen_bits_mask(0xFFFFFFFF);
break;
+ case RAW_SFILEINFO_FULL_EA_INFORMATION:
+ info->full_ea_information.in.eas = gen_ea_list();
+ break;
case RAW_SFILEINFO_GENERIC:
case RAW_SFILEINFO_SEC_DESC:
union smb_setfileinfo parm[NSERVERS];
NTSTATUS status[NSERVERS];
- parm[0].generic.in.file.path = gen_fname_open(instance);
-
gen_setfileinfo(instance, &parm[0]);
+ parm[0].generic.in.file.path = gen_fname_open(instance);
GEN_COPY_PARM;
union smb_setfileinfo parm[NSERVERS];
NTSTATUS status[NSERVERS];
- parm[0].generic.in.file.fnum = gen_fnum(instance);
-
gen_setfileinfo(instance, &parm[0]);
+ parm[0].generic.in.file.fnum = gen_fnum(instance);
GEN_COPY_PARM;
GEN_SET_FNUM_SMB2(generic.in.file.handle);
current_op.opnum = op;
current_op.name = gen_ops[which_op].name;
current_op.status = NT_STATUS_OK;
+ talloc_free(current_op.mem_ctx);
current_op.mem_ctx = talloc_named(NULL, 0, "%s", current_op.name);
ret = gen_ops[which_op].handler(instance);
- talloc_free(current_op.mem_ctx);
-
gen_ops[which_op].count++;
if (NT_STATUS_IS_OK(current_op.status)) {
gen_ops[which_op].success_count++;
n1 = search.out.netlogon;
search.in.user = "Administrator";
- search.in.realm = n1.nt5_ex.dns_domain;
+ search.in.realm = n1.data.nt5_ex.dns_domain;
search.in.host = "__cldap_torture__";
printf("Scanning for netlogon levels\n");
search.in.user = NULL;
status = cldap_netlogon(cldap, tctx, &search);
CHECK_STATUS(status, NT_STATUS_OK);
- CHECK_STRING(search.out.netlogon.nt5_ex.user_name, "");
- CHECK_VAL(search.out.netlogon.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX);
+ CHECK_STRING(search.out.netlogon.data.nt5_ex.user_name, "");
+ CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX);
printf("Trying with User=Administrator\n");
status = cldap_netlogon(cldap, tctx, &search);
CHECK_STATUS(status, NT_STATUS_OK);
- CHECK_STRING(search.out.netlogon.nt5_ex.user_name, search.in.user);
- CHECK_VAL(search.out.netlogon.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN_EX);
+ CHECK_STRING(search.out.netlogon.data.nt5_ex.user_name, search.in.user);
+ CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN_EX);
search.in.version = NETLOGON_NT_VERSION_5;
status = cldap_netlogon(cldap, tctx, &search);
search.in.user = NULL;
status = cldap_netlogon(cldap, tctx, &search);
CHECK_STATUS(status, NT_STATUS_OK);
- CHECK_STRING(search.out.netlogon.nt5_ex.user_name, "");
- CHECK_VAL(search.out.netlogon.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE);
+ CHECK_STRING(search.out.netlogon.data.nt5_ex.user_name, "");
+ CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE);
printf("Trying with User=Administrator\n");
status = cldap_netlogon(cldap, tctx, &search);
CHECK_STATUS(status, NT_STATUS_OK);
- CHECK_STRING(search.out.netlogon.nt5_ex.user_name, search.in.user);
- CHECK_VAL(search.out.netlogon.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN);
+ CHECK_STRING(search.out.netlogon.data.nt5_ex.user_name, search.in.user);
+ CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN);
search.in.version = NETLOGON_NT_VERSION_5 | NETLOGON_NT_VERSION_5EX;
printf("Trying with a GUID\n");
search.in.realm = NULL;
- search.in.domain_guid = GUID_string(tctx, &n1.nt5_ex.domain_uuid);
+ search.in.domain_guid = GUID_string(tctx, &n1.data.nt5_ex.domain_uuid);
status = cldap_netlogon(cldap, tctx, &search);
CHECK_STATUS(status, NT_STATUS_OK);
- CHECK_VAL(search.out.netlogon.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN_EX);
- CHECK_STRING(GUID_string(tctx, &search.out.netlogon.nt5_ex.domain_uuid), search.in.domain_guid);
+ CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN_EX);
+ CHECK_STRING(GUID_string(tctx, &search.out.netlogon.data.nt5_ex.domain_uuid), search.in.domain_guid);
printf("Trying with a incorrect GUID\n");
guid = GUID_random();
printf("Trying with a AAC\n");
search.in.acct_control = ACB_WSTRUST|ACB_SVRTRUST;
- search.in.realm = n1.nt5_ex.dns_domain;
+ search.in.realm = n1.data.nt5_ex.dns_domain;
status = cldap_netlogon(cldap, tctx, &search);
CHECK_STATUS(status, NT_STATUS_OK);
- CHECK_VAL(search.out.netlogon.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX);
- CHECK_STRING(search.out.netlogon.nt5_ex.user_name, "");
+ CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX);
+ CHECK_STRING(search.out.netlogon.data.nt5_ex.user_name, "");
printf("Trying with a zero AAC\n");
search.in.acct_control = 0x0;
- search.in.realm = n1.nt5_ex.dns_domain;
+ search.in.realm = n1.data.nt5_ex.dns_domain;
status = cldap_netlogon(cldap, tctx, &search);
CHECK_STATUS(status, NT_STATUS_OK);
- CHECK_VAL(search.out.netlogon.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX);
- CHECK_STRING(search.out.netlogon.nt5_ex.user_name, "");
+ CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX);
+ CHECK_STRING(search.out.netlogon.data.nt5_ex.user_name, "");
printf("Trying with a zero AAC and user=Administrator\n");
search.in.acct_control = 0x0;
search.in.user = "Administrator";
- search.in.realm = n1.nt5_ex.dns_domain;
+ search.in.realm = n1.data.nt5_ex.dns_domain;
status = cldap_netlogon(cldap, tctx, &search);
CHECK_STATUS(status, NT_STATUS_OK);
- CHECK_VAL(search.out.netlogon.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN_EX);
- CHECK_STRING(search.out.netlogon.nt5_ex.user_name, "Administrator");
+ CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN_EX);
+ CHECK_STRING(search.out.netlogon.data.nt5_ex.user_name, "Administrator");
printf("Trying with a bad AAC\n");
search.in.user = NULL;
search.in.acct_control = 0xFF00FF00;
- search.in.realm = n1.nt5_ex.dns_domain;
+ search.in.realm = n1.data.nt5_ex.dns_domain;
status = cldap_netlogon(cldap, tctx, &search);
CHECK_STATUS(status, NT_STATUS_OK);
- CHECK_VAL(search.out.netlogon.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX);
- CHECK_STRING(search.out.netlogon.nt5_ex.user_name, "");
+ CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX);
+ CHECK_STRING(search.out.netlogon.data.nt5_ex.user_name, "");
printf("Trying with a user only\n");
search = empty_search;
search.in.user = "Administrator";
status = cldap_netlogon(cldap, tctx, &search);
CHECK_STATUS(status, NT_STATUS_OK);
- CHECK_STRING(search.out.netlogon.nt5_ex.dns_domain, n1.nt5_ex.dns_domain);
- CHECK_STRING(search.out.netlogon.nt5_ex.user_name, search.in.user);
+ CHECK_STRING(search.out.netlogon.data.nt5_ex.dns_domain, n1.data.nt5_ex.dns_domain);
+ CHECK_STRING(search.out.netlogon.data.nt5_ex.user_name, search.in.user);
printf("Trying with just a bad username\n");
search.in.user = "___no_such_user___";
status = cldap_netlogon(cldap, tctx, &search);
CHECK_STATUS(status, NT_STATUS_OK);
- CHECK_STRING(search.out.netlogon.nt5_ex.user_name, search.in.user);
- CHECK_STRING(search.out.netlogon.nt5_ex.dns_domain, n1.nt5_ex.dns_domain);
- CHECK_VAL(search.out.netlogon.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN_EX);
+ CHECK_STRING(search.out.netlogon.data.nt5_ex.user_name, search.in.user);
+ CHECK_STRING(search.out.netlogon.data.nt5_ex.dns_domain, n1.data.nt5_ex.dns_domain);
+ CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN_EX);
printf("Trying with just a bad domain\n");
search = empty_search;
CHECK_STATUS(status, NT_STATUS_NOT_FOUND);
printf("Trying with a incorrect domain and correct guid\n");
- search.in.domain_guid = GUID_string(tctx, &n1.nt5_ex.domain_uuid);
+ search.in.domain_guid = GUID_string(tctx, &n1.data.nt5_ex.domain_uuid);
status = cldap_netlogon(cldap, tctx, &search);
CHECK_STATUS(status, NT_STATUS_OK);
- CHECK_STRING(search.out.netlogon.nt5_ex.dns_domain, n1.nt5_ex.dns_domain);
- CHECK_STRING(search.out.netlogon.nt5_ex.user_name, "");
- CHECK_VAL(search.out.netlogon.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX);
+ CHECK_STRING(search.out.netlogon.data.nt5_ex.dns_domain, n1.data.nt5_ex.dns_domain);
+ CHECK_STRING(search.out.netlogon.data.nt5_ex.user_name, "");
+ CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX);
printf("Trying with a incorrect domain and incorrect guid\n");
search.in.domain_guid = GUID_string(tctx, &guid);
status = cldap_netlogon(cldap, tctx, &search);
CHECK_STATUS(status, NT_STATUS_NOT_FOUND);
- CHECK_STRING(search.out.netlogon.nt5_ex.dns_domain, n1.nt5_ex.dns_domain);
- CHECK_STRING(search.out.netlogon.nt5_ex.user_name, "");
- CHECK_VAL(search.out.netlogon.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX);
+ CHECK_STRING(search.out.netlogon.data.nt5_ex.dns_domain, n1.data.nt5_ex.dns_domain);
+ CHECK_STRING(search.out.netlogon.data.nt5_ex.user_name, "");
+ CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX);
printf("Trying with a incorrect GUID and correct domain\n");
search.in.domain_guid = GUID_string(tctx, &guid);
- search.in.realm = n1.nt5_ex.dns_domain;
+ search.in.realm = n1.data.nt5_ex.dns_domain;
status = cldap_netlogon(cldap, tctx, &search);
CHECK_STATUS(status, NT_STATUS_OK);
- CHECK_STRING(search.out.netlogon.nt5_ex.dns_domain, n1.nt5_ex.dns_domain);
- CHECK_STRING(search.out.netlogon.nt5_ex.user_name, "");
- CHECK_VAL(search.out.netlogon.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX);
+ CHECK_STRING(search.out.netlogon.data.nt5_ex.dns_domain, n1.data.nt5_ex.dns_domain);
+ CHECK_STRING(search.out.netlogon.data.nt5_ex.user_name, "");
+ CHECK_VAL(search.out.netlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX);
return true;
}
n1 = search.out.netlogon;
if (n1.ntver == NETLOGON_NT_VERSION_5)
- server_type = n1.nt5.server_type;
+ server_type = n1.data.nt5.server_type;
else if (n1.ntver == NETLOGON_NT_VERSION_5EX)
- server_type = n1.nt5_ex.server_type;
+ server_type = n1.data.nt5_ex.server_type;
printf("The word is: %i\n", server_type);
if (server_type & NBT_SERVER_PDC)
n1 = search.out.netlogon;
if (n1.ntver == NETLOGON_NT_VERSION_5)
- server_type = n1.nt5.server_type;
+ server_type = n1.data.nt5.server_type;
else if (n1.ntver == NETLOGON_NT_VERSION_5EX)
- server_type = n1.nt5_ex.server_type;
+ server_type = n1.data.nt5_ex.server_type;
if (server_type & NBT_SERVER_DS_DNS_FOREST) {
struct cldap_search search2;
};
struct test_schema_ctx {
+ struct ldb_context *ldb;
+
struct ldb_paged_control *ctrl;
uint32_t count;
bool pending;
d_printf("Testing RootDSE Search\n");
- ret = ldb_search(ldb, ldb_dn_new(ldb, ldb, NULL), LDB_SCOPE_BASE,
- NULL, NULL, &r);
+ ret = ldb_search(ldb, ldb, &r, ldb_dn_new(ldb, ldb, NULL),
+ LDB_SCOPE_BASE, NULL, NULL);
if (ret != LDB_SUCCESS) {
return false;
} else if (r->count != 1) {
return true;
}
-static int test_schema_search_callback(struct ldb_context *ldb, void *context, struct ldb_reply *ares)
+static int test_schema_search_callback(struct ldb_request *req, struct ldb_reply *ares)
{
- struct test_schema_ctx *actx = talloc_get_type(context, struct test_schema_ctx);
+ struct test_schema_ctx *actx;
int ret = LDB_SUCCESS;
+ actx = talloc_get_type(req->context, struct test_schema_ctx);
+
+ if (!ares) {
+ return ldb_request_done(req, LDB_ERR_OPERATIONS_ERROR);
+ }
+ if (ares->error != LDB_SUCCESS) {
+ return ldb_request_done(req, ares->error);
+ }
+
switch (ares->type) {
case LDB_REPLY_ENTRY:
actx->count++;
- ret = actx->callback(actx->private_data, ldb, ares->message);
+ ret = actx->callback(actx->private_data, actx->ldb, ares->message);
break;
case LDB_REPLY_REFERRAL:
actx->pending = true;
}
}
- break;
-
+ talloc_free(ares);
+ return ldb_request_done(req, LDB_SUCCESS);
+
default:
d_printf("%s: unknown Reply Type %u\n", __location__, ares->type);
- return LDB_ERR_OTHER;
+ return ldb_request_done(req, LDB_ERR_OTHER);
}
if (talloc_free(ares) == -1) {
d_printf("talloc_free failed\n");
actx->pending = 0;
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_request_done(req, LDB_ERR_OPERATIONS_ERROR);
}
if (ret) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_request_done(req, LDB_ERR_OPERATIONS_ERROR);
}
return LDB_SUCCESS;
int ret;
struct test_schema_ctx *actx;
- req = talloc(ldb, struct ldb_request);
- actx = talloc(req, struct test_schema_ctx);
+ actx = talloc(ldb, struct test_schema_ctx);
+ actx->ldb = ldb;
+ actx->private_data = private_data;
+ actx->callback= callback;
- ctrl = talloc_array(req, struct ldb_control *, 2);
+ ctrl = talloc_array(actx, struct ldb_control *, 2);
ctrl[0] = talloc(ctrl, struct ldb_control);
ctrl[0]->oid = LDB_CONTROL_PAGED_RESULTS_OID;
ctrl[0]->critical = true;
ctrl[0]->data = control;
ctrl[1] = NULL;
- req->operation = LDB_SEARCH;
- req->op.search.base = ldb_dn_new(req, ldb, root->schemadn);
- req->op.search.scope = LDB_SCOPE_SUBTREE;
- req->op.search.tree = ldb_parse_tree(req, filter);
- if (req->op.search.tree == NULL) return -1;
- req->op.search.attrs = NULL;
- req->controls = ctrl;
- req->context = actx;
- req->callback = test_schema_search_callback;
- ldb_set_timeout(ldb, req, 0);
-
- actx->count = 0;
- actx->ctrl = control;
- actx->callback = callback;
- actx->private_data = private_data;
+ ret = ldb_build_search_req(&req, ldb, actx,
+ ldb_dn_new(actx, ldb, root->schemadn),
+ LDB_SCOPE_SUBTREE,
+ filter, NULL,
+ ctrl,
+ actx, test_schema_search_callback,
+ NULL);
+
+ actx->ctrl = control;
+ actx->count = 0;
again:
actx->pending = false;
ret = ldb_request(ldb, req);
if (ret != LDB_SUCCESS) {
d_printf("search failed - %s\n", ldb_errstring(ldb));
+ talloc_free(actx);
return false;
}
ret = ldb_wait(req->handle, LDB_WAIT_ALL);
if (ret != LDB_SUCCESS) {
d_printf("search error - %s\n", ldb_errstring(ldb));
+ talloc_free(actx);
return false;
}
goto again;
d_printf("filter[%s] count[%u]\n", filter, actx->count);
+ talloc_free(actx);
return true;
}
torture_comment(torture, "Check replUpToDateVector on partition[%s]\n",
ldb_dn_get_linearized(partition_dn));
- ret = ldb_search(ldb, partition_dn, LDB_SCOPE_BASE,
- "(objectClass=*)", attrs, &r);
+ ret = ldb_search(ldb, torture, &r, partition_dn, LDB_SCOPE_BASE, attrs,
+ "(objectClass=*)");
if (ret != LDB_SUCCESS) {
return false;
} else if (r->count != 1) {
talloc_free(r);
return false;
}
- talloc_steal(torture, r);
ZERO_STRUCT(utdv1);
utdv_val1 = ldb_msg_find_ldb_val(r->msgs[0], "replUpToDateVector");
ret = ldb_modify(ldb, msg);
if (ret != LDB_SUCCESS) return false;
- ret = ldb_search(ldb, partition_dn, LDB_SCOPE_BASE,
- "(objectClass=*)", attrs, &r);
+ ret = ldb_search(ldb, msg, &r, partition_dn, LDB_SCOPE_BASE,
+ attrs, "(objectClass=*)");
if (ret != LDB_SUCCESS) {
return false;
} else if (r->count != 1) {
talloc_free(r);
return false;
}
- talloc_steal(msg, r);
ZERO_STRUCT(utdv);
utdv_val = ldb_msg_find_ldb_val(r->msgs[0], "replUpToDateVector");
for (count=0;timeval_elapsed(&tv) < timelimit;count++) {
struct ldb_dn *dn;
struct ldb_result *res;
- char *expr;
i = random() % torture_entries;
dn = ldb_dn_new_fmt(tmp_ctx, ldb, "SID=S-1-5-21-53173311-3623041448-2049097239-%u", i);
- if (ldb_search(ldb, dn, LDB_SCOPE_BASE, NULL, NULL, &res) != LDB_SUCCESS || res->count != 1) {
+ if (ldb_search(ldb, tmp_ctx, &res, dn, LDB_SCOPE_BASE, NULL, NULL) != LDB_SUCCESS || res->count != 1) {
torture_fail(torture, talloc_asprintf(torture, "Failed to find SID %d", i));
}
talloc_free(res);
talloc_free(dn);
- expr = talloc_asprintf(tmp_ctx, "(UID=%u)", i);
- if (ldb_search(ldb, NULL, LDB_SCOPE_SUBTREE, expr, NULL, &res) != LDB_SUCCESS || res->count != 1) {
+ if (ldb_search(ldb, tmp_ctx, &res, NULL, LDB_SCOPE_SUBTREE, NULL, "(UID=%u)", i) != LDB_SUCCESS || res->count != 1) {
torture_fail(torture, talloc_asprintf(torture, "Failed to find UID %d", i));
}
talloc_free(res);
- talloc_free(expr);
}
if (talloc_total_blocks(torture) > 100) {
#include "torture/ndr/ndr.h"
#include "torture/ndr/proto.h"
#include "torture/auth/proto.h"
-#include "lib/crypto/test_proto.h"
+#include "../lib/crypto/test_proto.h"
#include "lib/registry/tests/proto.h"
/* ignore me */ static struct torture_suite *
NTSTATUS status;
int retries = 10;
struct smbcli_options options;
+ struct smbcli_session_options session_options;
lp_smbcli_options(lp_ctx, &options);
+ lp_smbcli_session_options(lp_ctx, &session_options);
printf("connect_one(%s, %d, %d)\n", share, snum, conn);
share, NULL,
servers[snum],
lp_resolve_context(lp_ctx),
- ev, &options);
+ ev, &options, &session_options);
if (!NT_STATUS_IS_OK(status)) {
sleep(2);
}
return a connection to a server
*******************************************************/
static struct smbcli_state *connect_one(char *share, const char **ports,
- struct smb_options *optionsi,
+ struct smb_options *options,
+ struct smb_options *session_options,
struct event_context *ev)
{
struct smbcli_state *c;
nt_status = smbcli_full_connection(NULL,
&c, myname, server_n, ports, share, NULL,
username, lp_workgroup(), password, ev,
- options);
+ options, session_options);
if (!NT_STATUS_IS_OK(nt_status)) {
DEBUG(0, ("smbcli_full_connection failed with error %s\n", nt_errstr(nt_status)));
return NULL;
int fnum[NSERVERS][NUMFSTYPES][NCONNECTIONS][NFILES],
const char **ports,
struct smbcli_options *options,
+ struct smbcli_session_options *session_options,
struct event_context *ev,
char *share1, char *share2)
{
smbcli_ulogoff(cli[server][conn]);
talloc_free(cli[server][conn]);
}
- cli[server][conn] = connect_one(share[server], ports, options, ev);
+ cli[server][conn] = connect_one(share[server], ports, options, session_options, ev);
if (!cli[server][conn]) {
DEBUG(0,("Failed to connect to %s\n", share[server]));
exit(1);
char *nfspath1, char *nfspath2,
const char **ports,
struct smbcli_options *options,
+ struct smbcli_session_options *session_options,
struct event_context *ev)
{
struct smbcli_state *cli[NSERVERS][NCONNECTIONS];
recorded[n].needed = true;
}
- reconnect(cli, nfs, fnum, ports, options, ev, share1, share2);
+ reconnect(cli, nfs, fnum, ports, options, session_options, ev, share1, share2);
open_files(cli, nfs, fnum);
n = retest(cli, nfs, fnum, numops);
n1 = n;
close_files(cli, nfs, fnum);
- reconnect(cli, nfs, fnum, ports, options, ev, share1, share2);
+ reconnect(cli, nfs, fnum, ports, options, session_options, ev, share1, share2);
open_files(cli, nfs, fnum);
for (i=0;i<n-1;i++) {
}
close_files(cli, nfs, fnum);
- reconnect(cli, nfs, fnum, ports, options, ev, share1, share2);
+ reconnect(cli, nfs, fnum, ports, options, session_options, ev, share1, share2);
open_files(cli, nfs, fnum);
showall = true;
n1 = retest(cli, nfs, fnum, n);
extern char *optarg;
extern int optind;
struct smbcli_options options;
+ struct smbcli_session_options session_options;
int opt;
char *p;
int seed;
locking_init(1);
lp_smbcli_options(lp_ctx, &options);
+ lp_smbcli_session_options(lp_ctx, &session_options);
test_locks(share1, share2, nfspath1, nfspath2, lp_smb_ports(lp_ctx),
- &options, ev);
+ &options, &session_options, ev);
return(0);
}
static struct smbcli_state *connect_one(struct resolve_context *resolve_ctx,
struct event_context *ev,
char *share, const char **ports,
- struct smbcli_options *options)
+ struct smbcli_options *options,
+ struct smbcli_session_options *session_options)
{
struct smbcli_state *c;
fstring server;
ports,
share, NULL,
cmdline_credentials, resolve_ctx, ev,
- options);
+ options, session_options);
if (!NT_STATUS_IS_OK(status)) {
return NULL;
struct event_context *ev;
struct loadparm_context *lp_ctx;
struct smbcli_options options;
+ struct smbcli_session_options session_options;
poptContext pc;
int argc_new, i;
char **argv_new;
gensec_init(lp_ctx);
lp_smbcli_options(lp_ctx, &options);
+ lp_smbcli_session_options(lp_ctx, &session_options);
cli = connect_one(lp_resolve_context(lp_ctx), ev, share,
- lp_smb_ports(lp_ctx), &options);
+ lp_smb_ports(lp_ctx), &options, &session_options);
if (!cli) {
DEBUG(0,("Failed to connect to %s\n", share));
exit(1);
torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
torture_assert(tctx, response->response_type == NETLOGON_GET_PDC, "Got incorrect type of netlogon response");
- torture_assert(tctx, response->get_pdc.command == NETLOGON_RESPONSE_FROM_PDC, "Got incorrect netlogon response command");
+ torture_assert(tctx, response->data.get_pdc.command == NETLOGON_RESPONSE_FROM_PDC, "Got incorrect netlogon response command");
return true;
}
torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
torture_assert_int_equal(tctx, response->response_type, NETLOGON_SAMLOGON, "Got incorrect type of netlogon response");
- map_netlogon_samlogon_response(&response->samlogon);
+ map_netlogon_samlogon_response(&response->data.samlogon);
- torture_assert_int_equal(tctx, response->samlogon.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX, "Got incorrect netlogon response command");
- torture_assert_int_equal(tctx, response->samlogon.nt5_ex.nt_version, NETLOGON_NT_VERSION_5EX_WITH_IP|NETLOGON_NT_VERSION_5EX|NETLOGON_NT_VERSION_1, "Got incorrect netlogon response command");
+ torture_assert_int_equal(tctx, response->data.samlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX, "Got incorrect netlogon response command");
+ torture_assert_int_equal(tctx, response->data.samlogon.data.nt5_ex.nt_version, NETLOGON_NT_VERSION_5EX_WITH_IP|NETLOGON_NT_VERSION_5EX|NETLOGON_NT_VERSION_1, "Got incorrect netlogon response command");
/* setup (another) temporary mailslot listener for replies */
dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
torture_assert_int_equal(tctx, response->response_type, NETLOGON_SAMLOGON, "Got incorrect type of netlogon response");
- map_netlogon_samlogon_response(&response->samlogon);
+ map_netlogon_samlogon_response(&response->data.samlogon);
- torture_assert_int_equal(tctx, response->samlogon.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN, "Got incorrect netlogon response command");
+ torture_assert_int_equal(tctx, response->data.samlogon.data.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN, "Got incorrect netlogon response command");
- torture_assert_str_equal(tctx, response->samlogon.nt5_ex.user_name, TEST_NAME"$", "Got incorrect user in netlogon response");
+ torture_assert_str_equal(tctx, response->data.samlogon.data.nt5_ex.user_name, TEST_NAME"$", "Got incorrect user in netlogon response");
join_ctx = torture_join_domain(tctx, TEST_NAME,
ACB_WSTRUST, &machine_credentials);
torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
torture_assert_int_equal(tctx, response->response_type, NETLOGON_SAMLOGON, "Got incorrect type of netlogon response");
- map_netlogon_samlogon_response(&response->samlogon);
+ map_netlogon_samlogon_response(&response->data.samlogon);
- torture_assert_int_equal(tctx, response->samlogon.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN, "Got incorrect netlogon response command");
+ torture_assert_int_equal(tctx, response->data.samlogon.data.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN, "Got incorrect netlogon response command");
/* setup (another) temporary mailslot listener for replies */
dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
torture_assert_int_equal(tctx, response->response_type, NETLOGON_SAMLOGON, "Got incorrect type of netlogon response");
- map_netlogon_samlogon_response(&response->samlogon);
+ map_netlogon_samlogon_response(&response->data.samlogon);
- torture_assert_int_equal(tctx, response->samlogon.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE, "Got incorrect netlogon response command");
+ torture_assert_int_equal(tctx, response->data.samlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE, "Got incorrect netlogon response command");
dgmslot->private = NULL;
torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
torture_assert_int_equal(tctx, response->response_type, NETLOGON_SAMLOGON, "Got incorrect type of netlogon response");
- map_netlogon_samlogon_response(&response->samlogon);
+ map_netlogon_samlogon_response(&response->data.samlogon);
- torture_assert_int_equal(tctx, response->samlogon.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN, "Got incorrect netlogon response command");
+ torture_assert_int_equal(tctx, response->data.samlogon.data.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN, "Got incorrect netlogon response command");
torture_leave_domain(tctx, join_ctx);
return true;
torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
torture_assert_int_equal(tctx, response->response_type, NETLOGON_SAMLOGON, "Got incorrect type of netlogon response");
- map_netlogon_samlogon_response(&response->samlogon);
+ map_netlogon_samlogon_response(&response->data.samlogon);
- torture_assert_int_equal(tctx, response->samlogon.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE, "Got incorrect netlogon response command");
+ torture_assert_int_equal(tctx, response->data.samlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE, "Got incorrect netlogon response command");
- torture_assert_str_equal(tctx, response->samlogon.nt5_ex.user_name, TEST_NAME"$", "Got incorrect user in netlogon response");
+ torture_assert_str_equal(tctx, response->data.samlogon.data.nt5_ex.user_name, TEST_NAME"$", "Got incorrect user in netlogon response");
/* setup a temporary mailslot listener for replies */
torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
torture_assert_int_equal(tctx, response->response_type, NETLOGON_SAMLOGON, "Got incorrect type of netlogon response");
- map_netlogon_samlogon_response(&response->samlogon);
+ map_netlogon_samlogon_response(&response->data.samlogon);
- torture_assert_int_equal(tctx, response->samlogon.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE, "Got incorrect netlogon response command");
+ torture_assert_int_equal(tctx, response->data.samlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE, "Got incorrect netlogon response command");
- torture_assert_str_equal(tctx, response->samlogon.nt5_ex.user_name, TEST_NAME"$", "Got incorrect user in netlogon response");
+ torture_assert_str_equal(tctx, response->data.samlogon.data.nt5_ex.user_name, TEST_NAME"$", "Got incorrect user in netlogon response");
/* setup (another) temporary mailslot listener for replies */
torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
torture_assert_int_equal(tctx, response->response_type, NETLOGON_GET_PDC, "Got incorrect type of ntlogon response");
- torture_assert_int_equal(tctx, response->get_pdc.command, NETLOGON_RESPONSE_FROM_PDC, "Got incorrect ntlogon response command");
+ torture_assert_int_equal(tctx, response->data.get_pdc.command, NETLOGON_RESPONSE_FROM_PDC, "Got incorrect ntlogon response command");
torture_leave_domain(tctx, join_ctx);
torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
torture_assert_int_equal(tctx, response->response_type, NETLOGON_GET_PDC, "Got incorrect type of ntlogon response");
- torture_assert_int_equal(tctx, response->get_pdc.command, NETLOGON_RESPONSE_FROM_PDC, "Got incorrect ntlogon response command");
+ torture_assert_int_equal(tctx, response->data.get_pdc.command, NETLOGON_RESPONSE_FROM_PDC, "Got incorrect ntlogon response command");
return true;
*/
#include "includes.h"
-#include "libcli/nbt/libnbt.h"
+#include "../libcli/nbt/libnbt.h"
#include "torture/torture.h"
#include "torture/nbt/proto.h"
#include "torture/smbtorture.h"
static void increment_handler(struct nbt_name_request *req)
{
- struct result_struct *v = talloc_get_type(req->async.private, struct result_struct);
+ struct result_struct *v = talloc_get_type(req->async.private_data, struct result_struct);
if (req->state != NBT_REQUEST_DONE) {
v->num_fail++;
} else {
req = nbt_name_query_send(nbtsock, &io);
torture_assert(tctx, req != NULL, "Failed to setup request!");
req->async.fn = increment_handler;
- req->async.private = result;
+ req->async.private_data = result;
num_sent++;
if (num_sent % 1000 == 0) {
if (torture_setting_bool(tctx, "progress", true)) {
static void register_handler(struct nbt_name_request *req)
{
- struct idx_state *istate = talloc_get_type(req->async.private, struct idx_state);
+ struct idx_state *istate = talloc_get_type(req->async.private_data, struct idx_state);
struct wins_state *state = istate->state;
struct nbt_name_register io;
NTSTATUS status;
req = nbt_name_register_send(nbtsock, &io);
req->async.fn = register_handler;
- req->async.private = istate;
+ req->async.private_data = istate;
talloc_free(tmp_ctx);
}
static void release_handler(struct nbt_name_request *req)
{
- struct idx_state *istate = talloc_get_type(req->async.private, struct idx_state);
+ struct idx_state *istate = talloc_get_type(req->async.private_data, struct idx_state);
struct wins_state *state = istate->state;
struct nbt_name_release io;
NTSTATUS status;
req = nbt_name_release_send(nbtsock, &io);
req->async.fn = release_handler;
- req->async.private = istate;
+ req->async.private_data = istate;
talloc_free(tmp_ctx);
}
static void query_handler(struct nbt_name_request *req)
{
- struct idx_state *istate = talloc_get_type(req->async.private, struct idx_state);
+ struct idx_state *istate = talloc_get_type(req->async.private_data, struct idx_state);
struct wins_state *state = istate->state;
struct nbt_name_query io;
NTSTATUS status;
req = nbt_name_query_send(nbtsock, &io);
req->async.fn = query_handler;
- req->async.private = istate;
+ req->async.private_data = istate;
talloc_free(tmp_ctx);
}
struct nbt_name *name;
struct nbt_name_packet *rep_packet;
struct test_conflict_owned_active_vs_replica_struct *rec =
- (struct test_conflict_owned_active_vs_replica_struct *)nbtsock->incoming.private;
+ (struct test_conflict_owned_active_vs_replica_struct *)nbtsock->incoming.private_data;
_NBT_ASSERT(req_packet->qdcount, 1);
_NBT_ASSERT(req_packet->questions[0].question_type, NBT_QTYPE_NETBIOS);
struct nbt_name *name;
struct nbt_name_packet *rep_packet;
struct test_conflict_owned_active_vs_replica_struct *rec =
- (struct test_conflict_owned_active_vs_replica_struct *)nbtsock->incoming.private;
+ (struct test_conflict_owned_active_vs_replica_struct *)nbtsock->incoming.private_data;
_NBT_ASSERT(req_packet->qdcount, 1);
_NBT_ASSERT(req_packet->questions[0].question_type, NBT_QTYPE_NETBIOS);
struct socket_address *src)
{
struct test_conflict_owned_active_vs_replica_struct *rec =
- (struct test_conflict_owned_active_vs_replica_struct *)nbtsock->incoming.private;
+ (struct test_conflict_owned_active_vs_replica_struct *)nbtsock->incoming.private_data;
rec->defend.ret = false;
torture_assert_str_equal(tctx, r->in.names[1].string, "Administrators",
"names[1]");
torture_assert_int_equal(tctx, r->in.level, 1, "level");
- torture_assert_int_equal(tctx, r->in.unknown1, 0, "unknown 1");
- torture_assert_int_equal(tctx, r->in.unknown2, 0, "unknown 2");
+ torture_assert_int_equal(tctx, r->in.lookup_options, 0, "lookup_options");
+ torture_assert_int_equal(tctx, r->in.client_revision, 0, "client_revision");
torture_assert_int_equal(tctx, *r->in.count, 0, "count");
torture_assert_int_equal(tctx, r->in.sids->count, 0, "sids count");
torture_assert(tctx, r->in.sids->sids == NULL, "sids sids");
torture_assert_str_equal(tctx, r->in.names[1].string, "Administrators",
"names[1]");
torture_assert_int_equal(tctx, r->in.level, 1, "level");
- torture_assert_int_equal(tctx, r->in.unknown1, 0, "unknown 1");
- torture_assert_int_equal(tctx, r->in.unknown2, 0, "unknown 2");
+ torture_assert_int_equal(tctx, r->in.lookup_options, 0, "lookup_options");
+ torture_assert_int_equal(tctx, r->in.client_revision, 0, "client_revision");
torture_assert_int_equal(tctx, *r->in.count, 0, "count");
torture_assert_int_equal(tctx, r->in.sids->count, 0, "sids count");
torture_assert(tctx, r->in.sids->sids == NULL, "sids sids");
}
ret &= test_path_ex(cli, tctx, BASEDIR, BASEDIR, NT_STATUS_OK, NT_STATUS_OK);
- ret &= test_path_ex(cli, tctx, ((char *)BASEDIR) + 1, BASEDIR, NT_STATUS_OK, NT_STATUS_OK);
- ret &= test_path_ex(cli, tctx, ((char *)BASEDIR"\\\\") + 1, BASEDIR, NT_STATUS_OK, NT_STATUS_OK);
- ret &= test_path_ex(cli, tctx, ((char *)BASEDIR"\\foo\\..") + 1, BASEDIR, NT_STATUS_OK, NT_STATUS_OK);
- ret &= test_path_ex(cli, tctx, ((char *)BASEDIR"\\f\\o\\o\\..\\..\\..") + 1, BASEDIR, NT_STATUS_OK, NT_STATUS_OK);
- ret &= test_path_ex(cli, tctx, ((char *)BASEDIR"\\foo\\\\..\\\\") + 1, BASEDIR, NT_STATUS_OK, NT_STATUS_OK);
+ ret &= test_path_ex(cli, tctx, ((const char *)BASEDIR) + 1, BASEDIR, NT_STATUS_OK, NT_STATUS_OK);
+ ret &= test_path_ex(cli, tctx, ((const char *)BASEDIR"\\\\") + 1, BASEDIR, NT_STATUS_OK, NT_STATUS_OK);
+ ret &= test_path_ex(cli, tctx, ((const char *)BASEDIR"\\foo\\..") + 1, BASEDIR, NT_STATUS_OK, NT_STATUS_OK);
+ ret &= test_path_ex(cli, tctx, ((const char *)BASEDIR"\\f\\o\\o\\..\\..\\..") + 1, BASEDIR, NT_STATUS_OK, NT_STATUS_OK);
+ ret &= test_path_ex(cli, tctx, ((const char *)BASEDIR"\\foo\\\\..\\\\") + 1, BASEDIR, NT_STATUS_OK, NT_STATUS_OK);
ret &= test_path_ex(cli, tctx, BASEDIR"\\", BASEDIR, NT_STATUS_OK, NT_STATUS_OK);
ret &= test_path_ex(cli, tctx, BASEDIR"\\\\..\\"BASEDIR, BASEDIR, NT_STATUS_OK, NT_STATUS_OK);
ret &= test_path_ex(cli, tctx, BASEDIR"\\\\\\", BASEDIR, NT_STATUS_OK, NT_STATUS_OK);
io2.in.filename = fname;
io2.in.resolve_ctx = lp_resolve_context(tctx->lp_ctx);
lp_smbcli_options(tctx->lp_ctx, &io2.in.options);
+ lp_smbcli_session_options(tctx->lp_ctx, &io2.in.session_options);
printf("testing parallel fetchfile with %d ops\n", torture_numops);
c = talloc_array(tctx, struct composite_context *, torture_numops);
for (i=0; i<torture_numops; i++) {
- c[i] = smb_composite_fsinfo_send(cli->tree,&io1);
+ c[i] = smb_composite_fsinfo_send(cli->tree, &io1, lp_resolve_context(tctx->lp_ctx));
c[i]->async.fn = loadfile_complete;
c[i]->async.private_data = count;
}
const char *fname = BASEDIR "\\test.txt";
uint8_t c = 1;
int i;
+ struct smbcli_session_options options;
printf("TESTING SESSION HANDLING\n");
}
printf("create a second security context on the same transport\n");
- session = smbcli_session_init(cli->transport, tctx, false);
+
+ lp_smbcli_session_options(tctx->lp_ctx, &options);
+
+ session = smbcli_session_init(cli->transport, tctx, false, options);
setup.in.sesskey = cli->transport->negotiate.sesskey;
setup.in.capabilities = cli->transport->negotiate.capabilities; /* ignored in secondary session setup, except by our libs, which care about the extended security bit */
session->vuid = setup.out.vuid;
printf("create a third security context on the same transport, with vuid set\n");
- session2 = smbcli_session_init(cli->transport, tctx, false);
+ session2 = smbcli_session_init(cli->transport, tctx, false, options);
session2->vuid = session->vuid;
setup.in.sesskey = cli->transport->negotiate.sesskey;
if (cli->transport->negotiate.capabilities & CAP_EXTENDED_SECURITY) {
printf("create a fourth security context on the same transport, without extended security\n");
- session3 = smbcli_session_init(cli->transport, tctx, false);
+ session3 = smbcli_session_init(cli->transport, tctx, false, options);
session3->vuid = session->vuid;
setup.in.sesskey = cli->transport->negotiate.sesskey;
CHECK_STATUS(status, NT_STATUS_LOGON_FAILURE);
printf("create a fouth anonymous security context on the same transport, without extended security\n");
- session4 = smbcli_session_init(cli->transport, tctx, false);
+ session4 = smbcli_session_init(cli->transport, tctx, false, options);
session4->vuid = session->vuid;
setup.in.sesskey = cli->transport->negotiate.sesskey;
setups[i].in.credentials = cmdline_credentials;
- sessions[i] = smbcli_session_init(cli->transport, tctx, false);
+ sessions[i] = smbcli_session_init(cli->transport, tctx, false, options);
composite_contexts[i] = smb_composite_sesssetup_send(sessions[i], &setups[i]);
}
const char *fname1 = BASEDIR "\\test1.txt";
const char *fname2 = BASEDIR "\\test2.txt";
uint8_t c = 1;
+ struct smbcli_session_options options;
printf("TESTING TREE with ulogoff\n");
share = torture_setting_string(tctx, "share", NULL);
host = torture_setting_string(tctx, "host", NULL);
+ lp_smbcli_session_options(tctx->lp_ctx, &options);
+
printf("create the first new sessions\n");
- session1 = smbcli_session_init(cli->transport, tctx, false);
+ session1 = smbcli_session_init(cli->transport, tctx, false, options);
setup.in.sesskey = cli->transport->negotiate.sesskey;
setup.in.capabilities = cli->transport->negotiate.capabilities;
setup.in.workgroup = lp_workgroup(tctx->lp_ctx);
CHECK_STATUS(status, NT_STATUS_OK);
printf("create the second new sessions\n");
- session2 = smbcli_session_init(cli->transport, tctx, false);
+ session2 = smbcli_session_init(cli->transport, tctx, false, options);
setup.in.sesskey = cli->transport->negotiate.sesskey;
setup.in.capabilities = cli->transport->negotiate.capabilities;
setup.in.workgroup = lp_workgroup(tctx->lp_ctx);
const char *fname = BASEDIR "\\test.txt";
uint8_t c = 1;
uint16_t vuid1, vuid2;
+ struct smbcli_session_options options;
printf("TESTING PID HANDLING WITH 2 SESSIONS\n");
return false;
}
+ lp_smbcli_session_options(tctx->lp_ctx, &options);
+
printf("create a second security context on the same transport\n");
- session = smbcli_session_init(cli->transport, tctx, false);
+ session = smbcli_session_init(cli->transport, tctx, false, options);
setup.in.sesskey = cli->transport->negotiate.sesskey;
setup.in.capabilities = cli->transport->negotiate.capabilities; /* ignored in secondary session setup, except by our libs, which care about the extended security bit */
const char *fname = BASEDIR "\\test.txt";
time_t t;
struct smbcli_request *req;
+ struct smbcli_session_options options;
if (!torture_setup_dir(cli, BASEDIR)) {
return false;
}
+ lp_smbcli_session_options(tctx->lp_ctx, &options);
+
printf("Testing LOCKING_ANDX_CANCEL_LOCK\n");
io.generic.level = RAW_LOCK_LOCKX;
}
printf("create a new sessions\n");
- session = smbcli_session_init(cli->transport, tctx, false);
+ session = smbcli_session_init(cli->transport, tctx, false, options);
setup.in.sesskey = cli->transport->negotiate.sesskey;
setup.in.capabilities = cli->transport->negotiate.capabilities;
setup.in.workgroup = lp_workgroup(tctx->lp_ctx);
io->in.fallback_to_anonymous = false;
io->in.workgroup = lp_workgroup(state->tctx->lp_ctx);
lp_smbcli_options(state->tctx->lp_ctx, &io->in.options);
+ lp_smbcli_session_options(state->tctx->lp_ctx, &io->in.session_options);
/* kill off the remnants of the old connection */
talloc_free(state->tree);
notify.nttrans.in.buffer_size = 1000;
notify.nttrans.in.recursive = true;
-#define NOTIFY_MASK_TEST(setup, op, cleanup, Action, expected, nchanges) \
+#define NOTIFY_MASK_TEST(test_name, setup, op, cleanup, Action, expected, nchanges) \
+ do { \
+ smbcli_getatr(cli->tree, test_name, NULL, NULL, NULL); \
do { for (mask=i=0;i<32;i++) { \
struct smbcli_request *req; \
status = smb_raw_open(cli->tree, tctx, &io); \
mask, expected); \
} \
} \
- } while (0)
+ } while (0); \
+ } while (0);
printf("testing mkdir\n");
- NOTIFY_MASK_TEST(;,
+ NOTIFY_MASK_TEST("testing mkdir",;,
smbcli_mkdir(cli->tree, BASEDIR "\\tname1");,
smbcli_rmdir(cli->tree, BASEDIR "\\tname1");,
NOTIFY_ACTION_ADDED,
FILE_NOTIFY_CHANGE_DIR_NAME, 1);
printf("testing create file\n");
- NOTIFY_MASK_TEST(;,
+ NOTIFY_MASK_TEST("testing create file",;,
smbcli_close(cli->tree, smbcli_open(cli->tree, BASEDIR "\\tname1", O_CREAT, 0));,
smbcli_unlink(cli->tree, BASEDIR "\\tname1");,
NOTIFY_ACTION_ADDED,
FILE_NOTIFY_CHANGE_FILE_NAME, 1);
printf("testing unlink\n");
- NOTIFY_MASK_TEST(
+ NOTIFY_MASK_TEST("testing unlink",
smbcli_close(cli->tree, smbcli_open(cli->tree, BASEDIR "\\tname1", O_CREAT, 0));,
smbcli_unlink(cli->tree, BASEDIR "\\tname1");,
;,
FILE_NOTIFY_CHANGE_FILE_NAME, 1);
printf("testing rmdir\n");
- NOTIFY_MASK_TEST(
+ NOTIFY_MASK_TEST("testing rmdir",
smbcli_mkdir(cli->tree, BASEDIR "\\tname1");,
smbcli_rmdir(cli->tree, BASEDIR "\\tname1");,
;,
FILE_NOTIFY_CHANGE_DIR_NAME, 1);
printf("testing rename file\n");
- NOTIFY_MASK_TEST(
+ NOTIFY_MASK_TEST("testing rename file",
smbcli_close(cli->tree, smbcli_open(cli->tree, BASEDIR "\\tname1", O_CREAT, 0));,
smbcli_rename(cli->tree, BASEDIR "\\tname1", BASEDIR "\\tname2");,
smbcli_unlink(cli->tree, BASEDIR "\\tname2");,
FILE_NOTIFY_CHANGE_FILE_NAME|FILE_NOTIFY_CHANGE_ATTRIBUTES|FILE_NOTIFY_CHANGE_CREATION, 2);
printf("testing rename dir\n");
- NOTIFY_MASK_TEST(
+ NOTIFY_MASK_TEST("testing rename dir",
smbcli_mkdir(cli->tree, BASEDIR "\\tname1");,
smbcli_rename(cli->tree, BASEDIR "\\tname1", BASEDIR "\\tname2");,
smbcli_rmdir(cli->tree, BASEDIR "\\tname2");,
FILE_NOTIFY_CHANGE_DIR_NAME, 2);
printf("testing set path attribute\n");
- NOTIFY_MASK_TEST(
+ NOTIFY_MASK_TEST("testing set path attribute",
smbcli_close(cli->tree, smbcli_open(cli->tree, BASEDIR "\\tname1", O_CREAT, 0));,
smbcli_setatr(cli->tree, BASEDIR "\\tname1", FILE_ATTRIBUTE_HIDDEN, 0);,
smbcli_unlink(cli->tree, BASEDIR "\\tname1");,
FILE_NOTIFY_CHANGE_ATTRIBUTES, 1);
printf("testing set path write time\n");
- NOTIFY_MASK_TEST(
+ NOTIFY_MASK_TEST("testing set path write time",
smbcli_close(cli->tree, smbcli_open(cli->tree, BASEDIR "\\tname1", O_CREAT, 0));,
smbcli_setatr(cli->tree, BASEDIR "\\tname1", FILE_ATTRIBUTE_NORMAL, 1000);,
smbcli_unlink(cli->tree, BASEDIR "\\tname1");,
FILE_NOTIFY_CHANGE_LAST_WRITE, 1);
printf("testing set file attribute\n");
- NOTIFY_MASK_TEST(
+ NOTIFY_MASK_TEST("testing set file attribute",
fnum2 = create_complex_file(cli, tctx, BASEDIR "\\tname1");,
smbcli_fsetatr(cli->tree, fnum2, FILE_ATTRIBUTE_HIDDEN, 0, 0, 0, 0);,
(smbcli_close(cli->tree, fnum2), smbcli_unlink(cli->tree, BASEDIR "\\tname1"));,
}
else {
printf("testing set file create time\n");
- NOTIFY_MASK_TEST(
+ NOTIFY_MASK_TEST("testing set file create time",
fnum2 = create_complex_file(cli, tctx,
BASEDIR "\\tname1");,
smbcli_fsetatr(cli->tree, fnum2, 0, t, 0, 0, 0);,
}
printf("testing set file access time\n");
- NOTIFY_MASK_TEST(
+ NOTIFY_MASK_TEST("testing set file access time",
fnum2 = create_complex_file(cli, tctx, BASEDIR "\\tname1");,
smbcli_fsetatr(cli->tree, fnum2, 0, 0, t, 0, 0);,
(smbcli_close(cli->tree, fnum2), smbcli_unlink(cli->tree, BASEDIR "\\tname1"));,
FILE_NOTIFY_CHANGE_LAST_ACCESS, 1);
printf("testing set file write time\n");
- NOTIFY_MASK_TEST(
+ NOTIFY_MASK_TEST("testing set file write time",
fnum2 = create_complex_file(cli, tctx, BASEDIR "\\tname1");,
smbcli_fsetatr(cli->tree, fnum2, 0, 0, 0, t, 0);,
(smbcli_close(cli->tree, fnum2), smbcli_unlink(cli->tree, BASEDIR "\\tname1"));,
FILE_NOTIFY_CHANGE_LAST_WRITE, 1);
printf("testing set file change time\n");
- NOTIFY_MASK_TEST(
+ NOTIFY_MASK_TEST("testing set file change time",
fnum2 = create_complex_file(cli, tctx, BASEDIR "\\tname1");,
smbcli_fsetatr(cli->tree, fnum2, 0, 0, 0, 0, t);,
(smbcli_close(cli->tree, fnum2), smbcli_unlink(cli->tree, BASEDIR "\\tname1"));,
printf("testing write\n");
- NOTIFY_MASK_TEST(
+ NOTIFY_MASK_TEST("testing write",
fnum2 = create_complex_file(cli, tctx, BASEDIR "\\tname1");,
smbcli_write(cli->tree, fnum2, 1, &c, 10000, 1);,
(smbcli_close(cli->tree, fnum2), smbcli_unlink(cli->tree, BASEDIR "\\tname1"));,
0, 1);
printf("testing truncate\n");
- NOTIFY_MASK_TEST(
+ NOTIFY_MASK_TEST("testing truncate",
fnum2 = create_complex_file(cli, tctx, BASEDIR "\\tname1");,
smbcli_ftruncate(cli->tree, fnum2, 10000);,
(smbcli_close(cli->tree, fnum2), smbcli_unlink(cli->tree, BASEDIR "\\tname1"));,
return ret;
}
+/*
+ test opening for delete on a read-only attribute file.
+*/
+static bool test_open_for_delete(struct smbcli_state *cli, struct torture_context *tctx)
+{
+ union smb_open io;
+ union smb_fileinfo finfo;
+ const char *fname = BASEDIR "\\torture_open_for_delete.txt";
+ NTSTATUS status;
+ int fnum = -1;
+ bool ret = true;
+
+ printf("Checking RAW_NTCREATEX for delete on a readonly file.\n");
+
+ /* reasonable default parameters */
+ io.generic.level = RAW_OPEN_NTCREATEX;
+ io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED;
+ io.ntcreatex.in.root_fid = 0;
+ io.ntcreatex.in.alloc_size = 0;
+ io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
+ io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_READONLY;
+ io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
+ io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;
+ io.ntcreatex.in.create_options = 0;
+ io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
+ io.ntcreatex.in.security_flags = 0;
+ io.ntcreatex.in.fname = fname;
+
+ /* Create the readonly file. */
+
+ status = smb_raw_open(cli->tree, tctx, &io);
+ CHECK_STATUS(status, NT_STATUS_OK);
+ fnum = io.ntcreatex.out.file.fnum;
+
+ CHECK_VAL(io.ntcreatex.out.oplock_level, 0);
+ io.ntcreatex.in.create_options = 0;
+ CHECK_VAL(io.ntcreatex.out.create_action, NTCREATEX_ACTION_CREATED);
+ CHECK_ALL_INFO(io.ntcreatex.out.attrib, attrib);
+ smbcli_close(cli->tree, fnum);
+
+ /* Now try and open for delete only - should succeed. */
+ io.ntcreatex.in.access_mask = SEC_STD_DELETE;
+ io.ntcreatex.in.file_attr = 0;
+ io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE | NTCREATEX_SHARE_ACCESS_DELETE;
+ io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
+ status = smb_raw_open(cli->tree, tctx, &io);
+ CHECK_STATUS(status, NT_STATUS_OK);
+
+ smbcli_unlink(cli->tree, fname);
+
+done:
+ smbcli_close(cli->tree, fnum);
+ smbcli_unlink(cli->tree, fname);
+
+ return ret;
+}
+
+
/* basic testing of all RAW_OPEN_* calls
*/
bool torture_raw_open(struct torture_context *torture, struct smbcli_state *cli)
ret &= test_ctemp(cli, torture);
ret &= test_chained(cli, torture);
ret &= test_no_leading_slash(cli, torture);
+ ret &= test_open_for_delete(cli, torture);
smb_raw_exit(cli->session);
smbcli_deltree(cli->tree, BASEDIR);
io->in.fallback_to_anonymous = false;
io->in.workgroup = lp_workgroup(state->tctx->lp_ctx);
lp_smbcli_options(state->tctx->lp_ctx, &io->in.options);
+ lp_smbcli_session_options(state->tctx->lp_ctx, &io->in.session_options);
/* kill off the remnants of the old connection */
talloc_free(state->tree);
struct smbcli_state **c)
{
NTSTATUS status;
-
struct smbcli_options options;
+ struct smbcli_session_options session_options;
lp_smbcli_options(tctx->lp_ctx, &options);
+ lp_smbcli_session_options(tctx->lp_ctx, &session_options);
options.use_level2_oplocks = false;
torture_setting_string(tctx, "share", NULL),
NULL, cmdline_credentials,
lp_resolve_context(tctx->lp_ctx),
- tctx->ev, &options);
+ tctx->ev, &options, &session_options);
if (!NT_STATUS_IS_OK(status)) {
printf("Failed to open connection - %s\n", nt_errstr(status));
return false;
struct timeval end;
struct timeval now;
struct smbcli_options options;
+ struct smbcli_session_options session_options;
lp_smbcli_options(tctx->lp_ctx, &options);
+ lp_smbcli_session_options(tctx->lp_ctx, &session_options);
child = fork();
if (child == -1) {
host, lp_smb_ports(tctx->lp_ctx), share,
NULL, cmdline_credentials,
lp_resolve_context(tctx->lp_ctx),
- tctx->ev, &options);
+ tctx->ev, &options, &session_options);
if (!NT_STATUS_IS_OK(status)) {
printf("failed to connect to //%s/%s: %s\n",
bool ret = true;
struct drsuapi_DsCrackNames r;
enum drsuapi_DsNameFormat formats[] = {
+ DRSUAPI_DS_NAME_FORMAT_UNKNOWN,
DRSUAPI_DS_NAME_FORMAT_FQDN_1779,
DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT,
DRSUAPI_DS_NAME_FORMAT_DISPLAY,
#include "torture/torture.h"
#include "torture/ldap/proto.h"
#include "libcli/auth/libcli_auth.h"
-#include "lib/crypto/crypto.h"
+#include "../lib/crypto/crypto.h"
#include "auth/credentials/credentials.h"
#include "libcli/auth/libcli_auth.h"
#include "auth/gensec/gensec.h"
ctx->site_name = talloc_asprintf(ctx, "%s", "Default-First-Site-Name");
printf("cldap_netlogon() returned %s. Defaulting to Site-Name: %s\n", errstr, ctx->site_name);
} else {
- ctx->site_name = talloc_steal(ctx, search.out.netlogon.nt5_ex.client_site);
+ ctx->site_name = talloc_steal(ctx, search.out.netlogon.data.nt5_ex.client_site);
printf("cldap_netlogon() returned Client Site-Name: %s.\n",ctx->site_name);
- printf("cldap_netlogon() returned Server Site-Name: %s.\n",search.out.netlogon.nt5_ex.server_site);
+ printf("cldap_netlogon() returned Server Site-Name: %s.\n",search.out.netlogon.data.nt5_ex.server_site);
}
if (!ctx->domain_dn) {
struct ldb_context *ldb = ldb_init(ctx, tctx->ev);
- struct ldb_dn *dn = samdb_dns_domain_to_dn(ldb, ctx, search.out.netlogon.nt5_ex.dns_domain);
+ struct ldb_dn *dn = samdb_dns_domain_to_dn(ldb, ctx, search.out.netlogon.data.nt5_ex.dns_domain);
ctx->domain_dn = ldb_dn_alloc_linearized(ctx, dn);
talloc_free(dn);
talloc_free(ldb);
struct smbcli_state *cli;
const char *host = torture_setting_string(torture, "host", NULL);
struct smbcli_options options;
+ struct smbcli_session_options session_options;
/* Join domain as a member server. */
tj = torture_join_domain(torture,
}
lp_smbcli_options(torture->lp_ctx, &options);
+ lp_smbcli_session_options(torture->lp_ctx, &session_options);
status = smbcli_full_connection(tj, &cli, host,
lp_smb_ports(torture->lp_ctx),
"IPC$", NULL,
machine_account,
lp_resolve_context(torture->lp_ctx),
- torture->ev, &options);
+ torture->ev, &options, &session_options);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0, ("%s failed to connect to IPC$ with workstation credentials\n",
TORTURE_NETBIOS_NAME));
"IPC$", NULL,
machine_account,
lp_resolve_context(torture->lp_ctx),
- torture->ev, &options);
+ torture->ev, &options, &session_options);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0, ("%s failed to connect to IPC$ with workstation credentials\n",
TORTURE_NETBIOS_NAME));
#include "libcli/auth/libcli_auth.h"
#include "torture/rpc/rpc.h"
#include "param/param.h"
-#include "lib/crypto/crypto.h"
+#include "../lib/crypto/crypto.h"
#define TEST_MACHINENAME "lsatestmach"
static void init_lsa_String(struct lsa_String *name, const char *s)
NTSTATUS status;
int i;
- struct lsa_TranslatedName name;
+ struct lsa_TranslatedName name[2];
struct lsa_TransNameArray tnames;
- tnames.names = &name;
- tnames.count = 1;
- name.name.string = "NT AUTHORITY\\BOGUS";
+ tnames.names = name;
+ tnames.count = 2;
+ name[0].name.string = "NT AUTHORITY\\BOGUS";
+ name[1].name.string = NULL;
printf("\nTesting LookupNames with bogus names\n");
r.in.sids = &sids;
r.in.level = 1;
r.in.count = &count;
- r.in.unknown1 = 0;
- r.in.unknown2 = 0;
+ r.in.lookup_options = 0;
+ r.in.client_revision = 0;
r.out.count = &count;
r.out.sids = &sids;
r.in.sids = &sids;
r.in.level = 1;
r.in.count = &count;
- r.in.unknown1 = 0;
- r.in.unknown2 = 0;
+ r.in.lookup_options = 0;
+ r.in.client_revision = 0;
r.out.count = &count;
r.out.sids = &sids;
r.in.sids = &sids;
r.in.level = 1;
r.in.count = &count;
- r.in.unknown1 = 0;
- r.in.unknown2 = 0;
+ r.in.lookup_options = 0;
+ r.in.client_revision = 0;
r.out.count = &count;
r.out.sids = &sids;
/* NO_MORE_ENTRIES is allowed */
if (NT_STATUS_EQUAL(enum_status, NT_STATUS_NO_MORE_ENTRIES)) {
- return true;
+ if (domains.count == 0) {
+ return true;
+ }
+ printf("EnumTrustDom failed - should have returned 0 trusted domains with 'NT_STATUS_NO_MORE_ENTRIES'\n");
+ return false;
} else if (NT_STATUS_EQUAL(enum_status, STATUS_MORE_ENTRIES)) {
/* Windows 2003 gets this off by one on the first run */
if (r.out.domains->count < 3 || r.out.domains->count > 4) {
/* NO_MORE_ENTRIES is allowed */
if (NT_STATUS_EQUAL(enum_status, NT_STATUS_NO_MORE_ENTRIES)) {
- return true;
+ if (domains_ex.count == 0) {
+ return true;
+ }
+ printf("EnumTrustDomainsEx failed - should have returned 0 trusted domains with 'NT_STATUS_NO_MORE_ENTRIES'\n");
+ return false;
} else if (NT_STATUS_EQUAL(enum_status, STATUS_MORE_ENTRIES)) {
/* Windows 2003 gets this off by one on the first run */
if (r_ex.out.domains->count < 3 || r_ex.out.domains->count > 4) {
struct lsa_CreateTrustedDomainEx2 r;
struct lsa_TrustDomainInfoInfoEx trustinfo;
struct lsa_TrustDomainInfoAuthInfoInternal authinfo;
- struct trustAuthInAndOutBlob auth_struct;
+ struct trustDomainPasswords auth_struct;
DATA_BLOB auth_blob;
struct dom_sid *domsid[12];
struct policy_handle trustdom_handle[12];
/* Try different trust types too */
- /* 1 == downleven (NT4), 2 == uplevel (ADS), 3 == MIT (kerberos but not AD) */
+ /* 1 == downlevel (NT4), 2 == uplevel (ADS), 3 == MIT (kerberos but not AD) */
trustinfo.trust_type = (((i / 3) + 1) % 3) + 1;
trustinfo.trust_attributes = LSA_TRUST_ATTRIBUTE_USES_RC4_ENCRYPTION;
auth_struct.incoming.count = 0;
ndr_err = ndr_push_struct_blob(&auth_blob, mem_ctx, lp_iconv_convenience(tctx->lp_ctx), &auth_struct,
- (ndr_push_flags_fn_t)ndr_push_trustAuthInAndOutBlob);
+ (ndr_push_flags_fn_t)ndr_push_trustDomainPasswords);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
- printf("ndr_push_struct_blob of trustAuthInAndOutBlob structure failed");
+ printf("ndr_push_struct_blob of trustDomainPasswords structure failed");
ret = false;
}
printf("QueryTrustedDomainInfo level 1 failed - %s\n", nt_errstr(status));
ret = false;
} else if (!q.out.info) {
+ printf("QueryTrustedDomainInfo level 1 failed to return an info pointer\n");
ret = false;
} else {
if (strcmp(q.out.info->info_ex.netbios_name.string, trustinfo.netbios_name.string) != 0) {
/* now that we have some domains to look over, we can test the enum calls */
if (!test_EnumTrustDom(p, mem_ctx, handle)) {
+ printf("test_EnumTrustDom failed\n");
ret = false;
}
for (i=0; i<12; i++) {
if (!test_DeleteTrustedDomainBySid(p, mem_ctx, handle, domsid[i])) {
+ printf("test_DeleteTrustedDomainBySid failed\n");
ret = false;
}
}
bool ret = true;
printf("\nTesting QueryInfoPolicy\n");
- for (i=1;i<13;i++) {
+ for (i=1;i<=13;i++) {
r.in.handle = handle;
r.in.level = i;
break;
case LSA_POLICY_INFO_DOMAIN:
case LSA_POLICY_INFO_ACCOUNT_DOMAIN:
+ case LSA_POLICY_INFO_DNS_INT:
case LSA_POLICY_INFO_DNS:
+ case LSA_POLICY_INFO_REPLICA:
+ case LSA_POLICY_INFO_QUOTA:
+ case LSA_POLICY_INFO_ROLE:
+ case LSA_POLICY_INFO_AUDIT_LOG:
+ case LSA_POLICY_INFO_AUDIT_EVENTS:
+ case LSA_POLICY_INFO_PD:
if (!NT_STATUS_IS_OK(status)) {
printf("QueryInfoPolicy failed - %s\n", nt_errstr(status));
ret = false;
break;
case LSA_POLICY_INFO_DOMAIN:
case LSA_POLICY_INFO_ACCOUNT_DOMAIN:
+ case LSA_POLICY_INFO_DNS_INT:
case LSA_POLICY_INFO_DNS:
+ case LSA_POLICY_INFO_REPLICA:
+ case LSA_POLICY_INFO_QUOTA:
+ case LSA_POLICY_INFO_ROLE:
+ case LSA_POLICY_INFO_AUDIT_LOG:
+ case LSA_POLICY_INFO_AUDIT_EVENTS:
+ case LSA_POLICY_INFO_PD:
if (!NT_STATUS_IS_OK(status)) {
printf("QueryInfoPolicy2 failed - %s\n", nt_errstr(status));
ret = false;
if (!join) {
ret = false;
}
-
if (!test_LookupNames_wellknown(p, tctx, handle)) {
ret = false;
}
if (!test_CreateSecret(p, tctx, handle)) {
ret = false;
}
-
if (!test_CreateTrustedDomain(p, tctx, handle)) {
ret = false;
}
torture_assert(tctx, creds_client_check(creds, &credentials3), "Credential chaining failed");
torture_comment(tctx, "negotiate_flags=0x%08x\n", negotiate_flags);
+
+ /* Prove that requesting a challenge again won't break it */
+ status = dcerpc_netr_ServerReqChallenge(p, tctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, "ServerReqChallenge");
*creds_out = creds;
return true;
q1.blob2.data = NULL;
q1.product.string = "product string";
- torture_comment(tctx, "Testing netr_uogonGetDomainInfo\n");
+ torture_comment(tctx, "Testing netr_LogonGetDomainInfo\n");
+
+ status = dcerpc_netr_LogonGetDomainInfo(p, tctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, "netr_LogonGetDomainInfo");
+ torture_assert(tctx, creds_client_check(creds, &a.cred), "Credential chaining failed");
+
+ torture_comment(tctx, "Testing netr_LogonGetDomainInfo 2nd call\n");
+ creds_client_authenticator(creds, &a);
status = dcerpc_netr_LogonGetDomainInfo(p, tctx, &r);
torture_assert_ntstatus_ok(tctx, status, "netr_LogonGetDomainInfo");
tcase = torture_suite_add_machine_rpc_iface_tcase(suite, "netlogon",
&ndr_table_netlogon, TEST_MACHINE_NAME);
+
torture_rpc_tcase_add_test(tcase, "LogonUasLogon", test_LogonUasLogon);
torture_rpc_tcase_add_test(tcase, "LogonUasLogoff", test_LogonUasLogoff);
torture_rpc_tcase_add_test_creds(tcase, "SamLogon", test_SamLogon);
--- /dev/null
+/*
+ Unix SMB/CIFS implementation.
+
+ test suite for behaviour of object uuids in rpc requests
+
+ Copyright (C) Stefan Metzmacher 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.
+
+ 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 "torture/torture.h"
+#include "librpc/gen_ndr/ndr_dssetup.h"
+#include "librpc/gen_ndr/ndr_dssetup_c.h"
+#include "librpc/gen_ndr/ndr_lsa.h"
+#include "librpc/gen_ndr/ndr_lsa_c.h"
+#include "torture/rpc/rpc.h"
+
+/*
+ this tests the send object uuids in the dcerpc request
+*/
+
+static bool test_random_uuid(struct torture_context *torture)
+{
+ NTSTATUS status;
+ struct dcerpc_pipe *p1, *p2;
+ struct rpc_request *req;
+ struct GUID uuid;
+ struct dssetup_DsRoleGetPrimaryDomainInformation r1;
+ struct lsa_GetUserName r2;
+ struct lsa_StringPointer authority_name_p;
+
+ torture_comment(torture, "RPC-OBJECTUUID-RANDOM\n");
+
+ status = torture_rpc_connection(torture, &p1, &ndr_table_dssetup);
+ torture_assert_ntstatus_ok(torture, status, "opening dsetup pipe1");
+
+ status = torture_rpc_connection(torture, &p2, &ndr_table_lsarpc);
+ torture_assert_ntstatus_ok(torture, status, "opening lsa pipe1");
+
+ uuid = GUID_random();
+
+ r1.in.level = DS_ROLE_BASIC_INFORMATION;
+ req = dcerpc_ndr_request_send(p1, &uuid,
+ &ndr_table_dssetup,
+ NDR_DSSETUP_DSROLEGETPRIMARYDOMAININFORMATION,
+ torture, &r1);
+ status = dcerpc_ndr_request_recv(req);
+ torture_assert_ntstatus_ok(torture, status, "DsRoleGetPrimaryDomainInformation failed");
+ torture_assert_werr_ok(torture, r1.out.result, "DsRoleGetPrimaryDomainInformation failed");
+
+ uuid = GUID_random();
+
+ r2.in.system_name = "\\";
+ r2.in.account_name = NULL;
+ r2.in.authority_name = &authority_name_p;
+ authority_name_p.string = NULL;
+
+ req = dcerpc_ndr_request_send(p2, &uuid,
+ &ndr_table_lsarpc,
+ NDR_LSA_GETUSERNAME,
+ torture, &r2);
+ status = dcerpc_ndr_request_recv(req);
+ torture_assert_ntstatus_ok(torture, status, "lsaClose failed");
+ torture_assert_ntstatus_ok(torture, r2.out.result, "lsaClose failed");
+
+ return true;
+}
+
+struct torture_suite *torture_rpc_object_uuid(TALLOC_CTX *mem_ctx)
+{
+ struct torture_suite *suite;
+ suite = torture_suite_create(mem_ctx, "OBJECTUUID");
+ torture_suite_add_simple_test(suite, "random-uuid", test_random_uuid);
+ return suite;
+}
TALLOC_CTX *tmp_ctx = talloc_new(tctx);
- int i;
-
torture_assert(tctx, tmp_ctx != NULL, "talloc_new() failed");
if (!test_SetupCredentials2(p, tctx, NETLOGON_NEG_AUTH2_ADS_FLAGS,
torture_assert_ntstatus_ok(tctx, status, "gensec_update (client) failed");
}
- if (client_to_server.length == 0) {
- break;
- }
-
status = gensec_update(gensec_server_context, tmp_ctx, client_to_server, &server_to_client);
if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {;
torture_assert_ntstatus_ok(tctx, status, "gensec_update (server) failed");
}
- if (server_to_client.length == 0) {
+ if (NT_STATUS_IS_OK(status)) {
break;
}
} while (1);
status = gensec_session_info(gensec_server_context, &session_info);
torture_assert_ntstatus_ok(tctx, status, "gensec_session_info failed");
- pac_wrapped_struct.MessageType = 0x3;
pac_wrapped_struct.ChecksumLength = session_info->server_info->pac_srv_sig.signature.length;
pac_wrapped_struct.SignatureType = session_info->server_info->pac_kdc_sig.type;
pac_wrapped_struct.SignatureLength = session_info->server_info->pac_kdc_sig.signature.length;
torture_assert(tctx, creds_client_check(creds, &r.out.return_authenticator->cred),
"Credential chaining failed");
- /* This will break message type, check that however we still get NT_STATUS_OK */
- for (i=0; i < 256; i++) {
- pac_wrapped_struct.MessageType = i;
- pac_wrapped_struct.ChecksumLength = session_info->server_info->pac_srv_sig.signature.length;
- pac_wrapped_struct.SignatureType = session_info->server_info->pac_kdc_sig.type;
- pac_wrapped_struct.SignatureLength = session_info->server_info->pac_kdc_sig.signature.length;
- pac_wrapped_struct.ChecksumAndSignature = payload
- = data_blob_talloc(tmp_ctx, NULL,
- pac_wrapped_struct.ChecksumLength
- + pac_wrapped_struct.SignatureLength);
- memcpy(&payload.data[0],
- session_info->server_info->pac_srv_sig.signature.data,
- pac_wrapped_struct.ChecksumLength);
- memcpy(&payload.data[pac_wrapped_struct.ChecksumLength],
- session_info->server_info->pac_kdc_sig.signature.data,
- pac_wrapped_struct.SignatureLength);
-
- ndr_err = ndr_push_struct_blob(&pac_wrapped, tmp_ctx, lp_iconv_convenience(tctx->lp_ctx), &pac_wrapped_struct,
- (ndr_push_flags_fn_t)ndr_push_PAC_Validate);
- torture_assert(tctx, NDR_ERR_CODE_IS_SUCCESS(ndr_err), "ndr_push_struct_blob of PACValidate structure failed");
-
- torture_assert(tctx, (creds->negotiate_flags & NETLOGON_NEG_ARCFOUR), "not willing to even try a PACValidate without RC4 encryption");
- creds_arcfour_crypt(creds, pac_wrapped.data, pac_wrapped.length);
-
- generic.length = pac_wrapped.length;
- generic.data = pac_wrapped.data;
-
- ZERO_STRUCT(auth2);
- creds_client_authenticator(creds, &auth);
- r.in.credential = &auth;
- r.in.return_authenticator = &auth2;
- r.in.logon_level = NetlogonGenericInformation;
- r.in.logon.generic = &generic;
- r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
- r.in.computer_name = cli_credentials_get_workstation(credentials);
- r.in.validation_level = NetlogonValidationGenericInfo2;
-
- status = dcerpc_netr_LogonSamLogon(p, tctx, &r);
-
- torture_assert_ntstatus_ok(tctx, status, "LogonSamLogon failed");
-
- torture_assert(tctx, creds_client_check(creds, &r.out.return_authenticator->cred),
- "Credential chaining failed");
- }
-
/* This will break the parsing nicely (even in the crypto wrapping), check we get INVALID_PARAMETER */
generic.length--;
torture_assert(tctx, creds_client_check(creds, &r.out.return_authenticator->cred),
"Credential chaining failed");
- pac_wrapped_struct.MessageType = 0x3;
pac_wrapped_struct.ChecksumLength = session_info->server_info->pac_srv_sig.signature.length;
pac_wrapped_struct.SignatureType = session_info->server_info->pac_kdc_sig.type;
torture_assert(tctx, creds_client_check(creds, &r.out.return_authenticator->cred),
"Credential chaining failed");
-
- pac_wrapped_struct.MessageType = 0x3;
pac_wrapped_struct.ChecksumLength = session_info->server_info->pac_srv_sig.signature.length;
pac_wrapped_struct.SignatureType = session_info->server_info->pac_kdc_sig.type;
pac_wrapped_struct.SignatureLength = session_info->server_info->pac_kdc_sig.signature.length;
torture_suite_add_suite(suite, torture_rpc_atsvc(suite));
torture_suite_add_suite(suite, torture_rpc_wkssvc(suite));
torture_suite_add_suite(suite, torture_rpc_handles(suite));
+ torture_suite_add_suite(suite, torture_rpc_object_uuid(suite));
torture_suite_add_suite(suite, torture_rpc_winreg(suite));
torture_suite_add_simple_test(suite, "SPOOLSS", torture_rpc_spoolss);
torture_suite_add_suite(suite, torture_rpc_spoolss_notify(suite));
#include "libcli/composite/composite.h"
#include "libcli/smb_composite/smb_composite.h"
#include "libcli/auth/libcli_auth.h"
-#include "lib/crypto/crypto.h"
+#include "../lib/crypto/crypto.h"
#include "auth/ntlmssp/ntlmssp.h"
#include "libcli/security/proto.h"
#include "param/param.h"
struct cli_credentials *anon_creds;
struct smb_composite_sesssetup setup;
struct smbcli_options options;
+ struct smbcli_session_options session_options;
mem_ctx = talloc_init("torture_bind_authcontext");
}
lp_smbcli_options(torture->lp_ctx, &options);
+ lp_smbcli_session_options(torture->lp_ctx, &session_options);
status = smbcli_full_connection(mem_ctx, &cli,
torture_setting_string(torture, "host", NULL),
lp_smb_ports(torture->lp_ctx),
"IPC$", NULL, cmdline_credentials,
lp_resolve_context(torture->lp_ctx),
- torture->ev, &options);
+ torture->ev, &options, &session_options);
if (!NT_STATUS_IS_OK(status)) {
d_printf("smbcli_full_connection failed: %s\n",
nt_errstr(status));
goto done;
}
- session2 = smbcli_session_init(cli->transport, mem_ctx, false);
+ session2 = smbcli_session_init(cli->transport, mem_ctx, false, session_options);
if (session2 == NULL) {
d_printf("smbcli_session_init failed\n");
goto done;
bool ret = false;
struct smbcli_state *cli;
struct smbcli_options options;
+ struct smbcli_session_options session_options;
mem_ctx = talloc_init("torture_bind_authcontext");
}
lp_smbcli_options(torture->lp_ctx, &options);
+ lp_smbcli_session_options(torture->lp_ctx, &session_options);
status = smbcli_full_connection(mem_ctx, &cli,
torture_setting_string(torture, "host", NULL),
lp_smb_ports(torture->lp_ctx),
"IPC$", NULL, cmdline_credentials,
lp_resolve_context(torture->lp_ctx),
- torture->ev, &options);
+ torture->ev, &options, &session_options);
if (!NT_STATUS_IS_OK(status)) {
d_printf("smbcli_full_connection failed: %s\n",
nt_errstr(status));
const char *wks_name;
int i;
struct smbcli_options options;
+ struct smbcli_session_options session_options;
wks_name = torture_setting_string(torture, "wksname", NULL);
if (wks_name == NULL) {
}
lp_smbcli_options(torture->lp_ctx, &options);
+ lp_smbcli_session_options(torture->lp_ctx, &session_options);
status = smbcli_full_connection(mem_ctx, &cli,
torture_setting_string(torture, "host", NULL),
lp_smb_ports(torture->lp_ctx),
"IPC$", NULL, anon_creds,
lp_resolve_context(torture->lp_ctx),
- torture->ev, &options);
+ torture->ev, &options, &session_options);
if (!NT_STATUS_IS_OK(status)) {
d_printf("smbcli_full_connection failed: %s\n",
nt_errstr(status));
struct smbcli_state *cli;
struct cli_credentials *wks_creds;
struct smbcli_options options;
+ struct smbcli_session_options session_options;
lp_smbcli_options(tctx->lp_ctx, &options);
+ lp_smbcli_session_options(tctx->lp_ctx, &session_options);
status = smbcli_full_connection(tctx, &cli,
torture_setting_string(tctx, "host", NULL),
lp_smb_ports(tctx->lp_ctx),
"IPC$", NULL, smb_creds,
lp_resolve_context(tctx->lp_ctx),
- tctx->ev, &options);
+ tctx->ev, &options, &session_options);
if (!NT_STATUS_IS_OK(status)) {
d_printf("smbcli_full_connection failed: %s\n",
nt_errstr(status));
struct cli_credentials *user_creds;
char *domain_name;
struct smbcli_options options;
+ struct smbcli_session_options session_options;
if (!(mem_ctx = talloc_new(torture))) {
return false;
}
lp_smbcli_options(torture->lp_ctx, &options);
+ lp_smbcli_session_options(torture->lp_ctx, &session_options);
status = smbcli_full_connection(
mem_ctx, &cli, torture_setting_string(torture, "host", NULL),
lp_smb_ports(torture->lp_ctx),
"IPC$", NULL, cmdline_credentials,
lp_resolve_context(torture->lp_ctx),
- torture->ev, &options);
+ torture->ev, &options, &session_options);
if (!NT_STATUS_IS_OK(status)) {
d_printf("(%s) smbcli_full_connection failed: %s\n",
__location__, nt_errstr(status));
lp_smb_ports(torture->lp_ctx),
"IPC$", NULL, anon_creds,
lp_resolve_context(torture->lp_ctx),
- torture->ev, &options);
+ torture->ev, &options, &session_options);
if (!NT_STATUS_IS_OK(status)) {
d_printf("(%s) anon smbcli_full_connection failed: %s\n",
__location__, nt_errstr(status));
struct smb_composite_sesssetup setup;
struct smbcli_tree *tree;
- session2 = smbcli_session_init(cli->transport, mem_ctx, false);
+ session2 = smbcli_session_init(cli->transport, mem_ctx, false, session_options);
if (session2 == NULL) {
d_printf("(%s) smbcli_session_init failed\n",
__location__);
#include "librpc/gen_ndr/ndr_netlogon_c.h"
#include "librpc/gen_ndr/ndr_samr_c.h"
#include "auth/auth.h"
-#include "lib/crypto/crypto.h"
+#include "../lib/crypto/crypto.h"
#include "lib/cmdline/popt_common.h"
#include "torture/rpc/rpc.h"
#include "auth/gensec/schannel_proto.h"
const char *comment;
const char *account_name;
const char *account_domain;
+ const char *netbios_name;
const char *password;
+ const char *workgroup;
struct dcerpc_pipe *p;
int function_level;
uint32_t parameter_control;
DATA_BLOB lmv2_response = data_blob(NULL, 0);
DATA_BLOB lmv2_session_key = data_blob(NULL, 0);
DATA_BLOB ntlmv2_session_key = data_blob(NULL, 0);
- DATA_BLOB names_blob = NTLMv2_generate_names_blob(samlogon_state->mem_ctx, samlogon_state->iconv_convenience, TEST_MACHINE_NAME, lp_workgroup(global_loadparm));
+ DATA_BLOB names_blob = NTLMv2_generate_names_blob(samlogon_state->mem_ctx, samlogon_state->iconv_convenience, TEST_MACHINE_NAME, samlogon_state->workgroup);
uint8_t lm_session_key[8];
uint8_t user_session_key[16];
DATA_BLOB lmv2_response = data_blob(NULL, 0);
DATA_BLOB lmv2_session_key = data_blob(NULL, 0);
DATA_BLOB ntlmv2_session_key = data_blob(NULL, 0);
- DATA_BLOB names_blob = NTLMv2_generate_names_blob(samlogon_state->mem_ctx, samlogon_state->iconv_convenience, lp_netbios_name(global_loadparm), lp_workgroup(global_loadparm));
+ DATA_BLOB names_blob = NTLMv2_generate_names_blob(samlogon_state->mem_ctx, samlogon_state->iconv_convenience, samlogon_state->netbios_name, samlogon_state->workgroup);
DATA_BLOB ntlm_response = data_blob_talloc(samlogon_state->mem_ctx, NULL, 24);
DATA_BLOB ntlm_session_key = data_blob_talloc(samlogon_state->mem_ctx, NULL, 16);
samlogon_state.account_name = account_name;
samlogon_state.account_domain = account_domain;
samlogon_state.password = plain_pass;
+ samlogon_state.workgroup = lp_workgroup(tctx->lp_ctx);
+ samlogon_state.netbios_name = lp_netbios_name(tctx->lp_ctx);
samlogon_state.p = p;
samlogon_state.creds = creds;
samlogon_state.expected_error = expected_error;
#include "system/time.h"
#include "librpc/gen_ndr/lsa.h"
#include "librpc/gen_ndr/ndr_samr_c.h"
-#include "lib/crypto/crypto.h"
+#include "../lib/crypto/crypto.h"
#include "libcli/auth/libcli_auth.h"
#include "libcli/security/security.h"
#include "torture/rpc/rpc.h"
#include "torture/torture.h"
#include "auth/auth.h"
#include "lib/util/dlinklist.h"
-#include "lib/crypto/crypto.h"
+#include "../lib/crypto/crypto.h"
#include "system/time.h"
#include "torture/rpc/rpc.h"
#include "auth/gensec/schannel_proto.h"
#include "includes.h"
#include "torture/torture.h"
#include "system/time.h"
-#include "lib/crypto/crypto.h"
+#include "../lib/crypto/crypto.h"
#include "libnet/libnet.h"
#include "lib/cmdline/popt_common.h"
#include "lib/ldb/include/ldb.h"
}
ldb_set_opaque(ldb_ctx, "credentials", cmdline_credentials);
+ ldb_set_opaque(ldb_ctx, "loadparm", cmdline_lp_ctx);
rtn = ldb_connect(ldb_ctx, remote_ldb_url, 0, NULL);
if (rtn != 0) {
{
struct winreg_NotifyChangeKeyValue r;
+ ZERO_STRUCT(r);
r.in.handle = handle;
r.in.watch_subtree = true;
r.in.notify_filter = 0;
struct policy_handle newhandle;
enum winreg_CreateAction action_taken = 0;
+ ZERO_STRUCT(r);
r.in.handle = handle;
r.out.new_handle = &newhandle;
init_winreg_String(&r.in.name, name);
secbuf.length = sdblob.length-10;
secbuf.inherit = 0;
+ ZERO_STRUCT(r);
r.in.handle = handle;
r.out.new_handle = newhandle;
init_winreg_String(&r.in.name, name);
{
struct winreg_CloseKey r;
+ ZERO_STRUCT(r);
r.in.handle = r.out.handle = handle;
torture_assert_ntstatus_ok(tctx, dcerpc_winreg_CloseKey(p, tctx, &r),
{
struct winreg_FlushKey r;
+ ZERO_STRUCT(r);
r.in.handle = handle;
torture_assert_ntstatus_ok(tctx, dcerpc_winreg_FlushKey(p, tctx, &r),
{
struct winreg_OpenKey r;
+ ZERO_STRUCT(r);
r.in.parent_handle = hive_handle;
init_winreg_String(&r.in.keyname, keyname);
r.in.unknown = 0x00000000;
{
struct winreg_DeleteKey r;
+ ZERO_STRUCT(r);
r.in.handle = handle;
init_winreg_String(&r.in.key, key);
class.name = "";
class.size = 1024;
+ ZERO_STRUCT(r);
r.in.handle = handle;
r.in.enum_index = 0;
r.in.name = &name;
NTSTATUS status;
uint32_t bufsize=0;
+ ZERO_STRUCT(r);
r.in.key_handle = handle;
r.in.values = r.out.values = talloc_array(tctx, struct QueryMultipleValue, 1);
r.in.values[0].name = talloc(tctx, struct winreg_String);
uint32_t offered = 0xfff;
uint32_t zero = 0;
+ ZERO_STRUCT(r);
r.in.handle = handle;
r.in.data = NULL;
r.in.value_name.name = valuename;
name.name = "";
name.size = 1024;
+ ZERO_STRUCT(r);
r.in.handle = handle;
r.in.enum_index = 0;
r.in.name = &name;
struct winreg_AbortSystemShutdown r;
uint16_t server = 0x0;
+ ZERO_STRUCT(r);
r.in.server = &server;
torture_assert_ntstatus_ok(tctx,
struct winreg_InitiateSystemShutdown r;
uint16_t hostname = 0x0;
+ ZERO_STRUCT(r);
r.in.hostname = &hostname;
r.in.message = talloc(tctx, struct lsa_StringLarge);
init_lsa_StringLarge(r.in.message, "spottyfood");
struct winreg_InitiateSystemShutdownEx r;
uint16_t hostname = 0x0;
+ ZERO_STRUCT(r);
r.in.hostname = &hostname;
r.in.message = talloc(tctx, struct lsa_StringLarge);
init_lsa_StringLarge(r.in.message, "spottyfood");
winreg_open_fn open_fn = userdata;
+ ZERO_STRUCT(r);
r.in.system_name = 0;
r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
r.out.handle = &handle;
winreg_open_fn open_fn = userdata;
+ ZERO_STRUCT(r);
r.in.system_name = 0;
r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
r.out.handle = &handle;
#include "torture/rpc/rpc.h"
#include "lib/cmdline/popt_common.h"
#include "param/param.h"
-#include "lib/crypto/crypto.h"
+#include "../lib/crypto/crypto.h"
#include "libcli/auth/libcli_auth.h"
#define SMBTORTURE_MACHINE_NAME "smbtrt_name"
status = smb2_getinfo_file(tree, tmp_ctx, &q);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_EQUAL(q.access_information.out.access_flags, io.in.desired_access);
+
+ io.in.file_attributes = 0;
+ io.in.desired_access = 0;
+ io.in.query_maximal_access = false;
+ io.in.share_access = 0;
+ status = smb2_create(tree, tmp_ctx, &io);
+ CHECK_STATUS(status, NT_STATUS_ACCESS_DENIED);
talloc_free(tmp_ctx);
const char *host = torture_setting_string(tctx, "host", NULL);
const char *share = torture_setting_string(tctx, "share", NULL);
struct smbcli_options options;
+ struct smbcli_session_options session_options;
lp_smbcli_options(tctx->lp_ctx, &options);
+ lp_smbcli_session_options(tctx->lp_ctx, &session_options);
status = smbcli_full_connection(tctx, &cli, host,
lp_smb_ports(tctx->lp_ctx),
share, NULL,
cmdline_credentials,
lp_resolve_context(tctx->lp_ctx),
- tctx->ev, &options);
+ tctx->ev, &options, &session_options);
if (!NT_STATUS_IS_OK(status)) {
printf("failed to connect to //%s/%s: %s\n",
const char *host = torture_setting_string(tctx, "host", NULL);
const char *share = torture_setting_string(tctx, "share", NULL);
struct smbcli_options options;
+ struct smbcli_session_options session_options;
lp_smbcli_options(tctx->lp_ctx, &options);
+ lp_smbcli_session_options(tctx->lp_ctx, &session_options);
status = smbcli_full_connection(tctx, &cli, host,
lp_smb_ports(tctx->lp_ctx),
share, NULL,
creds, lp_resolve_context(tctx->lp_ctx),
- tctx->ev, &options);
+ tctx->ev, &options, &session_options);
if (!NT_STATUS_IS_OK(status)) {
printf("failed to connect to //%s/%s: %s\n",
NTSTATUS status;
struct smbcli_options options;
+ struct smbcli_session_options session_options;
lp_smbcli_options(tctx->lp_ctx, &options);
+ lp_smbcli_session_options(tctx->lp_ctx, &session_options);
options.use_oplocks = torture_setting_bool(tctx, "use_oplocks", true);
options.use_level2_oplocks = torture_setting_bool(tctx, "use_level2_oplocks", true);
sharename, NULL,
cmdline_credentials,
lp_resolve_context(tctx->lp_ctx),
- ev, &options);
+ ev, &options, &session_options);
if (!NT_STATUS_IS_OK(status)) {
printf("Failed to open connection - %s\n", nt_errstr(status));
return false;
}
/* Search for rootdse */
- ldb_ret = ldb_search(ldb, basedn, LDB_SCOPE_BASE, NULL, rootdse_attrs, &rootdse_res);
+ ldb_ret = ldb_search(ldb, mem_ctx, &rootdse_res,
+ basedn, LDB_SCOPE_BASE, rootdse_attrs, NULL);
if (ldb_ret != LDB_SUCCESS) {
- ldb_ret = ldb_search(ldb, basedn, LDB_SCOPE_SUBTREE,
- "(&(objectClass=dMD)(cn=Schema))",
- NULL, &schema_res);
+ ldb_ret = ldb_search(ldb, mem_ctx, &schema_res, basedn, LDB_SCOPE_SUBTREE,
+ NULL, "(&(objectClass=dMD)(cn=Schema))");
if (ldb_ret) {
printf("cn=Schema Search failed: %s\n", ldb_errstring(ldb));
return NULL;
}
- talloc_steal(mem_ctx, schema_res);
-
if (schema_res->count != 1) {
talloc_free(schema_res);
printf("Failed to find rootDSE");
for (attribute=schema->attributes; attribute; attribute = attribute->next) {
const char *name = attribute->lDAPDisplayName;
- const char *description = attribute->adminDescription;
const char *oid = attribute->attributeID_oid;
const char *syntax = attribute->attributeSyntax_oid;
const char *equality = NULL, *substring = NULL;
}
}
- schema_entry = schema_attribute_description(mem_ctx, target, seperator, oid, name, description, equality, substring, syntax, single_value, false);
+ schema_entry = schema_attribute_description(mem_ctx,
+ target,
+ seperator,
+ oid,
+ name,
+ equality,
+ substring,
+ syntax,
+ single_value,
+ false);
if (schema_entry == NULL) {
ret.failures++;
/* This is already sorted to have 'top' and similar classes first */
for (objectclass=schema->classes; objectclass; objectclass = objectclass->next) {
const char *name = objectclass->lDAPDisplayName;
- const char *description = objectclass->adminDescription;
const char *oid = objectclass->governsID_oid;
const char *subClassOf = objectclass->subClassOf;
int objectClassCategory = objectclass->objectClassCategory;
oid,
name,
NULL,
- description,
subClassOf,
objectClassCategory,
must,
setnttoken_OBJ_FILES = $(utilssrcdir)/setnttoken.o
-#################################
-# Start BINARY nmblookup
-[BINARY::nmblookup]
-INSTALLDIR = BINDIR
-PRIVATE_DEPENDENCIES = \
- LIBSAMBA-HOSTCONFIG \
- LIBSAMBA-UTIL \
- LIBCLI_NBT \
- LIBPOPT \
- POPT_SAMBA \
- LIBNETIF \
- LIBCLI_RESOLVE
-# End BINARY nmblookup
-#################################
-
-nmblookup_OBJ_FILES = $(utilssrcdir)/nmblookup.o
-
#################################
# Start BINARY testparm
[BINARY::testparm]
+++ /dev/null
-<?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="ndrdump.1">
-
-<refmeta>
- <refentrytitle>ndrdump</refentrytitle>
- <manvolnum>1</manvolnum>
-</refmeta>
-
-
-<refnamediv>
- <refname>ndrdump</refname>
- <refpurpose>DCE/RPC Packet Parser and Dumper</refpurpose>
-</refnamediv>
-
-<refsynopsisdiv>
- <cmdsynopsis>
- <command>ndrdump</command>
- <arg choice="opt">-c context</arg>
- <arg choice="req">pipe</arg>
- <arg choice="req">function</arg>
- <arg choice="req">in|out</arg>
- <arg choice="req">filename</arg>
- </cmdsynopsis>
- <cmdsynopsis>
- <command>ndrdump</command>
- <arg choice="opt">pipe</arg>
- </cmdsynopsis>
- <cmdsynopsis>
- <command>ndrdump</command>
- </cmdsynopsis>
-</refsynopsisdiv>
-
-<refsect1>
- <title>DESCRIPTION</title>
-
- <para>ndrdump tries to parse the specified <replaceable>filename</replaceable>
- using Samba's parser for the specified pipe and function. The
- third argument should be
- either <emphasis>in</emphasis> or <emphasis>out</emphasis>, depending
- on whether the data should be parsed as a request or a reply.</para>
-
- <para>Running ndrdump without arguments will list the pipes for which
- parsers are available.</para>
-
- <para>Running ndrdump with one argument will list the functions that
- Samba can parse for the specified pipe.</para>
-
- <para>The primary function of ndrdump is debugging Samba's internal
- DCE/RPC parsing functions. The file being parsed is usually
- one exported by wiresharks <quote>Export selected packet bytes</quote>
- function.</para>
-
- <para>The context argument can be used to load context data from the request
- packet when parsing reply packets (such as array lengths).</para>
-
-</refsect1>
-
-<refsect1>
- <title>VERSION</title>
-
- <para>This man page is correct for version 4.0 of the Samba suite.</para>
-</refsect1>
-
-<refsect1>
- <title>SEE ALSO</title>
-
- <para>wireshark, pidl</para>
-
-</refsect1>
-
-<refsect1>
- <title>AUTHOR</title>
-
- <para>This utility is part of the <ulink url="http://www.samba.org/">Samba</ulink> suite, which is developed by the global <ulink url="http://www.samba.org/samba/team/">Samba Team</ulink>.</para>
-
- <para>ndrdump was written by Andrew Tridgell. </para>
-
- <para>This manpage was written by Jelmer Vernooij. </para>
-
-</refsect1>
-
-</refentry>
# Start SUBSYSTEM WEB
[MODULE::WEB]
INIT_FUNCTION = server_service_web_init
-SUBSYSTEM = smbd
-PRIVATE_DEPENDENCIES = ESP LIBTLS smbcalls process_model
+SUBSYSTEM = samba
+PRIVATE_DEPENDENCIES = LIBTLS smbcalls process_model LIBPYTHON
# End SUBSYSTEM WEB
#######################
-WEB_OBJ_FILES = $(addprefix $(web_serversrcdir)/, web_server.o http.o)
+WEB_OBJ_FILES = $(addprefix $(web_serversrcdir)/, web_server.o wsgi.o)
$(eval $(call proto_header_template,$(web_serversrcdir)/proto.h,$(WEB_OBJ_FILES:.o=.c)))
+++ /dev/null
-/*
- Unix SMB/CIFS implementation.
-
- http handling code
-
- Copyright (C) Andrew Tridgell 2005
-
- 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 "smbd/service_task.h"
-#include "web_server/web_server.h"
-#include "smbd/service_stream.h"
-#include "smbd/service.h"
-#include "lib/events/events.h"
-#include "system/time.h"
-#include "system/wait.h"
-#include "lib/appweb/esp/esp.h"
-#include "lib/appweb/ejs/ejsInternal.h"
-#include "lib/util/dlinklist.h"
-#include "lib/tls/tls.h"
-#include "scripting/ejs/smbcalls.h"
-#include "param/param.h"
-
-#define SAMBA_SESSION_KEY "SambaSessionId"
-#define HTTP_PREAUTH_URI "/scripting/preauth.esp"
-
-/* state of the esp subsystem for a specific request */
-struct esp_state {
- struct websrv_context *web;
- struct EspRequest *req;
- struct MprVar variables[ESP_OBJ_MAX];
- struct session_data *session;
-};
-
-/*
- output the http headers
-*/
-static void http_output_headers(struct websrv_context *web)
-{
- int i;
- char *s;
- DATA_BLOB b;
- uint32_t content_length = 0;
- const char *response_string = "Unknown Code";
- const struct {
- unsigned code;
- const char *response_string;
- } codes[] = {
- { 200, "OK" },
- { 301, "Moved" },
- { 302, "Found" },
- { 303, "Method" },
- { 304, "Not Modified" },
- { 400, "Bad request" },
- { 401, "Unauthorized" },
- { 403, "Forbidden" },
- { 404, "Not Found" },
- { 500, "Internal Server Error" },
- { 501, "Not implemented" }
- };
- for (i=0;i<ARRAY_SIZE(codes);i++) {
- if (codes[i].code == web->output.response_code) {
- response_string = codes[i].response_string;
- }
- }
-
- if (web->output.headers == NULL) return;
- s = talloc_asprintf(web, "HTTP/1.0 %u %s\r\n",
- web->output.response_code, response_string);
- if (s == NULL) return;
- for (i=0;web->output.headers[i];i++) {
- s = talloc_asprintf_append_buffer(s, "%s\r\n", web->output.headers[i]);
- }
-
- /* work out the content length */
- content_length = web->output.content.length;
- if (web->output.fd != -1) {
- struct stat st;
- fstat(web->output.fd, &st);
- content_length += st.st_size;
- }
- s = talloc_asprintf_append_buffer(s, "Content-Length: %u\r\n\r\n", content_length);
- if (s == NULL) return;
-
- b = web->output.content;
- web->output.content = data_blob_string_const(s);
- data_blob_append(web, &web->output.content, b.data, b.length);
- data_blob_free(&b);
-}
-
-/*
- return the local path for a URL
-*/
-static const char *http_local_path(struct websrv_context *web,
- const char *url,
- const char *base_dir)
-{
- int i;
- char *path;
-
- /* check that the url is OK */
- if (url[0] != '/') return NULL;
-
- for (i=0;url[i];i++) {
- if ((!isalnum((unsigned char)url[i]) && !strchr("./_-", url[i])) ||
- (url[i] == '.' && strchr("/.", url[i+1]))) {
- return NULL;
- }
- }
-
- path = talloc_asprintf(web, "%s/%s", base_dir, url+1);
- if (path == NULL) return NULL;
-
- if (directory_exist(path)) {
- path = talloc_asprintf_append_buffer(path, "/index.esp");
- }
- return path;
-}
-
-/*
- called when esp wants to read a file to support include() calls
-*/
-static int http_readFile(EspHandle handle,
- char **buf,
- int *len,
- const char *path,
- const char *base_dir)
-{
- struct websrv_context *web = talloc_get_type(handle,
- struct websrv_context);
- int fd = -1;
- struct stat st;
- *buf = NULL;
-
- path = http_local_path(web, path, base_dir);
- if (path == NULL) goto failed;
-
- fd = open(path, O_RDONLY);
- if (fd == -1 || fstat(fd, &st) != 0 || !S_ISREG(st.st_mode)) goto failed;
-
- *buf = talloc_array(handle, char, st.st_size+1);
- if (*buf == NULL) goto failed;
-
- if (read(fd, *buf, st.st_size) != st.st_size) goto failed;
-
- (*buf)[st.st_size] = 0;
-
- close(fd);
- *len = st.st_size;
- return 0;
-
-failed:
- DEBUG(0,("Failed to read file %s - %s\n", path, strerror(errno)));
- if (fd != -1) close(fd);
- talloc_free(*buf);
- *buf = NULL;
- return -1;
-}
-
-static int http_readFileFromSwatDir(EspHandle handle, char **buf, int *len,
- const char *path)
-{
- return http_readFile(handle, buf, len, path,
- lp_swat_directory(global_loadparm));
-}
-
-
-
-/*
- called when esp wants to find the real path of a file
-*/
-static int http_mapToStorage(EspHandle handle, char *path, int len, const char *uri, int flags)
-{
- if (uri == NULL || strlen(uri) >= len) return -1;
- strncpy(path, uri, len);
- return 0;
-}
-
-/*
- called when esp wants to output something
-*/
-static int http_writeBlock(EspHandle handle, const char *buf, int size)
-{
- struct websrv_context *web = talloc_get_type(handle, struct websrv_context);
- if (!data_blob_append(web, &web->output.content, buf, size))
- return -1;
- return size;
-}
-
-
-/*
- set a http header
-*/
-static void http_setHeader(EspHandle handle, const char *value, bool allowMultiple)
-{
- struct websrv_context *web = talloc_get_type(handle, struct websrv_context);
- char *p = strchr(value, ':');
-
- if (p && !allowMultiple && web->output.headers) {
- int i;
- for (i=0;web->output.headers[i];i++) {
- if (strncmp(web->output.headers[i], value, (p+1)-value) == 0) {
- web->output.headers[i] = talloc_strdup(web, value);
- return;
- }
- }
- }
-
- web->output.headers = str_list_add(web->output.headers, value);
- talloc_steal(web, web->output.headers);
-}
-
-/*
- set a http response code
-*/
-static void http_setResponseCode(EspHandle handle, int code)
-{
- struct websrv_context *web = talloc_get_type(handle, struct websrv_context);
- web->output.response_code = code;
-}
-
-/*
- redirect to another web page
- */
-static void http_redirect(EspHandle handle, int code, char *url)
-{
- struct websrv_context *web = talloc_get_type(handle, struct websrv_context);
- const char *host = web->input.host;
-
- /* form the full url, unless it already looks like a url */
- if (strchr(url, ':') == NULL) {
- if (host == NULL) {
- struct socket_address *socket_address = socket_get_my_addr(web->conn->socket, web);
- if (socket_address == NULL) goto internal_error;
- host = talloc_asprintf(web, "%s:%u",
- socket_address->addr, socket_address->port);
- }
- if (host == NULL) goto internal_error;
- if (url[0] != '/') {
- char *p = strrchr(web->input.url, '/');
- if (p == web->input.url) {
- url = talloc_asprintf(web, "http%s://%s/%s",
- tls_enabled(web->conn->socket)?"s":"",
- host, url);
- } else {
- int dirlen = p - web->input.url;
- url = talloc_asprintf(web, "http%s://%s%*.*s/%s",
- tls_enabled(web->conn->socket)?"s":"",
- host,
- dirlen, dirlen, web->input.url,
- url);
- }
- if (url == NULL) goto internal_error;
- }
- }
-
- http_setHeader(handle, talloc_asprintf(web, "Location: %s", url), 0);
-
- /* make sure we give a valid redirect code */
- if (code >= 300 && code < 400) {
- http_setResponseCode(handle, code);
- } else {
- http_setResponseCode(handle, 302);
- }
- return;
-
-internal_error:
- http_error(web, 500, "Internal server error");
-}
-
-
-/*
- setup a cookie
-*/
-static void http_setCookie(EspHandle handle, const char *name, const char *value,
- int lifetime, const char *path, bool secure)
-{
- struct websrv_context *web = talloc_get_type(handle, struct websrv_context);
- char *buf;
-
- if (lifetime > 0) {
- buf = talloc_asprintf(web, "Set-Cookie: %s=%s; path=%s; Expires=%s; %s",
- name, value, path?path:"/",
- http_timestring(web, time(NULL)+lifetime),
- secure?"secure":"");
- } else {
- buf = talloc_asprintf(web, "Set-Cookie: %s=%s; path=%s; %s",
- name, value, path?path:"/",
- secure?"secure":"");
- }
- http_setHeader(handle, "Cache-control: no-cache=\"set-cookie\"", 0);
- http_setHeader(handle, buf, 0);
- talloc_free(buf);
-}
-
-/*
- return the session id
-*/
-static const char *http_getSessionId(EspHandle handle)
-{
- struct websrv_context *web = talloc_get_type(handle, struct websrv_context);
- return web->session->id;
-}
-
-/*
- setup a session
-*/
-static void http_createSession(EspHandle handle, int timeout)
-{
- struct websrv_context *web = talloc_get_type(handle, struct websrv_context);
- if (web->session) {
- web->session->lifetime = timeout;
- http_setCookie(web, SAMBA_SESSION_KEY, web->session->id,
- web->session->lifetime, "/", 0);
- }
-}
-
-/*
- destroy a session
-*/
-static void http_destroySession(EspHandle handle)
-{
- struct websrv_context *web = talloc_get_type(handle, struct websrv_context);
- talloc_free(web->session);
- web->session = NULL;
-}
-
-
-/*
- setup for a raw http level error
-*/
-void http_error(struct websrv_context *web, int code, const char *info)
-{
- char *s;
- s = talloc_asprintf(web,"<HTML><HEAD><TITLE>Error %u</TITLE></HEAD><BODY><H1>Error %u</H1><pre>%s</pre><p></BODY></HTML>\r\n\r\n",
- code, code, info);
- if (s == NULL) {
- stream_terminate_connection(web->conn, "http_error: out of memory");
- return;
- }
- http_writeBlock(web, s, strlen(s));
- http_setResponseCode(web, code);
- http_output_headers(web);
- EVENT_FD_NOT_READABLE(web->conn->event.fde);
- EVENT_FD_WRITEABLE(web->conn->event.fde);
- web->output.output_pending = true;
-}
-
-/*
- map a unix error code to a http error
-*/
-void http_error_unix(struct websrv_context *web, const char *info)
-{
- int code = 500;
- switch (errno) {
- case ENOENT:
- case EISDIR:
- code = 404;
- break;
- case EACCES:
- code = 403;
- break;
- }
- info = talloc_asprintf(web, "%s<p>%s<p>\n", info, strerror(errno));
- http_error(web, code, info);
-}
-
-
-/*
- a simple file request
-*/
-static void http_simple_request(struct websrv_context *web)
-{
- const char *url = web->input.url;
- const char *path;
- struct stat st;
-
- path = http_local_path(web, url, lp_swat_directory(web->task->lp_ctx));
- if (path == NULL) goto invalid;
-
- /* looks ok */
- web->output.fd = open(path, O_RDONLY);
- if (web->output.fd == -1) {
- DEBUG(0,("Failed to read file %s - %s\n", path, strerror(errno)));
- http_error_unix(web, path);
- return;
- }
-
- if (fstat(web->output.fd, &st) != 0 || !S_ISREG(st.st_mode)) {
- close(web->output.fd);
- goto invalid;
- }
-
- return;
-
-invalid:
- http_error(web, 400, "Malformed URL");
-}
-
-/*
- setup the standard ESP arrays
-*/
-static void http_setup_arrays(struct esp_state *esp)
-{
- struct websrv_context *web = esp->web;
- struct esp_data *edata = talloc_get_type(web->task->private, struct esp_data);
- struct EspRequest *req = esp->req;
- struct socket_address *socket_address = socket_get_my_addr(web->conn->socket, esp);
- struct socket_address *peer_address = socket_get_peer_addr(web->conn->socket, esp);
- char *p;
-
-#define SETVAR(type, name, value) do { \
- const char *v = value; \
- if (v) espSetStringVar(req, type, name, v); \
-} while (0)
-
- SETVAR(ESP_REQUEST_OBJ, "CONTENT_LENGTH",
- talloc_asprintf(esp, "%u", web->input.content_length));
- SETVAR(ESP_REQUEST_OBJ, "QUERY_STRING", web->input.query_string);
- SETVAR(ESP_REQUEST_OBJ, "POST_DATA",
- talloc_strndup(esp,
- web->input.partial.data,
- web->input.partial.length));
- SETVAR(ESP_REQUEST_OBJ, "REQUEST_METHOD", web->input.post_request?"POST":"GET");
- SETVAR(ESP_REQUEST_OBJ, "REQUEST_URI", web->input.url);
- p = strrchr(web->input.url, '/');
- SETVAR(ESP_REQUEST_OBJ, "SCRIPT_NAME", p+1);
- SETVAR(ESP_REQUEST_OBJ, "SCRIPT_FILENAME", web->input.url);
- if (peer_address) {
- struct MprVar mpv = mprObject("socket_address");
- mprSetPtrChild(&mpv, "socket_address", peer_address);
- espSetVar(req, ESP_REQUEST_OBJ, "REMOTE_SOCKET_ADDRESS", mpv);
- SETVAR(ESP_REQUEST_OBJ, "REMOTE_ADDR", peer_address->addr);
- }
- p = socket_get_peer_name(web->conn->socket, esp);
- SETVAR(ESP_REQUEST_OBJ, "REMOTE_HOST", p);
- SETVAR(ESP_REQUEST_OBJ, "REMOTE_USER", "");
- SETVAR(ESP_REQUEST_OBJ, "CONTENT_TYPE", web->input.content_type);
- if (web->session) {
- SETVAR(ESP_REQUEST_OBJ, "SESSION_ID", web->session->id);
- }
- SETVAR(ESP_REQUEST_OBJ, "COOKIE_SUPPORT", web->input.cookie?"true":"false");
-
- SETVAR(ESP_HEADERS_OBJ, "HTTP_REFERER", web->input.referer);
- SETVAR(ESP_HEADERS_OBJ, "HOST", web->input.host);
- SETVAR(ESP_HEADERS_OBJ, "ACCEPT_ENCODING", web->input.accept_encoding);
- SETVAR(ESP_HEADERS_OBJ, "ACCEPT_LANGUAGE", web->input.accept_language);
- SETVAR(ESP_HEADERS_OBJ, "ACCEPT_CHARSET", web->input.accept_charset);
- SETVAR(ESP_HEADERS_OBJ, "COOKIE", web->input.cookie);
- SETVAR(ESP_HEADERS_OBJ, "USER_AGENT", web->input.user_agent);
-
- if (socket_address) {
- SETVAR(ESP_SERVER_OBJ, "SERVER_ADDR", socket_address->addr);
- SETVAR(ESP_SERVER_OBJ, "SERVER_NAME", socket_address->addr);
- SETVAR(ESP_SERVER_OBJ, "SERVER_HOST", socket_address->addr);
- SETVAR(ESP_SERVER_OBJ, "SERVER_PORT",
- talloc_asprintf(esp, "%u", socket_address->port));
- }
-
- SETVAR(ESP_SERVER_OBJ, "DOCUMENT_ROOT", lp_swat_directory(esp->web->task->lp_ctx));
- SETVAR(ESP_SERVER_OBJ, "SERVER_PROTOCOL", tls_enabled(web->conn->socket)?"https":"http");
- SETVAR(ESP_SERVER_OBJ, "SERVER_SOFTWARE", "SAMBA");
- SETVAR(ESP_SERVER_OBJ, "GATEWAY_INTERFACE", "CGI/1.1");
- SETVAR(ESP_SERVER_OBJ, "TLS_SUPPORT", tls_support(edata->tls_params)?"true":"false");
-}
-
-#if HAVE_SETJMP_H
-/* the esp scripting lirary generates exceptions when
- it hits a major error. We need to catch these and
- report a internal server error via http
-*/
-static jmp_buf ejs_exception_buf;
-static const char *exception_reason;
-
-static void web_server_ejs_exception(const char *reason)
-{
- Ejs *ep = ejsPtr(0);
- if (ep) {
- ejsSetErrorMsg(0, "%s", reason);
- exception_reason = ep->error;
- } else {
- exception_reason = reason;
- }
- DEBUG(0,("%s", exception_reason));
- longjmp(ejs_exception_buf, -1);
-}
-#else
-static void web_server_ejs_exception(const char *reason)
-{
- DEBUG(0,("%s", reason));
- smb_panic(reason);
-}
-#endif
-
-/*
- process a esp request
-*/
-static void esp_request(struct esp_state *esp, const char *url)
-{
- struct websrv_context *web = esp->web;
- int size;
- int res;
- char *emsg = NULL, *buf;
-
- if (http_readFile(web, &buf, &size, url, lp_swat_directory(esp->web->task->lp_ctx)) != 0) {
- http_error_unix(web, url);
- return;
- }
-
-#if HAVE_SETJMP_H
- if (setjmp(ejs_exception_buf) != 0) {
- http_error(web, 500, exception_reason);
- return;
- }
-#endif
-
- res = espProcessRequest(esp->req, url, buf, &emsg);
- if (res != 0 && emsg) {
- http_writeBlock(web, "<pre>", 5);
- http_writeBlock(web, emsg, strlen(emsg));
- http_writeBlock(web, "</pre>", 6);
- }
- talloc_free(buf);
-}
-
-/*
- perform pre-authentication on every page if /scripting/preauth.esp
- exists. If this script generates any non-whitepace output at all,
- then we don't run the requested URL.
-
- note that the preauth is run even for static pages such as images
-*/
-static bool http_preauth(struct esp_state *esp)
-{
- const char *path = http_local_path(esp->web,
- HTTP_PREAUTH_URI,
- lp_swat_directory(esp->web->task->lp_ctx));
- int i;
- if (path == NULL) {
- http_error(esp->web, 500, "Internal server error");
- return false;
- }
- if (!file_exist(path)) {
- /* if the preath script is not installed then allow access */
- return true;
- }
- esp_request(esp, HTTP_PREAUTH_URI);
- for (i=0;i<esp->web->output.content.length;i++) {
- if (!isspace(esp->web->output.content.data[i])) {
- /* if the preauth has generated content, then force it
- to be html, so that we can show the login page for
- failed access to images */
- http_setHeader(esp->web, "Content-Type: text/html", 0);
- return false;
- }
- }
- data_blob_free(&esp->web->output.content);
- return true;
-}
-
-
-/*
- handling of + and % escapes in http variables
-*/
-static const char *http_unescape(TALLOC_CTX *mem_ctx, const char *p)
-{
- char *s0 = talloc_strdup(mem_ctx, p);
- char *s = s0;
- if (s == NULL) return NULL;
-
- while (*s) {
- unsigned v;
- if (*s == '+') *s = ' ';
- if (*s == '%' && sscanf(s+1, "%02x", &v) == 1) {
- *s = (char)v;
- memmove(s+1, s+3, strlen(s+3)+1);
- }
- s++;
- }
-
- return s0;
-}
-
-/*
- set a form or GET variable
-*/
-static void esp_putvar(struct esp_state *esp, const char *var, const char *value)
-{
- if (strcasecmp(var, SAMBA_SESSION_KEY) == 0) {
- /* special case support for browsers without cookie
- support */
- esp->web->input.session_key = talloc_strdup(esp, value);
- } else {
- mprSetPropertyValue(&esp->variables[ESP_FORM_OBJ],
- http_unescape(esp, var),
- mprCreateStringVar(http_unescape(esp, value), 0));
- }
-}
-
-
-/*
- parse the variables in a POST style request
-*/
-static NTSTATUS http_parse_post(struct esp_state *esp)
-{
- DATA_BLOB b = esp->web->input.partial;
-
- while (b.length) {
- char *p, *line;
- size_t len;
-
- p = memchr(b.data, '&', b.length);
- if (p == NULL) {
- len = b.length;
- } else {
- len = p - (char *)b.data;
- }
- line = talloc_strndup(esp, (char *)b.data, len);
- NT_STATUS_HAVE_NO_MEMORY(line);
-
- p = strchr(line,'=');
- if (p) {
- *p = 0;
- esp_putvar(esp, line, p+1);
- }
- talloc_free(line);
- b.length -= len;
- b.data += len;
- if (b.length > 0) {
- b.length--;
- b.data++;
- }
- }
-
- return NT_STATUS_OK;
-}
-
-/*
- parse the variables in a GET style request
-*/
-static NTSTATUS http_parse_get(struct esp_state *esp)
-{
- struct websrv_context *web = esp->web;
- char *p, *s, *tok;
- char *pp;
-
- p = strchr(web->input.url, '?');
- web->input.query_string = p+1;
- *p = 0;
-
- s = talloc_strdup(esp, esp->web->input.query_string);
- NT_STATUS_HAVE_NO_MEMORY(s);
-
- for (tok=strtok_r(s,"&;", &pp);tok;tok=strtok_r(NULL,"&;", &pp)) {
- p = strchr(tok,'=');
- if (p) {
- *p = 0;
- esp_putvar(esp, tok, p+1);
- }
- }
- return NT_STATUS_OK;
-}
-
-/*
- called when a session times out
-*/
-static void session_timeout(struct event_context *ev, struct timed_event *te,
- struct timeval t, void *private)
-{
- struct session_data *s = talloc_get_type(private, struct session_data);
- talloc_free(s);
-}
-
-/*
- destroy a session
- */
-static int session_destructor(struct session_data *s)
-{
- DLIST_REMOVE(s->edata->sessions, s);
- return 0;
-}
-
-/*
- setup the session for this request
-*/
-static void http_setup_session(struct esp_state *esp)
-{
- const char *session_key = SAMBA_SESSION_KEY;
- char *p;
- const char *cookie = esp->web->input.cookie;
- const char *key = NULL;
- struct esp_data *edata = talloc_get_type(esp->web->task->private, struct esp_data);
- struct session_data *s;
- bool generated_key = false;
-
- /* look for our session key */
- if (cookie && (p = strstr(cookie, session_key)) &&
- p[strlen(session_key)] == '=') {
- p += strlen(session_key)+1;
- key = talloc_strndup(esp, p, strcspn(p, ";"));
- }
-
- if (key == NULL && esp->web->input.session_key) {
- key = esp->web->input.session_key;
- } else if (key == NULL) {
- key = generate_random_str_list(esp, 16, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ");
- generated_key = true;
- }
-
- /* try to find this session in the existing session list */
- for (s=edata->sessions;s;s=s->next) {
- if (strcmp(key, s->id) == 0) {
- break;
- }
- }
-
- if (s == NULL) {
- /* create a new session */
- s = talloc_zero(edata, struct session_data);
- s->id = talloc_steal(s, key);
- s->data = NULL;
- s->te = NULL;
- s->edata = edata;
- s->lifetime = lp_parm_int(esp->web->task->lp_ctx, NULL, "web", "sessiontimeout", 900);
- DLIST_ADD(edata->sessions, s);
- talloc_set_destructor(s, session_destructor);
- if (!generated_key) {
- mprSetPropertyValue(&esp->variables[ESP_REQUEST_OBJ],
- "SESSION_EXPIRED", mprCreateStringVar("true", 0));
- }
- }
-
- http_setCookie(esp->web, session_key, key, s->lifetime, "/", 0);
-
- if (s->data) {
- mprCopyVar(&esp->variables[ESP_SESSION_OBJ], s->data, MPR_DEEP_COPY);
- }
-
- esp->web->session = s;
-}
-
-
-/* callbacks for esp processing */
-static const struct Esp esp_control = {
- .maxScriptSize = 60000,
- .writeBlock = http_writeBlock,
- .setHeader = http_setHeader,
- .redirect = http_redirect,
- .setResponseCode = http_setResponseCode,
- .readFile = http_readFileFromSwatDir,
- .mapToStorage = http_mapToStorage,
- .setCookie = http_setCookie,
- .createSession = http_createSession,
- .destroySession = http_destroySession,
- .getSessionId = http_getSessionId
-};
-
-/*
- process a complete http request
-*/
-void http_process_input(struct websrv_context *web)
-{
- NTSTATUS status;
- struct esp_state *esp = NULL;
- struct esp_data *edata = talloc_get_type(web->task->private, struct esp_data);
- struct smbcalls_context *smbcalls_ctx;
- char *p;
- void *save_mpr_ctx = mprMemCtx();
- void *ejs_save = ejs_save_state();
- int i;
- const char *file_type = NULL;
- enum page_type {
- page_type_simple,
- page_type_esp
- };
- enum page_type page_type;
- const struct {
- const char *extension;
- const char *mime_type;
- enum page_type page_type;
- } mime_types[] = {
- {"gif", "image/gif"},
- {"png", "image/png"},
- {"jpg", "image/jpeg"},
- {"txt", "text/plain"},
- {"ico", "image/x-icon"},
- {"css", "text/css"},
- {"esp", "text/html", true}
- };
-
- /*
- * give the smbcalls a chance to find the event context
- * and messaging context
- */
- smbcalls_ctx = talloc(web, struct smbcalls_context);
- if (smbcalls_ctx == NULL) goto internal_error;
- smbcalls_ctx->event_ctx = web->conn->event.ctx;
- smbcalls_ctx->msg_ctx = web->conn->msg_ctx;
-
- esp = talloc_zero(smbcalls_ctx, struct esp_state);
- if (esp == NULL) goto internal_error;
-
- esp->web = web;
-
- mprSetCtx(esp);
-
- if (espOpen(&esp_control) != 0) goto internal_error;
-
- for (i=0;i<ARRAY_SIZE(esp->variables);i++) {
- esp->variables[i] = mprCreateUndefinedVar();
- }
- esp->variables[ESP_HEADERS_OBJ] = mprCreateObjVar("headers", ESP_HASH_SIZE);
- esp->variables[ESP_FORM_OBJ] = mprCreateObjVar("form", ESP_HASH_SIZE);
- esp->variables[ESP_APPLICATION_OBJ] = mprCreateObjVar("application", ESP_HASH_SIZE);
- esp->variables[ESP_COOKIES_OBJ] = mprCreateObjVar("cookies", ESP_HASH_SIZE);
- esp->variables[ESP_FILES_OBJ] = mprCreateObjVar("files", ESP_HASH_SIZE);
- esp->variables[ESP_REQUEST_OBJ] = mprCreateObjVar("request", ESP_HASH_SIZE);
- esp->variables[ESP_SERVER_OBJ] = mprCreateObjVar("server", ESP_HASH_SIZE);
- esp->variables[ESP_SESSION_OBJ] = mprCreateObjVar("session", ESP_HASH_SIZE);
-
- if (edata->application_data) {
- mprCopyVar(&esp->variables[ESP_APPLICATION_OBJ],
- edata->application_data, MPR_DEEP_COPY);
- }
-
- smb_setup_ejs_functions(web_server_ejs_exception);
-
- if (web->input.url == NULL) {
- http_error(web, 400, "You must specify a GET or POST request");
- mprSetCtx(save_mpr_ctx);
- ejs_restore_state(ejs_save);
- return;
- }
-
- /* parse any form or get variables */
- if (web->input.post_request) {
- status = http_parse_post(esp);
- if (!NT_STATUS_IS_OK(status)) {
- http_error(web, 400, "Malformed POST data");
- mprSetCtx(save_mpr_ctx);
- ejs_restore_state(ejs_save);
- return;
- }
- }
- if (strchr(web->input.url, '?')) {
- status = http_parse_get(esp);
- if (!NT_STATUS_IS_OK(status)) {
- http_error(web, 400, "Malformed GET data");
- mprSetCtx(save_mpr_ctx);
- ejs_restore_state(ejs_save);
- return;
- }
- }
-
- http_setup_session(esp);
-
- esp->req = espCreateRequest(web, web->input.url, esp->variables);
- if (esp->req == NULL) goto internal_error;
-
- p = strrchr(web->input.url, '.');
- if (p == NULL) {
- page_type = page_type_esp;
- file_type = "text/html";
- }
- for (i=0;p && i<ARRAY_SIZE(mime_types);i++) {
- if (strcmp(mime_types[i].extension, p+1) == 0) {
- page_type = mime_types[i].page_type;
- file_type = mime_types[i].mime_type;
- }
- }
- if (file_type == NULL) {
- page_type = page_type_simple;
- file_type = "text/html";
- }
-
- /* setup basic headers */
- http_setResponseCode(web, 200);
- http_setHeader(web, talloc_asprintf(esp, "Date: %s",
- http_timestring(esp, time(NULL))), 0);
- http_setHeader(web, "Server: Samba", 0);
- http_setHeader(web, "Connection: close", 0);
- http_setHeader(web, talloc_asprintf(esp, "Content-Type: %s", file_type), 0);
-
- http_setup_arrays(esp);
-
- /*
- * Do pre-authentication. If pre-authentication succeeds, do
- * page-type-specific processing.
- */
- switch(page_type)
- {
- case page_type_simple:
- if (http_preauth(esp)) {
- http_simple_request(web);
- }
- break;
-
- case page_type_esp:
- if (http_preauth(esp)) {
- esp_request(esp, web->input.url);
- }
- break;
- }
-
- if (web->conn == NULL) {
- /* the connection has been terminated above us, probably
- via a timeout */
- goto internal_error;
- }
-
- if (!web->output.output_pending) {
- http_output_headers(web);
- EVENT_FD_WRITEABLE(web->conn->event.fde);
- web->output.output_pending = true;
- }
-
- /* copy any application data to long term storage in edata */
- talloc_free(edata->application_data);
- edata->application_data = talloc_zero(edata, struct MprVar);
- mprSetCtx(edata->application_data);
- mprCopyVar(edata->application_data, &esp->variables[ESP_APPLICATION_OBJ],
- MPR_DEEP_COPY);
- mprSetCtx(esp);
-
- /* copy any session data */
- if (web->session) {
- talloc_free(web->session->data);
- web->session->data = talloc_zero(web->session, struct MprVar);
- if (esp->variables[ESP_SESSION_OBJ].properties == NULL ||
- esp->variables[ESP_SESSION_OBJ].properties[0].numItems == 0) {
- talloc_free(web->session);
- web->session = NULL;
- } else {
- mprSetCtx(web->session->data);
- mprCopyVar(web->session->data, &esp->variables[ESP_SESSION_OBJ],
- MPR_DEEP_COPY);
- /* setup the timeout for the session data */
- mprSetCtx(esp);
- talloc_free(web->session->te);
- web->session->te = event_add_timed(web->conn->event.ctx, web->session,
- timeval_current_ofs(web->session->lifetime, 0),
- session_timeout, web->session);
- }
- }
-
- talloc_free(esp);
- mprSetCtx(save_mpr_ctx);
- ejs_restore_state(ejs_save);
- return;
-
-internal_error:
- mprSetCtx(esp);
- talloc_free(esp);
- if (web->conn != NULL) {
- http_error(web, 500, "Internal server error");
- }
- mprSetCtx(save_mpr_ctx);
- ejs_restore_state(ejs_save);
-}
-
-
-/*
- parse one line of header input
-*/
-NTSTATUS http_parse_header(struct websrv_context *web, const char *line)
-{
- if (line[0] == 0) {
- web->input.end_of_headers = true;
- } else if (strncasecmp(line,"GET ", 4)==0) {
- web->input.url = talloc_strndup(web, &line[4], strcspn(&line[4], " \t"));
- } else if (strncasecmp(line,"POST ", 5)==0) {
- web->input.post_request = true;
- web->input.url = talloc_strndup(web, &line[5], strcspn(&line[5], " \t"));
- } else if (strchr(line, ':') == NULL) {
- http_error(web, 400, "This server only accepts GET and POST requests");
- return NT_STATUS_INVALID_PARAMETER;
- } else if (strncasecmp(line,"Content-Length: ", 16)==0) {
- web->input.content_length = strtoul(&line[16], NULL, 10);
- } else {
-#define PULL_HEADER(v, s) do { \
- if (strncmp(line, s, strlen(s)) == 0) { \
- web->input.v = talloc_strdup(web, &line[strlen(s)]); \
- return NT_STATUS_OK; \
- } \
-} while (0)
- PULL_HEADER(content_type, "Content-Type: ");
- PULL_HEADER(user_agent, "User-Agent: ");
- PULL_HEADER(referer, "Referer: ");
- PULL_HEADER(host, "Host: ");
- PULL_HEADER(accept_encoding, "Accept-Encoding: ");
- PULL_HEADER(accept_language, "Accept-Language: ");
- PULL_HEADER(accept_charset, "Accept-Charset: ");
- PULL_HEADER(cookie, "Cookie: ");
- }
-
- /* ignore all other headers for now */
- return NT_STATUS_OK;
-}
-
-
-/*
- setup the esp processor - called at task initialisation
-*/
-NTSTATUS http_setup_esp(struct task_server *task)
-{
- struct esp_data *edata;
-
- edata = talloc_zero(task, struct esp_data);
- NT_STATUS_HAVE_NO_MEMORY(edata);
-
- task->private = edata;
-
- edata->tls_params = tls_initialise(edata, task->lp_ctx);
- NT_STATUS_HAVE_NO_MEMORY(edata->tls_params);
-
- return NT_STATUS_OK;
-}
#!/usr/bin/python
+# -*- coding: utf-8 -*-
# Unix SMB/CIFS implementation.
# Copyright © Jelmer Vernooij <jelmer@samba.org> 2008
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
-def SWAT(environ, start_response):
+def __call__(environ, start_response):
status = '200 OK'
- response_headers = [('Content-type','text/plain')]
+ response_headers = [('Content-type','text/html')]
start_response(status, response_headers)
- return ['Hello world!\n']
+ yield '<table>\n'
+ for key, value in environ.items():
+ if isinstance(value, str):
+ yield '\t<tr><td><b>%s</b></td><td>%s</td></tr>\n' % (key, value)
+
+ yield '</table>\n'
+
+if __name__ == '__main__':
+ from wsgiref import simple_server
+ httpd = simple_server.make_server('localhost', 8090, __call__)
+ print "Serving HTTP on port 8090..."
+ httpd.serve_forever()
web server startup
Copyright (C) Andrew Tridgell 2005
+ Copyright (C) Jelmer Vernooij 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
#include "system/network.h"
#include "lib/socket/netif.h"
#include "lib/tls/tls.h"
+#include "lib/util/dlinklist.h"
#include "param/param.h"
/* don't allow connections to hang around forever */
*/
static int websrv_destructor(struct websrv_context *web)
{
- if (web->output.fd != -1) {
- close(web->output.fd);
- }
return 0;
}
stream_terminate_connection(conn, "websrv_timeout: timed out");
}
+/*
+ setup for a raw http level error
+*/
+void http_error(struct websrv_context *web, const char *status, const char *info)
+{
+ char *s;
+ s = talloc_asprintf(web,"<HTML><HEAD><TITLE>Error %s</TITLE></HEAD><BODY><H1>Error %s</H1><pre>%s</pre><p></BODY></HTML>\r\n\r\n",
+ status, status, info);
+ if (s == NULL) {
+ stream_terminate_connection(web->conn, "http_error: out of memory");
+ return;
+ }
+ websrv_output_headers(web, status, NULL);
+ websrv_output(web, s, strlen(s));
+}
+
+void websrv_output_headers(struct websrv_context *web, const char *status, struct http_header *headers)
+{
+ char *s;
+ DATA_BLOB b;
+ struct http_header *hdr;
+
+ s = talloc_asprintf(web, "HTTP/1.0 %s\r\n", status);
+ if (s == NULL) return;
+ for (hdr = headers; hdr; hdr = hdr->next) {
+ s = talloc_asprintf_append_buffer(s, "%s: %s\r\n", hdr->name, hdr->value);
+ }
+
+ s = talloc_asprintf_append_buffer(s, "\r\n");
+
+ b = web->output.content;
+ web->output.content = data_blob_string_const(s);
+ websrv_output(web, b.data, b.length);
+ data_blob_free(&b);
+}
+
+void websrv_output(struct websrv_context *web, void *data, size_t length)
+{
+ data_blob_append(web, &web->output.content, data, length);
+ EVENT_FD_NOT_READABLE(web->conn->event.fde);
+ EVENT_FD_WRITEABLE(web->conn->event.fde);
+ web->output.output_pending = true;
+}
+
+
+/*
+ parse one line of header input
+*/
+NTSTATUS http_parse_header(struct websrv_context *web, const char *line)
+{
+ if (line[0] == 0) {
+ web->input.end_of_headers = true;
+ } else if (strncasecmp(line,"GET ", 4)==0) {
+ web->input.url = talloc_strndup(web, &line[4], strcspn(&line[4], " \t"));
+ } else if (strncasecmp(line,"POST ", 5)==0) {
+ web->input.post_request = true;
+ web->input.url = talloc_strndup(web, &line[5], strcspn(&line[5], " \t"));
+ } else if (strchr(line, ':') == NULL) {
+ http_error(web, "400 Bad request", "This server only accepts GET and POST requests");
+ return NT_STATUS_INVALID_PARAMETER;
+ } else if (strncasecmp(line, "Content-Length: ", 16)==0) {
+ web->input.content_length = strtoul(&line[16], NULL, 10);
+ } else {
+ struct http_header *hdr = talloc_zero(web, struct http_header);
+ char *colon = strchr(line, ':');
+ if (colon == NULL) {
+ http_error(web, "500 Internal Server Error", "invalidly formatted header");
+ return NT_STATUS_INVALID_PARAMETER;
+ }
+
+ hdr->name = talloc_strndup(hdr, line, colon-line);
+ hdr->value = talloc_strdup(hdr, colon+1);
+ DLIST_ADD(web->input.headers, hdr);
+ }
+
+ /* ignore all other headers for now */
+ return NT_STATUS_OK;
+}
+
/*
called when a web connection becomes readable
*/
static void websrv_recv(struct stream_connection *conn, uint16_t flags)
{
+ struct web_server_data *wdata;
struct websrv_context *web = talloc_get_type(conn->private,
struct websrv_context);
NTSTATUS status;
destroy the stack variables being used by that
rendering process when we handle the timeout. */
if (!talloc_reference(web->task, web)) goto failed;
- http_process_input(web);
+ wdata = talloc_get_type(web->task->private, struct web_server_data);
+ if (wdata == NULL) goto failed;
+ wdata->http_process_input(wdata, web);
talloc_unlink(web->task, web);
}
return;
}
+
/*
called when a web connection becomes writable
*/
web->output.nsent += nsent;
- /* possibly read some more raw data from a file */
- if (web->output.content.length == web->output.nsent &&
- web->output.fd != -1) {
- uint8_t buf[2048];
- ssize_t nread;
-
- data_blob_free(&web->output.content);
- web->output.nsent = 0;
-
- nread = read(web->output.fd, buf, sizeof(buf));
- if (nread == -1 && errno == EINTR) {
- return;
- }
- if (nread <= 0) {
- close(web->output.fd);
- web->output.fd = -1;
- nread = 0;
- }
- web->output.content = data_blob_talloc(web, buf, nread);
- }
-
- if (web->output.content.length == web->output.nsent &&
- web->output.fd == -1) {
+ if (web->output.content.length == web->output.nsent) {
stream_terminate_connection(web->conn, "websrv_send: finished sending");
}
}
static void websrv_accept(struct stream_connection *conn)
{
struct task_server *task = talloc_get_type(conn->private, struct task_server);
- struct esp_data *edata = talloc_get_type(task->private, struct esp_data);
+ struct web_server_data *wdata = talloc_get_type(task->private, struct web_server_data);
struct websrv_context *web;
struct socket_context *tls_socket;
web->task = task;
web->conn = conn;
conn->private = web;
- web->output.fd = -1;
talloc_set_destructor(web, websrv_destructor);
event_add_timed(conn->event.ctx, web,
websrv_timeout, web);
/* Overwrite the socket with a (possibly) TLS socket */
- tls_socket = tls_init_server(edata->tls_params, conn->socket,
+ tls_socket = tls_init_server(wdata->tls_params, conn->socket,
conn->event.fde, "GPHO");
/* We might not have TLS, or it might not have initilised */
if (tls_socket) {
NTSTATUS status;
uint16_t port = lp_web_port(task->lp_ctx);
const struct model_ops *model_ops;
+ struct web_server_data *wdata;
task_server_set_title(task, "task[websrv]");
/* run the web server as a single process */
- model_ops = process_model_byname("single");
+ model_ops = process_model_startup(task->event_ctx, "single");
if (!model_ops) goto failed;
if (lp_interfaces(task->lp_ctx) && lp_bind_interfaces_only(task->lp_ctx)) {
/* startup the esp processor - unfortunately we can't do this
per connection as that wouldn't allow for session variables */
- status = http_setup_esp(task);
- if (!NT_STATUS_IS_OK(status)) goto failed;
+ wdata = talloc_zero(task, struct web_server_data);
+ if (wdata == NULL)goto failed;
+
+ task->private = wdata;
+
+ wdata->tls_params = tls_initialise(wdata, task->lp_ctx);
+ if (wdata->tls_params == NULL) goto failed;
+
+ if (!wsgi_initialize(wdata)) goto failed;
return;
#include "smbd/process_model.h"
+struct websrv_context;
+
+struct web_server_data {
+ struct tls_params *tls_params;
+ void (*http_process_input)(struct web_server_data *wdata,
+ struct websrv_context *web);
+ void *private;
+};
+
+struct http_header {
+ char *name;
+ char *value;
+ struct http_header *prev, *next;
+};
+
/*
context of one open web connection
*/
struct websrv_context {
struct task_server *task;
struct stream_connection *conn;
- struct {
+ struct websrv_request_input {
bool tls_detect;
bool tls_first_char;
uint8_t first_byte;
char *url;
unsigned content_length;
bool post_request;
- const char *content_type;
- const char *query_string;
- const char *user_agent;
- const char *referer;
- const char *host;
- const char *accept_encoding;
- const char *accept_language;
- const char *accept_charset;
- const char *cookie;
- const char *session_key;
+ struct http_header *headers;
} input;
- struct {
+ struct websrv_request_output {
bool output_pending;
DATA_BLOB content;
- int fd;
+ bool headers_sent;
unsigned nsent;
- int response_code;
- const char **headers;
} output;
struct session_data *session;
};
-/*
- context for long term storage in the web server, to support session[]
- and application[] data. Stored in task->private.
-*/
-struct esp_data {
- struct session_data {
- struct session_data *next, *prev;
- struct esp_data *edata;
- const char *id;
- struct MprVar *data;
- struct timed_event *te;
- int lifetime;
- } *sessions;
- struct MprVar *application_data;
- struct tls_params *tls_params;
-};
-
#include "web_server/proto.h"
--- /dev/null
+/*
+ Unix SMB/CIFS implementation.
+ Samba utility functions
+ Copyright © Jelmer Vernooij <jelmer@samba.org> 2008
+
+ Implementation of the WSGI interface described in PEP0333
+ (http://www.python.org/dev/peps/pep-0333)
+
+ 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 "web_server/web_server.h"
+#include "lib/util/dlinklist.h"
+#include "lib/util/data_blob.h"
+#include "lib/tls/tls.h"
+#include <Python.h>
+
+typedef struct {
+ PyObject_HEAD
+ struct websrv_context *web;
+} web_request_Object;
+
+static PyObject *start_response(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+ PyObject *response_header, *exc_info = NULL;
+ char *status;
+ int i;
+ const char *kwnames[] = {
+ "status", "response_header", "exc_info", NULL
+ };
+ web_request_Object *py_web = (web_request_Object *)self;
+ struct websrv_context *web = py_web->web;
+ struct http_header *headers = NULL;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs, "sO|O:start_response", discard_const_p(char *, kwnames), &status, &response_header, &exc_info)) {
+ return NULL;
+ }
+
+ /* FIXME: exc_info */
+
+ if (!PyList_Check(response_header)) {
+ PyErr_SetString(PyExc_TypeError, "response_header should be list");
+ return NULL;
+ }
+
+ for (i = 0; i < PyList_Size(response_header); i++) {
+ struct http_header *hdr = talloc_zero(web, struct http_header);
+ PyObject *item = PyList_GetItem(response_header, i);
+ PyObject *py_name, *py_value;
+
+ if (!PyTuple_Check(item)) {
+ PyErr_SetString(PyExc_TypeError, "Expected tuple");
+ return NULL;
+ }
+
+ if (PyTuple_Size(item) != 2) {
+ PyErr_SetString(PyExc_TypeError, "header tuple has invalid size, expected 2");
+ return NULL;
+ }
+
+ py_name = PyTuple_GetItem(item, 0);
+
+ if (!PyString_Check(py_name)) {
+ PyErr_SetString(PyExc_TypeError, "header name should be string");
+ return NULL;
+ }
+
+ py_value = PyTuple_GetItem(item, 1);
+ if (!PyString_Check(py_value)) {
+ PyErr_SetString(PyExc_TypeError, "header value should be string");
+ return NULL;
+ }
+
+ hdr->name = talloc_strdup(hdr, PyString_AsString(py_name));
+ hdr->value = talloc_strdup(hdr, PyString_AsString(py_value));
+ DLIST_ADD(headers, hdr);
+ }
+
+ websrv_output_headers(web, status, headers);
+
+ return Py_None;
+}
+
+static PyMethodDef web_request_methods[] = {
+ { "start_response", (PyCFunction)start_response, METH_VARARGS|METH_KEYWORDS, NULL },
+ { NULL }
+};
+
+
+PyTypeObject web_request_Type = {
+ PyObject_HEAD_INIT(NULL) 0,
+ .tp_name = "wsgi.Request",
+ .tp_methods = web_request_methods,
+ .tp_basicsize = sizeof(web_request_Object),
+ .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
+};
+
+typedef struct {
+ PyObject_HEAD
+} error_Stream_Object;
+
+static PyObject *py_error_flush(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+ /* Nothing to do here */
+ return Py_None;
+}
+
+static PyObject *py_error_write(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+ const char *kwnames[] = { "str", NULL };
+ char *str = NULL;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s:write", discard_const_p(char *, kwnames), &str)) {
+ return NULL;
+ }
+
+ DEBUG(0, ("WSGI App: %s", str));
+
+ return Py_None;
+}
+
+static PyObject *py_error_writelines(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+ const char *kwnames[] = { "seq", NULL };
+ PyObject *seq = NULL, *item;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:writelines", discard_const_p(char *, kwnames), &seq)) {
+ return NULL;
+ }
+
+ while ((item = PyIter_Next(seq))) {
+ char *str = PyString_AsString(item);
+
+ DEBUG(0, ("WSGI App: %s", str));
+ }
+
+ return Py_None;
+}
+
+static PyMethodDef error_Stream_methods[] = {
+ { "flush", (PyCFunction)py_error_flush, METH_VARARGS|METH_KEYWORDS, NULL },
+ { "write", (PyCFunction)py_error_write, METH_VARARGS|METH_KEYWORDS, NULL },
+ { "writelines", (PyCFunction)py_error_writelines, METH_VARARGS|METH_KEYWORDS, NULL },
+ { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject error_Stream_Type = {
+ PyObject_HEAD_INIT(NULL) 0,
+ .tp_name = "wsgi.ErrorStream",
+ .tp_basicsize = sizeof(error_Stream_Object),
+ .tp_methods = error_Stream_methods,
+ .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
+};
+
+typedef struct {
+ PyObject_HEAD
+ struct websrv_context *web;
+ size_t offset;
+} input_Stream_Object;
+
+static PyObject *py_input_read(PyObject *_self, PyObject *args, PyObject *kwargs)
+{
+ const char *kwnames[] = { "size", NULL };
+ PyObject *ret;
+ input_Stream_Object *self = (input_Stream_Object *)_self;
+ int size = -1;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|i", discard_const_p(char *, kwnames), &size))
+ return NULL;
+
+ /* Don't read beyond buffer boundaries */
+ if (size == -1)
+ size = self->web->input.partial.length-self->offset;
+ else
+ size = MIN(size, self->web->input.partial.length-self->offset);
+
+ ret = PyString_FromStringAndSize((char *)self->web->input.partial.data+self->offset, size);
+ self->offset += size;
+
+ return ret;
+}
+
+static PyObject *py_input_readline(PyObject *_self)
+{
+ input_Stream_Object *self = (input_Stream_Object *)_self;
+ /* FIXME */
+ PyErr_SetString(PyExc_NotImplementedError,
+ "readline() not yet implemented");
+ return NULL;
+}
+
+static PyObject *py_input_readlines(PyObject *_self, PyObject *args, PyObject *kwargs)
+{
+ const char *kwnames[] = { "hint", NULL };
+ PyObject *ret;
+ int hint;
+ input_Stream_Object *self = (input_Stream_Object *)_self;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|i", discard_const_p(char *, kwnames), &hint))
+ return NULL;
+
+ /* FIXME */
+ PyErr_SetString(PyExc_NotImplementedError,
+ "readlines() not yet implemented");
+ return NULL;
+}
+
+static PyObject *py_input___iter__(PyObject *_self)
+{
+ input_Stream_Object *self = (input_Stream_Object *)_self;
+ /* FIXME */
+ PyErr_SetString(PyExc_NotImplementedError,
+ "__iter__() not yet implemented");
+ return NULL;
+}
+
+static PyMethodDef input_Stream_methods[] = {
+ { "read", (PyCFunction)py_input_read, METH_VARARGS|METH_KEYWORDS, NULL },
+ { "readline", (PyCFunction)py_input_readline, METH_NOARGS, NULL },
+ { "readlines", (PyCFunction)py_input_readlines, METH_VARARGS|METH_KEYWORDS, NULL },
+ { "__iter__", (PyCFunction)py_input___iter__, METH_NOARGS, NULL },
+ { NULL, NULL, 0, NULL }
+};
+
+PyTypeObject input_Stream_Type = {
+ PyObject_HEAD_INIT(NULL) 0,
+ .tp_name = "wsgi.InputStream",
+ .tp_basicsize = sizeof(input_Stream_Object),
+ .tp_methods = input_Stream_methods,
+ .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
+};
+
+static PyObject *Py_InputHttpStream(struct websrv_context *web)
+{
+ input_Stream_Object *ret = PyObject_New(input_Stream_Object, &input_Stream_Type);
+ ret->web = web;
+ ret->offset = 0;
+ return (PyObject *)ret;
+}
+
+static PyObject *Py_ErrorHttpStream(void)
+{
+ error_Stream_Object *ret = PyObject_New(error_Stream_Object, &error_Stream_Type);
+ return (PyObject *)ret;
+}
+
+static PyObject *create_environ(bool tls, int content_length, struct http_header *headers, const char *request_method, const char *servername, int serverport, PyObject *inputstream, const char *request_string)
+{
+ PyObject *env;
+ PyObject *errorstream;
+ PyObject *py_scheme;
+ struct http_header *hdr;
+ char *questionmark;
+
+ env = PyDict_New();
+ if (env == NULL) {
+ return NULL;
+ }
+
+ errorstream = Py_ErrorHttpStream();
+ if (errorstream == NULL) {
+ Py_DECREF(env);
+ Py_DECREF(inputstream);
+ return NULL;
+ }
+
+ PyDict_SetItemString(env, "wsgi.input", inputstream);
+ PyDict_SetItemString(env, "wsgi.errors", errorstream);
+ PyDict_SetItemString(env, "wsgi.version", Py_BuildValue("(i,i)", 1, 0));
+ PyDict_SetItemString(env, "wsgi.multithread", Py_False);
+ PyDict_SetItemString(env, "wsgi.multiprocess", Py_True);
+ PyDict_SetItemString(env, "wsgi.run_once", Py_False);
+ PyDict_SetItemString(env, "SERVER_PROTOCOL", PyString_FromString("HTTP/1.0"));
+ if (content_length > 0) {
+ PyDict_SetItemString(env, "CONTENT_LENGTH", PyLong_FromLong(content_length));
+ }
+ PyDict_SetItemString(env, "REQUEST_METHOD", PyString_FromString(request_method));
+
+ questionmark = strchr(request_string, '?');
+ if (questionmark == NULL) {
+ PyDict_SetItemString(env, "SCRIPT_NAME", PyString_FromString(request_string));
+ } else {
+ PyDict_SetItemString(env, "QUERY_STRING", PyString_FromString(questionmark+1));
+ PyDict_SetItemString(env, "SCRIPT_NAME", PyString_FromStringAndSize(request_string, questionmark-request_string));
+ }
+
+ PyDict_SetItemString(env, "SERVER_NAME", PyString_FromString(servername));
+ PyDict_SetItemString(env, "SERVER_PORT", PyInt_FromLong(serverport));
+ for (hdr = headers; hdr; hdr = hdr->next) {
+ char *name;
+ if (!strcasecmp(hdr->name, "Content-Type")) {
+ PyDict_SetItemString(env, "CONTENT_TYPE", PyString_FromString(hdr->value));
+ } else {
+ asprintf(&name, "HTTP_%s", hdr->name);
+ PyDict_SetItemString(env, name, PyString_FromString(hdr->value));
+ free(name);
+ }
+ }
+
+ if (tls) {
+ py_scheme = PyString_FromString("https");
+ } else {
+ py_scheme = PyString_FromString("http");
+ }
+ PyDict_SetItemString(env, "wsgi.url_scheme", py_scheme);
+
+ return env;
+}
+
+static void wsgi_process_http_input(struct web_server_data *wdata,
+ struct websrv_context *web)
+{
+ PyObject *py_environ, *result, *item, *iter;
+ PyObject *request_handler = wdata->private;
+ struct socket_address *socket_address;
+
+ web_request_Object *py_web = PyObject_New(web_request_Object, &web_request_Type);
+ py_web->web = web;
+
+ socket_address = socket_get_my_addr(web->conn->socket, web);
+ py_environ = create_environ(tls_enabled(web->conn->socket),
+ web->input.content_length,
+ web->input.headers,
+ web->input.post_request?"POST":"GET",
+ socket_address->addr,
+ socket_address->port,
+ Py_InputHttpStream(web),
+ web->input.url
+ );
+ if (py_environ == NULL) {
+ DEBUG(0, ("Unable to create WSGI environment object\n"));
+ return;
+ }
+
+ result = PyObject_CallMethod(request_handler, discard_const_p(char, "__call__"), discard_const_p(char, "OO"),
+ py_environ, PyObject_GetAttrString((PyObject *)py_web, "start_response"));
+
+ if (result == NULL) {
+ DEBUG(0, ("error while running WSGI code\n"));
+ return;
+ }
+
+ iter = PyObject_GetIter(result);
+ Py_DECREF(result);
+
+ /* Now, iter over all the data returned */
+
+ while ((item = PyIter_Next(iter))) {
+ websrv_output(web, PyString_AsString(item), PyString_Size(item));
+ Py_DECREF(item);
+ }
+
+ Py_DECREF(iter);
+}
+
+bool wsgi_initialize(struct web_server_data *wdata)
+{
+ PyObject *py_swat;
+
+ Py_Initialize();
+
+ if (PyType_Ready(&web_request_Type) < 0)
+ return false;
+
+ if (PyType_Ready(&input_Stream_Type) < 0)
+ return false;
+
+ if (PyType_Ready(&error_Stream_Type) < 0)
+ return false;
+
+ wdata->http_process_input = wsgi_process_http_input;
+ py_swat = PyImport_Import(PyString_FromString("swat"));
+ if (py_swat == NULL) {
+ DEBUG(0, ("Unable to find SWAT\n"));
+ return false;
+ }
+ wdata->private = py_swat;
+ return true;
+}
# Start SUBSYSTEM WINBIND
[MODULE::WINBIND]
INIT_FUNCTION = server_service_winbind_init
-SUBSYSTEM = smbd
+SUBSYSTEM = samba
PRIVATE_DEPENDENCIES = \
WB_HELPER \
IDMAP \
dn = ldb_dn_new(tmp_ctx, ldb, "CN=CONFIG");
if (dn == NULL) goto failed;
- ret = ldb_search(ldb, dn, LDB_SCOPE_BASE, NULL, NULL, &res);
+ ret = ldb_search(ldb, tmp_ctx, &res, dn, LDB_SCOPE_BASE, NULL, NULL);
if (ret != LDB_SUCCESS) goto failed;
- talloc_steal(tmp_ctx, res);
-
if (res->count != 1) {
ret = -1;
goto failed;
goto failed;
}
- ret = ldb_search_exp_fmt(ldb, tmp_ctx, &res, NULL, LDB_SCOPE_SUBTREE,
+ ret = ldb_search(ldb, tmp_ctx, &res, NULL, LDB_SCOPE_SUBTREE,
NULL, "(&(|(type=ID_TYPE_BOTH)(type=%s))"
"(xidNumber=%u))", id_type, unixid->id);
if (ret != LDB_SUCCESS) {
return NT_STATUS_OK;
}
- ret = ldb_search_exp_fmt(ldb, tmp_ctx, &res, NULL, LDB_SCOPE_SUBTREE,
+ ret = ldb_search(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) {
/* 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,
+ ret = ldb_search(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) {
goto failed;
}
- ret = ldb_search(ldb, dn, LDB_SCOPE_BASE, NULL, NULL, &res);
+ ret = ldb_search(ldb, tmp_ctx, &res, dn, LDB_SCOPE_BASE, NULL, NULL);
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;
/* within the winbind task we want to be a single process, so
ask for the single process model ops and pass these to the
stream_setup_socket() call. */
- model_ops = process_model_byname("single");
+ model_ops = process_model_startup(task->event_ctx, "single");
if (!model_ops) {
task_server_terminate(task,
"Can't find 'single' process model_ops");
# Start SUBSYSTEM WREPL_SRV
[MODULE::WREPL_SRV]
INIT_FUNCTION = server_service_wrepl_init
-SUBSYSTEM = smbd
+SUBSYSTEM = samba
PRIVATE_DEPENDENCIES = \
LIBCLI_WREPL WINSDB process_model
# End SUBSYSTEM WREPL_SRV
(long long)owner_in->min_version,
(long long)owner_in->max_version);
NT_STATUS_HAVE_NO_MEMORY(filter);
- ret = ldb_search(service->wins_db->ldb, NULL, LDB_SCOPE_SUBTREE, filter, NULL, &res);
+ ret = ldb_search(service->wins_db->ldb, call, &res, NULL, LDB_SCOPE_SUBTREE, NULL, "%s", filter);
if (ret != LDB_SUCCESS) return NT_STATUS_INTERNAL_DB_CORRUPTION;
- talloc_steal(call, res);
DEBUG(10,("WINSREPL: filter '%s' count %d\n", filter, res->count));
if (res->count == 0) {
/* within the wrepl task we want to be a single process, so
ask for the single process model ops and pass these to the
stream_setup_socket() call. */
- model_ops = process_model_byname("single");
+ model_ops = process_model_startup(service->task->event_ctx, "single");
if (!model_ops) {
DEBUG(0,("Can't find 'single' process model_ops"));
return NT_STATUS_INTERNAL_ERROR;
/* within the wrepl task we want to be a single process, so
ask for the single process model ops and pass these to the
stream_setup_socket() call. */
- model_ops = process_model_byname("single");
+ model_ops = process_model_startup(task->event_ctx, "single");
if (!model_ops) {
DEBUG(0,("Can't find 'single' process model_ops"));
return NT_STATUS_INTERNAL_ERROR;
"(expireTime<=%s))",
owner_filter, now_timestr);
NT_STATUS_HAVE_NO_MEMORY(filter);
- ret = ldb_search(service->wins_db->ldb, NULL, LDB_SCOPE_SUBTREE, filter, NULL, &res);
+ ret = ldb_search(service->wins_db->ldb, tmp_mem, &res, NULL, LDB_SCOPE_SUBTREE, NULL, "%s", filter);
if (ret != LDB_SUCCESS) return NT_STATUS_INTERNAL_DB_CORRUPTION;
- talloc_steal(tmp_mem, res);
DEBUG(10,("WINS scavenging: filter '%s' count %d\n", filter, res->count));
tombstone_extra_time = timeval_add(&service->startup_time,
"(!(recordState=%u))(expireTime<=%s))",
owner_filter, WREPL_STATE_ACTIVE, now_timestr);
NT_STATUS_HAVE_NO_MEMORY(filter);
- ret = ldb_search(service->wins_db->ldb, NULL, LDB_SCOPE_SUBTREE, filter, NULL, &res);
+ ret = ldb_search(service->wins_db->ldb, tmp_mem, &res, NULL, LDB_SCOPE_SUBTREE, NULL, "%s", filter);
if (ret != LDB_SUCCESS) return NT_STATUS_INTERNAL_DB_CORRUPTION;
- talloc_steal(tmp_mem, res);
DEBUG(10,("WINS scavenging: filter '%s' count %d\n", filter, res->count));
tombstone_extra_time = timeval_add(&service->startup_time,
"(recordState=%u)(expireTime<=%s))",
owner_filter, WREPL_STATE_ACTIVE, now_timestr);
NT_STATUS_HAVE_NO_MEMORY(filter);
- ret = ldb_search(service->wins_db->ldb, NULL, LDB_SCOPE_SUBTREE, filter, NULL, &res);
+ ret = ldb_search(service->wins_db->ldb, tmp_mem, &res, NULL, LDB_SCOPE_SUBTREE, NULL, "%s", filter);
if (ret != LDB_SUCCESS) return NT_STATUS_INTERNAL_DB_CORRUPTION;
- talloc_steal(tmp_mem, res);
DEBUG(10,("WINS scavenging: filter '%s' count %d\n", filter, res->count));
for (i=0; i < res->count; i++) {
if (!dn) goto failed;
/* find the record in the WINS database */
- ret = ldb_search(ldb, dn, LDB_SCOPE_BASE,
- NULL, NULL, &res);
+ ret = ldb_search(ldb, tmp_ctx, &res, dn, LDB_SCOPE_BASE, NULL, NULL);
if (ret != LDB_SUCCESS) goto failed;
- talloc_steal(tmp_ctx, res);
if (res->count > 1) goto failed;
if (res->count == 1) {
service->config.seqnumber = new_seqnumber;
/* find the record in the WINS database */
- ret = ldb_search(service->config.ldb, ldb_dn_new(tmp_ctx, service->config.ldb, "CN=PARTNERS"), LDB_SCOPE_SUBTREE,
- "(objectClass=wreplPartner)", NULL, &res);
+ ret = ldb_search(service->config.ldb, tmp_ctx, &res,
+ ldb_dn_new(tmp_ctx, service->config.ldb, "CN=PARTNERS"),
+ LDB_SCOPE_SUBTREE, NULL, "(objectClass=wreplPartner)");
if (ret != LDB_SUCCESS) goto failed;
- talloc_steal(tmp_ctx, res);
/* first disable all existing partners */
for (partner=service->partners; partner; partner = partner->next) {
}
/* find the record in the WINS database */
- ret = ldb_search(ldb, NULL, LDB_SCOPE_SUBTREE,
- "(objectClass=winsRecord)", attrs, &res);
+ ret = ldb_search(ldb, tmp_ctx, &res, NULL, LDB_SCOPE_SUBTREE,
+ attrs, "(objectClass=winsRecord)");
status = NT_STATUS_INTERNAL_DB_CORRUPTION;
if (ret != LDB_SUCCESS) goto failed;
- talloc_steal(tmp_ctx, res);
for (i=0; i < res->count; i++) {
wins_owner = ldb_msg_find_attr_as_string(res->msgs[i], "winsOwner", NULL);
failed=`expr $failed + 1`
fi
+wellknown_object_test() {
+ local guid=$1
+ local object=$2
+ local basedns
+ local dn
+ local r
+ local c
+ local n
+ local failed=0
+
+ basedns="<WKGUID=${guid},${BASEDN}> <wkGuId=${guid},${BASEDN}>"
+ for dn in ${basedns}; do
+ echo "Test ${dn} => ${object}"
+ r=`bin/ldbsearch $options $CONFIGURATION -H $p://$SERVER '(objectClass=*)' -b "${dn}" | grep 'dn: '`
+ n=`echo "${r}" | grep 'dn: ' | wc -l`
+ c=`echo "${r}" | grep "${object}" | wc -l`
+
+ if [ $n -lt 1 ]; then
+ echo "Object not found by WKGUID"
+ failed=`expr $failed + 1`
+ continue
+ fi
+ if [ $c -lt 1 ]; then
+ echo "Wrong object found by WKGUID: [${r}]"
+ failed=`expr $failed + 1`
+ continue
+ fi
+ done
+
+ return $failed
+}
+
+wellknown_object_test 22B70C67D56E4EFB91E9300FCA3DC1AA ForeignSecurityPrincipals
+st=$?
+if [ x"$st" != x"0" ]; then
+ failed=`expr $failed + $st`
+fi
+wellknown_object_test 2FBAC1870ADE11D297C400C04FD8D5CD Infrastructure
+st=$?
+if [ x"$st" != x"0" ]; then
+ failed=`expr $failed + $st`
+fi
+wellknown_object_test AB1D30F3768811D1ADED00C04FD8D5CD System
+st=$?
+if [ x"$st" != x"0" ]; then
+ failed=`expr $failed + $st`
+fi
+wellknown_object_test A361B2FFFFD211D1AA4B00C04FD7D83A Domain Controllers
+st=$?
+if [ x"$st" != x"0" ]; then
+ failed=`expr $failed + $st`
+fi
+wellknown_object_test AA312825768811D1ADED00C04FD8D5CD Computers
+st=$?
+if [ x"$st" != x"0" ]; then
+ failed=`expr $failed + $st`
+fi
+wellknown_object_test A9D1CA15768811D1ADED00C04FD8D5CD Users
+st=$?
+if [ x"$st" != x"0" ]; then
+ failed=`expr $failed + $st`
+fi
+
+echo "Getting HEX GUID/SID of $BASEDN"
+HEXDN=`bin/ldbsearch $CONFIGURATION $options -b "$BASEDN" -H $p://$SERVER -s base "(objectClass=*)" --controls=extended_dn:1:0 | grep 'dn: ' | cut -d ' ' -f2-`
+HEXGUID=`echo "$HEXDN" | cut -d ';' -f1`
+HEXSID=`echo "$HEXDN" | cut -d ';' -f2`
+echo "HEXGUID[$HEXGUID]"
+echo "HEXSID[$HEXSID]"
+
+echo "Getting STR GUID/SID of $BASEDN"
+STRDN=`bin/ldbsearch $CONFIGURATION $options -b "$BASEDN" -H $p://$SERVER -s base "(objectClass=*)" --controls=extended_dn:1:1 | grep 'dn: ' | cut -d ' ' -f2-`
+echo "STRDN: $STRDN"
+STRGUID=`echo "$STRDN" | cut -d ';' -f1`
+STRSID=`echo "$STRDN" | cut -d ';' -f2`
+echo "STRGUID[$STRGUID]"
+echo "STRSID[$STRSID]"
+
+SPECIALDNS="$HEXGUID $HEXSID $STRGUID $STRSID"
+for SPDN in $SPECIALDNS; do
+ echo "Search for $SPDN"
+ nentries=`bin/ldbsearch $options $CONFIGURATION -H $p://$SERVER -s base -b "$SPDN" '(objectClass=*)' | grep "dn: $BASEDN" | wc -l`
+ if [ $nentries -lt 1 ]; then
+ echo "Special search returned 0 items"
+ failed=`expr $failed + 1`
+ fi
+done
exit $failed
+++ /dev/null
-#!/bin/sh
-exec smbscript "$0" ${1+"$@"}
-
-var options = GetOptions(ARGV,
- "POPT_COMMON_SAMBA");
-if (options == undefined) {
- println("Failed to parse options");
- return -1;
-}
-
-libinclude("base.js");
-
-var obj = new Object();
-obj.FOO = "foo";
-obj.BAR = "bar";
-var str1 = "${FOO}:${BAR}";
-var str2 = "${FOO}:${BAR} "; // note the space after the brace
-var sub1 = substitute_var(str1, obj);
-var sub2 = substitute_var(str2, obj);
-
-assert(str1 + " " == str2);
-assert(sub1 + " " == sub2);
-exit(0);
+++ /dev/null
-/*
- demonstrate some bugs in ejs
-
- tridge <appweb@tridgell.net>
-*/
-
-
-/****************************************
-demo a bug in constructing arrays
-fix at http://build.samba.org/build.pl?function=diff;tree=samba4;revision=7124
-status: FIXED
-*****************************************/
-function arraybug() {
- var a;
-
- println("First with 3 elements");
- a = new Array("one", "two", "three");
- printVars(a);
- assert(a.length == 3);
- assert(a[0] == "one");
- assert(a[1] == "two");
- assert(a[2] == "three");
-
- println("with a array length");
- a = new Array(5);
- printVars(a);
- assert(a.length == 5);
-
- println("\nNow with 1 element");
- a = new Array("one");
- printVars(a);
- assert(a.length == 1);
- assert(a[0] == "one");
-
- println("ALL OK");
-}
-
-
-/****************************************
-demo a bug in variable arguments
-fix at http://build.samba.org/build.pl?function=diff;tree=samba4;revision=7085
-status: FIXED
-*****************************************/
-function argsbug() {
- println("we should have been called with 3 arguments");
- assert(arguments.length == 3);
- assert(arguments[0] == "one");
- assert(arguments[1] == "two");
- assert(arguments[2] == "three");
-}
-
-
-/****************************************
-demo a bug in constructing objects
-no fix available yet
-status: SUBMITTED
-*****************************************/
-function MyObj() {
- var o = new Object();
- o.test = 42;
- return o;
-}
-
-function objbug() {
- println("the docs say you should use 'new'");
- var o1 = new MyObj();
- var o2 = MyObj();
- printVars(o1);
- printVars(o2);
- assert(o1.test == 42);
- assert(o2.test == 42);
-}
-
-/*
- demo a expression handling bug
- status: FIXED
-*/
-function exprbug() {
- var a = new Array(10);
- var i;
- for (i=0;i<4;i++) {
- a[1+(i*2)] = i;
- a[2+(i*2)] = i*2;
- }
-}
-
-/****************************************
-demo lack of recursion
-fix in http://build.samba.org/build.pl?function=diff;tree=samba4;revision=7127
-status: FIXED
-*****************************************/
-function fibonacci(n) {
- if (n < 3) {
- return 1;
- }
- return fibonacci(n-1) + fibonacci(n-2);
-}
-
-function recursebug() {
- println("First 10 fibonacci numbers:");
- for (i=0;i<10;i++) {
- println("fibonacci(" + i + ")=" + fibonacci(i));
- }
-}
-
-/****************************************
-demo lack of function variables inside functions
-status: FIXED IN SAMBA
-*****************************************/
-function callback()
-{
- return "testing";
-}
-
-function fnbug(c)
-{
- s = c();
- assert(s == "testing");
-}
-
-/****************************************
-demo incorrect handling of reserved words in strings
-status: SUBMITTED
-*****************************************/
-function reservedbug()
-{
- assert("funct" + "ion" == 'function');
-}
-
-
-/****************************************
-demo incorrect handling of boolean functions
-status: SUBMITTED
-*****************************************/
-function no()
-{
- return false;
-}
-
-function boolbug()
-{
- assert(false == no());
- assert(!no());
-}
-
-
-/* run the tests */
-arraybug();
-argsbug("one", "two", "three");
-recursebug();
-exprbug();
-fnbug(callback);
-reservedbug();
-boolbug();
-objbug();
+++ /dev/null
-#!/bin/sh
-exec smbscript "$0" ${1+"$@"}
-/*
- demonstrate access to ldb databases from ejs
-*/
-
-
-var ldb = ldb_init();
-var sys;
-var options = GetOptions(ARGV,
- "POPT_AUTOHELP",
- "POPT_COMMON_SAMBA");
-if (options == undefined) {
- println("Failed to parse options");
- return -1;
-}
-
-libinclude("base.js");
-
-if (options.ARGV.length != 1) {
- println("Usage: ldb.js <prefix>");
- return -1;
-}
-
-prefix = options.ARGV[0];
-
-function basic_tests(ldb)
-{
- println("Running basic tests");
- ok = ldb.add("
-dn: cn=x,cn=test
-objectClass: foo
-x: 3
-");
- assert(ok.error == 0);
-
- println("Testing ldb.search");
- var res = ldb.search("(objectClass=*)");
- assert(res.msgs[0].objectClass[0] == "foo");
- assert(res.msgs[0].dn == "cn=x,cn=test");
- assert(res.msgs[0].x == 3);
-
- ok = ldb.add("
-dn: cn=x2,cn=test
-objectClass: foo
-x: 4
-");
- assert(ok.error == 0);
- var attrs = new Array("x");
- res = ldb.search("x=4", NULL, ldb.SCOPE_DEFAULT, attrs);
- assert(res.msgs[0].x == 4);
- assert(res.msgs[0].objectClass == undefined);
- assert(res.msgs[0].dn == "cn=x2,cn=test");
-
- ok = ldb.del("cn=x,cn=test");
- assert(ok.error == 0);
-
- ok = ldb.rename("cn=x2,cn=test", "cn=x3,cn=test");
- assert(ok.error == 0);
- res = ldb.search("x=4", NULL, ldb.SCOPE_DEFAULT, attrs);
- assert(res.msgs[0].dn == "cn=x3,cn=test");
-
- ok = ldb.rename("cn=x3,cn=test", "cn=X3,cn=test");
- assert(ok.error == 0);
- res = ldb.search("x=4", NULL, ldb.SCOPE_DEFAULT, attrs);
- assert(res.msgs[0].dn == "cn=X3,cn=test");
-
- ok = ldb.modify("
-dn: cn=x3,cn=test
-changetype: modify
-add: x
-x: 7
-");
-
- res = ldb.search("x=7");
- assert(res.msgs.length == 1);
- assert(res.msgs[0].x.length == 2);
-
- /* Check a few things before we add modules */
- assert(res.msgs[0].objectGUID == undefined);
- assert(res.msgs[0].createTimestamp == undefined);
- assert(res.msgs[0].whenCreated == undefined);
-
-}
-
-function setup_modules(ldb)
-{
- ok = ldb.add("
-dn: @MODULES
-@LIST: rootdse,operational,rdn_name,partition
-
-dn: @ROOTDSE
-defaultNamingContext: cn=Test
-
-dn: @PARTITION
-partition: cn=SideTest:" + prefix + "/" + "testside.ldb
-partition: cn=Sub,cn=PartTest:" + prefix + "/" + "testsub.ldb
-partition: cn=PartTest:" + prefix + "/" + "testpartition.ldb
-partition: cn=Sub,cn=Sub,cn=PartTest:" + prefix + "/" + "testsubsub.ldb
-replicateEntries: @ATTRIBUTES
-replicateEntries: @INDEXLIST
-modules: cn=PartTest:objectguid
-");
-}
-
-/* Test the basic operation of the timestamps,objectguid and name_rdn
- modules */
-
-function modules_test(ldb, parttestldb)
-{
- println("Running modules tests");
-
- ok = ldb.add("
-dn: @ATTRIBUTES
-cn: CASE_INSENSITIVE
-caseattr: CASE_INSENSITIVE
-");
- if (ok.error != 0) {
- println("Failed to add: " + ok.errstr);
- assert(ok.error == 0);
- }
-
- /* Confirm that the attributes were replicated */
- var res_attrs = parttestldb.search("cn=*", "@ATTRIBUTES", parttestldb.SCOPE_BASE);
- assert(res_attrs.msgs[0].cn == "CASE_INSENSITIVE");
-
- ok = ldb.add("
-dn: cn=x8,cn=PartTest
-objectClass: foo
-x: 8
-");
- if (ok.error != 0) {
- println("Failed to add: " + ok.errstr);
- assert(ok.error == 0);
- }
-
- ok = ldb.add("
-dn: cn=x9,cn=PartTest
-objectClass: foo
-x: 9
-cn: X9
-");
- if (ok.error != 0) {
- println("Failed to add: " + ok.errstr);
- assert(ok.error == 0);
- }
-
- ok = ldb.add("
-dn: cn=X9,cn=PartTest
-objectClass: foo
-x: 9
-cn: X9
-");
- if (ok.error == 0) {
- println("Should have failed to add cn=X9,cn=PartTest");
- assert(ok.error != 0);
- }
-
- var res = ldb.search("x=8", "cn=PartTest", ldb.SCOPE_DEFAULT);
- assert(res.msgs[0].objectGUID != undefined);
- assert(res.msgs[0].uSNCreated != undefined);
- assert(res.msgs[0].uSNChanged != undefined);
- assert(res.msgs[0].createTimestamp == undefined);
- assert(res.msgs[0].whenCreated != undefined);
- assert(res.msgs[0].name == "x8");
- assert(res.msgs[0].cn == "x8");
-
- /* Confirm that this ended up in the correct LDB */
- var res_otherldb = parttestldb.search("x=8", "cn=PartTest", parttestldb.SCOPE_DEFAULT);
- assert(res_otherldb.msgs[0].objectGUID != undefined);
- assert(res_otherldb.msgs[0].createTimestamp == undefined);
- assert(res_otherldb.msgs[0].whenCreated != undefined);
- assert(res_otherldb.msgs[0].name == "x8");
- assert(res_otherldb.msgs[0].cn == "x8");
-
- var attrs = new Array("*", "createTimestamp");
- var res2 = ldb.search("x=9", "cn=PartTest", ldb.SCOPE_DEFAULT, attrs);
- assert(res2.msgs[0].objectGUID != undefined);
- assert(res2.msgs[0].createTimestamp != undefined);
- assert(res2.msgs[0].whenCreated != undefined);
- assert(res2.msgs[0].name == "x9");
- assert(res2.msgs[0].cn == "x9");
-
- assert(res.msgs[0].objectGUID != res2.msgs[0].objectGUID);
-
- var attrs = new Array("*");
- var res3 = ldb.search("", "", ldb.SCOPE_BASE, attrs);
- assert(res3.msgs[0].cn == undefined);
- assert(res3.msgs[0].distinguishedName == undefined);
- assert(res3.msgs[0].name == undefined);
- assert(res3.msgs[0].currentTime != undefined);
- assert(res3.msgs[0].highestCommittedUSN != undefined);
-
- assert(res3.msgs[0].namingContexts[0] == "cn=Sub,cn=Sub,cn=PartTest");
- assert(res3.msgs[0].namingContexts[1] == "cn=Sub,cn=PartTest");
- assert(res3.msgs[0].namingContexts[2] == "cn=PartTest");
- assert(res3.msgs[0].namingContexts[3] == "cn=SideTest");
- var usn = res3.msgs[0].highestCommittedUSN;
-
- /* Start a transaction. We are going to abort it later, to
- * show we clean up all partitions */
-
- ok = ldb.transaction_start()
- if (!ok) {
- println("Failed to start a transaction: " + ok.errstr);
- assert(ok.error == 0);
- }
-
-
- ok = ldb.add("
-dn: cn=x10,cn=parttest
-objectClass: foo
-x: 10
-");
- if (ok.error != 0) {
- println("Failed to add: " + ok.errstr);
- assert(ok.error == 0);
- }
-
- var attrs = new Array("highestCommittedUSN");
- var res4 = ldb.search("", "", ldb.SCOPE_BASE, attrs);
- var usn2 = res4.msgs[0].highestCommittedUSN;
- assert(usn < res4.msgs[0].highestCommittedUSN);
-
- ok = ldb.add("
-dn: cn=x11,cn=sub,cn=parttest
-objectClass: foo
-x: 11
-");
- if (ok.error != 0) {
- println("Failed to add: " + ok.errstr);
- assert(ok.error == 0);
- }
-
- var attrs = new Array("highestCommittedUSN");
- var res5 = ldb.search("", "", ldb.SCOPE_BASE, attrs);
- assert(usn2 < res5.msgs[0].highestCommittedUSN);
-
- var attrs = new Array("*", "createTimestamp");
- var res6 = ldb.search("x=11", "cn=parttest", ldb.SCOPE_SUB, attrs);
- assert(res6.msgs.length == 0);
-
- var attrs = new Array("*", "createTimestamp");
- var res7 = ldb.search("x=10", "cn=sub,cn=parttest", ldb.SCOPE_DEFAULT, attrs);
- assert(res7.msgs.length == 0);
-
- var res8 = ldb.search("x=11", "cn=sub,cn=parttest", ldb.SCOPE_DEFAULT, attrs);
-
- assert(res8.msgs[0].objectGUID == undefined); /* The objectGUID module is not loaded here */
- assert(res8.msgs[0].uSNCreated == undefined); /* The objectGUID module is not loaded here */
- assert(res8.msgs[0].name == "x11");
- assert(res8.msgs[0].cn == "x11");
-
- ok = ldb.add("
-dn: caseattr=XY,cn=PartTest
-objectClass: foo
-x: Y
-");
- if (ok.error != 0) {
- println("Failed to add: " + ok.errstr);
- assert(ok.error == 0);
- }
-
- ok = ldb.add("
-dn: caseattr=XZ,cn=PartTest
-objectClass: foo
-x: Z
-caseattr: XZ
-");
- if (ok.error != 0) {
- println("Failed to add: " + ok.errstr);
- assert(ok.error == 0);
- }
-
- ok = ldb.add("
-dn: caseattr=xz,cn=PartTest
-objectClass: foo
-x: Z
-caseattr: xz
-");
- if (ok.error == 0) {
- println("Should have failed to add caseattr=xz,cn=PartTest");
- assert(ok.error != 0);
- }
-
- ok = ldb.add("
-dn: caseattr2=XZ,cn=PartTest
-objectClass: foo
-x: Z
-caseattr2: XZ
-");
- if (ok.error != 0) {
- println("Failed to add: " + ok.errstr);
- assert(ok.error == 0);
- }
-
- ok = ldb.add("
-dn: caseattr2=Xz,cn=PartTest
-objectClass: foo
-x: Z
-caseattr2: Xz
-");
- if (ok.error != 0) {
- println("Failed to add: " + ok.errstr);
- assert(ok.error == 0);
- }
-
- var resX = ldb.search("caseattr=xz", "cn=parttest", ldb.SCOPE_DEFAULT, attrs);
- assert(resX.msgs.length == 1);
- assert(resX.msgs[0].objectGUID != undefined);
- assert(resX.msgs[0].createTimestamp != undefined);
- assert(resX.msgs[0].whenCreated != undefined);
- assert(resX.msgs[0].name == "XZ");
-
- var rescount = ldb.search("(|(caseattr=*)(cn=*))", "cn=parttest", ldb.SCOPE_DEFAULT, attrs);
- assert(rescount.msgs.length == 5);
-
- /* Check this attribute is *not* case sensitive */
- var resXcount = ldb.search("caseattr=x*", "cn=parttest", ldb.SCOPE_DEFAULT, attrs);
- assert(resXcount.msgs.length == 2);
-
- /* Check that this attribute *is* case sensitive */
- var resXcount2 = ldb.search("caseattr2=xz", "cn=parttest", ldb.SCOPE_DEFAULT, attrs);
- assert(resXcount2.msgs.length == 0);
-
-
- /* Now abort the transaction to show that even with
- * partitions, it is aborted everywhere */
- ok = ldb.transaction_cancel();
- if (!ok) {
- println("Failed to cancel a transaction: " + ok.errstr);
- assert(ok);
- }
-
- /* now check it all went away */
-
- var attrs = new Array("highestCommittedUSN");
- var res9 = ldb.search("", "", ldb.SCOPE_BASE, attrs);
- assert(usn == res9.msgs[0].highestCommittedUSN);
-
- var attrs = new Array("*");
- var res10 = ldb.search("x=11", "cn=sub,cn=parttest", ldb.SCOPE_DEFAULT, attrs);
- assert(res10.msgs.length == 0);
-
- var attrs = new Array("*");
- var res11 = ldb.search("x=10", "cn=parttest", ldb.SCOPE_DEFAULT, attrs);
- assert(res11.msgs.length == 0);
-
- var attrs = new Array("*");
- var res12 = ldb.search("caseattr=*", "cn=parttest", ldb.SCOPE_DEFAULT, attrs);
- assert(res12.msgs.length == 0);
-
-}
-
-sys = sys_init();
-var dbfile = "test.ldb";
-
-sys.unlink(prefix + "/" + dbfile);
-sys.unlink(prefix + "/" + "testpartition.ldb");
-sys.unlink(prefix + "/" + "testsub.ldb");
-sys.unlink(prefix + "/" + "testsubsub.ldb");
-sys.unlink(prefix + "/" + "testside.ldb");
-
-var ok = ldb.connect("tdb://" + prefix + "/" + dbfile);
-assert(ok);
-
-basic_tests(ldb);
-
-setup_modules(ldb);
-ldb = ldb_init();
-var ok = ldb.connect("tdb://" + prefix + "/" + dbfile);
-assert(ok);
-
-parttestldb = ldb_init();
-var ok = parttestldb.connect("tdb://" + prefix + "/" + "testpartition.ldb");
-assert(ok);
-
-modules_test(ldb, parttestldb);
-
-sys.unlink(prefix + "/" + dbfile);
-sys.unlink(prefix + "/" + "testpartition.ldb");
-sys.unlink(prefix + "/" + "testsub.ldb");
-sys.unlink(prefix + "/" + "testsubsub.ldb");
-sys.unlink(prefix + "/" + "testside.ldb");
-return 0;
+++ /dev/null
-#!/bin/sh
-exec smbscript "$0" ${1+"$@"}
-/*
- work out the minimal schema for a set of objectclasses
-*/
-
-libinclude("base.js");
-
-var ldb = ldb_init();
-
-var options = GetOptions(ARGV,
- "POPT_AUTOHELP",
- "POPT_COMMON_SAMBA",
- "POPT_COMMON_CREDENTIALS",
- "verbose",
- "classes",
- "attributes");
-if (options == undefined) {
- println("Failed to parse options");
- return -1;
-}
-verbose = options["verbose"];
-dump_all = "yes";
-dump_classes = options["classes"];
-dump_attributes = options["attributes"];
-
-if (dump_classes != undefined) {
- dump_all = undefined;
-}
-if (dump_attributes != undefined) {
- dump_all = undefined;
-}
-if (dump_all != undefined) {
- dump_classes = "yes";
- dump_attributes = "yes";
-}
-
-if (options.ARGV.length != 2) {
- println("Usage: minschema.js <URL> <classfile>");
- return -1;
-}
-
-var url = options.ARGV[0];
-var classfile = options.ARGV[1];
-
-/* use command line creds if available */
-ldb.credentials = options.get_credentials();
-
-var ok = ldb.connect(url);
-assert(ok);
-
-objectclasses = new Object();
-attributes = new Object();
-rootDse = new Object();
-
-objectclasses_expanded = new Object();
-
-/* the attributes we need for objectclasses */
-class_attrs = new Array("objectClass",
- "subClassOf",
- "governsID",
- "possSuperiors",
- "possibleInferiors",
- "mayContain",
- "mustContain",
- "auxiliaryClass",
- "rDNAttID",
- "showInAdvancedViewOnly",
- "adminDisplayName",
- "adminDescription",
- "objectClassCategory",
- "lDAPDisplayName",
- "schemaIDGUID",
- "systemOnly",
- "systemPossSuperiors",
- "systemMayContain",
- "systemMustContain",
- "systemAuxiliaryClass",
- "defaultSecurityDescriptor",
- "systemFlags",
- "defaultHidingValue",
- "defaultObjectCategory",
-
- /* this attributes are not used by w2k3 */
- "schemaFlagsEx",
- "msDs-IntId",
- "msDs-Schema-Extensions",
- "classDisplayName",
- "isDefunct");
-
-
-attrib_attrs = new Array("objectClass",
- "attributeID",
- "attributeSyntax",
- "isSingleValued",
- "rangeLower",
- "rangeUpper",
- "mAPIID",
- "linkID",
- "showInAdvancedViewOnly",
- "adminDisplayName",
- "oMObjectClass",
- "adminDescription",
- "oMSyntax",
- "searchFlags",
- "extendedCharsAllowed",
- "lDAPDisplayName",
- "schemaIDGUID",
- "attributeSecurityGUID",
- "systemOnly",
- "systemFlags",
- "isMemberOfPartialAttributeSet",
-
- /* this attributes are not used by w2k3 */
- "schemaFlagsEx",
- "msDs-IntId",
- "msDs-Schema-Extensions",
- "classDisplayName",
- "isEphemeral",
- "isDefunct");
-
-/*
- notes:
-
- objectClassCategory
- 1: structural
- 2: abstract
- 3: auxiliary
-*/
-
-
-/*
- print only if verbose is set
-*/
-function dprintf() {
- if (verbose != undefined) {
- print(vsprintf(arguments));
- }
-}
-
-function get_object_cn(ldb, name) {
- var attrs = new Array("cn");
-
- var res = ldb.search(sprintf("(ldapDisplayName=%s)", name), rootDse.schemaNamingContext, ldb.SCOPE_SUBTREE, attrs);
- assert(res != undefined);
- assert(res.msgs.length == 1);
-
- var cn = res.msgs[0]["cn"];
- assert(cn != undefined);
- if (typeof(cn) == "string") {
- return cn;
- }
- return cn[0];
-}
-/*
- create an objectclass object
-*/
-function obj_objectClass(ldb, name) {
- var o = new Object();
- o.name = name;
- o.cn = get_object_cn(ldb, name);
- return o;
-}
-
-/*
- create an attribute object
-*/
-function obj_attribute(ldb, name) {
- var o = new Object();
- o.name = name;
- o.cn = get_object_cn(ldb, name);
- return o;
-}
-
-
-syntaxmap = new Object();
-
-syntaxmap['2.5.5.1'] = '1.3.6.1.4.1.1466.115.121.1.12';
-syntaxmap['2.5.5.2'] = '1.3.6.1.4.1.1466.115.121.1.38';
-syntaxmap['2.5.5.3'] = '1.2.840.113556.1.4.1362';
-syntaxmap['2.5.5.4'] = '1.2.840.113556.1.4.905';
-syntaxmap['2.5.5.5'] = '1.3.6.1.4.1.1466.115.121.1.26';
-syntaxmap['2.5.5.6'] = '1.3.6.1.4.1.1466.115.121.1.36';
-syntaxmap['2.5.5.7'] = '1.2.840.113556.1.4.903';
-syntaxmap['2.5.5.8'] = '1.3.6.1.4.1.1466.115.121.1.7';
-syntaxmap['2.5.5.9'] = '1.3.6.1.4.1.1466.115.121.1.27';
-syntaxmap['2.5.5.10'] = '1.3.6.1.4.1.1466.115.121.1.40';
-syntaxmap['2.5.5.11'] = '1.3.6.1.4.1.1466.115.121.1.24';
-syntaxmap['2.5.5.12'] = '1.3.6.1.4.1.1466.115.121.1.15';
-syntaxmap['2.5.5.13'] = '1.3.6.1.4.1.1466.115.121.1.43';
-syntaxmap['2.5.5.14'] = '1.2.840.113556.1.4.904';
-syntaxmap['2.5.5.15'] = '1.2.840.113556.1.4.907';
-syntaxmap['2.5.5.16'] = '1.2.840.113556.1.4.906';
-syntaxmap['2.5.5.17'] = '1.3.6.1.4.1.1466.115.121.1.40';
-
-/*
- map some attribute syntaxes from some apparently MS specific
- syntaxes to the standard syntaxes
-*/
-function map_attribute_syntax(s) {
- if (syntaxmap[s] != undefined) {
- return syntaxmap[s];
- }
- return s;
-}
-
-
-/*
- fix a string DN to use ${SCHEMADN}
-*/
-function fix_dn(dn) {
- var s = strstr(dn, rootDse.schemaNamingContext);
- if (s == NULL) {
- return dn;
- }
- return substr(dn, 0, strlen(dn) - strlen(s)) + "${SCHEMADN}";
-}
-
-/*
- dump an object as ldif
-*/
-function write_ldif_one(o, attrs) {
- var i;
- printf("dn: CN=%s,${SCHEMADN}\n", o.cn);
- for (i=0;i<attrs.length;i++) {
- var a = attrs[i];
- if (o[a] == undefined) {
- continue;
- }
- /* special case for oMObjectClass, which is a binary object */
- if (a == "oMObjectClass") {
- printf("%s:: %s\n", a, o[a]);
- continue;
- }
- var v = o[a];
- if (typeof(v) == "string") {
- v = new Array(v);
- }
- var j;
- for (j=0;j<v.length;j++) {
- printf("%s: %s\n", a, fix_dn(v[j]));
- }
- }
- printf("\n");
-}
-
-/*
- dump an array of objects as ldif
-*/
-function write_ldif(o, attrs) {
- var i;
- for (i in o) {
- write_ldif_one(o[i], attrs);
- }
-}
-
-
-/*
- create a testDN based an an example DN
- the idea is to ensure we obey any structural rules
-*/
-function create_testdn(exampleDN) {
- var a = split(",", exampleDN);
- a[0] = "CN=TestDN";
- return join(",", a);
-}
-
-/*
- find the properties of an objectclass
- */
-function find_objectclass_properties(ldb, o) {
- var res = ldb.search(
- sprintf("(ldapDisplayName=%s)", o.name),
- rootDse.schemaNamingContext, ldb.SCOPE_SUBTREE, class_attrs);
- assert(res != undefined);
- assert(res.msgs.length == 1);
- var msg = res.msgs[0];
- var a;
- for (a in msg) {
- o[a] = msg[a];
- }
-}
-
-/*
- find the properties of an attribute
- */
-function find_attribute_properties(ldb, o) {
- var res = ldb.search(
- sprintf("(ldapDisplayName=%s)", o.name),
- rootDse.schemaNamingContext, ldb.SCOPE_SUBTREE, attrib_attrs);
- assert(res != undefined);
- assert(res.msgs.length == 1);
- var msg = res.msgs[0];
- var a;
- for (a in msg) {
- /* special case for oMObjectClass, which is a binary object */
- if (a == "oMObjectClass") {
- o[a] = ldb.encode(msg[a]);
- continue;
- }
- o[a] = msg[a];
- }
-}
-
-/*
- find the auto-created properties of an objectclass. Only works for classes
- that can be created using just a DN and the objectclass
- */
-function find_objectclass_auto(ldb, o) {
- if (o["exampleDN"] == undefined) {
- return;
- }
- var testdn = create_testdn(o.exampleDN);
- var ok;
-
- dprintf("testdn is '%s'\n", testdn);
-
- var ldif = "dn: " + testdn;
- ldif = ldif + "\nobjectClass: " + o.name;
- ok = ldb.add(ldif);
- if (ok.error != 0) {
- dprintf("error adding %s: %s\n", o.name, ok.errstr);
- dprintf("%s\n", ldif);
- return;
- }
-
- var res = ldb.search("", testdn, ldb.SCOPE_BASE);
- ok = ldb.del(testdn);
- assert(ok.error == 0);
-
- var a;
- for (a in res.msgs[0]) {
- attributes[a].autocreate = true;
- }
-}
-
-
-/*
- look at auxiliary information from a class to intuit the existance of more
- classes needed for a minimal schema
-*/
-function expand_objectclass(ldb, o) {
- var attrs = new Array("auxiliaryClass", "systemAuxiliaryClass",
- "possSuperiors", "systemPossSuperiors",
- "subClassOf");
- var res = ldb.search(
- sprintf("(&(objectClass=classSchema)(ldapDisplayName=%s))", o.name),
- rootDse.schemaNamingContext, ldb.SCOPE_SUBTREE, attrs);
- var a;
- dprintf("Expanding class %s\n", o.name);
- assert(res != undefined);
- assert(res.msgs.length == 1);
- var msg = res.msgs[0];
- for (a=0;a<attrs.length;a++) {
- var aname = attrs[a];
- if (msg[aname] == undefined) {
- continue;
- }
- var list = msg[aname];
- if (typeof(list) == "string") {
- list = new Array(msg[aname]);
- }
- var i;
- for (i=0;i<list.length;i++) {
- var name = list[i];
- if (objectclasses[name] == undefined) {
- dprintf("Found new objectclass '%s'\n", name);
- objectclasses[name] = obj_objectClass(ldb, name);
- }
- }
- }
-}
-
-
-/*
- add the must and may attributes from an objectclass to the full list
- of attributes
-*/
-function add_objectclass_attributes(ldb, class) {
- var attrs = new Array("mustContain", "systemMustContain",
- "mayContain", "systemMayContain");
- var i;
- for (i=0;i<attrs.length;i++) {
- var aname = attrs[i];
- if (class[aname] == undefined) {
- continue;
- }
- var alist = class[aname];
- if (typeof(alist) == "string") {
- alist = new Array(alist);
- }
- var j;
- var len = alist.length;
- for (j=0;j<len;j++) {
- var a = alist[j];
- if (attributes[a] == undefined) {
- attributes[a] = obj_attribute(ldb, a);
- }
- }
- }
-}
-
-
-/*
- process an individual record, working out what attributes it has
-*/
-function walk_dn(ldb, dn) {
- /* get a list of all possible attributes for this object */
- var attrs = new Array("allowedAttributes");
- var res = ldb.search("objectClass=*", dn, ldb.SCOPE_BASE, attrs);
- if (res.error != 0) {
- dprintf("Unable to fetch allowedAttributes for '%s' - %s\n",
- dn, res.errstr);
- return;
- }
- var allattrs = res.msgs[0].allowedAttributes;
- res = ldb.search("objectClass=*", dn, ldb.SCOPE_BASE, allattrs);
- if (res.error != 0) {
- dprintf("Unable to fetch all attributes for '%s' - %s\n",
- dn, res.errstr);
- return;
- }
- var a;
- var msg = res.msgs[0];
- for (a in msg) {
- if (attributes[a] == undefined) {
- attributes[a] = obj_attribute(ldb, a);
- }
- }
-}
-
-/*
- walk a naming context, looking for all records
-*/
-function walk_naming_context(ldb, namingContext) {
- var attrs = new Array("objectClass");
- var res = ldb.search("objectClass=*", namingContext, ldb.SCOPE_DEFAULT, attrs);
- if (res.error != 0) {
- dprintf("Unable to fetch objectClasses for '%s' - %s\n",
- namingContext, res.errstr);
- return;
- }
- var r;
- for (r=0;r<res.msgs.length;r++) {
- var msg = res.msgs[r].objectClass;
- var c;
- for (c=0;c<msg.length;c++) {
- var objectClass = msg[c];
- if (objectclasses[objectClass] == undefined) {
- objectclasses[objectClass] = obj_objectClass(ldb, objectClass);
- objectclasses[objectClass].exampleDN = res.msgs[r].dn;
- }
- }
- walk_dn(ldb, res.msgs[r].dn);
- }
-}
-
-/*
- trim the may attributes for an objectClass
-*/
-function trim_objectclass_attributes(ldb, class) {
- var i,j,n;
-
- /* trim possibleInferiors,
- * include only the classes we extracted */
- var possinf = class["possibleInferiors"];
- if (possinf != undefined) {
- var newpossinf = new Array();
- if (typeof(possinf) == "string") {
- possinf = new Array(possinf);
- }
- n = 0;
- for (j = 0;j < possinf.length; j++) {
- var x = possinf[j];
- if (objectclasses[x] != undefined) {
- newpossinf[n] = x;
- n++;
- }
- }
- class["possibleInferiors"] = newpossinf;
- }
-
- /* trim systemMayContain,
- * remove duplicates */
- var sysmay = class["systemMayContain"];
- if (sysmay != undefined) {
- var newsysmay = new Array();
- if (typeof(sysmay) == "string") {
- sysmay = new Array(sysmay);
- }
- for (j = 0;j < sysmay.length; j++) {
- var x = sysmay[j];
- var dup = false;
- if (newsysmay[0] == undefined) {
- newsysmay[0] = x;
- } else {
- for (n = 0; n < newsysmay.length; n++) {
- if (newsysmay[n] == x) {
- dup = true;
- }
- }
- if (dup == false) {
- newsysmay[n] = x;
- }
- }
- }
- class["systemMayContain"] = newsysmay;
- }
-
- /* trim mayContain,
- * remove duplicates */
- var may = class["mayContain"];
- if (may != undefined) {
- var newmay = new Array();
- if (typeof(may) == "string") {
- may = new Array(may);
- }
- for (j = 0;j < may.length; j++) {
- var x = may[j];
- var dup = false;
- if (newmay[0] == undefined) {
- newmay[0] = x;
- } else {
- for (n = 0; n < newmay.length; n++) {
- if (newmay[n] == x) {
- dup = true;
- }
- }
- if (dup == false) {
- newmay[n] = x;
- }
- }
- }
- class["mayContain"] = newmay;
- }
-}
-
-/*
- load the basic attributes of an objectClass
-*/
-function build_objectclass(ldb, name) {
- var attrs = new Array("name");
- var res = ldb.search(
- sprintf("(&(objectClass=classSchema)(ldapDisplayName=%s))", name),
- rootDse.schemaNamingContext, ldb.SCOPE_SUBTREE, attrs);
- if (res.error != 0) {
- dprintf("unknown class '%s'\n", name);
- return undefined;
- }
- if (res.msgs.length == 0) {
- dprintf("unknown class '%s'\n", name);
- return undefined;
- }
- return obj_objectClass(ldb, name);
-}
-
-/*
- append 2 lists
-*/
-function list_append(a1, a2) {
- var i;
- if (a1 == undefined) {
- return a2;
- }
- if (a2 == undefined) {
- return a1;
- }
- for (i=0;i<a2.length;i++) {
- a1[a1.length] = a2[i];
- }
- return a1;
-}
-
-/*
- form a coalesced attribute list
-*/
-function attribute_list(class, attr1, attr2) {
- var a1 = class[attr1];
- var a2 = class[attr2];
- if (typeof(a1) == "string") {
- a1 = new Array(a1);
- }
- if (typeof(a2) == "string") {
- a2 = new Array(a2);
- }
- return list_append(a1, a2);
-}
-
-/*
- write out a list in aggregate form
-*/
-function aggregate_list(name, list) {
- if (list == undefined) {
- return;
- }
- var i;
- printf("%s ( ", name);
- for (i=0;i<list.length;i++) {
- printf("%s ", list[i]);
- if (i < (list.length - 1)) {
- printf("$ ");
- }
- }
- printf(") ");
-}
-
-/*
- write the aggregate record for an objectclass
-*/
-function write_aggregate_objectclass(class) {
- printf("objectClasses: ( %s NAME '%s' ", class.governsID, class.name);
- if (class['subClassOf'] != undefined) {
- printf("SUP %s ", class['subClassOf']);
- }
- if (class.objectClassCategory == 1) {
- printf("STRUCTURAL ");
- } else if (class.objectClassCategory == 2) {
- printf("ABSTRACT ");
- } else if (class.objectClassCategory == 3) {
- printf("AUXILIARY ");
- }
-
- var list;
-
- list = attribute_list(class, "systemMustContain", "mustContain");
- aggregate_list("MUST", list);
-
- list = attribute_list(class, "systemMayContain", "mayContain");
- aggregate_list("MAY", list);
-
- printf(")\n");
-}
-
-
-/*
- write the aggregate record for an ditcontentrule
-*/
-function write_aggregate_ditcontentrule(class) {
- var list = attribute_list(class, "auxiliaryClass", "systemAuxiliaryClass");
- var i;
- if (list == undefined) {
- return;
- }
-
- printf("dITContentRules: ( %s NAME '%s' ", class.governsID, class.name);
-
- aggregate_list("AUX", list);
-
- var may_list = undefined;
- var must_list = undefined;
-
- for (i=0;i<list.length;i++) {
- var c = list[i];
- var list2;
- list2 = attribute_list(objectclasses[c],
- "mayContain", "systemMayContain");
- may_list = list_append(may_list, list2);
- list2 = attribute_list(objectclasses[c],
- "mustContain", "systemMustContain");
- must_list = list_append(must_list, list2);
- }
-
- aggregate_list("MUST", must_list);
- aggregate_list("MAY", may_list);
-
- printf(")\n");
-}
-
-/*
- write the aggregate record for an attribute
-*/
-function write_aggregate_attribute(attrib) {
- printf("attributeTypes: ( %s NAME '%s' SYNTAX '%s' ",
- attrib.attributeID, attrib.name,
- map_attribute_syntax(attrib.attributeSyntax));
- if (attrib['isSingleValued'] == "TRUE") {
- printf("SINGLE-VALUE ");
- }
- if (attrib['systemOnly'] == "TRUE") {
- printf("NO-USER-MODIFICATION ");
- }
-
- printf(")\n");
-}
-
-
-
-/*
- load a list from a file
-*/
-function load_list(file) {
- var sys = sys_init();
- var s = sys.file_load(file);
- var a = split("\n", s);
- return a;
-}
-
-/* get the rootDSE */
-var res = ldb.search("", "", ldb.SCOPE_BASE);
-rootDse = res.msgs[0];
-
-/* load the list of classes we are interested in */
-var classes = load_list(classfile);
-var i;
-for (i=0;i<classes.length;i++) {
- var classname = classes[i];
- var class = build_objectclass(ldb, classname);
- if (class != undefined) {
- objectclasses[classname] = class;
- }
-}
-
-
-/*
- expand the objectclass list as needed
-*/
-var num_classes = 0;
-var expanded = 0;
-/* calculate the actual number of classes */
-for (i in objectclasses) {
- num_classes++;
-}
-/* so EJS do not have while nor the break statement
- cannot find any other way than doing more loops
- than necessary to recursively expand all classes
- */
-var inf;
-for (inf = 0;inf < 500; inf++) {
- if (expanded < num_classes) {
- for (i in objectclasses) {
- var n = objectclasses[i];
- if (objectclasses_expanded[i] != "DONE") {
- expand_objectclass(ldb, objectclasses[i]);
- objectclasses_expanded[i] = "DONE";
- expanded++;
- }
- }
- /* recalculate the actual number of classes */
- num_classes = 0;
- for (i in objectclasses) {
- num_classes++;
- }
- }
-}
-
-/*
- find objectclass properties
-*/
-for (i in objectclasses) {
- find_objectclass_properties(ldb, objectclasses[i]);
-}
-
-/*
- form the full list of attributes
-*/
-for (i in objectclasses) {
- add_objectclass_attributes(ldb, objectclasses[i]);
-}
-
-/* and attribute properties */
-for (i in attributes) {
- find_attribute_properties(ldb, attributes[i]);
-}
-
-/*
- trim the 'may' attribute lists to those really needed
-*/
-for (i in objectclasses) {
- trim_objectclass_attributes(ldb, objectclasses[i]);
-}
-
-/*
- dump an ldif form of the attributes and objectclasses
-*/
-if (dump_attributes != undefined) {
- write_ldif(attributes, attrib_attrs);
-}
-if (dump_classes != undefined) {
- write_ldif(objectclasses, class_attrs);
-}
-if (verbose == undefined) {
- exit(0);
-}
-
-/*
- dump list of objectclasses
-*/
-printf("objectClasses:\n")
-for (i in objectclasses) {
- printf("\t%s\n", i);
-}
-printf("attributes:\n")
-for (i in attributes) {
- printf("\t%s\n", i);
-}
-
-printf("autocreated attributes:\n");
-for (i in attributes) {
- if (attributes[i].autocreate == true) {
- printf("\t%s\n", i);
- }
-}
-
-return 0;
+++ /dev/null
-#!/usr/bin/env smbscript
-/*
- (C) Jelmer Vernooij <jelmer@samba.org> 2005
- (C) Martin Kuehl <mkhl@samba.org> 2006
- Published under the GNU GPL
- Sponsored by Google Summer of Code
- */
-
-var sys;
-var options = GetOptions(ARGV, "POPT_AUTOHELP", "POPT_COMMON_SAMBA");
-if (options == undefined) {
- println("Failed to parse options");
- return -1;
-}
-
-libinclude("base.js");
-
-if (options.ARGV.length != 2) {
- println("Usage: samba3sam.js <TESTDIR> <DATADIR>");
- return -1;
-}
-
-var prefix = options.ARGV[0];
-var datadir = options.ARGV[1];
-
-function setup_data(obj, ldif)
-{
- assert(ldif != undefined);
- ldif = substitute_var(ldif, obj);
- assert(ldif != undefined);
- var ok = obj.db.add(ldif);
- assert(ok.error == 0);
-}
-
-function setup_modules(ldb, s3, s4, ldif)
-{
- assert(ldif != undefined);
- ldif = substitute_var(ldif, s4);
- assert(ldif != undefined);
- var ok = ldb.add(ldif);
- assert(ok.error == 0);
-
- var ldif = "
-dn: @MAP=samba3sam
-@FROM: " + s4.BASEDN + "
-@TO: sambaDomainName=TESTS," + s3.BASEDN + "
-
-dn: @MODULES
-@LIST: rootdse,paged_results,server_sort,extended_dn,asq,samldb,password_hash,operational,objectguid,rdn_name,samba3sam,partition
-
-dn: @PARTITION
-partition: " + s4.BASEDN + ":" + s4.url + "
-partition: " + s3.BASEDN + ":" + s3.url + "
-replicateEntries: @SUBCLASSES
-replicateEntries: @ATTRIBUTES
-replicateEntries: @INDEXLIST
-";
- var ok = ldb.add(ldif);
- assert(ok.error == 0);
-}
-
-function test_s3sam_search(ldb)
-{
- println("Looking up by non-mapped attribute");
- var msg = ldb.search("(cn=Administrator)");
- assert(msg.error == 0);
- assert(msg.msgs.length == 1);
- assert(msg.msgs[0].cn == "Administrator");
-
- println("Looking up by mapped attribute");
- var msg = ldb.search("(name=Backup Operators)");
- assert(msg.error == 0);
- assert(msg.msgs.length == 1);
- assert(msg.msgs[0].name == "Backup Operators");
-
- println("Looking up by old name of renamed attribute");
- var msg = ldb.search("(displayName=Backup Operators)");
- assert(msg.msgs.length == 0);
-
- println("Looking up mapped entry containing SID");
- var msg = ldb.search("(cn=Replicator)");
- assert(msg.error == 0);
- assert(msg.msgs.length == 1);
- println(msg.msgs[0].dn);
- assert(msg.msgs[0].dn == "cn=Replicator,ou=Groups,dc=vernstok,dc=nl");
- assert(msg.msgs[0].objectSid == "S-1-5-21-4231626423-2410014848-2360679739-552");
-
- println("Checking mapping of objectClass");
- var oc = msg.msgs[0].objectClass;
- assert(oc != undefined);
- for (var i in oc) {
- assert(oc[i] == "posixGroup" || oc[i] == "group");
- }
-
- println("Looking up by objectClass");
- var msg = ldb.search("(|(objectClass=user)(cn=Administrator))");
- assert(msg.error == 0);
- assert(msg.msgs.length == 2);
- for (var i = 0; i < msg.msgs.length; i++) {
- assert((msg.msgs[i].dn == "unixName=Administrator,ou=Users,dc=vernstok,dc=nl") ||
- (msg.msgs[i].dn == "unixName=nobody,ou=Users,dc=vernstok,dc=nl"));
- }
-}
-
-function test_s3sam_modify(ldb, s3)
-{
- var msg, ok;
- println("Adding a record that will be fallbacked");
- ok = ldb.add("
-dn: cn=Foo
-foo: bar
-blah: Blie
-cn: Foo
-showInAdvancedViewOnly: TRUE
-");
- if (ok.error != 0) {
- println(ok.errstr);
- assert(ok.error == 0);
- }
-
- println("Checking for existence of record (local)");
- /* TODO: This record must be searched in the local database, which is currently only supported for base searches
- * msg = ldb.search("(cn=Foo)", new Array('foo','blah','cn','showInAdvancedViewOnly'));
- * TODO: Actually, this version should work as well but doesn't...
- *
- */
- var attrs = new Array('foo','blah','cn','showInAdvancedViewOnly');
- msg = ldb.search("(cn=Foo)", "cn=Foo", ldb.LDB_SCOPE_BASE, attrs);
- assert(msg.error == 0);
- assert(msg.msgs.length == 1);
- assert(msg.msgs[0].showInAdvancedViewOnly == "TRUE");
- assert(msg.msgs[0].foo == "bar");
- assert(msg.msgs[0].blah == "Blie");
-
- println("Adding record that will be mapped");
- ok = ldb.add("
-dn: cn=Niemand,cn=Users,dc=vernstok,dc=nl
-objectClass: user
-unixName: bin
-sambaUnicodePwd: geheim
-cn: Niemand
-");
- if (ok.error != 0) {
- println(ok.errstr);
- assert(ok.error == 0);
- }
- assert(ok.error == 0);
-
- println("Checking for existence of record (remote)");
- msg = ldb.search("(unixName=bin)", new Array('unixName','cn','dn', 'sambaUnicodePwd'));
- assert(msg.error == 0);
- assert(msg.msgs.length == 1);
- assert(msg.msgs[0].cn == "Niemand");
- assert(msg.msgs[0].sambaUnicodePwd == "geheim");
-
- println("Checking for existence of record (local && remote)");
- msg = ldb.search("(&(unixName=bin)(sambaUnicodePwd=geheim))", new Array('unixName','cn','dn', 'sambaUnicodePwd'));
- assert(msg.error == 0);
- assert(msg.msgs.length == 1); // TODO: should check with more records
- assert(msg.msgs[0].cn == "Niemand");
- assert(msg.msgs[0].unixName == "bin");
- assert(msg.msgs[0].sambaUnicodePwd == "geheim");
-
- println("Checking for existence of record (local || remote)");
- msg = ldb.search("(|(unixName=bin)(sambaUnicodePwd=geheim))", new Array('unixName','cn','dn', 'sambaUnicodePwd'));
- println("got " + msg.msgs.length + " replies");
- assert(msg.error == 0);
- assert(msg.msgs.length == 1); // TODO: should check with more records
- assert(msg.msgs[0].cn == "Niemand");
- assert(msg.msgs[0].unixName == "bin" || msg.msgs[0].sambaUnicodePwd == "geheim");
-
- println("Checking for data in destination database");
- msg = s3.db.search("(cn=Niemand)");
- assert(msg.error == 0);
- assert(msg.msgs.length >= 1);
- assert(msg.msgs[0].sambaSID == "S-1-5-21-4231626423-2410014848-2360679739-2001");
- assert(msg.msgs[0].displayName == "Niemand");
-
- println("Adding attribute...");
- ok = ldb.modify("
-dn: cn=Niemand,cn=Users,dc=vernstok,dc=nl
-changetype: modify
-add: description
-description: Blah
-");
- if (ok.error != 0) {
- println(ok.errstr);
- assert(ok.error == 0);
- }
- assert(ok.error == 0);
-
- println("Checking whether changes are still there...");
- msg = ldb.search("(cn=Niemand)");
- assert(msg.error == 0);
- assert(msg.msgs.length >= 1);
- assert(msg.msgs[0].cn == "Niemand");
- assert(msg.msgs[0].description == "Blah");
-
- println("Modifying attribute...");
- ok = ldb.modify("
-dn: cn=Niemand,cn=Users,dc=vernstok,dc=nl
-changetype: modify
-replace: description
-description: Blie
-");
- if (ok.error != 0) {
- println(ok.errstr);
- assert(ok.error == 0);
- }
- assert(ok.error == 0);
-
- println("Checking whether changes are still there...");
- msg = ldb.search("(cn=Niemand)");
- assert(msg.error == 0);
- assert(msg.msgs.length >= 1);
- assert(msg.msgs[0].description == "Blie");
-
- println("Deleting attribute...");
- ok = ldb.modify("
-dn: cn=Niemand,cn=Users,dc=vernstok,dc=nl
-changetype: modify
-delete: description
-");
- if (ok.error != 0) {
- println(ok.errstr);
- assert(ok.error == 0);
- }
- assert(ok.error == 0);
-
- println("Checking whether changes are no longer there...");
- msg = ldb.search("(cn=Niemand)");
- assert(msg.error == 0);
- assert(msg.msgs.length >= 1);
- assert(msg.msgs[0].description == undefined);
-
- println("Renaming record...");
- ok = ldb.rename("cn=Niemand,cn=Users,dc=vernstok,dc=nl", "cn=Niemand2,cn=Users,dc=vernstok,dc=nl");
- assert(ok.error == 0);
-
- println("Checking whether DN has changed...");
- msg = ldb.search("(cn=Niemand2)");
- assert(msg.error == 0);
- assert(msg.msgs.length == 1);
- assert(msg.msgs[0].dn == "cn=Niemand2,cn=Users,dc=vernstok,dc=nl");
-
- println("Deleting record...");
- ok = ldb.del("cn=Niemand2,cn=Users,dc=vernstok,dc=nl");
- if (ok.error != 0) {
- println(ok.errstr);
- assert(ok.error == 0);
- }
-
- println("Checking whether record is gone...");
- msg = ldb.search("(cn=Niemand2)");
- assert(msg.error == 0);
- assert(msg.msgs.length == 0);
-}
-
-function test_map_search(ldb, s3, s4)
-{
- println("Running search tests on mapped data");
- var res;
- var dn;
- var attrs;
-
-
- var ldif = "
-dn: " + "sambaDomainName=TESTS," + s3.BASEDN + "
-objectclass: sambaDomain
-objectclass: top
-sambaSID: S-1-5-21-4231626423-2410014848-2360679739
-sambaNextRid: 2000
-sambaDomainName: TESTS"
- ldif = substitute_var(ldif, s3);
- assert(ldif != undefined);
- var ok = s3.db.add(ldif);
- assert(ok.error == 0);
-
- printf("Add a set of split records");
- var ldif = "
-dn: " + s4.dn("cn=X") + "
-objectClass: user
-cn: X
-codePage: x
-revision: x
-dnsHostName: x
-nextRid: y
-lastLogon: x
-description: x
-objectSid: S-1-5-21-4231626423-2410014848-2360679739-552
-primaryGroupID: 1-5-21-4231626423-2410014848-2360679739-512
-
-dn: " + s4.dn("cn=Y") + "
-objectClass: top
-cn: Y
-codePage: x
-revision: x
-dnsHostName: y
-nextRid: y
-lastLogon: y
-description: x
-
-dn: " + s4.dn("cn=Z") + "
-objectClass: top
-cn: Z
-codePage: x
-revision: y
-dnsHostName: z
-nextRid: y
-lastLogon: z
-description: y
-";
-
- ldif = substitute_var(ldif, s4);
- assert(ldif != undefined);
- var ok = ldb.add(ldif);
- if (ok.error != 0) {
- println(ok.errstr);
- assert(ok.error == 0);
- }
-
- println("Add a set of remote records");
-
- var ldif = "
-dn: " + s3.dn("cn=A") + "
-objectClass: posixAccount
-cn: A
-sambaNextRid: x
-sambaBadPasswordCount: x
-sambaLogonTime: x
-description: x
-sambaSID: S-1-5-21-4231626423-2410014848-2360679739-552
-sambaPrimaryGroupSID: S-1-5-21-4231626423-2410014848-2360679739-512
-
-dn: " + s3.dn("cn=B") + "
-objectClass: top
-cn:B
-sambaNextRid: x
-sambaBadPasswordCount: x
-sambaLogonTime: y
-description: x
-
-dn: " + s3.dn("cn=C") + "
-objectClass: top
-cn: C
-sambaNextRid: x
-sambaBadPasswordCount: y
-sambaLogonTime: z
-description: y
-";
- ldif = substitute_var(ldif, s3);
- assert(ldif != undefined);
- var ok = s3.db.add(ldif);
- assert(ok.error == 0);
-
- println("Testing search by DN");
-
- /* Search remote record by local DN */
- dn = s4.dn("cn=A");
- attrs = new Array("dnsHostName", "lastLogon");
- res = ldb.search("", dn, ldb.SCOPE_BASE, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 1);
- assert(res.msgs[0].dn == dn);
- assert(res.msgs[0].dnsHostName == undefined);
- assert(res.msgs[0].lastLogon == "x");
-
- /* Search remote record by remote DN */
- dn = s3.dn("cn=A");
- attrs = new Array("dnsHostName", "lastLogon", "sambaLogonTime");
- res = s3.db.search("", dn, ldb.SCOPE_BASE, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 1);
- assert(res.msgs[0].dn == dn);
- assert(res.msgs[0].dnsHostName == undefined);
- assert(res.msgs[0].lastLogon == undefined);
- assert(res.msgs[0].sambaLogonTime == "x");
-
- /* Search split record by local DN */
- dn = s4.dn("cn=X");
- attrs = new Array("dnsHostName", "lastLogon");
- res = ldb.search("", dn, ldb.SCOPE_BASE, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 1);
- assert(res.msgs[0].dn == dn);
- assert(res.msgs[0].dnsHostName == "x");
- assert(res.msgs[0].lastLogon == "x");
-
- /* Search split record by remote DN */
- dn = s3.dn("cn=X");
- attrs = new Array("dnsHostName", "lastLogon", "sambaLogonTime");
- res = s3.db.search("", dn, ldb.SCOPE_BASE, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 1);
- assert(res.msgs[0].dn == dn);
- assert(res.msgs[0].dnsHostName == undefined);
- assert(res.msgs[0].lastLogon == undefined);
- assert(res.msgs[0].sambaLogonTime == "x");
-
- println("Testing search by attribute");
-
- /* Search by ignored attribute */
- attrs = new Array("dnsHostName", "lastLogon");
- res = ldb.search("(revision=x)", NULL, ldb. SCOPE_DEFAULT, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 2);
- assert(res.msgs[0].dn == s4.dn("cn=Y"));
- assert(res.msgs[0].dnsHostName == "y");
- assert(res.msgs[0].lastLogon == "y");
- assert(res.msgs[1].dn == s4.dn("cn=X"));
- assert(res.msgs[1].dnsHostName == "x");
- assert(res.msgs[1].lastLogon == "x");
-
- /* Search by kept attribute */
- attrs = new Array("dnsHostName", "lastLogon");
- res = ldb.search("(description=y)", NULL, ldb. SCOPE_DEFAULT, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 2);
- assert(res.msgs[0].dn == s4.dn("cn=Z"));
- assert(res.msgs[0].dnsHostName == "z");
- assert(res.msgs[0].lastLogon == "z");
- assert(res.msgs[1].dn == s4.dn("cn=C"));
- assert(res.msgs[1].dnsHostName == undefined);
- assert(res.msgs[1].lastLogon == "z");
-
- /* Search by renamed attribute */
- attrs = new Array("dnsHostName", "lastLogon");
- res = ldb.search("(badPwdCount=x)", NULL, ldb. SCOPE_DEFAULT, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 2);
- assert(res.msgs[0].dn == s4.dn("cn=B"));
- assert(res.msgs[0].dnsHostName == undefined);
- assert(res.msgs[0].lastLogon == "y");
- assert(res.msgs[1].dn == s4.dn("cn=A"));
- assert(res.msgs[1].dnsHostName == undefined);
- assert(res.msgs[1].lastLogon == "x");
-
- /* Search by converted attribute */
- attrs = new Array("dnsHostName", "lastLogon", "objectSid");
- /* TODO:
- Using the SID directly in the parse tree leads to conversion
- errors, letting the search fail with no results.
- res = ldb.search("(objectSid=S-1-5-21-4231626423-2410014848-2360679739-552)", NULL, ldb. SCOPE_DEFAULT, attrs);
- */
- res = ldb.search("(objectSid=*)", NULL, ldb. SCOPE_DEFAULT, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 3);
- assert(res.msgs[0].dn == s4.dn("cn=X"));
- assert(res.msgs[0].dnsHostName == "x");
- assert(res.msgs[0].lastLogon == "x");
- assert(res.msgs[0].objectSid == "S-1-5-21-4231626423-2410014848-2360679739-552");
- assert(res.msgs[1].dn == s4.dn("cn=A"));
- assert(res.msgs[1].dnsHostName == undefined);
- assert(res.msgs[1].lastLogon == "x");
- assert(res.msgs[1].objectSid == "S-1-5-21-4231626423-2410014848-2360679739-552");
-
- /* Search by generated attribute */
- /* In most cases, this even works when the mapping is missing
- * a `convert_operator' by enumerating the remote db. */
- attrs = new Array("dnsHostName", "lastLogon", "primaryGroupID");
- res = ldb.search("(primaryGroupID=512)", NULL, ldb. SCOPE_DEFAULT, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 1);
- assert(res.msgs[0].dn == s4.dn("cn=A"));
- assert(res.msgs[0].dnsHostName == undefined);
- assert(res.msgs[0].lastLogon == "x");
- assert(res.msgs[0].primaryGroupID == "512");
-
- /* TODO: There should actually be two results, A and X. The
- * primaryGroupID of X seems to get corrupted somewhere, and the
- * objectSid isn't available during the generation of remote (!) data,
- * which can be observed with the following search. Also note that Xs
- * objectSid seems to be fine in the previous search for objectSid... */
- /*
- res = ldb.search("(primaryGroupID=*)", NULL, ldb. SCOPE_DEFAULT, attrs);
- println(res.msgs.length + " results found");
- for (i=0;i<res.msgs.length;i++) {
- for (obj in res.msgs[i]) {
- println(obj + ": " + res.msgs[i][obj]);
- }
- println("---");
- }
- */
-
- /* Search by remote name of renamed attribute */
- attrs = new Array("dnsHostName", "lastLogon");
- res = ldb.search("(sambaBadPasswordCount=*)", "", ldb. SCOPE_DEFAULT, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 0);
-
- /* Search by objectClass */
- attrs = new Array("dnsHostName", "lastLogon", "objectClass");
- res = ldb.search("(objectClass=user)", NULL, ldb. SCOPE_DEFAULT, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 2);
- assert(res.msgs[0].dn == s4.dn("cn=X"));
- assert(res.msgs[0].dnsHostName == "x");
- assert(res.msgs[0].lastLogon == "x");
- assert(res.msgs[0].objectClass != undefined);
- assert(res.msgs[0].objectClass[0] == "user");
- assert(res.msgs[1].dn == s4.dn("cn=A"));
- assert(res.msgs[1].dnsHostName == undefined);
- assert(res.msgs[1].lastLogon == "x");
- assert(res.msgs[1].objectClass != undefined);
- assert(res.msgs[1].objectClass[0] == "user");
-
- /* Prove that the objectClass is actually used for the search */
- res = ldb.search("(|(objectClass=user)(badPwdCount=x))", NULL, ldb. SCOPE_DEFAULT, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 3);
- assert(res.msgs[0].dn == s4.dn("cn=B"));
- assert(res.msgs[0].dnsHostName == undefined);
- assert(res.msgs[0].lastLogon == "y");
- assert(res.msgs[0].objectClass != undefined);
- for (i=0;i<res.msgs[0].objectClass.length;i++) {
- assert(res.msgs[0].objectClass[i] != "user");
- }
- assert(res.msgs[1].dn == s4.dn("cn=X"));
- assert(res.msgs[1].dnsHostName == "x");
- assert(res.msgs[1].lastLogon == "x");
- assert(res.msgs[1].objectClass != undefined);
- assert(res.msgs[1].objectClass[0] == "user");
- assert(res.msgs[2].dn == s4.dn("cn=A"));
- assert(res.msgs[2].dnsHostName == undefined);
- assert(res.msgs[2].lastLogon == "x");
- assert(res.msgs[2].objectClass != undefined);
- assert(res.msgs[2].objectClass[0] == "user");
-
- println("Testing search by parse tree");
-
- /* Search by conjunction of local attributes */
- attrs = new Array("dnsHostName", "lastLogon");
- res = ldb.search("(&(codePage=x)(revision=x))", NULL, ldb.SCOPE_DEFAULT, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 2);
- assert(res.msgs[0].dn == s4.dn("cn=Y"));
- assert(res.msgs[0].dnsHostName == "y");
- assert(res.msgs[0].lastLogon == "y");
- assert(res.msgs[1].dn == s4.dn("cn=X"));
- assert(res.msgs[1].dnsHostName == "x");
- assert(res.msgs[1].lastLogon == "x");
-
- /* Search by conjunction of remote attributes */
- attrs = new Array("dnsHostName", "lastLogon");
- res = ldb.search("(&(lastLogon=x)(description=x))", NULL, ldb.SCOPE_DEFAULT, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 2);
- assert(res.msgs[0].dn == s4.dn("cn=X"));
- assert(res.msgs[0].dnsHostName == "x");
- assert(res.msgs[0].lastLogon == "x");
- assert(res.msgs[1].dn == s4.dn("cn=A"));
- assert(res.msgs[1].dnsHostName == undefined);
- assert(res.msgs[1].lastLogon == "x");
-
- /* Search by conjunction of local and remote attribute */
- attrs = new Array("dnsHostName", "lastLogon");
- res = ldb.search("(&(codePage=x)(description=x))", NULL, ldb.SCOPE_DEFAULT, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 2);
- assert(res.msgs[0].dn == s4.dn("cn=Y"));
- assert(res.msgs[0].dnsHostName == "y");
- assert(res.msgs[0].lastLogon == "y");
- assert(res.msgs[1].dn == s4.dn("cn=X"));
- assert(res.msgs[1].dnsHostName == "x");
- assert(res.msgs[1].lastLogon == "x");
-
- /* Search by conjunction of local and remote attribute w/o match */
- attrs = new Array("dnsHostName", "lastLogon");
- res = ldb.search("(&(codePage=x)(nextRid=x))", NULL, ldb.SCOPE_DEFAULT, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 0);
- res = ldb.search("(&(revision=x)(lastLogon=z))", NULL, ldb.SCOPE_DEFAULT, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 0);
-
- /* Search by disjunction of local attributes */
- attrs = new Array("dnsHostName", "lastLogon");
- res = ldb.search("(|(revision=x)(dnsHostName=x))", NULL, ldb.SCOPE_DEFAULT, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 2);
- assert(res.msgs[0].dn == s4.dn("cn=Y"));
- assert(res.msgs[0].dnsHostName == "y");
- assert(res.msgs[0].lastLogon == "y");
- assert(res.msgs[1].dn == s4.dn("cn=X"));
- assert(res.msgs[1].dnsHostName == "x");
- assert(res.msgs[1].lastLogon == "x");
-
- /* Search by disjunction of remote attributes */
- attrs = new Array("dnsHostName", "lastLogon");
- res = ldb.search("(|(badPwdCount=x)(lastLogon=x))", NULL, ldb.SCOPE_DEFAULT, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 3);
- assert(res.msgs[0].dn == s4.dn("cn=B"));
- assert(res.msgs[0].dnsHostName == undefined);
- assert(res.msgs[0].lastLogon == "y");
- assert(res.msgs[1].dn == s4.dn("cn=X"));
- assert(res.msgs[1].dnsHostName == "x");
- assert(res.msgs[1].lastLogon == "x");
- assert(res.msgs[2].dn == s4.dn("cn=A"));
- assert(res.msgs[2].dnsHostName == undefined);
- assert(res.msgs[2].lastLogon == "x");
-
- /* Search by disjunction of local and remote attribute */
- attrs = new Array("dnsHostName", "lastLogon");
- res = ldb.search("(|(revision=x)(lastLogon=y))", NULL, ldb.SCOPE_DEFAULT, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 3);
- assert(res.msgs[0].dn == s4.dn("cn=Y"));
- assert(res.msgs[0].dnsHostName == "y");
- assert(res.msgs[0].lastLogon == "y");
- assert(res.msgs[1].dn == s4.dn("cn=B"));
- assert(res.msgs[1].dnsHostName == undefined);
- assert(res.msgs[1].lastLogon == "y");
- assert(res.msgs[2].dn == s4.dn("cn=X"));
- assert(res.msgs[2].dnsHostName == "x");
- assert(res.msgs[2].lastLogon == "x");
-
- /* Search by disjunction of local and remote attribute w/o match */
- attrs = new Array("dnsHostName", "lastLogon");
- res = ldb.search("(|(codePage=y)(nextRid=z))", NULL, ldb.SCOPE_DEFAULT, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 0);
-
- /* Search by negated local attribute */
- attrs = new Array("dnsHostName", "lastLogon");
- res = ldb.search("(!(revision=x))", NULL, ldb.SCOPE_DEFAULT, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 5);
- assert(res.msgs[0].dn == s4.dn("cn=B"));
- assert(res.msgs[0].dnsHostName == undefined);
- assert(res.msgs[0].lastLogon == "y");
- assert(res.msgs[1].dn == s4.dn("cn=A"));
- assert(res.msgs[1].dnsHostName == undefined);
- assert(res.msgs[1].lastLogon == "x");
- assert(res.msgs[2].dn == s4.dn("cn=Z"));
- assert(res.msgs[2].dnsHostName == "z");
- assert(res.msgs[2].lastLogon == "z");
- assert(res.msgs[3].dn == s4.dn("cn=C"));
- assert(res.msgs[3].dnsHostName == undefined);
- assert(res.msgs[3].lastLogon == "z");
-
- /* Search by negated remote attribute */
- attrs = new Array("dnsHostName", "lastLogon");
- res = ldb.search("(!(description=x))", NULL, ldb.SCOPE_DEFAULT, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 3);
- assert(res.msgs[0].dn == s4.dn("cn=Z"));
- assert(res.msgs[0].dnsHostName == "z");
- assert(res.msgs[0].lastLogon == "z");
- assert(res.msgs[1].dn == s4.dn("cn=C"));
- assert(res.msgs[1].dnsHostName == undefined);
- assert(res.msgs[1].lastLogon == "z");
-
- /* Search by negated conjunction of local attributes */
- attrs = new Array("dnsHostName", "lastLogon");
- res = ldb.search("(!(&(codePage=x)(revision=x)))", NULL, ldb.SCOPE_DEFAULT, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 5);
- assert(res.msgs[0].dn == s4.dn("cn=B"));
- assert(res.msgs[0].dnsHostName == undefined);
- assert(res.msgs[0].lastLogon == "y");
- assert(res.msgs[1].dn == s4.dn("cn=A"));
- assert(res.msgs[1].dnsHostName == undefined);
- assert(res.msgs[1].lastLogon == "x");
- assert(res.msgs[2].dn == s4.dn("cn=Z"));
- assert(res.msgs[2].dnsHostName == "z");
- assert(res.msgs[2].lastLogon == "z");
- assert(res.msgs[3].dn == s4.dn("cn=C"));
- assert(res.msgs[3].dnsHostName == undefined);
- assert(res.msgs[3].lastLogon == "z");
-
- /* Search by negated conjunction of remote attributes */
- attrs = new Array("dnsHostName", "lastLogon");
- res = ldb.search("(!(&(lastLogon=x)(description=x)))", NULL, ldb.SCOPE_DEFAULT, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 5);
- assert(res.msgs[0].dn == s4.dn("cn=Y"));
- assert(res.msgs[0].dnsHostName == "y");
- assert(res.msgs[0].lastLogon == "y");
- assert(res.msgs[1].dn == s4.dn("cn=B"));
- assert(res.msgs[1].dnsHostName == undefined);
- assert(res.msgs[1].lastLogon == "y");
- assert(res.msgs[2].dn == s4.dn("cn=Z"));
- assert(res.msgs[2].dnsHostName == "z");
- assert(res.msgs[2].lastLogon == "z");
- assert(res.msgs[3].dn == s4.dn("cn=C"));
- assert(res.msgs[3].dnsHostName == undefined);
- assert(res.msgs[3].lastLogon == "z");
-
- /* Search by negated conjunction of local and remote attribute */
- attrs = new Array("dnsHostName", "lastLogon");
- res = ldb.search("(!(&(codePage=x)(description=x)))", NULL, ldb.SCOPE_DEFAULT, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 5);
- assert(res.msgs[0].dn == s4.dn("cn=B"));
- assert(res.msgs[0].dnsHostName == undefined);
- assert(res.msgs[0].lastLogon == "y");
- assert(res.msgs[1].dn == s4.dn("cn=A"));
- assert(res.msgs[1].dnsHostName == undefined);
- assert(res.msgs[1].lastLogon == "x");
- assert(res.msgs[2].dn == s4.dn("cn=Z"));
- assert(res.msgs[2].dnsHostName == "z");
- assert(res.msgs[2].lastLogon == "z");
- assert(res.msgs[3].dn == s4.dn("cn=C"));
- assert(res.msgs[3].dnsHostName == undefined);
- assert(res.msgs[3].lastLogon == "z");
-
- /* Search by negated disjunction of local attributes */
- attrs = new Array("dnsHostName", "lastLogon");
- res = ldb.search("(!(|(revision=x)(dnsHostName=x)))", NULL, ldb.SCOPE_DEFAULT, attrs);
- assert(res.error == 0);
- assert(res.msgs[0].dn == s4.dn("cn=B"));
- assert(res.msgs[0].dnsHostName == undefined);
- assert(res.msgs[0].lastLogon == "y");
- assert(res.msgs[1].dn == s4.dn("cn=A"));
- assert(res.msgs[1].dnsHostName == undefined);
- assert(res.msgs[1].lastLogon == "x");
- assert(res.msgs[2].dn == s4.dn("cn=Z"));
- assert(res.msgs[2].dnsHostName == "z");
- assert(res.msgs[2].lastLogon == "z");
- assert(res.msgs[3].dn == s4.dn("cn=C"));
- assert(res.msgs[3].dnsHostName == undefined);
- assert(res.msgs[3].lastLogon == "z");
-
- /* Search by negated disjunction of remote attributes */
- attrs = new Array("dnsHostName", "lastLogon");
- res = ldb.search("(!(|(badPwdCount=x)(lastLogon=x)))", NULL, ldb.SCOPE_DEFAULT, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 4);
- assert(res.msgs[0].dn == s4.dn("cn=Y"));
- assert(res.msgs[0].dnsHostName == "y");
- assert(res.msgs[0].lastLogon == "y");
- assert(res.msgs[1].dn == s4.dn("cn=Z"));
- assert(res.msgs[1].dnsHostName == "z");
- assert(res.msgs[1].lastLogon == "z");
- assert(res.msgs[2].dn == s4.dn("cn=C"));
- assert(res.msgs[2].dnsHostName == undefined);
- assert(res.msgs[2].lastLogon == "z");
-
- /* Search by negated disjunction of local and remote attribute */
- attrs = new Array("dnsHostName", "lastLogon");
- res = ldb.search("(!(|(revision=x)(lastLogon=y)))", NULL, ldb.SCOPE_DEFAULT, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 4);
- assert(res.msgs[0].dn == s4.dn("cn=A"));
- assert(res.msgs[0].dnsHostName == undefined);
- assert(res.msgs[0].lastLogon == "x");
- assert(res.msgs[1].dn == s4.dn("cn=Z"));
- assert(res.msgs[1].dnsHostName == "z");
- assert(res.msgs[1].lastLogon == "z");
- assert(res.msgs[2].dn == s4.dn("cn=C"));
- assert(res.msgs[2].dnsHostName == undefined);
- assert(res.msgs[2].lastLogon == "z");
-
- println("Search by complex parse tree");
- attrs = new Array("dnsHostName", "lastLogon");
- res = ldb.search("(|(&(revision=x)(dnsHostName=x))(!(&(description=x)(nextRid=y)))(badPwdCount=y))", NULL, ldb.SCOPE_DEFAULT, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 6);
- assert(res.msgs[0].dn == s4.dn("cn=B"));
- assert(res.msgs[0].dnsHostName == undefined);
- assert(res.msgs[0].lastLogon == "y");
- assert(res.msgs[1].dn == s4.dn("cn=X"));
- assert(res.msgs[1].dnsHostName == "x");
- assert(res.msgs[1].lastLogon == "x");
- assert(res.msgs[2].dn == s4.dn("cn=A"));
- assert(res.msgs[2].dnsHostName == undefined);
- assert(res.msgs[2].lastLogon == "x");
- assert(res.msgs[3].dn == s4.dn("cn=Z"));
- assert(res.msgs[3].dnsHostName == "z");
- assert(res.msgs[3].lastLogon == "z");
- assert(res.msgs[4].dn == s4.dn("cn=C"));
- assert(res.msgs[4].dnsHostName == undefined);
- assert(res.msgs[4].lastLogon == "z");
-
- /* Clean up */
- var dns = new Array();
- dns[0] = s4.dn("cn=A");
- dns[1] = s4.dn("cn=B");
- dns[2] = s4.dn("cn=C");
- dns[3] = s4.dn("cn=X");
- dns[4] = s4.dn("cn=Y");
- dns[5] = s4.dn("cn=Z");
- for (i=0;i<dns.length;i++) {
- var ok = ldb.del(dns[i]);
- assert(ok.error == 0);
- }
-}
-
-function test_map_modify(ldb, s3, s4)
-{
- println("Running modification tests on mapped data");
-
- var ldif;
- var attrs;
- var dn, dn2;
- var res;
- var ok;
-
- println("Testing modification of local records");
-
- /* Add local record */
- dn = "cn=test,dc=idealx,dc=org";
- ldif = "
-dn: " + dn + "
-cn: test
-foo: bar
-revision: 1
-description: test
-";
- ok = ldb.add(ldif);
- assert(ok.error == 0);
- /* Check it's there */
- attrs = new Array("foo", "revision", "description");
- res = ldb.search("", dn, ldb.SCOPE_BASE, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 1);
- assert(res.msgs[0].dn == dn);
- assert(res.msgs[0].foo == "bar");
- assert(res.msgs[0].revision == "1");
- assert(res.msgs[0].description == "test");
- /* Check it's not in the local db */
- res = s4.db.search("(cn=test)", NULL, ldb.SCOPE_DEFAULT, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 0);
- /* Check it's not in the remote db */
- res = s3.db.search("(cn=test)", NULL, ldb.SCOPE_DEFAULT, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 0);
-
- /* Modify local record */
- ldif = "
-dn: " + dn + "
-replace: foo
-foo: baz
-replace: description
-description: foo
-";
- ok = ldb.modify(ldif);
- assert(ok.error == 0);
- /* Check in local db */
- res = ldb.search("", dn, ldb.SCOPE_BASE, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 1);
- assert(res.msgs[0].dn == dn);
- assert(res.msgs[0].foo == "baz");
- assert(res.msgs[0].revision == "1");
- assert(res.msgs[0].description == "foo");
-
- /* Rename local record */
- dn2 = "cn=toast,dc=idealx,dc=org";
- ok = ldb.rename(dn, dn2);
- assert(ok.error == 0);
- /* Check in local db */
- res = ldb.search("", dn2, ldb.SCOPE_BASE, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 1);
- assert(res.msgs[0].dn == dn2);
- assert(res.msgs[0].foo == "baz");
- assert(res.msgs[0].revision == "1");
- assert(res.msgs[0].description == "foo");
-
- /* Delete local record */
- ok = ldb.del(dn2);
- assert(ok.error == 0);
- /* Check it's gone */
- res = ldb.search("", dn2, ldb.SCOPE_BASE);
- assert(res.error == 0);
- assert(res.msgs.length == 0);
-
- println("Testing modification of remote records");
-
- /* Add remote record */
- dn = s4.dn("cn=test");
- dn2 = s3.dn("cn=test");
- ldif = "
-dn: " + dn2 + "
-cn: test
-description: foo
-sambaBadPasswordCount: 3
-sambaNextRid: 1001
-";
- ok = s3.db.add(ldif);
- assert(ok.error == 0);
- /* Check it's there */
- attrs = new Array("description", "sambaBadPasswordCount", "sambaNextRid");
- res = s3.db.search("", dn2, ldb.SCOPE_BASE, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 1);
- assert(res.msgs[0].dn == dn2);
- assert(res.msgs[0].description == "foo");
- assert(res.msgs[0].sambaBadPasswordCount == "3");
- assert(res.msgs[0].sambaNextRid == "1001");
- /* Check in mapped db */
- attrs = new Array("description", "badPwdCount", "nextRid");
- res = ldb.search("", dn, ldb.SCOPE_BASE, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 1);
- assert(res.msgs[0].dn == dn);
- assert(res.msgs[0].description == "foo");
- assert(res.msgs[0].badPwdCount == "3");
- assert(res.msgs[0].nextRid == "1001");
- /* Check in local db */
- res = s4.db.search("", dn, ldb.SCOPE_BASE, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 0);
-
- /* Modify remote data of remote record */
- ldif = "
-dn: " + dn + "
-replace: description
-description: test
-replace: badPwdCount
-badPwdCount: 4
-";
- ok = ldb.modify(ldif);
- /* Check in mapped db */
- attrs = new Array("description", "badPwdCount", "nextRid");
- res = ldb.search("", dn, ldb.SCOPE_BASE, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 1);
- assert(res.msgs[0].dn == dn);
- assert(res.msgs[0].description == "test");
- assert(res.msgs[0].badPwdCount == "4");
- assert(res.msgs[0].nextRid == "1001");
- /* Check in remote db */
- attrs = new Array("description", "sambaBadPasswordCount", "sambaNextRid");
- res = s3.db.search("", dn2, ldb.SCOPE_BASE, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 1);
- assert(res.msgs[0].dn == dn2);
- assert(res.msgs[0].description == "test");
- assert(res.msgs[0].sambaBadPasswordCount == "4");
- assert(res.msgs[0].sambaNextRid == "1001");
-
- /* Rename remote record */
- dn2 = s4.dn("cn=toast");
- ok = ldb.rename(dn, dn2);
- assert(ok.error == 0);
- /* Check in mapped db */
- dn = dn2;
- attrs = new Array("description", "badPwdCount", "nextRid");
- res = ldb.search("", dn, ldb.SCOPE_BASE, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 1);
- assert(res.msgs[0].dn == dn);
- assert(res.msgs[0].description == "test");
- assert(res.msgs[0].badPwdCount == "4");
- assert(res.msgs[0].nextRid == "1001");
- /* Check in remote db */
- dn2 = s3.dn("cn=toast");
- attrs = new Array("description", "sambaBadPasswordCount", "sambaNextRid");
- res = s3.db.search("", dn2, ldb.SCOPE_BASE, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 1);
- assert(res.msgs[0].dn == dn2);
- assert(res.msgs[0].description == "test");
- assert(res.msgs[0].sambaBadPasswordCount == "4");
- assert(res.msgs[0].sambaNextRid == "1001");
-
- /* Delete remote record */
- ok = ldb.del(dn);
- assert(ok.error == 0);
- /* Check in mapped db */
- res = ldb.search("", dn, ldb.SCOPE_BASE);
- assert(res.error == 0);
- assert(res.msgs.length == 0);
- /* Check in remote db */
- res = s3.db.search("", dn2, ldb.SCOPE_BASE);
- assert(res.error == 0);
- assert(res.msgs.length == 0);
-
- /* Add remote record (same as before) */
- dn = s4.dn("cn=test");
- dn2 = s3.dn("cn=test");
- ldif = "
-dn: " + dn2 + "
-cn: test
-description: foo
-sambaBadPasswordCount: 3
-sambaNextRid: 1001
-";
- ok = s3.db.add(ldif);
- assert(ok.error == 0);
-
- /* Modify local data of remote record */
- ldif = "
-dn: " + dn + "
-add: revision
-revision: 1
-replace: description
-description: test
-";
- ok = ldb.modify(ldif);
- /* Check in mapped db */
- attrs = new Array("revision", "description");
- res = ldb.search("", dn, ldb.SCOPE_BASE, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 1);
- assert(res.msgs[0].dn == dn);
- assert(res.msgs[0].description == "test");
- assert(res.msgs[0].revision == "1");
- /* Check in remote db */
- res = s3.db.search("", dn2, ldb.SCOPE_BASE, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 1);
- assert(res.msgs[0].dn == dn2);
- assert(res.msgs[0].description == "test");
- assert(res.msgs[0].revision == undefined);
- /* Check in local db */
- res = s4.db.search("", dn, ldb.SCOPE_BASE, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 1);
- assert(res.msgs[0].dn == dn);
- assert(res.msgs[0].description == undefined);
- assert(res.msgs[0].revision == "1");
-
- /* Delete (newly) split record */
- ok = ldb.del(dn);
- assert(ok.error == 0);
-
- println("Testing modification of split records");
-
- /* Add split record */
- dn = s4.dn("cn=test");
- dn2 = s3.dn("cn=test");
- ldif = "
-dn: " + dn + "
-cn: test
-description: foo
-badPwdCount: 3
-nextRid: 1001
-revision: 1
-";
- ok = ldb.add(ldif);
- assert(ok.error == 0);
- /* Check it's there */
- attrs = new Array("description", "badPwdCount", "nextRid", "revision");
- res = ldb.search("", dn, ldb.SCOPE_BASE, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 1);
- assert(res.msgs[0].dn == dn);
- assert(res.msgs[0].description == "foo");
- assert(res.msgs[0].badPwdCount == "3");
- assert(res.msgs[0].nextRid == "1001");
- assert(res.msgs[0].revision == "1");
- /* Check in local db */
- res = s4.db.search("", dn, ldb.SCOPE_BASE, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 1);
- assert(res.msgs[0].dn == dn);
- assert(res.msgs[0].description == undefined);
- assert(res.msgs[0].badPwdCount == undefined);
- assert(res.msgs[0].nextRid == undefined);
- assert(res.msgs[0].revision == "1");
- /* Check in remote db */
- attrs = new Array("description", "sambaBadPasswordCount", "sambaNextRid", "revision");
- res = s3.db.search("", dn2, ldb.SCOPE_BASE, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 1);
- assert(res.msgs[0].dn == dn2);
- assert(res.msgs[0].description == "foo");
- assert(res.msgs[0].sambaBadPasswordCount == "3");
- assert(res.msgs[0].sambaNextRid == "1001");
- assert(res.msgs[0].revision == undefined);
-
- /* Modify of split record */
- ldif = "
-dn: " + dn + "
-replace: description
-description: test
-replace: badPwdCount
-badPwdCount: 4
-replace: revision
-revision: 2
-";
- ok = ldb.modify(ldif);
- assert(ok.error == 0);
- /* Check in mapped db */
- attrs = new Array("description", "badPwdCount", "nextRid", "revision");
- res = ldb.search("", dn, ldb.SCOPE_BASE, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 1);
- assert(res.msgs[0].dn == dn);
- assert(res.msgs[0].description == "test");
- assert(res.msgs[0].badPwdCount == "4");
- assert(res.msgs[0].nextRid == "1001");
- assert(res.msgs[0].revision == "2");
- /* Check in local db */
- res = s4.db.search("", dn, ldb.SCOPE_BASE, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 1);
- assert(res.msgs[0].dn == dn);
- assert(res.msgs[0].description == undefined);
- assert(res.msgs[0].badPwdCount == undefined);
- assert(res.msgs[0].nextRid == undefined);
- assert(res.msgs[0].revision == "2");
- /* Check in remote db */
- attrs = new Array("description", "sambaBadPasswordCount", "sambaNextRid", "revision");
- res = s3.db.search("", dn2, ldb.SCOPE_BASE, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 1);
- assert(res.msgs[0].dn == dn2);
- assert(res.msgs[0].description == "test");
- assert(res.msgs[0].sambaBadPasswordCount == "4");
- assert(res.msgs[0].sambaNextRid == "1001");
- assert(res.msgs[0].revision == undefined);
-
- /* Rename split record */
- dn2 = s4.dn("cn=toast");
- ok = ldb.rename(dn, dn2);
- assert(ok.error == 0);
- /* Check in mapped db */
- dn = dn2;
- attrs = new Array("description", "badPwdCount", "nextRid", "revision");
- res = ldb.search("", dn, ldb.SCOPE_BASE, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 1);
- assert(res.msgs[0].dn == dn);
- assert(res.msgs[0].description == "test");
- assert(res.msgs[0].badPwdCount == "4");
- assert(res.msgs[0].nextRid == "1001");
- assert(res.msgs[0].revision == "2");
- /* Check in local db */
- res = s4.db.search("", dn, ldb.SCOPE_BASE, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 1);
- assert(res.msgs[0].dn == dn);
- assert(res.msgs[0].description == undefined);
- assert(res.msgs[0].badPwdCount == undefined);
- assert(res.msgs[0].nextRid == undefined);
- assert(res.msgs[0].revision == "2");
- /* Check in remote db */
- dn2 = s3.dn("cn=toast");
- attrs = new Array("description", "sambaBadPasswordCount", "sambaNextRid", "revision");
- res = s3.db.search("", dn2, ldb.SCOPE_BASE, attrs);
- assert(res.error == 0);
- assert(res.msgs.length == 1);
- assert(res.msgs[0].dn == dn2);
- assert(res.msgs[0].description == "test");
- assert(res.msgs[0].sambaBadPasswordCount == "4");
- assert(res.msgs[0].sambaNextRid == "1001");
- assert(res.msgs[0].revision == undefined);
-
- /* Delete split record */
- ok = ldb.del(dn);
- assert(ok.error == 0);
- /* Check in mapped db */
- res = ldb.search("", dn, ldb.SCOPE_BASE);
- assert(res.error == 0);
- assert(res.msgs.length == 0);
- /* Check in local db */
- res = s4.db.search("", dn, ldb.SCOPE_BASE);
- assert(res.error == 0);
- assert(res.msgs.length == 0);
- /* Check in remote db */
- res = s3.db.search("", dn2, ldb.SCOPE_BASE);
- assert(res.error == 0);
- assert(res.msgs.length == 0);
-}
-
-function make_dn(rdn)
-{
- return rdn + ",sambaDomainName=TESTS," + this.BASEDN;
-}
-
-function make_s4dn(rdn)
-{
- return rdn + "," + this.BASEDN;
-}
-
-var ldb = ldb_init();
-
-sys = sys_init();
-var ldbfile = prefix + "/" + "test.ldb";
-var ldburl = "tdb://" + ldbfile;
-
-var samba4 = new Object("samba4 partition info");
-samba4.file = prefix + "/" + "samba4.ldb";
-samba4.url = "tdb://" + samba4.file;
-samba4.BASEDN = "dc=vernstok,dc=nl";
-samba4.db = ldb_init();
-samba4.dn = make_s4dn;
-
-var samba3 = new Object("samba3 partition info");
-samba3.file = prefix + "/" + "samba3.ldb";
-samba3.url = "tdb://" + samba3.file;
-samba3.BASEDN = "cn=Samba3Sam";
-samba3.db = ldb_init();
-samba3.dn = make_dn;
-
-var templates = new Object("templates partition info");
-templates.file = prefix + "/" + "templates.ldb";
-templates.url = "tdb://" + templates.file;
-templates.BASEDN = "cn=templates";
-templates.db = ldb_init();
-
-sys.unlink(ldbfile);
-sys.unlink(samba3.file);
-sys.unlink(templates.file);
-sys.unlink(samba4.file);
-
-var ok = ldb.connect(ldburl);
-assert(ok);
-var ok = samba3.db.connect(samba3.url);
-assert(ok);
-var ok = templates.db.connect(templates.url);
-assert(ok);
-var ok = samba4.db.connect(samba4.url);
-assert(ok);
-
-setup_data(samba3, sys.file_load(datadir + "/" + "samba3.ldif"));
-setup_data(templates, sys.file_load(datadir + "/" + "provision_samba3sam_templates.ldif"));
-setup_modules(ldb, samba3, samba4, sys.file_load(datadir + "/" + "provision_samba3sam.ldif"));
-
-ldb = ldb_init();
-var ok = ldb.connect(ldburl);
-assert(ok);
-
-test_s3sam_search(ldb);
-test_s3sam_modify(ldb, samba3);
-
-sys.unlink(ldbfile);
-sys.unlink(samba3.file);
-sys.unlink(templates.file);
-sys.unlink(samba4.file);
-
-ldb = ldb_init();
-var ok = ldb.connect(ldburl);
-assert(ok);
-samba3.db = ldb_init();
-var ok = samba3.db.connect(samba3.url);
-assert(ok);
-templates.db = ldb_init();
-var ok = templates.db.connect(templates.url);
-assert(ok);
-samba4.db = ldb_init();
-var ok = samba4.db.connect(samba4.url);
-assert(ok);
-
-setup_data(templates, sys.file_load(datadir + "/" + "provision_samba3sam_templates.ldif"));
-setup_modules(ldb, samba3, samba4, sys.file_load(datadir + "provision_samba3sam.ldif"));
-
-ldb = ldb_init();
-var ok = ldb.connect(ldburl);
-assert(ok);
-
-test_map_search(ldb, samba3, samba4);
-test_map_modify(ldb, samba3, samba4);
-
-sys.unlink(ldbfile);
-sys.unlink(samba3.file);
-sys.unlink(samba4.file);
-
-return 0;
+++ /dev/null
-#!/usr/bin/env smbscript
-/*
- test sprintf function
-*/
-
-string_init(local);
-
-function check_result(s, v)
-{
- if (s != v) {
- println("expected '" + v + "' but got '" + s + "'");
- }
- assert(s == v);
-}
-
-function xprintf()
-{
- return "XX{" + vsprintf(arguments) + "}XX";
-}
-
-check_result(sprintf("%d", 7), "7");
-check_result(sprintf("%04d", 42), "0042");
-check_result(sprintf("my string=%7.2s", "foo%7"), "my string= fo");
-check_result(sprintf("blah=0x%*x", 4, 19), "blah=0x 13");
-check_result(sprintf("blah=0x%0*x", 4, 19), "blah=0x0013");
-check_result(sprintf("blah=%.0f", 1032), "blah=1032");
-check_result(sprintf("%4.2f%%", 72.32), "72.32%");
-
-check_result(xprintf("%4.2f%% and %s", 72.32, "foo"),"XX{72.32% and foo}XX");
-
-println("ALL OK");
git.samba.org / bbaumbach / samba-autobuild / .git / commitdiff