geos_one/bongo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

Remove remnants of MDB libraries and plugins \o/

Browse Source
This commit is contained in:
alexhudson
2008-01-12 13:08:44 +00:00
parent 608e5c9098
commit f033f510f0
17 changed files with 0 additions and 15504 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/libs/mdb-file/Bongo.rules
-19
View File
@@ -1,19 +0,0 @@
# -*- Makefile -*-
mdb_LTLIBRARIES += libmdbfile.la
libmdbfile_la_SOURCES = \
src/libs/mdb-file/mdbfile.c \
src/libs/mdb-file/mdbfilep.h
libmdbfile_la_CPPFLAGS = $(AM_CPPFLAGS) \
-DLOCALSTATEDIR=\""$(localstatedir)"\" \
-DMDB_INTERNAL
libmdbfile_la_LDFLAGS = -module -avoid-version
libmdbfile_la_LIBADD = \
libbongoutil.la \
libbongomemmgr.la \
libbongoxpl.la
src/libs/mdb-file/all: libmdbfile.la
src/libs/mdb-file/clean: clean
src/libs/mdb-file/Makefile.am
-17
View File
@@ -1,17 +0,0 @@
# -*- Makefile -*-
#
# Do not edit!
#
# (unless this is Makefile.am.subdir)
#
# This file is a copy of the toplevel Makefile.am.subdir. If changes
# need to be made, edit that file, and make update-makefiles, and
# check the new files in.
#
# This is a skeletal automake file. The real automake fules for
# building the targets for this directory can be found in the
# Bongo.rules file. This file is simply here so that 'make all' can
# work in each subdirectory.
all clean install:
@cd $(top_builddir) && $(MAKE) $(MFLAGS) $(subdir)/$@
src/libs/mdb-file/mdbfile.c
-3998
View File
File diff suppressed because it is too large Load Diff
src/libs/mdb-file/mdbfilep.h
-366
View File
@@ -1,366 +0,0 @@
/*
* <Novell-copyright>
* Copyright (c) 2001 Novell, Inc. All Rights Reserved.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of version 2 of the GNU General Public License
* as published by the Free Software Foundation.
*
* 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, contact Novell, Inc.
*
* To contact Novell about this file by physical or electronic mail, you
* may find current contact information at www.novell.com.
* </Novell-copyright>
*/
#ifndef MDBP_H
#define MDBP_H
/* Little helpers */
#define MDB_CONTEXT_IS_VALID(ValueStruct) (ValueStruct->Flags & MDB_FLAGS_CONTEXT_VALID)
/* Bit definitions */
#define MDB_FLAGS_ALLOCATED_HANDLE (unsigned long)(1<<0) /* The Init function has allocated the handle */
#define MDB_FLAGS_CONTEXT_VALID (unsigned long)(1<<1) /* The Context handle is valid */
#define MDB_FLAGS_CONTEXT_DUPLICATE (unsigned long)(1<<2) /* The context handle is duplicated, do not free it */
#define MDB_FLAGS_BASEDN_CHANGED (unsigned long)(1<<3) /* Caching uses this, if the DN of a context is changed, this is set */
#define VALUE_ALLOC_SIZE 20
#define VALUE_BUFFER_SIZE (10 * 1024)
#define ERR_NO_SUCH_ENTRY 0xFFFFFDA7
#define ERR_NO_SUCH_VALUE 0xFFFFFDA6
#define ERR_NO_SUCH_ATTRIBUTE 0xFFFFFDA5
#define ERR_NO_SUCH_CLASS 0xFFFFFDA4
#define ERR_NO_SUCH_PARTITION 0xFFFFFDA3
#define ERR_ENTRY_ALREADY_EXISTS 0xFFFFFDA2
#define ERR_NOT_EFFECTIVE_CLASS 0xFFFFFDA1
#define ERR_ILLEGAL_ATTRIBUTE 0xFFFFFDA0
#define ERR_MISSING_MANDATORY 0xFFFFFD9F
#define ERR_ILLEGAL_DS_NAME 0xFFFFFD9E
#define ERR_ILLEGAL_CONTAINMENT 0xFFFFFD9D
#define ERR_CANT_HAVE_MULTIPLE_VALUES 0xFFFFFD9C
#define ERR_SYNTAX_VIOLATION 0xFFFFFD9B
#define ERR_DUPLICATE_VALUE 0xFFFFFD9A
#define ERR_ATTRIBUTE_ALREADY_EXISTS 0xFFFFFD99
#define ERR_MAXIMUM_ENTRIES_EXIST 0xFFFFFD98
#define ERR_DATABASE_FORMAT 0xFFFFFD97
#define ERR_INCONSISTENT_DATABASE 0xFFFFFD96
#define ERR_INVALID_COMPARISON 0xFFFFFD95
#define ERR_COMPARISON_FAILED 0xFFFFFD94
#define ERR_TRANSACTIONS_DISABLED 0xFFFFFD93
#define ERR_INVALID_TRANSPORT 0xFFFFFD92
#define ERR_SYNTAX_INVALID_IN_NAME 0xFFFFFD91
#define ERR_TRANSPORT_FAILURE 0xFFFFFD8F
#define ERR_ALL_REFERRALS_FAILED 0xFFFFFD8E
#define ERR_CANT_REMOVE_NAMING_VALUE 0xFFFFFD8D
#define ERR_OBJECT_CLASS_VIOLATION 0xFFFFFD8C
#define ERR_ENTRY_IS_NOT_LEAF 0xFFFFFD8B
#define ERR_DIFFERENT_TREE 0xFFFFFD8A
#define ERR_SYSTEM_FAILURE 0xFFFFFD88
#define ERR_INVALID_ENTRY_FOR_ROOT 0xFFFFFD87
#define ERR_NO_REFERRALS 0xFFFFFD86
#define ERR_REMOTE_FAILURE 0xFFFFFD85
#define ERR_UNREACHABLE_SERVER 0XFFFFFD84
#define ERR_NO_CHARACTER_MAPPING 0XFFFFFD82
#define ERR_INCOMPLETE_AUTHENTICATION 0XFFFFFD81
#define ERR_INVALID_CERTIFICATE 0xFFFFFD80
#define ERR_INVALID_REQUEST 0xFFFFFD7F
#define ERR_INVALID_ITERATION 0xFFFFFD7E
#define ERR_SCHEMA_IS_NONREMOVABLE 0xFFFFFD7D
#define ERR_SCHEMA_IS_IN_USE 0xFFFFFD7C
#define ERR_CLASS_ALREADY_EXISTS 0xFFFFFD7B
#define ERR_BAD_NAMING_ATTRIBUTES 0xFFFFFD7A
#define ERR_INSUFFICIENT_STACK 0xFFFFFD78
#define ERR_INSUFFICIENT_BUFFER 0xFFFFFD77
#define ERR_AMBIGUOUS_CONTAINMENT 0xFFFFFD76
#define ERR_AMBIGUOUS_NAMING 0xFFFFFD75
#define ERR_DUPLICATE_MANDATORY 0xFFFFFD74
#define ERR_DUPLICATE_OPTIONAL 0xFFFFFD73
#define ERR_RECORD_IN_USE 0xFFFFFD6C
#define ERR_ENTRY_NOT_CONTAINER 0xFFFFFD64
#define ERR_FAILED_AUTHENTICATION 0xFFFFFD63
#define ERR_INVALID_CONTEXT 0xFFFFFD62
#define ERR_NO_SUCH_PARENT 0xFFFFFD61
#define ERR_NO_ACCESS 0xFFFFFD60
#define ERR_INVALID_NAME_SERVICE 0xFFFFFD5E
#define ERR_INVALID_TASK 0xFFFFFD5D
#define ERR_INVALID_CONN_HANDLE 0xFFFFFD5C
#define ERR_INVALID_IDENTITY 0xFFFFFD5B
#define ERR_DUPLICATE_ACL 0xFFFFFD5A
#define ERR_ALIAS_OF_AN_ALIAS 0xFFFFFD57
#define ERR_INVALID_RDN 0xFFFFFD4E
#define ERR_INCORRECT_BASE_CLASS 0xFFFFFD4C
#define ERR_MISSING_REFERENCE 0xFFFFFD4B
#define ERR_LOST_ENTRY 0xFFFFFD4A
#define ERR_FATAL 0xFFFFFD45
typedef struct {
/* Semi-public; known to the main MDB library */
unsigned char Description[128];
struct _MDBInterfaceStruct *Interface;
/* Private */
unsigned char Dirname[XPL_MAX_PATH + 1];
BOOL ReadOnly;
} MDBFILEContextStruct;
typedef MDBFILEContextStruct *MDBHandle;
typedef struct {
/* Public part, exposed to allow simpler code */
unsigned char **Value;
unsigned long Used;
unsigned long ErrNo;
struct _MDBInterfaceStruct *Interface;
/* Private part, not exposed in public header */
unsigned long Flags;
unsigned long Allocated;
unsigned char *BaseDN;
unsigned char Buffer[VALUE_BUFFER_SIZE];
unsigned char Path[XPL_MAX_PATH + 1];
unsigned char Filename[(XPL_MAX_PATH * 4) + 1];
MDBFILEContextStruct *Handle;
} MDBValueStruct;
typedef struct {
BOOL Initialized;
unsigned int EntriesLeft;
FILE *File;
MDBValueStruct *V;
unsigned char Buffer[VALUE_BUFFER_SIZE];
unsigned char Filename[(XPL_MAX_PATH * 4) + 1];
unsigned long Offset;
} MDBEnumStruct;
typedef struct _MDBFILEBaseSchemaAttributes {
unsigned char *name;
unsigned long flags;
unsigned long type;
unsigned char *asn1;
} MDBFILEBaseSchemaAttributes;
typedef struct _MDBFILEBaseSchemaClasses {
unsigned char *name;
unsigned long flags;
unsigned char *asn1;
unsigned char *superClass;
unsigned char *containedBy;
unsigned char *namedBy;
unsigned char *mandatory;
unsigned char *optional;
} MDBFILEBaseSchemaClasses;
MDBFILEBaseSchemaAttributes MDBFILEBaseSchemaAttributesList[] = {
{ "ACL",64,17,"2.16.840.1.113719.1.1.4.1.2" },
{ "Aliased Object Name",69,1,"2.5.4.1" },
{ "Back Link",268,23,"2.16.840.1.113719.1.1.4.1.6" },
{ "Bindery Property",12,32,"2.16.840.1.113719.1.1.4.1.8" },
{ "Bindery Object Restriction",13,8,"2.16.840.1.113719.1.1.4.1.7" },
{ "Bindery Type",45,5,"2.16.840.1.113719.1.1.4.1.9" },
{ "CA Private Key",93,32,"2.16.840.1.113719.1.1.4.1.11" },
{ "CA Public Key",205,32,"2.16.840.1.113719.1.1.4.1.12" },
{ "Cartridge",100,3,"2.16.840.1.113719.1.1.4.1.10" },
{ "CN",102,3,"2.5.4.3" },
{ "Printer Configuration",69,32,"2.16.840.1.113719.1.1.4.1.78" },
{ "Convergence",71,8,"2.16.840.1.113719.1.1.4.1.15" },
{ "C",103,3,"2.5.4.6" },
{ "Default Queue",325,1,"2.16.840.1.113719.1.1.4.1.18" },
{ "Description",102,3,"2.5.4.13" },
{ "Partition Creation Time",205,19,"2.16.840.1.113719.1.1.4.1.64" },
{ "Facsimile Telephone Number",68,11,"2.5.4.23" },
{ "High Convergence Sync Interval",69,27,"2.16.840.1.113719.1.1.4.1.117" },
{ "Group Membership",580,1,"2.16.840.1.113719.1.1.4.1.25" },
{ "Home Directory",71,15,"2.16.840.1.113719.1.1.4.1.26" },
{ "Host Device",69,1,"2.16.840.1.113719.1.1.4.1.27" },
{ "Host Resource Name",101,3,"2.16.840.1.113719.1.1.4.1.28" },
{ "Host Server",69,1,"2.16.840.1.113719.1.1.4.1.29" },
{ "Inherited ACL",76,17,"2.16.840.1.113719.1.1.4.1.30" },
{ "L",102,3,"2.5.4.7" },
{ "Login Allowed Time Map",71,32,"2.16.840.1.113719.1.1.4.1.39" },
{ "Login Disabled",69,7,"2.16.840.1.113719.1.1.4.1.40" },
{ "Login Expiration Time",69,24,"2.16.840.1.113719.1.1.4.1.41" },
{ "Login Grace Limit",69,8,"2.16.840.1.113719.1.1.4.1.42" },
{ "Login Grace Remaining",69,22,"2.16.840.1.113719.1.1.4.1.43" },
{ "Login Intruder Address",69,12,"2.16.840.1.113719.1.1.4.1.44" },
{ "Login Intruder Attempts",69,22,"2.16.840.1.113719.1.1.4.1.45" },
{ "Login Intruder Limit",69,8,"2.16.840.1.113719.1.1.4.1.46" },
{ "Intruder Attempt Reset Interval",69,27,"2.16.840.1.113719.1.1.4.1.31" },
{ "Login Intruder Reset Time",69,24,"2.16.840.1.113719.1.1.4.1.47" },
{ "Login Maximum Simultaneous",69,8,"2.16.840.1.113719.1.1.4.1.48" },
{ "Login Script",69,21,"2.16.840.1.113719.1.1.4.1.49" },
{ "Login Time",5,24,"2.16.840.1.113719.1.1.4.1.50" },
{ "Member",68,1,"2.5.4.31" },
{ "Memory",69,8,"2.16.840.1.113719.1.1.4.1.52" },
{ "EMail Address",228,14,"0.9.2342.19200300.100.1.3" },
{ "Network Address",68,12,"2.16.840.1.113719.1.1.4.1.55" },
{ "Network Address Restriction",68,12,"2.16.840.1.113719.1.1.4.1.56" },
{ "Notify",68,25,"2.16.840.1.113719.1.1.4.1.57" },
{ "Obituary",76,32,"2.16.840.1.113719.1.1.4.1.114" },
{ "Object Class",196,20,"2.5.4.0" },
{ "Operator",324,1,"2.16.840.1.113719.1.1.4.1.59" },
{ "OU",102,3,"2.5.4.11" },
{ "O",102,3,"2.5.4.10" },
{ "Owner",68,1,"2.5.4.32" },
{ "Page Description Language",102,4,"2.16.840.1.113719.1.1.4.1.63" },
{ "Passwords Used",86,32,"2.16.840.1.113719.1.1.4.1.65" },
{ "Password Allow Change",69,7,"2.16.840.1.113719.1.1.4.1.66" },
{ "Password Expiration Interval",69,27,"2.16.840.1.113719.1.1.4.1.67" },
{ "Password Expiration Time",69,24,"2.16.840.1.113719.1.1.4.1.68" },
{ "Password Minimum Length",69,8,"2.16.840.1.113719.1.1.4.1.69" },
{ "Password Required",69,7,"2.16.840.1.113719.1.1.4.1.70" },
{ "Password Unique Required",69,7,"2.16.840.1.113719.1.1.4.1.71" },
{ "Path",68,15,"2.16.840.1.113719.1.1.4.1.72" },
{ "Physical Delivery Office Name",102,3,"2.5.4.19" },
{ "Postal Address",68,18,"2.5.4.16" },
{ "Postal Code",102,3,"2.5.4.17" },
{ "Postal Office Box",102,3,"2.5.4.18" },
{ "Print Job Configuration",69,21,"2.16.840.1.113719.1.1.4.1.80" },
{ "Printer Control",69,21,"2.16.840.1.113719.1.1.4.1.79" },
{ "Private Key",93,32,"2.16.840.1.113719.1.1.4.1.82" },
{ "Profile",69,1,"2.16.840.1.113719.1.1.4.1.83" },
{ "Public Key",205,32,"2.16.840.1.113719.1.1.4.1.84" },
{ "Queue",68,25,"2.16.840.1.113719.1.1.4.1.85" },
{ "Queue Directory",359,3,"2.16.840.1.113719.1.1.4.1.86" },
{ "Reference",1052,1,"2.16.840.1.113719.1.1.4.1.115" },
{ "Replica",204,16,"2.16.840.1.113719.1.1.4.1.88" },
{ "Resource",68,1,"2.16.840.1.113719.1.1.4.1.89" },
{ "Role Occupant",68,1,"2.5.4.33" },
{ "Higher Privileges",836,1,"2.16.840.1.113719.1.1.4.1.116" },
{ "Security Equals",836,1,"2.16.840.1.113719.1.1.4.1.92" },
{ "See Also",68,1,"2.5.4.34" },
{ "Serial Number",102,4,"2.16.840.1.113719.1.1.4.1.94" },
{ "Server",324,1,"2.16.840.1.113719.1.1.4.1.95" },
{ "S",102,3,"2.5.4.8" },
{ "Status",197,8,"2.16.840.1.113719.1.1.4.1.98" },
{ "SA",102,3,"2.5.4.9" },
{ "Supported Typefaces",102,3,"2.16.840.1.113719.1.1.4.1.102" },
{ "Supported Services",102,3,"2.16.840.1.113719.1.1.4.1.101" },
{ "Surname",230,3,"2.5.4.4" },
{ "Telephone Number",100,10,"2.5.4.20" },
{ "Title",102,3,"2.5.4.12" },
{ "Unknown",4,0,"2.16.840.1.113719.1.1.4.1.109" },
{ "User",324,1,"2.16.840.1.113719.1.1.4.1.111" },
{ "Version",231,3,"2.16.840.1.113719.1.1.4.1.112" },
{ "Account Balance",69,22,"2.16.840.1.113719.1.1.4.1.1" },
{ "Allow Unlimited Credit",69,7,"2.16.840.1.113719.1.1.4.1.4" },
{ "Low Convergence Reset Time",69,24,"2.16.840.1.113719.1.1.4.1.118" },
{ "Minimum Account Balance",69,8,"2.16.840.1.113719.1.1.4.1.54" },
{ "Low Convergence Sync Interval",69,27,"2.16.840.1.113719.1.1.4.1.104" },
{ "Device",68,1,"2.16.840.1.113719.1.1.4.1.21" },
{ "Message Server",69,1,"2.16.840.1.113719.1.1.4.1.53" },
{ "Language",69,6,"2.16.840.1.113719.1.1.4.1.34" },
{ "Supported Connections",69,8,"2.16.840.1.113719.1.1.4.1.100" },
{ "Type Creator Map",69,21,"2.16.840.1.113719.1.1.4.1.107" },
{ "UID",69,8,"2.16.840.1.113719.1.1.4.1.108" },
{ "GID",69,8,"2.16.840.1.113719.1.1.4.1.24" },
{ "Unknown Base Class",39,3,"2.16.840.1.113719.1.1.4.1.110" },
{ "Received Up To",204,19,"2.16.840.1.113719.1.1.4.1.87" },
{ "Synchronized Up To",1164,19,"2.16.840.1.113719.1.1.4.1.33" },
{ "Authority Revocation",77,32,"2.16.840.1.113719.1.1.4.1.5" },
{ "Certificate Revocation",77,32,"2.16.840.1.113719.1.1.4.1.13" },
{ "Cross Certificate Pair",68,32,"2.16.840.1.113719.1.1.4.1.17" },
{ "Locked By Intruder",69,7,"2.16.840.1.113719.1.1.4.1.37" },
{ "Printer",68,25,"2.16.840.1.113719.1.1.4.1.77" },
{ "Detect Intruder",69,7,"2.16.840.1.113719.1.1.4.1.20" },
{ "Lockout After Detection",69,7,"2.16.840.1.113719.1.1.4.1.38" },
{ "Intruder Lockout Reset Interval",69,27,"2.16.840.1.113719.1.1.4.1.32" },
{ "Server Holds",68,26,"2.16.840.1.113719.1.1.4.1.96" },
{ "SAP Name",103,3,"2.16.840.1.113719.1.1.4.1.91" },
{ "Volume",69,1,"2.16.840.1.113719.1.1.4.1.113" },
{ "Last Login Time",13,24,"2.16.840.1.113719.1.1.4.1.35" },
{ "Print Server",69,25,"2.16.840.1.113719.1.1.4.1.81" },
{ "NNS Domain",102,3,"2.16.840.1.113719.1.1.4.1.119" },
{ "Full Name",102,3,"2.16.840.1.113719.1.1.4.1.120" },
{ "Partition Control",204,25,"2.16.840.1.113719.1.1.4.1.121" },
{ "Revision",2189,22,"2.16.840.1.113719.1.1.4.1.122" },
{ "Certificate Validity Interval",71,27,"2.16.840.1.113719.1.1.4.1.123" },
{ "External Synchronizer",68,32,"2.16.840.1.113719.1.1.4.1.124" },
{ "Messaging Database Location",69,15,"2.16.840.1.113719.1.1.4.1.125" },
{ "Message Routing Group",68,1,"2.16.840.1.113719.1.1.4.1.126" },
{ "Messaging Server",68,1,"2.16.840.1.113719.1.1.4.1.127" },
{ "Postmaster",68,1,"2.16.840.1.113719.1.1.4.1.128" },
{ "Mailbox Location",197,1,"2.16.840.1.113719.1.1.4.1.162" },
{ "Mailbox ID",231,3,"2.16.840.1.113719.1.1.4.1.163" },
{ "External Name",69,32,"2.16.840.1.113719.1.1.4.1.164" },
{ "Security Flags",69,8,"2.16.840.1.113719.1.1.4.1.165" },
{ "Messaging Server Type",103,3,"2.16.840.1.113719.1.1.4.1.166" },
{ "Last Referenced Time",1029,19,"2.16.840.1.113719.1.1.4.1.167" },
{ "Given Name",230,3,"2.5.4.42" },
{ "Initials",230,3,"2.5.4.43" },
{ "Generational Qualifier",231,3,"2.16.840.1.113719.1.1.4.1.170" },
{ "Profile Membership",580,1,"2.16.840.1.113719.1.1.4.1.171" },
{ "DS Revision",197,8,"2.16.840.1.113719.1.1.4.1.172" },
{ "Supported Gateway",102,3,"2.16.840.1.113719.1.1.4.1.173" },
{ "Equivalent To Me",324,1,"2.16.840.1.113719.1.1.4.1.174" },
{ "Replica Up To",1164,32,"2.16.840.1.113719.1.1.4.1.175" },
{ "Partition Status",1164,32,"2.16.840.1.113719.1.1.4.1.176" },
{ "Permanent Config Parms",196,32,"2.16.840.1.113719.1.1.4.1.177" },
{ "Timezone",133,32,"2.16.840.1.113719.1.1.4.1.178" },
{ "Bindery Restriction Level",5,8,"2.16.840.1.113719.1.1.4.1.179" },
{ "Transitive Vector",2252,32,"2.16.840.1.113719.1.1.4.1.180" },
{ "T",102,3,"2.16.840.1.113719.1.1.4.1.181" },
{ "Purge Vector",3212,19,"2.16.840.1.113719.1.1.4.1.183" },
{ "Synchronization Tolerance",196,19,"2.16.840.1.113719.1.1.4.1.184" },
{ "Password Management",69,0,"2.16.840.1.113719.1.1.4.1.185" },
{ "Used By",332,15,"2.16.840.1.113719.1.1.4.1.186" },
{ "Uses",332,15,"2.16.840.1.113719.1.1.4.1.187" },
{ "Obituary Notify",76,32,"2.16.840.1.113719.1.1.4.1.500" },
{ "GUID",207,32,"2.16.840.1.113719.1.1.4.1.501" },
{ "Other GUID",198,32,"2.16.840.1.113719.1.1.4.1.502" },
{ NULL,0,0,NULL },
};
MDBFILEBaseSchemaClasses MDBFILEBaseSchemaClassesList[] = {
{ "[Nothing]",3,NULL,NULL,NULL,NULL,NULL,NULL },
{ "Top",3,"2.5.6.0",NULL,NULL,"T","Object Class,T","CA Public Key,Private Key,Certificate Validity Interval,Authority Revocation,Last Referenced Time,Equivalent To Me,ACL,Back Link,Bindery Property,Obituary,Reference,Revision,Cross Certificate Pair,Certificate Revocation,Used By,GUID,Other GUID" },
{ "Tree Root",3,"2.16.840.1.113719.1.1.6.1.32","Top","[Nothing]",NULL,NULL,NULL },
{ "Alias",2,"2.5.6.1","Top",NULL,NULL,"Aliased Object Name",NULL },
{ "Country",3,"2.5.6.2","Top","Top,Tree Root,[Nothing]","C","C","Description" },
{ "Locality",3,"2.5.6.3","Top","Locality,Country,Organizational Unit,Organization","L,S",NULL,"Description,L,See Also,S,SA" },
{ "Organization",3,"2.5.6.4",NULL,"Top,Tree Root,Country,Locality,[Nothing]","O","O","Description,Facsimile Telephone Number,L,Login Script,EMail Address,Physical Delivery Office Name,Postal Address,Postal Code,Postal Office Box,Print Job Configuration,Printer Control,See Also,S,SA,Telephone Number,Login Intruder Limit,Intruder Attempt Reset Interval,Detect Intruder,Lockout After Detection,Intruder Lockout Reset Interval" },
{ "Organizational Unit",3,"2.5.6.5",NULL,"Locality,Organization,Organizational Unit","OU","OU","Description,Facsimile Telephone Number,L,Login Script,EMail Address,Physical Delivery Office Name,Postal Address,Postal Code,Postal Office Box,Print Job Configuration,Printer Control,See Also,S,SA,Telephone Number,Login Intruder Limit,Intruder Attempt Reset Interval,Detect Intruder,Lockout After Detection,Intruder Lockout Reset Interval" },
{ "Organizational Role",2,"2.5.6.8","Top","Organization,Organizational Unit","CN","CN","Description,Facsimile Telephone Number,L,EMail Address,OU,Physical Delivery Office Name,Postal Address,Postal Code,Postal Office Box,Role Occupant,See Also,S,SA,Telephone Number,Mailbox Location,Mailbox ID" },
{ "Group",2,"2.5.6.17","Top","Organization,Organizational Unit","CN","CN","Description,L,Member,OU,O,Owner,See Also,GID,Full Name,EMail Address,Mailbox Location,Mailbox ID,Profile,Profile Membership,Login Script" },
{ "Person",2,"2.5.6.6",NULL,"Organization,Organizational Unit","CN","CN","Description,See Also,Telephone Number,Full Name,Given Name,Initials,Generational Qualifier" },
{ "Organizational Person",2,"2.5.6.7","Person","Organization,Organizational Unit","CN,OU",NULL,"Facsimile Telephone Number,L,EMail Address,OU,Physical Delivery Office Name,Postal Address,Postal Code,Postal Office Box,S,SA,Title,Mailbox Location,Mailbox ID" },
{ "User",2,"2.5.6.10","Organizational Person",NULL,NULL,NULL,"Group Membership,Home Directory,Login Allowed Time Map,Login Disabled,Login Expiration Time,Login Grace Limit,Login Grace Remaining,Login Intruder Address,Login Intruder Attempts,Login Intruder Reset Time,Login Maximum Simultaneous,Login Script,Login Time,Network Address Restriction,Network Address,Passwords Used,Password Allow Change,Password Expiration Interval,Password Expiration Time,Password Minimum Length,Password Required,Password Unique Required,Print Job Configuration,Private Key,Profile,Public Key,Security Equals,Account Balance,Allow Unlimited Credit,Minimum Account Balance,Message Server,Language,UID,Locked By Intruder,Server Holds,Last Login Time,Type Creator Map,Higher Privileges,Printer Control,Security Flags,Profile Membership,Timezone" },
{ "Device",2,"2.16.840.1.113719.1.1.6.1.6","Top","Organization,Organizational Unit","CN","CN","Description,L,Network Address,OU,O,Owner,See Also,Serial Number" },
{ "Computer",2,"2.16.840.1.113719.1.1.6.1.4","Device",NULL,NULL,NULL,"Operator,Server,Status" },
{ "Printer",2,"2.16.840.1.113719.1.1.6.1.17","Device",NULL,NULL,NULL,"Cartridge,Printer Configuration,Default Queue,Host Device,Print Server,Memory,Network Address Restriction,Notify,Operator,Page Description Language,Queue,Status,Supported Typefaces" },
{ "Resource",0,"2.16.840.1.113719.1.1.6.1.21","TOp","Organization,Organizational Unit","CN","CN","Description,Host Resource Name,L,OU,O,See Also,Uses" },
{ "Queue",2,"2.16.840.1.113719.1.1.6.1.20","Resource",NULL,NULL,"Queue Directory","Device,Operator,Server,User,Network Address,Volume,Host Server" },
{ "Bindery Queue",2,"2.16.840.1.113719.1.1.6.1.3","Queue",NULL,"CN","Bindery Type",NULL },
{ "Volume",2,"2.16.840.1.113719.1.1.6.1.26","Resource",NULL,NULL,"Host Server","Status" },
{ "Directory Map",2,"2.16.840.1.113719.1.1.6.1.7","Resource",NULL,NULL,"Host Server","Path" },
{ "Profile",2,"2.16.840.1.113719.1.1.6.1.19","Top","Organization,Organizational Unit","CN","CN,Login Script","Description,L,OU,O,See Also,Full Name" },
{ "Server",0,"2.16.840.1.113719.1.1.6.1.22","Top","Organization,Organizational Unit","CN","CN","Description,Host Device,L,OU,O,Private Key,Public Key,Resource,See Also,Status,User,Version,Network Address,Account Balance,Allow Unlimited Credit,Minimum Account Balance,Full Name,Security Equals,Security Flags,Timezone" },
{ "NCP Server",2,"2.16.840.1.113719.1.1.6.1.10","Server",NULL,NULL,NULL,"Operator,Supported Services,Messaging Server,DS Revision,Permanent Config Parms" },
{ "Print Server",2,"2.16.840.1.113719.1.1.6.1.18","Server",NULL,NULL,NULL,"Operator,Printer,SAP Name" },
{ "CommExec",2,"2.16.840.1.113719.1.1.6.1.31","Server",NULL,NULL,NULL,"Network Address Restriction" },
{ "Bindery Object",2,"2.16.840.1.113719.1.1.6.1.2","Top","Organization,Organizational Unit","CN,Bindery Type","Bindery Object Restriction,Bindery Type,CN",NULL },
{ "Unknown",3,"2.16.840.1.113719.1.1.6.1.24","Top",NULL,NULL,NULL,NULL },
{ "Partition",0,"2.16.840.1.113719.1.1.6.1.15",NULL,NULL,NULL,NULL,"Convergence,Partition Creation Time,Replica,Inherited ACL,Low Convergence Sync Interval,Received Up To,Synchronized Up To,Authority Revocation,Certificate Revocation,CA Private Key,CA Public Key,Cross Certificate Pair,Low Convergence Reset Time,High Convergence Sync Interval,Partition Control,Replica Up To,Partition Status,Transitive Vector,Purge Vector,Synchronization Tolerance,Obituary Notify,Local Received Up To" },
{ "AFP Server",2,"2.16.840.1.113719.1.1.6.1.0","Server",NULL,NULL,NULL,"Serial Number,Supported Connections" },
{ "Messaging Server",2,"2.16.840.1.113719.1.1.6.1.27","Server",NULL,NULL,NULL,"Messaging Database Location,Message Routing Group,Postmaster,Supported Services,Messaging Server Type,Supported Gateway" },
{ "Message Routing Group",2,"2.16.840.1.113719.1.1.6.1.28","Group",NULL,NULL,NULL,NULL },
{ "External Entity",2,"2.16.840.1.113719.1.1.6.1.29","Top","Organization,Organizational Unit","CN,OU","CN","Description,See Also,Facsimile Telephone Number,L,EMail Address,OU,Physical Delivery Office Name,Postal Address,Postal Code,Postal Office Box,S,SA,Title,External Name,Mailbox Location,Mailbox ID" },
{ "List",2,"2.16.840.1.113719.1.1.6.1.30","Top","Organization,Organizational Unit","CN","CN","Description,L,Member,OU,O,EMail Address,Mailbox Location,Mailbox ID,Owner,See Also,Full Name" },
{ NULL,0,NULL,NULL,NULL,NULL,NULL,NULL }
};
#endif /* MDBP_H */
src/libs/mdb-odbc/Makefile.am
-20
View File
@@ -1,20 +0,0 @@
INCLUDES= \
$(ALL_CFLAGS) \
-I$(top_srcdir)/include \
-DLOCALSTATEDIR=\""$(localstatedir)"\" \
-DMDB_INTERNAL
LIBS= -lodbc
mdbdir=$(libdir)/bongomdb
mdb_LTLIBRARIES=libmdbodbc.la
libmdbodbc_la_SOURCES = \
mdbodbc.c \
mdbodbcp.h
libmdbodbc_la_LDFLAGS = -module -avoid-version
libmdbodbc_la_LIBADD = \
../bongoutil/libbongoutil.la \
../xpl/libbongoxpl.la
src/libs/mdb-odbc/mdbodbc.c
-4466
View File
File diff suppressed because it is too large Load Diff
src/libs/mdb-odbc/mdbodbcp.h
-956
View File
@@ -1,956 +0,0 @@
#ifndef MDBODBCP_H
#define MDBODBCP_H
#define MDB_ODBC_ROOT_ID -1
#define VALUE_ALLOC_SIZE 20
#define MDB_ODBC_NAME_SIZE 64
#define MDB_ODBC_PART_SIZE 255
typedef struct {
/* Semi-public; known to the main MDB library */
unsigned char Description[128];
struct _MDBInterfaceStruct *Interface;
/* Private */
signed long object;
SQLHDBC connection;
} MDBodbcContextStruct;
typedef MDBodbcContextStruct *MDBHandle;
typedef struct {
/* Public part, exposed to allow simpler code */
unsigned char **Value;
unsigned long Used;
unsigned long ErrNo;
struct _MDBInterfaceStruct *Interface;
/* Private part, not exposed in public header */
unsigned long Allocated;
MDBodbcContextStruct *handle;
signed long statementCount;
/*
The base pointer will be used whenever the Base DN ID is needed. This is
a pointer so that it can be set to the address of another value struct when
MDBShareContext() is used.
*/
struct {
SQLINTEGER *id;
SQLINTEGER value;
SQLINTEGER *class;
SQLINTEGER classValue;
BOOL *read;
BOOL readValue;
BOOL *write;
BOOL writeValue;
BOOL *delete;
BOOL deleteValue;
BOOL *rename;
BOOL renameValue;
} base;
struct {
unsigned char dn[255 + 1];
SQLINTEGER id;
SQLINTEGER class;
BOOL read;
BOOL write;
BOOL delete;
BOOL rename;
unsigned long time;
} cache;
struct {
SQLHSTMT asArray[0];
SQLHSTMT getTreeInfo;
SQLHSTMT setTreeInfo;
SQLHSTMT getRootRights;
SQLHSTMT getRightsProviders;
SQLHSTMT getRights;
SQLHSTMT setRights;
SQLHSTMT delRightsByProviderAndObject;
SQLHSTMT delRightsByProvider;
SQLHSTMT delRightsByObject;
SQLHSTMT delRightsByParent;
SQLHSTMT delRightsByChild;
SQLHSTMT getObjectID;
SQLHSTMT getAttrByName;
SQLHSTMT getClassByName;
SQLHSTMT getObjectAttrInfo;
SQLHSTMT getParentInfo;
SQLHSTMT getObjectClass;
SQLHSTMT getObjectClassName;
SQLHSTMT verifyContainment;
SQLHSTMT listContainment;
SQLHSTMT createObject;
SQLHSTMT createAttribute;
SQLHSTMT createClass;
SQLHSTMT createSuperClass;
SQLHSTMT deleteObjectValues;
SQLHSTMT deleteObjectRights;
SQLHSTMT deleteObject;
SQLHSTMT copySuperClass;
SQLHSTMT createContainment;
SQLHSTMT createMandatory;
SQLHSTMT getMandatoryByName;
SQLHSTMT createOptional;
SQLHSTMT createNaming;
SQLHSTMT copyContainment;
SQLHSTMT copyMandatory;
SQLHSTMT copyOptional;
SQLHSTMT copyNaming;
SQLHSTMT clearAttribute;
SQLHSTMT addDNValue;
SQLHSTMT addStringValue;
SQLHSTMT addBoolValue;
SQLHSTMT moveObject;
SQLHSTMT renameObject;
SQLHSTMT verifyPassword;
SQLHSTMT setPassword;
SQLHSTMT deleteAttr;
SQLHSTMT deleteAttrFromMandatory;
SQLHSTMT deleteAttrFromOptional;
SQLHSTMT deleteAttrFromNaming;
SQLHSTMT deleteAttrFromValues;
SQLHSTMT deleteAttrFromRights;
SQLHSTMT deleteClassFromContainment;
SQLHSTMT deleteClassFromMandatory;
SQLHSTMT deleteClassFromOptional;
SQLHSTMT deleteClassFromNaming;
SQLHSTMT deleteClass;
SQLHSTMT readValue;
SQLHSTMT getChildren;
SQLHSTMT getChildrenByClass;
SQLHSTMT getChildrenIDs;
SQLHSTMT hasChildren;
} stmts;
union {
struct {
SQLINTEGER read;
SQLINTEGER write;
SQLINTEGER delete;
SQLINTEGER rename;
} getRootRights;
struct {
SQLINTEGER trustee;
SQLINTEGER provider;
} getRightsProviders;
/* Used by getRights and setRights */
struct {
SQLINTEGER object;
SQLINTEGER trustee;
SQLINTEGER provider;
SQLINTEGER parent;
SQLINTEGER read;
SQLINTEGER write;
SQLINTEGER delete;
SQLINTEGER rename;
} setGetRights;
struct {
SQLINTEGER provider;
SQLINTEGER object;
} delRightsByProviderAndObject;
struct {
SQLINTEGER provider;
} delRightsByProvider;
struct {
SQLINTEGER object;
SQLINTEGER trustee;
} delRightsByObject;
struct {
SQLINTEGER trustee;
} delRightsByParent;
struct {
SQLINTEGER provider;
SQLINTEGER trustee;
} delRightsByChild;
struct {
unsigned char object[MDB_ODBC_NAME_SIZE + 1];
SQLINTEGER objectLength;
SQLINTEGER id;
SQLINTEGER class;
SQLINTEGER read;
SQLINTEGER write;
SQLINTEGER delete;
SQLINTEGER rename;
} getObjectID;
struct {
unsigned char attribute[MDB_ODBC_NAME_SIZE + 1];
SQLINTEGER attributeLength;
SQLINTEGER id;
} getAttrByName;
struct {
SQLINTEGER attribute;
} deleteAttr;
struct {
SQLINTEGER object;
unsigned char attribute[MDB_ODBC_NAME_SIZE + 1];
SQLINTEGER attributeLength;
SQLINTEGER id;
SQLINTEGER single;
SQLINTEGER type;
} getObjectAttrInfo;
struct {
SQLINTEGER object;
unsigned char name[MDB_ODBC_NAME_SIZE + 1];
} getParentInfo;
struct {
SQLINTEGER object;
SQLINTEGER class;
} getObjectClass;
struct {
SQLINTEGER object;
unsigned char class[MDB_ODBC_NAME_SIZE + 1];
} getObjectClassName;
struct {
SQLINTEGER object;
SQLINTEGER child;
} hasChildren;
struct {
SQLINTEGER object;
SQLINTEGER class;
} verifyContainment;
struct {
SQLINTEGER object;
unsigned char name[MDB_ODBC_NAME_SIZE + 1];
} listContainment;
struct {
unsigned char name[MDB_ODBC_NAME_SIZE + 1];
SQLINTEGER nameLength;
SQLINTEGER parent;
SQLINTEGER parentClass;
unsigned char class[MDB_ODBC_NAME_SIZE + 1];
SQLINTEGER classLength;
} createObject;
struct {
unsigned char name[MDB_ODBC_NAME_SIZE + 1];
SQLINTEGER nameLength;
SQLINTEGER type;
SQLINTEGER single;
SQLINTEGER public;
} createAttribute;
struct {
unsigned char name[MDB_ODBC_NAME_SIZE + 1];
SQLINTEGER nameLength;
SQLINTEGER container;
} createClass;
struct {
unsigned char name[MDB_ODBC_NAME_SIZE + 1];
SQLINTEGER nameLength;
SQLINTEGER class;
} getClassByName;
struct {
unsigned char name[MDB_ODBC_NAME_SIZE + 1];
SQLINTEGER nameLength;
SQLINTEGER class;
} createSuperClass;
struct {
unsigned char name[MDB_ODBC_NAME_SIZE + 1];
SQLINTEGER nameLength;
SQLINTEGER class;
} copySuperClass;
struct {
unsigned char name[MDB_ODBC_NAME_SIZE + 1];
SQLINTEGER nameLength;
SQLINTEGER class;
} createContainment;
struct {
unsigned char name[MDB_ODBC_NAME_SIZE + 1];
SQLINTEGER nameLength;
SQLINTEGER class;
} createMandatory;
struct {
unsigned char class[MDB_ODBC_NAME_SIZE + 1];
SQLINTEGER classLength;
} getMandatoryByName;
struct {
unsigned char name[MDB_ODBC_NAME_SIZE + 1];
SQLINTEGER nameLength;
SQLINTEGER class;
} createOptional;
struct {
unsigned char name[MDB_ODBC_NAME_SIZE + 1];
SQLINTEGER nameLength;
SQLINTEGER class;
} createNaming;
struct {
SQLINTEGER object;
} deleteObjectValues;
struct {
SQLINTEGER object;
} deleteObjectRights;
struct {
SQLINTEGER object;
} deleteObject;
struct {
SQLINTEGER class;
} copyContainment;
struct {
SQLINTEGER class;
} copyMandatory;
struct {
SQLINTEGER class;
} copyOptional;
struct {
SQLINTEGER class;
} copyNaming;
struct {
SQLINTEGER object;
SQLINTEGER attribute;
} clearAttribute;
struct {
SQLINTEGER owner;
SQLINTEGER attribute;
SQLINTEGER value;
} addDNValue;
struct {
SQLINTEGER owner;
SQLINTEGER attribute;
unsigned char value[MDB_ODBC_PART_SIZE + 1];
SQLINTEGER valueLength;
SQLINTEGER complete;
} addStringValue;
struct {
SQLINTEGER owner;
SQLINTEGER attribute;
SQLINTEGER value;
} addBoolValue;
struct {
SQLINTEGER object;
SQLINTEGER parent;
} moveObject;
struct {
SQLINTEGER object;
unsigned char name[MDB_ODBC_PART_SIZE + 1];
SQLINTEGER nameLength;
} renameObject;
struct {
SQLINTEGER object;
unsigned char pass[32 + 1];
SQLINTEGER passLength;
} verifyPassword;
struct {
SQLINTEGER object;
unsigned char pass[32 + 1];
SQLINTEGER passLength;
} setPassword;
struct {
SQLINTEGER attribute;
} deleteAttrFromMandatory;
struct {
SQLINTEGER attribute;
} deleteAttrFromOptional;
struct {
SQLINTEGER attribute;
} deleteAttrFromNaming;
struct {
SQLINTEGER attribute;
} deleteAttrFromValues;
struct {
SQLINTEGER attribute;
} deleteAttrFromRights;
struct {
SQLINTEGER class;
} deleteClassFromContainment;
struct {
SQLINTEGER class;
} deleteClassFromMandatory;
struct {
SQLINTEGER class;
} deleteClassFromOptional;
struct {
SQLINTEGER class;
} deleteClassFromNaming;
struct {
SQLINTEGER class;
} deleteClass;
struct {
SQLINTEGER object;
SQLINTEGER dn;
SQLINTEGER bool;
SQLINTEGER complete;
SQLINTEGER type;
unsigned char attribute[MDB_ODBC_NAME_SIZE + 1];
unsigned long attributeLength;
unsigned char value[MDB_ODBC_PART_SIZE + 1];
} readValue;
/* getChildren is also used by getChildrenByClass */
struct {
SQLINTEGER object;
SQLINTEGER container;
unsigned char class[MDB_ODBC_NAME_SIZE + 1];
unsigned long classLength;
unsigned char child[MDB_ODBC_NAME_SIZE + 1];
SQLINTEGER allContainers;
} getChildren;
struct {
SQLINTEGER object;
SQLINTEGER child;
} getChildrenIDs;
} params;
} MDBValueStruct;
typedef struct {
char *sql;
SQLHSTMT stmt;
/* This buffer should be large enough for any enum response */
unsigned char result[MDB_ODBC_PART_SIZE + 1];
/* Used for returning DN results where only the name changes from response to response */
unsigned char dn[MDB_ODBC_PART_SIZE + 1];
unsigned char class[MDB_ODBC_PART_SIZE + 1];
SQLINTEGER classlen;
unsigned char *name;
SQLINTEGER object;
/* These are all included as possible responses */
SQLINTEGER id;
SQLINTEGER bool;
SQLINTEGER complete;
SQLINTEGER type;
SQLINTEGER container;
SQLINTEGER allContainers;
/* This should be used if MDBReadEx() reads a value alrger than MDB_ODBC_PART_SIZE */
unsigned char *largeResult;
} MDBEnumStruct;
/*
Do as much static setup as can be done here. Some things, such as setting the
admin password, or creating the tree entry will have to be done seperately since
they are dynamic.
We attempt to create some of the tables twice. This is because mysql does not support
SERIAL. If we fail to create a table using SERIAL then we will try again with
INTEGER AUTO_INCREMENT UNIQUE, which as far as this driver is concerned is the same thing.
The last line creates the root object. It can not be created with the regular
creation statement for objects because it has no parent object.
*/
unsigned char *MDBodbcSQLPrepare[] = {
"CREATE TABLE treeinfo" \
"(" \
"name varchar(64)," \
"defaultContainer INTEGER" \
");",
"CREATE TABLE objects" \
"(" \
"id SERIAL," \
"name varchar(64)," \
"class INTEGER," \
"parent INTEGER," \
"pass char(32)" \
");",
"CREATE TABLE objects" \
"(" \
"id INTEGER AUTO_INCREMENT UNIQUE," \
"name varchar(64)," \
"class INTEGER," \
"parent INTEGER," \
"pass char(32)" \
");",
"CREATE TABLE classes" \
"(" \
"id SERIAL," \
"name varchar(64) UNIQUE," \
"container INTEGER" \
");",
"CREATE TABLE classes" \
"(" \
"id INTEGER AUTO_INCREMENT UNIQUE," \
"name varchar(64) UNIQUE," \
"container INTEGER" \
");",
"CREATE TABLE superclasses" \
"(" \
"subclass INTEGER," \
"superclass INTEGER" \
");",
"CREATE TABLE containment" \
"(" \
"container INTEGER," \
"leaf INTEGER" \
");",
"CREATE TABLE attributes" \
"(" \
"id SERIAL," \
"name varchar(64)," \
"type INTEGER," \
"single INTEGER," \
"public INTEGER" \
");",
"CREATE TABLE attributes" \
"(" \
"id INTEGER AUTO_INCREMENT UNIQUE," \
"name varchar(64)," \
"type INTEGER," \
"single INTEGER," \
"public INTEGER" \
");",
"CREATE TABLE mandatory" \
"(" \
"attribute INTEGER," \
"class INTEGER" \
");",
"CREATE TABLE optional" \
"(" \
"attribute INTEGER," \
"class INTEGER" \
");",
"CREATE TABLE naming" \
"(" \
"attribute INTEGER," \
"class INTEGER" \
");",
"CREATE TABLE data" \
"(" \
"id SERIAL," \
"object INTEGER," \
"attribute INTEGER," \
"value VARCHAR(255)" \
" DEFAULT ' '," \
"dnvalue INTEGER DEFAULT -1," \
"boolvalue INTEGER DEFAULT -1," \
"complete INTEGER DEFAULT -1" \
");",
"CREATE TABLE data" \
"(" \
"id INTEGER AUTO_INCREMENT UNIQUE," \
"object INTEGER," \
"attribute INTEGER," \
"value VARCHAR(255)" \
" DEFAULT ' '," \
"dnvalue INTEGER DEFAULT -1," \
"boolvalue INTEGER DEFAULT -1," \
"complete INTEGER DEFAULT -1" \
");",
"CREATE TABLE rights" \
"(" \
"object INTEGER DEFAULT -1," \
"trustee INTEGER DEFAULT -1," \
"provider INTEGER DEFAULT -1," \
"r INTEGER DEFAULT -1," \
"w INTEGER DEFAULT -1," \
"d INTEGER DEFAULT -1," \
"n INTEGER DEFAULT -1," \
"parent INTEGER DEFAULT 0" \
");",
"CREATE INDEX objects_index ON objects (id, parent, class, name);",
"CREATE INDEX classes_index ON classes (id, name);",
"CREATE INDEX superclasses_index ON superclasses (subclass);",
"CREATE INDEX containment_index ON containment (container, leaf);",
"CREATE INDEX attributes_index ON attributes (id, name);",
"CREATE INDEX mandatory_index ON mandatory (class);",
"CREATE INDEX optional_index ON optional (class);",
"CREATE INDEX naming_index ON naming (class);",
"CREATE INDEX values_index ON data (object, attribute);",
"CREATE INDEX rights_index ON rights (object, trustee);",
NULL
};
unsigned char *MDBodbcSQLCreateRoot[] = {
"DELETE FROM objects;",
"INSERT INTO objects (id, name, parent, class)" \
" SELECT -1, ?, -1, id FROM classes WHERE UCASE(name)=UCASE('Top');",
NULL
};
/*
Set the rights to be such that anything is allowed by anyone while the setup
is being run. This will be changed after setup is complete.
*/
unsigned char *MDBodbcSQLSetPrepareRights[] = {
"INSERT INTO objects (id, name, parent, class)" \
" VALUES (-1, ?, -1, -1);",
"INSERT INTO rights (object, trustee, r, w, d, n)" \
" VALUES(-1, -1, 1, 1, 1, 1);",
NULL
};
/*
Removes the temporary rights used during setup, and set the default rights
which are none. Also provide full rights to the root to the administrators
group, and to admin.
*/
unsigned char *MDBodbcSQLSetInitialRights[] = {
"DELETE FROM rights;",
"INSERT INTO rights (object) VALUES (-1);",
"INSERT INTO rights (object, provider, trustee, r, w, d, n)" \
" SELECT -1, objects.id, objects.id, 1, 1, 1, 1" \
" FROM objects WHERE UCASE(objects.name)=UCASE('Administrators') OR" \
" UCASE(objects.name)=UCASE('Admin');",
NULL
};
#define REMOVE_TABLES "DROP TABLE treeinfo; DROP TABLE objects;" \
"DROP TABLE classes;DROP TABLE superclasses; DROP TABLE containment;" \
"DROP TABLE attributes;DROP TABLE mandatory; DROP TABLE optional;" \
"DROP TABLE data;DROP TABLE rights; DROP TABLE naming;"
#define SQL_GET_TREE_INFO "SELECT name, defaultContainer FROM treeinfo LIMIT 1;"
#define SQL_SET_TREE_INFO "INSERT INTO treeinfo (name, defaultContainer) VALUES (?, ?);"
#define SQL_GET_ROOT_RIGHTS "SELECT r, w, d, n FROM rights WHERE trustee=? AND object=-1;"
#define SQL_DEL_RIGHTS_BY_PROVIDER_AND_OBJ "DELETE FROM rights WHERE provider=? AND object=?;"
#define SQL_DEL_RIGHTS_BY_OBJECT "DELETE FROM rights WHERE object=? AND trustee=?;"
#define SQL_GET_RIGHTS_PROVIDERS "SELECT provider FROM rights WHERE trustee=? AND parent=1;"
#define SQL_DEL_RIGHTS_BY_CHILD "DELETE FROM rights WHERE provider=? AND trustee=? AND parent=1;"
#define SQL_DEL_RIGHTS_BY_PROVIDER "DELETE FROM rights WHERE provider=? AND provider!=trustee;"
#define SQL_SET_RIGHTS "INSERT INTO rights (object, trustee, provider, parent, r, w, d, n) VALUES (?, ?, ?, ?, ?, ?, ?, ?);"
#define SQL_GET_RIGHTS "SELECT provider, object, r, w, d, n FROM rights WHERE trustee=?;"
#define SQL_GET_OBJECT_ID "SELECT objects.id, objects.class, rights.r, rights.w, rights.d, rights.n FROM objects, rights" \
" WHERE UCASE(objects.name)=UCASE(?) AND objects.parent=? AND" \
" ((rights.object=objects.id AND rights.trustee=?) OR (rights.object=-1 AND rights.trustee=-1))"\
" ORDER BY rights.trustee DESC LIMIT 1;"
#define SQL_GET_ATTRIBUTE_BY_NAME "SELECT id FROM attributes WHERE UCASE(name)=UCASE(?);"
#define SQL_GET_CLASS_BY_NAME "SELECT id FROM classes WHERE UCASE(name)=UCASE(?);"
#define SQL_GET_CHILDREN "SELECT objects.name, classes.container FROM objects, classes WHERE objects.parent=? AND objects.id>0 AND objects.class=classes.id;"
#define SQL_GET_CHILDREN_BY_CLASS "SELECT objects.name, classes.container FROM objects, classes WHERE objects.parent=? AND objects.id>0 AND objects.class=classes.id" \
" AND (UCASE(classes.name)=UCASE(?) OR classes.container=?);"
#define SQL_HAS_CHILDREN "SELECT id FROM objects WHERE parent=? LIMIT 1;"
#define SQL_GET_CHILDREN_IDS "SELECT id FROM objects WHERE parent=? AND id > 0;"
/*
This really nasty bit of SQL will create an object with the specified name, and
specified class in the specified parent container, if that class is allowed in
that container class.
*/
#define SQL_CREATE_OBJECT \
"INSERT INTO objects (name, parent, class)" \
" SELECT ?, ?, classes.id FROM classes, containment" \
" WHERE UCASE(classes.name)=UCASE(?)" \
" AND classes.id=containment.leaf" \
" AND containment.container=?" \
" LIMIT 1;"
#define SQL_RENAME_OBJECT "UPDATE objects SET name=? WHERE id=?;"
#define SQL_MOVE_OBJECT "UPDATE objects SET parent=? WHERE id=?;"
#define SQL_VERIFY_CONTAINMENT "SELECT containment.leaf FROM containment, objects WHERE objects.id=? AND objects.class=containment.container AND containment.leaf=?;"
#define SQL_LIST_CONTAINMENT "SELECT classes.name FROM classes, containment, objects WHERE containment.leaf=classes.id AND containment.container=objects.class AND objects.id=?;"
#define SQL_CREATE_ATTRIBUTE "INSERT INTO attributes (name, type, single, public) VALUES (?, ?, ?, ?);"
#define SQL_CREATE_CLASS "INSERT INTO classes (name, container) VALUES (?, ?);"
#define SQL_CREATE_SUPERCLASS "INSERT INTO superclasses (subclass, superclass) SELECT ?, id FROM classes where UCASE(name)=UCASE(?);"
#define SQL_CREATE_CONTAINMENT "INSERT INTO containment (leaf, container) SELECT ?, id FROM classes where UCASE(name)=UCASE(?);"
#define SQL_CREATE_MANDATORY "INSERT INTO mandatory (class, attribute) SELECT ?, id FROM attributes where UCASE(name)=UCASE(?);"
#define SQL_CREATE_OPTIONAL "INSERT INTO optional (class, attribute) SELECT ?, id FROM attributes where UCASE(name)=UCASE(?);"
#define SQL_CREATE_NAMING "INSERT INTO naming (class, attribute) SELECT ?, id FROM attributes where UCASE(name)=UCASE(?);"
#define SQL_GET_OBJECT_CLASS "SELECT class FROM objects WHERE id=?;"
#define SQL_GET_OBJECT_CLASSNAME "SELECT classes.name FROM classes, objects WHERE objects.id=? AND objects.class=classes.id;"
#define SQL_GET_NAMING "SELECT attributes.name FROM attributes, naming WHERE attributes.id=naming.attribute and naming.class=?;"
#define SQL_GET_MANDATORY "SELECT attributes.name FROM attributes, mandatory WHERE attributes.id=mandatory.attribute and mandatory.class=?;"
#define SQL_GET_MANDATORY_BY_NAME "SELECT attributes.name FROM attributes, classes, mandatory WHERE" \
" mandatory.attribute=attributes.id AND mandatory.class=classes.id" \
" and UCASE(classes.name)=UCASE(?);"
#define SQL_GET_PARENT_INFO "SELECT parent, name FROM objects WHERE id=?;"
/* If the specified attribute can be written to the specified object then a single row will be returned, with the attribute ID and a BOOL specifiying single or multi value */
#define SQL_GET_OBJECT_ATTR_INFO "SELECT attributes.id, attributes.single, attributes.type FROM attributes, objects, optional WHERE objects.id=? AND objects.class=optional.class AND UCASE(attributes.name)=UCASE(?) AND attributes.id=optional.attribute LIMIT 1;"
#define SQL_ADD_DN_VALUE "INSERT INTO data (object, attribute, dnvalue) VALUES (?, ?, ?);"
#define SQL_REMOVE_DN_VALUE "DELETE FROM data WHERE object=? AND attribute=? AND dnvalue=?;"
#define SQL_ADD_BOOL_VALUE "INSERT INTO data (object, attribute, boolvalue) VALUES (?, ?, ?);"
#define SQL_REMOVE_BOOL_VALUE "DELETE FROM data WHERE object=? AND attribute=? AND boolvalue=?;"
#define SQL_ADD_STRING_VALUE "INSERT INTO data (object, attribute, value, complete) VALUES (?, ?, ?, ?);"
#define SQL_REMOVE_STRING_VALUE "DELETE FROM data WHERE object=? AND attribute=? AND value=?;"
#define SQL_READ_VALUE "SELECT data.value, data.dnvalue, data.boolvalue, data.complete, attributes.type FROM data, attributes WHERE data.object=? AND data.attribute=attributes.id AND UCASE(attributes.name)=UCASE(?) ORDER BY data.id;"
/* Copy data from all superclasses to a new class */
#define SQL_COPY_SUPERCLASSES "INSERT INTO superclasses (subclass, superclass) SELECT ?, superclasses.superclass FROM superclasses, classes WHERE superclasses.subclass=classes.id AND UCASE(classes.name)=UCASE(?);"
#define SQL_COPY_CONTAINMENT "INSERT INTO containment (container, leaf) SELECT containment.container, superclasses.subclass FROM containment, superclasses WHERE containment.leaf=superclasses.superclass and superclasses.subclass=?;"
#define SQL_COPY_MANDATORY "INSERT INTO mandatory (attribute, class) SELECT mandatory.attribute, superclasses.subclass FROM mandatory, superclasses WHERE mandatory.class=superclasses.superclass and superclasses.subclass=?;"
#define SQL_COPY_OPTIONAL "INSERT INTO optional (attribute, class) SELECT optional.attribute, superclasses.subclass FROM optional, superclasses WHERE optional.class=superclasses.superclass and superclasses.subclass=?;"
#define SQL_COPY_NAMING "INSERT INTO naming (attribute, class) SELECT naming.attribute, superclasses.subclass FROM naming, superclasses WHERE naming.class=superclasses.superclass and superclasses.subclass=?;"
#define SQL_CLEAR_ATTRIBUTE "DELETE FROM data WHERE object=? AND attribute=?;"
/* Delete an object */
#define SQL_DELETE_OBJECT_VALUES "DELETE FROM data WHERE object=?;"
#define SQL_DELETE_OBJECT_RIGHTS "DELETE FROM rights WHERE provider=?;"
#define SQL_DELETE_OBJECT "DELETE FROM objects WHERE id=?;"
/* Delete an attribute */
#define SQL_DELETE_ATTRIBUTE "DELETE FROM attributes WHERE id=?;"
#define SQL_MANDATORY_DELETE_ATTR "DELETE FROM mandatory WHERE attribute=?;"
#define SQL_OPTIONAL_DELETE_ATTR "DELETE FROM optional WHERE attribute=?;"
#define SQL_NAMING_DELETE_ATTR "DELETE FROM naming WHERE attribute=?;"
#define SQL_VALUES_DELETE_ATTR "DELETE FROM data WHERE attribute=?;"
/* Delete a class */
#define SQL_GET_SUBCLASSES "SELECT subclass FROM superclasses WHERE superclass=?;"
#define SQL_GET_OBJECTS_BY_CLASS "SELECT id FROM objects WHERE class=?;"
#define SQL_CONTAINMENT_DEL_CLASS "DELETE FROM containment WHERE container=? OR leaf=?;"
#define SQL_MANDATORY_DEL_CLASS "DELETE FROM mandatory WHERE class=?;"
#define SQL_OPTIONAL_DEL_CLASS "DELETE FROM optional WHERE class=?;"
#define SQL_NAMING_DEL_CLASS "DELETE FROM naming WHERE class=?;"
#define SQL_DELETE_CLASS "DELETE FROM classes WHERE id=?;"
#define SQL_VERIFY_PASSWORD "SELECT id FROM objects WHERE id=? AND pass=?;"
#define SQL_SET_PASSWORD "UPDATE objects SET pass=? WHERE id=?;"
/*
We need mdb.h for the types used below, but we have to make sure it is included after
we have defined our own ValueStruct, EnumStruct and Handle types.
*/
#include <mdb.h>
typedef struct _MDBodbcBaseSchemaAttributes {
unsigned char *name;
unsigned long flags;
unsigned long type;
} MDBodbcBaseSchemaAttributes;
MDBodbcBaseSchemaAttributes MDBodbcBaseSchemaAttributesList[] = {
{ "Aliased Object Name", 69, MDB_ATTR_SYN_DIST_NAME },
{ "Back Link", 268, MDB_ATTR_SYN_DIST_NAME },
{ "CA Private Key", 93, MDB_ATTR_SYN_BINARY },
{ "CA Public Key", 205, MDB_ATTR_SYN_BINARY },
{ "CN", 102, MDB_ATTR_SYN_STRING },
{ "C", 103, MDB_ATTR_SYN_STRING },
{ "Description", 102, MDB_ATTR_SYN_STRING },
{ "Facsimile Telephone Number", 68, MDB_ATTR_SYN_STRING },
{ "Group Membership", 580, MDB_ATTR_SYN_DIST_NAME },
{ "L", 102, MDB_ATTR_SYN_STRING },
{ "Login Disabled", 69, MDB_ATTR_SYN_BOOL },
{ "Member", 68, MDB_ATTR_SYN_DIST_NAME },
{ "EMail Address", 228, MDB_ATTR_SYN_STRING },
{ "Internet EMail Address", 228, MDB_ATTR_SYN_STRING },
{ "departmentNumber", 228, MDB_ATTR_SYN_STRING },
{ "Notify", 68, MDB_ATTR_SYN_DIST_NAME },
{ "Operator", 324, MDB_ATTR_SYN_DIST_NAME },
{ "OU", 102, MDB_ATTR_SYN_STRING },
{ "O", 102, MDB_ATTR_SYN_STRING },
{ "Owner", 68, MDB_ATTR_SYN_DIST_NAME },
{ "Page Description Language", 102, MDB_ATTR_SYN_STRING },
{ "Path", 68, MDB_ATTR_SYN_STRING },
{ "Physical Delivery Office Name", 102, MDB_ATTR_SYN_STRING },
{ "Postal Address", 68, MDB_ATTR_SYN_STRING },
{ "Postal Code", 102, MDB_ATTR_SYN_STRING },
{ "Postal Office Box", 102, MDB_ATTR_SYN_STRING },
{ "Private Key", 93, MDB_ATTR_SYN_BINARY },
{ "Profile", 69, MDB_ATTR_SYN_DIST_NAME },
{ "Public Key", 205, MDB_ATTR_SYN_BINARY },
{ "Reference", 1052, MDB_ATTR_SYN_DIST_NAME },
{ "Resource", 68, MDB_ATTR_SYN_DIST_NAME },
{ "Role Occupant", 68, MDB_ATTR_SYN_DIST_NAME },
{ "Higher Privileges", 836, MDB_ATTR_SYN_DIST_NAME },
{ "Security Equals", 836, MDB_ATTR_SYN_DIST_NAME },
{ "See Also", 68, MDB_ATTR_SYN_DIST_NAME },
{ "Serial Number", 102, MDB_ATTR_SYN_STRING },
{ "Server", 324, MDB_ATTR_SYN_DIST_NAME },
{ "S", 102, MDB_ATTR_SYN_STRING },
{ "Status", 197, MDB_ATTR_SYN_STRING },
{ "SA", 102, MDB_ATTR_SYN_STRING },
{ "Surname", 230, MDB_ATTR_SYN_STRING },
{ "Telephone Number", 100, MDB_ATTR_SYN_STRING },
{ "Title", 102, MDB_ATTR_SYN_STRING },
{ "Unknown", 4, MDB_ATTR_SYN_STRING },
{ "User", 324, MDB_ATTR_SYN_DIST_NAME },
{ "Version", 231, MDB_ATTR_SYN_STRING },
{ "Device", 68, MDB_ATTR_SYN_DIST_NAME },
{ "Language", 69, MDB_ATTR_SYN_STRING },
{ "UID", 69, MDB_ATTR_SYN_STRING },
{ "GID", 69, MDB_ATTR_SYN_STRING },
{ "Unknown Base Class", 39, MDB_ATTR_SYN_STRING },
{ "Authority Revocation", 77, MDB_ATTR_SYN_BINARY },
{ "Certificate Revocation", 77, MDB_ATTR_SYN_BINARY },
{ "Cross Certificate Pair", 68, MDB_ATTR_SYN_BINARY },
{ "Full Name", 102, MDB_ATTR_SYN_STRING },
{ "Certificate Validity Interval", 71, MDB_ATTR_SYN_STRING },
{ "External Synchronizer", 68, MDB_ATTR_SYN_BINARY },
{ "Message Routing Group", 68, MDB_ATTR_SYN_DIST_NAME },
{ "Postmaster", 68, MDB_ATTR_SYN_DIST_NAME },
{ "Mailbox Location", 197, MDB_ATTR_SYN_DIST_NAME },
{ "Mailbox ID", 231, MDB_ATTR_SYN_STRING },
{ "External Name", 69, MDB_ATTR_SYN_BINARY },
{ "Security Flags", 69, MDB_ATTR_SYN_STRING },
{ "Last Referenced Time", 1029, MDB_ATTR_SYN_STRING },
{ "Given Name", 230, MDB_ATTR_SYN_STRING },
{ "Initials", 230, MDB_ATTR_SYN_STRING },
{ "Generational Qualifier", 231, MDB_ATTR_SYN_STRING },
{ "Profile Membership", 580, MDB_ATTR_SYN_DIST_NAME },
{ "Equivalent To Me", 324, MDB_ATTR_SYN_DIST_NAME },
{ "Timezone", 133, MDB_ATTR_SYN_BINARY },
{ "T", 102, MDB_ATTR_SYN_STRING },
{ "Used By", 332, MDB_ATTR_SYN_STRING },
{ "Uses", 332, MDB_ATTR_SYN_STRING },
{ "GUID", 207, MDB_ATTR_SYN_BINARY },
{ "Other GUID", 198, MDB_ATTR_SYN_BINARY },
{ NULL, 0, 0 }
};
typedef struct _MDBodbcBaseSchemaClasses {
unsigned char *name;
unsigned long flags;
unsigned char *superClass;
unsigned char *containedBy;
unsigned char *namedBy;
unsigned char *mandatory;
unsigned char *optional;
} MDBodbcBaseSchemaClasses;
MDBodbcBaseSchemaClasses MDBodbcBaseSchemaClassesList[] = {
{ "[Nothing]", 3, NULL, NULL, NULL, NULL, NULL },
{ "Top", 3, NULL, NULL, "T", NULL, "CA Public Key,Private Key,Certificate Validity Interval,Authority Revocation,Last Referenced Time,Equivalent To Me,Back Link,Reference,Cross Certificate Pair,Certificate Revocation,Used By,GUID,Other GUID" },
{ "Alias", 2, "Top", NULL, NULL, "Aliased Object Name", NULL },
{ "Country", 3, "Top", "Top,Tree Root,[Nothing]", "C", "C", "Description" },
{ "Organization", 3, NULL, "Top,Tree Root,Country,Locality,[Nothing]", "O", "O","Description,Facsimile Telephone Number,L,EMail Address,Physical Delivery Office Name,Postal Address,Postal Code,Postal Office Box,See Also,S,SA,Telephone Number" },
{ "Organizational Unit", 3, NULL, "Locality,Organization,Organizational Unit", "OU", "OU","Description,Facsimile Telephone Number,L,EMail Address,Physical Delivery Office Name,Postal Address,Postal Code,Postal Office Box,See Also,S,SA,Telephone Number" },
{ "Locality", 3, "Top", "Locality,Country,Organizational Unit,Organization", "L,S", NULL,"Description,L,See Also,S,SA" },
{ "Organizational Role", 2, "Top", "Organization,Organizational Unit", "CN", "CN", "Description,Facsimile Telephone Number,L,EMail Address,OU,Physical Delivery Office Name,Postal Address,Postal Code,Postal Office Box,Role Occupant,See Also,S,SA,Telephone Number,Mailbox Location,Mailbox ID" },
{ "Group", 2, "Top", "Organization,Organizational Unit", "CN", "CN", "Description,L,Member,OU,O,Owner,See Also,GID,Full Name,EMail Address,Mailbox Location,Mailbox ID,Profile,Profile Membership" },
{ "Person", 2, NULL, "Organization,Organizational Unit", "CN", "CN", "Description,See Also,Telephone Number,Full Name,Given Name,Initials,Generational Qualifier" },
{ "Organizational Person", 2, "Person", NULL, "OU", NULL, "Facsimile Telephone Number,L,EMail Address,OU,Physical Delivery Office Name,Postal Address,Postal Code,Postal Office Box,S,SA,Title,Mailbox Location,Mailbox ID" },
{ "User", 2, "Organizational Person", NULL, NULL, NULL, "Group Membership,Login Disabled,Private Key,Profile,Public Key,Security Equals,Minimum Message Server,Language,UID,Type Creator Map,Higher Privileges,Security Flags,Profile Membership,Timezone,Surname,Internet EMail Address,departmentNumber" },
{ "Device", 2, "Top", "Organization,Organizational Unit", "CN", "CN", "Description,L,OU,O,Owner,See Also,Serial Number" },
{ "Computer", 2, "Device", NULL, NULL, NULL, "Operator,Server,Status" },
{ "Resource", 0, "Top", "Organization,Organizational Unit", "CN", "CN", "Description,L,OU,O,See Also,Uses" },
{ "Profile", 2, "Top", "Organization,Organizational Unit", "CN", "CN", "Description,L,OU,O,See Also,Full Name" },
{ "Server", 0, "Top", "Organization,Organizational Unit", "CN", "CN", "Description,L,OU,O,Private Key,Public Key,Resource,See Also,Status,User,Version,Full Name,Security Equals,Security Flags,Timezone" },
{ "NCP Server", 2, "Server", NULL, NULL, NULL, "Operator" },
{ NULL, 0, NULL, NULL, NULL, NULL, NULL }
};
#define ERR_NO_SUCH_ENTRY 0xFFFFFDA7
#define ERR_NO_SUCH_VALUE 0xFFFFFDA6
#define ERR_NO_SUCH_ATTRIBUTE 0xFFFFFDA5
#define ERR_NO_SUCH_CLASS 0xFFFFFDA4
#define ERR_NO_SUCH_PARTITION 0xFFFFFDA3
#define ERR_ENTRY_ALREADY_EXISTS 0xFFFFFDA2
#define ERR_NOT_EFFECTIVE_CLASS 0xFFFFFDA1
#define ERR_ILLEGAL_ATTRIBUTE 0xFFFFFDA0
#define ERR_MISSING_MANDATORY 0xFFFFFD9F
#define ERR_ILLEGAL_DS_NAME 0xFFFFFD9E
#define ERR_ILLEGAL_CONTAINMENT 0xFFFFFD9D
#define ERR_CANT_HAVE_MULTIPLE_VALUES 0xFFFFFD9C
#define ERR_SYNTAX_VIOLATION 0xFFFFFD9B
#define ERR_DUPLICATE_VALUE 0xFFFFFD9A
#define ERR_ATTRIBUTE_ALREADY_EXISTS 0xFFFFFD99
#define ERR_MAXIMUM_ENTRIES_EXIST 0xFFFFFD98
#define ERR_DATABASE_FORMAT 0xFFFFFD97
#define ERR_INCONSISTENT_DATABASE 0xFFFFFD96
#define ERR_INVALID_COMPARISON 0xFFFFFD95
#define ERR_COMPARISON_FAILED 0xFFFFFD94
#define ERR_TRANSACTIONS_DISABLED 0xFFFFFD93
#define ERR_INVALID_TRANSPORT 0xFFFFFD92
#define ERR_SYNTAX_INVALID_IN_NAME 0xFFFFFD91
#define ERR_TRANSPORT_FAILURE 0xFFFFFD8F
#define ERR_ALL_REFERRALS_FAILED 0xFFFFFD8E
#define ERR_CANT_REMOVE_NAMING_VALUE 0xFFFFFD8D
#define ERR_OBJECT_CLASS_VIOLATION 0xFFFFFD8C
#define ERR_ENTRY_IS_NOT_LEAF 0xFFFFFD8B
#define ERR_DIFFERENT_TREE 0xFFFFFD8A
#define ERR_SYSTEM_FAILURE 0xFFFFFD88
#define ERR_INVALID_ENTRY_FOR_ROOT 0xFFFFFD87
#define ERR_NO_REFERRALS 0xFFFFFD86
#define ERR_REMOTE_FAILURE 0xFFFFFD85
#define ERR_UNREACHABLE_SERVER 0XFFFFFD84
#define ERR_NO_CHARACTER_MAPPING 0XFFFFFD82
#define ERR_INCOMPLETE_AUTHENTICATION 0XFFFFFD81
#define ERR_INVALID_CERTIFICATE 0xFFFFFD80
#define ERR_INVALID_REQUEST 0xFFFFFD7F
#define ERR_INVALID_ITERATION 0xFFFFFD7E
#define ERR_SCHEMA_IS_NONREMOVABLE 0xFFFFFD7D
#define ERR_SCHEMA_IS_IN_USE 0xFFFFFD7C
#define ERR_CLASS_ALREADY_EXISTS 0xFFFFFD7B
#define ERR_BAD_NAMING_ATTRIBUTES 0xFFFFFD7A
#define ERR_INSUFFICIENT_STACK 0xFFFFFD78
#define ERR_INSUFFICIENT_BUFFER 0xFFFFFD77
#define ERR_AMBIGUOUS_CONTAINMENT 0xFFFFFD76
#define ERR_AMBIGUOUS_NAMING 0xFFFFFD75
#define ERR_DUPLICATE_MANDATORY 0xFFFFFD74
#define ERR_DUPLICATE_OPTIONAL 0xFFFFFD73
#define ERR_RECORD_IN_USE 0xFFFFFD6C
#define ERR_ENTRY_NOT_CONTAINER 0xFFFFFD64
#define ERR_FAILED_AUTHENTICATION 0xFFFFFD63
#define ERR_INVALID_CONTEXT 0xFFFFFD62
#define ERR_NO_SUCH_PARENT 0xFFFFFD61
#define ERR_NO_ACCESS 0xFFFFFD60
#define ERR_INVALID_NAME_SERVICE 0xFFFFFD5E
#define ERR_INVALID_TASK 0xFFFFFD5D
#define ERR_INVALID_CONN_HANDLE 0xFFFFFD5C
#define ERR_INVALID_IDENTITY 0xFFFFFD5B
#define ERR_DUPLICATE_ACL 0xFFFFFD5A
#define ERR_ALIAS_OF_AN_ALIAS 0xFFFFFD57
#define ERR_INVALID_RDN 0xFFFFFD4E
#define ERR_INCORRECT_BASE_CLASS 0xFFFFFD4C
#define ERR_MISSING_REFERENCE 0xFFFFFD4B
#define ERR_LOST_ENTRY 0xFFFFFD4A
#define ERR_FATAL 0xFFFFFD45
#endif /* MDBODBCP_H */
src/libs/mdb-xldap/Bongo.rules
-33
View File
@@ -1,33 +0,0 @@
# -*- Makefile -*-
if HAVE_LDAP
mdb_LTLIBRARIES += libmdbldap.la
endif
libmdbldap_la_SOURCES = \
src/libs/mdb-xldap/valarray.c \
src/libs/mdb-xldap/schema.c \
src/libs/mdb-xldap/mdbldap.c \
src/libs/mdb-xldap/mdbldapp.h
libmdbldap_la_CPPFLAGS = $(AM_CPPFLAGS) \
-DLOCALSTATEDIR=\""$(localstatedir)"\" \
-DMDB_INTERNAL
libmdbldap_la_LDFLAGS = -module -avoid-version
libmdbldap_la_LIBADD = \
$(LDAP_LIBS) \
libbongoutil.la \
libbongoxpl.la \
libbongomemmgr.la \
libbongostreamio.la \
$(top_builddir)/import/log4c/log4c/libbongolog4c.la
if HAVE_LDAP
src/libs/mdb-xldap/all: libmdbldap.la
src/libs/mdb-xldap/install:
@cd $(top_builddir) && $(MAKE) $(MFLAGS) mdb_LTLIBRARIES=libmdbldap.la install-mdbLTLIBRARIES
else
src/libs/mdb-xldap/all:
src/libs/mdb-xldap/install:
endif
src/libs/mdb-xldap/clean: clean
src/libs/mdb-xldap/Makefile.am
-17
View File
@@ -1,17 +0,0 @@
# -*- Makefile -*-
#
# Do not edit!
#
# (unless this is Makefile.am.subdir)
#
# This file is a copy of the toplevel Makefile.am.subdir. If changes
# need to be made, edit that file, and make update-makefiles, and
# check the new files in.
#
# This is a skeletal automake file. The real automake fules for
# building the targets for this directory can be found in the
# Bongo.rules file. This file is simply here so that 'make all' can
# work in each subdirectory.
all clean install:
@cd $(top_builddir) && $(MAKE) $(MFLAGS) $(subdir)/$@
src/libs/mdb-xldap/mdbldap.c
-4009
View File
File diff suppressed because it is too large Load Diff
src/libs/mdb-xldap/mdbldapp.h
-146
View File
@@ -1,146 +0,0 @@
#define LDAP_DEPRECATED 1
#include <ldap.h>
#include <config.h>
#include <xpl.h>
/* compatibility with different client libraries */
#ifndef LDAP_CONST
#define LDAP_CONST const
#endif
#ifndef LDAP_OPT_SUCCESS
#define LDAP_OPT_SUCCESS 0
#endif
#ifndef LDAP_EXOP_MODIFY_PASSWD
#define LDAP_EXOP_MODIFY_PASSWD "1.3.6.1.4.1.4203.1.11.1"
#endif
#ifndef LDAP_TAG_EXOP_MODIFY_PASSWD_ID
#define LDAP_TAG_EXOP_MODIFY_PASSWD_ID ((ber_tag_t) 0x80U)
#endif
#ifndef LDAP_TAG_EXOP_MODIFY_PASSWD_OLD
#define LDAP_TAG_EXOP_MODIFY_PASSWD_OLD ((ber_tag_t) 0x81U)
#endif
#ifndef LDAP_TAG_EXOP_MODIFY_PASSWD_NEW
#define LDAP_TAG_EXOP_MODIFY_PASSWD_NEW ((ber_tag_t) 0x82U)
#endif
#ifndef LBER_USE_DER
#define LBER_USE_DER 0x01
#endif
#define MDBLDAP_FLAGS_ALLOCATED_HANDLE (unsigned long)(1 << 0)
#define MDBLDAP_FLAGS_CONTEXT_VALID (unsigned long)(1 << 1)
#define MDBLDAP_FLAGS_CONTEXT_DUPLICATE (unsigned long)(1 << 2)
#define MDBLDAP_FLAGS_BASEDB_CHANGED (unsigned long)(1 << 3)
#define MDBLDAP_MIN_CONNECTIONS 4
#define MDBLDAP_MAX_CONNECTIONS 8
#define MDBLDAP_DEFAULT_CACHE_SIZE 512
#define VALUE_ALLOC_SIZE 20
typedef struct {
unsigned char Description[128];
struct _MDBInterfaceStruct *Interface;
char *binddn;
char *passwd;
struct {
int next;
int min;
int max;
XplMutex mutex;
LDAP **list;
} conn;
} MDBLDAPContextStruct;
typedef MDBLDAPContextStruct *MDBHandle;
typedef struct {
unsigned char **Value;
unsigned long Used;
unsigned long ErrNo;
struct _MDBInterfaceStruct *Interface;
MDBLDAPContextStruct *context;
LDAP *ldap;
unsigned char *base;
unsigned char *lastDn;
unsigned long allocated;
BOOL duplicate;
} MDBValueStruct;
typedef struct {
char **vals;
int next;
int count;
} MDBEnumStruct;
#ifndef MDB_INTERNAL
#define MDB_INTERNAL
#endif
#include <mdb.h>
/* schema.c */
typedef struct {
char *val;
char *oid;
char **names;
int namecnt;
char *desc;
char *equality;
char *syntax;
char *sup;
BOOL singleval;
int refcnt;
BOOL visited;
} MDBLDAPSchemaAttr;
typedef enum {
TYPE_ABSTRACT,
TYPE_AUXILIARY,
TYPE_STRUCTURAL
} ClassTypeEnum;
typedef struct {
char *val;
char *oid;
char **names;
char *desc;
char **sup;
char **must;
char **may;
char *naming;
ClassTypeEnum type;
int refcnt;
BOOL visited;
} MDBLDAPSchemaClass;
#define MDBLDAP_SYNTAX_DN(syntax) \
!strncmp((syntax), "1.3.6.1.4.1.1466.115.121.1.12", 29)
#define MDBLDAP_SYNTAX_STRING(syntax) \
!strncmp((syntax), "1.3.6.1.4.1.1466.115.121.1.15", 29)
BOOL ParseAttributeTypeDescription(char *ptr, MDBLDAPSchemaAttr *attr);
BOOL ParseObjectClassDescription(char *ptr, MDBLDAPSchemaClass *class);
/* valarray.c */
typedef char * (* TranslateFunction) (const char *val, const char *opt);
inline char **NewValArray(int size);
inline void FreeValArray(char **vals);
inline int CountValArray(char **vals);
inline char **CopyValArray(char **vals);
inline BOOL ExpandValArray(char ***vals, int size);
inline unsigned int ValueStructToValArray(MDBValueStruct *v, char **vals);
inline int ValArrayToValueStruct(char **vals, MDBValueStruct *v);
inline char **TranslateValArray(char **in, TranslateFunction transfunc, char *opt);
inline unsigned int TranslateValueStructToValArray(MDBValueStruct *v, char **vals, TranslateFunction transfunc, char *opt);
inline int TranslateValArrayToValueStruct(char **vals, MDBValueStruct *v, TranslateFunction transfunc, char *opt);
BOOL MDBLDAPAddValue(const unsigned char *Value, MDBValueStruct *V);
BOOL MDBLDAPFreeValues(MDBValueStruct * V);
EXPORT BOOL MDBLDAPInit(MDBDriverInitStruct *Init);
EXPORT void MDBLDAPShutdown(void);
src/libs/mdb-xldap/schema.c
-286
View File
@@ -1,286 +0,0 @@
#include <string.h>
#include "mdbldapp.h"
#define CHARS_WHITESPACE " \t\n\f\r"
#define CHARS_DIGIT "0123456789"
#define CHARS_ALPHA_UPPER "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
#define CHARS_ALPHA_LOWER "abcdefghijklmnopqrstuvwxyz"
#define CHARS_ALPHA CHARS_ALPHA_UPPER CHARS_ALPHA_LOWER
#define CHARS_ALPHANUM CHARS_DIGIT CHARS_ALPHA
#define CHARS_WORD "_" CHARS_ALPHANUM
#define CHARS_WHSP CHARS_WHITESPACE
#define CHARS_OID "-." CHARS_WORD
/**
* Find the first character not among the characters in 'except'.
*/
static char *strnot(const char *string, const char *except) {
char *s = (char *) string;
char *e = (char *) except;
while (*s != '\0') {
while (*e != '\0') {
if (*s == *e) {
s++;
break;
}
e++;
}
if (*e == '\0') {
break;
}
e = (char *) except;
}
return s;
}
/**
* Return true if c is among the characters in 'accept'.
*/
static int charin(int c, const char *accept) {
char *a = (char *) accept;
while (*a != '\0') {
if (c == *a) {
return 1;
}
a++;
}
return 0;
}
static char *ParseOid(char *ptr, char **oid) {
if (!charin(*ptr, CHARS_OID)) {
return NULL;
}
*oid = ptr;
if (!(ptr = strchr(ptr, ' '))) {
return NULL;
}
*ptr++ = '\0';
return ptr;
}
static char *ParseQdescr(char *ptr, char **qdescr) {
if (*ptr != '\'') {
return NULL;
}
*qdescr = ++ptr;
if (!(ptr = strchr(ptr, '\''))) {
return NULL;
}
*ptr++ = '\0';
return ptr;
}
static char *ParseNoidlen(char *ptr, char **noidlen) {
/* Active Directory sometimes (incorrectly) uses quotes here */
if (*ptr == '\'') {
return ParseQdescr(ptr, noidlen);
}
if (!charin(*ptr, CHARS_OID)) {
return NULL;
}
*noidlen = ptr;
if (!(ptr = strchr(ptr, ' '))) {
}
*ptr++ = '\0';
return ptr;
}
static char *ParseOids(char *ptr, char ***oids) {
int inc = 4;
int idx = 0;
*oids = NewValArray(inc);
if (!*oids) {
return NULL;
}
if (*ptr == '(') {
ptr = strnot(ptr + 1, CHARS_WHSP);
while (ptr && *ptr != ')') {
if (!(idx % inc)) {
if (!ExpandValArray(oids, idx + inc)) {
FreeValArray(*oids);
free(*oids);
return NULL;
}
}
if (!(ptr = ParseOid(ptr, &((*oids)[idx++]))) ||
!(ptr = strnot(ptr, "$" CHARS_WHSP))) {
break;
}
}
if (!ptr || *ptr != ')') {
FreeValArray(*oids);
free(*oids);
return NULL;
}
} else if (charin(*ptr, CHARS_OID)) {
ptr = ParseOid(ptr, &((*oids)[idx++]));
} else {
FreeValArray(*oids);
free(*oids);
return NULL;
}
return ptr;
}
static char *ParseQdescrs(char *ptr, char ***qdescrs) {
int inc = 4;
int idx = 0;
*qdescrs = NewValArray(inc);
if (!*qdescrs) {
return NULL;
}
if (*ptr == '(') {
ptr = strnot(ptr + 1, CHARS_WHSP);
while (ptr && *ptr != ')') {
if (!(idx % inc)) {
if (!ExpandValArray(qdescrs, idx + inc)) {
FreeValArray(*qdescrs);
free(*qdescrs);
return NULL;
}
}
if (!(ptr = ParseQdescr(ptr, &((*qdescrs)[idx++]))) ||
!(ptr = strnot(ptr, CHARS_WHSP))) {
break;
}
}
if (!ptr || *ptr != ')') {
FreeValArray(*qdescrs);
free(*qdescrs);
return NULL;
}
} else if (*ptr == '\'') {
if (!(ptr = ParseQdescr(ptr, &((*qdescrs)[idx++])))) {
FreeValArray(*qdescrs);
free(*qdescrs);
return NULL;
}
} else {
FreeValArray(*qdescrs);
free(*qdescrs);
return NULL;
}
return ptr;
}
BOOL ParseAttributeTypeDescription(char *ptr, MDBLDAPSchemaAttr *attr) {
char *tmp;
ptr = strnot(ptr, CHARS_WHSP);
if (*ptr != '(') {
return FALSE;
}
if (!(ptr = strnot(ptr + 1, CHARS_WHSP)) ||
!(ptr = ParseOid(ptr, &attr->oid))) {
return FALSE;
}
if ((tmp = strstr(ptr, "NAME"))) {
ptr = tmp;
if (!(ptr = strnot(ptr + 4, CHARS_WHSP)) ||
!(ptr = ParseQdescrs(ptr, &attr->names))) {
return FALSE;
}
}
if ((tmp = strstr(ptr, "SUP"))) {
ptr = tmp;
if (!(ptr = strnot(ptr + 3, CHARS_WHSP)) ||
!(ptr = ParseOid(ptr, &attr->sup))) {
return FALSE;
}
}
if ((tmp = strstr(ptr, "EQUALITY"))) {
ptr = tmp;
if (!(ptr = strnot(ptr + 8, CHARS_WHSP)) ||
!(ptr = ParseOid(ptr, &attr->equality))) {
return FALSE;
}
}
if ((tmp = strstr(ptr, "SYNTAX"))) {
ptr = tmp;
if (!(ptr = strnot(ptr + 6, CHARS_WHSP)) ||
!(ptr = ParseNoidlen(ptr, &attr->syntax))) {
return FALSE;
}
}
if (!(ptr = strnot(ptr, CHARS_WHSP)) &&
!strncmp(ptr, "SINGLE-VALUE", 12)) {
attr->singleval = TRUE;
}
return TRUE;
}
BOOL ParseObjectClassDescription(char *ptr, MDBLDAPSchemaClass *class) {
char *tmp;
ptr = strnot(ptr, CHARS_WHSP);
if (*ptr != '(') {
return FALSE;
}
if (!(ptr = strnot(ptr + 1, CHARS_WHSP)) ||
!(ptr = ParseOid(ptr, &class->oid))) {
return FALSE;
}
if ((tmp = strstr(ptr, "NAME"))) {
ptr = tmp;
if (!(ptr = strnot(ptr + 4, CHARS_WHSP)) ||
!(ptr = ParseQdescrs(ptr, &class->names))) {
return FALSE;
}
}
if ((tmp = strstr(ptr, "SUP"))) {
ptr = tmp;
if (!(ptr = strnot(ptr + 3, CHARS_WHSP)) ||
!(ptr = ParseOids(ptr, &class->sup))) {
return FALSE;
}
}
/*
ptr = strnot(ptr, CHARS_WHSP);
if (!strncmp(ptr, "ABSTRACT", 8) ||
!strncmp(ptr, "STRUCTURAL", 10) ||
!strncmp(ptr, "AUXILIARY", 9)) {
type = ptr;
if (!(ptr = strchr(ptr, ' '))) {
return FALSE;
}
*ptr++ = '\0';
}
*/
if ((tmp = strstr(ptr, "MUST"))) {
ptr = tmp;
if (!(ptr = strnot(ptr + 4, CHARS_WHSP)) ||
!(ptr = ParseOids(ptr, &class->must))) {
return FALSE;
}
}
if ((tmp = strstr(ptr, "MAY"))) {
ptr = tmp;
if (!(ptr = strnot(ptr + 3, CHARS_WHSP)) ||
!(ptr = ParseOids(ptr, &class->may))) {
return FALSE;
}
}
return TRUE;
}
src/libs/mdb-xldap/valarray.c
-213
View File
@@ -1,213 +0,0 @@
/****************************************************************************
* <Novell-copyright>
* Copyright (c) 2006 Novell, Inc. All Rights Reserved.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of version 2 of the GNU General Public License
* as published by the Free Software Foundation.
*
* 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, contact Novell, Inc.
*
* To contact Novell about this file by physical or electronic mail, you
* may find current contact information at www.novell.com.
* </Novell-copyright>
****************************************************************************/
#include "mdbldapp.h"
/**
* Functions for handling char ** arrays.
*/
inline char **
NewValArray(int size)
{
char **vals;
vals = malloc(sizeof(char *) * (size + 1));
if (vals) {
memset(vals, 0, sizeof(char *) * (size + 1));
}
return vals;
}
inline void
FreeValArray(char **vals)
{
int i;
for (i = 0; vals[i]; i++) {
free(vals[i]);
vals[i] = NULL;
}
/*free(vals);*/
}
inline int
CountValArray(char **vals)
{
int i;
for (i = 0; vals[i]; i++);
return i;
}
inline char **
CopyValArray(char **vals)
{
char **dup;
int count;
int i;
count = CountValArray(vals);
dup = NewValArray(count);
if (dup) {
for (i = 0; vals[i]; i++) {
dup[i] = strdup(vals[i]);
if (!dup[i]) {
break;
}
}
if (i < count) {
FreeValArray(dup);
free(dup);
dup = NULL;
}
}
return dup;
}
inline BOOL
ExpandValArray(char ***vals, int size)
{
char **tmps;
char **ptr;
int count;
int ext;
count = CountValArray(*vals);
ext = size - count;
if (ext > 0) {
tmps = realloc(*vals, (sizeof(char *) * (size + 1)));
if (tmps) {
ptr = tmps + count + 1;
memset(ptr, 0, (sizeof(char *) * ext));
*vals = tmps;
return TRUE;
}
}
return FALSE;
}
inline unsigned int
ValueStructToValArray(MDBValueStruct *v, char **vals)
{
unsigned int i;
for (i = 0; i < v->Used; i++) {
vals[i] = strdup((char *)(v->Value[i]));
if (!vals[i]) {
break;
}
}
if (i < v->Used) {
FreeValArray(vals);
return 0;
}
return i;
}
inline int
ValArrayToValueStruct(char **vals, MDBValueStruct *v)
{
int i;
int count;
count = CountValArray(vals);
for (i = 0; vals[i]; i++) {
if (!MDBLDAPAddValue((unsigned char *)(vals[i]), v)) {
break;
}
}
if (i < count) {
return 0;
}
return i;
}
inline char **
TranslateValArray(char **in, TranslateFunction transfunc, char *opt)
{
char **out;
int count;
int i;
count = CountValArray(in);
out = NewValArray(count);
if (out) {
for (i = 0; in[i]; i++) {
out[i] = transfunc(in[i], opt);
if (!out[i]) {
break;
}
}
if (i < count) {
FreeValArray(out);
free(out);
out = NULL;
}
}
return out;
}
inline unsigned int
TranslateValueStructToValArray(MDBValueStruct *v, char **vals,
TranslateFunction transfunc, char *opt)
{
unsigned int i;
for (i = 0; i < v->Used; i++) {
vals[i] = transfunc((char *)(v->Value[i]), opt);
if (!vals[i]) {
break;
}
}
if (i < v->Used) {
FreeValArray(vals);
return 0;
}
return i;
}
inline int
TranslateValArrayToValueStruct(char **vals, MDBValueStruct *v,
TranslateFunction transfunc, char *opt)
{
char *val;
int count;
int i;
count = CountValArray(vals);
for (i = 0; vals[i]; i++) {
val = transfunc(vals[i], opt);
if (val) {
if (!MDBLDAPAddValue((unsigned char *)val, v)) {
break;
}
free(val);
} else {
break;
}
}
if (i < count) {
return 0;
}
return i;
}
src/libs/mdb/Bongo.rules
-21
View File
@@ -1,21 +0,0 @@
# -*- Makefile -*-
mdbdir = $(libdir)/bongomdb
mdb_LTLIBRARIES =
lib_LTLIBRARIES += libbongomdb.la
libbongomdb_la_SOURCES = \
src/libs/mdb/mdb.c \
src/libs/mdb/mdbp.h
libbongomdb_la_CPPFLAGS = $(AM_CPPFLAGS) \
-DDRIVER_EXTENSION=\"$(SHARED_POSTFIX)\" \
-DSYSCONF_DIR=\""$(sysconfdir)"\" \
-DDRIVER_DIR=\""$(libdir)/bongomdb"\"
libbongomdb_la_LIBADD = \
libbongoxpl.la \
$(DL_LIBS)
src/libs/mdb/all: libbongomdb.la
src/libs/mdb/clean: clean
src/libs/mdb/Makefile.am
-17
View File
@@ -1,17 +0,0 @@
# -*- Makefile -*-
#
# Do not edit!
#
# (unless this is Makefile.am.subdir)
#
# This file is a copy of the toplevel Makefile.am.subdir. If changes
# need to be made, edit that file, and make update-makefiles, and
# check the new files in.
#
# This is a skeletal automake file. The real automake fules for
# building the targets for this directory can be found in the
# Bongo.rules file. This file is simply here so that 'make all' can
# work in each subdirectory.
all clean install:
@cd $(top_builddir) && $(MAKE) $(MFLAGS) $(subdir)/$@
src/libs/mdb/mdb.c
-887
View File
@@ -1,887 +0,0 @@
/*
* <Novell-copyright>
* Copyright (c) 2001 Novell, Inc. All Rights Reserved.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of version 2 of the GNU General Public License
* as published by the Free Software Foundation.
*
* 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, contact Novell, Inc.
*
* To contact Novell about this file by physical or electronic mail, you
* may find current contact information at www.novell.com.
* </Novell-copyright>
*/
/* We use bongo-specific keys/dirs here rather than mdb, so that we don't conflict before
* we merge */
#include <config.h>
#include <xpl.h>
#include <errno.h>
#include <signal.h>
/* Local modification, bongo's xpl no longer defines these */
#include <mdb.h>
#include "mdbp.h"
/* Globals */
LONG Tid;
LONG TGid;
XplSemaphore ShutdownSemaphore;
BOOL MDBInitialized = FALSE;
BOOL MDBLoading = FALSE;
BOOL MDBFailed = FALSE;
#define ChopNL(String) { unsigned char *pTr; pTr=strchr((String), 0x0a); if (pTr) *pTr='\0'; pTr=strrchr((String), 0x0d); if (pTr) *pTr='\0'; }
#if defined(NETWARE)
#define MDB_CONFIG_INIT
#define MDB_CONFIG_FILE "sys:/etc/mdb.cfg"
unsigned char DriverDir[XPL_MAX_PATH+1] = "sys:\\system";
#elif defined(WIN32)
#define MDB_CONFIG_INIT { \
HKEY HKey; \
GetWindowsDirectory(MDB_CONFIG_FILE, sizeof(MDB_CONFIG_FILE)); \
strcat(MDB_CONFIG_FILE, "/mdb.cfg"); \
\
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, "Software\\Bongo\\MDB", 0, KEY_READ, &HKey)==ERROR_SUCCESS) { \
DWORD BufSize=XPL_MAX_PATH; \
RegQueryValueEx(HKey, "DriverDir", NULL, NULL, DriverDir, &BufSize); \
RegCloseKey(HKey); \
} \
}
unsigned char MDB_CONFIG_FILE[256+1];
unsigned char DriverDir[XPL_MAX_PATH+1] = "C:\\program files\\Bongo\\MDB";
#elif defined(SUSE) || defined(LINUX) || defined(S390RH) || defined(REDHAT) || defined(SOLARIS) || defined(MACOSX)
#define MDB_CONFIG_INIT
#define MDB_CONFIG_FILE XPL_DEFAULT_CONF_DIR "/mdb.conf"
unsigned char DriverDir[XPL_MAX_PATH+1] = DRIVER_DIR;
#endif
typedef struct _MDBDriverStruct {
unsigned char Driver[256];
BOOL Primary;
MDBDriverInitFunc Init;
MDBDriverShutdownFunc Shutdown;
MDBInterfaceStruct Interface;
XplPluginHandle Handle;
void *Data;
} MDBDriverStruct;
typedef struct {
unsigned char Module[XPL_MAX_PATH];
unsigned char Driver[XPL_MAX_PATH];
unsigned char Arguments[512];
} MDBModuleStruct;
unsigned long MDBDriverCount = 0;
MDBDriverStruct *MDBDrivers = NULL;
unsigned long MDBModuleCount = 0;
unsigned long MDBModuleAlloc = 0;
MDBModuleStruct *MDBModules = NULL;
unsigned long MDBDefaultDriver = 0;
static unsigned long
MDBFindDriver(const unsigned char *Driver)
{
unsigned long i;
for (i=0; i<MDBDriverCount; i++) {
if (XplStrCaseCmp(MDBDrivers[i].Driver, Driver)==0) {
return(i);
}
}
return(-1);
}
static XplPluginHandle
MDBGetDriverHandle(const unsigned char *Driver)
{
unsigned long i;
for (i=0; i<MDBDriverCount; i++) {
if (XplStrCaseCmp(MDBDrivers[i].Driver, Driver)==0) {
return(MDBDrivers[i].Handle);
}
}
return(NULL);
}
static unsigned long
MDBInitDriver (MDBDriverStruct *Driver,
const unsigned char *Arguments,
unsigned char *Error)
{
unsigned char FuncName[XPL_MAX_PATH+sizeof ("Shutdown")];
MDBDriverInitStruct Init;
strcpy (FuncName, Driver->Driver);
strcat (FuncName, "Init");
/* FIXME: what do we do about DriverName here */
Driver->Init=(MDBDriverInitFunc)XplGetDLLFunction(DriverName, FuncName, Driver->Handle);
if (!Driver->Init) {
if (Error) sprintf(Error, "Driver %s, missing Init function", Driver->Driver);
if (Driver->Primary) {
XplUnloadDLL(Driver->Driver, Driver->Handle);
}
return(-1);
}
/* Grab the shutdown function */
strcpy(FuncName, Driver->Driver);
strcat(FuncName, "Shutdown");
Driver->Shutdown=(MDBDriverShutdownFunc)XplGetDLLFunction(DriverName, FuncName, Driver->Handle);
if (!Driver->Shutdown) {
if (Error) sprintf(Error, "Driver %s, missing Shutdown function", Driver->Driver);
if (Driver->Primary) {
XplUnloadDLL(Driver->Driver, Driver->Handle);
}
return(-1);
}
memset(&Init, 0, sizeof(Init));
Init.Arguments=Arguments;
if (!Driver->Init(&Init)) {
if (Error) sprintf(Error, "Driver %s, Init failed with: %s", Driver->Driver, Init.Error);
Driver->Shutdown();
/* Can't unload for now; dclient creates a bunch of threads and they go to hell if we unload this dll */
//XplUnloadDLL(Driver->Driver, Driver->Handle);
return(-1);
}
memcpy(&Driver->Interface, &Init.Interface, sizeof(MDBInterfaceStruct));
return 0;
}
static unsigned long
MDBLoadDriver(const unsigned char *DriverNameIn, const unsigned char *Arguments, unsigned char *Error)
{
unsigned char DriverName[XPL_MAX_PATH+1];
unsigned char Name[XPL_MAX_PATH+1];
unsigned char *ptr;
MDBDriverStruct *Driver;
/* First, make sure there's enough space in our list */
MDBDrivers=realloc(MDBDrivers, sizeof(MDBDriverStruct)*(MDBDriverCount+1));
if (!MDBDrivers) {
return(-1);
}
Driver=&MDBDrivers[MDBDriverCount];
memset(Driver, 0, sizeof(MDBDriverStruct));
strcpy(DriverName, DriverNameIn);
ptr=DriverName;
while (*ptr) {
*ptr=tolower(*ptr);
ptr++;
}
TryAgain:
if ((strchr(DriverNameIn, '/')==NULL) && (strchr(DriverNameIn, '\\')==NULL)) {
if ((strlen(DriverName)<5) || (XplStrNCaseCmp(DriverName+strlen(DriverName)-strlen(DRIVER_EXTENSION), DRIVER_EXTENSION, strlen(DRIVER_EXTENSION))!=0)) {
ptr=strrchr(DriverName, '.');
if (ptr && XplStrNCaseCmp(ptr,".NLM", 4)==0) {
strcpy(ptr, DRIVER_EXTENSION);
goto TryAgain;
} else {
/* No period means possibly no extension, let's add our default extension */
strcat(DriverName, DRIVER_EXTENSION);
goto TryAgain;
}
if (Error) strcpy(Error, "Bad driver extension");
return(-1);
}
} else {
unsigned char *ptr;
if ((ptr=strrchr(DriverNameIn, '/'))==NULL) {
ptr=strrchr(DriverNameIn, '\\');
}
ptr++;
strcpy(DriverName, ptr);
}
strcpy(Name, DriverName);
Name[strlen(Name)-strlen(DRIVER_EXTENSION)]='\0';
ptr=Name;
while (*ptr) {
*ptr=toupper(*ptr);
ptr++;
}
Driver->Handle=MDBGetDriverHandle(DriverName);
if (!Driver->Handle) {
if (!(strchr(DriverNameIn, '/')==NULL) && (strchr(DriverNameIn, '\\')==NULL)) {
/* Use the absolute path if it was passed */
Driver->Handle=XplLoadDLL(DriverNameIn);
} else {
/* Otherwise try <name> then lib<name> */
unsigned char Path[XPL_MAX_PATH + 1];
sprintf(Path, "%s%c%s", DriverDir, XPL_DIR_SEPARATOR, DriverName);
Driver->Handle=XplLoadDLL(Path);
if (!Driver->Handle) {
sprintf(Path, "%s%clib%s", DriverDir, XPL_DIR_SEPARATOR, DriverName);
Driver->Handle=XplLoadDLL(Path);
}
}
Driver->Primary=TRUE;
}
if (!Driver->Handle) {
if (Error) sprintf(Error, "Could not load driver, error %d", errno);
return(-1);
}
/* Give the module a chance to initialize */
strcpy(Driver->Driver, Name);
if (MDBInitDriver (Driver, Arguments, Error) == 0) {
//XplConsolePrintf("MDBDriver '%s', successfully loaded\n", DriverName);
return(MDBDriverCount++);
} else {
return(-1);
}
}
EXPORT int
MDBGetAPIVersion(BOOL WantCompatibleVersion, unsigned char *Description, MDBHandle Context)
{
if (Description) {
if (Context) {
strncpy(Description, ((MDBContextCacheStruct *)Context)->Description, MDB_MAX_API_DESCRIPTION_CHARS-1);
} else {
strcpy(Description, "<undefined>");
}
}
if (WantCompatibleVersion) {
return(MDB_COMPATIBLE_TO_API);
} else {
return(MDB_CURRENT_API_VERSION);
}
}
EXPORT BOOL
MDBGetServerInfo(unsigned char *HostDN, unsigned char *HostTree, MDBValueStruct *V)
{
if (!V) {
return(MDBDrivers[MDBDefaultDriver].Interface.MDBGetServerInfo(HostDN, HostTree, V));
} else {
return(V->Interface->MDBGetServerInfo(HostDN, HostTree, V));
}
}
EXPORT char *
MDBGetBaseDN(MDBValueStruct *V)
{
if (!V) {
return(MDBDrivers[MDBDefaultDriver].Interface.MDBGetBaseDN(V));
} else {
return(V->Interface->MDBGetBaseDN(V));
}
}
/* Authentication */
EXPORT MDBHandle
MDBAuthenticate(const unsigned char *Module, const unsigned char *Object, const unsigned char *Password)
{
unsigned int i;
unsigned long Driver=MDBDefaultDriver;
MDBHandle Handle;
unsigned char *Arguments=NULL;
for (i=0; i<MDBModuleCount; i++) {
if (XplStrCaseCmp(Module, MDBModules[i].Module)==0) {
Driver=MDBFindDriver(MDBModules[i].Driver);
if (Driver!=(unsigned long)-1) {
Arguments=MDBModules[Driver].Arguments;
} else {
Driver=MDBDefaultDriver;
}
}
}
Handle=MDBDrivers[Driver].Interface.MDBAuthenticate(Object, Password, Arguments);
if (Handle) {
((MDBContextCacheStruct *)Handle)->Interface=&MDBDrivers[Driver].Interface;
}
return(Handle);
}
EXPORT BOOL
MDBRelease(MDBHandle Handle)
{
if (Handle) {
return(((MDBContextCacheStruct *)Handle)->Interface->MDBRelease(Handle));
} else {
return(FALSE);
}
}
EXPORT MDBValueStruct
*MDBCreateValueStruct(MDBHandle Handle, const unsigned char *Context)
{
MDBValueStruct *V;
V=((MDBContextCacheStruct *)Handle)->Interface->MDBCreateValueStruct(Handle, Context);
if (V) {
V->Interface=((MDBContextCacheStruct *)Handle)->Interface;
}
return(V);
}
EXPORT BOOL
MDBDestroyValueStruct(MDBValueStruct *V)
{
return(V->Interface->MDBDestroyValueStruct(V));
}
EXPORT MDBValueStruct
*MDBShareContext(MDBValueStruct *VOld)
{
MDBValueStruct *VNew;
VNew=VOld->Interface->MDBShareContext(VOld);
if (VNew) {
VNew->Interface=VOld->Interface;
}
return(VNew);
}
EXPORT BOOL
MDBSetValueStructContext(const unsigned char *Context, MDBValueStruct *V)
{
return(V->Interface->MDBSetValueStructContext(Context, V));
}
EXPORT MDBEnumStruct
*MDBCreateEnumStruct(MDBValueStruct *V)
{
return(V->Interface->MDBCreateEnumStruct(V));
}
EXPORT BOOL
MDBDestroyEnumStruct(MDBEnumStruct *E, MDBValueStruct *V)
{
return(V->Interface->MDBDestroyEnumStruct(E, V));
}
EXPORT BOOL
MDBAddValue(const unsigned char *Value, MDBValueStruct *V)
{
return(V->Interface->MDBAddValue(Value, V));
}
EXPORT BOOL
MDBFreeValue(unsigned long Index, MDBValueStruct *V)
{
return(V->Interface->MDBFreeValue(Index, V));
}
EXPORT BOOL
MDBFreeValues(MDBValueStruct *V)
{
return(V->Interface->MDBFreeValues(V));
}
EXPORT long
MDBRead(const unsigned char *Object, const unsigned char *Attribute, MDBValueStruct *V)
{
return(V->Interface->MDBRead(Object, Attribute, V));
}
EXPORT const unsigned char
*MDBReadEx(const unsigned char *Object, const unsigned char *Attribute, MDBEnumStruct *E, MDBValueStruct *V)
{
return(V->Interface->MDBReadEx(Object, Attribute, E, V));
}
EXPORT long
MDBReadDN(const unsigned char *Object, const unsigned char *Attribute, MDBValueStruct *V)
{
return(V->Interface->MDBReadDN(Object, Attribute, V));
}
EXPORT BOOL
MDBWriteTyped(const unsigned char *Object, const unsigned char *Attribute, const int AttrType, MDBValueStruct *V)
{
return(V->Interface->MDBWriteTyped(Object, Attribute, AttrType, V));
}
EXPORT BOOL
MDBWrite(const unsigned char *Object, const unsigned char *Attribute, MDBValueStruct *V)
{
return(V->Interface->MDBWrite(Object, Attribute, V));
}
EXPORT BOOL
MDBWriteDN(const unsigned char *Object, const unsigned char *Attribute, MDBValueStruct *V)
{
return(V->Interface->MDBWriteDN(Object, Attribute, V));
}
EXPORT BOOL
MDBClear(const unsigned char *Object, const unsigned char *Attribute, MDBValueStruct *V)
{
return(V->Interface->MDBClear(Object, Attribute, V));
}
EXPORT BOOL
MDBAdd(const unsigned char *Object, const unsigned char *Attribute, const unsigned char *Value, MDBValueStruct *V)
{
return(V->Interface->MDBAdd(Object, Attribute, Value, V));
}
EXPORT BOOL
MDBAddDN(const unsigned char *Object, const unsigned char *Attribute, const unsigned char *Value, MDBValueStruct *V)
{
return(V->Interface->MDBAddDN(Object, Attribute, Value, V));
}
EXPORT BOOL
MDBRemove(const unsigned char *Object, const unsigned char *Attribute, const unsigned char *Value, MDBValueStruct *V)
{
return(V->Interface->MDBRemove(Object, Attribute, Value, V));
}
EXPORT BOOL
MDBRemoveDN(const unsigned char *Object, const unsigned char *Attribute, const unsigned char *Value, MDBValueStruct *V)
{
return(V->Interface->MDBRemoveDN(Object, Attribute, Value, V));
}
EXPORT BOOL
MDBIsObject(const unsigned char *Object, MDBValueStruct *V)
{
return(V->Interface->MDBIsObject(Object, V));
}
EXPORT BOOL
MDBGetObjectDetails(const unsigned char *Object, unsigned char *Type, unsigned char *RDN, unsigned char *DN, MDBValueStruct *V)
{
return(V->Interface->MDBGetObjectDetails(Object, Type, RDN, DN, V));
}
EXPORT BOOL
MDBGetObjectDetailsEx(const unsigned char *Object, MDBValueStruct *Types, unsigned char *RDN, unsigned char *DN, MDBValueStruct *V)
{
return(V->Interface->MDBGetObjectDetailsEx(Object, Types, RDN, DN, V));
}
EXPORT BOOL
MDBVerifyPassword(const unsigned char *Object, const unsigned char *Password, MDBValueStruct *V)
{
return(V->Interface->MDBVerifyPassword(Object, Password, V));
}
EXPORT BOOL
MDBVerifyPasswordEx(const unsigned char *Object, const unsigned char *Password, MDBValueStruct *V)
{
return(V->Interface->MDBVerifyPasswordEx(Object, Password, V));
}
EXPORT BOOL
MDBChangePassword(const unsigned char *Object, const unsigned char *OldPassword, const unsigned char *NewPassword, MDBValueStruct *V)
{
return(V->Interface->MDBChangePassword(Object, OldPassword, NewPassword, V));
}
EXPORT BOOL
MDBChangePasswordEx(const unsigned char *Object, const unsigned char *OldPassword, const unsigned char *NewPassword, MDBValueStruct *V)
{
return(V->Interface->MDBChangePasswordEx(Object, OldPassword, NewPassword, V));
}
EXPORT long
MDBEnumerateObjects(const unsigned char *Container, const unsigned char *Type, const unsigned char *Pattern, MDBValueStruct *V)
{
return(V->Interface->MDBEnumerateObjects(Container, Type, Pattern, V));
}
EXPORT const unsigned char
*MDBEnumerateObjectsEx(const unsigned char *Container, const unsigned char *Type, const unsigned char *Pattern, unsigned long Flags, MDBEnumStruct *E, MDBValueStruct *V)
{
return(V->Interface->MDBEnumerateObjectsEx(Container, Type, Pattern, Flags, E, V));
}
EXPORT const unsigned char
*MDBEnumerateAttributesEx(const unsigned char *Object, MDBEnumStruct *E, MDBValueStruct *V)
{
return(V->Interface->MDBEnumerateAttributesEx(Object, E, V));
}
EXPORT BOOL
MDBCreateAlias(const unsigned char *Alias, const unsigned char *AliasedObjectDn, MDBValueStruct *V)
{
return(V->Interface->MDBCreateAlias(Alias, AliasedObjectDn, V));
}
EXPORT BOOL
MDBCreateObject(const unsigned char *Object, const unsigned char *Class, MDBValueStruct *Attribute, MDBValueStruct *Data, MDBValueStruct *V)
{
return(V->Interface->MDBCreateObject(Object, Class, Attribute, Data, V));
}
EXPORT BOOL
MDBDeleteObject(const unsigned char *Object, BOOL Recursive, MDBValueStruct *V)
{
return(V->Interface->MDBDeleteObject(Object, Recursive, V));
}
EXPORT BOOL
MDBRenameObject(const unsigned char *ObjectOld, const unsigned char *ObjectNew, MDBValueStruct *V)
{
return(V->Interface->MDBRenameObject(ObjectOld, ObjectNew, V));
}
EXPORT BOOL
MDBDefineAttribute(const unsigned char *Attribute, const unsigned char *ASN1, unsigned long Type, BOOL SingleValue, BOOL ImmediateSync, BOOL Public, MDBValueStruct *V)
{
return(V->Interface->MDBDefineAttribute(Attribute, ASN1, Type, SingleValue, ImmediateSync, Public, V));
}
EXPORT BOOL
MDBUndefineAttribute(const unsigned char *Attribute, MDBValueStruct *V)
{
return(V->Interface->MDBUndefineAttribute(Attribute, V));
}
EXPORT BOOL
MDBDefineClass(const unsigned char *Class, const unsigned char *ASN1, BOOL Container, MDBValueStruct *Superclass, MDBValueStruct *Containment, MDBValueStruct *Naming, MDBValueStruct *Mandatory, MDBValueStruct *Optional, MDBValueStruct *V)
{
return(V->Interface->MDBDefineClass(Class, ASN1, Container, Superclass, Containment, Naming, Mandatory, Optional, V));
}
EXPORT BOOL
MDBAddAttribute(const unsigned char *Attribute, const unsigned char *Class, MDBValueStruct *V)
{
return(V->Interface->MDBAddAttribute(Attribute, Class, V));
}
EXPORT BOOL
MDBUndefineClass(const unsigned char *Class, MDBValueStruct *V)
{
return(V->Interface->MDBUndefineClass(Class, V));
}
EXPORT BOOL
MDBListContainableClasses(const unsigned char *Container, MDBValueStruct *V)
{
return(V->Interface->MDBListContainableClasses(Container, V));
}
EXPORT const unsigned char
*MDBListContainableClassesEx(const unsigned char *Container, MDBEnumStruct *E, MDBValueStruct *V)
{
return(V->Interface->MDBListContainableClassesEx(Container, E, V));
}
EXPORT BOOL
MDBGrantObjectRights(const unsigned char *Object, const unsigned char *TrusteeDN, BOOL Read, BOOL Write, BOOL Delete, BOOL Rename, BOOL Admin, MDBValueStruct *V)
{
return(V->Interface->MDBGrantObjectRights(Object, TrusteeDN, Read, Write, Delete, Rename, Admin, V));
}
EXPORT BOOL
MDBGrantAttributeRights(const unsigned char *Object, const unsigned char *Attribute, const unsigned char *TrusteeDN, BOOL Read, BOOL Write, BOOL Admin, MDBValueStruct *V)
{
return(V->Interface->MDBGrantAttributeRights(Object, Attribute, TrusteeDN, Read, Write, Admin, V));
}
EXPORT BOOL
MDBFindObjects(const unsigned char *Container,
MDBValueStruct *Types,
const unsigned char *Pattern,
MDBValueStruct *Attributes,
int depth,
int max,
MDBValueStruct *V)
{
if (V->Interface->MDBFindObjects) {
return(V->Interface->MDBFindObjects(Container, Types, Pattern, Attributes, depth, max, V));
} else {
return FALSE;
}
}
EXPORT BOOL
MDBDumpValueStruct(MDBValueStruct *V)
{
unsigned long i;
if (!V->Used) {
XplConsolePrintf("No data in structure\n");
}
XplConsolePrintf("ValueStruct: Used:%lu\n", V->Used);
for (i=0; i<V->Used; i++) {
XplConsolePrintf("Value[%02lu] %-25s", i, V->Value[i]);
if (((i+1) % 2)==0) {
XplConsolePrintf("\n");
} else {
XplConsolePrintf(" | ");
}
}
XplConsolePrintf("\r\n");
return(TRUE);
}
/*
Config format:
DriverDir=<Directory>
Default=<Drivername>
Driver=<Drivername> [DriverArguments]
Module <Modulename>=<Drivername> [DriverArguments]
*/
static BOOL
MDBReadConfiguration(void)
{
FILE *Handle;
unsigned char Buffer[1024];
unsigned char Error[XPL_MAX_PATH*2];
unsigned char DefaultDriverName[XPL_MAX_PATH+1] = "";
MDB_CONFIG_INIT;
Handle=fopen(MDB_CONFIG_FILE, "rb");
if (!Handle) {
return(FALSE);
}
while (!ferror(Handle) && !feof(Handle)) {
if (fgets(Buffer, sizeof(Buffer), Handle)!=NULL) {
ChopNL(Buffer);
if (XplStrNCaseCmp(Buffer, "DriverDir=", 10)==0) {
strcpy(DriverDir, Buffer+10);
} else if (XplStrNCaseCmp(Buffer, "Module ", 7)==0) {
unsigned char *Module;
unsigned char *Driver;
unsigned char *Arguments;
if ((MDBModuleCount+1)>MDBModuleAlloc) {
MDBModules=realloc(MDBModules, sizeof(MDBModuleStruct)*(MDBModuleAlloc+10));
if (!MDBModules) {
fclose(Handle);
return(FALSE);
}
MDBModuleAlloc+=10;
}
Module=Buffer+7;
Driver=strchr(Module, '=');
if (Driver) {
*Driver='\0';
Driver++;
if ((Arguments=strchr(Driver, ' '))!=NULL) {
*Arguments='\0';
Arguments++;
}
strcpy(MDBModules[MDBModuleCount].Module, Module);
strcpy(MDBModules[MDBModuleCount].Driver, Driver);
if (Arguments) {
strcpy(MDBModules[MDBModuleCount].Arguments, Arguments);
} else {
MDBModules[MDBModuleCount].Arguments[0]='\0';
}
MDBModuleCount++;
}
} else if (XplStrNCaseCmp(Buffer, "Driver=", 7)==0) {
unsigned char *Arguments;
if ((Arguments=strchr(Buffer+7, ' '))!=NULL) {
*Arguments='\0';
Arguments++;
}
if (MDBLoadDriver(Buffer+7, Arguments, Error)==(unsigned long)-1) {
XplConsolePrintf("\rDriver %s failed to load:%s\n", Buffer+7, Error);
fclose(Handle);
return(FALSE);
}
} else if (XplStrNCaseCmp(Buffer, "Default=", 8)==0) {
strcpy(DefaultDriverName, Buffer+8);
}
}
}
fclose(Handle);
if (DefaultDriverName[0]!='\0') {
MDBDefaultDriver=MDBFindDriver(DefaultDriverName);
}
return(TRUE);
}
EXPORT BOOL
MDBInit(void)
{
if (MDBFailed) {
return FALSE;
}
if (!MDBInitialized && !MDBLoading) {
MDBLoading=TRUE;
/* Read configuration */
if (!MDBReadConfiguration()) {
unsigned char Error[XPL_MAX_PATH*2];
if ((MDBLoadDriver("MDBDS", NULL, Error)==(unsigned long)-1) && (MDBLoadDriver("MDBREG", NULL, Error)==(unsigned long)-1) && (MDBLoadDriver("MDBFILE", NULL, Error)==(unsigned long)-1)) {
MDBLoading = FALSE;
MDBFailed = TRUE;
XplConsolePrintf("Failed to load any MDB driver\n");
/* INSERT "fake" MDB driver here */
return(FALSE);
}
}
MDBInitialized=TRUE;
}
while (!MDBInitialized) {
XplDelay(100);
}
return(MDBInitialized);
}
EXPORT BOOL
MDBShutdown(void)
{
return(TRUE);
}
#if defined(NETWARE)
void
MDBSigHandler(int Signal)
{
int OldTGid;
unsigned long i;
OldTGid=XplSetThreadGroupID(TGid);
XplSignalLocalSemaphore(ShutdownSemaphore);
XplWaitOnLocalSemaphore(ShutdownSemaphore);
/* Do any required cleanup */
for (i=0; i<MDBDriverCount; i++) {
MDBDrivers[i].Shutdown();
XplUnloadDLL(MDBDrivers[i].Driver, MDBDrivers[i].Handle);
}
if (MDBDrivers) {
free(MDBDrivers);
}
if (MDBModules) {
free(MDBModules);
}
XplCloseLocalSemaphore(ShutdownSemaphore);
XplSetThreadGroupID(OldTGid);
}
int
main(int argc, char *argv[])
{
Tid=XplGetThreadID();
TGid=XplGetThreadGroupID();
signal(SIGTERM, MDBSigHandler);
/*
This will "park" the module 'til we get unloaded;
it would not be neccessary to do this on NetWare,
but to prevent from automatically exiting on Unix
we need to keep main around...
*/
MDBInit();
XplOpenLocalSemaphore(ShutdownSemaphore, 0);
XplWaitOnLocalSemaphore(ShutdownSemaphore);
XplSignalLocalSemaphore(ShutdownSemaphore);
return(0);
}
#endif
#if defined(WIN32)
BOOL WINAPI
DllMain(HINSTANCE hInst, DWORD Reason, LPVOID Reserved)
{
if (Reason==DLL_PROCESS_ATTACH) {
DisableThreadLibraryCalls(hInst);
}
return(TRUE);
}
#endif
src/libs/mdb/mdbp.h
-33
View File
@@ -1,33 +0,0 @@
/*
* <Novell-copyright>
* Copyright (c) 2001 Novell, Inc. All Rights Reserved.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of version 2 of the GNU General Public License
* as published by the Free Software Foundation.
*
* 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, contact Novell, Inc.
*
* To contact Novell about this file by physical or electronic mail, you
* may find current contact information at www.novell.com.
* </Novell-copyright>
*/
#ifndef MDBP_H
#define MDBP_H
typedef struct {
unsigned char Description[128];
struct _MDBInterfaceStruct *Interface;
} MDBContextCacheStruct;
#endif /* MDBP_H */