diff options
| -rw-r--r-- | include/modules/ldap.h | 47 | ||||
| -rw-r--r-- | src/modules/extra/m_ldap.cpp | 647 |
2 files changed, 364 insertions, 330 deletions
diff --git a/include/modules/ldap.h b/include/modules/ldap.h index 75ab16077..aeb3aa335 100644 --- a/include/modules/ldap.h +++ b/include/modules/ldap.h @@ -1,8 +1,8 @@ /* * InspIRCd -- Internet Relay Chat Daemon * - * Copyright (C) 2013 Adam <Adam@anope.org> - * Copyright (C) 2003-2013 Anope Team <team@anope.org> + * Copyright (C) 2015 Adam <Adam@anope.org> + * Copyright (C) 2003-2015 Anope Team <team@anope.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public @@ -78,22 +78,22 @@ struct LDAPAttributes : public std::map<std::string, std::vector<std::string> > } }; +enum QueryType +{ + QUERY_UNKNOWN, + QUERY_BIND, + QUERY_SEARCH, + QUERY_ADD, + QUERY_DELETE, + QUERY_MODIFY, + QUERY_COMPARE +}; + struct LDAPResult { std::vector<LDAPAttributes> messages; std::string error; - enum QueryType - { - QUERY_UNKNOWN, - QUERY_BIND, - QUERY_SEARCH, - QUERY_ADD, - QUERY_DELETE, - QUERY_MODIFY, - QUERY_COMPARE - }; - QueryType type; LDAPQuery id; @@ -145,55 +145,48 @@ class LDAPProvider : public DataProvider /** Attempt to bind to the LDAP server as a manager * @param i The LDAPInterface the result is sent to - * @return The query ID */ - virtual LDAPQuery BindAsManager(LDAPInterface *i) = 0; + virtual void BindAsManager(LDAPInterface* i) = 0; /** Bind to LDAP * @param i The LDAPInterface the result is sent to * @param who The binddn * @param pass The password - * @return The query ID */ - virtual LDAPQuery Bind(LDAPInterface* i, const std::string& who, const std::string& pass) = 0; + virtual void Bind(LDAPInterface* i, const std::string& who, const std::string& pass) = 0; /** Search ldap for the specified filter * @param i The LDAPInterface the result is sent to * @param base The base DN to search * @param filter The filter to apply - * @return The query ID */ - virtual LDAPQuery Search(LDAPInterface* i, const std::string& base, const std::string& filter) = 0; + virtual void Search(LDAPInterface* i, const std::string& base, const std::string& filter) = 0; /** Add an entry to LDAP * @param i The LDAPInterface the result is sent to * @param dn The dn of the entry to add * @param attributes The attributes - * @return The query ID */ - virtual LDAPQuery Add(LDAPInterface* i, const std::string& dn, LDAPMods& attributes) = 0; + virtual void Add(LDAPInterface* i, const std::string& dn, LDAPMods& attributes) = 0; /** Delete an entry from LDAP * @param i The LDAPInterface the result is sent to * @param dn The dn of the entry to delete - * @return The query ID */ - virtual LDAPQuery Del(LDAPInterface* i, const std::string& dn) = 0; + virtual void Del(LDAPInterface* i, const std::string& dn) = 0; /** Modify an existing entry in LDAP * @param i The LDAPInterface the result is sent to * @param base The base DN to modify * @param attributes The attributes to modify - * @return The query ID */ - virtual LDAPQuery Modify(LDAPInterface* i, const std::string& base, LDAPMods& attributes) = 0; + virtual void Modify(LDAPInterface* i, const std::string& base, LDAPMods& attributes) = 0; /** Compare an attribute in LDAP with our value * @param i The LDAPInterface the result is sent to * @param dn DN to use for comparing * @param attr Attr of DN to compare with * @param val value to compare attr of dn - * @return the query ID */ - virtual LDAPQuery Compare(LDAPInterface* i, const std::string& dn, const std::string& attr, const std::string& val) = 0; + virtual void Compare(LDAPInterface* i, const std::string& dn, const std::string& attr, const std::string& val) = 0; }; diff --git a/src/modules/extra/m_ldap.cpp b/src/modules/extra/m_ldap.cpp index 10469f370..c11025836 100644 --- a/src/modules/extra/m_ldap.cpp +++ b/src/modules/extra/m_ldap.cpp @@ -1,8 +1,8 @@ /* * InspIRCd -- Internet Relay Chat Daemon * - * Copyright (C) 2013-2014 Adam <Adam@anope.org> - * Copyright (C) 2003-2014 Anope Team <team@anope.org> + * Copyright (C) 2013-2015 Adam <Adam@anope.org> + * Copyright (C) 2003-2015 Anope Team <team@anope.org> * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public @@ -29,6 +29,140 @@ /* $LinkerFlags: -lldap_r */ +class LDAPService; + +class LDAPRequest +{ + public: + LDAPService* service; + LDAPInterface* inter; + LDAPMessage* message; /* message returned by ldap_ */ + LDAPResult* result; /* final result */ + struct timeval tv; + QueryType type; + + LDAPRequest(LDAPService* s, LDAPInterface* i) + : service(s) + , inter(i) + , message(NULL) + , result(NULL) + { + type = QUERY_UNKNOWN; + tv.tv_sec = 0; + tv.tv_usec = 100000; + } + + virtual ~LDAPRequest() + { + delete result; + if (message != NULL) + ldap_msgfree(message); + } + + virtual int run() = 0; +}; + +class LDAPBind : public LDAPRequest +{ + std::string who, pass; + + public: + LDAPBind(LDAPService* s, LDAPInterface* i, const std::string& w, const std::string& p) + : LDAPRequest(s, i) + , who(w) + , pass(p) + { + type = QUERY_BIND; + } + + int run() CXX11_OVERRIDE; +}; + +class LDAPSearch : public LDAPRequest +{ + std::string base; + int searchscope; + std::string filter; + + public: + LDAPSearch(LDAPService* s, LDAPInterface* i, const std::string& b, int se, const std::string& f) + : LDAPRequest(s, i) + , base(b) + , searchscope(se) + , filter(f) + { + type = QUERY_SEARCH; + } + + int run() CXX11_OVERRIDE; +}; + +class LDAPAdd : public LDAPRequest +{ + std::string dn; + LDAPMods attributes; + + public: + LDAPAdd(LDAPService* s, LDAPInterface* i, const std::string& d, const LDAPMods& attr) + : LDAPRequest(s, i) + , dn(d) + , attributes(attr) + { + type = QUERY_ADD; + } + + int run() CXX11_OVERRIDE; +}; + +class LDAPDel : public LDAPRequest +{ + std::string dn; + + public: + LDAPDel(LDAPService* s, LDAPInterface* i, const std::string& d) + : LDAPRequest(s, i) + , dn(d) + { + type = QUERY_DELETE; + } + + int run() CXX11_OVERRIDE; +}; + +class LDAPModify : public LDAPRequest +{ + std::string base; + LDAPMods attributes; + + public: + LDAPModify(LDAPService* s, LDAPInterface* i, const std::string& b, const LDAPMods& attr) + : LDAPRequest(s, i) + , base(b) + , attributes(attr) + { + type = QUERY_MODIFY; + } + + int run() CXX11_OVERRIDE; +}; + +class LDAPCompare : public LDAPRequest +{ + std::string dn, attr, val; + + public: + LDAPCompare(LDAPService* s, LDAPInterface* i, const std::string& d, const std::string& a, const std::string& v) + : LDAPRequest(s, i) + , dn(d) + , attr(a) + , val(v) + { + type = QUERY_COMPARE; + } + + int run() CXX11_OVERRIDE; +}; + class LDAPService : public LDAPProvider, public SocketThread { LDAP* con; @@ -38,7 +172,8 @@ class LDAPService : public LDAPProvider, public SocketThread time_t timeout; time_t last_timeout_check; - LDAPMod** BuildMods(const LDAPMods& attributes) + public: + static LDAPMod** BuildMods(const LDAPMods& attributes) { LDAPMod** mods = new LDAPMod*[attributes.size() + 1]; memset(mods, 0, sizeof(LDAPMod*) * (attributes.size() + 1)); @@ -69,7 +204,7 @@ class LDAPService : public LDAPProvider, public SocketThread return mods; } - void FreeMods(LDAPMod** mods) + static void FreeMods(LDAPMod** mods) { for (unsigned int i = 0; mods[i] != NULL; ++i) { @@ -86,6 +221,7 @@ class LDAPService : public LDAPProvider, public SocketThread delete[] mods; } + private: void Reconnect() { // Only try one connect a minute. It is an expensive blocking operation @@ -97,48 +233,17 @@ class LDAPService : public LDAPProvider, public SocketThread Connect(); } - void SaveInterface(LDAPInterface* i, LDAPQuery msgid) + void QueueRequest(LDAPRequest* r) { - if (i != NULL) - { - this->LockQueue(); - this->queries[msgid] = std::make_pair(ServerInstance->Time(), i); - this->UnlockQueueWakeup(); - } - } - - void Timeout() - { - if (last_timeout_check == ServerInstance->Time()) - return; - last_timeout_check = ServerInstance->Time(); - - for (query_queue::iterator it = this->queries.begin(); it != this->queries.end(); ) - { - LDAPQuery msgid = it->first; - time_t created = it->second.first; - LDAPInterface* i = it->second.second; - ++it; - - if (ServerInstance->Time() > created + timeout) - { - LDAPResult* ldap_result = new LDAPResult(); - ldap_result->id = msgid; - ldap_result->error = "Query timed out"; - - this->queries.erase(msgid); - this->results.push_back(std::make_pair(i, ldap_result)); - - this->NotifyParent(); - } - } + this->LockQueue(); + this->queries.push_back(r); + this->UnlockQueueWakeup(); } public: - typedef std::map<LDAPQuery, std::pair<time_t, LDAPInterface*> > query_queue; - typedef std::vector<std::pair<LDAPInterface*, LDAPResult*> > result_queue; - query_queue queries; - result_queue results; + typedef std::vector<LDAPRequest*> query_queue; + query_queue queries, results; + Mutex process_mutex; /* held when processing requests not in either queue */ LDAPService(Module* c, ConfigTag* tag) : LDAPProvider(c, "LDAP/" + tag->getString("id")) @@ -160,30 +265,29 @@ class LDAPService : public LDAPProvider, public SocketThread { this->LockQueue(); - for (query_queue::iterator i = this->queries.begin(); i != this->queries.end(); ++i) + for (unsigned int i = 0; i < this->queries.size(); ++i) { - LDAPQuery msgid = i->first; - LDAPInterface* inter = i->second.second; + LDAPRequest* req = this->queries[i]; - ldap_abandon_ext(this->con, msgid, NULL, NULL); + /* queries have no results yet */ + req->result = new LDAPResult(); + req->result->type = req->type; + req->result->error = "LDAP Interface is going away"; + req->inter->OnError(*req->result); - if (inter) - { - LDAPResult r; - r.error = "LDAP Interface is going away"; - inter->OnError(r); - } + delete req; } this->queries.clear(); - for (result_queue::iterator i = this->results.begin(); i != this->results.end(); ++i) + for (unsigned int i = 0; i < this->results.size(); ++i) { - LDAPInterface* inter = i->first; - LDAPResult* r = i->second; + LDAPRequest* req = this->results[i]; + + /* even though this may have already finished successfully we return that it didn't */ + req->result->error = "LDAP Interface is going away"; + req->inter->OnError(*req->result); - r->error = "LDAP Interface is going away"; - if (inter) - inter->OnError(*r); + delete req; } this->results.clear(); @@ -218,316 +322,192 @@ class LDAPService : public LDAPProvider, public SocketThread } } - LDAPQuery BindAsManager(LDAPInterface* i) CXX11_OVERRIDE + void BindAsManager(LDAPInterface* i) CXX11_OVERRIDE { std::string binddn = config->getString("binddn"); std::string bindauth = config->getString("bindauth"); - return this->Bind(i, binddn, bindauth); + this->Bind(i, binddn, bindauth); } - LDAPQuery Bind(LDAPInterface* i, const std::string& who, const std::string& pass) CXX11_OVERRIDE + void Bind(LDAPInterface* i, const std::string& who, const std::string& pass) CXX11_OVERRIDE { - berval cred; - cred.bv_val = strdup(pass.c_str()); - cred.bv_len = pass.length(); - - LDAPQuery msgid; - int ret = ldap_sasl_bind(con, who.c_str(), LDAP_SASL_SIMPLE, &cred, NULL, NULL, &msgid); - free(cred.bv_val); - if (ret != LDAP_SUCCESS) - { - if (ret == LDAP_SERVER_DOWN || ret == LDAP_TIMEOUT) - { - this->Reconnect(); - return this->Bind(i, who, pass); - } - else - throw LDAPException(ldap_err2string(ret)); - } - - SaveInterface(i, msgid); - return msgid; + LDAPBind* b = new LDAPBind(this, i, who, pass); + QueueRequest(b); } - LDAPQuery Search(LDAPInterface* i, const std::string& base, const std::string& filter) CXX11_OVERRIDE + void Search(LDAPInterface* i, const std::string& base, const std::string& filter) CXX11_OVERRIDE { if (i == NULL) throw LDAPException("No interface"); - LDAPQuery msgid; - int ret = ldap_search_ext(this->con, base.c_str(), searchscope, filter.c_str(), NULL, 0, NULL, NULL, NULL, 0, &msgid); - if (ret != LDAP_SUCCESS) - { - if (ret == LDAP_SERVER_DOWN || ret == LDAP_TIMEOUT) - { - this->Reconnect(); - return this->Search(i, base, filter); - } - else - throw LDAPException(ldap_err2string(ret)); - } - - SaveInterface(i, msgid); - return msgid; + LDAPSearch* s = new LDAPSearch(this, i, base, searchscope, filter); + QueueRequest(s); } - LDAPQuery Add(LDAPInterface* i, const std::string& dn, LDAPMods& attributes) CXX11_OVERRIDE + void Add(LDAPInterface* i, const std::string& dn, LDAPMods& attributes) CXX11_OVERRIDE { - LDAPMod** mods = this->BuildMods(attributes); - LDAPQuery msgid; - int ret = ldap_add_ext(this->con, dn.c_str(), mods, NULL, NULL, &msgid); - this->FreeMods(mods); - - if (ret != LDAP_SUCCESS) - { - if (ret == LDAP_SERVER_DOWN || ret == LDAP_TIMEOUT) - { - this->Reconnect(); - return this->Add(i, dn, attributes); - } - else - throw LDAPException(ldap_err2string(ret)); - } - - SaveInterface(i, msgid); - return msgid; + LDAPAdd* add = new LDAPAdd(this, i, dn, attributes); + QueueRequest(add); } - LDAPQuery Del(LDAPInterface* i, const std::string& dn) CXX11_OVERRIDE + void Del(LDAPInterface* i, const std::string& dn) CXX11_OVERRIDE { - LDAPQuery msgid; - int ret = ldap_delete_ext(this->con, dn.c_str(), NULL, NULL, &msgid); - - if (ret != LDAP_SUCCESS) - { - if (ret == LDAP_SERVER_DOWN || ret == LDAP_TIMEOUT) - { - this->Reconnect(); - return this->Del(i, dn); - } - else - throw LDAPException(ldap_err2string(ret)); - } - - SaveInterface(i, msgid); - return msgid; + LDAPDel* del = new LDAPDel(this, i, dn); + QueueRequest(del); } - LDAPQuery Modify(LDAPInterface* i, const std::string& base, LDAPMods& attributes) CXX11_OVERRIDE + void Modify(LDAPInterface* i, const std::string& base, LDAPMods& attributes) CXX11_OVERRIDE { - LDAPMod** mods = this->BuildMods(attributes); - LDAPQuery msgid; - int ret = ldap_modify_ext(this->con, base.c_str(), mods, NULL, NULL, &msgid); - this->FreeMods(mods); - - if (ret != LDAP_SUCCESS) - { - if (ret == LDAP_SERVER_DOWN || ret == LDAP_TIMEOUT) - { - this->Reconnect(); - return this->Modify(i, base, attributes); - } - else - throw LDAPException(ldap_err2string(ret)); - } + LDAPModify* mod = new LDAPModify(this, i, base, attributes); + QueueRequest(mod); + } - SaveInterface(i, msgid); - return msgid; + void Compare(LDAPInterface* i, const std::string& dn, const std::string& attr, const std::string& val) CXX11_OVERRIDE + { + LDAPCompare* comp = new LDAPCompare(this, i, dn, attr, val); + QueueRequest(comp); } - LDAPQuery Compare(LDAPInterface* i, const std::string& dn, const std::string& attr, const std::string& val) CXX11_OVERRIDE + private: + void BuildReply(int res, LDAPRequest* req) { - berval cred; - cred.bv_val = strdup(val.c_str()); - cred.bv_len = val.length(); + LDAPResult* ldap_result = req->result = new LDAPResult(); + req->result->type = req->type; - LDAPQuery msgid; - int ret = ldap_compare_ext(con, dn.c_str(), attr.c_str(), &cred, NULL, NULL, &msgid); - free(cred.bv_val); + if (res != LDAP_SUCCESS) + { + ldap_result->error = ldap_err2string(res); + return; + } - if (ret != LDAP_SUCCESS) + if (req->message == NULL) { - if (ret == LDAP_SERVER_DOWN || ret == LDAP_TIMEOUT) - { - this->Reconnect(); - return this->Compare(i, dn, attr, val); - } - else - throw LDAPException(ldap_err2string(ret)); + return; } - SaveInterface(i, msgid); - return msgid; - } + /* a search result */ - void Run() CXX11_OVERRIDE - { - while (!this->GetExitFlag()) + for (LDAPMessage* cur = ldap_first_message(this->con, req->message); cur; cur = ldap_next_message(this->con, cur)) { - this->LockQueue(); - if (this->queries.empty()) + LDAPAttributes attributes; + + char* dn = ldap_get_dn(this->con, cur); + if (dn != NULL) { - this->WaitForQueue(); - this->UnlockQueue(); - continue; + attributes["dn"].push_back(dn); + ldap_memfree(dn); + dn = NULL; } - this->Timeout(); - this->UnlockQueue(); - struct timeval tv = { 1, 0 }; - LDAPMessage* result; - int rtype = ldap_result(this->con, LDAP_RES_ANY, 1, &tv, &result); - if (rtype <= 0 || this->GetExitFlag()) - continue; + BerElement* ber = NULL; - int cur_id = ldap_msgid(result); + for (char* attr = ldap_first_attribute(this->con, cur, &ber); attr; attr = ldap_next_attribute(this->con, cur, ber)) + { + berval** vals = ldap_get_values_len(this->con, cur, attr); + int count = ldap_count_values_len(vals); - this->LockQueue(); + std::vector<std::string> attrs; + for (int j = 0; j < count; ++j) + attrs.push_back(vals[j]->bv_val); + attributes[attr] = attrs; - query_queue::iterator it = this->queries.find(cur_id); - if (it == this->queries.end()) - { - this->UnlockQueue(); - ldap_msgfree(result); - continue; + ldap_value_free_len(vals); + ldap_memfree(attr); } - LDAPInterface* i = it->second.second; - this->queries.erase(it); + if (ber != NULL) + ber_free(ber, 0); - this->UnlockQueue(); + ldap_result->messages.push_back(attributes); + } + } - LDAPResult* ldap_result = new LDAPResult(); - ldap_result->id = cur_id; + void SendRequests() + { + process_mutex.Lock(); - for (LDAPMessage* cur = ldap_first_message(this->con, result); cur; cur = ldap_next_message(this->con, cur)) - { - int cur_type = ldap_msgtype(cur); + query_queue q; + this->LockQueue(); + queries.swap(q); + this->UnlockQueue(); - LDAPAttributes attributes; + if (q.empty()) + { + process_mutex.Unlock(); + return; + } - { - char* dn = ldap_get_dn(this->con, cur); - if (dn != NULL) - { - attributes["dn"].push_back(dn); - ldap_memfree(dn); - } - } + for (unsigned int i = 0; i < q.size(); ++i) + { + LDAPRequest* req = q[i]; + int ret = req->run(); - switch (cur_type) + if (ret == LDAP_SERVER_DOWN || ret == LDAP_TIMEOUT) + { + /* try again */ + try { - case LDAP_RES_BIND: - ldap_result->type = LDAPResult::QUERY_BIND; - break; - case LDAP_RES_SEARCH_ENTRY: - ldap_result->type = LDAPResult::QUERY_SEARCH; - break; - case LDAP_RES_ADD: - ldap_result->type = LDAPResult::QUERY_ADD; - break; - case LDAP_RES_DELETE: - ldap_result->type = LDAPResult::QUERY_DELETE; - break; - case LDAP_RES_MODIFY: - ldap_result->type = LDAPResult::QUERY_MODIFY; - break; - case LDAP_RES_SEARCH_RESULT: - // If we get here and ldap_result->type is LDAPResult::QUERY_UNKNOWN - // then the result set is empty - ldap_result->type = LDAPResult::QUERY_SEARCH; - break; - case LDAP_RES_COMPARE: - ldap_result->type = LDAPResult::QUERY_COMPARE; - break; - default: - continue; + Reconnect(); } - - switch (cur_type) + catch (const LDAPException &) { - case LDAP_RES_SEARCH_ENTRY: - { - BerElement* ber = NULL; - for (char* attr = ldap_first_attribute(this->con, cur, &ber); attr; attr = ldap_next_attribute(this->con, cur, ber)) - { - berval** vals = ldap_get_values_len(this->con, cur, attr); - int count = ldap_count_values_len(vals); - - std::vector<std::string> attrs; - for (int j = 0; j < count; ++j) - attrs.push_back(vals[j]->bv_val); - attributes[attr] = attrs; - - ldap_value_free_len(vals); - ldap_memfree(attr); - } - if (ber != NULL) - ber_free(ber, 0); - - break; - } - case LDAP_RES_BIND: - case LDAP_RES_ADD: - case LDAP_RES_DELETE: - case LDAP_RES_MODIFY: - case LDAP_RES_COMPARE: - { - int errcode = -1; - int parse_result = ldap_parse_result(this->con, cur, &errcode, NULL, NULL, NULL, NULL, 0); - if (parse_result != LDAP_SUCCESS) - { - ldap_result->error = ldap_err2string(parse_result); - } - else - { - if (cur_type == LDAP_RES_COMPARE) - { - if (errcode != LDAP_COMPARE_TRUE) - ldap_result->error = ldap_err2string(errcode); - } - else if (errcode != LDAP_SUCCESS) - ldap_result->error = ldap_err2string(errcode); - } - break; - } - default: - continue; } - ldap_result->messages.push_back(attributes); + ret = req->run(); } - ldap_msgfree(result); + BuildReply(ret, req); this->LockQueue(); - this->results.push_back(std::make_pair(i, ldap_result)); - this->UnlockQueueWakeup(); + this->results.push_back(req); + this->UnlockQueue(); + } + + this->NotifyParent(); + + process_mutex.Unlock(); + } - this->NotifyParent(); + public: + void Run() CXX11_OVERRIDE + { + while (!this->GetExitFlag()) + { + this->LockQueue(); + if (this->queries.empty()) + this->WaitForQueue(); + this->UnlockQueue(); + + SendRequests(); } } void OnNotify() CXX11_OVERRIDE { - LDAPService::result_queue r; + query_queue r; this->LockQueue(); this->results.swap(r); this->UnlockQueue(); - for (LDAPService::result_queue::iterator i = r.begin(); i != r.end(); ++i) + for (unsigned int i = 0; i < r.size(); ++i) { - LDAPInterface* li = i->first; - LDAPResult* res = i->second; + LDAPRequest* req = r[i]; + LDAPInterface* li = req->inter; + LDAPResult* res = req->result; if (!res->error.empty()) li->OnError(*res); else li->OnResult(*res); - delete res; + delete req; } } + + LDAP* GetConnection() + { + return con; + } }; class ModuleLDAP : public Module @@ -583,28 +563,36 @@ class ModuleLDAP : public Module for (ServiceMap::iterator it = this->LDAPServices.begin(); it != this->LDAPServices.end(); ++it) { LDAPService* s = it->second; + + s->process_mutex.Lock(); s->LockQueue(); - for (LDAPService::query_queue::iterator it2 = s->queries.begin(); it2 != s->queries.end();) + + for (unsigned int i = s->queries.size(); i > 0; --i) { - int msgid = it2->first; - LDAPInterface* i = it2->second.second; - ++it2; + LDAPRequest* req = s->queries[i - 1]; + LDAPInterface* li = req->inter; - if (i->creator == m) - s->queries.erase(msgid); + if (li->creator == m) + { + s->queries.erase(s->queries.begin() + i - 1); + delete req; + } } + for (unsigned int i = s->results.size(); i > 0; --i) { - LDAPInterface* li = s->results[i - 1].first; - LDAPResult* r = s->results[i - 1].second; + LDAPRequest* req = s->results[i - 1]; + LDAPInterface* li = req->inter; if (li->creator == m) { s->results.erase(s->results.begin() + i - 1); - delete r; + delete req; } } + s->UnlockQueue(); + s->process_mutex.Unlock(); } } @@ -625,4 +613,57 @@ class ModuleLDAP : public Module } }; +int LDAPBind::run() +{ + berval cred; + cred.bv_val = strdup(pass.c_str()); + cred.bv_len = pass.length(); + + int i = ldap_sasl_bind_s(service->GetConnection(), who.c_str(), LDAP_SASL_SIMPLE, &cred, NULL, NULL, NULL); + + free(cred.bv_val); + + return i; +} + +int LDAPSearch::run() +{ + return ldap_search_ext_s(service->GetConnection(), base.c_str(), searchscope, filter.c_str(), NULL, 0, NULL, NULL, &tv, 0, &message); +} + +int LDAPAdd::run() +{ + LDAPMod** mods = LDAPService::BuildMods(attributes); + int i = ldap_add_ext_s(service->GetConnection(), dn.c_str(), mods, NULL, NULL); + LDAPService::FreeMods(mods); + return i; +} + +int LDAPDel::run() +{ + return ldap_delete_ext_s(service->GetConnection(), dn.c_str(), NULL, NULL); +} + +int LDAPModify::run() +{ + LDAPMod** mods = LDAPService::BuildMods(attributes); + int i = ldap_modify_ext_s(service->GetConnection(), base.c_str(), mods, NULL, NULL); + LDAPService::FreeMods(mods); + return i; +} + +int LDAPCompare::run() +{ + berval cred; + cred.bv_val = strdup(val.c_str()); + cred.bv_len = val.length(); + + int ret = ldap_compare_ext_s(service->GetConnection(), dn.c_str(), attr.c_str(), &cred, NULL, NULL); + + free(cred.bv_val); + + return ret; + +} + MODULE_INIT(ModuleLDAP) |