diff options
Diffstat (limited to 'contrib/ldapc++/src')
92 files changed, 9820 insertions, 0 deletions
diff --git a/contrib/ldapc++/src/LDAPAddRequest.cpp b/contrib/ldapc++/src/LDAPAddRequest.cpp new file mode 100644 index 0000000..8ae0ea1 --- /dev/null +++ b/contrib/ldapc++/src/LDAPAddRequest.cpp @@ -0,0 +1,79 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + + +#include <ldap.h> + +#include "debug.h" + +#include "LDAPAddRequest.h" +#include "LDAPEntry.h" +#include "LDAPException.h" +#include "LDAPMessageQueue.h" +#include "LDAPResult.h" + +using namespace std; + +LDAPAddRequest::LDAPAddRequest(const LDAPAddRequest& req) : + LDAPRequest(req){ + DEBUG(LDAP_DEBUG_CONSTRUCT, "LDAPAddRequest::LDAPAddRequest(&)" << endl); + m_entry=new LDAPEntry(*(req.m_entry)); +} + +LDAPAddRequest::LDAPAddRequest(const LDAPEntry* entry, + LDAPAsynConnection *connect, const LDAPConstraints *cons, + bool isReferral, const LDAPRequest* parent) + : LDAPRequest(connect, cons, isReferral,parent){ + DEBUG(LDAP_DEBUG_CONSTRUCT, "LDAPAddRequest::LDAPAddRequest()" << endl); + DEBUG(LDAP_DEBUG_CONSTRUCT | LDAP_DEBUG_PARAMETER, + " entry:" << entry << endl + << " isReferral:" << isReferral << endl); + m_requestType = LDAPRequest::ADD; + m_entry = new LDAPEntry(*entry); +} + +LDAPAddRequest::~LDAPAddRequest(){ + DEBUG(LDAP_DEBUG_DESTROY, "LDAPAddRequest::~LDAPAddRequest()" << endl); + delete m_entry; +} + +LDAPMessageQueue* LDAPAddRequest::sendRequest(){ + DEBUG(LDAP_DEBUG_TRACE, "LDAPAddRequest::sendRequest()" << endl); + int msgID=0; + const LDAPAttributeList* list=m_entry->getAttributes(); + LDAPMod** attrs=list->toLDAPModArray(); + LDAPControl** tmpSrvCtrls = m_cons->getSrvCtrlsArray(); + LDAPControl** tmpClCtrls = m_cons->getClCtrlsArray(); + int err=ldap_add_ext(m_connection->getSessionHandle(), + m_entry->getDN().c_str(),attrs,tmpSrvCtrls,tmpClCtrls,&msgID); + LDAPControlSet::freeLDAPControlArray(tmpSrvCtrls); + LDAPControlSet::freeLDAPControlArray(tmpClCtrls); + ldap_mods_free(attrs,1); + if(err != LDAP_SUCCESS){ + throw LDAPException(err); + }else{ + m_msgID=msgID; + return new LDAPMessageQueue(this); + } +} + +LDAPRequest* LDAPAddRequest::followReferral(LDAPMsg* ref){ + DEBUG(LDAP_DEBUG_TRACE, "LDAPAddRequest::followReferral()"<< endl); + LDAPUrlList::const_iterator usedUrl; + LDAPUrlList urls = ((LDAPResult*)ref)->getReferralUrls(); + LDAPAsynConnection* con = 0; + try { + con = getConnection()->referralConnect(urls,usedUrl,m_cons); + } catch(LDAPException e){ + delete con; + return 0; + } + if(con != 0){ + return new LDAPAddRequest(m_entry, con, m_cons,true,this); + } + return 0; +} + diff --git a/contrib/ldapc++/src/LDAPAddRequest.h b/contrib/ldapc++/src/LDAPAddRequest.h new file mode 100644 index 0000000..c74f7b3 --- /dev/null +++ b/contrib/ldapc++/src/LDAPAddRequest.h @@ -0,0 +1,30 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#ifndef LDAP_ADD_REQUEST_H +#define LDAP_ADD_REQUEST_H + +#include <LDAPRequest.h> +#include <LDAPEntry.h> + +class LDAPMessageQueue; + +class LDAPAddRequest : LDAPRequest { + public: + LDAPAddRequest(const LDAPAddRequest& req); + LDAPAddRequest(const LDAPEntry* entry, + LDAPAsynConnection *connect, + const LDAPConstraints *cons, bool isReferral=false, + const LDAPRequest* parent=0); + virtual ~LDAPAddRequest(); + virtual LDAPMessageQueue* sendRequest(); + virtual LDAPRequest* followReferral(LDAPMsg* refs); + private: + LDAPEntry* m_entry; + +}; +#endif // LDAP_ADD_REQUEST_H + diff --git a/contrib/ldapc++/src/LDAPAsynConnection.cpp b/contrib/ldapc++/src/LDAPAsynConnection.cpp new file mode 100644 index 0000000..98fbd25 --- /dev/null +++ b/contrib/ldapc++/src/LDAPAsynConnection.cpp @@ -0,0 +1,366 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + + +#include "config.h" +#include "debug.h" +#include "LDAPAsynConnection.h" + +#include "LDAPAddRequest.h" +#include "LDAPBindRequest.h" +#include "LDAPCompareRequest.h" +#include "LDAPDeleteRequest.h" +#include "LDAPExtRequest.h" +#include "LDAPEntry.h" +#include "LDAPModDNRequest.h" +#include "LDAPModifyRequest.h" +#include "LDAPRequest.h" +#include "LDAPRebind.h" +#include "LDAPRebindAuth.h" +#include "LDAPSearchRequest.h" +#include <lber.h> +#include <sstream> + +using namespace std; + +LDAPAsynConnection::LDAPAsynConnection(const string& url, int port, + LDAPConstraints *cons ){ + DEBUG(LDAP_DEBUG_CONSTRUCT,"LDAPAsynConnection::LDAPAsynConnection()" + << endl); + DEBUG(LDAP_DEBUG_CONSTRUCT | LDAP_DEBUG_PARAMETER, + " URL:" << url << endl << " port:" << port << endl); + cur_session=0; + m_constr = 0; + // Is this an LDAP URI? + if ( url.find("://") == std::string::npos ) { + this->init(url, port); + } else { + this->initialize(url); + } + this->setConstraints(cons); +} + +LDAPAsynConnection::~LDAPAsynConnection(){ + unbind(); + delete m_constr; +} + +void LDAPAsynConnection::init(const string& hostname, int port){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPAsynConnection::init" << endl); + DEBUG(LDAP_DEBUG_TRACE | LDAP_DEBUG_PARAMETER, + " hostname:" << hostname << endl + << " port:" << port << endl); + + unbind(); + + m_uri.setScheme("ldap"); + m_uri.setHost(hostname); + m_uri.setPort(port); + + const char *ldapuri = m_uri.getURLString().c_str(); + int ret = ldap_initialize(&cur_session, ldapuri); + if ( ret != LDAP_SUCCESS ) { + throw LDAPException( ret ); + } + int opt=3; + ldap_set_option(cur_session, LDAP_OPT_REFERRALS, LDAP_OPT_OFF); + ldap_set_option(cur_session, LDAP_OPT_PROTOCOL_VERSION, &opt); +} + +void LDAPAsynConnection::initialize(const std::string& uri){ + unbind(); + + m_uri.setURLString(uri); + int ret = ldap_initialize(&cur_session, m_uri.getURLString().c_str()); + if ( ret != LDAP_SUCCESS ) { + throw LDAPException( ret ); + } + int opt=3; + ldap_set_option(cur_session, LDAP_OPT_REFERRALS, LDAP_OPT_OFF); + ldap_set_option(cur_session, LDAP_OPT_PROTOCOL_VERSION, &opt); +} + +void LDAPAsynConnection::start_tls(){ + int ret = ldap_start_tls_s( cur_session, NULL, NULL ); + if( ret != LDAP_SUCCESS ) { + throw LDAPException(this); + } +} + +LDAPMessageQueue* LDAPAsynConnection::bind(const string& dn, + const string& passwd, const LDAPConstraints *cons){ + DEBUG(LDAP_DEBUG_TRACE, "LDAPAsynConnection::bind()" << endl); + DEBUG(LDAP_DEBUG_TRACE | LDAP_DEBUG_PARAMETER, " dn:" << dn << endl + << " passwd:" << passwd << endl); + LDAPBindRequest *req = new LDAPBindRequest(dn,passwd,this,cons); + try{ + LDAPMessageQueue *ret = req->sendRequest(); + return ret; + }catch(LDAPException e){ + delete req; + throw; + } +} + +LDAPMessageQueue* LDAPAsynConnection::saslBind(const std::string &mech, + const std::string &cred, + const LDAPConstraints *cons) +{ + DEBUG(LDAP_DEBUG_TRACE, "LDAPAsynConnection::saslBind()" << endl); + LDAPSaslBindRequest *req = new LDAPSaslBindRequest(mech, cred, this, cons); + try{ + LDAPMessageQueue *ret = req->sendRequest(); + return ret; + }catch(LDAPException e){ + delete req; + throw; + } + +} + +LDAPMessageQueue* LDAPAsynConnection::saslInteractiveBind( + const std::string &mech, + int flags, + SaslInteractionHandler *sih, + const LDAPConstraints *cons) +{ + DEBUG(LDAP_DEBUG_TRACE, "LDAPAsynConnection::saslInteractiveBind" + << std::endl); + LDAPSaslInteractiveBind *req = + new LDAPSaslInteractiveBind(mech, flags, sih, this, cons); + try { + LDAPMessageQueue *ret = req->sendRequest(); + return ret; + }catch(LDAPException e){ + delete req; + throw; + } +} + +LDAPMessageQueue* LDAPAsynConnection::search(const string& base,int scope, + const string& filter, + const StringList& attrs, + bool attrsOnly, + const LDAPConstraints *cons){ + DEBUG(LDAP_DEBUG_TRACE, "LDAPAsynConnection::search()" << endl); + DEBUG(LDAP_DEBUG_TRACE | LDAP_DEBUG_PARAMETER, " base:" << base << endl + << " scope:" << scope << endl + << " filter:" << filter << endl ); + LDAPSearchRequest *req = new LDAPSearchRequest(base, scope,filter, attrs, + attrsOnly, this, cons); + try{ + LDAPMessageQueue *ret = req->sendRequest(); + return ret; + }catch(LDAPException e){ + delete req; + throw; + } +} + +LDAPMessageQueue* LDAPAsynConnection::del(const string& dn, + const LDAPConstraints *cons){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPAsynConnection::del()" << endl); + DEBUG(LDAP_DEBUG_TRACE | LDAP_DEBUG_PARAMETER," dn:" << dn << endl); + LDAPDeleteRequest *req = new LDAPDeleteRequest(dn, this, cons); + try{ + LDAPMessageQueue *ret = req->sendRequest(); + return ret; + }catch(LDAPException e){ + delete req; + throw; + } +} + +LDAPMessageQueue* LDAPAsynConnection::compare(const string& dn, + const LDAPAttribute& attr, const LDAPConstraints *cons){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPAsynConnection::compare()" << endl); + DEBUG(LDAP_DEBUG_TRACE | LDAP_DEBUG_PARAMETER," dn:" << dn << endl + << " attr:" << attr << endl); + LDAPCompareRequest *req = new LDAPCompareRequest(dn, attr, this, cons); + try{ + LDAPMessageQueue *ret = req->sendRequest(); + return ret; + }catch(LDAPException e){ + delete req; + throw; + } +} + +LDAPMessageQueue* LDAPAsynConnection::add( const LDAPEntry* le, + const LDAPConstraints *cons){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPAsynConnection::add()" << endl); + DEBUG(LDAP_DEBUG_TRACE | LDAP_DEBUG_PARAMETER," entry:" << *le << endl); + LDAPAddRequest *req = new LDAPAddRequest(le, this, cons); + try{ + LDAPMessageQueue *ret = req->sendRequest(); + return ret; + }catch(LDAPException e){ + delete req; + throw; + } +} + +LDAPMessageQueue* LDAPAsynConnection::modify(const string& dn, + const LDAPModList *mod, const LDAPConstraints *cons){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPAsynConnection::modify()" << endl); + DEBUG(LDAP_DEBUG_TRACE | LDAP_DEBUG_PARAMETER," dn:" << dn << endl); + LDAPModifyRequest *req = new LDAPModifyRequest(dn, mod, this, cons); + try{ + LDAPMessageQueue *ret = req->sendRequest(); + return ret; + }catch(LDAPException e){ + delete req; + throw; + } +} + +LDAPMessageQueue* LDAPAsynConnection::rename(const string& dn, + const string& newRDN, bool delOldRDN, const string& newParentDN, + const LDAPConstraints *cons ){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPAsynConnection::rename()" << endl); + DEBUG(LDAP_DEBUG_TRACE | LDAP_DEBUG_PARAMETER," dn:" << dn << endl + << " newRDN:" << newRDN << endl + << " newParentDN:" << newParentDN << endl + << " delOldRDN:" << delOldRDN << endl); + LDAPModDNRequest *req = new LDAPModDNRequest(dn, newRDN, delOldRDN, + newParentDN, this, cons ); + try{ + LDAPMessageQueue *ret = req->sendRequest(); + return ret; + }catch(LDAPException e){ + delete req; + throw; + } +} + + +LDAPMessageQueue* LDAPAsynConnection::extOperation(const string& oid, + const string& value, const LDAPConstraints *cons ){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPAsynConnection::extOperation()" << endl); + DEBUG(LDAP_DEBUG_TRACE | LDAP_DEBUG_PARAMETER," oid:" << oid << endl); + LDAPExtRequest *req = new LDAPExtRequest(oid, value, this,cons); + try{ + LDAPMessageQueue *ret = req->sendRequest(); + return ret; + }catch(LDAPException e){ + delete req; + throw; + } +} + + +void LDAPAsynConnection::abandon(LDAPMessageQueue *q){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPAsynConnection::abandon()" << endl); + LDAPRequestStack *reqStack=q->getRequestStack(); + LDAPRequest *req; + while(! reqStack->empty()){ + req=reqStack->top(); + if (ldap_abandon_ext(cur_session, req->getMsgID(), 0, 0) + != LDAP_SUCCESS){ + throw LDAPException(this); + } + delete req; + reqStack->pop(); + } +} + +void LDAPAsynConnection::unbind(){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPAsynConnection::unbind()" << endl); + if(cur_session){ + LDAPControl** tmpSrvCtrls=m_constr->getSrvCtrlsArray(); + LDAPControl** tmpClCtrls=m_constr->getClCtrlsArray(); + int err=ldap_unbind_ext(cur_session, tmpSrvCtrls, tmpClCtrls); + cur_session=0; + LDAPControlSet::freeLDAPControlArray(tmpSrvCtrls); + LDAPControlSet::freeLDAPControlArray(tmpClCtrls); + if(err != LDAP_SUCCESS){ + throw LDAPException(err); + } + } +} + +void LDAPAsynConnection::setConstraints(LDAPConstraints *cons){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPAsynConnection::setConstraints()" << endl); + delete m_constr; + m_constr=cons; +} + +const LDAPConstraints* LDAPAsynConnection::getConstraints() const { + DEBUG(LDAP_DEBUG_TRACE,"LDAPAsynConnection::getConstraints()" << endl); + return m_constr; +} + +TlsOptions LDAPAsynConnection::getTlsOptions() const { + return TlsOptions( cur_session ); +} + +LDAP* LDAPAsynConnection::getSessionHandle() const{ + DEBUG(LDAP_DEBUG_TRACE,"LDAPAsynConnection::getSessionHandle()" << endl); + return cur_session; +} + +const string& LDAPAsynConnection::getHost() const{ + DEBUG(LDAP_DEBUG_TRACE,"LDAPAsynConnection::setHost()" << endl); + return m_uri.getHost(); +} + +int LDAPAsynConnection::getPort() const{ + DEBUG(LDAP_DEBUG_TRACE,"LDAPAsynConnection::getPort()" << endl); + return m_uri.getPort(); +} + +LDAPAsynConnection* LDAPAsynConnection::referralConnect( + const LDAPUrlList& urls, LDAPUrlList::const_iterator& usedUrl, + const LDAPConstraints* cons) const { + DEBUG(LDAP_DEBUG_TRACE, "LDAPAsynConnection::referralConnect()" << endl) + LDAPUrlList::const_iterator conUrl; + LDAPAsynConnection* tmpConn=0; + const LDAPRebind* rebind = cons->getReferralRebind(); + LDAPRebindAuth* auth = 0; + + for(conUrl=urls.begin(); conUrl!=urls.end(); conUrl++){ + string host= conUrl->getHost(); + int port= conUrl->getPort(); + DEBUG(LDAP_DEBUG_TRACE," connecting to: " << host << ":" << + port << endl); + //Set the new connection's constraints-object ? + tmpConn=new LDAPAsynConnection(host.c_str(),port); + int err=0; + + if(rebind){ + auth=rebind->getRebindAuth(host, port); + } + if(auth){ + string dn = auth->getDN(); + string passwd = auth->getPassword(); + const char* c_dn=0; + struct berval c_passwd = { 0, 0 }; + if(dn != ""){ + c_dn = dn.c_str(); + } + if(passwd != ""){ + c_passwd.bv_val = const_cast<char*>(passwd.c_str()); + c_passwd.bv_len = passwd.size(); + } + err = ldap_sasl_bind_s(tmpConn->getSessionHandle(), c_dn, + LDAP_SASL_SIMPLE, &c_passwd, NULL, NULL, NULL); + } else { + // Do anonymous bind + err = ldap_sasl_bind_s(tmpConn->getSessionHandle(),NULL, + LDAP_SASL_SIMPLE, NULL, NULL, NULL, NULL); + } + if( err == LDAP_SUCCESS ){ + usedUrl=conUrl; + return tmpConn; + }else{ + delete tmpConn; + tmpConn=0; + } + auth=0; + } + return 0; +} + diff --git a/contrib/ldapc++/src/LDAPAsynConnection.h b/contrib/ldapc++/src/LDAPAsynConnection.h new file mode 100644 index 0000000..ba2016e --- /dev/null +++ b/contrib/ldapc++/src/LDAPAsynConnection.h @@ -0,0 +1,338 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + + +#ifndef LDAP_ASYN_CONNECTION_H +#define LDAP_ASYN_CONNECTION_H + +#include<iostream> +#include<string> + +#include<ldap.h> + +#include <LDAPEntry.h> +#include <LDAPException.h> +#include <LDAPMessageQueue.h> +#include <LDAPConstraints.h> +#include <LDAPModification.h> +#include <LDAPModList.h> +#include <LDAPUrl.h> +#include <LDAPUrlList.h> +#include <SaslInteractionHandler.h> +#include <TlsOptions.h> + +//* Main class for an asynchronous LDAP connection +/** + * This class represents an asynchronous connection to an LDAP-Server. It + * provides the methods for authentication, and all other LDAP-Operations + * (e.g. search, add, delete, etc.) + * All of the LDAP-Operations return a pointer to a LDAPMessageQueue-Object, + * which can be used to obtain the results of that operation. + * A basic example of this class could be like this: <BR> + * 1. Create a new LDAPAsynConnection Object: <BR> + * 2. Use the init-method to initialize the connection <BR> + * 3. Call the bind-method to authenticate to the directory <BR> + * 4. Obtain the bind results from the return LDAPMessageQueue-Object <BR> + * 5. Perform on of the operations on the directory (add, delete, search, ..) + * <BR> + * 6. Use the return LDAPMessageQueue to obtain the results of the operation + * <BR> + * 7. Close the connection (feature not implemented yet :) ) <BR> + */ +class LDAPAsynConnection{ + public : + /** + * Constant for the Search-Operation to indicate a Base-Level + * Search + */ + static const int SEARCH_BASE=0; + + /** + * Constant for the Search-Operation to indicate a One-Level + * Search + */ + static const int SEARCH_ONE=1; + + /** + * Constant for the Search-Operation to indicate a subtree + * Search + */ + static const int SEARCH_SUB=2; + + /** Constructor that initializes a connection to a server + * @param hostname Name (or IP-Address) of the destination host + * @param port Port the LDAP server is running on + * @param cons Default constraints to use with operations over + * this connection + */ + LDAPAsynConnection(const std::string& url=std::string("localhost"), + int port=0, LDAPConstraints *cons=new LDAPConstraints() ); + + //* Destructor + virtual ~LDAPAsynConnection(); + /** + * Initializes a connection to a server. + * + * There actually no + * communication to the server. Just the object is initialized + * (e.g. this method is called within the + * LDAPAsynConnection(char*,int,LDAPConstraints) constructor.) + * @param hostname The Name or IP-Address of the destination + * LDAP-Server + * @param port The Network Port the server is running on + */ + void init(const std::string& hostname, int port); + + /** + * Initializes a connection to a server. + * + * There actually no communication to the server. Just the + * object is initialized + * @param uri The LDAP-Uri for the destination + */ + void initialize(const std::string& uri); + + /** + * Start TLS on this connection. This isn't in the constructor, + * because it could fail (i.e. server doesn't have SSL cert, client + * api wasn't compiled against OpenSSL, etc.). + * @throws LDAPException if the TLS Layer could not be setup + * correctly + */ + void start_tls(); + + /** Simple authentication to a LDAP-Server + * + * @throws LDAPException If the Request could not be sent to the + * destination server, a LDAPException-object contains the + * error that occurred. + * This method does a simple (username, password) bind to the server. + * Other, saver, authentcation methods are provided later + * @param dn the distinguished name to bind as + * @param passwd cleartext password to use + */ + LDAPMessageQueue* bind(const std::string& dn="", + const std::string& passwd="", + const LDAPConstraints *cons=0); + + LDAPMessageQueue* saslBind(const std::string& mech, + const std::string& cred, + const LDAPConstraints *cons=0); + + LDAPMessageQueue* saslInteractiveBind(const std::string& mech, + int flags=0, + SaslInteractionHandler *sih=0, + const LDAPConstraints *cons=0); + + /** Performing a search on a directory tree. + * + * Use the search method to perform a search on the LDAP-Directory + * @throws LDAPException If the Request could not be sent to the + * destination server, a LDAPException-object contains the + * error that occurred. + * @param base The distinguished name of the starting point for the + * search operation + * @param scope The scope of the search. Possible values: <BR> + * LDAPAsynConnection::SEARCH_BASE, <BR> + * LDAPAsynConnection::SEARCH_ONE, <BR> + * LDAPAsynConnection::SEARCH_SUB + * @param filter The std::string representation of a search filter to + * use with this operation + * @param attrsOnly true if only the attributes names (no values) + * should be returned + * @param cons A set of constraints that should be used with this + * request + */ + LDAPMessageQueue* search(const std::string& base="", int scope=0, + const std::string& filter="objectClass=*", + const StringList& attrs=StringList(), + bool attrsOnly=false, + const LDAPConstraints *cons=0); + + /** Delete an entry from the directory + * + * This method sends a delete request to the server + * @throws LDAPException If the Request could not be sent to the + * destination server, a LDAPException-object contains the + * error that occurred. + * @param dn Distinguished name of the entry that should be deleted + * @param cons A set of constraints that should be used with this + * request + */ + LDAPMessageQueue* del(const std::string& dn, const LDAPConstraints *cons=0); + + /** + * Perform the COMPARE-operation on an attribute + * + * @throws LDAPException If the Request could not be sent to the + * destination server, a LDAPException-object contains the + * error that occurred. + * @param dn Distinguished name of the entry for which the compare + * should be performed + * @param attr An Attribute (one (!) value) to use for the + * compare operation + * @param cons A set of constraints that should be used with this + * request + */ + LDAPMessageQueue* compare(const std::string& dn, + const LDAPAttribute& attr, + const LDAPConstraints *cons=0); + + /** Add an entry to the directory + * + * @throws LDAPException If the Request could not be sent to the + * destination server, a LDAPException-object contains the + * error that occurred. + * @param le The entry that will be added to the directory + */ + LDAPMessageQueue* add( const LDAPEntry* le, + const LDAPConstraints *const=0); + + /** Apply modifications to attributes of an entry + * + * @throws LDAPException If the Request could not be sent to the + * destination server, a LDAPException-object contains the + * error that occurred. + * @param dn Distinguished Name of the Entry to modify + * @param modlist A set of modification that should be applied + * to the Entry + * @param cons A set of constraints that should be used with this + * request + */ + LDAPMessageQueue* modify(const std::string& dn, + const LDAPModList *modlist, + const LDAPConstraints *cons=0); + + /** modify the DN of an entry + * + * @throws LDAPException If the Request could not be sent to the + * destination server, a LDAPException-object contains the + * error that occurred. + * @param dn DN to modify + * @param newRDN The new relative DN for the entry + * @param delOldRDN true=The old RDN will be removed from the + * attributes <BR> + * false=The old RDN will still be present in the + * attributes of the entry + * @param newParentDN The DN of the new parent entry of the entry + * 0 to keep the old one + */ + LDAPMessageQueue* rename(const std::string& dn, + const std::string& newRDN, + bool delOldRDN=false, const std::string& newParentDN="", + const LDAPConstraints* cons=0); + + /** Perform a LDAP extended Operation + * + * @throws LDAPException If the Request could not be sent to the + * destination server, a LDAPException-object contains the + * error that occurred. + * @param oid The dotted decimal representation of the extended + * Operation that should be performed + * @param value The data associated with this operation + * @param cons A set of constraints that should be used with this + * request + */ + LDAPMessageQueue* extOperation(const std::string& oid, + const std::string& value="", const LDAPConstraints *cons=0); + + /** End an outstanding request + * + * @param q All outstanding request related to this LDAPMessageQueue + * will be abandoned + */ + void abandon(LDAPMessageQueue *q); + + /** + * Performs the UNBIND-operation on the destination server + * + * @throws LDAPException in any case of an error + */ + void unbind(); + + /** + * @returns The C-APIs LDAP-structure that is associated with the + * current connection + */ + LDAP* getSessionHandle() const ; + + /** + * @returns The Hostname of the destination server of the + * connection. + */ + const std::string& getHost() const; + + /** + * @returns The Port to which this connection is connecting to on + * the remote server. + */ + int getPort() const; + + /** Change the default constraints of the connection + * + * @parameter cons cons New LDAPConstraints to use with the connection + */ + void setConstraints(LDAPConstraints *cons); + + /** Get the default constraints of the connection + * + * @return Pointer to the LDAPConstraints-Object that is currently + * used with the Connection + */ + const LDAPConstraints* getConstraints() const; + TlsOptions getTlsOptions() const; + /** + * This method is used internally for automatic referral chasing. + * It tries to bind to a destination server of the URLs of a + * referral. + * + * @throws LDAPException in any case of an error + * @param urls Contains a std::list of LDAP-Urls that indicate the + * destinations of a referral + * @param usedUrl After this method has successfully bind to one of + * the Destination URLs this parameter contains the URLs + * which was contacted. + * @param cons An LDAPConstraints-Object that should be used for + * the new connection. If this object contains a + * LDAPRebind-object it is used to bind to the new server + */ + LDAPAsynConnection* referralConnect(const LDAPUrlList& urls, + LDAPUrlList::const_iterator& usedUrl, + const LDAPConstraints* cons) const; + + private : + /** + * Private copy constructor. So nobody can call it. + */ + LDAPAsynConnection(const LDAPAsynConnection& lc){}; + + /** + * A pointer to the C-API LDAP-structure that is associated with + * this connection + */ + LDAP *cur_session; + + /** + * A pointer to the default LDAPConstrains-object that is used when + * no LDAPConstraints-parameter is provided with a call for a + * LDAP-operation + */ + LDAPConstraints *m_constr; + + /** + * The URI of this connection + */ + LDAPUrl m_uri; + + protected: + /** + * Is caching enabled? + */ + bool m_cacheEnabled; +}; +#endif //LDAP_ASYN_CONNECTION_H + + diff --git a/contrib/ldapc++/src/LDAPAttrType.cpp b/contrib/ldapc++/src/LDAPAttrType.cpp new file mode 100644 index 0000000..5f5d829 --- /dev/null +++ b/contrib/ldapc++/src/LDAPAttrType.cpp @@ -0,0 +1,148 @@ +// $OpenLDAP$ +/* + * Copyright 2003-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#include "debug.h" +#include "LDAPAttrType.h" + + +LDAPAttrType::LDAPAttrType(){ + DEBUG(LDAP_DEBUG_CONSTRUCT, + "LDAPAttrType::LDAPAttrType( )" << endl); + + oid = string (); + desc = string (); + names = StringList (); + single = false; + usage = 0; +} + +LDAPAttrType::LDAPAttrType (string at_item, int flags ) { + + DEBUG(LDAP_DEBUG_CONSTRUCT, + "LDAPAttrType::LDAPAttrType( )" << endl); + + LDAPAttributeType *a; + int ret; + const char *errp; + a = ldap_str2attributetype (at_item.c_str(), &ret, &errp, flags); + + if (a) { + this->setNames( a->at_names ); + this->setDesc( a->at_desc ); + this->setOid( a->at_oid ); + this->setSingle( a->at_single_value ); + this->setUsage( a->at_usage ); + this->setSuperiorOid( a->at_sup_oid ); + this->setEqualityOid( a->at_equality_oid ); + this->setOrderingOid( a->at_ordering_oid ); + this->setSubstringOid( a->at_substr_oid ); + this->setSyntaxOid( a->at_syntax_oid ); + } + // else? -> error +} + +LDAPAttrType::~LDAPAttrType() { + DEBUG(LDAP_DEBUG_DESTROY,"LDAPAttrType::~LDAPAttrType()" << endl); +} + +void LDAPAttrType::setSingle (int at_single) { + single = (at_single == 1); +} + +void LDAPAttrType::setNames ( char **at_names ) { + names = StringList(at_names); +} + +void LDAPAttrType::setDesc (const char *at_desc) { + desc = string (); + if (at_desc) + desc = at_desc; +} + +void LDAPAttrType::setOid (const char *at_oid) { + oid = string (); + if (at_oid) + oid = at_oid; +} + +void LDAPAttrType::setUsage (int at_usage) { + usage = at_usage; +} + +void LDAPAttrType::setSuperiorOid( const char *oid ){ + if ( oid ) + superiorOid = oid; +} + +void LDAPAttrType::setEqualityOid( const char *oid ){ + if ( oid ) + equalityOid = oid; +} + +void LDAPAttrType::setOrderingOid( const char *oid ){ + if ( oid ) + orderingOid = oid; +} + +void LDAPAttrType::setSubstringOid( const char *oid ){ + if ( oid ) + substringOid = oid; +} + +void LDAPAttrType::setSyntaxOid( const char *oid ){ + if ( oid ) + syntaxOid = oid; +} + +bool LDAPAttrType::isSingle() const { + return single; +} + +string LDAPAttrType::getOid() const { + return oid; +} + +string LDAPAttrType::getDesc() const { + return desc; +} + +StringList LDAPAttrType::getNames() const { + return names; +} + +string LDAPAttrType::getName() const { + + if (names.empty()) + return ""; + else + return *(names.begin()); +} + +int LDAPAttrType::getUsage() const { + return usage; +} + +std::string LDAPAttrType::getSuperiorOid() const { + return superiorOid; +} + +std::string LDAPAttrType::getEqualityOid() const { + return equalityOid; +} + +std::string LDAPAttrType::getOrderingOid() const { + return orderingOid; +} + +std::string LDAPAttrType::getSubstringOid() const { + return substringOid; +} + +std::string LDAPAttrType::getSyntaxOid() const { + return syntaxOid; +} + + diff --git a/contrib/ldapc++/src/LDAPAttrType.h b/contrib/ldapc++/src/LDAPAttrType.h new file mode 100644 index 0000000..34948cc --- /dev/null +++ b/contrib/ldapc++/src/LDAPAttrType.h @@ -0,0 +1,101 @@ +// $OpenLDAP$ +/* + * Copyright 2003-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#ifndef LDAP_ATTRTYPE_H +#define LDAP_ATTRTYPE_H + +#include <ldap_schema.h> +#include <string> + +#include "StringList.h" + +using namespace std; + +/** + * Represents the Attribute Type (from LDAP schema) + */ +class LDAPAttrType{ + private : + StringList names; + std::string desc, oid, superiorOid, equalityOid; + std::string orderingOid, substringOid, syntaxOid; + bool single; + int usage; + + public : + + /** + * Constructor + */ + LDAPAttrType(); + + /** + * Constructs new object and fills the data structure by parsing the + * argument. + * @param at_item description of attribute type is string returned + * by the search command. It is in the form: + * "( SuSE.YaST.Attr:19 NAME ( 'skelDir' ) DESC '' + * EQUALITY caseExactIA5Match SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 )" + */ + LDAPAttrType (string at_item, int flags = LDAP_SCHEMA_ALLOW_NO_OID | + LDAP_SCHEMA_ALLOW_QUOTED ); + + /** + * Destructor + */ + virtual ~LDAPAttrType(); + + + /** + * Returns attribute description + */ + string getDesc() const; + + /** + * Returns attribute oid + */ + string getOid() const; + + /** + * Returns attribute name (first one if there are more of them) + */ + string getName() const; + + /** + * Returns all attribute names + */ + StringList getNames() const; + + /** + * Returns true if attribute type allows only single value + */ + bool isSingle() const; + + /** + * Return the 'usage' value: + * (0=userApplications, 1=directoryOperation, 2=distributedOperation, + * 3=dSAOperation) + */ + int getUsage () const; + std::string getSuperiorOid() const; + std::string getEqualityOid() const; + std::string getOrderingOid() const; + std::string getSubstringOid() const; + std::string getSyntaxOid() const; + + void setNames( char **at_names); + void setDesc(const char *at_desc); + void setOid(const char *at_oid); + void setSingle(int at_single_value); + void setUsage(int at_usage ); + void setSuperiorOid( const char *oid ); + void setEqualityOid( const char *oid ); + void setOrderingOid( const char *oid ); + void setSubstringOid( const char *oid ); + void setSyntaxOid( const char *oid ); +}; + +#endif // LDAP_ATTRTYPE_H diff --git a/contrib/ldapc++/src/LDAPAttribute.cpp b/contrib/ldapc++/src/LDAPAttribute.cpp new file mode 100644 index 0000000..d6689ff --- /dev/null +++ b/contrib/ldapc++/src/LDAPAttribute.cpp @@ -0,0 +1,199 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + + +//TODO!!! +// * some kind of iterator to step through the attribute values +// * remove values from Attribute +// * handling of subtypes (;de; and so on) +// * some documentation + + +#include <ldap.h> +#include <cstdlib> + +#include "debug.h" +#include "StringList.h" + +#include "LDAPAttribute.h" + +using namespace std; + +LDAPAttribute::LDAPAttribute(){ + DEBUG(LDAP_DEBUG_CONSTRUCT, "LDAPAttribute::LDAPAttribute( )" << endl); + m_name=string(); +} + +LDAPAttribute::LDAPAttribute(const LDAPAttribute& attr){ + DEBUG(LDAP_DEBUG_CONSTRUCT, "LDAPAttribute::LDAPAttribute(&)" << endl); + DEBUG(LDAP_DEBUG_CONSTRUCT | LDAP_DEBUG_PARAMETER, + " attr:" << attr << endl); + m_name=attr.m_name; + m_values=StringList(attr.m_values); +} + +LDAPAttribute::LDAPAttribute(const string& name, const string& value){ + DEBUG(LDAP_DEBUG_CONSTRUCT, "LDAPAttribute::LDAPAttribute()" << endl); + DEBUG(LDAP_DEBUG_CONSTRUCT | LDAP_DEBUG_PARAMETER, + " name:" << name << endl << " value:" << value << endl); + this->setName(name); + if(value != ""){ + this->addValue(value); + } +} + + +LDAPAttribute::LDAPAttribute(const string& name, const StringList& values){ + DEBUG(LDAP_DEBUG_CONSTRUCT, "LDAPAttribute::LDAPAttribute()" << endl); + DEBUG(LDAP_DEBUG_CONSTRUCT | LDAP_DEBUG_PARAMETER, + " name:" << name << endl); + m_name=name; + m_values=values; +} + +LDAPAttribute::LDAPAttribute(const char *name, char **values){ + DEBUG(LDAP_DEBUG_CONSTRUCT, "LDAPAttribute::LDAPAttribute()" << endl); + DEBUG(LDAP_DEBUG_CONSTRUCT | LDAP_DEBUG_PARAMETER, + " name:" << name << endl); + this->setName(name); + this->setValues(values); +} + +LDAPAttribute::LDAPAttribute(const char *name, BerValue **values){ + DEBUG(LDAP_DEBUG_CONSTRUCT, "LDAPAttribute::LDAPAttribute()" << endl); + DEBUG(LDAP_DEBUG_CONSTRUCT | LDAP_DEBUG_PARAMETER, + " name:" << name << endl); + this->setName(name); + this->setValues(values); +} + +LDAPAttribute::~LDAPAttribute(){ + DEBUG(LDAP_DEBUG_DESTROY,"LDAPAttribute::~LDAPAttribute()" << endl); +} + +void LDAPAttribute::addValue(const string& value){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPAttribute::addValue()" << endl); + m_values.add(value); +} + +int LDAPAttribute::addValue(const BerValue *value){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPAttribute::addValue()" << endl); + if(value!=0){ + this->addValue(string(value->bv_val, value->bv_len)); + return 0; + } + return -1; +} + +int LDAPAttribute::setValues(char **values){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPAttribute::setValues()" << endl); + if(values){ + m_values.clear(); + for( char **i=values; *i!=0; i++){ + this->addValue(*i); + } + } + return 0; +} + +int LDAPAttribute::setValues(BerValue **values){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPAttribute::setValues()" << endl); + if(values){ + m_values.clear(); + for( BerValue **i=values; *i!=0; i++){ + if( this->addValue(*i) ){ + return -1; + } + } + } + return 0; +} + +void LDAPAttribute::setValues(const StringList& values){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPAttribute::setValues()" << endl); + m_values=values; +} + +const StringList& LDAPAttribute::getValues() const{ + DEBUG(LDAP_DEBUG_TRACE,"LDAPAttribute::getValues()" << endl); + return m_values; +} + +BerValue** LDAPAttribute::getBerValues() const{ + DEBUG(LDAP_DEBUG_TRACE,"LDAPAttribute::getBerValues()" << endl); + size_t size=m_values.size(); + if (size == 0){ + return 0; + }else{ + BerValue **temp = (BerValue**) malloc(sizeof(BerValue*) * (size+1)); + StringList::const_iterator i; + int p=0; + + for(i=m_values.begin(), p=0; i!=m_values.end(); i++,p++){ + temp[p]=(BerValue*) malloc(sizeof(BerValue)); + temp[p]->bv_len= i->size(); + temp[p]->bv_val= (char*) malloc(sizeof(char) * (i->size()+1)); + i->copy(temp[p]->bv_val,string::npos); + } + temp[size]=0; + return temp; + } +} + +int LDAPAttribute::getNumValues() const{ + DEBUG(LDAP_DEBUG_TRACE,"LDAPAttribute::getNumValues()" << endl); + return m_values.size(); +} + +const string& LDAPAttribute::getName() const { + DEBUG(LDAP_DEBUG_TRACE, "LDAPAttribute::getName()" << endl); + return m_name; +} + +void LDAPAttribute::setName(const string& name){ + DEBUG(LDAP_DEBUG_TRACE, "LDAPAttribute::setName()" << endl); + DEBUG(LDAP_DEBUG_TRACE | LDAP_DEBUG_PARAMETER," name:" << name << endl); + m_name.erase(); + m_name=name; +} + +// The bin-FLAG of the mod_op is always set to LDAP_MOD_BVALUES (0x80) +LDAPMod* LDAPAttribute::toLDAPMod() const { + DEBUG(LDAP_DEBUG_TRACE, "LDAPAttribute::toLDAPMod()" << endl); + LDAPMod* ret= (LDAPMod*) malloc(sizeof(LDAPMod)); + ret->mod_op=LDAP_MOD_BVALUES; //always assume binary-Values + ret->mod_type= (char*) malloc(sizeof(char) * (m_name.size()+1)); + m_name.copy(ret->mod_type,string::npos); + ret->mod_type[m_name.size()]=0; + ret->mod_bvalues=this->getBerValues(); + return ret; +} + +bool LDAPAttribute::isNotPrintable() const { + StringList::const_iterator i; + for(i=m_values.begin(); i!=m_values.end(); i++){ + size_t len = i->size(); + for(size_t j=0; j<len; j++){ + if (! isprint( (i->data())[j] ) ){ + return true; + } + } + } + return false; +} + +ostream& operator << (ostream& s, const LDAPAttribute& attr){ + s << attr.m_name << "="; + StringList::const_iterator i; + if (attr.isNotPrintable()){ + s << "NOT_PRINTABLE" ; + }else{ + for(i=attr.m_values.begin(); i!=attr.m_values.end(); i++){ + s << *i << " "; + } + } + return s; +} diff --git a/contrib/ldapc++/src/LDAPAttribute.h b/contrib/ldapc++/src/LDAPAttribute.h new file mode 100644 index 0000000..e978137 --- /dev/null +++ b/contrib/ldapc++/src/LDAPAttribute.h @@ -0,0 +1,181 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + + +#ifndef LDAP_ATTRIBUTE_H +#define LDAP_ATTRIBUTE_H + +#include<iostream> +#include<string> +#include<ldap.h> +#include<lber.h> + +#include <StringList.h> + +/** + * Represents the name an value(s) of an Attribute + */ +class LDAPAttribute{ + public : + /** + * Default constructor. + * initializes an empty object. + */ + LDAPAttribute(); + + /** + * Copy constructor. + * Copies all values of an Attribute to a new one + * @param attr The Attribute that should be copied + */ + LDAPAttribute(const LDAPAttribute& attr); + + /** + * Construct an Attribute with a single string value + * @param name The attribute's name (type) + * @param value The string value of the attribute, if "" the + * attribute will have no values, for LDAPv3 + * this values must be UTF-8 encoded + */ + LDAPAttribute(const std::string& name, const std::string& value=""); + + /** + * Construct an attribute with multiple string values + * @param name The attribute's name (type) + * @param values A 0-terminated array of char*. Each char* specifies + * one value of the attribute (UTF-8 encoded) + */ + LDAPAttribute(const char* name, char **values); + + /** + * Construct an attribute with multiple string values + * @param name The attribute's name (type) + * @param values A list of strings. Each element specifies + * one value of the attribute (UTF-8 or binary + * encoded) + */ + LDAPAttribute(const std::string& name, const StringList& values); + + /** + * Construct an attribute with multiple binary coded values + * @param name The attribute's name (type) + * @param values 0-terminated array of binary attribute values + * The BerValue struct is declared as:<BR> + * struct berval{ + * unsigned long bv_len; + * char *bv_val; + * } BerValue; + */ + LDAPAttribute(const char* name, BerValue **values); + + /** + * Destructor + */ + ~LDAPAttribute(); + + /** + * Add a single string value(bin/char) to the Attribute + * @param value Value that should be added, it is copied inside the + * object + */ + void addValue(const std::string& value); + + /** + * Add a single binary value to the Attribute + * @param value The binary coded value that should be added to the + * Attribute. + * @return 0 no problem <BR> + * -1 failure (mem. allocation problem) + */ + int addValue(const BerValue *value); + + /** + * Set the values of the attribute. If the object contains some values + * already, they are deleted + * @param values 0-terminated array of char*, each char* + * representing a string value to add to the entry + * + * @return 0 no problem <BR> + * -1 failure (mem. allocation problem) + */ + int setValues(char** values); + + /** + * Set the values of the attribute. If the object does already contain + * some values, they will be deleted + * @param values 0-terminated array of BerValue*, each BerValue + * representing a binary value to add to the entry + * + * @return 0 no problem <BR> + * -1 failure (mem. allocation problem) + */ + int setValues(BerValue** values); + + /** + * Set the values of the attribute. If the object does already contain + * some values, they will be deleted + * @param values A list of string-Objects. Each string is + * representing a string or binary value to add to + * the entry + */ + void setValues(const StringList& values); + + /** + * For internal use only. + * This method is used to translate the values of the Attribute to + * 0-terminated Array of BerValue-structs as used by the C-API + * @return The Values of the Attribute as an 0-terminated Array of + * BerValue* (is dynamically allocated, delete it after usage) + * <BR> + * 0-pointer in case of error + */ + BerValue** getBerValues() const; + + /** + * @return The values of the array as a list of strings + */ + const StringList& getValues() const; + + /** + * @return The number of values of the attribute + */ + int getNumValues() const; + + /** + * @return The name(type) of the attribute + */ + const std::string& getName() const ; + + /** + * Sets the Attribute's name (type) + * @param the new name of the object + */ + void setName(const std::string& name); + + /** + * For internal use only. + * + * This method translate the attribute of the object into a + * LDAPMod-Structure as used by the C-API + */ + LDAPMod* toLDAPMod() const ; + + /** + * @return true If the attribute contains non-printable attributes + */ + bool isNotPrintable() const ; + + private : + std::string m_name; + StringList m_values; + + /** + * This method can be used to dump the data of a LDAPResult-Object. + * It is only useful for debugging purposes at the moment + */ + friend std::ostream& operator << (std::ostream& s, const LDAPAttribute& attr); +}; +#endif //#ifndef LDAP_ATTRIBUTE_H diff --git a/contrib/ldapc++/src/LDAPAttributeList.cpp b/contrib/ldapc++/src/LDAPAttributeList.cpp new file mode 100644 index 0000000..9752191 --- /dev/null +++ b/contrib/ldapc++/src/LDAPAttributeList.cpp @@ -0,0 +1,193 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + + +#include "debug.h" + +#include "LDAPAttributeList.h" + +#include "LDAPException.h" +#include "LDAPAttribute.h" +#include "LDAPAsynConnection.h" +#include "LDAPMessage.h" + +#include <cstdlib> + +using namespace std; + +// little helper function for doing case insensitive string comparison +bool nocase_compare(char c1, char c2); + +LDAPAttributeList::LDAPAttributeList(){ + DEBUG(LDAP_DEBUG_CONSTRUCT, + "LDAPAttributeList::LDAPAttributeList( )" << endl); +} + +LDAPAttributeList::LDAPAttributeList(const LDAPAttributeList& al){ + DEBUG(LDAP_DEBUG_CONSTRUCT, + "LDAPAttributeList::LDAPAttributeList(&)" << endl); + m_attrs=al.m_attrs; +} + +LDAPAttributeList::LDAPAttributeList(const LDAPAsynConnection *ld, + LDAPMessage *msg){ + DEBUG(LDAP_DEBUG_CONSTRUCT, + "LDAPAttributeList::LDAPAttributeList()" << endl); + BerElement *ptr=0; + char *name=ldap_first_attribute(ld->getSessionHandle(), msg, &ptr); +/* + This code was making problems if no attribute were returned + How am I supposed to find decoding errors? ldap_first/next_attribute + return 0 in case of error or if there are no more attributes. In either + case they set the LDAP* error code to 0x54 (Decoding error) ??? Strange.. + + There will be some changes in the new version of the C-API so that this + code should work in the future. + if(name == 0){ + ber_free(ptr,0); + ldap_memfree(name); + throw LDAPException(ld); + }else{ +*/ BerValue **values; + for (;name !=0; + name=ldap_next_attribute(ld->getSessionHandle(),msg,ptr) ){ + values=ldap_get_values_len(ld->getSessionHandle(), + msg, name); + this->addAttribute(LDAPAttribute(name, values)); + ldap_memfree(name); + ldap_value_free_len(values); + } + ber_free(ptr,0); +// } +} + +LDAPAttributeList::~LDAPAttributeList(){ + DEBUG(LDAP_DEBUG_DESTROY,"LDAPAttributeList::~LDAPAttributeList()" << endl); +} + +size_t LDAPAttributeList::size() const{ + DEBUG(LDAP_DEBUG_TRACE,"LDAPAttribute::size()" << endl); + return m_attrs.size(); +} + +bool LDAPAttributeList::empty() const{ + DEBUG(LDAP_DEBUG_TRACE,"LDAPAttribute::empty()" << endl); + return m_attrs.empty(); +} + +LDAPAttributeList::const_iterator LDAPAttributeList::begin() const{ + DEBUG(LDAP_DEBUG_TRACE,"LDAPAttribute::begin()" << endl); + return m_attrs.begin(); +} + +LDAPAttributeList::const_iterator LDAPAttributeList::end() const{ + DEBUG(LDAP_DEBUG_TRACE,"LDAPAttribute::end()" << endl); + return m_attrs.end(); +} + +const LDAPAttribute* LDAPAttributeList::getAttributeByName( + const string& name) const { + DEBUG(LDAP_DEBUG_TRACE,"LDAPAttribute::getAttributeByName()" << endl); + DEBUG(LDAP_DEBUG_TRACE | LDAP_DEBUG_PARAMETER, + " name:" << name << endl); + LDAPAttributeList::const_iterator i; + for( i = m_attrs.begin(); i != m_attrs.end(); i++){ + const std::string& tmpType = i->getName(); + if(name.size() == tmpType.size()){ + if(equal(name.begin(), name.end(), tmpType.begin(), + nocase_compare)){ + return &(*i); + DEBUG(LDAP_DEBUG_TRACE," found:" << name << endl); + } + } + } + return 0; +} + +void LDAPAttributeList::addAttribute(const LDAPAttribute& attr){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPAttribute::addAttribute()" << endl); + DEBUG(LDAP_DEBUG_TRACE | LDAP_DEBUG_PARAMETER, + " attr:" << attr << endl); + const std::string attrType = attr.getName(); + const std::string::size_type attrLen = attrType.size(); + std::string::size_type tmpAttrLen = 0; + bool done=false; + LDAPAttributeList::iterator i; + for( i=m_attrs.begin(); i != m_attrs.end(); i++ ){ + const std::string tmpAttrType = i->getName(); + tmpAttrLen = tmpAttrType.size(); + if(tmpAttrLen == attrLen){ + if(equal(tmpAttrType.begin(), tmpAttrType.end(), attrType.begin(), + nocase_compare)){ + const StringList& values = attr.getValues(); + StringList::const_iterator j; + for(j = values.begin(); j != values.end(); j++){ + i->addValue(*j); + } + DEBUG(LDAP_DEBUG_TRACE,"Attribute" << i->getName() + << "already present" << endl); + done=true; + break; // The AttributeType was already present, + // we are done here + } + } + } + if(! done){ + m_attrs.push_back(attr); + } +} + +void LDAPAttributeList::delAttribute(const std::string& type) +{ + DEBUG(LDAP_DEBUG_TRACE,"LDAPAttribute::replaceAttribute()" << endl); + DEBUG(LDAP_DEBUG_TRACE | LDAP_DEBUG_PARAMETER, " type: " << type << endl); + LDAPAttributeList::iterator i; + for( i = m_attrs.begin(); i != m_attrs.end(); i++){ + if(type.size() == i->getName().size()){ + if(equal(type.begin(), type.end(), i->getName().begin(), + nocase_compare)){ + m_attrs.erase(i); + break; + } + } + } +} + +void LDAPAttributeList::replaceAttribute(const LDAPAttribute& attr) +{ + DEBUG(LDAP_DEBUG_TRACE,"LDAPAttribute::replaceAttribute()" << endl); + DEBUG(LDAP_DEBUG_TRACE | LDAP_DEBUG_PARAMETER, + " attr:" << attr << endl); + + LDAPAttributeList::iterator i; + this->delAttribute( attr.getName() ); + m_attrs.push_back(attr); +} + +LDAPMod** LDAPAttributeList::toLDAPModArray() const{ + DEBUG(LDAP_DEBUG_TRACE,"LDAPAttribute::toLDAPModArray()" << endl); + LDAPMod **ret = (LDAPMod**) malloc((m_attrs.size()+1) * sizeof(LDAPMod*)); + LDAPAttributeList::const_iterator i; + int j=0; + for (i=m_attrs.begin(); i!= m_attrs.end(); i++, j++){ + ret[j]=i->toLDAPMod(); + } + ret[m_attrs.size()]=0; + return ret; +} + +ostream& operator << (ostream& s, const LDAPAttributeList& al){ + LDAPAttributeList::const_iterator i; + for(i=al.m_attrs.begin(); i!=al.m_attrs.end(); i++){ + s << *i << "; "; + } + return s; +} + +bool nocase_compare( char c1, char c2){ + return toupper(c1) == toupper(c2); +} + diff --git a/contrib/ldapc++/src/LDAPAttributeList.h b/contrib/ldapc++/src/LDAPAttributeList.h new file mode 100644 index 0000000..f03275e --- /dev/null +++ b/contrib/ldapc++/src/LDAPAttributeList.h @@ -0,0 +1,121 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + + +#ifndef LDAP_ATTRIBUTE_LIST_H +#define LDAP_ATTRIBUTE_LIST_H + +#include <ldap.h> +#include <list> +#include <string> + +class LDAPAttribute; +class LDAPAsynConnection; +class LDAPMsg; + +/** + * This container class is used to store multiple LDAPAttribute-objects. + */ +class LDAPAttributeList{ + typedef std::list<LDAPAttribute> ListType; + + private : + ListType m_attrs; + + public : + typedef ListType::const_iterator const_iterator; + typedef ListType::iterator iterator; + + + /** + * Copy-constructor + */ + LDAPAttributeList(const LDAPAttributeList& al); + + /** + * For internal use only + * + * This constructor is used by the library internally to create a + * list of attributes from a LDAPMessage-struct that was return by + * the C-API + */ + LDAPAttributeList(const LDAPAsynConnection *ld, LDAPMessage *msg); + + /** + * Constructs an empty list. + */ + LDAPAttributeList(); + + /** + * Destructor + */ + virtual ~LDAPAttributeList(); + + /** + * @return The number of LDAPAttribute-objects that are currently + * stored in this list. + */ + size_t size() const; + + /** + * @return true if there are zero LDAPAttribute-objects currently + * stored in this list. + */ + bool empty() const; + + /** + * @return A iterator that points to the first element of the list. + */ + const_iterator begin() const; + + /** + * @return A iterator that points to the element after the last + * element of the list. + */ + const_iterator end() const; + + /** + * Get an Attribute by its AttributeType + * @param name The name of the Attribute to look for + * @return a pointer to the LDAPAttribute with the AttributeType + * "name" or 0, if there is no Attribute of that Type + */ + const LDAPAttribute* getAttributeByName(const std::string& name) const; + + /** + * Adds one element to the end of the list. + * @param attr The attribute to add to the list. + */ + void addAttribute(const LDAPAttribute& attr); + + /** + * Deletes all values of an Attribute for the list + * @param type The attribute type to be deleted. + */ + void delAttribute(const std::string& type); + + /** + * Replace an Attribute in the List + * @param attr The attribute to add to the list. + */ + void replaceAttribute(const LDAPAttribute& attr); + + /** + * Translates the list of Attributes to a 0-terminated array of + * LDAPMod-structures as needed by the C-API + */ + LDAPMod** toLDAPModArray() const; + + /** + * This method can be used to dump the data of a LDAPResult-Object. + * It is only useful for debugging purposes at the moment + */ + friend std::ostream& operator << (std::ostream& s, + const LDAPAttributeList& al); +}; + +#endif // LDAP_ATTRIBUTE_LIST_H + diff --git a/contrib/ldapc++/src/LDAPBindRequest.cpp b/contrib/ldapc++/src/LDAPBindRequest.cpp new file mode 100644 index 0000000..a67a0e1 --- /dev/null +++ b/contrib/ldapc++/src/LDAPBindRequest.cpp @@ -0,0 +1,173 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#include <ldap.h> + +#include "debug.h" + +#include "LDAPBindRequest.h" +#include "LDAPException.h" +#include "SaslInteractionHandler.h" +#include "SaslInteraction.h" + +#include <cstdlib> +#include <sasl/sasl.h> + +using namespace std; + +LDAPBindRequest::LDAPBindRequest(const LDAPBindRequest& req) : + LDAPRequest(req){ + DEBUG(LDAP_DEBUG_CONSTRUCT, "LDAPBindRequest::LDAPBindRequest(&)" << endl); + m_dn=req.m_dn; + m_cred=req.m_cred; + m_mech=req.m_mech; +} + +LDAPBindRequest::LDAPBindRequest(const string& dn,const string& passwd, + LDAPAsynConnection *connect, const LDAPConstraints *cons, + bool isReferral) : LDAPRequest(connect, cons, isReferral){ + DEBUG(LDAP_DEBUG_CONSTRUCT,"LDAPBindRequest::LDAPBindRequest()" << endl); + DEBUG(LDAP_DEBUG_CONSTRUCT | LDAP_DEBUG_PARAMETER, " dn:" << dn << endl + << " passwd:" << passwd << endl); + m_dn = dn; + m_cred = passwd; + m_mech = ""; +} + +LDAPBindRequest::~LDAPBindRequest(){ + DEBUG(LDAP_DEBUG_DESTROY,"LDAPBindRequest::~LDAPBindRequest()" << endl); +} + +LDAPMessageQueue* LDAPBindRequest::sendRequest(){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPBindRequest::sendRequest()" << endl); + int msgID=0; + + const char* mech = (m_mech == "" ? 0 : m_mech.c_str()); + BerValue* tmpcred=0; + if(m_cred != ""){ + char* tmppwd = (char*) malloc( (m_cred.size()+1) * sizeof(char)); + m_cred.copy(tmppwd,string::npos); + tmppwd[m_cred.size()]=0; + tmpcred=ber_bvstr(tmppwd); + }else{ + tmpcred=(BerValue*) malloc(sizeof(BerValue)); + tmpcred->bv_len=0; + tmpcred->bv_val=0; + } + const char* dn = 0; + if(m_dn != ""){ + dn = m_dn.c_str(); + } + LDAPControl** tmpSrvCtrls=m_cons->getSrvCtrlsArray(); + LDAPControl** tmpClCtrls=m_cons->getClCtrlsArray(); + int err=ldap_sasl_bind(m_connection->getSessionHandle(),dn, + mech, tmpcred, tmpSrvCtrls, tmpClCtrls, &msgID); + LDAPControlSet::freeLDAPControlArray(tmpSrvCtrls); + LDAPControlSet::freeLDAPControlArray(tmpClCtrls); + ber_bvfree(tmpcred); + + if(err != LDAP_SUCCESS){ + throw LDAPException(err); + }else{ + m_msgID=msgID; + return new LDAPMessageQueue(this); + } +} + +LDAPSaslBindRequest::LDAPSaslBindRequest(const std::string& mech, + const std::string& cred, + LDAPAsynConnection *connect, + const LDAPConstraints *cons, + bool isReferral) : LDAPRequest(connect, cons, isReferral),m_mech(mech), m_cred(cred) {} + +LDAPMessageQueue* LDAPSaslBindRequest::sendRequest() +{ + DEBUG(LDAP_DEBUG_TRACE,"LDAPSaslBindRequest::sendRequest()" << endl); + int msgID=0; + + BerValue tmpcred; + tmpcred.bv_val = (char*) malloc( m_cred.size() * sizeof(char)); + m_cred.copy(tmpcred.bv_val,string::npos); + tmpcred.bv_len = m_cred.size(); + + LDAPControl** tmpSrvCtrls=m_cons->getSrvCtrlsArray(); + LDAPControl** tmpClCtrls=m_cons->getClCtrlsArray(); + int err=ldap_sasl_bind(m_connection->getSessionHandle(), "", m_mech.c_str(), + &tmpcred, tmpSrvCtrls, tmpClCtrls, &msgID); + LDAPControlSet::freeLDAPControlArray(tmpSrvCtrls); + LDAPControlSet::freeLDAPControlArray(tmpClCtrls); + free(tmpcred.bv_val); + + if(err != LDAP_SUCCESS){ + throw LDAPException(err); + }else{ + m_msgID=msgID; + return new LDAPMessageQueue(this); + } +} + +LDAPSaslBindRequest::~LDAPSaslBindRequest() +{ + DEBUG(LDAP_DEBUG_DESTROY,"LDAPSaslBindRequest::~LDAPSaslBindRequest()" << endl); +} + +LDAPSaslInteractiveBind::LDAPSaslInteractiveBind( const std::string& mech, + int flags, SaslInteractionHandler *sih, LDAPAsynConnection *connect, + const LDAPConstraints *cons, bool isReferral) : + LDAPRequest(connect, cons, isReferral), + m_mech(mech), m_flags(flags), m_sih(sih), m_res(0) +{ +} + +static int my_sasl_interact(LDAP *l, unsigned flags, void *cbh, void *interact) +{ + DEBUG(LDAP_DEBUG_TRACE, "LDAPSaslInteractiveBind::my_sasl_interact()" + << std::endl ); + std::list<SaslInteraction*> interactions; + + sasl_interact_t *iter = (sasl_interact_t*) interact; + while ( iter->id != SASL_CB_LIST_END ) { + SaslInteraction *si = new SaslInteraction(iter); + interactions.push_back( si ); + iter++; + } + ((SaslInteractionHandler*)cbh)->handleInteractions(interactions); + return LDAP_SUCCESS; +} + +/* This kind of fakes an asynchronous operation, ldap_sasl_interactive_bind_s + * is synchronous */ +LDAPMessageQueue *LDAPSaslInteractiveBind::sendRequest() +{ + DEBUG(LDAP_DEBUG_TRACE, "LDAPSaslInteractiveBind::sendRequest()" << + m_mech << std::endl); + + LDAPControl** tmpSrvCtrls=m_cons->getSrvCtrlsArray(); + LDAPControl** tmpClCtrls=m_cons->getClCtrlsArray(); + int res = ldap_sasl_interactive_bind_s( m_connection->getSessionHandle(), + "", m_mech.c_str(), tmpSrvCtrls, tmpClCtrls, m_flags, + my_sasl_interact, m_sih ); + + DEBUG(LDAP_DEBUG_TRACE, "ldap_sasl_interactive_bind_s returned: " + << res << std::endl); + if(res != LDAP_SUCCESS){ + throw LDAPException(res); + } else { + m_res = new LDAPResult(LDAPMsg::BIND_RESPONSE, res, ""); + } + return new LDAPMessageQueue(this); +} + +LDAPMsg* LDAPSaslInteractiveBind::getNextMessage() const +{ + return m_res; +} + +LDAPSaslInteractiveBind::~LDAPSaslInteractiveBind() +{ + DEBUG(LDAP_DEBUG_DESTROY,"LDAPSaslInteractiveBind::~LDAPSaslInteractiveBind()" << endl); +} + diff --git a/contrib/ldapc++/src/LDAPBindRequest.h b/contrib/ldapc++/src/LDAPBindRequest.h new file mode 100644 index 0000000..efadffb --- /dev/null +++ b/contrib/ldapc++/src/LDAPBindRequest.h @@ -0,0 +1,61 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#ifndef LDAP_BIND_REQUEST_H +#define LDAP_BIND_REQUEST_H + +#include <LDAPRequest.h> +#include <LDAPResult.h> +#include <SaslInteractionHandler.h> + +class LDAPBindRequest : LDAPRequest { + private: + std::string m_dn; + std::string m_cred; + std::string m_mech; + + public: + LDAPBindRequest( const LDAPBindRequest& req); + //just for simple authentication + LDAPBindRequest(const std::string&, const std::string& passwd, + LDAPAsynConnection *connect, const LDAPConstraints *cons, + bool isReferral=false); + virtual ~LDAPBindRequest(); + virtual LDAPMessageQueue *sendRequest(); +}; + +class LDAPSaslBindRequest : LDAPRequest +{ + public: + LDAPSaslBindRequest( const std::string& mech, const std::string& cred, + LDAPAsynConnection *connect, const LDAPConstraints *cons, + bool isReferral=false); + virtual LDAPMessageQueue *sendRequest(); + virtual ~LDAPSaslBindRequest(); + + private: + std::string m_mech; + std::string m_cred; +}; + +class LDAPSaslInteractiveBind : LDAPRequest +{ + public: + LDAPSaslInteractiveBind( const std::string& mech, int flags, + SaslInteractionHandler *sih, LDAPAsynConnection *connect, + const LDAPConstraints *cons, bool isReferral=false); + virtual LDAPMessageQueue *sendRequest(); + virtual LDAPMsg* getNextMessage() const; + virtual ~LDAPSaslInteractiveBind(); + + private: + std::string m_mech; + int m_flags; + SaslInteractionHandler *m_sih; + LDAPResult *m_res; +}; +#endif //LDAP_BIND_REQUEST_H + diff --git a/contrib/ldapc++/src/LDAPCompareRequest.cpp b/contrib/ldapc++/src/LDAPCompareRequest.cpp new file mode 100644 index 0000000..4edc646 --- /dev/null +++ b/contrib/ldapc++/src/LDAPCompareRequest.cpp @@ -0,0 +1,79 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#include <ldap.h> + +#include "debug.h" + +#include "LDAPCompareRequest.h" +#include "LDAPException.h" +#include "LDAPMessageQueue.h" +#include "LDAPResult.h" + +using namespace std; + +LDAPCompareRequest::LDAPCompareRequest(const LDAPCompareRequest& req){ + DEBUG(LDAP_DEBUG_CONSTRUCT, + "LDAPCompareRequest::LDAPCompareRequest(&)" << endl); + m_dn=req.m_dn; + m_attr=req.m_attr; +} + +LDAPCompareRequest::LDAPCompareRequest(const string& dn, + const LDAPAttribute& attr, LDAPAsynConnection *connect, + const LDAPConstraints *cons, bool isReferral, + const LDAPRequest* parent) : + LDAPRequest(connect, cons, isReferral,parent){ + DEBUG(LDAP_DEBUG_CONSTRUCT, "LDAPCompareRequest::LDAPCompareRequest()" + << endl); + DEBUG(LDAP_DEBUG_CONSTRUCT | LDAP_DEBUG_PARAMETER, " dn:" << dn << endl + << " attr:" << attr << endl); + m_requestType=LDAPRequest::COMPARE; + m_dn=dn; + m_attr=attr; +} + +LDAPCompareRequest::~LDAPCompareRequest(){ + DEBUG(LDAP_DEBUG_DESTROY, "LDAPCompareRequest::~LDAPCompareRequest()" + << endl); +} + +LDAPMessageQueue* LDAPCompareRequest::sendRequest(){ + DEBUG(LDAP_DEBUG_TRACE, "LDAPCompareRequest::sendRequest()" << endl); + int msgID=0; + BerValue **val=m_attr.getBerValues(); + LDAPControl** tmpSrvCtrls=m_cons->getSrvCtrlsArray(); + LDAPControl** tmpClCtrls=m_cons->getClCtrlsArray(); + int err=ldap_compare_ext(m_connection->getSessionHandle(),m_dn.c_str(), + m_attr.getName().c_str(), val[0], tmpSrvCtrls, + tmpClCtrls, &msgID); + ber_bvecfree(val); + LDAPControlSet::freeLDAPControlArray(tmpSrvCtrls); + LDAPControlSet::freeLDAPControlArray(tmpClCtrls); + if(err != LDAP_SUCCESS){ + throw LDAPException(err); + }else{ + m_msgID=msgID; + return new LDAPMessageQueue(this); + } +} + +LDAPRequest* LDAPCompareRequest::followReferral(LDAPMsg* ref){ + DEBUG(LDAP_DEBUG_TRACE, "LDAPCompareRequest::followReferral()" << endl); + LDAPUrlList::const_iterator usedUrl; + LDAPUrlList urls = ((LDAPResult*)ref)->getReferralUrls(); + LDAPAsynConnection* con = 0; + try{ + con=getConnection()->referralConnect(urls,usedUrl,m_cons); + }catch(LDAPException e){ + return 0; + } + if(con != 0){ + return new LDAPCompareRequest(m_dn, m_attr, con, m_cons, true, this); + } + return 0; +} + diff --git a/contrib/ldapc++/src/LDAPCompareRequest.h b/contrib/ldapc++/src/LDAPCompareRequest.h new file mode 100644 index 0000000..3202e04 --- /dev/null +++ b/contrib/ldapc++/src/LDAPCompareRequest.h @@ -0,0 +1,31 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#ifndef LDAP_COMPARE_REQUEST_H +#define LDAP_COMPARE_REQUEST_H + +#include <LDAPRequest.h> + +class LDAPMessageQueue; + +class LDAPCompareRequest : public LDAPRequest { + public : + LDAPCompareRequest(const LDAPCompareRequest& req); + LDAPCompareRequest(const std::string& dn, const LDAPAttribute& attr, + LDAPAsynConnection *connect, const LDAPConstraints *cons, + bool isReferral=false, const LDAPRequest* parent=0); + virtual ~LDAPCompareRequest(); + virtual LDAPMessageQueue* sendRequest(); + virtual LDAPRequest* followReferral(LDAPMsg* urls); + + private : + std::string m_dn; + LDAPAttribute m_attr; + +}; +#endif //LDAP_COMPARE_REQUEST_H + + diff --git a/contrib/ldapc++/src/LDAPConnection.cpp b/contrib/ldapc++/src/LDAPConnection.cpp new file mode 100644 index 0000000..77111a1 --- /dev/null +++ b/contrib/ldapc++/src/LDAPConnection.cpp @@ -0,0 +1,382 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#include "debug.h" + +#include "LDAPResult.h" +#include "LDAPException.h" +#include "LDAPUrlList.h" + +#include "LDAPConnection.h" +const int LDAPConnection::SEARCH_BASE = LDAPAsynConnection::SEARCH_BASE; +const int LDAPConnection::SEARCH_ONE = LDAPAsynConnection::SEARCH_ONE; +const int LDAPConnection::SEARCH_SUB = LDAPAsynConnection::SEARCH_SUB; + +using namespace std; + +LDAPConnection::LDAPConnection(const string& hostname, int port, + LDAPConstraints* cons) : + LDAPAsynConnection(hostname, port, cons){ +} + +LDAPConnection::~LDAPConnection(){ +} + +void LDAPConnection::start_tls(){ + LDAPAsynConnection::start_tls(); +} + +void LDAPConnection::bind(const string& dn, const string& passwd, + LDAPConstraints* cons){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPConnection::bind" << endl); + LDAPMessageQueue* msg=0; + LDAPResult* res=0; + try{ + msg = LDAPAsynConnection::bind(dn,passwd,cons); + res = (LDAPResult*)msg->getNext(); + }catch(LDAPException e){ + delete msg; + delete res; + throw; + } + int resCode=res->getResultCode(); + if(resCode != LDAPResult::SUCCESS) { + if(resCode == LDAPResult::REFERRAL){ + LDAPUrlList urls = res->getReferralUrls(); + delete res; + delete msg; + throw LDAPReferralException(urls); + }else{ + string srvMsg = res->getErrMsg(); + delete res; + delete msg; + throw LDAPException(resCode, srvMsg); + } + } + delete res; + delete msg; // memcheck +} + +void LDAPConnection::saslInteractiveBind( const std::string &mech, + int flags, + SaslInteractionHandler *sih, + const LDAPConstraints *cons) +{ + DEBUG(LDAP_DEBUG_TRACE,"LDAPConnection::bind" << endl); + LDAPMessageQueue* msg=0; + LDAPResult* res=0; + try{ + msg = LDAPAsynConnection::saslInteractiveBind(mech, flags, sih, cons); + res = (LDAPResult*)msg->getNext(); + }catch(LDAPException e){ + delete msg; + delete res; + throw; + } + int resCode=res->getResultCode(); + if(resCode != LDAPResult::SUCCESS) { + if(resCode == LDAPResult::REFERRAL){ + LDAPUrlList urls = res->getReferralUrls(); + delete res; + delete msg; + throw LDAPReferralException(urls); + }else{ + string srvMsg = res->getErrMsg(); + delete res; + delete msg; + throw LDAPException(resCode, srvMsg); + } + } + delete res; + delete msg; +} + +void LDAPConnection::unbind(){ + LDAPAsynConnection::unbind(); +} + +bool LDAPConnection::compare(const string& dn, const LDAPAttribute& attr, + LDAPConstraints* cons){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPConnection::compare" << endl); + LDAPMessageQueue* msg=0; + LDAPResult* res=0; + try{ + msg = LDAPAsynConnection::compare(dn,attr,cons); + res = (LDAPResult*)msg->getNext(); + }catch(LDAPException e){ + delete msg; + delete res; + throw; + } + int resCode=res->getResultCode(); + switch (resCode){ + case LDAPResult::COMPARE_TRUE : + delete res; + delete msg; + return true; + break; + case LDAPResult::COMPARE_FALSE : + delete res; + delete msg; + return false; + break; + case LDAPResult::REFERRAL : + { + LDAPUrlList urls = res->getReferralUrls(); + delete res; + delete msg; + throw LDAPReferralException(urls); + } + break; + default : + string srvMsg = res->getErrMsg(); + delete res; + delete msg; + throw LDAPException(resCode, srvMsg); + } +} + +void LDAPConnection::del(const string& dn, const LDAPConstraints* cons){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPConnection::del" << endl); + LDAPMessageQueue* msg=0; + LDAPResult* res=0; + try{ + msg = LDAPAsynConnection::del(dn,cons); + res = (LDAPResult*)msg->getNext(); + }catch(LDAPException e){ + delete msg; + delete res; + throw; + } + int resCode=res->getResultCode(); + switch (resCode){ + case LDAPResult::SUCCESS : + delete res; + delete msg; + break; + case LDAPResult::REFERRAL : + { + LDAPUrlList urls = res->getReferralUrls(); + delete res; + delete msg; + throw LDAPReferralException(urls); + } + break; + default : + string srvMsg = res->getErrMsg(); + delete res; + delete msg; + throw LDAPException(resCode, srvMsg); + } + +} + +void LDAPConnection::add(const LDAPEntry* le, const LDAPConstraints* cons){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPConnection::add" << endl); + LDAPMessageQueue* msg=0; + LDAPResult* res=0; + try{ + msg = LDAPAsynConnection::add(le,cons); + res = (LDAPResult*)msg->getNext(); + }catch(LDAPException e){ + delete msg; + delete res; + throw; + } + int resCode=res->getResultCode(); + switch (resCode){ + case LDAPResult::SUCCESS : + delete res; + delete msg; + break; + case LDAPResult::REFERRAL : + { + LDAPUrlList urls = res->getReferralUrls(); + delete res; + delete msg; + throw LDAPReferralException(urls); + } + break; + default : + string srvMsg = res->getErrMsg(); + delete res; + delete msg; + throw LDAPException(resCode, srvMsg); + } +} + +void LDAPConnection::modify(const string& dn, const LDAPModList* mods, + const LDAPConstraints* cons){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPConnection::modify" << endl); + LDAPMessageQueue* msg=0; + LDAPResult* res=0; + try{ + msg = LDAPAsynConnection::modify(dn,mods,cons); + res = (LDAPResult*)msg->getNext(); + }catch(LDAPException e){ + delete msg; + delete res; + throw; + } + int resCode=res->getResultCode(); + switch (resCode){ + case LDAPResult::SUCCESS : + delete res; + delete msg; + break; + case LDAPResult::REFERRAL : + { + LDAPUrlList urls = res->getReferralUrls(); + delete res; + delete msg; + throw LDAPReferralException(urls); + } + break; + default : + string srvMsg = res->getErrMsg(); + delete res; + delete msg; + throw LDAPException(resCode, srvMsg); + } + +} + +void LDAPConnection::rename(const string& dn, const string& newRDN, + bool delOldRDN, const string& newParentDN, + const LDAPConstraints* cons){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPConnection::rename" << endl); + LDAPMessageQueue* msg=0; + LDAPResult* res=0; + try{ + msg = LDAPAsynConnection::rename(dn,newRDN,delOldRDN, newParentDN, + cons); + res = (LDAPResult*)msg->getNext(); + }catch(LDAPException e){ + delete msg; + delete res; + throw; + } + int resCode=res->getResultCode(); + switch (resCode){ + case LDAPResult::SUCCESS : + delete res; + delete msg; + break; + case LDAPResult::REFERRAL : + { + LDAPUrlList urls = res->getReferralUrls(); + delete res; + delete msg; + throw LDAPReferralException(urls); + } + break; + default : + string srvMsg = res->getErrMsg(); + delete res; + delete msg; + throw LDAPException(resCode, srvMsg); + } +} + +LDAPSearchResults* LDAPConnection::search(const string& base, int scope, + const string& filter, const StringList& attrs, bool attrsOnly, + const LDAPConstraints* cons){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPConnection::search" << endl); + LDAPMessageQueue* msgq=0; + LDAPResult* res=0; + LDAPSearchResults* results= 0; + + try{ + results = new LDAPSearchResults(); + msgq = LDAPAsynConnection::search(base,scope, filter, attrs, attrsOnly, + cons); + res = results->readMessageQueue(msgq); + }catch(LDAPException e){ + delete results; // memcheck + delete msgq; + throw; + } + if(res != 0){ + int resCode=res->getResultCode(); + switch (resCode){ + case LDAPResult::SUCCESS : + delete res; + delete msgq; + return results; + break; + case LDAPResult::REFERRAL : + { + LDAPUrlList urls = res->getReferralUrls(); + delete results; // memcheck + delete res; + delete msgq; + throw LDAPReferralException(urls); + } + break; + default : + string srvMsg = res->getErrMsg(); + delete results; // memcheck + delete res; + delete msgq; + throw LDAPException(resCode, srvMsg); + } + } + return 0; +} + +LDAPExtResult* LDAPConnection::extOperation(const string& oid, + const string& value, const LDAPConstraints *cons){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPConnection::extOperation" << endl); + LDAPMessageQueue* msg=0; + LDAPExtResult* res=0; + try{ + msg = LDAPAsynConnection::extOperation(oid,value,cons); + res = (LDAPExtResult*)msg->getNext(); + }catch(LDAPException e){ + delete msg; + delete res; + throw; + } + int resCode=res->getResultCode(); + switch (resCode){ + case LDAPResult::SUCCESS : + delete msg; + return res; + case LDAPResult::REFERRAL : + { + LDAPUrlList urls = res->getReferralUrls(); + delete res; + delete msg; + throw LDAPReferralException(urls); + } + break; + default : + string srvMsg = res->getErrMsg(); + delete res; + delete msg; + throw LDAPException(resCode, srvMsg); + } +} + +const string& LDAPConnection::getHost() const{ + return LDAPAsynConnection::getHost(); +} + +int LDAPConnection::getPort() const{ + return LDAPAsynConnection::getPort(); +} + +void LDAPConnection::setConstraints(LDAPConstraints* cons){ + LDAPAsynConnection::setConstraints(cons); +} + +const LDAPConstraints* LDAPConnection::getConstraints() const{ + return LDAPAsynConnection::getConstraints(); +} + +TlsOptions LDAPConnection::getTlsOptions() const { + return LDAPAsynConnection::getTlsOptions(); +} diff --git a/contrib/ldapc++/src/LDAPConnection.h b/contrib/ldapc++/src/LDAPConnection.h new file mode 100644 index 0000000..e2d7ccc --- /dev/null +++ b/contrib/ldapc++/src/LDAPConnection.h @@ -0,0 +1,241 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#ifndef LDAP_CONNECTION_H +#define LDAP_CONNECTION_H + +#include <LDAPSearchResults.h> +#include <LDAPExtResult.h> +#include <LDAPAsynConnection.h> + +/** Main class for synchronous LDAP-Communication + * + * The class represent a LDAP-Connection to perform synchronous + * LDAP-Operations. This provides methods for the different + * LDAP-Operations. All the methods for the LDAP-operations block until + * all results for the operation are received or until an error occurs + */ +class LDAPConnection : private LDAPAsynConnection { + + public : + /** + * Constant for the Search-Operation to indicate a Base-Level + * Search + */ + static const int SEARCH_BASE; + + /** + * Constant for the Search-Operation to indicate a One-Level + * Search + */ + static const int SEARCH_ONE; + + /** + * Constant for the Search-Operation to indicate a Subtree + * Search + */ + static const int SEARCH_SUB; + + /** This Constructor initializes synchronous LDAP-Connection + * + * During execution of this constructor no network communication + * is performed. Just some internal data structure are initialized + * @param hostname Name (or IP-Address) of the destination host + * @param port Port the LDAP server is running on + * @param cons Default constraints to use with operations over + * this connection + */ + LDAPConnection(const std::string& hostname="localhost", int port=389, + LDAPConstraints* cons=new LDAPConstraints()); + + /** + * Destructor + */ + ~LDAPConnection(); + + /** + * Initializes a synchronous connection to a server. + * + * There is actually no + * communication to the server. Just the object is initialized + * (e.g. this method is called within the + * LDAPConnection(char*,int,LDAPConstraints) constructor.) + * @param hostname The Name or IP-Address of the destination + * LDAP-Server + * @param port The Network Port the server is running on + */ + void init(const std::string& hostname, int port); + + /** + * Start TLS on this connection. This isn't in the constructor, + * because it could fail (i.e. server doesn't have SSL cert, client + * api wasn't compiled against OpenSSL, etc.). + * @throws LDAPException if the TLS Layer could not be setup + * correctly + */ + void start_tls(); + + /** + * Performs a simple authentication with the server + * + * @throws LDAPReferralException if a referral is received + * @throws LDAPException for any other error occurring during the + * operation + * @param dn The name of the entry to bind as + * @param passwd The cleartext password for the entry + */ + void bind(const std::string& dn="", const std::string& passwd="", + LDAPConstraints* cons=0); + void saslInteractiveBind(const std::string& mech, + int flags=0, + SaslInteractionHandler *sih=0, + const LDAPConstraints *cons=0); + + /** + * Performs the UNBIND-operation on the destination server + * + * @throws LDAPException in any case of an error + */ + void unbind(); + + /** + * Performs a COMPARE-operation on an entry of the destination + * server. + * + * @throws LDAPReferralException if a referral is received + * @throws LDAPException for any other error occurring during the + * operation + * @param dn Distinguished name of the entry for which the compare + * should be performed + * @param attr An Attribute (one (!) value) to use for the + * compare operation + * @param cons A set of constraints that should be used with this + * request + * @returns The result of the compare operation. true if the + * attr-parameter matched an Attribute of the entry. false if it + * did not match + */ + bool compare(const std::string& dn, const LDAPAttribute& attr, + LDAPConstraints* cons=0); + + /** + * Deletes an entry from the directory + * + * This method performs the DELETE operation on the server + * @throws LDAPReferralException if a referral is received + * @throws LDAPException for any other error occurring during the + * operation + * @param dn Distinguished name of the entry that should be deleted + * @param cons A set of constraints that should be used with this + * request + */ + void del(const std::string& dn, const LDAPConstraints* cons=0); + + /** + * Use this method to perform the ADD-operation + * + * @throws LDAPReferralException if a referral is received + * @throws LDAPException for any other error occurring during the + * operation + * @param le the entry to add to the directory + * @param cons A set of constraints that should be used with this + * request + */ + void add(const LDAPEntry* le, const LDAPConstraints* cons=0); + + /** + * To modify the attributes of an entry, this method can be used + * + * @throws LDAPReferralException if a referral is received + * @throws LDAPException for any other error occurring during the + * operation + * @param dn The DN of the entry which should be modified + * @param mods A set of modifications for that entry. + * @param cons A set of constraints that should be used with this + * request + */ + void modify(const std::string& dn, const LDAPModList* mods, + const LDAPConstraints* cons=0); + + /** + * This method performs the ModDN-operation. + * + * It can be used to rename or move an entry by modifying its DN. + * + * @throws LDAPReferralException if a referral is received + * @throws LDAPException for any other error occurring during the + * operation + * @param dn The DN that should be modified + * @param newRDN If the RDN of the entry should be modified the + * new RDN can be put here. + * @param delOldRDN If the old RDN should be removed from the + * entry's attribute this parameter has to be + * "true" + * @param newParentDN If the entry should be moved inside the + * DIT, the DN of the new parent of the entry + * can be given here. + * @param cons A set of constraints that should be used with this + * request + */ + void rename(const std::string& dn, const std::string& newRDN, + bool delOldRDN=false, const std::string& newParentDN="", + const LDAPConstraints* cons=0); + + /** + * This method can be used for the sync. SEARCH-operation. + * + * @throws LDAPReferralException if a referral is received + * @throws LDAPException for any other error occurring during the + * operation + * @param base The distinguished name of the starting point for the + * search + * @param scope The scope of the search. Possible values: <BR> + * LDAPAsynConnection::SEARCH_BASE, <BR> + * LDAPAsynConnection::SEARCH_ONE, <BR> + * LDAPAsynConnection::SEARCH_SUB + * @param filter The std::string representation of a search filter to + * use with this operation + * @param attrsOnly true if only the attributes names (no values) + * should be returned + * @param cons A set of constraints that should be used with this + * request + * @returns A pointer to a LDAPSearchResults-object that can be + * used to read the results of the search. + */ + LDAPSearchResults* search(const std::string& base, int scope=0, + const std::string& filter="objectClass=*", + const StringList& attrs=StringList(), bool attrsOnly=false, + const LDAPConstraints* cons=0); + + /** + * This method is for extended LDAP-Operations. + * + * @throws LDAPReferralException if a referral is received + * @throws LDAPException for any other error occurring during the + * operation + * @param oid The Object Identifier of the Extended Operation that + * should be performed. + * @param strint If the Extended Operation needs some additional + * data it can be passed to the server by this parameter. + * @param cons A set of constraints that should be used with this + * request + * @returns The result of the Extended Operation as an + * pointer to a LDAPExtResult-object. + */ + LDAPExtResult* extOperation(const std::string& oid, const std::string& + value="", const LDAPConstraints *const = 0); + + const std::string& getHost() const; + + int getPort() const; + + void setConstraints(LDAPConstraints *cons); + + const LDAPConstraints* getConstraints() const ; + TlsOptions getTlsOptions() const; +}; + +#endif //LDAP_CONNECTION_H diff --git a/contrib/ldapc++/src/LDAPConstraints.cpp b/contrib/ldapc++/src/LDAPConstraints.cpp new file mode 100644 index 0000000..c91d7ca --- /dev/null +++ b/contrib/ldapc++/src/LDAPConstraints.cpp @@ -0,0 +1,178 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + + +#include "debug.h" +#include "config.h" +#include "ac/time.h" +#include "LDAPConstraints.h" +#include "LDAPControlSet.h" + +using namespace std; + +LDAPConstraints::LDAPConstraints(){ + DEBUG(LDAP_DEBUG_CONSTRUCT,"LDAPConstraints::LDAPConstraints()" << endl); + m_aliasDeref=LDAPConstraints::DEREF_NEVER; + m_maxTime=LDAP_NO_LIMIT; + m_maxSize=LDAP_NO_LIMIT; + m_referralChase=false; + m_HopLimit=7; + m_serverControls=0; + m_clientControls=0; + m_refRebind=0; +} + +LDAPConstraints::LDAPConstraints(const LDAPConstraints& c){ + DEBUG(LDAP_DEBUG_CONSTRUCT,"LDAPConstraints::LDAPConstraints(&)" << endl); + m_aliasDeref=c.m_aliasDeref; + m_maxTime=c.m_maxTime; + m_maxSize=c.m_maxSize; + m_referralChase=c.m_referralChase; + m_HopLimit=c.m_HopLimit; + m_deref=c.m_deref; + if(c.m_serverControls){ + m_serverControls=new LDAPControlSet(*c.m_serverControls); + }else{ + m_serverControls=0; + } + if(c.m_clientControls){ + m_clientControls=new LDAPControlSet(*c.m_clientControls); + }else{ + m_clientControls=0; + } + m_refRebind=c.m_refRebind; +} + +LDAPConstraints::~LDAPConstraints(){ + DEBUG(LDAP_DEBUG_DESTROY,"LDAPConstraints::~LDAPConstraints()" << endl); + delete m_clientControls; + delete m_serverControls; +} + +void LDAPConstraints::setAliasDeref(int deref){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPConstraints::setAliasDeref()" << endl); + DEBUG(LDAP_DEBUG_TRACE | LDAP_DEBUG_PARAMETER, + " deref:" << deref << endl); + if( (deref == LDAPConstraints::DEREF_NEVER) || + (deref == LDAPConstraints::DEREF_SEARCHING) || + (deref == LDAPConstraints::DEREF_FINDING) || + (deref == LDAPConstraints::DEREF_ALWAYS) + ){ + m_aliasDeref=deref; + } +} + + +void LDAPConstraints::setMaxTime(int t){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPConstraints::setMaxTime()" << endl); + DEBUG(LDAP_DEBUG_TRACE | LDAP_DEBUG_PARAMETER," time:" << t << endl); + m_maxTime=t; +} + +void LDAPConstraints::setSizeLimit(int s){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPConstraints::setSizeLimit()" << endl); + DEBUG(LDAP_DEBUG_TRACE | LDAP_DEBUG_PARAMETER," size:" << s << endl); + m_maxSize=s; +} + +void LDAPConstraints::setReferralChase(bool rc){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPConstraints::setReferralChase()" << endl); + DEBUG(LDAP_DEBUG_TRACE | LDAP_DEBUG_PARAMETER," rc:" << rc << endl); + m_referralChase=rc; +} + +void LDAPConstraints::setHopLimit(int limit){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPConstraints::setHopLimit()" << endl); + DEBUG(LDAP_DEBUG_TRACE | LDAP_DEBUG_PARAMETER, + " limit:" << limit << endl); + m_HopLimit=limit; +} + +void LDAPConstraints::setReferralRebind(const LDAPRebind* rebind){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPConstraints::setReferralRebind()" << endl); + m_refRebind = rebind; +} + +void LDAPConstraints::setServerControls(const LDAPControlSet* ctrls){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPConstraints::setServerControls()" << endl); + m_serverControls=new LDAPControlSet(*ctrls); +} + +void LDAPConstraints::setClientControls(const LDAPControlSet* ctrls){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPConstraints::setClientControls()" << endl); + m_clientControls=new LDAPControlSet(*ctrls); +} + +int LDAPConstraints::getAliasDeref() const { + DEBUG(LDAP_DEBUG_TRACE,"LDAPConstraints::getAliasDeref()" << endl); + return m_aliasDeref; +} + +int LDAPConstraints::getMaxTime() const { + DEBUG(LDAP_DEBUG_TRACE,"LDAPConstraints::getMaxTime()" << endl); + return m_maxTime; +} + +int LDAPConstraints::getSizeLimit() const { + DEBUG(LDAP_DEBUG_TRACE,"LDAPConstraints::getSizeLimit()" << endl); + return m_maxSize; +} + +const LDAPRebind* LDAPConstraints::getReferralRebind() const{ + DEBUG(LDAP_DEBUG_TRACE,"LDAPConstraints::getReferralRebind()" << endl); + return m_refRebind; +} + +const LDAPControlSet* LDAPConstraints::getServerControls() const{ + DEBUG(LDAP_DEBUG_TRACE,"LDAPConstraints::getServerControls()" << endl); + return m_serverControls; +} + +const LDAPControlSet* LDAPConstraints::getClientControls() const{ + DEBUG(LDAP_DEBUG_TRACE,"LDAPConstraints::getClientControls()" << endl); + return m_clientControls; +} + +LDAPControl** LDAPConstraints::getSrvCtrlsArray() const { + DEBUG(LDAP_DEBUG_TRACE,"LDAPConstraints::getSrvCtrlsArray()" << endl); + if(m_serverControls){ + return m_serverControls->toLDAPControlArray(); + }else{ + return 0; + } +} + +LDAPControl** LDAPConstraints::getClCtrlsArray() const { + DEBUG(LDAP_DEBUG_TRACE,"LDAPConstraints::getClCtrlsArray()" << endl); + if(m_clientControls){ + return m_clientControls->toLDAPControlArray(); + }else{ + return 0; + } +} + +timeval* LDAPConstraints::getTimeoutStruct() const { + DEBUG(LDAP_DEBUG_TRACE,"LDAPConstraints::getTimeoutStruct()" << endl); + if(m_maxTime == LDAP_NO_LIMIT){ + return 0; + }else{ + timeval *ret = new timeval; + ret->tv_sec=m_maxTime; + ret->tv_usec=0; + return ret; + } +} + +bool LDAPConstraints::getReferralChase() const { + DEBUG(LDAP_DEBUG_TRACE,"LDAPConstraints::getReferralChase()" << endl); + return m_referralChase; +} + +int LDAPConstraints::getHopLimit() const{ + DEBUG(LDAP_DEBUG_TRACE,"LDAPConstraints::getHopLimit()" << endl); + return m_HopLimit; +} + diff --git a/contrib/ldapc++/src/LDAPConstraints.h b/contrib/ldapc++/src/LDAPConstraints.h new file mode 100644 index 0000000..32f1d1d --- /dev/null +++ b/contrib/ldapc++/src/LDAPConstraints.h @@ -0,0 +1,98 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + + +#ifndef LDAP_CONSTRAINTS_H +#define LDAP_CONSTRAINTS_H +#include <list> + +#include <LDAPControl.h> +#include <LDAPControlSet.h> +#include <LDAPRebind.h> + +//TODO!! +// * implement the Alias-Handling Option (OPT_DEREF) +// * the Restart-Option ??? +// * default Server(s) + +//* Class for representing the various protocol options +/** This class represents some options that can be set for a LDAPConnection + * operation. Namely these are time and size limits. Options for referral + * chasing and a default set of client of server controls to be used with + * every request + */ +class LDAPConstraints{ + + public : + static const int DEREF_NEVER = 0x00; + static const int DEREF_SEARCHING = 0x01; + static const int DEREF_FINDING = 0x02; + static const int DEREF_ALWAYS = 0x04; + + //* Constructs a LDAPConstraints object with default values + LDAPConstraints(); + + //* Copy constructor + LDAPConstraints(const LDAPConstraints& c); + + ~LDAPConstraints(); + + void setAliasDeref(int deref); + void setMaxTime(int t); + void setSizeLimit(int s); + void setReferralChase(bool rc); + void setHopLimit(int hop); + void setReferralRebind(const LDAPRebind* rebind); + void setServerControls(const LDAPControlSet* ctrls); + void setClientControls(const LDAPControlSet* ctrls); + + int getAliasDeref() const; + int getMaxTime() const ; + int getSizeLimit() const; + const LDAPRebind* getReferralRebind() const; + const LDAPControlSet* getServerControls() const; + const LDAPControlSet* getClientControls() const; + + //*for internal use only + LDAPControl** getSrvCtrlsArray() const; + + //*for internal use only + LDAPControl** getClCtrlsArray() const; + + //*for internal use only + timeval* getTimeoutStruct() const; + bool getReferralChase() const ; + int getHopLimit() const; + + private : + int m_aliasDeref; + + //* max. time the server may spend for a search request + int m_maxTime; + + //* max number of entries to return from a search request + int m_maxSize; + + //* Flag for enabling automatic referral/reference chasing + bool m_referralChase; + + //* HopLimit for referral chasing + int m_HopLimit; + + //* Alias dereferencing option + int m_deref; + + //* Object used to do bind for Referral chasing + const LDAPRebind* m_refRebind; + + //* List of Client Controls that should be used for each request + LDAPControlSet* m_clientControls; + + //* List of Server Controls that should be used for each request + LDAPControlSet* m_serverControls; + +}; +#endif //LDAP_CONSTRAINTS_H diff --git a/contrib/ldapc++/src/LDAPControl.cpp b/contrib/ldapc++/src/LDAPControl.cpp new file mode 100644 index 0000000..7ca4445 --- /dev/null +++ b/contrib/ldapc++/src/LDAPControl.cpp @@ -0,0 +1,94 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + + +#include "LDAPControl.h" +#include "debug.h" + +using namespace std; + +LDAPCtrl::LDAPCtrl(const char *oid, bool critical, const char* data, + int length){ + DEBUG(LDAP_DEBUG_CONSTRUCT,"LDAPCtrl::LDAPCtrl()" << endl); + DEBUG(LDAP_DEBUG_CONSTRUCT | LDAP_DEBUG_PARAMETER, + " oid:" << oid << endl << " critical:" << critical << endl); + m_oid = oid; + m_isCritical=critical; + if (data != 0 && length !=0){ + m_data.assign(data,length); + m_noData=false; + }else{ + m_data=string(); + m_noData=true; + } +} + +LDAPCtrl::LDAPCtrl(const string& oid, bool critical, const string& data){ + DEBUG(LDAP_DEBUG_CONSTRUCT,"LDAPCtrl::LDAPCtrl()" << endl); + DEBUG(LDAP_DEBUG_CONSTRUCT | LDAP_DEBUG_PARAMETER, + " oid:" << oid << endl << " critical:" << critical << endl); + m_oid=oid; + m_isCritical=critical; + m_data=data; + m_noData=false; +} + +LDAPCtrl::LDAPCtrl(const LDAPControl* ctrl){ + DEBUG(LDAP_DEBUG_CONSTRUCT,"LDAPCtrl::LDAPCtrl()" << endl); + m_oid = string(ctrl->ldctl_oid); + m_isCritical = ctrl->ldctl_iscritical ? true : false; + m_data = string(ctrl->ldctl_value.bv_val, ctrl->ldctl_value.bv_len ); + m_noData = ctrl->ldctl_value.bv_len ? false : true; +} + +LDAPCtrl::~LDAPCtrl(){ + DEBUG(LDAP_DEBUG_DESTROY,"LDAPCtrl::~LDAPCtrl" << endl); +} + +string LDAPCtrl::getOID() const{ + DEBUG(LDAP_DEBUG_TRACE,"LDAPCtrl::getOID()" << endl); + return m_oid; +} + +bool LDAPCtrl::isCritical()const { + DEBUG(LDAP_DEBUG_TRACE,"LDAPCtrl::isCritical()" << endl); + return m_isCritical; +} + +bool LDAPCtrl::hasData() const{ + return !m_noData; +} + +string LDAPCtrl::getData() const { + DEBUG(LDAP_DEBUG_TRACE,"LDAPCtrl::getData()" << endl); + return m_data; +} + +LDAPControl* LDAPCtrl::getControlStruct() const { + DEBUG(LDAP_DEBUG_TRACE,"LDAPCtrl::getControlStruct()" << endl); + LDAPControl* ret = new LDAPControl; + ret->ldctl_oid= new char[m_oid.size() + 1]; + m_oid.copy(ret->ldctl_oid,string::npos); + ret->ldctl_oid[m_oid.size()]=0; + if ( m_noData ) { + ret->ldctl_value.bv_len = 0; + ret->ldctl_value.bv_val = NULL; + } else { + ret->ldctl_value.bv_len=m_data.size(); + ret->ldctl_value.bv_val= new char[m_data.size()]; + m_data.copy(ret->ldctl_value.bv_val,string::npos); + } + ret->ldctl_iscritical = ( m_isCritical ? 1:0); + return ret; +} + +void LDAPCtrl::freeLDAPControlStruct(LDAPControl *ctrl){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPCtrl::freeControlStruct()" << endl); + delete[] ctrl->ldctl_oid; + delete[] ctrl->ldctl_value.bv_val; + delete ctrl; +} + diff --git a/contrib/ldapc++/src/LDAPControl.h b/contrib/ldapc++/src/LDAPControl.h new file mode 100644 index 0000000..a8e0c94 --- /dev/null +++ b/contrib/ldapc++/src/LDAPControl.h @@ -0,0 +1,87 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + + +#ifndef LDAP_CONTROL_H +#define LDAP_CONTROL_H +#include <string> +#include <ldap.h> + +/** + * This class is used to store Controls. Controls are a mechanism to extend + * and modify LDAP-Operations. + */ +class LDAPCtrl{ + public : + /** + * Constructor. + * @param oid: The Object Identifier of the Control + * @param critical: "true" if the Control should be handled + * critical by the server. + * @param data: If there is data for the control, put it here. + * @param length: The length of the data field + */ + LDAPCtrl(const char *oid, bool critical=false, const char *data=0, + int length=0); + + /** + * Constructor. + * @param oid: The Object Identifier of the Control + * @param critical: "true" if the Control should be handled + * critical by the server. + * @param data: If there is data for the control, put it here. + */ + LDAPCtrl(const std::string& oid, bool critical, + const std::string& data); + + /** + * Creates a copy of the Control that "ctrl is pointing to + */ + LDAPCtrl(const LDAPControl* ctrl); + + /** + * Destructor + */ + ~LDAPCtrl(); + + /** + * @return The OID of the control + */ + std::string getOID() const; + + /** + * @return true if there is no "Control Value" (there is a + * difference between no and an empty control value) + */ + bool hasData() const; + + /** + * @return The Data of the control as a std::string-Object + */ + std::string getData() const; + + /** + * @return "true" if the control is critical + */ + bool isCritical() const; + + /** + * For internal use only. + * + * Translates the control to a LDAPControl-structure as needed by + * the C-API + */ + LDAPControl* getControlStruct() const; + static void freeLDAPControlStruct(LDAPControl *ctrl); + + private : + std::string m_oid; + std::string m_data; + bool m_isCritical; + bool m_noData; +}; + +#endif //LDAP_CONTROL_H diff --git a/contrib/ldapc++/src/LDAPControlSet.cpp b/contrib/ldapc++/src/LDAPControlSet.cpp new file mode 100644 index 0000000..ce9f3de --- /dev/null +++ b/contrib/ldapc++/src/LDAPControlSet.cpp @@ -0,0 +1,84 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#include "debug.h" +#include "LDAPControlSet.h" + +using namespace std; + +LDAPControlSet::LDAPControlSet(){ +} + +LDAPControlSet::LDAPControlSet(const LDAPControlSet& cs){ + DEBUG(LDAP_DEBUG_CONSTRUCT,"LDAPControlSet::LDAPControlSet(&)" << endl); + data=cs.data; +} + +LDAPControlSet::LDAPControlSet(LDAPControl** controls){ + DEBUG(LDAP_DEBUG_CONSTRUCT,"LDAPControlSet::LDAPControlSet()" << endl); + if(controls != 0){ + LDAPControl** i; + for( i=controls; *i!=0;i++) { + add(LDAPCtrl(*i)); + } + } +} + +LDAPControlSet::~LDAPControlSet(){ + DEBUG(LDAP_DEBUG_DESTROY,"LDAPControlSet::~LDAPControlSet()" << endl); +} + +size_t LDAPControlSet::size() const { + DEBUG(LDAP_DEBUG_TRACE,"LDAPControlSet::size()" << endl); + return data.size(); +} + +bool LDAPControlSet::empty() const { + DEBUG(LDAP_DEBUG_TRACE,"LDAPControlSet::empty()" << endl); + return data.empty(); +} + +LDAPControlSet::const_iterator LDAPControlSet::begin() const{ + DEBUG(LDAP_DEBUG_TRACE,"LDAPControlSet::begin()" << endl); + return data.begin(); +} + + +LDAPControlSet::const_iterator LDAPControlSet::end() const{ + DEBUG(LDAP_DEBUG_TRACE,"LDAPControlSet::end()" << endl); + return data.end (); +} + +void LDAPControlSet::add(const LDAPCtrl& ctrl){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPControlSet::add()" << endl); + data.push_back(ctrl); +} + +LDAPControl** LDAPControlSet::toLDAPControlArray() const{ + DEBUG(LDAP_DEBUG_TRACE, "LDAPControlSet::toLDAPControlArray()" << endl); + if(data.empty()){ + return 0; + }else{ + LDAPControl** ret= new LDAPControl*[data.size()+1]; + CtrlList::const_iterator i; + int j=0; + for(i=data.begin(); i!=data.end(); i++,j++){ + ret[j] = i->getControlStruct(); + } + ret[data.size()]=0; + return ret; + } +} + +void LDAPControlSet::freeLDAPControlArray(LDAPControl **ctrl){ + DEBUG(LDAP_DEBUG_TRACE, "LDAPControlSet::freeLDAPControlArray()" << endl); + if( ctrl ){ + for( LDAPControl **i = ctrl; *i != 0; ++i ){ + LDAPCtrl::freeLDAPControlStruct(*i); + } + } + delete[] ctrl; +} diff --git a/contrib/ldapc++/src/LDAPControlSet.h b/contrib/ldapc++/src/LDAPControlSet.h new file mode 100644 index 0000000..4c033be --- /dev/null +++ b/contrib/ldapc++/src/LDAPControlSet.h @@ -0,0 +1,89 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#ifndef LDAP_CONTROL_SET_H +#define LDAP_CONTROL_SET_H + +#include <list> +#include <ldap.h> +#include <LDAPControl.h> + +typedef std::list<LDAPCtrl> CtrlList; + +/** + * This container class is used to store multiple LDAPCtrl-objects. + */ +class LDAPControlSet { + typedef CtrlList::const_iterator const_iterator; + public : + /** + * Constructs an empty std::list + */ + LDAPControlSet(); + + + /** + * Copy-constructor + */ + LDAPControlSet(const LDAPControlSet& cs); + + /** + * For internal use only + * + * This constructor creates a new LDAPControlSet for a + * 0-terminated array of LDAPControl-structures as used by the + * C-API + * @param controls: pointer to a 0-terminated array of pointers to + * LDAPControl-structures + * @note: untested til now. Due to lack of server that return + * Controls + */ + LDAPControlSet(LDAPControl** controls); + + /** + * Destructor + */ + ~LDAPControlSet(); + + /** + * @return The number of LDAPCtrl-objects that are currently + * stored in this list. + */ + size_t size() const ; + + /** + * @return true if there are zero LDAPCtrl-objects currently + * stored in this list. + */ + bool empty() const; + + /** + * @return A iterator that points to the first element of the list. + */ + const_iterator begin() const; + + /** + * @return A iterator that points to the element after the last + * element of the list. + */ + const_iterator end() const; + + /** + * Adds one element to the end of the list. + * @param ctrl The Control to add to the list. + */ + void add(const LDAPCtrl& ctrl); + + /** + * Translates the list to a 0-terminated array of pointers to + * LDAPControl-structures as needed by the C-API + */ + LDAPControl** toLDAPControlArray()const ; + static void freeLDAPControlArray(LDAPControl **ctrl); + private : + CtrlList data; +} ; +#endif //LDAP_CONTROL_SET_H diff --git a/contrib/ldapc++/src/LDAPDeleteRequest.cpp b/contrib/ldapc++/src/LDAPDeleteRequest.cpp new file mode 100644 index 0000000..8ae82b4 --- /dev/null +++ b/contrib/ldapc++/src/LDAPDeleteRequest.cpp @@ -0,0 +1,75 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#include <ldap.h> + +#include "debug.h" + +#include "LDAPDeleteRequest.h" +#include "LDAPException.h" +#include "LDAPMessageQueue.h" +#include "LDAPResult.h" + +using namespace std; + +LDAPDeleteRequest::LDAPDeleteRequest( const LDAPDeleteRequest& req) : + LDAPRequest(req){ + DEBUG(LDAP_DEBUG_CONSTRUCT, + "LDAPDeleteRequest::LDAPDeleteRequest(&)" << endl); + m_dn = req.m_dn; +} + +LDAPDeleteRequest::LDAPDeleteRequest(const string& dn, + LDAPAsynConnection *connect, const LDAPConstraints *cons, + bool isReferral, const LDAPRequest* parent) + : LDAPRequest(connect, cons, isReferral, parent) { + DEBUG(LDAP_DEBUG_CONSTRUCT, + "LDAPDeleteRequest::LDAPDeleteRequest()" << endl); + DEBUG(LDAP_DEBUG_CONSTRUCT | LDAP_DEBUG_PARAMETER, " dn:" << dn << endl); + m_requestType=LDAPRequest::DELETE; + m_dn=dn; +} + +LDAPDeleteRequest::~LDAPDeleteRequest(){ + DEBUG(LDAP_DEBUG_DESTROY, + "LDAPDeleteRequest::~LDAPDeleteRequest()" << endl); +} + +LDAPMessageQueue* LDAPDeleteRequest::sendRequest(){ + DEBUG(LDAP_DEBUG_TRACE, "LDAPDeleteRequest::sendRequest()" << endl); + int msgID=0; + LDAPControl** tmpSrvCtrls=m_cons->getSrvCtrlsArray(); + LDAPControl** tmpClCtrls=m_cons->getClCtrlsArray(); + int err=ldap_delete_ext(m_connection->getSessionHandle(),m_dn.c_str(), + tmpSrvCtrls, tmpClCtrls ,&msgID); + LDAPControlSet::freeLDAPControlArray(tmpSrvCtrls); + LDAPControlSet::freeLDAPControlArray(tmpClCtrls); + if(err != LDAP_SUCCESS){ + throw LDAPException(err); + }else{ + m_msgID=msgID; + return new LDAPMessageQueue(this); + } +} + +LDAPRequest* LDAPDeleteRequest::followReferral(LDAPMsg* refs){ + DEBUG(LDAP_DEBUG_TRACE, "LDAPDeleteRequest::followReferral()" << endl); + LDAPUrlList::const_iterator usedUrl; + LDAPUrlList urls= ((LDAPResult*)refs)->getReferralUrls(); + LDAPAsynConnection* con=0; + try{ + con = getConnection()->referralConnect(urls,usedUrl,m_cons); + }catch (LDAPException e){ + delete con; + return 0; + } + if(con != 0){ + return new LDAPDeleteRequest(m_dn, con, m_cons, true, this); + } + return 0; +} + + diff --git a/contrib/ldapc++/src/LDAPDeleteRequest.h b/contrib/ldapc++/src/LDAPDeleteRequest.h new file mode 100644 index 0000000..f1250ff --- /dev/null +++ b/contrib/ldapc++/src/LDAPDeleteRequest.h @@ -0,0 +1,26 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#ifndef LDAP_DELETE_REQUEST_H +#define LDAP_DELETE_REQUEST_H + +#include <LDAPRequest.h> +class LDAPMessageQueue; + +class LDAPDeleteRequest : public LDAPRequest{ + public : + LDAPDeleteRequest(const LDAPDeleteRequest& req); + LDAPDeleteRequest(const std::string& dn, LDAPAsynConnection *connect, + const LDAPConstraints *cons, bool isReferral=false, + const LDAPRequest* parent=0); + virtual ~LDAPDeleteRequest(); + virtual LDAPMessageQueue* sendRequest(); + virtual LDAPRequest* followReferral(LDAPMsg* refs); + + private : + std::string m_dn; +}; +#endif //LDAP_DELETE_REQUEST_H diff --git a/contrib/ldapc++/src/LDAPEntry.cpp b/contrib/ldapc++/src/LDAPEntry.cpp new file mode 100644 index 0000000..f597426 --- /dev/null +++ b/contrib/ldapc++/src/LDAPEntry.cpp @@ -0,0 +1,104 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + + +#include "debug.h" +#include "LDAPEntry.h" + +#include "LDAPAsynConnection.h" +#include "LDAPException.h" + +using namespace std; + +LDAPEntry::LDAPEntry(const LDAPEntry& entry){ + DEBUG(LDAP_DEBUG_CONSTRUCT,"LDAPEntry::LDAPEntry(&)" << endl); + m_dn=entry.m_dn; + m_attrs=new LDAPAttributeList( *(entry.m_attrs)); +} + + +LDAPEntry::LDAPEntry(const string& dn, const LDAPAttributeList *attrs){ + DEBUG(LDAP_DEBUG_CONSTRUCT,"LDAPEntry::LDAPEntry()" << endl); + DEBUG(LDAP_DEBUG_CONSTRUCT | LDAP_DEBUG_PARAMETER, + " dn:" << dn << endl); + if ( attrs ) + m_attrs=new LDAPAttributeList(*attrs); + else + m_attrs=new LDAPAttributeList(); + m_dn=dn; +} + +LDAPEntry::LDAPEntry(const LDAPAsynConnection *ld, LDAPMessage *msg){ + DEBUG(LDAP_DEBUG_CONSTRUCT,"LDAPEntry::LDAPEntry()" << endl); + char* tmp=ldap_get_dn(ld->getSessionHandle(),msg); + m_dn=string(tmp); + ldap_memfree(tmp); + m_attrs = new LDAPAttributeList(ld, msg); +} + +LDAPEntry::~LDAPEntry(){ + DEBUG(LDAP_DEBUG_DESTROY,"LDAPEntry::~LDAPEntry()" << endl); + delete m_attrs; +} + +LDAPEntry& LDAPEntry::operator=(const LDAPEntry& from){ + m_dn = from.m_dn; + delete m_attrs; + m_attrs = new LDAPAttributeList( *(from.m_attrs)); + return *this; +} + +void LDAPEntry::setDN(const string& dn){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPEntry::setDN()" << endl); + DEBUG(LDAP_DEBUG_TRACE | LDAP_DEBUG_PARAMETER, + " dn:" << dn << endl); + m_dn=dn; +} + +void LDAPEntry::setAttributes(LDAPAttributeList *attrs){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPEntry::setAttributes()" << endl); + DEBUG(LDAP_DEBUG_TRACE | LDAP_DEBUG_PARAMETER, + " attrs:" << *attrs << endl); + if (m_attrs != 0){ + delete m_attrs; + } + m_attrs=attrs; +} + +const string& LDAPEntry::getDN() const{ + DEBUG(LDAP_DEBUG_TRACE,"LDAPEntry::getDN()" << endl); + return m_dn; +} + +const LDAPAttributeList* LDAPEntry::getAttributes() const{ + DEBUG(LDAP_DEBUG_TRACE,"LDAPEntry::getAttributes()" << endl); + return m_attrs; +} + +const LDAPAttribute* LDAPEntry::getAttributeByName(const std::string& name) const +{ + return m_attrs->getAttributeByName(name); +} + +void LDAPEntry::addAttribute(const LDAPAttribute& attr) +{ + m_attrs->addAttribute(attr); +} + +void LDAPEntry::delAttribute(const std::string& type) +{ + m_attrs->delAttribute(type); +} + +void LDAPEntry::replaceAttribute(const LDAPAttribute& attr) +{ + m_attrs->replaceAttribute(attr); +} + +ostream& operator << (ostream& s, const LDAPEntry& le){ + s << "DN: " << le.m_dn << ": " << *(le.m_attrs); + return s; +} diff --git a/contrib/ldapc++/src/LDAPEntry.h b/contrib/ldapc++/src/LDAPEntry.h new file mode 100644 index 0000000..7155523 --- /dev/null +++ b/contrib/ldapc++/src/LDAPEntry.h @@ -0,0 +1,116 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + + +#ifndef LDAP_ENTRY_H +#define LDAP_ENTRY_H +#include <ldap.h> + +#include <LDAPAttributeList.h> + +class LDAPAsynConnection; + +/** + * This class is used to store every kind of LDAP Entry. + */ +class LDAPEntry{ + + public : + /** + * Copy-constructor + */ + LDAPEntry(const LDAPEntry& entry); + + /** + * Constructs a new entry (also used as standard constructor). + * + * @param dn The Distinguished Name for the new entry. + * @param attrs The attributes for the new entry. + */ + LDAPEntry(const std::string& dn=std::string(), + const LDAPAttributeList *attrs=0); + + /** + * Used internally only. + * + * The constructor is used internally to create a LDAPEntry from + * the C-API's data structures. + */ + LDAPEntry(const LDAPAsynConnection *ld, LDAPMessage *msg); + + /** + * Destructor + */ + ~LDAPEntry(); + + /** + * Assignment operator + */ + LDAPEntry& operator=(const LDAPEntry& from); + + /** + * Sets the DN-attribute. + * @param dn: The new DN for the entry. + */ + void setDN(const std::string& dn); + + /** + * Sets the attributes of the entry. + * @param attr: A pointer to a std::list of the new attributes. + */ + void setAttributes(LDAPAttributeList *attrs); + + /** + * Get an Attribute by its AttributeType (simple wrapper around + * LDAPAttributeList::getAttributeByName() ) + * @param name The name of the Attribute to look for + * @return a pointer to the LDAPAttribute with the AttributeType + * "name" or 0, if there is no Attribute of that Type + */ + const LDAPAttribute* getAttributeByName(const std::string& name) const; + + /** + * Adds one Attribute to the List of Attributes (simple wrapper around + * LDAPAttributeList::addAttribute() ). + * @param attr The attribute to add to the list. + */ + void addAttribute(const LDAPAttribute& attr); + + /** + * Deletes all values of an Attribute from the list of Attributes + * (simple wrapper around LDAPAttributeList::delAttribute() ). + * @param type The attribute to delete. + */ + void delAttribute(const std::string& type); + + /** + * Replace an Attribute in the List of Attributes (simple wrapper + * around LDAPAttributeList::replaceAttribute() ). + * @param attr The attribute to add to the list. + */ + void replaceAttribute(const LDAPAttribute& attr); + + /** + * @returns The current DN of the entry. + */ + const std::string& getDN() const ; + + /** + * @returns A const pointer to the attributes of the entry. + */ + const LDAPAttributeList* getAttributes() const; + + /** + * This method can be used to dump the data of a LDAPResult-Object. + * It is only useful for debugging purposes at the moment + */ + friend std::ostream& operator << (std::ostream& s, const LDAPEntry& le); + + private : + LDAPAttributeList *m_attrs; + std::string m_dn; +}; +#endif //LDAP_ENTRY_H diff --git a/contrib/ldapc++/src/LDAPEntryList.cpp b/contrib/ldapc++/src/LDAPEntryList.cpp new file mode 100644 index 0000000..1d0b737 --- /dev/null +++ b/contrib/ldapc++/src/LDAPEntryList.cpp @@ -0,0 +1,40 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + + +#include "LDAPEntryList.h" +#include "LDAPEntry.h" + +LDAPEntryList::LDAPEntryList(){ +} + +LDAPEntryList::LDAPEntryList(const LDAPEntryList& e){ + m_entries = e.m_entries; +} + +LDAPEntryList::~LDAPEntryList(){ +} + +size_t LDAPEntryList::size() const{ + return m_entries.size(); +} + +bool LDAPEntryList::empty() const{ + return m_entries.empty(); +} + +LDAPEntryList::const_iterator LDAPEntryList::begin() const{ + return m_entries.begin(); +} + +LDAPEntryList::const_iterator LDAPEntryList::end() const{ + return m_entries.end(); +} + +void LDAPEntryList::addEntry(const LDAPEntry& e){ + m_entries.push_back(e); +} + diff --git a/contrib/ldapc++/src/LDAPEntryList.h b/contrib/ldapc++/src/LDAPEntryList.h new file mode 100644 index 0000000..d9aea6d --- /dev/null +++ b/contrib/ldapc++/src/LDAPEntryList.h @@ -0,0 +1,70 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#ifndef LDAP_ENTRY_LIST_H +#define LDAP_ENTRY_LIST_H + +#include <cstdio> +#include <list> + +class LDAPEntry; + +/** + * For internal use only. + * + * This class is used by LDAPSearchResults to store a std::list of + * LDAPEntry-Objects + */ +class LDAPEntryList{ + typedef std::list<LDAPEntry> ListType; + + public: + typedef ListType::const_iterator const_iterator; + + /** + * Copy-Constructor + */ + LDAPEntryList(const LDAPEntryList& el); + + /** + * Default-Constructor + */ + LDAPEntryList(); + + /** + * Destructor + */ + ~LDAPEntryList(); + + /** + * @return The number of entries currently stored in the list. + */ + size_t size() const; + + /** + * @return true if there are zero entries currently stored in the list. + */ + bool empty() const; + + /** + * @return An iterator pointing to the first element of the list. + */ + const_iterator begin() const; + + /** + * @return An iterator pointing to the end of the list + */ + const_iterator end() const; + + /** + * Adds an Entry to the end of the list. + */ + void addEntry(const LDAPEntry& e); + + private: + ListType m_entries; +}; +#endif // LDAP_ENTRY_LIST_H diff --git a/contrib/ldapc++/src/LDAPException.cpp b/contrib/ldapc++/src/LDAPException.cpp new file mode 100644 index 0000000..1bda281 --- /dev/null +++ b/contrib/ldapc++/src/LDAPException.cpp @@ -0,0 +1,96 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#include <ldap.h> +#include "config.h" +#include "LDAPException.h" + +#include "LDAPAsynConnection.h" +#include "LDAPResult.h" + +using namespace std; + +LDAPException::LDAPException(int res_code, const string& err_string) throw() + : std::runtime_error(err_string) +{ + m_res_code=res_code; + m_res_string=string(ldap_err2string(res_code)); + m_err_string=err_string; +} + +LDAPException::LDAPException(const LDAPAsynConnection *lc) throw() + : std::runtime_error("") +{ + LDAP *l = lc->getSessionHandle(); + ldap_get_option(l,LDAP_OPT_RESULT_CODE,&m_res_code); + const char *res_cstring = ldap_err2string(m_res_code); + if ( res_cstring ) { + m_res_string = string(res_cstring); + } else { + m_res_string = ""; + } + const char* err_string; + +#ifdef LDAP_OPT_DIAGNOSTIC_MESSAGE + ldap_get_option(l,LDAP_OPT_DIAGNOSTIC_MESSAGE ,&err_string); +#else + ldap_get_option(l,LDAP_OPT_ERROR_STRING,&err_string); +#endif + if ( err_string ) { + m_err_string = string(err_string); + } else { + m_err_string = ""; + } +} + +LDAPException::~LDAPException() throw() +{ +} + +int LDAPException::getResultCode() const throw() +{ + return m_res_code; +} + +const string& LDAPException::getResultMsg() const throw() +{ + return m_res_string; +} + +const string& LDAPException::getServerMsg() const throw() +{ + return m_err_string; +} + +const char* LDAPException::what() const throw() +{ + return this->m_res_string.c_str(); +} + +ostream& operator << (ostream& s, LDAPException e) throw() +{ + s << "Error " << e.m_res_code << ": " << e.m_res_string; + if (!e.m_err_string.empty()) { + s << endl << "additional info: " << e.m_err_string ; + } + return s; +} + + +LDAPReferralException::LDAPReferralException(const LDAPUrlList& urls) throw() + : LDAPException(LDAPResult::REFERRAL) , m_urlList(urls) +{ +} + +LDAPReferralException::~LDAPReferralException() throw() +{ +} + +const LDAPUrlList& LDAPReferralException::getUrls() throw() +{ + return m_urlList; +} + diff --git a/contrib/ldapc++/src/LDAPException.h b/contrib/ldapc++/src/LDAPException.h new file mode 100644 index 0000000..391f855 --- /dev/null +++ b/contrib/ldapc++/src/LDAPException.h @@ -0,0 +1,107 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + + +#ifndef LDAP_EXCEPTION_H +#define LDAP_EXCEPTION_H + +#include <iostream> +#include <string> +#include <stdexcept> + +#include <LDAPUrlList.h> + +class LDAPAsynConnection; + +/** + * This class is only thrown as an Exception and used to signalize error + * conditions during LDAP-operations + */ +class LDAPException : public std::runtime_error +{ + + public : + /** + * Constructs a LDAPException-object from the parameters + * @param res_code A valid LDAP result code. + * @param err_string An additional error message for the error + * that happened (optional) + */ + LDAPException(int res_code, + const std::string& err_string=std::string()) throw(); + + /** + * Constructs a LDAPException-object from the error state of a + * LDAPAsynConnection-object + * @param lc A LDAP-Connection for that an error has happened. The + * Constructor tries to read its error state. + */ + LDAPException(const LDAPAsynConnection *lc) throw(); + + /** + * Destructor + */ + virtual ~LDAPException() throw(); + + /** + * @return The Result code of the object + */ + int getResultCode() const throw(); + + /** + * @return The error message that is corresponding to the result + * code . + */ + const std::string& getResultMsg() const throw(); + + /** + * @return The additional error message of the error (if it was set) + */ + const std::string& getServerMsg() const throw(); + + + virtual const char* what() const throw(); + + /** + * This method can be used to dump the data of a LDAPResult-Object. + * It is only useful for debugging purposes at the moment + */ + friend std::ostream& operator << (std::ostream &s, LDAPException e) throw(); + + private : + int m_res_code; + std::string m_res_string; + std::string m_err_string; +}; + +/** + * This class extends LDAPException and is used to signalize Referrals + * there were received during synchronous LDAP-operations + */ +class LDAPReferralException : public LDAPException +{ + + public : + /** + * Creates an object that is initialized with a list of URLs + */ + LDAPReferralException(const LDAPUrlList& urls) throw(); + + /** + * Destructor + */ + ~LDAPReferralException() throw(); + + /** + * @return The List of URLs of the Referral/Search Reference + */ + const LDAPUrlList& getUrls() throw(); + + private : + LDAPUrlList m_urlList; +}; + +#endif //LDAP_EXCEPTION_H diff --git a/contrib/ldapc++/src/LDAPExtRequest.cpp b/contrib/ldapc++/src/LDAPExtRequest.cpp new file mode 100644 index 0000000..a07e648 --- /dev/null +++ b/contrib/ldapc++/src/LDAPExtRequest.cpp @@ -0,0 +1,84 @@ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#include <ldap.h> +#include <lber.h> + +#include "debug.h" + +#include "LDAPExtRequest.h" +#include "LDAPException.h" +#include "LDAPResult.h" + +#include <cstdlib> + +using namespace std; + +LDAPExtRequest::LDAPExtRequest(const LDAPExtRequest& req) : + LDAPRequest(req){ + DEBUG(LDAP_DEBUG_CONSTRUCT,"LDAPExtRequest::LDAPExtRequest(&)" << endl); + m_data=req.m_data; + m_oid=req.m_oid; +} + +LDAPExtRequest::LDAPExtRequest(const string& oid, const string& data, + LDAPAsynConnection *connect, const LDAPConstraints *cons, + bool isReferral, const LDAPRequest* parent) + : LDAPRequest(connect, cons, isReferral, parent){ + DEBUG(LDAP_DEBUG_CONSTRUCT, "LDAPExtRequest::LDAPExtRequest()" << endl); + DEBUG(LDAP_DEBUG_CONSTRUCT | LDAP_DEBUG_PARAMETER, + " oid:" << oid << endl); + m_oid=oid; + m_data=data; +} + +LDAPExtRequest::~LDAPExtRequest(){ + DEBUG(LDAP_DEBUG_DESTROY, "LDAPExtRequest::~LDAPExtRequest()" << endl); +} + +LDAPMessageQueue* LDAPExtRequest::sendRequest(){ + DEBUG(LDAP_DEBUG_TRACE, "LDAPExtRequest::sendRequest()" << endl); + int msgID=0; + BerValue* tmpdata=0; + if(m_data != ""){ + tmpdata=(BerValue*) malloc(sizeof(BerValue)); + tmpdata->bv_len = m_data.size(); + tmpdata->bv_val = (char*) malloc(sizeof(char) * (m_data.size()) ); + m_data.copy(tmpdata->bv_val, string::npos); + } + LDAPControl** tmpSrvCtrls=m_cons->getSrvCtrlsArray(); + LDAPControl** tmpClCtrls=m_cons->getClCtrlsArray(); + int err=ldap_extended_operation(m_connection->getSessionHandle(), + m_oid.c_str(), tmpdata, tmpSrvCtrls, tmpClCtrls, &msgID); + LDAPControlSet::freeLDAPControlArray(tmpSrvCtrls); + LDAPControlSet::freeLDAPControlArray(tmpClCtrls); + ber_bvfree(tmpdata); + if(err != LDAP_SUCCESS){ + delete this; + throw LDAPException(err); + }else{ + m_msgID=msgID; + return new LDAPMessageQueue(this); + } +} + +LDAPRequest* LDAPExtRequest::followReferral(LDAPMsg* ref){ + DEBUG(LDAP_DEBUG_TRACE, "LDAPExtRequest::followReferral()" << endl); + LDAPUrlList::const_iterator usedUrl; + LDAPUrlList urls = ((LDAPResult*)ref)->getReferralUrls(); + LDAPAsynConnection* con = 0; + try { + con = getConnection()->referralConnect(urls,usedUrl,m_cons); + } catch(LDAPException e){ + delete con; + return 0; + } + if(con != 0){ + return new LDAPExtRequest(m_oid, m_data, con, m_cons,true,this); + } + return 0; +} + + diff --git a/contrib/ldapc++/src/LDAPExtRequest.h b/contrib/ldapc++/src/LDAPExtRequest.h new file mode 100644 index 0000000..6f9c9bc --- /dev/null +++ b/contrib/ldapc++/src/LDAPExtRequest.h @@ -0,0 +1,28 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#ifndef LDAP_EXT_REQUEST_H +#define LDAP_EXT_REQUEST_H + +#include <LDAPRequest.h> + +class LDAPExtRequest : LDAPRequest { + + public: + LDAPExtRequest(const LDAPExtRequest& req); + LDAPExtRequest(const std::string& oid, const std::string& data, + LDAPAsynConnection *connect, const LDAPConstraints *cons, + bool isReferral=false, const LDAPRequest* parent=0); + virtual ~LDAPExtRequest(); + virtual LDAPMessageQueue* sendRequest(); + virtual LDAPRequest* followReferral(LDAPMsg* urls); + + private: + std::string m_oid; + std::string m_data; +}; + +#endif // LDAP_EXT_REQUEST_H diff --git a/contrib/ldapc++/src/LDAPExtResult.cpp b/contrib/ldapc++/src/LDAPExtResult.cpp new file mode 100644 index 0000000..f3177e8 --- /dev/null +++ b/contrib/ldapc++/src/LDAPExtResult.cpp @@ -0,0 +1,49 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#include "debug.h" +#include <lber.h> +#include "LDAPRequest.h" +#include "LDAPException.h" + +#include "LDAPResult.h" +#include "LDAPExtResult.h" + +using namespace std; + +LDAPExtResult::LDAPExtResult(const LDAPRequest* req, LDAPMessage* msg) : + LDAPResult(req, msg){ + DEBUG(LDAP_DEBUG_CONSTRUCT,"LDAPExtResult::LDAPExtResult()" << endl); + char* oid = 0; + BerValue* data = 0; + LDAP* lc = req->getConnection()->getSessionHandle(); + int err=ldap_parse_extended_result(lc, msg, &oid, &data, 0); + if(err != LDAP_SUCCESS){ + ber_bvfree(data); + ldap_memfree(oid); + throw LDAPException(err); + }else{ + m_oid=string(oid); + ldap_memfree(oid); + if(data){ + m_data=string(data->bv_val, data->bv_len); + ber_bvfree(data); + } + } +} + +LDAPExtResult::~LDAPExtResult(){ + DEBUG(LDAP_DEBUG_DESTROY,"LDAPExtResult::~LDAPExtResult()" << endl); +} + +const string& LDAPExtResult::getResponseOid() const{ + return m_oid; +} + +const string& LDAPExtResult::getResponse() const{ + return m_data; +} + diff --git a/contrib/ldapc++/src/LDAPExtResult.h b/contrib/ldapc++/src/LDAPExtResult.h new file mode 100644 index 0000000..90e81af --- /dev/null +++ b/contrib/ldapc++/src/LDAPExtResult.h @@ -0,0 +1,50 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#ifndef LDAP_EXT_RESULT_H +#define LDAP_EXT_RESULT_H + +#include <ldap.h> + +#include <LDAPResult.h> + +class LDAPRequest; + +/** + * Object of this class are created by the LDAPMsg::create method if + * results for an Extended Operation were returned by a LDAP server. + */ +class LDAPExtResult : public LDAPResult { + public : + /** + * Constructor that creates an LDAPExtResult-object from the C-API + * structures + */ + LDAPExtResult(const LDAPRequest* req, LDAPMessage* msg); + + /** + * The Destructor + */ + virtual ~LDAPExtResult(); + + /** + * @returns The OID of the Extended Operation that has returned + * this result. + */ + const std::string& getResponseOid() const; + + /** + * @returns If the result contained data this method will return + * the data to the caller as a std::string. + */ + const std::string& getResponse() const; + + private: + std::string m_oid; + std::string m_data; +}; + +#endif // LDAP_EXT_RESULT_H diff --git a/contrib/ldapc++/src/LDAPMessage.cpp b/contrib/ldapc++/src/LDAPMessage.cpp new file mode 100644 index 0000000..f63212a --- /dev/null +++ b/contrib/ldapc++/src/LDAPMessage.cpp @@ -0,0 +1,72 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + + +#include "LDAPMessage.h" + +#include "LDAPResult.h" +#include "LDAPExtResult.h" +#include "LDAPSaslBindResult.h" +#include "LDAPRequest.h" +#include "LDAPSearchResult.h" +#include "LDAPSearchReference.h" +#include "debug.h" +#include <iostream> + +using namespace std; + +LDAPMsg::LDAPMsg(LDAPMessage *msg){ + DEBUG(LDAP_DEBUG_CONSTRUCT,"LDAPMsg::LDAPMsg()" << endl); + msgType=ldap_msgtype(msg); + m_hasControls=false; +} + +LDAPMsg::LDAPMsg(int type, int id=0){ + DEBUG(LDAP_DEBUG_CONSTRUCT,"LDAPMsg::LDAPMsg()" << endl); + msgType = type; + msgID = id; + m_hasControls=false; +} + +LDAPMsg* LDAPMsg::create(const LDAPRequest *req, LDAPMessage *msg){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPMsg::create()" << endl); + switch(ldap_msgtype(msg)){ + case SEARCH_ENTRY : + return new LDAPSearchResult(req,msg); + break; + case SEARCH_REFERENCE : + return new LDAPSearchReference(req, msg); + break; + case EXTENDED_RESPONSE : + return new LDAPExtResult(req,msg); + break; + case BIND_RESPONSE : + return new LDAPSaslBindResult(req,msg); + default : + return new LDAPResult(req, msg); + } + return 0; +} + + +int LDAPMsg::getMessageType(){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPMsg::getMessageType()" << endl); + return msgType; +} + +int LDAPMsg::getMsgID(){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPMsg::getMsgID()" << endl); + return msgID; +} + +bool LDAPMsg::hasControls() const{ + return m_hasControls; +} + +const LDAPControlSet& LDAPMsg::getSrvControls() const { + return m_srvControls; +} + diff --git a/contrib/ldapc++/src/LDAPMessage.h b/contrib/ldapc++/src/LDAPMessage.h new file mode 100644 index 0000000..a152d90 --- /dev/null +++ b/contrib/ldapc++/src/LDAPMessage.h @@ -0,0 +1,127 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + + +#ifndef LDAP_MSG_H +#define LDAP_MSG_H +#include <ldap.h> + +#include <LDAPControlSet.h> + +class LDAPRequest; +/** + * This class represents any type of LDAP- Message returned + * from the server. + * + * This class is never not instantiated directly. Only + * its subclasses are used. The main feature of this class is the + * static method create() (see below) + */ +class LDAPMsg{ + public: + //public Constants defining the response message types + static const int BIND_RESPONSE=LDAP_RES_BIND; + static const int SEARCH_ENTRY=LDAP_RES_SEARCH_ENTRY; + static const int SEARCH_DONE=LDAP_RES_SEARCH_RESULT; + static const int SEARCH_REFERENCE=LDAP_RES_SEARCH_REFERENCE; + static const int MODIFY_RESPONSE=LDAP_RES_MODIFY; + static const int ADD_RESPONSE=LDAP_RES_ADD; + static const int DEL_RESPONSE=LDAP_RES_DELETE; + static const int MODDN_RESPONSE=LDAP_RES_MODDN; + static const int COMPARE_RESPONSE=LDAP_RES_COMPARE; + static const int EXTENDED_RESPONSE=LDAP_RES_EXTENDED; + //public Constants defining the request message types + static const int BIND_REQUEST=LDAP_REQ_BIND; + static const int UNBIND_REQUEST=LDAP_REQ_UNBIND; + static const int SEARCH_REQUEST=LDAP_REQ_SEARCH; + static const int MODIFY_REQUEST=LDAP_REQ_MODIFY; + static const int ADD_REQUEST=LDAP_REQ_ADD; + static const int DELETE_REQUEST=LDAP_REQ_DELETE; + static const int MODRDN_REQUEST=LDAP_REQ_MODRDN; + static const int COMPARE_REQUEST=LDAP_REQ_COMPARE; + static const int ABANDON_REQUEST=LDAP_REQ_ABANDON; + static const int EXTENDED_REQUEST=LDAP_REQ_EXTENDED; + + /** + * The destructor has no implementation, because this is an abstract + * class. + */ + virtual ~LDAPMsg() {} + + /** + * This method is used by the library to parse the results returned + * by the C-API. + * + * Based on msgtype-Value of the *msg-Parameter this method creates + * an Object of one of the subtypes of LDAPMsg (e.g. LDAPSearchResult + * or LDAPResult) that represents the same Message as the + * *msg-Parameter. *msg is e.g. a Message returned by the C-API's + * ldap_result call. + * @param req The LDAPRequest-object this result message is + * associated with. + * @param msg The LDAPMessage-structure from the C-API that + * contains the LDAP-message to parse. + * @return An Object of one of the subtypes of this class. It + * contains the parsed LDAP-message. + */ + static LDAPMsg* create(const LDAPRequest *req, LDAPMessage *msg); + + /** + * @returns The Type of message that this object contains. Possible + * values are: <BR> + * BIND_RESPONSE <BR> + * SEARCH_ENTRY <BR> + * SEARCH_DONE <BR> + * SEARCH_REFERENCE <BR> + * MODIFY_RESPONSE <BR> + * ADD_RESPONSE <BR> + * DEL_RESPONSE <BR> + * MODDN_RESPONSE <BR> + * COMPARE_RESPONSE <BR> + * EXTENDED_RESPONSE <BR> + */ + int getMessageType(); + + /** + * @returns The message-ID that the C-API return for the + * Result-message. + */ + int getMsgID(); + + /** + * @returns If any Control was sent back by the server this method + * returns true. Otherwise false is returned. + */ + bool hasControls() const; + + /** + * @returns Server controls that were sent back by the server. + * @note This feature is not test well yet. + */ + const LDAPControlSet& getSrvControls() const; + + protected: + /** + * This constructor make a copy of a LDAPMsg-pointer. The object + * itself (no the pointer) is copied. + * Only for internal use. + */ + LDAPMsg(LDAPMessage *msg); + LDAPMsg(int msgType, int msgID); + + /** + * This attribute stores Server-Control that were returned with the + * message. + */ + LDAPControlSet m_srvControls; + + bool m_hasControls; + + private: + int msgType; + int msgID; +}; +#endif //ifndef LDAP_MSG_H diff --git a/contrib/ldapc++/src/LDAPMessageQueue.cpp b/contrib/ldapc++/src/LDAPMessageQueue.cpp new file mode 100644 index 0000000..0cbc0d1 --- /dev/null +++ b/contrib/ldapc++/src/LDAPMessageQueue.cpp @@ -0,0 +1,171 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + + +#include "config.h" +#include "debug.h" +#include "LDAPMessageQueue.h" +#include "LDAPRequest.h" +#include "LDAPResult.h" +#include "LDAPSearchReference.h" +#include "LDAPSearchRequest.h" +#include "LDAPUrl.h" +#include "LDAPUrlList.h" +#include "LDAPException.h" + +using namespace std; + +// TODO: How to handle unsolicited notifications, like notice of +// disconnection + +LDAPMessageQueue::LDAPMessageQueue(LDAPRequest *req){ + DEBUG(LDAP_DEBUG_CONSTRUCT, "LDAPMessageQueue::LDAPMessageQueue()" << endl); + m_activeReq.push(req); + m_issuedReq.push_back(req); +} + +LDAPMessageQueue::~LDAPMessageQueue(){ + DEBUG(LDAP_DEBUG_DESTROY, "LDAPMessageQueue::~LDAPMessageQueue()" << endl); + for(LDAPRequestList::iterator i=m_issuedReq.begin(); + i != m_issuedReq.end(); i++){ + delete *i; + } + m_issuedReq.clear(); +} + + +LDAPMsg *LDAPMessageQueue::getNext(){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPMessageQueue::getNext()" << endl); + + if ( m_activeReq.empty() ) { + return 0; + } + + LDAPRequest *req=m_activeReq.top(); + LDAPMsg *ret=0; + + try{ + ret = req->getNextMessage(); + }catch(LDAPException e){ + //do some clean up + m_activeReq.pop(); + throw; + } + + const LDAPConstraints *constr=req->getConstraints(); + switch (ret->getMessageType()) { + case LDAPMsg::SEARCH_REFERENCE : + if (constr->getReferralChase() ){ + //throws Exception (limit Exceeded) + LDAPRequest *refReq=chaseReferral(ret); + if(refReq != 0){ + m_activeReq.push(refReq); + m_issuedReq.push_back(refReq); + delete ret; + return getNext(); + } + } + return ret; + break; + case LDAPMsg::SEARCH_ENTRY : + return ret; + break; + case LDAPMsg::SEARCH_DONE : + if(req->isReferral()){ + req->unbind(); + } + switch ( ((LDAPResult*)ret)->getResultCode()) { + case LDAPResult::REFERRAL : + if(constr->getReferralChase()){ + //throws Exception (limit Exceeded) + LDAPRequest *refReq=chaseReferral(ret); + if(refReq != 0){ + m_activeReq.pop(); + m_activeReq.push(refReq); + m_issuedReq.push_back(refReq); + delete ret; + return getNext(); + } + } + return ret; + break; + case LDAPResult::SUCCESS : + if(req->isReferral()){ + delete ret; + m_activeReq.pop(); + return getNext(); + }else{ + m_activeReq.pop(); + return ret; + } + break; + default: + m_activeReq.pop(); + return ret; + break; + } + break; + //must be some kind of LDAPResultMessage + default: + if(req->isReferral()){ + req->unbind(); + } + LDAPResult* res_p=(LDAPResult*)ret; + switch (res_p->getResultCode()) { + case LDAPResult::REFERRAL : + if(constr->getReferralChase()){ + //throws Exception (limit Exceeded) + LDAPRequest *refReq=chaseReferral(ret); + if(refReq != 0){ + m_activeReq.pop(); + m_activeReq.push(refReq); + m_issuedReq.push_back(refReq); + delete ret; + return getNext(); + } + } + return ret; + break; + default: + m_activeReq.pop(); + return ret; + } + break; + } +} + +// TODO Maybe moved to LDAPRequest::followReferral seems more reasonable +//there +LDAPRequest* LDAPMessageQueue::chaseReferral(LDAPMsg* ref){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPMessageQueue::chaseReferral()" << endl); + LDAPRequest *req=m_activeReq.top(); + LDAPRequest *refReq=req->followReferral(ref); + if(refReq !=0){ + if(refReq->getConstraints()->getHopLimit() < refReq->getHopCount()){ + delete(refReq); + throw LDAPException(LDAP_REFERRAL_LIMIT_EXCEEDED); + } + if(refReq->isCycle()){ + delete(refReq); + throw LDAPException(LDAP_CLIENT_LOOP); + } + try { + refReq->sendRequest(); + return refReq; + }catch (LDAPException e){ + DEBUG(LDAP_DEBUG_TRACE," caught exception" << endl); + return 0; + } + }else{ + return 0; + } +} + +LDAPRequestStack* LDAPMessageQueue::getRequestStack(){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPMessageQueue::getRequestStack()" << endl); + return &m_activeReq; +} + diff --git a/contrib/ldapc++/src/LDAPMessageQueue.h b/contrib/ldapc++/src/LDAPMessageQueue.h new file mode 100644 index 0000000..9e42d80 --- /dev/null +++ b/contrib/ldapc++/src/LDAPMessageQueue.h @@ -0,0 +1,72 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + + +#ifndef LDAP_MESSAGE_QUEUE_H +#define LDAP_MESSAGE_QUEUE_H + +#include <stack> + +#include <LDAPUrlList.h> +#include <LDAPMessage.h> + +class LDAPAsynConnection; +class LDAPRequest; +class LDAPSearchRequest; +class LDAPUrl; +typedef std::stack<LDAPRequest*> LDAPRequestStack; +typedef std::list<LDAPRequest*> LDAPRequestList; + +/** + * This class is created for the asynchronous LDAP-operations. And can be + * used by the client to retrieve the results of an operation. + */ +class LDAPMessageQueue{ + public : + + /** + * This creates a new LDAPMessageQueue. For a LDAP-request + * + * @param conn The Request for that is queue can be used to get + * the results. + */ + LDAPMessageQueue(LDAPRequest *conn); + /** + * Destructor + */ + ~LDAPMessageQueue(); + + /** + * This method reads exactly one Message from the results of a + * Request. + * @throws LDAPException + * @return A pointer to an object of one of the classes that were + * derived from LDAPMsg. The user has to cast it to the + * correct type (e.g. LDAPResult or LDAPSearchResult) + */ + LDAPMsg* getNext(); + + /** + * For internat use only. + * + * The method is used to start the automatic referral chasing + */ + LDAPRequest* chaseReferral(LDAPMsg* ref); + + /** + * For internal use only + * + * The referral chasing algorithm needs this method to see the + * currently active requests. + */ + LDAPRequestStack* getRequestStack(); + + private : + LDAPRequestStack m_activeReq; + LDAPRequestList m_issuedReq; +}; +#endif //ifndef LDAP_MESSAGE_QUEUE_H + diff --git a/contrib/ldapc++/src/LDAPModDNRequest.cpp b/contrib/ldapc++/src/LDAPModDNRequest.cpp new file mode 100644 index 0000000..c81484a --- /dev/null +++ b/contrib/ldapc++/src/LDAPModDNRequest.cpp @@ -0,0 +1,88 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#include <ldap.h> + +#include "debug.h" + +#include "LDAPModDNRequest.h" +#include "LDAPException.h" +#include "LDAPResult.h" +#include "LDAPUrlList.h" + +using namespace std; + +LDAPModDNRequest::LDAPModDNRequest(const LDAPModDNRequest& req) : + LDAPRequest(req){ + DEBUG(LDAP_DEBUG_CONSTRUCT, + "LDAPModDNRequest::LDAPModDNRequest(&)" << endl); + m_dn = req.m_dn; + m_newRDN = req.m_newRDN; + m_newParentDN = req.m_newParentDN; + m_deleteOld = req.m_deleteOld; +} + +LDAPModDNRequest::LDAPModDNRequest(const string& dn, const string& newRDN, + bool deleteOld, const string& newParentDN, + LDAPAsynConnection *connect, + const LDAPConstraints *cons, bool isReferral, + const LDAPRequest* parent): + LDAPRequest(connect, cons, isReferral, parent){ + DEBUG(LDAP_DEBUG_CONSTRUCT, + "LDAPModDNRequest::LDAPModDNRequest(&)" << endl); + DEBUG(LDAP_DEBUG_CONSTRUCT | LDAP_DEBUG_PARAMETER, + " dn:" << dn << endl << " newRDN:" << newRDN << endl + << " deleteOld:" << deleteOld << endl + << " newParent:" << newParentDN << endl); + m_dn = dn; + m_newRDN = newRDN; + m_newParentDN = newParentDN; + m_deleteOld=deleteOld; +} + +LDAPModDNRequest::~LDAPModDNRequest(){ + DEBUG(LDAP_DEBUG_DESTROY, "LDAPModDNRequest::~LDAPModDNRequest()" << endl); +} + +LDAPMessageQueue* LDAPModDNRequest::sendRequest(){ + DEBUG(LDAP_DEBUG_TRACE, "LDAPModDNRequest::sendRequest()" << endl); + int msg_id; + const char* newRDN = (m_newRDN == "" ? 0 :m_newRDN.c_str()); + const char* newParentDN = (m_newParentDN == "" ? + 0 : + m_newParentDN.c_str()); + LDAPControl** tmpSrvCtrls=m_cons->getSrvCtrlsArray(); + LDAPControl** tmpClCtrls=m_cons->getClCtrlsArray(); + int err=ldap_rename(m_connection->getSessionHandle(),m_dn.c_str(),newRDN, + newParentDN,m_deleteOld ? 1 : 0, tmpSrvCtrls, tmpClCtrls,&msg_id); + LDAPControlSet::freeLDAPControlArray(tmpSrvCtrls); + LDAPControlSet::freeLDAPControlArray(tmpClCtrls); + if(err!=LDAP_SUCCESS){ + throw LDAPException(err); + }else{ + m_msgID=msg_id; + return new LDAPMessageQueue(this); + } +} + +LDAPRequest* LDAPModDNRequest::followReferral(LDAPMsg* ref){ + DEBUG(LDAP_DEBUG_TRACE, "LDAPModifyRequest::followReferral()" << endl); + LDAPUrlList::const_iterator usedUrl; + LDAPUrlList urls = ((LDAPResult*)ref)->getReferralUrls(); + LDAPAsynConnection* con = 0; + try { + con = getConnection()->referralConnect(urls,usedUrl,m_cons); + } catch(LDAPException e){ + delete con; + return 0; + } + if(con != 0){ + return new LDAPModDNRequest(m_dn, m_newRDN, m_deleteOld, m_newParentDN, + con, m_cons,true,this); + } + return 0; +} + diff --git a/contrib/ldapc++/src/LDAPModDNRequest.h b/contrib/ldapc++/src/LDAPModDNRequest.h new file mode 100644 index 0000000..d45c6a2 --- /dev/null +++ b/contrib/ldapc++/src/LDAPModDNRequest.h @@ -0,0 +1,33 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#ifndef LDAP_MOD_DN_REQUEST_H +#define LDAP_MOD_DN_REQUEST_H + +#include <LDAPRequest.h> + +class LDAPModDNRequest : LDAPRequest { + + public: + LDAPModDNRequest(const LDAPModDNRequest& req); + LDAPModDNRequest(const std::string& dn, const std::string& newRDN, + bool deleteOld, const std::string& newParentDN, + LDAPAsynConnection *connect, const LDAPConstraints *cons, + bool isReferral=false, const LDAPRequest* parent=0); + virtual ~LDAPModDNRequest(); + + virtual LDAPMessageQueue* sendRequest(); + virtual LDAPRequest* followReferral(LDAPMsg* urls); + + private: + std::string m_dn; + std::string m_newRDN; + std::string m_newParentDN; + bool m_deleteOld; +}; + +#endif // LDAP_MOD_DN_REQUEST_H + diff --git a/contrib/ldapc++/src/LDAPModList.cpp b/contrib/ldapc++/src/LDAPModList.cpp new file mode 100644 index 0000000..1ce248a --- /dev/null +++ b/contrib/ldapc++/src/LDAPModList.cpp @@ -0,0 +1,48 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + + +#include "LDAPModList.h" +#include "debug.h" + +#include <cstdlib> + +using namespace std; + +LDAPModList::LDAPModList(){ + DEBUG(LDAP_DEBUG_CONSTRUCT,"LDAPModList::LDAPModList()" << endl); +} + +LDAPModList::LDAPModList(const LDAPModList& ml){ + DEBUG(LDAP_DEBUG_CONSTRUCT,"LDAPModList::LDAPModList(&)" << endl); + m_modList=ml.m_modList; +} + +void LDAPModList::addModification(const LDAPModification &mod){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPModList::addModification()" << endl); + m_modList.push_back(mod); +} + +LDAPMod** LDAPModList::toLDAPModArray(){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPModList::toLDAPModArray()" << endl); + LDAPMod **ret = (LDAPMod**) malloc( + (m_modList.size()+1) * sizeof(LDAPMod*)); + ret[m_modList.size()]=0; + LDAPModList::ListType::const_iterator i; + int j=0; + for (i=m_modList.begin(); i != m_modList.end(); i++ , j++){ + ret[j]=i->toLDAPMod(); + } + return ret; +} + +bool LDAPModList::empty() const { + return m_modList.empty(); +} + +unsigned int LDAPModList::size() const { + return m_modList.size(); +} diff --git a/contrib/ldapc++/src/LDAPModList.h b/contrib/ldapc++/src/LDAPModList.h new file mode 100644 index 0000000..5b0323c --- /dev/null +++ b/contrib/ldapc++/src/LDAPModList.h @@ -0,0 +1,59 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + + +#ifndef LDAP_MOD_LIST_H +#define LDAP_MOD_LIST_H + +#include <ldap.h> +#include <list> +#include <LDAPModification.h> + +/** + * This container class is used to store multiple LDAPModification-objects. + */ +class LDAPModList{ + typedef std::list<LDAPModification> ListType; + + public : + /** + * Constructs an empty list. + */ + LDAPModList(); + + /** + * Copy-constructor + */ + LDAPModList(const LDAPModList&); + + /** + * Adds one element to the end of the list. + * @param mod The LDAPModification to add to the std::list. + */ + void addModification(const LDAPModification &mod); + + /** + * Translates the list to a 0-terminated array of + * LDAPMod-structures as needed by the C-API + */ + LDAPMod** toLDAPModArray(); + + /** + * @returns true, if the ModList contains no Operations + */ + bool empty() const; + + /** + * @returns number of Modifications in the ModList + */ + unsigned int size() const; + + private : + ListType m_modList; +}; +#endif //LDAP_MOD_LIST_H + + diff --git a/contrib/ldapc++/src/LDAPModification.cpp b/contrib/ldapc++/src/LDAPModification.cpp new file mode 100644 index 0000000..f10a792 --- /dev/null +++ b/contrib/ldapc++/src/LDAPModification.cpp @@ -0,0 +1,48 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + + +#include "LDAPModification.h" +#include "debug.h" + +using namespace std; + +LDAPModification::LDAPModification(const LDAPAttribute& attr, mod_op op){ + DEBUG(LDAP_DEBUG_CONSTRUCT,"LDAPModification::LDAPModification()" << endl); + DEBUG(LDAP_DEBUG_CONSTRUCT | LDAP_DEBUG_PARAMETER, + " attr:" << attr << endl); + m_attr = attr; + m_mod_op = op; +} + +LDAPMod* LDAPModification::toLDAPMod() const { + DEBUG(LDAP_DEBUG_TRACE,"LDAPModification::toLDAPMod()" << endl); + LDAPMod* ret=m_attr.toLDAPMod(); + + //The mod_op value of the LDAPMod-struct needs to be ORed with the right + // LDAP_MOD_* constant to preserve the BIN-flag (see CAPI-draft for + // explanation of the LDAPMod struct) + switch (m_mod_op){ + case OP_ADD : + ret->mod_op |= LDAP_MOD_ADD; + break; + case OP_DELETE : + ret->mod_op |= LDAP_MOD_DELETE; + break; + case OP_REPLACE : + ret->mod_op |= LDAP_MOD_REPLACE; + break; + } + return ret; +} + +const LDAPAttribute* LDAPModification::getAttribute() const { + return &m_attr; +} + +LDAPModification::mod_op LDAPModification::getOperation() const { + return m_mod_op; +} diff --git a/contrib/ldapc++/src/LDAPModification.h b/contrib/ldapc++/src/LDAPModification.h new file mode 100644 index 0000000..25f5be4 --- /dev/null +++ b/contrib/ldapc++/src/LDAPModification.h @@ -0,0 +1,30 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + + +#ifndef LDAP_MODIFICATION_H +#define LDAP_MODIFICATION_H + +#include <ldap.h> +#include <LDAPAttribute.h> + +class LDAPModification{ + public: + enum mod_op {OP_ADD, OP_DELETE, OP_REPLACE}; + + LDAPModification(const LDAPAttribute& attr, mod_op op); + LDAPMod *toLDAPMod() const; + + const LDAPAttribute* getAttribute() const; + mod_op getOperation() const; + + private: + LDAPAttribute m_attr; + mod_op m_mod_op; + +}; +#endif //LDAP_MODIFICATION_H + diff --git a/contrib/ldapc++/src/LDAPModifyRequest.cpp b/contrib/ldapc++/src/LDAPModifyRequest.cpp new file mode 100644 index 0000000..a7ca55a --- /dev/null +++ b/contrib/ldapc++/src/LDAPModifyRequest.cpp @@ -0,0 +1,81 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#include <ldap.h> + +#include "debug.h" + +#include "LDAPModifyRequest.h" +#include "LDAPException.h" +#include "LDAPMessageQueue.h" +#include "LDAPResult.h" + +using namespace std; + +LDAPModifyRequest::LDAPModifyRequest(const LDAPModifyRequest& req) : + LDAPRequest(req){ + DEBUG(LDAP_DEBUG_CONSTRUCT, + "LDAPModifyRequest::LDAPModifyRequest(&)" << endl); + m_modList = new LDAPModList(*(req.m_modList)); + m_dn = req.m_dn; +} + +LDAPModifyRequest::LDAPModifyRequest(const string& dn, + const LDAPModList *modList, LDAPAsynConnection *connect, + const LDAPConstraints *cons, bool isReferral, + const LDAPRequest* parent) : + LDAPRequest(connect, cons, isReferral, parent){ + DEBUG(LDAP_DEBUG_CONSTRUCT, + "LDAPModifyRequest::LDAPModifyRequest(&)" << endl); + DEBUG(LDAP_DEBUG_CONSTRUCT | LDAP_DEBUG_PARAMETER, + " dn:" << dn << endl); + m_dn = dn; + m_modList = new LDAPModList(*modList); +} + +LDAPModifyRequest::~LDAPModifyRequest(){ + DEBUG(LDAP_DEBUG_DESTROY, + "LDAPModifyRequest::~LDAPModifyRequest()" << endl); + delete m_modList; +} + +LDAPMessageQueue* LDAPModifyRequest::sendRequest(){ + DEBUG(LDAP_DEBUG_TRACE, "LDAPModifyRequest::sendRequest()" << endl); + int msgID=0; + LDAPControl** tmpSrvCtrls=m_cons->getSrvCtrlsArray(); + LDAPControl** tmpClCtrls=m_cons->getClCtrlsArray(); + LDAPMod** tmpMods=m_modList->toLDAPModArray(); + int err=ldap_modify_ext(m_connection->getSessionHandle(),m_dn.c_str(), + tmpMods, tmpSrvCtrls, tmpClCtrls,&msgID); + LDAPControlSet::freeLDAPControlArray(tmpSrvCtrls); + LDAPControlSet::freeLDAPControlArray(tmpClCtrls); + ldap_mods_free(tmpMods,1); + if(err != LDAP_SUCCESS){ + throw LDAPException(err); + }else{ + m_msgID=msgID; + return new LDAPMessageQueue(this); + } +} + +LDAPRequest* LDAPModifyRequest::followReferral(LDAPMsg* ref){ + DEBUG(LDAP_DEBUG_TRACE, "LDAPModifyRequest::followReferral()" << endl); + LDAPUrlList::const_iterator usedUrl; + LDAPUrlList urls = ((LDAPResult*)ref)->getReferralUrls(); + LDAPAsynConnection* con = 0; + try { + con = getConnection()->referralConnect(urls,usedUrl,m_cons); + } catch(LDAPException e){ + delete con; + return 0; + } + if(con != 0){ + return new LDAPModifyRequest(m_dn, m_modList, con, m_cons,true,this); + } + return 0; +} + + diff --git a/contrib/ldapc++/src/LDAPModifyRequest.h b/contrib/ldapc++/src/LDAPModifyRequest.h new file mode 100644 index 0000000..a1eccdd --- /dev/null +++ b/contrib/ldapc++/src/LDAPModifyRequest.h @@ -0,0 +1,30 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#ifndef LDAP_MODIFY_REQUEST_H +#define LDAP_MODIFY_REQUEST_H + +#include <LDAPRequest.h> + +class LDAPMessageQueue; + +class LDAPModifyRequest : LDAPRequest { + private : + std::string m_dn; + LDAPModList *m_modList; + + public: + LDAPModifyRequest(const LDAPModifyRequest& mod); + LDAPModifyRequest(const std::string& dn, const LDAPModList *modList, + LDAPAsynConnection *connect, const LDAPConstraints *cons, + bool isReferral=false, const LDAPRequest* req=0); + virtual ~LDAPModifyRequest(); + virtual LDAPMessageQueue* sendRequest(); + virtual LDAPRequest* followReferral(LDAPMsg* refs); +}; + +#endif // LDAP_MODIFY_REQUEST_H + diff --git a/contrib/ldapc++/src/LDAPObjClass.cpp b/contrib/ldapc++/src/LDAPObjClass.cpp new file mode 100644 index 0000000..e3899f1 --- /dev/null +++ b/contrib/ldapc++/src/LDAPObjClass.cpp @@ -0,0 +1,130 @@ +// $OpenLDAP$ +/* + * Copyright 2003-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#include "debug.h" +#include "LDAPObjClass.h" + + +LDAPObjClass::LDAPObjClass(){ + DEBUG(LDAP_DEBUG_CONSTRUCT, + "LDAPObjClass::LDAPObjClass( )" << endl); + + oid = string (); + desc = string (); + names = StringList (); + must = StringList(); + may = StringList(); + sup = StringList(); +} + +LDAPObjClass::LDAPObjClass (const LDAPObjClass &oc){ + DEBUG(LDAP_DEBUG_CONSTRUCT, + "LDAPObjClass::LDAPObjClass( )" << endl); + + oid = oc.oid; + desc = oc.desc; + names = oc.names; + must = oc.must; + may = oc.may; + kind = oc.kind; + sup = oc.sup; +} + +LDAPObjClass::LDAPObjClass (string oc_item, int flags ) { + + DEBUG(LDAP_DEBUG_CONSTRUCT, + "LDAPObjClass::LDAPObjClass( )" << endl); + + LDAPObjectClass *o; + int ret; + const char *errp; + o = ldap_str2objectclass ( oc_item.c_str(), &ret, &errp, flags ); + + if (o) { + this->setNames (o->oc_names); + this->setDesc (o->oc_desc); + this->setOid (o->oc_oid); + this->setKind (o->oc_kind); + this->setMust (o->oc_at_oids_must); + this->setMay (o->oc_at_oids_may); + this->setSup (o->oc_sup_oids); + } + // else? -> error +} + +LDAPObjClass::~LDAPObjClass() { + DEBUG(LDAP_DEBUG_DESTROY,"LDAPObjClass::~LDAPObjClass()" << endl); +} + +void LDAPObjClass::setKind (int oc_kind) { + kind = oc_kind; +} + +void LDAPObjClass::setNames (char **oc_names) { + names = StringList (oc_names); +} + +void LDAPObjClass::setMust (char **oc_must) { + must = StringList (oc_must); +} + +void LDAPObjClass::setMay (char **oc_may) { + may = StringList (oc_may); +} + +void LDAPObjClass::setSup (char **oc_sup) { + sup = StringList (oc_sup); +} + +void LDAPObjClass::setDesc (char *oc_desc) { + desc = string (); + if (oc_desc) + desc = oc_desc; +} + +void LDAPObjClass::setOid (char *oc_oid) { + oid = string (); + if (oc_oid) + oid = oc_oid; +} + +string LDAPObjClass::getOid() const { + return oid; +} + +string LDAPObjClass::getDesc() const { + return desc; +} + +StringList LDAPObjClass::getNames() const { + return names; +} + +StringList LDAPObjClass::getMust() const { + return must; +} + +StringList LDAPObjClass::getMay() const { + return may; +} + +StringList LDAPObjClass::getSup() const { + return sup; +} + +string LDAPObjClass::getName() const { + + if (names.empty()) + return ""; + else + return *(names.begin()); +} + +int LDAPObjClass::getKind() const { + return kind; +} + + diff --git a/contrib/ldapc++/src/LDAPObjClass.h b/contrib/ldapc++/src/LDAPObjClass.h new file mode 100644 index 0000000..e9c7b42 --- /dev/null +++ b/contrib/ldapc++/src/LDAPObjClass.h @@ -0,0 +1,104 @@ +// $OpenLDAP$ +/* + * Copyright 2003-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#ifndef LDAP_OBJCLASS_H +#define LDAP_OBJCLASS_H + +#include <ldap_schema.h> +#include <string> + +#include "StringList.h" + +using namespace std; + +/** + * Represents the Object Class (from LDAP schema) + */ +class LDAPObjClass{ + private : + StringList names, must, may, sup; + string desc, oid; + int kind; + + public : + + /** + * Constructs an empty object. + */ + LDAPObjClass(); + + /** + * Copy constructor + */ + LDAPObjClass( const LDAPObjClass& oc ); + + /** + * Constructs new object and fills the data structure by parsing the + * argument. + * @param oc_item description of object class is string returned + * by the search command. It is in the form: + * "( SuSE.YaST.OC:5 NAME 'userTemplate' SUP objectTemplate STRUCTURAL + * DESC 'User object template' MUST ( cn ) MAY ( secondaryGroup ))" + */ + LDAPObjClass (string oc_item, int flags = LDAP_SCHEMA_ALLOW_NO_OID | + LDAP_SCHEMA_ALLOW_QUOTED); + + /** + * Destructor + */ + virtual ~LDAPObjClass(); + + /** + * Returns object class description + */ + string getDesc() const; + + /** + * Returns object class oid + */ + string getOid() const; + + /** + * Returns object class name (first one if there are more of them) + */ + string getName() const; + + /** + * Returns object class kind: 0=ABSTRACT, 1=STRUCTURAL, 2=AUXILIARY + */ + int getKind() const; + + /** + * Returns all object class names + */ + StringList getNames() const; + + /** + * Returns list of required attributes + */ + StringList getMust() const; + + /** + * Returns list of allowed (and not required) attributes + */ + StringList getMay() const; + + /** + * Returns list of the OIDs of the superior ObjectClasses + */ + StringList getSup() const; + + void setNames (char **oc_names); + void setMay (char **oc_may); + void setMust (char **oc_must); + void setDesc (char *oc_desc); + void setOid (char *oc_oid); + void setKind (int oc_kind); + void setSup (char **oc_sup); + +}; + +#endif // LDAP_OBJCLASS_H diff --git a/contrib/ldapc++/src/LDAPRebind.cpp b/contrib/ldapc++/src/LDAPRebind.cpp new file mode 100644 index 0000000..cde229a --- /dev/null +++ b/contrib/ldapc++/src/LDAPRebind.cpp @@ -0,0 +1,9 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#include "LDAPRebind.h" + + diff --git a/contrib/ldapc++/src/LDAPRebind.h b/contrib/ldapc++/src/LDAPRebind.h new file mode 100644 index 0000000..9fe7737 --- /dev/null +++ b/contrib/ldapc++/src/LDAPRebind.h @@ -0,0 +1,27 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#ifndef LDAP_REBIND_H +#define LDAP_REBIND_H + +#include <string> +#include <LDAPRebindAuth.h> + +/** + * Just an abstract class to provide a mechanism for rebind to another + * server when chasing referrals. Clients have to implement a class + * derived from this. To use authentication other than anonymous for + * referral chasing + */ + +class LDAPRebind{ + public: + virtual ~LDAPRebind() {} + virtual LDAPRebindAuth* getRebindAuth(const std::string& hostname, + int port) const = 0; +}; +#endif //LDAP_REBIND_H + diff --git a/contrib/ldapc++/src/LDAPRebindAuth.cpp b/contrib/ldapc++/src/LDAPRebindAuth.cpp new file mode 100644 index 0000000..80c726b --- /dev/null +++ b/contrib/ldapc++/src/LDAPRebindAuth.cpp @@ -0,0 +1,40 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#include <iostream> + +#include "LDAPRebindAuth.h" +#include "debug.h" + +using namespace std; + +LDAPRebindAuth::LDAPRebindAuth(const string& dn, const string& pwd){ + DEBUG(LDAP_DEBUG_CONSTRUCT,"LDAPRebindAuth::LDAPRebindAuth()" << endl); + DEBUG(LDAP_DEBUG_CONSTRUCT | LDAP_DEBUG_PARAMETER," dn:" << dn << endl + << " pwd:" << pwd << endl); + m_dn=dn; + m_password=pwd; +} + +LDAPRebindAuth::LDAPRebindAuth(const LDAPRebindAuth& lra){ + DEBUG(LDAP_DEBUG_CONSTRUCT,"LDAPRebindAuth::LDAPRebindAuth(&)" << endl); + m_dn=lra.m_dn; + m_password=lra.m_password; +} + +LDAPRebindAuth::~LDAPRebindAuth(){ + DEBUG(LDAP_DEBUG_DESTROY,"LDAPRebindAuth::~LDAPRebindAuth()" << endl); +} + +const string& LDAPRebindAuth::getDN() const{ + DEBUG(LDAP_DEBUG_TRACE,"LDAPRebindAuth::getDN()" << endl); + return m_dn; +} + +const string& LDAPRebindAuth::getPassword() const{ + DEBUG(LDAP_DEBUG_TRACE,"LDAPRebindAuth::getPassword()" << endl); + return m_password; +} diff --git a/contrib/ldapc++/src/LDAPRebindAuth.h b/contrib/ldapc++/src/LDAPRebindAuth.h new file mode 100644 index 0000000..60c12ac --- /dev/null +++ b/contrib/ldapc++/src/LDAPRebindAuth.h @@ -0,0 +1,55 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#ifndef LDAP_REBIND_AUTH_H +#define LDAP_REBIND_AUTH_H + +#include<string> + +/** + * This class represent Authentication information for the case that the + * library is chasing referrals. + * + * The LDAPRebind::getRebindAuth() method returns an object of this type. + * And the library uses it to authentication to the destination server of a + * referral. + * @note currently only SIMPLE authentication is supported by the library + */ +class LDAPRebindAuth{ + public: + /** + * @param dn The DN that should be used for the authentication + * @param pwd The password that belongs to the DN + */ + LDAPRebindAuth(const std::string& dn="", const std::string& pwd=""); + + /** + * Copy-constructor + */ + LDAPRebindAuth(const LDAPRebindAuth& lra); + + /** + * Destructor + */ + virtual ~LDAPRebindAuth(); + + /** + * @return The DN that was set in the constructor + */ + const std::string& getDN() const; + + /** + * @return The password that was set in the constructor + */ + const std::string& getPassword() const; + + private: + std::string m_dn; + std::string m_password; +}; + +#endif //LDAP_REBIND_AUTH_H + diff --git a/contrib/ldapc++/src/LDAPReferenceList.cpp b/contrib/ldapc++/src/LDAPReferenceList.cpp new file mode 100644 index 0000000..53cef03 --- /dev/null +++ b/contrib/ldapc++/src/LDAPReferenceList.cpp @@ -0,0 +1,40 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + + +#include "LDAPReferenceList.h" +#include "LDAPSearchReference.h" + +LDAPReferenceList::LDAPReferenceList(){ +} + +LDAPReferenceList::LDAPReferenceList(const LDAPReferenceList& e){ + m_refs = e.m_refs; +} + +LDAPReferenceList::~LDAPReferenceList(){ +} + +size_t LDAPReferenceList::size() const{ + return m_refs.size(); +} + +bool LDAPReferenceList::empty() const{ + return m_refs.empty(); +} + +LDAPReferenceList::const_iterator LDAPReferenceList::begin() const{ + return m_refs.begin(); +} + +LDAPReferenceList::const_iterator LDAPReferenceList::end() const{ + return m_refs.end(); +} + +void LDAPReferenceList::addReference(const LDAPSearchReference& e){ + m_refs.push_back(e); +} + diff --git a/contrib/ldapc++/src/LDAPReferenceList.h b/contrib/ldapc++/src/LDAPReferenceList.h new file mode 100644 index 0000000..f4f60f3 --- /dev/null +++ b/contrib/ldapc++/src/LDAPReferenceList.h @@ -0,0 +1,74 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#ifndef LDAP_REFERENCE_LIST_H +#define LDAP_REFERENCE_LIST_H + +#include <cstdio> +#include <list> + +class LDAPSearchReference; + +/** + * Container class for storing a list of Search References + * + * Used internally only by LDAPSearchResults + */ +class LDAPReferenceList{ + typedef std::list<LDAPSearchReference> ListType; + + public: + typedef ListType::const_iterator const_iterator; + + /** + * Constructs an empty list. + */ + LDAPReferenceList(); + + /** + * Copy-constructor + */ + LDAPReferenceList(const LDAPReferenceList& rl); + + /** + * Destructor + */ + ~LDAPReferenceList(); + + /** + * @return The number of LDAPSearchReference-objects that are + * currently stored in this list. + */ + size_t size() const; + + /** + * @return true if there are zero LDAPSearchReference-objects + * currently stored in this list. + */ + bool empty() const; + + /** + * @return A iterator that points to the first element of the list. + */ + const_iterator begin() const; + + /** + * @return A iterator that points to the element after the last + * element of the list. + */ + const_iterator end() const; + + /** + * Adds one element to the end of the list. + * @param e The LDAPSearchReference to add to the list. + */ + void addReference(const LDAPSearchReference& e); + + private: + ListType m_refs; +}; +#endif // LDAP_REFERENCE_LIST_H + diff --git a/contrib/ldapc++/src/LDAPRequest.cpp b/contrib/ldapc++/src/LDAPRequest.cpp new file mode 100644 index 0000000..57839ce --- /dev/null +++ b/contrib/ldapc++/src/LDAPRequest.cpp @@ -0,0 +1,145 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + + +#include "debug.h" +#include "LDAPRequest.h" + +using namespace std; + +LDAPRequest::LDAPRequest(){ + DEBUG(LDAP_DEBUG_CONSTRUCT, "LDAPRequest::LDAPRequest()" << endl); +} + +LDAPRequest::LDAPRequest(const LDAPRequest& req){ + DEBUG(LDAP_DEBUG_CONSTRUCT, "LDAPRequest::LDAPRequest(&)" << endl); + m_isReferral=req.m_isReferral; + m_cons = new LDAPConstraints(*(req.m_cons)); + m_connection = req.m_connection; + m_parent = req.m_parent; + m_hopCount = req.m_hopCount; + m_msgID = req.m_msgID; +} + +LDAPRequest::LDAPRequest(LDAPAsynConnection* con, + const LDAPConstraints* cons,bool isReferral, const LDAPRequest* parent){ + DEBUG(LDAP_DEBUG_CONSTRUCT,"LDAPRequest::LDAPRequest()" << endl); + m_connection=con; + if(cons == 0){ + m_cons=new LDAPConstraints( *(con->getConstraints()) ); + }else{ + m_cons=new LDAPConstraints( *cons); + } + m_isReferral=isReferral; + if(m_isReferral){ + m_hopCount = (parent->getHopCount()+1); + m_parent= parent; + }else{ + m_hopCount=0; + m_parent=0; + } +} + +LDAPRequest::~LDAPRequest(){ + DEBUG(LDAP_DEBUG_DESTROY,"LDAPRequest::~LDAPRequest()" << endl); + delete m_cons; +} + +LDAPMsg* LDAPRequest::getNextMessage() const +{ + DEBUG(LDAP_DEBUG_DESTROY,"LDAPRequest::getNextMessage()" << endl); + int res; + LDAPMessage *msg; + + res=ldap_result(this->m_connection->getSessionHandle(), + this->m_msgID,0,0,&msg); + + if (res <= 0){ + if(msg != 0){ + ldap_msgfree(msg); + } + throw LDAPException(this->m_connection); + }else{ + LDAPMsg *ret=0; + //this can throw an exception (Decoding Error) + ret = LDAPMsg::create(this,msg); + ldap_msgfree(msg); + return ret; + } +} + +LDAPRequest* LDAPRequest::followReferral(LDAPMsg* /*urls*/){ + DEBUG(LDAP_DEBUG_TRACE,"LDAPBindRequest::followReferral()" << endl); + DEBUG(LDAP_DEBUG_TRACE, + "ReferralChasing not implemented for this operation" << endl); + return 0; +} + +const LDAPConstraints* LDAPRequest::getConstraints() const{ + DEBUG(LDAP_DEBUG_TRACE,"LDAPRequest::getConstraints()" << endl); + return m_cons; +} + +const LDAPAsynConnection* LDAPRequest::getConnection() const{ + DEBUG(LDAP_DEBUG_TRACE,"LDAPRequest::getConnection()" << endl); + return m_connection; +} + +int LDAPRequest::getType() const { + DEBUG(LDAP_DEBUG_TRACE,"LDAPRequest::getType()" << endl); + return m_requestType; +} + +int LDAPRequest::getMsgID() const { + DEBUG(LDAP_DEBUG_TRACE,"LDAPRequest::getMsgId()" << endl); + return m_msgID; +} + +int LDAPRequest::getHopCount() const { + DEBUG(LDAP_DEBUG_TRACE,"LDAPRequest::getHopCount()" << endl); + return m_hopCount; +} + +const LDAPRequest* LDAPRequest::getParent() const{ + DEBUG(LDAP_DEBUG_TRACE,"LDAPRequest::getParent()" << endl); + return m_parent; +} + +bool LDAPRequest::isReferral() const { + DEBUG(LDAP_DEBUG_TRACE,"LDAPRequest::isReferral()" << endl); + return m_isReferral; +} + +bool LDAPRequest::equals(const LDAPRequest* req) const{ + DEBUG(LDAP_DEBUG_TRACE,"LDAPRequest::equals()" << endl); + if( (this->m_requestType == req->getType()) && + (this->m_connection->getHost() == req->m_connection->getHost()) && + (this->m_connection->getPort() == req->m_connection->getPort()) + ){ + return true; + }return false; +} + +bool LDAPRequest::isCycle() const{ + DEBUG(LDAP_DEBUG_TRACE,"LDAPRequest::isCycle()" << endl); + const LDAPRequest* parent=m_parent; + if(parent != 0){ + do{ + if(this->equals(parent)){ + return true; + }else{ + parent=parent->getParent(); + } + } + while(parent != 0); + } + return false; +} + +void LDAPRequest::unbind() const{ + DEBUG(LDAP_DEBUG_TRACE,"LDAPRequest::unbind()" << endl); + m_connection->unbind(); +} diff --git a/contrib/ldapc++/src/LDAPRequest.h b/contrib/ldapc++/src/LDAPRequest.h new file mode 100644 index 0000000..059002b --- /dev/null +++ b/contrib/ldapc++/src/LDAPRequest.h @@ -0,0 +1,89 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + + +#ifndef LDAP_REQUEST_H +#define LDAP_REQUEST_H + +#include <LDAPConstraints.h> +#include <LDAPAsynConnection.h> +#include <LDAPMessageQueue.h> + +class LDAPUrl; + +/** + * For internal use only + * + * Each request that is sent to a LDAP-server by this library is + * represented by a special object that contains the parameters and some + * other info of the request. This virtual class is the common base class + * for these specialized request classes. + */ +class LDAPRequest{ + + public : + static const int BIND=0; + static const int UNBIND=2; + static const int SEARCH=3; + static const int MODIFY=7; + static const int ADD=8; + static const int DELETE=10; + static const int COMPARE=14; + + LDAPRequest(const LDAPRequest& req); + LDAPRequest(LDAPAsynConnection* conn, + const LDAPConstraints* cons, bool isReferral=false, + const LDAPRequest* parent=0); + virtual ~LDAPRequest(); + + const LDAPConstraints* getConstraints() const; + const LDAPAsynConnection* getConnection() const; + virtual LDAPMsg *getNextMessage() const; + int getType()const; + int getMsgID() const; + int getHopCount() const; + + /** + * @return The LDAPRequest that has created this object. Or 0 if + * this object was not created by another request. + */ + const LDAPRequest* getParent() const; + + /** + * @return true if this object was created during the automatic + * chasing of referrals. Otherwise false + */ + bool isReferral() const; + + void unbind() const; + + /** + * This method encodes the request an calls the appropriate + * functions of the C-API to send the Request to a LDAP-Server + */ + virtual LDAPMessageQueue* sendRequest()=0; + virtual LDAPRequest* followReferral(LDAPMsg* ref); + + /** + * Compare this request with another on. And returns true if they + * have the same parameters. + */ + virtual bool equals(const LDAPRequest* req) const; + + bool isCycle() const; + + protected : + bool m_isReferral; + int m_requestType; + LDAPConstraints *m_cons; + LDAPAsynConnection *m_connection; + const LDAPRequest* m_parent; + int m_hopCount; + int m_msgID; //the associated C-API Message ID + LDAPRequest(); +}; +#endif //LDAP_REQUEST_H + diff --git a/contrib/ldapc++/src/LDAPResult.cpp b/contrib/ldapc++/src/LDAPResult.cpp new file mode 100644 index 0000000..fd35438 --- /dev/null +++ b/contrib/ldapc++/src/LDAPResult.cpp @@ -0,0 +1,96 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + + +#include "debug.h" +#include"LDAPResult.h" +#include"LDAPAsynConnection.h" +#include "LDAPRequest.h" +#include "LDAPException.h" + +#include <cstdlib> + +using namespace std; + +LDAPResult::LDAPResult(const LDAPRequest *req, LDAPMessage *msg) : + LDAPMsg(msg){ + if(msg != 0){ + DEBUG(LDAP_DEBUG_CONSTRUCT,"LDAPResult::LDAPResult()" << endl); + const LDAPAsynConnection *con=req->getConnection(); + char **refs=0; + LDAPControl** srvctrls=0; + char* matchedDN=0; + char* errMsg=0; + int err=ldap_parse_result(con->getSessionHandle(),msg,&m_resCode, + &matchedDN, &errMsg,&refs,&srvctrls,0); + if(err != LDAP_SUCCESS){ + ber_memvfree((void**) refs); + ldap_controls_free(srvctrls); + throw LDAPException(err); + }else{ + if (refs){ + m_referrals=LDAPUrlList(refs); + ber_memvfree((void**) refs); + } + if (srvctrls){ + m_srvControls = LDAPControlSet(srvctrls); + m_hasControls = true; + ldap_controls_free(srvctrls); + }else{ + m_hasControls = false; + } + if(matchedDN != 0){ + m_matchedDN=string(matchedDN); + free(matchedDN); + } + if(errMsg != 0){ + m_errMsg=string(errMsg); + free(errMsg); + } + } + } +} + +LDAPResult::LDAPResult(int type, int resultCode, const std::string &msg) : + LDAPMsg(type,0), m_resCode(resultCode), m_errMsg(msg) +{} + + +LDAPResult::~LDAPResult(){ + DEBUG(LDAP_DEBUG_DESTROY,"LDAPResult::~LDAPResult()" << endl); +} + +int LDAPResult::getResultCode() const{ + DEBUG(LDAP_DEBUG_TRACE,"LDAPResult::getResultCode()" << endl); + return m_resCode; +} + +string LDAPResult::resToString() const{ + DEBUG(LDAP_DEBUG_TRACE,"LDAPResult::resToString()" << endl); + return string(ldap_err2string(m_resCode)); +} + +const string& LDAPResult::getErrMsg() const{ + DEBUG(LDAP_DEBUG_TRACE,"LDAPResult::getErrMsg()" << endl); + return m_errMsg; +} + +const string& LDAPResult::getMatchedDN() const{ + DEBUG(LDAP_DEBUG_TRACE,"LDAPResult::getMatchedDN()" << endl); + return m_matchedDN; +} + +const LDAPUrlList& LDAPResult::getReferralUrls() const{ + DEBUG(LDAP_DEBUG_TRACE,"LDAPResult::getReferralUrl()" << endl); + return m_referrals; +} + +ostream& operator<<(ostream &s,LDAPResult &l){ + return s << "Result: " << l.m_resCode << ": " + << ldap_err2string(l.m_resCode) << endl + << "Matched: " << l.m_matchedDN << endl << "ErrMsg: " << l.m_errMsg; +} + diff --git a/contrib/ldapc++/src/LDAPResult.h b/contrib/ldapc++/src/LDAPResult.h new file mode 100644 index 0000000..a90d010 --- /dev/null +++ b/contrib/ldapc++/src/LDAPResult.h @@ -0,0 +1,162 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + + +#ifndef LDAP_RESULT_H +#define LDAP_RESULT_H + +#include<iostream> +#include<ldap.h> +#include <LDAPMessage.h> +#include <LDAPControlSet.h> +#include <LDAPUrlList.h> + +class LDAPRequest; +class LDAPAsynConnection; + +/** + * This class is for representing LDAP-Result-Messages. + * + * It represents all Messages that were returned + * from LDAP-Operations except for Messages of the Type + * LDAPMsg::SEARCH_ENTRY, LDAPMsg::SEARCH_REFERENCE and + * LDAPMsg::EXTENDED_RESPONSE. <BR> + * It defines a integer constant for every possible result type that can be + * returned by the server. + */ +class LDAPResult : public LDAPMsg{ + public : + //Error codes from RFC 2251 + static const int SUCCESS = 0; + static const int OPERATIONS_ERROR = 1; + static const int PROTOCOL_ERROR = 2; + static const int TIME_LIMIT_EXCEEDED = 3; + static const int SIZE_LIMIT_EXCEEDED = 4; + static const int COMPARE_FALSE = 5; + static const int COMPARE_TRUE = 6; + static const int AUTH_METHOD_NOT_SUPPORTED = 7; + static const int STRONG_AUTH_REQUIRED = 8; + + static const int REFERRAL = 10; + static const int ADMIN_LIMIT_EXCEEDED = 11; + static const int UNAVAILABLE_CRITICAL_EXTENSION = 12; + static const int CONFIDENTIALITY_REQUIRED = 13; + static const int SASL_BIND_IN_PROGRESS = 14; + + static const int NO_SUCH_ATTRIBUTE = 16; + static const int UNDEFINED_ATTRIBUTE_TYP = 17; + static const int INAPPROPRIATE_MATCHING = 18; + static const int CONSTRAINT_VIOLATION = 19; + static const int ATTRIBUTE_OR_VALUE_EXISTS = 20; + static const int INVALID_ATTRIBUTE_SYNTAX = 21; + + static const int NO_SUCH_OBJECT = 32; + static const int ALIAS_PROBLEM = 33; + static const int INVALID_DN_SYNTAX = 34; + + static const int ALIAS_DEREFERENCING_PROBLEM = 36; + + static const int INAPPROPRIATE_AUTHENTICATION = 48; + static const int INVALID_CREDENTIALS = 49; + static const int INSUFFICIENT_ACCESS = 50; + static const int BUSY = 51; + static const int UNAVAILABLE = 52; + static const int UNWILLING_TO_PERFORM = 53; + static const int LOOP_DETECT = 54; + + static const int NAMING_VIOLATION = 64; + static const int OBJECT_CLASS_VIOLATION = 65; + static const int NOT_ALLOWED_ON_NONLEAF = 66; + static const int NOT_ALLOWED_ON_RDN = 67; + static const int ENTRY_ALREADY_EXISTS = 68; + static const int OBJECT_CLASS_MODS_PROHIBITED = 69; + + static const int AFFECTS_MULTIPLE_DSAS = 71; + + // some Errorcodes defined in the LDAP C API DRAFT + static const int OTHER = 80; + static const int SERVER_DOWN = 81; + static const int LOCAL_ERROR = 82; + static const int ENCODING_ERROR = 83; + static const int DECODING_ERROR = 84; + static const int TIMEOUT = 85; + static const int AUTH_UNKNOWN = 86; + static const int FILTER_ERROR = 87; + static const int USER_CANCELLED = 88; + static const int PARAM_ERROR = 89; + static const int NO_MEMORY = 90; + static const int CONNECT_ERROR = 91; + static const int NOT_SUPPORTED = 92; + static const int CONTROL_NOT_FOUND = 93; + static const int NO_RESULTS_RETURNED = 94; + static const int MORE_RESULTS_TO_RETURN = 95; + static const int CLIENT_LOOP = 96; + static const int REFERRAL_LIMIT_EXCEEDED = 97; + + /** + * This constructor is called by the LDAPMsg::create method in + * order to parse a LDAPResult-Message + * @param req The request the result is associated with. + * @param msg The LDAPMessage-structure that contains the + * Message. + */ + LDAPResult(const LDAPRequest *req, LDAPMessage *msg); + LDAPResult(int type, int resultCode, const std::string &msg); + + /** + * The destructor. + */ + virtual ~LDAPResult(); + + /** + * @returns The result code of the Message. Possible values are the + * integer constants defined in this class. + */ + int getResultCode() const; + + /** + * This method transforms the result code to a human-readable + * result message. + * @returns A std::string containing the result message. + */ + std::string resToString() const; + + /** + * In some case of error the server may return additional error + * messages. + * @returns The additional error message returned by the server. + */ + const std::string& getErrMsg() const; + + /** + * For messages with a result code of: NO_SUCH_OBJECT, + * ALIAS_PROBLEM, ALIAS_DEREFERENCING_PROBLEM or INVALID_DN_SYNTAX + * the server returns the DN of deepest entry in the DIT that could + * be found for this operation. + * @returns The Matched-DN value that was returned by the server. + */ + const std::string& getMatchedDN() const; + + /** + * @returns If the result code is REFERRAL this method returns the + * URLs of the referral that was sent by the server. + */ + const LDAPUrlList& getReferralUrls() const; + + private : + int m_resCode; + std::string m_matchedDN; + std::string m_errMsg; + LDAPUrlList m_referrals; + + /** + * This method can be used to dump the data of a LDAPResult-Object. + * It is only useful for debugging purposes at the moment + */ + friend std::ostream& operator<<(std::ostream &s,LDAPResult &l); +}; +#endif //LDAP_RESULT_H + diff --git a/contrib/ldapc++/src/LDAPSaslBindResult.cpp b/contrib/ldapc++/src/LDAPSaslBindResult.cpp new file mode 100644 index 0000000..ae15cfb --- /dev/null +++ b/contrib/ldapc++/src/LDAPSaslBindResult.cpp @@ -0,0 +1,45 @@ +// $OpenLDAP$ +/* + * Copyright 2007-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#include "debug.h" +#include <lber.h> +#include "LDAPRequest.h" +#include "LDAPException.h" + +#include "LDAPResult.h" +#include "LDAPSaslBindResult.h" + +using namespace std; + +LDAPSaslBindResult::LDAPSaslBindResult(const LDAPRequest* req, LDAPMessage* msg) : + LDAPResult(req, msg){ + DEBUG(LDAP_DEBUG_CONSTRUCT,"LDAPSaslBindResult::LDAPSaslBindResult()" + << std::endl); + BerValue* data = 0; + LDAP* lc = req->getConnection()->getSessionHandle(); + int err = ldap_parse_sasl_bind_result(lc, msg, &data, 0); + if( err != LDAP_SUCCESS && err != LDAP_SASL_BIND_IN_PROGRESS ){ + ber_bvfree(data); + throw LDAPException(err); + }else{ + if(data){ + DEBUG(LDAP_DEBUG_TRACE, " creds present" << std::endl); + m_creds=string(data->bv_val, data->bv_len); + ber_bvfree(data); + } else { + DEBUG(LDAP_DEBUG_TRACE, " no creds present" << std::endl); + } + } +} + +LDAPSaslBindResult::~LDAPSaslBindResult(){ + DEBUG(LDAP_DEBUG_DESTROY,"LDAPSaslBindResult::~LDAPSaslBindResult()" << endl); +} + +const string& LDAPSaslBindResult::getServerCreds() const{ + return m_creds; +} + diff --git a/contrib/ldapc++/src/LDAPSaslBindResult.h b/contrib/ldapc++/src/LDAPSaslBindResult.h new file mode 100644 index 0000000..b31e89e --- /dev/null +++ b/contrib/ldapc++/src/LDAPSaslBindResult.h @@ -0,0 +1,43 @@ +// $OpenLDAP$ +/* + * Copyright 2007-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#ifndef LDAP_SASL_BIND_RESULT_H +#define LDAP_SASL_BIND_RESULT_H + +#include <ldap.h> + +#include <LDAPResult.h> + +class LDAPRequest; + +/** + * Object of this class are created by the LDAPMsg::create method if + * results for an Extended Operation were returned by a LDAP server. + */ +class LDAPSaslBindResult : public LDAPResult { + public : + /** + * Constructor that creates an LDAPExtResult-object from the C-API + * structures + */ + LDAPSaslBindResult(const LDAPRequest* req, LDAPMessage* msg); + + /** + * The Destructor + */ + virtual ~LDAPSaslBindResult(); + + /** + * @returns If the result contained data this method will return + * the data to the caller as a std::string. + */ + const std::string& getServerCreds() const; + + private: + std::string m_creds; +}; + +#endif // LDAP_SASL_BIND_RESULT_H diff --git a/contrib/ldapc++/src/LDAPSchema.cpp b/contrib/ldapc++/src/LDAPSchema.cpp new file mode 100644 index 0000000..38fe282 --- /dev/null +++ b/contrib/ldapc++/src/LDAPSchema.cpp @@ -0,0 +1,84 @@ +// $OpenLDAP$ +/* + * Copyright 2003-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#include "LDAPSchema.h" + +#include <ctype.h> +#include <ldap.h> + +#include "debug.h" +#include "StringList.h" + + +using namespace std; + +LDAPSchema::LDAPSchema(){ + DEBUG(LDAP_DEBUG_CONSTRUCT, + "LDAPSchema::LDAPSchema( )" << endl); +} + +LDAPSchema::~LDAPSchema() { + DEBUG(LDAP_DEBUG_DESTROY,"LDAPSchema::~LDAPSchema()" << endl); +} + +void LDAPSchema::setObjectClasses (const StringList &ocs) { + DEBUG(LDAP_DEBUG_TRACE,"LDAPSchema::setObjectClasses()" << endl); + + // parse the stringlist and save it to global map... + StringList::const_iterator i,j; + for (i = ocs.begin(); i != ocs.end(); i++) { + LDAPObjClass oc ( (*i) ); + StringList names = oc.getNames(); + // there could be more names for one object... + for (j = names.begin(); j != names.end(); j++) { + string lc_name = *j; + string::iterator k; + for ( k = lc_name.begin(); k != lc_name.end(); k++ ) { + (*k) = tolower(*k); + } + object_classes [lc_name] = LDAPObjClass (oc); + } + } +} + +void LDAPSchema::setAttributeTypes (const StringList &ats) { + DEBUG(LDAP_DEBUG_TRACE,"LDAPSchema::setAttributeTypes()" << endl); + + // parse the stringlist and save it to global map... + StringList::const_iterator i,j; + for (i = ats.begin(); i != ats.end(); i++) { + LDAPAttrType at ( (*i) ); + StringList names = at.getNames(); + // there could be more names for one object... + for (j = names.begin(); j != names.end(); j++) { + string lc_name = *j; + string::iterator k; + for ( k = lc_name.begin(); k != lc_name.end(); k++ ) { + (*k) = tolower(*k); + } + attr_types [lc_name] = LDAPAttrType (at); + } + } +} + +LDAPObjClass LDAPSchema::getObjectClassByName (string name) { + string lc_name = name; + string::iterator k; + for ( k = lc_name.begin(); k != lc_name.end(); k++ ) { + (*k) = tolower(*k); + } + return object_classes [lc_name]; +} + +LDAPAttrType LDAPSchema::getAttributeTypeByName (string name) { + string lc_name = name; + string::iterator k; + for ( k = lc_name.begin(); k != lc_name.end(); k++ ) { + (*k) = tolower(*k); + } + + return attr_types [lc_name]; +} diff --git a/contrib/ldapc++/src/LDAPSchema.h b/contrib/ldapc++/src/LDAPSchema.h new file mode 100644 index 0000000..c55c9af --- /dev/null +++ b/contrib/ldapc++/src/LDAPSchema.h @@ -0,0 +1,73 @@ +// $OpenLDAP$ +/* + * Copyright 2003-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#ifndef LDAP_SCHEMA_H +#define LDAP_SCHEMA_H + +#include <string> +#include <map> + +#include "LDAPObjClass.h" +#include "LDAPAttrType.h" + +/** + * Represents the LDAP schema + */ +class LDAPSchema{ + private : + /** + * map of object classes: index is name, value is LDAPObjClass object + */ + map <string, LDAPObjClass> object_classes; + + /** + * map of attribute types: index is name, value is LDAPAttrType object + */ + map <string, LDAPAttrType> attr_types; + + public : + + /** + * Constructs an empty object + */ + LDAPSchema(); + + /** + * Destructor + */ + virtual ~LDAPSchema(); + + /** + * Fill the object_classes map + * @param oc description of one objectclass (string returned by search + * command), in form: + * "( 1.2.3.4.5 NAME '<name>' SUP <supname> STRUCTURAL + * DESC '<description>' MUST ( <attrtype> ) MAY ( <attrtype> ))" + */ + void setObjectClasses (const StringList &oc); + + /** + * Fill the attr_types map + * @param at description of one attribute type + * (string returned by search command), in form: + * "( 1.2.3.4.6 NAME ( '<name>' ) DESC '<desc>' + * EQUALITY caseExactIA5Match SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 )" + */ + void setAttributeTypes (const StringList &at); + + /** + * Returns object class object with given name + */ + LDAPObjClass getObjectClassByName (std::string name); + + /** + * Returns attribute type object with given name + */ + LDAPAttrType getAttributeTypeByName (string name); + +}; + +#endif // LDAP_SCHEMA_H diff --git a/contrib/ldapc++/src/LDAPSearchReference.cpp b/contrib/ldapc++/src/LDAPSearchReference.cpp new file mode 100644 index 0000000..d82348c --- /dev/null +++ b/contrib/ldapc++/src/LDAPSearchReference.cpp @@ -0,0 +1,53 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + + +#include <iostream> + +#include "debug.h" +#include "LDAPSearchReference.h" +#include "LDAPException.h" +#include "LDAPRequest.h" +#include "LDAPUrl.h" + +using namespace std; + +LDAPSearchReference::LDAPSearchReference(const LDAPRequest *req, + LDAPMessage *msg) : LDAPMsg(msg){ + DEBUG(LDAP_DEBUG_CONSTRUCT, + "LDAPSearchReference::LDAPSearchReference()" << endl;) + char **ref=0; + LDAPControl** srvctrls=0; + const LDAPAsynConnection* con=req->getConnection(); + int err = ldap_parse_reference(con->getSessionHandle(), msg, &ref, + &srvctrls,0); + if (err != LDAP_SUCCESS){ + ber_memvfree((void**) ref); + ldap_controls_free(srvctrls); + throw LDAPException(err); + }else{ + m_urlList=LDAPUrlList(ref); + ber_memvfree((void**) ref); + if (srvctrls){ + m_srvControls = LDAPControlSet(srvctrls); + m_hasControls = true; + ldap_controls_free(srvctrls); + }else{ + m_hasControls = false; + } + } +} + +LDAPSearchReference::~LDAPSearchReference(){ + DEBUG(LDAP_DEBUG_DESTROY,"LDAPSearchReference::~LDAPSearchReference()" + << endl); +} + +const LDAPUrlList& LDAPSearchReference::getUrls() const{ + DEBUG(LDAP_DEBUG_TRACE,"LDAPSearchReference::getUrls()" << endl); + return m_urlList; +} + diff --git a/contrib/ldapc++/src/LDAPSearchReference.h b/contrib/ldapc++/src/LDAPSearchReference.h new file mode 100644 index 0000000..209ae33 --- /dev/null +++ b/contrib/ldapc++/src/LDAPSearchReference.h @@ -0,0 +1,46 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + + +#ifndef LDAP_SEARCH_REFERENCE_H +#define LDAP_SEARCH_REFERENCE_H + +#include <LDAPMessage.h> +#include <LDAPUrlList.h> + +class LDAPRequest; +class LDAPUrl; + +/** + * This class is used to represent Continuation References that were + * returned during a SEARCH-Operation. + */ +class LDAPSearchReference : public LDAPMsg{ + + public : + /** + * Constructor that create an object from the C-API structures + */ + LDAPSearchReference(const LDAPRequest* req, LDAPMessage* msg); + + /** + * The Destructor + */ + ~LDAPSearchReference(); + + /** + * @returns The destination URLs that were send with this message + */ + const LDAPUrlList& getUrls() const; + + private : + LDAPUrlList m_urlList; + LDAPSearchReference(); +}; + + + +#endif //LDAP_SEARCH_REFERENCE_H diff --git a/contrib/ldapc++/src/LDAPSearchRequest.cpp b/contrib/ldapc++/src/LDAPSearchRequest.cpp new file mode 100644 index 0000000..bc752c9 --- /dev/null +++ b/contrib/ldapc++/src/LDAPSearchRequest.cpp @@ -0,0 +1,135 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#include "config.h" +#include "ac/time.h" +#include "debug.h" +#include "LDAPSearchRequest.h" +#include "LDAPException.h" +#include "LDAPSearchReference.h" +#include "LDAPResult.h" +#include "LDAPRequest.h" +#include "LDAPUrl.h" + +using namespace std; + +LDAPSearchRequest::LDAPSearchRequest(const LDAPSearchRequest& req ) : + LDAPRequest (req){ + DEBUG(LDAP_DEBUG_CONSTRUCT, + "LDAPSearchRequest::LDAPSearchRequest(&)" << endl); + m_base=req.m_base; + m_scope=req.m_scope; + m_filter=req.m_filter; + m_attrs=req.m_attrs; + m_attrsOnly=req.m_attrsOnly; +} + + +LDAPSearchRequest::LDAPSearchRequest(const string& base, int scope, + const string& filter, const StringList& attrs, bool attrsOnly, + LDAPAsynConnection *connect, + const LDAPConstraints* cons, bool isReferral, + const LDAPRequest* parent) + : LDAPRequest (connect,cons,isReferral,parent) { + + DEBUG(LDAP_DEBUG_CONSTRUCT, + "LDAPSearchRequest:LDAPSearchRequest()" << endl); + DEBUG(LDAP_DEBUG_CONSTRUCT & LDAP_DEBUG_PARAMETER, + " base:" << base << endl << " scope:" << scope << endl + << " filter:" << filter << endl); + m_requestType=LDAPRequest::SEARCH; + //insert some validating and copying here + m_base=base; + m_scope=scope; + if(filter == ""){ + m_filter="objectClass=*"; + }else{ + m_filter=filter; + } + m_attrs=attrs; + m_attrsOnly=attrsOnly; +} + +LDAPSearchRequest::~LDAPSearchRequest(){ + DEBUG(LDAP_DEBUG_DESTROY, "LDAPSearchRequest::~LDAPSearchRequest" << endl); +} + +LDAPMessageQueue* LDAPSearchRequest::sendRequest(){ + int msgID; + DEBUG(LDAP_DEBUG_TRACE, "LDAPSearchRequest::sendRequest()" << endl); + timeval* tmptime=m_cons->getTimeoutStruct(); + char** tmpattrs=m_attrs.toCharArray(); + LDAPControl** tmpSrvCtrl=m_cons->getSrvCtrlsArray(); + LDAPControl** tmpClCtrl=m_cons->getClCtrlsArray(); + int aliasDeref = m_cons->getAliasDeref(); + ldap_set_option(m_connection->getSessionHandle(), LDAP_OPT_DEREF, + &aliasDeref); + int err=ldap_search_ext(m_connection->getSessionHandle(), m_base.c_str(), + m_scope, m_filter.c_str(), tmpattrs, m_attrsOnly, tmpSrvCtrl, + tmpClCtrl, tmptime, m_cons->getSizeLimit(), &msgID ); + delete tmptime; + ber_memvfree((void**)tmpattrs); + LDAPControlSet::freeLDAPControlArray(tmpSrvCtrl); + LDAPControlSet::freeLDAPControlArray(tmpClCtrl); + + if (err != LDAP_SUCCESS){ + throw LDAPException(err); + } else if (isReferral()){ + m_msgID=msgID; + return 0; + }else{ + m_msgID=msgID; + return new LDAPMessageQueue(this); + } +} + +LDAPRequest* LDAPSearchRequest::followReferral(LDAPMsg* ref){ + DEBUG(LDAP_DEBUG_TRACE, "LDAPSearchRequest::followReferral()" << endl); + LDAPUrlList urls; + LDAPUrlList::const_iterator usedUrl; + LDAPAsynConnection* con; + string filter; + int scope; + if(ref->getMessageType() == LDAPMsg::SEARCH_REFERENCE){ + urls = ((LDAPSearchReference *)ref)->getUrls(); + }else{ + urls = ((LDAPResult *)ref)->getReferralUrls(); + } + con = getConnection()->referralConnect(urls,usedUrl,m_cons); + if(con != 0){ + if((usedUrl->getFilter() != "") && + (usedUrl->getFilter() != m_filter)){ + filter=usedUrl->getFilter(); + }else{ + filter=m_filter; + } + if( (ref->getMessageType() == LDAPMsg::SEARCH_REFERENCE) && + (m_scope == LDAPAsynConnection::SEARCH_ONE) + ){ + scope = LDAPAsynConnection::SEARCH_BASE; + DEBUG(LDAP_DEBUG_TRACE," adjusted scope to BASE" << endl); + }else{ + scope = m_scope; + } + }else{ + return 0; + } + return new LDAPSearchRequest(usedUrl->getDN(), scope, filter, + m_attrs, m_attrsOnly, con, m_cons,true,this); +} + +bool LDAPSearchRequest::equals(const LDAPRequest* req)const{ + DEBUG(LDAP_DEBUG_TRACE,"LDAPSearchRequest::equals()" << endl); + if( LDAPRequest::equals(req)){ + LDAPSearchRequest* sreq = (LDAPSearchRequest*)req; + if ( (m_base == sreq->m_base) && + (m_scope == sreq->m_scope) + ){ + return true; + } + } + return false; +} diff --git a/contrib/ldapc++/src/LDAPSearchRequest.h b/contrib/ldapc++/src/LDAPSearchRequest.h new file mode 100644 index 0000000..59a63a8 --- /dev/null +++ b/contrib/ldapc++/src/LDAPSearchRequest.h @@ -0,0 +1,43 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#ifndef LDAP_SEARCH_REQUEST_H +#define LDAP_SEARCH_REQUEST_H + +#include <queue> +#include <LDAPRequest.h> + +class LDAPSearchReference; +class LDAPReferral; +class LDAPUrl; + +class LDAPSearchRequest : public LDAPRequest{ + + public : + LDAPSearchRequest(const LDAPSearchRequest& req); + + LDAPSearchRequest(const std::string& base, int scope, const std::string& filter, + const StringList& attrs, bool attrsOnly, + LDAPAsynConnection *connect, + const LDAPConstraints* cons, bool isReferral=false, + const LDAPRequest* parent=0); + virtual ~LDAPSearchRequest(); + virtual LDAPMessageQueue* sendRequest(); + virtual LDAPRequest* followReferral(LDAPMsg* ref); + virtual bool equals(const LDAPRequest* req) const; + + private : + std::string m_base; + int m_scope; + std::string m_filter; + StringList m_attrs; + bool m_attrsOnly; + + //no default constructor + LDAPSearchRequest(){}; +}; + +#endif //LDAP_SEARCH_REQUEST_H diff --git a/contrib/ldapc++/src/LDAPSearchResult.cpp b/contrib/ldapc++/src/LDAPSearchResult.cpp new file mode 100644 index 0000000..cc850df --- /dev/null +++ b/contrib/ldapc++/src/LDAPSearchResult.cpp @@ -0,0 +1,52 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + + +#include <iostream> + +#include "debug.h" +#include "LDAPSearchResult.h" +#include "LDAPRequest.h" + +using namespace std; + +LDAPSearchResult::LDAPSearchResult(const LDAPRequest *req, + LDAPMessage *msg) : LDAPMsg(msg){ + DEBUG(LDAP_DEBUG_CONSTRUCT, + "LDAPSearchResult::LDAPSearchResult()" << endl); + entry = new LDAPEntry(req->getConnection(), msg); + //retrieve the controls here + LDAPControl** srvctrls=0; + int err = ldap_get_entry_controls(req->getConnection()->getSessionHandle(), + msg,&srvctrls); + if(err != LDAP_SUCCESS){ + ldap_controls_free(srvctrls); + }else{ + if (srvctrls){ + m_srvControls = LDAPControlSet(srvctrls); + m_hasControls = true; + ldap_controls_free(srvctrls); + }else{ + m_hasControls = false; + } + } +} + +LDAPSearchResult::LDAPSearchResult(const LDAPSearchResult& res) : + LDAPMsg(res){ + entry = new LDAPEntry(*(res.entry)); +} + +LDAPSearchResult::~LDAPSearchResult(){ + DEBUG(LDAP_DEBUG_DESTROY,"LDAPSearchResult::~LDAPSearchResult()" << endl); + delete entry; +} + +const LDAPEntry* LDAPSearchResult::getEntry() const{ + DEBUG(LDAP_DEBUG_TRACE,"LDAPSearchResult::getEntry()" << endl); + return entry; +} + diff --git a/contrib/ldapc++/src/LDAPSearchResult.h b/contrib/ldapc++/src/LDAPSearchResult.h new file mode 100644 index 0000000..c7646e5 --- /dev/null +++ b/contrib/ldapc++/src/LDAPSearchResult.h @@ -0,0 +1,45 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + + +#ifndef LDAP_SEARCH_RESULT_H +#define LDAP_SEARCH_RESULT_H + +#include <LDAPMessage.h> +#include <LDAPEntry.h> + +class LDAPRequest; + +/** + * This class is used to represent the result entries of a + * SEARCH-operation. + */ +class LDAPSearchResult : public LDAPMsg{ + public: + /** + * Constructor that create an object from the C-API structures + */ + LDAPSearchResult(const LDAPRequest *req, LDAPMessage *msg); + + /** + * Copy-Constructor + */ + LDAPSearchResult(const LDAPSearchResult& res); + + /** + * The Destructor + */ + virtual ~LDAPSearchResult(); + + /** + * @returns The entry that has been sent with this result message. + */ + const LDAPEntry* getEntry() const; + + private: + LDAPEntry *entry; +}; +#endif //LDAP_SEARCH_RESULT_H diff --git a/contrib/ldapc++/src/LDAPSearchResults.cpp b/contrib/ldapc++/src/LDAPSearchResults.cpp new file mode 100644 index 0000000..a25afe5 --- /dev/null +++ b/contrib/ldapc++/src/LDAPSearchResults.cpp @@ -0,0 +1,60 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + + +#include "LDAPException.h" +#include "LDAPSearchResult.h" +#include "LDAPResult.h" + +#include "LDAPSearchResults.h" + +LDAPSearchResults::LDAPSearchResults(){ + entryPos = entryList.begin(); + refPos = refList.begin(); +} + +LDAPResult* LDAPSearchResults::readMessageQueue(LDAPMessageQueue* msg){ + if(msg != 0){ + LDAPMsg* res=0; + for(;;){ + try{ + res = msg->getNext(); + }catch (LDAPException e){ + throw; + } + switch(res->getMessageType()){ + case LDAPMsg::SEARCH_ENTRY : + entryList.addEntry(*((LDAPSearchResult*)res)->getEntry()); + break; + case LDAPMsg::SEARCH_REFERENCE : + refList.addReference(*((LDAPSearchReference*)res)); + break; + default: + entryPos=entryList.begin(); + refPos=refList.begin(); + return ((LDAPResult*) res); + } + delete res; + res=0; + } + } + return 0; +} + +LDAPEntry* LDAPSearchResults::getNext(){ + if( entryPos != entryList.end() ){ + LDAPEntry* ret= new LDAPEntry(*entryPos); + entryPos++; + return ret; + } + if( refPos != refList.end() ){ + LDAPUrlList urls= refPos->getUrls(); + refPos++; + throw(LDAPReferralException(urls)); + } + return 0; +} + diff --git a/contrib/ldapc++/src/LDAPSearchResults.h b/contrib/ldapc++/src/LDAPSearchResults.h new file mode 100644 index 0000000..f675de1 --- /dev/null +++ b/contrib/ldapc++/src/LDAPSearchResults.h @@ -0,0 +1,56 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#ifndef LDAP_SEARCH_RESULTS_H +#define LDAP_SEARCH_RESULTS_H + +#include <LDAPEntry.h> +#include <LDAPEntryList.h> +#include <LDAPMessage.h> +#include <LDAPMessageQueue.h> +#include <LDAPReferenceList.h> +#include <LDAPSearchReference.h> + +class LDAPResult; + +/** + * The class stores the results of a synchronous SEARCH-Operation + */ +class LDAPSearchResults{ + public: + /** + * Default-Constructor + */ + LDAPSearchResults(); + + /** + * For internal use only. + * + * This method reads Search result entries from a + * LDAPMessageQueue-object. + * @param msg The message queue to read + */ + LDAPResult* readMessageQueue(LDAPMessageQueue* msg); + + /** + * The method is used by the client-application to read the + * result entries of the SEARCH-Operation. Every call of this + * method returns one entry. If all entries were read it return 0. + * @throws LDAPReferralException If a Search Reference was + * returned by the server + * @returns A LDAPEntry-object as a result of a SEARCH-Operation or + * 0 if no more entries are there to return. + */ + LDAPEntry* getNext(); + private : + LDAPEntryList entryList; + LDAPReferenceList refList; + LDAPEntryList::const_iterator entryPos; + LDAPReferenceList::const_iterator refPos; +}; +#endif //LDAP_SEARCH_RESULTS_H + + diff --git a/contrib/ldapc++/src/LDAPUrl.cpp b/contrib/ldapc++/src/LDAPUrl.cpp new file mode 100644 index 0000000..b3a2ec0 --- /dev/null +++ b/contrib/ldapc++/src/LDAPUrl.cpp @@ -0,0 +1,518 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + + +#include "LDAPUrl.h" +#include <sstream> +#include <iomanip> +#include "debug.h" + +using namespace std; + +#define PCT_ENCFLAG_NONE 0x0000U +#define PCT_ENCFLAG_COMMA 0x0001U +#define PCT_ENCFLAG_SLASH 0x0002U + +#define LDAP_DEFAULT_PORT 389 +#define LDAPS_DEFAULT_PORT 636 + +LDAPUrl::LDAPUrl(const std::string &url) +{ + DEBUG(LDAP_DEBUG_CONSTRUCT, "LDAPUrl::LDAPUrl()" << endl); + DEBUG(LDAP_DEBUG_CONSTRUCT | LDAP_DEBUG_PARAMETER, + " url:" << url << endl); + m_urlString = url; + m_Filter = ""; + m_Scheme = "ldap"; + m_Scope = 0; + m_Port = 0; + regenerate = false; + if (url != "") { + this->parseUrl(); + } +} + +LDAPUrl::~LDAPUrl() +{ + DEBUG(LDAP_DEBUG_DESTROY, "LDAPUrl::~LDAPUrl()" << endl); + m_Attrs.clear(); +} + +int LDAPUrl::getPort() const +{ + return m_Port; +} + +void LDAPUrl::setPort(int port) +{ + m_Port = port; + regenerate = true; +} + +int LDAPUrl::getScope() const +{ + return m_Scope; +} + +void LDAPUrl::setScope( const std::string &scope ) +{ + if (scope == "base" || scope == "" ) { + m_Scope = 0; + } else if (scope == "one" ) { + m_Scope = 1; + } else if (scope == "sub" ) { + m_Scope = 2; + } else { + throw LDAPUrlException(LDAPUrlException::INVALID_SCOPE, + "Scope was:" + scope); + } + regenerate = true; +} + +const string& LDAPUrl::getURLString() const +{ + if (regenerate){ + this->components2Url(); + regenerate=false; + } + return m_urlString; +} + +void LDAPUrl::setURLString( const std::string &url ) +{ + m_urlString = url; + if (url != "") { + this->parseUrl(); + } + regenerate = false; +} + +const string& LDAPUrl::getHost() const +{ + return m_Host; +} + +void LDAPUrl::setHost( const std::string &host ) +{ + m_Host = host; + regenerate = true; +} + +const string& LDAPUrl::getDN() const +{ + return m_DN; +} +void LDAPUrl::setDN( const std::string &dn ) +{ + m_DN = dn; + regenerate = true; +} + +const string& LDAPUrl::getFilter() const +{ + return m_Filter; +} +void LDAPUrl::setFilter( const std::string &filter ) +{ + m_Filter = filter; + regenerate = true; +} + +const StringList& LDAPUrl::getAttrs() const +{ + return m_Attrs; +} +void LDAPUrl::setAttrs( const StringList &attrs ) +{ + m_Attrs = attrs; + regenerate = true; +} + +const StringList& LDAPUrl::getExtensions() const +{ + return m_Extensions; +} + +void LDAPUrl::setExtensions( const StringList &ext ) +{ + m_Extensions = ext; + regenerate = true; +} + +const std::string& LDAPUrl::getScheme() const +{ + return m_Scheme; +} + +void LDAPUrl::setScheme( const std::string &scheme ) +{ + if (scheme == "ldap" || scheme == "ldaps" || + scheme == "ldapi" || scheme == "cldap" ) + { + m_Scheme = scheme; + regenerate = true; + } else { + throw LDAPUrlException(LDAPUrlException::INVALID_SCHEME, + "Unknown URL scheme: \"" + scheme + "\""); + } +} + +void LDAPUrl::parseUrl() +{ + DEBUG(LDAP_DEBUG_TRACE, "LDAPUrl::parseUrl()" << std::endl); + // reading Scheme + std::string::size_type pos = m_urlString.find(':'); + std::string::size_type startpos = pos; + if (pos == std::string::npos) { + throw LDAPUrlException(LDAPUrlException::INVALID_URL, + "No colon found in URL"); + } + std::string scheme = m_urlString.substr(0, pos); + DEBUG(LDAP_DEBUG_TRACE, " scheme is <" << scheme << ">" << std::endl); + + if ( scheme == "ldap" ) { + m_Scheme = scheme; + } else if ( scheme == "ldaps" ) { + m_Scheme = scheme; + } else if ( scheme == "ldapi" ) { + m_Scheme = scheme; + } else if ( scheme == "cldap" ) { + m_Scheme = scheme; + } else { + throw LDAPUrlException(LDAPUrlException::INVALID_SCHEME, + "Unknown URL Scheme: \"" + scheme + "\""); + } + + if ( m_urlString[pos+1] != '/' || m_urlString[pos+2] != '/' ) { + throw LDAPUrlException(LDAPUrlException::INVALID_URL); + } else { + startpos = pos + 3; + } + if ( m_urlString[startpos] == '/' ) { + // no hostname and port + startpos++; + } else { + std::string::size_type hostend, portstart=0; + pos = m_urlString.find('/', startpos); + + // IPv6 Address? + if ( m_urlString[startpos] == '[' ) { + // skip + startpos++; + hostend = m_urlString.find(']', startpos); + if ( hostend == std::string::npos ){ + throw LDAPUrlException(LDAPUrlException::INVALID_URL); + } + portstart = hostend + 1; + } else { + hostend = m_urlString.find(':', startpos); + if ( hostend == std::string::npos || portstart > pos ) { + hostend = pos; + } + portstart = hostend; + } + std::string host = m_urlString.substr(startpos, hostend - startpos); + DEBUG(LDAP_DEBUG_TRACE, " host: <" << host << ">" << std::endl); + percentDecode(host, m_Host); + + if (portstart >= m_urlString.length() || portstart >= pos ) { + if ( m_Scheme == "ldap" || m_Scheme == "cldap" ) { + m_Port = LDAP_DEFAULT_PORT; + } else if ( m_Scheme == "ldaps" ) { + m_Port = LDAPS_DEFAULT_PORT; + } + } else { + std::string port = m_urlString.substr(portstart+1, + (pos == std::string::npos ? pos : pos-portstart-1) ); + if ( port.length() > 0 ) { + std::istringstream i(port); + i >> m_Port; + if ( i.fail() ){ + throw LDAPUrlException(LDAPUrlException::INVALID_PORT); + } + } + DEBUG(LDAP_DEBUG_TRACE, " Port: <" << m_Port << ">" + << std::endl); + } + startpos = pos + 1; + } + int parserMode = base; + while ( pos != std::string::npos ) { + pos = m_urlString.find('?', startpos); + std::string actComponent = m_urlString.substr(startpos, + pos - startpos); + DEBUG(LDAP_DEBUG_TRACE, " ParserMode:" << parserMode << std::endl); + DEBUG(LDAP_DEBUG_TRACE, " ActComponent: <" << actComponent << ">" + << std::endl); + std::string s_scope = ""; + std::string s_ext = ""; + switch(parserMode) { + case base : + percentDecode(actComponent, m_DN); + DEBUG(LDAP_DEBUG_TRACE, " BaseDN:" << m_DN << std::endl); + break; + case attrs : + DEBUG(LDAP_DEBUG_TRACE, " reading Attributes" << std::endl); + if (actComponent.length() != 0 ) { + string2list(actComponent,m_Attrs, true); + } + break; + case scope : + percentDecode(actComponent, s_scope); + if (s_scope == "base" || s_scope == "" ) { + m_Scope = 0; + } else if (s_scope == "one" ) { + m_Scope = 1; + } else if (s_scope == "sub" ) { + m_Scope = 2; + } else { + throw LDAPUrlException(LDAPUrlException::INVALID_SCOPE); + } + DEBUG(LDAP_DEBUG_TRACE, " Scope: <" << s_scope << ">" + << std::endl); + break; + case filter : + percentDecode(actComponent, m_Filter); + DEBUG(LDAP_DEBUG_TRACE, " filter: <" << m_Filter << ">" + << std::endl); + break; + case extensions : + DEBUG(LDAP_DEBUG_TRACE, " reading Extensions" << std::endl); + string2list(actComponent, m_Extensions, true); + break; + default : + DEBUG(LDAP_DEBUG_TRACE, " unknown state" << std::endl); + break; + } + startpos = pos + 1; + parserMode++; + } +} + +void LDAPUrl::percentDecode(const std::string& src, std::string &out) +{ + DEBUG(LDAP_DEBUG_TRACE, "LDAPUrl::percentDecode()" << std::endl); + std::string::size_type pos = 0; + std::string::size_type startpos = 0; + pos = src.find('%', startpos); + while ( pos != std::string::npos ) { + out += src.substr(startpos, pos - startpos); + std::string istr(src.substr(pos+1, 2)); + std::istringstream i(istr); + i.setf(std::ios::hex, std::ios::basefield); + i.unsetf(std::ios::showbase); + int hex; + i >> hex; + if ( i.fail() ){ + throw LDAPUrlException(LDAPUrlException::URL_DECODING_ERROR, + "Invalid percent encoding"); + } + char j = hex; + out.push_back(j); + startpos = pos+3; + pos = src.find('%', startpos); + } + out += src.substr(startpos, pos - startpos); +} + +void LDAPUrl::string2list(const std::string &src, StringList& sl, + bool percentDecode) +{ + std::string::size_type comma_startpos = 0; + std::string::size_type comma_pos = 0; + std::string actItem; + while ( comma_pos != std::string::npos ) { + comma_pos = src.find(',', comma_startpos); + actItem = src.substr(comma_startpos, comma_pos - comma_startpos); + if (percentDecode){ + std::string decoded; + this->percentDecode(actItem,decoded); + actItem = decoded; + } + sl.add(actItem); + comma_startpos = comma_pos + 1; + } +} + + +void LDAPUrl::components2Url() const +{ + std::ostringstream url; + std::string encoded = ""; + + url << m_Scheme << "://"; + // IPv6 ? + if ( m_Host.find( ':', 0 ) != std::string::npos ) { + url << "[" << this->percentEncode(m_Host, encoded) << "]"; + } else { + url << this->percentEncode(m_Host, encoded, PCT_ENCFLAG_SLASH); + } + + if ( m_Port != 0 ) { + url << ":" << m_Port; + } + + url << "/"; + encoded = ""; + if ( m_DN != "" ) { + this->percentEncode( m_DN, encoded ); + url << encoded; + } + string qm = ""; + if ( ! m_Attrs.empty() ){ + url << "?"; + bool first = true; + for ( StringList::const_iterator i = m_Attrs.begin(); + i != m_Attrs.end(); i++) + { + this->percentEncode( *i, encoded ); + if ( ! first ) { + url << ","; + } else { + first = false; + } + url << encoded; + } + } else { + qm.append("?"); + } + if ( m_Scope == 1 ) { + url << qm << "?one"; + qm = ""; + } else if ( m_Scope == 2 ) { + url << qm << "?sub"; + qm = ""; + } else { + qm.append("?"); + } + if (m_Filter != "" ){ + this->percentEncode( m_Filter, encoded ); + url << qm << "?" << encoded; + qm = ""; + } else { + qm.append("?"); + } + + if ( ! m_Extensions.empty() ){ + url << qm << "?"; + bool first = true; + for ( StringList::const_iterator i = m_Extensions.begin(); + i != m_Extensions.end(); i++) + { + this->percentEncode( *i, encoded, 1); + if ( ! first ) { + url << ","; + } else { + first = false; + } + url << encoded; + } + } + m_urlString=url.str(); +} + + +std::string& LDAPUrl::percentEncode( const std::string &src, + std::string &dest, + int flags) const +{ + std::ostringstream o; + o.setf(std::ios::hex, std::ios::basefield); + o.setf(std::ios::uppercase); + o.unsetf(std::ios::showbase); + bool escape=false; + for ( std::string::const_iterator i = src.begin(); i != src.end(); i++ ){ + switch(*i){ + /* reserved */ + case '?' : + escape = true; + break; + case ',' : + if ( flags & PCT_ENCFLAG_COMMA ) { + escape = true; + } else { + escape = false; + } + break; + case ':' : + case '/' : + if ( flags & PCT_ENCFLAG_SLASH ) { + escape = true; + } else { + escape = false; + } + break; + case '#' : + case '[' : + case ']' : + case '@' : + case '!' : + case '$' : + case '&' : + case '\'' : + case '(' : + case ')' : + case '*' : + case '+' : + case ';' : + case '=' : + /* unreserved */ + case '-' : + case '.' : + case '_' : + case '~' : + escape = false; + break; + default : + if ( std::isalnum(*i) ) { + escape = false; + } else { + escape = true; + } + break; + } + if ( escape ) { + o << "%" << std::setw(2) << std::setfill('0') << (int)(unsigned char)*i ; + } else { + o.put(*i); + } + } + dest = o.str(); + return dest; +} + +const code2string_s LDAPUrlException::code2string[] = { + { INVALID_SCHEME, "Invalid URL Scheme" }, + { INVALID_PORT, "Invalid Port in Url" }, + { INVALID_SCOPE, "Invalid Search Scope in Url" }, + { INVALID_URL, "Invalid LDAP Url" }, + { URL_DECODING_ERROR, "Url-decoding Error" }, + { 0, 0 } +}; + +LDAPUrlException::LDAPUrlException( int code, const std::string &msg) : + m_code(code), m_addMsg(msg) {} + +int LDAPUrlException::getCode() const +{ + return m_code; +} + +const std::string LDAPUrlException::getAdditionalInfo() const +{ + return m_addMsg; +} + +const std::string LDAPUrlException::getErrorMessage() const +{ + for ( int i = 0; code2string[i].string != 0; i++ ) { + if ( code2string[i].code == m_code ) { + return std::string(code2string[i].string); + } + } + return ""; + +} diff --git a/contrib/ldapc++/src/LDAPUrl.h b/contrib/ldapc++/src/LDAPUrl.h new file mode 100644 index 0000000..9c1f3e3 --- /dev/null +++ b/contrib/ldapc++/src/LDAPUrl.h @@ -0,0 +1,207 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + + +#ifndef LDAP_URL_H +#define LDAP_URL_H + +#include <StringList.h> + +class LDAPUrlException; +/** + * This class is used to analyze and store LDAP-Urls as returned by a + * LDAP-Server as Referrals and Search References. LDAP-URLs are defined + * in RFC1959 and have the following format: <BR> + * <code> + * ldap://host:port/baseDN[?attr[?scope[?filter]]] <BR> + * </code> + */ +class LDAPUrl{ + + public : + /** + * Create a new object from a string that contains a LDAP-Url + * @param url The URL String + */ + LDAPUrl(const std::string &url=""); + + /** + * Destructor + */ + ~LDAPUrl(); + + /** + * @return The part of the URL that is representing the network + * port + */ + int getPort() const; + + /** + * Set the port value of the URL + * @param dn The port value + */ + void setPort(int port); + + /** + * @return The scope part of the URL is returned. + */ + int getScope() const; + + /** + * Set the Scope part of the URL + * @param scope The new scope + */ + void setScope(const std::string& scope); + + /** + * @return The complete URL as a string + */ + const std::string& getURLString() const; + + /** + * Set the URL member attribute + * @param url The URL String + */ + void setURLString(const std::string &url); + + /** + * @return The hostname or IP-Address of the destination host. + */ + const std::string& getHost() const; + + /** + * Set the Host part of the URL + * @param host The new host part + */ + void setHost( const std::string &host); + + /** + * @return The Protocol Scheme of the URL. + */ + const std::string& getScheme() const; + + /** + * Set the Protocol Scheme of the URL + * @param host The Protocol scheme. Allowed values are + * ldap,ldapi,ldaps and cldap + */ + void setScheme( const std::string &scheme ); + + /** + * @return The Base-DN part of the URL + */ + const std::string& getDN() const; + + /** + * Set the DN part of the URL + * @param dn The new DN part + */ + void setDN( const std::string &dn); + + + /** + * @return The Filter part of the URL + */ + const std::string& getFilter() const; + + /** + * Set the Filter part of the URL + * @param filter The new Filter + */ + void setFilter( const std::string &filter); + + /** + * @return The List of attributes that was in the URL + */ + const StringList& getAttrs() const; + + /** + * Set the Attributes part of the URL + * @param attrs StringList containing the List of Attributes + */ + void setAttrs( const StringList &attrs); + void setExtensions( const StringList &ext); + const StringList& getExtensions() const; + + /** + * Percent-decode a string + * @param src The string that is to be decoded + * @param dest The decoded result string + */ + void percentDecode( const std::string& src, std::string& dest ); + + /** + * Percent-encoded a string + * @param src The string that is to be encoded + * @param dest The encoded result string + * @param flags + */ + std::string& percentEncode( const std::string& src, + std::string& dest, + int flags=0 ) const; + + protected : + /** + * Split the url string that is associated with this Object into + * it components. The components of the URL can be access via the + * get...() methods. + * (this function is mostly for internal use and gets called + * automatically whenever necessary) + */ + void parseUrl(); + + /** + * Generate an URL string from the components that were set with + * the various set...() methods + * (this function is mostly for internal use and gets called + * automatically whenever necessary) + */ + void components2Url() const; + + void string2list(const std::string &src, StringList& sl, + bool percentDecode=false); + + protected : + mutable bool regenerate; + int m_Port; + int m_Scope; + std::string m_Host; + std::string m_DN; + std::string m_Filter; + StringList m_Attrs; + StringList m_Extensions; + mutable std::string m_urlString; + std::string m_Scheme; + enum mode { base, attrs, scope, filter, extensions }; +}; + +/// @cond +struct code2string_s { + int code; + const char* string; +}; +/// @endcond + +class LDAPUrlException { + public : + LDAPUrlException(int code, const std::string &msg="" ); + + int getCode() const; + const std::string getErrorMessage() const; + const std::string getAdditionalInfo() const; + + static const int INVALID_SCHEME = 1; + static const int INVALID_PORT = 2; + static const int INVALID_SCOPE = 3; + static const int INVALID_URL = 4; + static const int URL_DECODING_ERROR = 5; + static const code2string_s code2string[]; + + private: + int m_code; + std::string m_addMsg; +}; +#endif //LDAP_URL_H diff --git a/contrib/ldapc++/src/LDAPUrlList.cpp b/contrib/ldapc++/src/LDAPUrlList.cpp new file mode 100644 index 0000000..6e4e921 --- /dev/null +++ b/contrib/ldapc++/src/LDAPUrlList.cpp @@ -0,0 +1,57 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#include "LDAPUrlList.h" +#include <assert.h> +#include "debug.h" + +using namespace std; + +LDAPUrlList::LDAPUrlList(){ + DEBUG(LDAP_DEBUG_CONSTRUCT," LDAPUrlList::LDAPUrlList()" << endl); + m_urls=LDAPUrlList::ListType(); +} + +LDAPUrlList::LDAPUrlList(const LDAPUrlList& urls){ + DEBUG(LDAP_DEBUG_CONSTRUCT," LDAPUrlList::LDAPUrlList(&)" << endl); + m_urls = urls.m_urls; +} + + +LDAPUrlList::LDAPUrlList(char** url){ + DEBUG(LDAP_DEBUG_CONSTRUCT," LDAPUrlList::LDAPUrlList()" << endl); + char** i; + assert(url); + for(i = url; *i != 0; i++){ + add(LDAPUrl(*i)); + } +} + +LDAPUrlList::~LDAPUrlList(){ + DEBUG(LDAP_DEBUG_DESTROY," LDAPUrlList::~LDAPUrlList()" << endl); + m_urls.clear(); +} + +size_t LDAPUrlList::size() const{ + return m_urls.size(); +} + +bool LDAPUrlList::empty() const{ + return m_urls.empty(); +} + +LDAPUrlList::const_iterator LDAPUrlList::begin() const{ + return m_urls.begin(); +} + +LDAPUrlList::const_iterator LDAPUrlList::end() const{ + return m_urls.end(); +} + +void LDAPUrlList::add(const LDAPUrl& url){ + m_urls.push_back(url); +} + diff --git a/contrib/ldapc++/src/LDAPUrlList.h b/contrib/ldapc++/src/LDAPUrlList.h new file mode 100644 index 0000000..0b4f27c --- /dev/null +++ b/contrib/ldapc++/src/LDAPUrlList.h @@ -0,0 +1,78 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#ifndef LDAP_URL_LIST_H +#define LDAP_URL_LIST_H + +#include <list> +#include <LDAPUrl.h> + +/** + * This container class is used to store multiple LDAPUrl-objects. + */ +class LDAPUrlList{ + typedef std::list<LDAPUrl> ListType; + + public: + typedef ListType::const_iterator const_iterator; + + /** + * Constructs an empty list. + */ + LDAPUrlList(); + + /** + * Copy-constructor + */ + LDAPUrlList(const LDAPUrlList& urls); + + /** + * For internal use only + * + * This constructor is used by the library internally to create a + * std::list of URLs from a array of C-strings that was return by + * the C-API + */ + LDAPUrlList(char** urls); + + /** + * Destructor + */ + ~LDAPUrlList(); + + /** + * @return The number of LDAPUrl-objects that are currently + * stored in this list. + */ + size_t size() const; + + /** + * @return true if there are zero LDAPUrl-objects currently + * stored in this list. + */ + bool empty() const; + + /** + * @return A iterator that points to the first element of the list. + */ + const_iterator begin() const; + + /** + * @return A iterator that points to the element after the last + * element of the list. + */ + const_iterator end() const; + + /** + * Adds one element to the end of the list. + * @param attr The attribute to add to the list. + */ + void add(const LDAPUrl& url); + + private : + ListType m_urls; +}; +#endif //LDAP_URL_LIST_H diff --git a/contrib/ldapc++/src/LdifReader.cpp b/contrib/ldapc++/src/LdifReader.cpp new file mode 100644 index 0000000..207806d --- /dev/null +++ b/contrib/ldapc++/src/LdifReader.cpp @@ -0,0 +1,350 @@ +// $OpenLDAP$ +/* + * Copyright 2008-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#include "LdifReader.h" +#include "LDAPMessage.h" +#include "LDAPEntry.h" +#include "LDAPAttributeList.h" +#include "LDAPAttribute.h" +#include "LDAPUrl.h" +#include "debug.h" + +#include <string> +#include <sstream> +#include <stdexcept> + +#include <sasl/saslutil.h> // For base64 routines + +typedef std::pair<std::string, std::string> stringpair; + +LdifReader::LdifReader( std::istream &input ) + : m_ldifstream(input), m_lineNumber(0) +{ + DEBUG(LDAP_DEBUG_TRACE, "<> LdifReader::LdifReader()" << std::endl); + this->m_version = 0; + // read the first record to find out version and type of the LDIF + this->readNextRecord(true); + this->m_currentIsFirst = true; +} + +int LdifReader::readNextRecord( bool first ) +{ + DEBUG(LDAP_DEBUG_TRACE, "-> LdifReader::readRecord()" << std::endl); + std::string line; + std::string type; + std::string value; + int numLine = 0; + int recordType = 0; + + if ( (! first) && this->m_currentIsFirst == true ) + { + this->m_currentIsFirst = false; + return m_curRecType; + } + + m_currentRecord.clear(); + + while ( !this->getLdifLine(line) ) + { + DEBUG(LDAP_DEBUG_TRACE, " Line: " << line << std::endl ); + + // skip comments and empty lines between entries + if ( line[0] == '#' || ( numLine == 0 && line.size() == 0 ) ) + { + DEBUG(LDAP_DEBUG_TRACE, "skipping empty line or comment" << std::endl ); + continue; + } + if ( line.size() == 0 ) + { + // End of Entry + break; + } + + this->splitLine(line, type, value); + + if ( numLine == 0 ) + { + if ( type == "version" ) + { + std::istringstream valuestream(value); + valuestream >> this->m_version; + if ( this->m_version != 1 ) // there is no other Version than LDIFv1 + { + std::ostringstream err; + err << "Line " << this->m_lineNumber + << ": Unsupported LDIF Version"; + throw( std::runtime_error(err.str()) ); + } + continue; + } + if ( type == "dn" ) // Record should start with the DN ... + { + DEBUG(LDAP_DEBUG_TRACE, " Record DN:" << value << std::endl); + } + else if ( type == "include" ) // ... or it might be an "include" line + { + DEBUG(LDAP_DEBUG_TRACE, " Include directive: " << value << std::endl); + if ( this->m_version == 1 ) + { + std::ostringstream err; + err << "Line " << this->m_lineNumber + << ": \"include\" not allowed in LDIF version 1."; + throw( std::runtime_error(err.str()) ); + } + else + { + std::ostringstream err; + err << "Line " << this->m_lineNumber + << ": \"include\" not yet supported."; + throw( std::runtime_error(err.str()) ); + } + } + else + { + DEBUG(LDAP_DEBUG_TRACE, " Record doesn't start with a DN" + << std::endl); + std::ostringstream err; + err << "Line " << this->m_lineNumber + << ": LDIF record does not start with a DN."; + throw( std::runtime_error(err.str()) ); + } + } + if ( numLine == 1 ) // might contain "changtype" to indicate a change request + { + if ( type == "changetype" ) + { + if ( first ) + { + this->m_ldifTypeRequest = true; + } + else if (! this->m_ldifTypeRequest ) + { + // Change Request in Entry record LDIF, should we accept it? + std::ostringstream err; + err << "Line " << this->m_lineNumber + << ": Change Request in an entry-only LDIF."; + throw( std::runtime_error(err.str()) ); + } + if ( value == "modify" ) + { + recordType = LDAPMsg::MODIFY_REQUEST; + } + else if ( value == "add" ) + { + recordType = LDAPMsg::ADD_REQUEST; + } + else if ( value == "delete" ) + { + recordType = LDAPMsg::DELETE_REQUEST; + } + else if ( value == "modrdn" ) + { + recordType = LDAPMsg::MODRDN_REQUEST; + } + else + { + DEBUG(LDAP_DEBUG_TRACE, " Unknown change request <" + << value << ">" << std::endl); + std::ostringstream err; + err << "Line " << this->m_lineNumber + << ": Unknown changetype: \"" << value << "\"."; + throw( std::runtime_error(err.str()) ); + } + } + else + { + if ( first ) + { + this->m_ldifTypeRequest = false; + } + else if (this->m_ldifTypeRequest ) + { + // Entry record in Change record LDIF, should we accept + // it (e.g. as AddRequest)? + } + recordType = LDAPMsg::SEARCH_ENTRY; + } + } + m_currentRecord.push_back( stringpair(type, value) ); + numLine++; + } + DEBUG(LDAP_DEBUG_TRACE, "<- LdifReader::readRecord() return: " + << recordType << std::endl); + m_curRecType = recordType; + return recordType; +} + +LDAPEntry LdifReader::getEntryRecord() +{ + std::list<stringpair>::const_iterator i = m_currentRecord.begin(); + if ( m_curRecType != LDAPMsg::SEARCH_ENTRY ) + { + throw( std::runtime_error( "The LDIF record: '" + i->second + + "' is not a valid LDAP Entry" )); + } + LDAPEntry resEntry(i->second); + i++; + LDAPAttribute curAttr(i->first); + LDAPAttributeList *curAl = new LDAPAttributeList(); + for ( ; i != m_currentRecord.end(); i++ ) + { + if ( i->first == curAttr.getName() ) + { + curAttr.addValue(i->second); + } + else + { + const LDAPAttribute* existing = curAl->getAttributeByName( i->first ); + if ( existing ) + { + // Attribute exists already (handle gracefully) + curAl->addAttribute( curAttr ); + curAttr = LDAPAttribute( *existing ); + curAttr.addValue(i->second); + curAl->delAttribute( i->first ); + } + else + { + curAl->addAttribute( curAttr ); + curAttr = LDAPAttribute( i->first, i->second ); + } + } + } + curAl->addAttribute( curAttr ); + resEntry.setAttributes( curAl ); + return resEntry; +} + +int LdifReader::getLdifLine(std::string &ldifline) +{ + DEBUG(LDAP_DEBUG_TRACE, "-> LdifReader::getLdifLine()" << std::endl); + + this->m_lineNumber++; + if ( ! getline(m_ldifstream, ldifline) ) + { + return -1; + } + while ( m_ldifstream && + (m_ldifstream.peek() == ' ' || m_ldifstream.peek() == '\t')) + { + std::string cat; + m_ldifstream.ignore(); + getline(m_ldifstream, cat); + ldifline += cat; + this->m_lineNumber++; + } + + DEBUG(LDAP_DEBUG_TRACE, "<- LdifReader::getLdifLine()" << std::endl); + return 0; +} + +void LdifReader::splitLine( + const std::string& line, + std::string &type, + std::string &value) const +{ + std::string::size_type pos = line.find(':'); + if ( pos == std::string::npos ) + { + DEBUG(LDAP_DEBUG_ANY, "Invalid LDIF line. No `:` separator" + << std::endl ); + std::ostringstream err; + err << "Line " << this->m_lineNumber << ": Invalid LDIF line. No `:` separator"; + throw( std::runtime_error( err.str() )); + } + + type = line.substr(0, pos); + if ( pos == line.size() ) + { + // empty value + value = ""; + return; + } + + pos++; + char delim = line[pos]; + if ( delim == ':' || delim == '<' ) + { + pos++; + } + + for( ; pos < line.size() && isspace(line[pos]); pos++ ) + { /* empty */ } + + value = line.substr(pos); + + if ( delim == ':' ) + { + // Base64 encoded value + DEBUG(LDAP_DEBUG_TRACE, " base64 encoded value" << std::endl ); + char outbuf[value.size()]; + int rc = sasl_decode64(value.c_str(), value.size(), + outbuf, value.size(), NULL); + if( rc == SASL_OK ) + { + value = std::string(outbuf); + } + else if ( rc == SASL_BADPROT ) + { + value = ""; + DEBUG( LDAP_DEBUG_TRACE, " invalid base64 content" << std::endl ); + std::ostringstream err; + err << "Line " << this->m_lineNumber << ": Can't decode Base64 data"; + throw( std::runtime_error( err.str() )); + } + else if ( rc == SASL_BUFOVER ) + { + value = ""; + DEBUG( LDAP_DEBUG_TRACE, " not enough space in output buffer" + << std::endl ); + std::ostringstream err; + err << "Line " << this->m_lineNumber + << ": Can't decode Base64 data. Buffer too small"; + throw( std::runtime_error( err.str() )); + } + } + else if ( delim == '<' ) + { + // URL value + DEBUG(LDAP_DEBUG_TRACE, " url value" << std::endl ); + std::ostringstream err; + err << "Line " << this->m_lineNumber + << ": URLs are currently not supported"; + throw( std::runtime_error( err.str() )); + } + else + { + // "normal" value + DEBUG(LDAP_DEBUG_TRACE, " string value" << std::endl ); + } + DEBUG(LDAP_DEBUG_TRACE, " Type: <" << type << ">" << std::endl ); + DEBUG(LDAP_DEBUG_TRACE, " Value: <" << value << ">" << std::endl ); + return; +} + +std::string LdifReader::readIncludeLine( const std::string& line ) const +{ + std::string::size_type pos = sizeof("file:") - 1; + std::string scheme = line.substr( 0, pos ); + std::string file; + + // only file:// URLs supported currently + if ( scheme != "file:" ) + { + DEBUG( LDAP_DEBUG_TRACE, "unsupported scheme: " << scheme + << std::endl); + } + else if ( line[pos] == '/' ) + { + if ( line[pos+1] == '/' ) + { + pos += 2; + } + file = line.substr(pos, std::string::npos); + DEBUG( LDAP_DEBUG_TRACE, "target file: " << file << std::endl); + } + return file; +} diff --git a/contrib/ldapc++/src/LdifReader.h b/contrib/ldapc++/src/LdifReader.h new file mode 100644 index 0000000..7fe6d4d --- /dev/null +++ b/contrib/ldapc++/src/LdifReader.h @@ -0,0 +1,57 @@ +// $OpenLDAP$ +/* + * Copyright 2008-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#ifndef LDIF_READER_H +#define LDIF_READER_H + +#include <LDAPEntry.h> +#include <iosfwd> +#include <list> + +typedef std::list< std::pair<std::string, std::string> > LdifRecord; +class LdifReader +{ + public: + LdifReader( std::istream &input ); + + inline bool isEntryRecords() const + { + return !m_ldifTypeRequest; + } + + inline bool isChangeRecords() const + { + return m_ldifTypeRequest; + } + + inline int getVersion() const + { + return m_version; + } + + LDAPEntry getEntryRecord(); + int readNextRecord( bool first=false ); + //LDAPRequest getChangeRecord(); + + private: + int getLdifLine(std::string &line); + + void splitLine(const std::string& line, + std::string &type, + std::string &value ) const; + + std::string readIncludeLine( const std::string &line) const; + + std::istream &m_ldifstream; + LdifRecord m_currentRecord; + int m_version; + int m_curRecType; + int m_lineNumber; + bool m_ldifTypeRequest; + bool m_currentIsFirst; +}; + +#endif /* LDIF_READER_H */ diff --git a/contrib/ldapc++/src/LdifWriter.cpp b/contrib/ldapc++/src/LdifWriter.cpp new file mode 100644 index 0000000..5dcbd41 --- /dev/null +++ b/contrib/ldapc++/src/LdifWriter.cpp @@ -0,0 +1,116 @@ +// $OpenLDAP$ +/* + * Copyright 2008-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#include "LdifWriter.h" +#include "StringList.h" +#include "LDAPAttribute.h" +#include "debug.h" +#include <sstream> +#include <stdexcept> + +LdifWriter::LdifWriter( std::ostream& output, int version ) : + m_ldifstream(output), m_version(version), m_addSeparator(false) +{ + if ( version ) + { + if ( version == 1 ) + { + m_ldifstream << "version: " << version << std::endl; + m_addSeparator = true; + } else { + std::ostringstream err; + err << "Unsupported LDIF Version"; + throw( std::runtime_error(err.str()) ); + } + } + +} + +void LdifWriter::writeRecord(const LDAPEntry& le) +{ + std::ostringstream line; + + if ( m_addSeparator ) + { + m_ldifstream << std::endl; + } else { + m_addSeparator = true; + } + + line << "dn: " << le.getDN(); + this->breakline( line.str(), m_ldifstream ); + + const LDAPAttributeList *al = le.getAttributes(); + LDAPAttributeList::const_iterator i = al->begin(); + for ( ; i != al->end(); i++ ) + { + StringList values = i->getValues(); + StringList::const_iterator j = values.begin(); + for( ; j != values.end(); j++) + { + // clear output stream + line.str(""); + line << i->getName() << ": " << *j; + this->breakline( line.str(), m_ldifstream ); + } + } +} + +void LdifWriter::writeIncludeRecord( const std::string& target ) +{ + DEBUG(LDAP_DEBUG_TRACE, "writeIncludeRecord: " << target << std::endl); + std::string scheme = target.substr( 0, sizeof("file:")-1 ); + + if ( m_version == 1 ) + { + std::ostringstream err; + err << "\"include\" not allowed in LDIF version 1."; + throw( std::runtime_error(err.str()) ); + } + + if ( m_addSeparator ) + { + m_ldifstream << std::endl; + } else { + m_addSeparator = true; + } + + m_ldifstream << "include: "; + if ( scheme != "file:" ) + { + m_ldifstream << "file://"; + } + + m_ldifstream << target << std::endl; +} + +void LdifWriter::breakline( const std::string &line, std::ostream &out ) +{ + std::string::size_type pos = 0; + std::string::size_type linelength = 76; + bool first = true; + + if ( line.length() >= linelength ) + { + while ( pos < line.length() ) + { + if (! first ) + { + out << " "; + } + out << line.substr(pos, linelength) << std::endl; + pos += linelength; + if ( first ) + { + first = false; + linelength--; //account for the leading space + } + } + } else { + out << line << std::endl; + } +} + diff --git a/contrib/ldapc++/src/LdifWriter.h b/contrib/ldapc++/src/LdifWriter.h new file mode 100644 index 0000000..10c487d --- /dev/null +++ b/contrib/ldapc++/src/LdifWriter.h @@ -0,0 +1,31 @@ +// $OpenLDAP$ +/* + * Copyright 2008-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#ifndef LDIF_WRITER_H +#define LDIF_WRITER_H + +#include <LDAPEntry.h> +#include <iosfwd> +#include <list> + +class LdifWriter +{ + public: + LdifWriter( std::ostream& output, int version = 0 ); + void writeRecord(const LDAPEntry& le); + void writeIncludeRecord(const std::string& target); + + private: + void breakline( const std::string &line, std::ostream &out ); + + std::ostream& m_ldifstream; + int m_version; + bool m_addSeparator; + +}; + +#endif /* LDIF_WRITER_H */ + diff --git a/contrib/ldapc++/src/Makefile.am b/contrib/ldapc++/src/Makefile.am new file mode 100644 index 0000000..83e3abc --- /dev/null +++ b/contrib/ldapc++/src/Makefile.am @@ -0,0 +1,103 @@ +# $OpenLDAP$ + +### +# Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. +# COPYING RESTRICTIONS APPLY, see COPYRIGHT file +## + +lib_LTLIBRARIES = libldapcpp.la + +libldapcpp_la_SOURCES = LDAPAddRequest.cpp \ + LDAPAsynConnection.cpp \ + LDAPAttribute.cpp \ + LDAPAttributeList.cpp \ + LDAPAttrType.cpp \ + LDAPBindRequest.cpp \ + LDAPCompareRequest.cpp \ + LDAPConnection.cpp \ + LDAPConstraints.cpp \ + LDAPControl.cpp \ + LDAPControlSet.cpp \ + LDAPDeleteRequest.cpp \ + LDAPEntry.cpp \ + LDAPEntryList.cpp \ + LDAPException.cpp \ + LDAPExtRequest.cpp \ + LDAPExtResult.cpp \ + LDAPMessage.cpp \ + LDAPMessageQueue.cpp \ + LDAPModDNRequest.cpp \ + LDAPModification.cpp \ + LDAPModifyRequest.cpp \ + LDAPModList.cpp \ + LDAPObjClass.cpp \ + LDAPRebind.cpp \ + LDAPRebindAuth.cpp \ + LDAPReferenceList.cpp \ + LDAPRequest.cpp \ + LDAPResult.cpp \ + LDAPSaslBindResult.cpp \ + LDAPSchema.cpp \ + LDAPSearchReference.cpp \ + LDAPSearchRequest.cpp \ + LDAPSearchResult.cpp \ + LDAPSearchResults.cpp \ + LDAPUrl.cpp \ + LDAPUrlList.cpp \ + LdifReader.cpp \ + LdifWriter.cpp \ + SaslInteraction.cpp \ + SaslInteractionHandler.cpp \ + StringList.cpp \ + TlsOptions.cpp + +include_HEADERS = LDAPAsynConnection.h \ + LDAPAttribute.h \ + LDAPAttributeList.h \ + LDAPAttrType.h \ + LDAPConnection.h \ + LDAPConstraints.h \ + LDAPControl.h \ + LDAPControlSet.h \ + LDAPEntry.h \ + LDAPEntryList.h \ + LDAPException.h \ + LDAPExtResult.h \ + LDAPMessage.h \ + LDAPMessageQueue.h \ + LDAPModification.h \ + LDAPModList.h \ + LDAPObjClass.h \ + LDAPRebind.h \ + LDAPRebindAuth.h \ + LDAPReferenceList.h \ + LDAPResult.h \ + LDAPSaslBindResult.h \ + LDAPSchema.h \ + LDAPSearchReference.h \ + LDAPSearchResult.h \ + LDAPSearchResults.h \ + LDAPUrl.h \ + LDAPUrlList.h \ + LdifReader.h \ + LdifWriter.h \ + SaslInteraction.h \ + SaslInteractionHandler.h \ + StringList.h \ + TlsOptions.h + +noinst_HEADERS = ac/time.h \ + debug.h \ + LDAPAddRequest.h \ + LDAPBindRequest.h \ + LDAPCompareRequest.h \ + LDAPDeleteRequest.h \ + LDAPExtRequest.h \ + LDAPModDNRequest.h \ + LDAPModifyRequest.h \ + LDAPRequest.h \ + LDAPSearchRequest.h + +libldapcpp_la_LIBADD = -lldap -llber +libldapcpp_la_LDFLAGS = -version-info @OPENLDAP_CPP_API_VERSION@ + diff --git a/contrib/ldapc++/src/Makefile.in b/contrib/ldapc++/src/Makefile.in new file mode 100644 index 0000000..aaa3cf0 --- /dev/null +++ b/contrib/ldapc++/src/Makefile.in @@ -0,0 +1,717 @@ +# Makefile.in generated by automake 1.11 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, +# 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, +# Inc. +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ + +# $OpenLDAP$ + +### +# Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. +# COPYING RESTRICTIONS APPLY, see COPYRIGHT file + + +VPATH = @srcdir@ +pkgdatadir = $(datadir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkglibexecdir = $(libexecdir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ +subdir = src +DIST_COMMON = $(include_HEADERS) $(noinst_HEADERS) \ + $(srcdir)/Makefile.am $(srcdir)/Makefile.in \ + $(srcdir)/config.h.in +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +mkinstalldirs = $(install_sh) -d +CONFIG_HEADER = config.h +CONFIG_CLEAN_FILES = +CONFIG_CLEAN_VPATH_FILES = +am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; +am__vpath_adj = case $$p in \ + $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ + *) f=$$p;; \ + esac; +am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; +am__install_max = 40 +am__nobase_strip_setup = \ + srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` +am__nobase_strip = \ + for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" +am__nobase_list = $(am__nobase_strip_setup); \ + for p in $$list; do echo "$$p $$p"; done | \ + sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ + $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ + if (++n[$$2] == $(am__install_max)) \ + { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ + END { for (dir in files) print dir, files[dir] }' +am__base_list = \ + sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ + sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' +am__installdirs = "$(DESTDIR)$(libdir)" "$(DESTDIR)$(includedir)" +LTLIBRARIES = $(lib_LTLIBRARIES) +libldapcpp_la_DEPENDENCIES = +am_libldapcpp_la_OBJECTS = LDAPAddRequest.lo LDAPAsynConnection.lo \ + LDAPAttribute.lo LDAPAttributeList.lo LDAPAttrType.lo \ + LDAPBindRequest.lo LDAPCompareRequest.lo LDAPConnection.lo \ + LDAPConstraints.lo LDAPControl.lo LDAPControlSet.lo \ + LDAPDeleteRequest.lo LDAPEntry.lo LDAPEntryList.lo \ + LDAPException.lo LDAPExtRequest.lo LDAPExtResult.lo \ + LDAPMessage.lo LDAPMessageQueue.lo LDAPModDNRequest.lo \ + LDAPModification.lo LDAPModifyRequest.lo LDAPModList.lo \ + LDAPObjClass.lo LDAPRebind.lo LDAPRebindAuth.lo \ + LDAPReferenceList.lo LDAPRequest.lo LDAPResult.lo \ + LDAPSaslBindResult.lo LDAPSchema.lo LDAPSearchReference.lo \ + LDAPSearchRequest.lo LDAPSearchResult.lo LDAPSearchResults.lo \ + LDAPUrl.lo LDAPUrlList.lo LdifReader.lo LdifWriter.lo \ + SaslInteraction.lo SaslInteractionHandler.lo StringList.lo \ + TlsOptions.lo +libldapcpp_la_OBJECTS = $(am_libldapcpp_la_OBJECTS) +libldapcpp_la_LINK = $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \ + $(CXXFLAGS) $(libldapcpp_la_LDFLAGS) $(LDFLAGS) -o $@ +DEFAULT_INCLUDES = -I.@am__isrc@ +depcomp = $(SHELL) $(top_srcdir)/depcomp +am__depfiles_maybe = depfiles +am__mv = mv -f +CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \ + $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) +LTCXXCOMPILE = $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \ + --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \ + $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) +CXXLD = $(CXX) +CXXLINK = $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \ + --mode=link $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) \ + $(LDFLAGS) -o $@ +SOURCES = $(libldapcpp_la_SOURCES) +DIST_SOURCES = $(libldapcpp_la_SOURCES) +HEADERS = $(include_HEADERS) $(noinst_HEADERS) +ETAGS = etags +CTAGS = ctags +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +ACLOCAL = @ACLOCAL@ +AMTAR = @AMTAR@ +AR = @AR@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +CC = @CC@ +CCDEPMODE = @CCDEPMODE@ +CFLAGS = @CFLAGS@ +CPP = @CPP@ +CPPFLAGS = @CPPFLAGS@ +CXX = @CXX@ +CXXCPP = @CXXCPP@ +CXXDEPMODE = @CXXDEPMODE@ +CXXFLAGS = @CXXFLAGS@ +CYGPATH_W = @CYGPATH_W@ +DEFS = @DEFS@ +DEPDIR = @DEPDIR@ +DSYMUTIL = @DSYMUTIL@ +DUMPBIN = @DUMPBIN@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EXEEXT = @EXEEXT@ +FGREP = @FGREP@ +GREP = @GREP@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +LD = @LD@ +LDFLAGS = @LDFLAGS@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LIBTOOL = @LIBTOOL@ +LIPO = @LIPO@ +LN_S = @LN_S@ +LTLIBOBJS = @LTLIBOBJS@ +MAKEINFO = @MAKEINFO@ +MKDIR_P = @MKDIR_P@ +NM = @NM@ +NMEDIT = @NMEDIT@ +OBJDUMP = @OBJDUMP@ +OBJEXT = @OBJEXT@ +OPENLDAP_CPP_API_VERSION = @OPENLDAP_CPP_API_VERSION@ +OTOOL = @OTOOL@ +OTOOL64 = @OTOOL64@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +RANLIB = @RANLIB@ +SED = @SED@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +VERSION = @VERSION@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_ct_CC = @ac_ct_CC@ +ac_ct_CXX = @ac_ct_CXX@ +ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ +am__include = @am__include@ +am__leading_dot = @am__leading_dot@ +am__quote = @am__quote@ +am__tar = @am__tar@ +am__untar = @am__untar@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +lt_ECHO = @lt_ECHO@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +top_build_prefix = @top_build_prefix@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +lib_LTLIBRARIES = libldapcpp.la +libldapcpp_la_SOURCES = LDAPAddRequest.cpp \ + LDAPAsynConnection.cpp \ + LDAPAttribute.cpp \ + LDAPAttributeList.cpp \ + LDAPAttrType.cpp \ + LDAPBindRequest.cpp \ + LDAPCompareRequest.cpp \ + LDAPConnection.cpp \ + LDAPConstraints.cpp \ + LDAPControl.cpp \ + LDAPControlSet.cpp \ + LDAPDeleteRequest.cpp \ + LDAPEntry.cpp \ + LDAPEntryList.cpp \ + LDAPException.cpp \ + LDAPExtRequest.cpp \ + LDAPExtResult.cpp \ + LDAPMessage.cpp \ + LDAPMessageQueue.cpp \ + LDAPModDNRequest.cpp \ + LDAPModification.cpp \ + LDAPModifyRequest.cpp \ + LDAPModList.cpp \ + LDAPObjClass.cpp \ + LDAPRebind.cpp \ + LDAPRebindAuth.cpp \ + LDAPReferenceList.cpp \ + LDAPRequest.cpp \ + LDAPResult.cpp \ + LDAPSaslBindResult.cpp \ + LDAPSchema.cpp \ + LDAPSearchReference.cpp \ + LDAPSearchRequest.cpp \ + LDAPSearchResult.cpp \ + LDAPSearchResults.cpp \ + LDAPUrl.cpp \ + LDAPUrlList.cpp \ + LdifReader.cpp \ + LdifWriter.cpp \ + SaslInteraction.cpp \ + SaslInteractionHandler.cpp \ + StringList.cpp \ + TlsOptions.cpp + +include_HEADERS = LDAPAsynConnection.h \ + LDAPAttribute.h \ + LDAPAttributeList.h \ + LDAPAttrType.h \ + LDAPConnection.h \ + LDAPConstraints.h \ + LDAPControl.h \ + LDAPControlSet.h \ + LDAPEntry.h \ + LDAPEntryList.h \ + LDAPException.h \ + LDAPExtResult.h \ + LDAPMessage.h \ + LDAPMessageQueue.h \ + LDAPModification.h \ + LDAPModList.h \ + LDAPObjClass.h \ + LDAPRebind.h \ + LDAPRebindAuth.h \ + LDAPReferenceList.h \ + LDAPResult.h \ + LDAPSaslBindResult.h \ + LDAPSchema.h \ + LDAPSearchReference.h \ + LDAPSearchResult.h \ + LDAPSearchResults.h \ + LDAPUrl.h \ + LDAPUrlList.h \ + LdifReader.h \ + LdifWriter.h \ + SaslInteraction.h \ + SaslInteractionHandler.h \ + StringList.h \ + TlsOptions.h + +noinst_HEADERS = ac/time.h \ + debug.h \ + LDAPAddRequest.h \ + LDAPBindRequest.h \ + LDAPCompareRequest.h \ + LDAPDeleteRequest.h \ + LDAPExtRequest.h \ + LDAPModDNRequest.h \ + LDAPModifyRequest.h \ + LDAPRequest.h \ + LDAPSearchRequest.h + +libldapcpp_la_LIBADD = -lldap -llber +libldapcpp_la_LDFLAGS = -version-info @OPENLDAP_CPP_API_VERSION@ +all: config.h + $(MAKE) $(AM_MAKEFLAGS) all-am + +.SUFFIXES: +.SUFFIXES: .cpp .lo .o .obj +$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ + && { if test -f $@; then exit 0; else break; fi; }; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/Makefile'; \ + $(am__cd) $(top_srcdir) && \ + $(AUTOMAKE) --foreign src/Makefile +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(am__aclocal_m4_deps): + +config.h: stamp-h1 + @if test ! -f $@; then \ + rm -f stamp-h1; \ + $(MAKE) $(AM_MAKEFLAGS) stamp-h1; \ + else :; fi + +stamp-h1: $(srcdir)/config.h.in $(top_builddir)/config.status + @rm -f stamp-h1 + cd $(top_builddir) && $(SHELL) ./config.status src/config.h +$(srcdir)/config.h.in: $(am__configure_deps) + ($(am__cd) $(top_srcdir) && $(AUTOHEADER)) + rm -f stamp-h1 + touch $@ + +distclean-hdr: + -rm -f config.h stamp-h1 +install-libLTLIBRARIES: $(lib_LTLIBRARIES) + @$(NORMAL_INSTALL) + test -z "$(libdir)" || $(MKDIR_P) "$(DESTDIR)$(libdir)" + @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \ + list2=; for p in $$list; do \ + if test -f $$p; then \ + list2="$$list2 $$p"; \ + else :; fi; \ + done; \ + test -z "$$list2" || { \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \ + } + +uninstall-libLTLIBRARIES: + @$(NORMAL_UNINSTALL) + @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \ + for p in $$list; do \ + $(am__strip_dir) \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \ + done + +clean-libLTLIBRARIES: + -test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES) + @list='$(lib_LTLIBRARIES)'; for p in $$list; do \ + dir="`echo $$p | sed -e 's|/[^/]*$$||'`"; \ + test "$$dir" != "$$p" || dir=.; \ + echo "rm -f \"$${dir}/so_locations\""; \ + rm -f "$${dir}/so_locations"; \ + done +libldapcpp.la: $(libldapcpp_la_OBJECTS) $(libldapcpp_la_DEPENDENCIES) + $(libldapcpp_la_LINK) -rpath $(libdir) $(libldapcpp_la_OBJECTS) $(libldapcpp_la_LIBADD) $(LIBS) + +mostlyclean-compile: + -rm -f *.$(OBJEXT) + +distclean-compile: + -rm -f *.tab.c + +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LDAPAddRequest.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LDAPAsynConnection.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LDAPAttrType.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LDAPAttribute.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LDAPAttributeList.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LDAPBindRequest.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LDAPCompareRequest.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LDAPConnection.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LDAPConstraints.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LDAPControl.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LDAPControlSet.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LDAPDeleteRequest.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LDAPEntry.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LDAPEntryList.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LDAPException.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LDAPExtRequest.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LDAPExtResult.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LDAPMessage.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LDAPMessageQueue.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LDAPModDNRequest.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LDAPModList.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LDAPModification.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LDAPModifyRequest.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LDAPObjClass.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LDAPRebind.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LDAPRebindAuth.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LDAPReferenceList.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LDAPRequest.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LDAPResult.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LDAPSaslBindResult.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LDAPSchema.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LDAPSearchReference.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LDAPSearchRequest.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LDAPSearchResult.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LDAPSearchResults.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LDAPUrl.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LDAPUrlList.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LdifReader.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/LdifWriter.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/SaslInteraction.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/SaslInteractionHandler.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/StringList.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/TlsOptions.Plo@am__quote@ + +.cpp.o: +@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $< +@am__fastdepCXX_TRUE@ $(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(CXXCOMPILE) -c -o $@ $< + +.cpp.obj: +@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'` +@am__fastdepCXX_TRUE@ $(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'` + +.cpp.lo: +@am__fastdepCXX_TRUE@ $(LTCXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $< +@am__fastdepCXX_TRUE@ $(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(LTCXXCOMPILE) -c -o $@ $< + +mostlyclean-libtool: + -rm -f *.lo + +clean-libtool: + -rm -rf .libs _libs +install-includeHEADERS: $(include_HEADERS) + @$(NORMAL_INSTALL) + test -z "$(includedir)" || $(MKDIR_P) "$(DESTDIR)$(includedir)" + @list='$(include_HEADERS)'; test -n "$(includedir)" || list=; \ + for p in $$list; do \ + if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \ + echo "$$d$$p"; \ + done | $(am__base_list) | \ + while read files; do \ + echo " $(INSTALL_HEADER) $$files '$(DESTDIR)$(includedir)'"; \ + $(INSTALL_HEADER) $$files "$(DESTDIR)$(includedir)" || exit $$?; \ + done + +uninstall-includeHEADERS: + @$(NORMAL_UNINSTALL) + @list='$(include_HEADERS)'; test -n "$(includedir)" || list=; \ + files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \ + test -n "$$files" || exit 0; \ + echo " ( cd '$(DESTDIR)$(includedir)' && rm -f" $$files ")"; \ + cd "$(DESTDIR)$(includedir)" && rm -f $$files + +ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES) + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + mkid -fID $$unique +tags: TAGS + +TAGS: $(HEADERS) $(SOURCES) config.h.in $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + set x; \ + here=`pwd`; \ + list='$(SOURCES) $(HEADERS) config.h.in $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + shift; \ + if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + if test $$# -gt 0; then \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + "$$@" $$unique; \ + else \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$unique; \ + fi; \ + fi +ctags: CTAGS +CTAGS: $(HEADERS) $(SOURCES) config.h.in $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + list='$(SOURCES) $(HEADERS) config.h.in $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + test -z "$(CTAGS_ARGS)$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && $(am__cd) $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) "$$here" + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + +distdir: $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d "$(distdir)/$$file"; then \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ + else \ + test -f "$(distdir)/$$file" \ + || cp -p $$d/$$file "$(distdir)/$$file" \ + || exit 1; \ + fi; \ + done +check-am: all-am +check: check-am +all-am: Makefile $(LTLIBRARIES) $(HEADERS) config.h +installdirs: + for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(includedir)"; do \ + test -z "$$dir" || $(MKDIR_P) "$$dir"; \ + done +install: install-am +install-exec: install-exec-am +install-data: install-data-am +uninstall: uninstall-am + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-am +install-strip: + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + `test -z '$(STRIP)' || \ + echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install +mostlyclean-generic: + +clean-generic: + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-am + +clean-am: clean-generic clean-libLTLIBRARIES clean-libtool \ + mostlyclean-am + +distclean: distclean-am + -rm -rf ./$(DEPDIR) + -rm -f Makefile +distclean-am: clean-am distclean-compile distclean-generic \ + distclean-hdr distclean-tags + +dvi: dvi-am + +dvi-am: + +html: html-am + +html-am: + +info: info-am + +info-am: + +install-data-am: install-includeHEADERS + +install-dvi: install-dvi-am + +install-dvi-am: + +install-exec-am: install-libLTLIBRARIES + +install-html: install-html-am + +install-html-am: + +install-info: install-info-am + +install-info-am: + +install-man: + +install-pdf: install-pdf-am + +install-pdf-am: + +install-ps: install-ps-am + +install-ps-am: + +installcheck-am: + +maintainer-clean: maintainer-clean-am + -rm -rf ./$(DEPDIR) + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-am + +mostlyclean-am: mostlyclean-compile mostlyclean-generic \ + mostlyclean-libtool + +pdf: pdf-am + +pdf-am: + +ps: ps-am + +ps-am: + +uninstall-am: uninstall-includeHEADERS uninstall-libLTLIBRARIES + +.MAKE: all install-am install-strip + +.PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \ + clean-libLTLIBRARIES clean-libtool ctags distclean \ + distclean-compile distclean-generic distclean-hdr \ + distclean-libtool distclean-tags distdir dvi dvi-am html \ + html-am info info-am install install-am install-data \ + install-data-am install-dvi install-dvi-am install-exec \ + install-exec-am install-html install-html-am \ + install-includeHEADERS install-info install-info-am \ + install-libLTLIBRARIES install-man install-pdf install-pdf-am \ + install-ps install-ps-am install-strip installcheck \ + installcheck-am installdirs maintainer-clean \ + maintainer-clean-generic mostlyclean mostlyclean-compile \ + mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \ + tags uninstall uninstall-am uninstall-includeHEADERS \ + uninstall-libLTLIBRARIES + + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/contrib/ldapc++/src/SaslInteraction.cpp b/contrib/ldapc++/src/SaslInteraction.cpp new file mode 100644 index 0000000..a4ad187 --- /dev/null +++ b/contrib/ldapc++/src/SaslInteraction.cpp @@ -0,0 +1,44 @@ +// $OpenLDAP$ +/* + * Copyright 2007-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#include <SaslInteraction.h> +#include <iostream> +#include "debug.h" + +SaslInteraction::SaslInteraction( sasl_interact_t *interact ) : + m_interact(interact) {} + +SaslInteraction::~SaslInteraction() +{ + DEBUG(LDAP_DEBUG_TRACE, "SaslInteraction::~SaslInteraction()" << std::endl); +} + +unsigned long SaslInteraction::getId() const +{ + return m_interact->id; +} + +const std::string SaslInteraction::getPrompt() const +{ + return std::string(m_interact->prompt); +} + +const std::string SaslInteraction::getChallenge() const +{ + return std::string(m_interact->challenge); +} + +const std::string SaslInteraction::getDefaultResult() const +{ + return std::string(m_interact->defresult); +} + +void SaslInteraction::setResult(const std::string &res) +{ + m_result = res; + m_interact->result = m_result.data(); + m_interact->len = m_result.size(); +} diff --git a/contrib/ldapc++/src/SaslInteraction.h b/contrib/ldapc++/src/SaslInteraction.h new file mode 100644 index 0000000..2033a41 --- /dev/null +++ b/contrib/ldapc++/src/SaslInteraction.h @@ -0,0 +1,29 @@ +// $OpenLDAP$ +/* + * Copyright 2007-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#ifndef SASL_INTERACTION_H +#define SASL_INTERACTION_H + +#include <string> +#include <sasl/sasl.h> + +class SaslInteraction { + public: + SaslInteraction( sasl_interact_t *interact ); + ~SaslInteraction(); + unsigned long getId() const; + const std::string getPrompt() const; + const std::string getChallenge() const; + const std::string getDefaultResult() const; + + void setResult(const std::string &res); + + private: + sasl_interact_t *m_interact; + std::string m_result; + +}; +#endif /* SASL_INTERACTION_H */ diff --git a/contrib/ldapc++/src/SaslInteractionHandler.cpp b/contrib/ldapc++/src/SaslInteractionHandler.cpp new file mode 100644 index 0000000..cb5d37d --- /dev/null +++ b/contrib/ldapc++/src/SaslInteractionHandler.cpp @@ -0,0 +1,101 @@ +// $OpenLDAP$ +/* + * Copyright 2007-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#include <iostream> +#include <iomanip> +#include <limits> +#include "config.h" + +#ifdef HAVE_TERMIOS_H +#include <termios.h> +#include <unistd.h> +#include <cstdio> +#endif + +#include <string.h> +#include "SaslInteractionHandler.h" +#include "SaslInteraction.h" +#include "debug.h" + +void DefaultSaslInteractionHandler::handleInteractions( + const std::list<SaslInteraction*> &cb ) +{ + DEBUG(LDAP_DEBUG_TRACE, "DefaultSaslInteractionHandler::handleCallbacks()" + << std::endl ); + std::list<SaslInteraction*>::const_iterator i; + + for (i = cb.begin(); i != cb.end(); i++ ) { + bool noecho; + + cleanupList.push_back(*i); + + std::cout << (*i)->getPrompt(); + if (! (*i)->getDefaultResult().empty() ) { + std::cout << "(" << (*i)->getDefaultResult() << ")" ; + } + std:: cout << ": "; + + switch ( (*i)->getId() ) { + case SASL_CB_PASS: + case SASL_CB_ECHOPROMPT: + noecho = true; + noecho = true; + break; + default: + noecho = false; + break; + } +#ifdef HAVE_TERMIOS_H + /* turn off terminal echo if needed */ + struct termios old_attr; + if ( noecho ) { + struct termios attr; + if (tcgetattr(STDIN_FILENO, &attr) < 0) { + perror("tcgetattr"); + } + + /* save terminal attributes */ + memcpy(&old_attr, &attr, sizeof(attr)); + + /* disable echo */ + attr.c_lflag &= ~(ECHO); + + /* write attributes to terminal */ + if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &attr) < 0) { + perror("tcsetattr"); + } + } +#endif /* HAVE_TERMIOS_H */ + std::string input; + std::cin >> std::noskipws >> input; + std::cin >> std::skipws; + (*i)->setResult(input); + if( std::cin.fail() ) { + std::cin.clear(); + } + /* ignore the rest of the input line */ + std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); + +#ifdef HAVE_TERMIOS_H + /* restore terminal settings */ + if ( noecho ) { + tcsetattr(STDIN_FILENO, TCSANOW, &old_attr); + std::cout << std::endl; + } +#endif /* HAVE_TERMIOS_H */ + } +} + +DefaultSaslInteractionHandler::~DefaultSaslInteractionHandler() +{ + DEBUG(LDAP_DEBUG_TRACE, "DefaultSaslInteractionHandler::~DefaultSaslInteractionHandler()" + << std::endl ); + + std::list<SaslInteraction*>::const_iterator i; + for (i = cleanupList.begin(); i != cleanupList.end(); i++ ) { + delete(*i); + } +} diff --git a/contrib/ldapc++/src/SaslInteractionHandler.h b/contrib/ldapc++/src/SaslInteractionHandler.h new file mode 100644 index 0000000..d356983 --- /dev/null +++ b/contrib/ldapc++/src/SaslInteractionHandler.h @@ -0,0 +1,27 @@ +// $OpenLDAP$ +/* + * Copyright 2007-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#ifndef SASL_INTERACTION_HANDLER_H +#define SASL_INTERACTION_HANDLER_H +#include <list> + +class SaslInteraction; + +class SaslInteractionHandler { + public: + virtual void handleInteractions( const std::list<SaslInteraction*> &cb )=0; + virtual ~SaslInteractionHandler() {} +}; + +class DefaultSaslInteractionHandler { + public: + virtual void handleInteractions( const std::list<SaslInteraction*> &cb ); + virtual ~DefaultSaslInteractionHandler(); + + private: + std::list<SaslInteraction*> cleanupList; +}; +#endif /* SASL_INTERACTION_HANDLER_H */ diff --git a/contrib/ldapc++/src/StringList.cpp b/contrib/ldapc++/src/StringList.cpp new file mode 100644 index 0000000..c53f6a4 --- /dev/null +++ b/contrib/ldapc++/src/StringList.cpp @@ -0,0 +1,77 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#include "StringList.h" +#include "debug.h" + +#include <cstdlib> + +using namespace std; + +StringList::StringList(){ +} + +StringList::StringList(const StringList& sl){ + m_data= StringList::ListType(sl.m_data); +} + +StringList::StringList(char** values){ + if(values == 0){ + m_data=StringList::ListType(); + }else{ + char** i; + for(i=values; *i != 0; i++){ + m_data.push_back(string(*i)); + } + } +} + +StringList::~StringList(){ + DEBUG(LDAP_DEBUG_TRACE,"StringList::~StringList()" << endl); +} + +char** StringList::toCharArray() const{ + if(!empty()){ + char** ret = (char**) malloc(sizeof(char*) * (size()+1)); + StringList::const_iterator i; + int j=0; + for(i=begin(); i != end(); i++,j++){ + ret[j]=(char*) malloc(sizeof(char) * (i->size()+1)); + i->copy(ret[j],string::npos); + ret[j][i->size()]=0; + } + ret[size()]=0; + return ret; + }else{ + return 0; + } +} + +void StringList::add(const string& value){ + m_data.push_back(value); +} + +size_t StringList::size() const{ + return m_data.size(); +} + +bool StringList::empty() const{ + return m_data.empty(); +} + +StringList::const_iterator StringList::begin() const{ + return m_data.begin(); +} + +StringList::const_iterator StringList::end() const{ + return m_data.end(); +} + + +void StringList::clear(){ + m_data.clear(); +} + diff --git a/contrib/ldapc++/src/StringList.h b/contrib/ldapc++/src/StringList.h new file mode 100644 index 0000000..95c8c8c --- /dev/null +++ b/contrib/ldapc++/src/StringList.h @@ -0,0 +1,88 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#ifndef STRING_LIST_H +#define STRING_LIST_H + +#include <string> +#include <list> +/** + * Container class to store multiple string-objects + */ +class StringList{ + typedef std::list<std::string> ListType; + + private: + ListType m_data; + + public: + typedef ListType::const_iterator const_iterator; + + /** + * Constructs an empty list. + */ + StringList(); + + /** + * Copy-constructor + */ + StringList(const StringList& sl); + + /** + * For internal use only + * + * This constructor is used by the library internally to create a + * list of string from a array for c-Strings (char*)thar was + * returned by the C-API + */ + StringList(char** values); + + /** + * Destructor + */ + ~StringList(); + + /** + * The methods converts the list to a 0-terminated array of + * c-Strings. + */ + char** toCharArray() const; + + /** + * Adds one element to the end of the list. + * @param attr The attribute to add to the list. + */ + void add(const std::string& value); + + /** + * @return The number of strings that are currently + * stored in this list. + */ + size_t size() const; + + /** + * @return true if there are zero strings currently + * stored in this list. + */ + bool empty() const; + + /** + * @return A iterator that points to the first element of the list. + */ + const_iterator begin() const; + + /** + * @return A iterator that points to the element after the last + * element of the list. + */ + const_iterator end() const; + + /** + * removes all elements from the list + */ + void clear(); +}; +#endif //STRING_LIST_H diff --git a/contrib/ldapc++/src/TlsOptions.cpp b/contrib/ldapc++/src/TlsOptions.cpp new file mode 100644 index 0000000..609f127 --- /dev/null +++ b/contrib/ldapc++/src/TlsOptions.cpp @@ -0,0 +1,163 @@ +// $OpenLDAP$ +/* + * Copyright 2010-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#include <fstream> +#include <sstream> +#include <sys/types.h> +#include <sys/stat.h> +#include <errno.h> +#include <unistd.h> +#include <cstring> +#include "TlsOptions.h" +#include "LDAPException.h" + +enum opttype { + INT=0, + STRING, + OTHER +}; + +typedef struct tls_optmap { + int optval; + opttype type; +} tls_optmap_t; + +static tls_optmap_t optmap[] = { + { LDAP_OPT_X_TLS_CACERTFILE, STRING }, + { LDAP_OPT_X_TLS_CACERTDIR, STRING }, + { LDAP_OPT_X_TLS_CERTFILE, STRING }, + { LDAP_OPT_X_TLS_KEYFILE, STRING }, + { LDAP_OPT_X_TLS_REQUIRE_CERT, INT }, + { LDAP_OPT_X_TLS_PROTOCOL_MIN, INT }, + { LDAP_OPT_X_TLS_CIPHER_SUITE, STRING }, + { LDAP_OPT_X_TLS_RANDOM_FILE, STRING }, + { LDAP_OPT_X_TLS_CRLCHECK, INT }, + { LDAP_OPT_X_TLS_DHFILE, STRING }, + { LDAP_OPT_X_TLS_NEWCTX, INT } +}; +#if 0 /* not implemented currently */ + static const int TLS_CRLFILE /* GNUtls only */ + static const int TLS_SSL_CTX /* OpenSSL SSL* */ + static const int TLS_CONNECT_CB + static const int TLS_CONNECT_ARG +#endif + +static void checkOpt( TlsOptions::tls_option opt, opttype type ) { + if ( opt < TlsOptions::CACERTFILE || opt >= TlsOptions::LASTOPT ){ + throw( LDAPException( LDAP_PARAM_ERROR, "unknown Option" ) ); + } + + if ( optmap[opt].type != type ){ + throw( LDAPException( LDAP_PARAM_ERROR, "not a string option" ) ); + } +} + +TlsOptions::TlsOptions() : m_ld(NULL) {} + +TlsOptions::TlsOptions( LDAP* ld ): m_ld(ld) { } + +void TlsOptions::setOption( tls_option opt, const std::string& value ) const { + checkOpt(opt, STRING); + switch(opt) { + case TlsOptions::CACERTFILE : + case TlsOptions::CERTFILE : + case TlsOptions::KEYFILE : + { + // check if the supplied file is actually readable + std::ifstream ifile(value.c_str()); + if ( !ifile ) { + throw( LDAPException( LDAP_LOCAL_ERROR, "Unable to open the supplied file for reading" ) ); + } + } + break; + case TlsOptions::CACERTDIR : + { + struct stat st; + std::ostringstream msg; + bool fail=false; + int err = stat(value.c_str(),&st); + if ( err ) { + msg << strerror(errno); + fail = true; + } else { + if ( !S_ISDIR(st.st_mode) ){ + msg << "The supplied path is not a directory."; + fail = true; + } + } + if ( fail ) { + std::ostringstream errstr; + errstr << "Error while setting Certificate Directory (" << value << "): " << msg.str(); + throw( LDAPException( LDAP_LOCAL_ERROR, errstr.str() ) ); + } + } + break; + } + this->setOption( opt, value.empty() ? NULL : (void*) value.c_str() ); +} + +void TlsOptions::setOption( tls_option opt, int value ) const { + checkOpt(opt, INT); + this->setOption( opt, (void*) &value); +} + +void TlsOptions::setOption( tls_option opt, void *value ) const { + int ret = ldap_set_option( m_ld, optmap[opt].optval, value); + if ( ret != LDAP_OPT_SUCCESS ) + { + if ( ret != LDAP_OPT_ERROR ){ + throw( LDAPException( ret )); + } else { + throw( LDAPException( LDAP_PARAM_ERROR, "error while setting TLS option" ) ); + } + } + this->newCtx(); +} + +void TlsOptions::getOption( tls_option opt, void* value ) const { + int ret = ldap_get_option( m_ld, optmap[opt].optval, value); + if ( ret != LDAP_OPT_SUCCESS ) + { + if ( ret != LDAP_OPT_ERROR ){ + throw( LDAPException( ret )); + } else { + throw( LDAPException( LDAP_PARAM_ERROR, "error while reading TLS option" ) ); + } + } +} + +int TlsOptions::getIntOption( tls_option opt ) const { + int value; + checkOpt(opt, INT); + ldap_get_option( m_ld, optmap[opt].optval, (void*) &value); + return value; +} + +std::string TlsOptions::getStringOption( tls_option opt ) const { + char *value; + checkOpt(opt, STRING); + ldap_get_option( m_ld, optmap[opt].optval, (void*) &value); + std::string strval; + if (value) + { + strval=std::string(value); + ldap_memfree(value); + } + return strval; +} + +void TlsOptions::newCtx() const { + int val = 0; + int ret = ldap_set_option( m_ld, LDAP_OPT_X_TLS_NEWCTX, &val); + if ( ret != LDAP_OPT_SUCCESS ) + { + if ( ret != LDAP_OPT_ERROR ){ + throw( LDAPException( ret )); + } else { + throw( LDAPException( LDAP_LOCAL_ERROR, "error while renewing TLS context" ) ); + } + } +} diff --git a/contrib/ldapc++/src/TlsOptions.h b/contrib/ldapc++/src/TlsOptions.h new file mode 100644 index 0000000..41d6ee3 --- /dev/null +++ b/contrib/ldapc++/src/TlsOptions.h @@ -0,0 +1,162 @@ +// $OpenLDAP$ +/* + * Copyright 2010-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ +#ifndef TLS_OPTIONS_H +#define TLS_OPTIONS_H +#include <string> +#include <ldap.h> + +/** + * Class to access the global (and connection specific) TLS Settings + * To access the global TLS Settings just instantiate a TlsOption object + * using the default constructor. + * + * To access connection specific settings instantiate a TlsOption object + * through the getTlsOptions() method from the corresponding + * LDAPConnection/LDAPAsynConnection object. + * + */ +class TlsOptions { + public: + + /** + * Available TLS Options + */ + enum tls_option { + CACERTFILE=0, + CACERTDIR, + CERTFILE, + KEYFILE, + REQUIRE_CERT, + PROTOCOL_MIN, + CIPHER_SUITE, + RANDOM_FILE, + CRLCHECK, + DHFILE, + /// @cond + LASTOPT /* dummy */ + /// @endcond + }; + + /** + * Possible Values for the REQUIRE_CERT option + */ + enum verifyMode { + NEVER=0, + HARD, + DEMAND, + ALLOW, + TRY + }; + + /** + * Possible Values for the CRLCHECK option + */ + enum crlMode { + CRL_NONE=0, + CRL_PEER, + CRL_ALL + }; + + + /** + * Default constructor. Gives access to the global TlsSettings + */ + TlsOptions(); + + /** + * Set string valued options. + * @param opt The following string valued options are available: + * - TlsOptions::CACERTFILE + * - TlsOptions::CACERTDIR + * - TlsOptions::CERTFILE + * - TlsOptions::KEYFILE + * - TlsOptions::CIPHER_SUITE + * - TlsOptions::RANDOM_FILE + * - TlsOptions::DHFILE + * @param value The value to apply to that option, + * - TlsOptions::CACERTFILE: + * The path to the file containing all recognized Certificate + * Authorities + * - TlsOptions::CACERTDIR: + * The path to a directory containing individual files of all + * recognized Certificate Authority certificates + * - TlsOptions::CERTFILE: + * The path to the client certificate + * - TlsOptions::KEYFILE: + * The path to the file containing the private key matching the + * Certificate that as configured with TlsOptions::CERTFILE + * - TlsOptions::CIPHER_SUITE + * Specifies the cipher suite and preference order + * - TlsOptions::RANDOM_FILE + * Specifies the file to obtain random bits from when + * /dev/[u]random is not available. + * - TlsOptions::DHFILE + * File containing DH parameters + */ + void setOption(tls_option opt, const std::string& value) const; + + /** + * Set integer valued options. + * @param opt The following string valued options are available: + * - TlsOptions::REQUIRE_CERT + * - TlsOptions::PROTOCOL_MIN + * - TlsOptions::CRLCHECK + * @param value The value to apply to that option, + * - TlsOptions::REQUIRE_CERT: + * Possible Values (For details see the ldap.conf(5) man-page): + * - TlsOptions::NEVER + * - TlsOptions::DEMAND + * - TlsOptions::ALLOW + * - TlsOptions::TRY + * - TlsOptions::PROTOCOL_MIN + * - TlsOptions::CRLCHECK + * Possible Values: + * - TlsOptions::CRL_NONE + * - TlsOptions::CRL_PEER + * - TlsOptions::CRL_ALL + */ + void setOption(tls_option opt, int value) const; + + /** + * Generic setOption variant. Generally you should prefer to use one + * of the other variants + */ + void setOption(tls_option opt, void *value) const; + + /** + * Read integer valued options + * @return Option value + * @throws LDAPException in case of error (invalid on non-integer + * valued option is requested) + */ + int getIntOption(tls_option opt) const; + + /** + * Read string valued options + * @return Option value + * @throws LDAPException in case of error (invalid on non-string + * valued option is requested) + */ + std::string getStringOption(tls_option opt) const; + + /** + * Read options value. Usually you should prefer to use either + * getIntOption() or getStringOption() + * @param value points to a buffer containing the option value + * @throws LDAPException in case of error (invalid on non-string + * valued option is requested) + */ + void getOption(tls_option opt, void *value ) const; + + private: + TlsOptions( LDAP* ld ); + void newCtx() const; + LDAP *m_ld; + + friend class LDAPAsynConnection; +}; + +#endif /* TLS_OPTIONS_H */ diff --git a/contrib/ldapc++/src/ac/time.h b/contrib/ldapc++/src/ac/time.h new file mode 100644 index 0000000..cc89f70 --- /dev/null +++ b/contrib/ldapc++/src/ac/time.h @@ -0,0 +1,28 @@ +/* Generic time.h */ +/* $OpenLDAP$ */ +/* + * Copyright 1998-2022 The OpenLDAP Foundation, Redwood City, California, USA + * All rights reserved. + * + * Redistribution and use in source and binary forms are permitted only + * as authorized by the OpenLDAP Public License. A copy of this + * license is available at http://www.OpenLDAP.org/license.html or + * in file LICENSE in the top-level directory of the distribution. + */ + +#ifndef _AC_TIME_H +#define _AC_TIME_H + +#ifdef TIME_WITH_SYS_TIME +# include <sys/time.h> +# include <time.h> +#elif defined HAVE_SYS_TIME_H +# include <sys/time.h> +# ifdef HAVE_SYS_TIMEB_H +# include <sys/timeb.h> +# endif +#else +# include <time.h> +#endif + +#endif /* _AC_TIME_H */ diff --git a/contrib/ldapc++/src/config.h.in b/contrib/ldapc++/src/config.h.in new file mode 100644 index 0000000..3042472 --- /dev/null +++ b/contrib/ldapc++/src/config.h.in @@ -0,0 +1,70 @@ +/* src/config.h.in. Generated from configure.ac by autoheader. */ + +/* Define to 1 if you have the <dlfcn.h> header file. */ +#undef HAVE_DLFCN_H + +/* Define to 1 if you have the <inttypes.h> header file. */ +#undef HAVE_INTTYPES_H + +/* Define to 1 if you have the <ldap.h> header file. */ +#undef HAVE_LDAP_H + +/* Define to 1 if you have the `resolv' library (-lresolv). */ +#undef HAVE_LIBRESOLV + +/* Define to 1 if you have the <memory.h> header file. */ +#undef HAVE_MEMORY_H + +/* Define to 1 if you have the <stdint.h> header file. */ +#undef HAVE_STDINT_H + +/* Define to 1 if you have the <stdlib.h> header file. */ +#undef HAVE_STDLIB_H + +/* Define to 1 if you have the <strings.h> header file. */ +#undef HAVE_STRINGS_H + +/* Define to 1 if you have the <string.h> header file. */ +#undef HAVE_STRING_H + +/* Define to 1 if you have the <sys/stat.h> header file. */ +#undef HAVE_SYS_STAT_H + +/* Define to 1 if you have the <sys/types.h> header file. */ +#undef HAVE_SYS_TYPES_H + +/* Define to 1 if you have the <termios.h> header file. */ +#undef HAVE_TERMIOS_H + +/* Define to 1 if you have the <unistd.h> header file. */ +#undef HAVE_UNISTD_H + +/* Name of package */ +#undef PACKAGE + +/* Define to the address where bug reports for this package should be sent. */ +#undef PACKAGE_BUGREPORT + +/* Define to the full name of this package. */ +#undef PACKAGE_NAME + +/* Define to the full name and version of this package. */ +#undef PACKAGE_STRING + +/* Define to the one symbol short name of this package. */ +#undef PACKAGE_TARNAME + +/* Define to the version of this package. */ +#undef PACKAGE_VERSION + +/* Define to 1 if you have the ANSI C header files. */ +#undef STDC_HEADERS + +/* Define to 1 if you can safely include both <sys/time.h> and <time.h>. */ +#undef TIME_WITH_SYS_TIME + +/* Version number of package */ +#undef VERSION + +/* Define to 1 ot enable debug logging */ +#undef WITH_DEBUG diff --git a/contrib/ldapc++/src/debug.h b/contrib/ldapc++/src/debug.h new file mode 100644 index 0000000..e80b760 --- /dev/null +++ b/contrib/ldapc++/src/debug.h @@ -0,0 +1,33 @@ +// $OpenLDAP$ +/* + * Copyright 2000-2022 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + +#ifndef DEBUG_H +#define DEBUG_H +#include <iostream> +#include "config.h" +#define LDAP_DEBUG_NONE 0x0000 +#define LDAP_DEBUG_TRACE 0x0001 +#define LDAP_DEBUG_CONSTRUCT 0x0002 +#define LDAP_DEBUG_DESTROY 0x0004 +#define LDAP_DEBUG_PARAMETER 0x0008 +#define LDAP_DEBUG_ANY 0xffff + +#define DEBUGLEVEL LDAP_DEBUG_ANY + +#define PRINT_FILE \ + std::cerr << "file: " __FILE__ << " line: " << __LINE__ + +#ifdef WITH_DEBUG +#define DEBUG(level, arg) \ + if((level) & DEBUGLEVEL){ \ + std::cerr << arg ; \ + } +#else +#undef DEBUG +#define DEBUG(level,arg) +#endif //WITH_DEBUG + +#endif // DEBUG_H diff --git a/contrib/ldapc++/src/stamp-h.in b/contrib/ldapc++/src/stamp-h.in new file mode 100644 index 0000000..9788f70 --- /dev/null +++ b/contrib/ldapc++/src/stamp-h.in @@ -0,0 +1 @@ +timestamp |