git.sur5r.net Git - openldap/blob - contrib/ldapc++/src/LDAPConnection.cpp

   1 /*
   2  * Copyright 2000, OpenLDAP Foundation, All Rights Reserved.
   3  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   4  */
   5
   6 #include "debug.h"
   7
   8 #include "LDAPResult.h"
   9 #include "LDAPException.h"
  10 #include "LDAPReferralException.h"
  11 #include "LDAPUrlList.h"
  12
  13 #include "LDAPConnection.h"
  14 const int LDAPConnection::SEARCH_BASE = LDAPAsynConnection::SEARCH_BASE;
  15 const int LDAPConnection::SEARCH_ONE = LDAPAsynConnection::SEARCH_ONE;
  16 const int LDAPConnection::SEARCH_SUB = LDAPAsynConnection::SEARCH_SUB;
  17
  18 using namespace std;
  19
  20 LDAPConnection::LDAPConnection(const string& hostname, int port,
  21         LDAPConstraints* cons) :
  22         LDAPAsynConnection(hostname, port, cons){
  23 }
  24
  25 LDAPConnection::~LDAPConnection(){
  26 }
  27
  28 int LDAPConnection::start_tls(){
  29     return LDAPAsynConnection::start_tls();
  30 }
  31
  32 void LDAPConnection::bind(const string& dn, const string& passwd,
  33         LDAPConstraints* cons){
  34     DEBUG(LDAP_DEBUG_TRACE,"LDAPConnection::bind" << endl);
  35     LDAPMessageQueue* msg=0;
  36     LDAPResult* res=0;
  37     try{
  38         msg = LDAPAsynConnection::bind(dn,passwd,cons);
  39         res = (LDAPResult*)msg->getNext();
  40     }catch(LDAPException e){
  41         delete msg;
  42         delete res;
  43         throw;
  44     }
  45     int resCode=res->getResultCode();
  46     if(resCode != LDAPResult::SUCCESS) {
  47         if(resCode == LDAPResult::REFERRAL){
  48             LDAPUrlList urls = res->getReferralUrls();
  49             delete res;
  50             delete msg;
  51             throw LDAPReferralException(urls);
  52         }else{
  53             delete res;
  54             delete msg;
  55             throw LDAPException(resCode);
  56         }
  57     }
  58     delete res;
  59     delete msg;   // memcheck
  60 }
  61
  62 void LDAPConnection::unbind(){
  63     LDAPAsynConnection::unbind();
  64 }
  65
  66 bool LDAPConnection::compare(const string& dn, const LDAPAttribute& attr,
  67         LDAPConstraints* cons){
  68     DEBUG(LDAP_DEBUG_TRACE,"LDAPConnection::compare" << endl);
  69     LDAPMessageQueue* msg=0;
  70     LDAPResult* res=0;
  71     try{
  72         msg = LDAPAsynConnection::compare(dn,attr,cons);
  73         res = (LDAPResult*)msg->getNext();
  74     }catch(LDAPException e){
  75         delete msg;
  76         delete res;
  77         throw;
  78     }
  79     int resCode=res->getResultCode();
  80     switch (resCode){
  81         case LDAPResult::COMPARE_TRUE :
  82             delete res;
  83             delete msg;
  84             return true;
  85         break;
  86         case LDAPResult::COMPARE_FALSE :
  87             delete res;
  88             delete msg;
  89             return false;
  90         break;
  91         case LDAPResult::REFERRAL :
  92         {
  93             LDAPUrlList urls = res->getReferralUrls();
  94             delete res;
  95             delete msg;
  96             throw LDAPReferralException(urls);
  97         }
  98         break;
  99         default :
 100             delete res;
 101             delete msg;
 102             throw LDAPException(resCode);
 103     }
 104 }
 105
 106 void LDAPConnection::del(const string& dn, const LDAPConstraints* cons){
 107     DEBUG(LDAP_DEBUG_TRACE,"LDAPConnection::del" << endl);
 108     LDAPMessageQueue* msg=0;
 109     LDAPResult* res=0;
 110     try{
 111         msg = LDAPAsynConnection::del(dn,cons);
 112         res = (LDAPResult*)msg->getNext();
 113     }catch(LDAPException e){
 114         delete msg;
 115         delete res;
 116         throw;
 117     }
 118     int resCode=res->getResultCode();
 119     switch (resCode){
 120         case LDAPResult::SUCCESS :
 121             delete res;
 122             delete msg;
 123         break;
 124         case LDAPResult::REFERRAL :
 125         {
 126             LDAPUrlList urls = res->getReferralUrls();
 127             delete res;
 128             delete msg;
 129             throw LDAPReferralException(urls);
 130         }
 131         break;
 132         default :
 133             delete res;
 134             delete msg;
 135             throw LDAPException(resCode);
 136     }
 137
 138 }
 139
 140 void LDAPConnection::add(const LDAPEntry* le, const LDAPConstraints* cons=0){
 141     DEBUG(LDAP_DEBUG_TRACE,"LDAPConnection::add" << endl);
 142     LDAPMessageQueue* msg=0;
 143     LDAPResult* res=0;
 144     try{
 145         msg = LDAPAsynConnection::add(le,cons);
 146         res = (LDAPResult*)msg->getNext();
 147     }catch(LDAPException e){
 148         delete msg;
 149         delete res;
 150         throw;
 151     }
 152     int resCode=res->getResultCode();
 153     switch (resCode){
 154         case LDAPResult::SUCCESS :
 155             delete res;
 156             delete msg;
 157         break;
 158         case LDAPResult::REFERRAL :
 159         {
 160             LDAPUrlList urls = res->getReferralUrls();
 161             delete res;
 162             delete msg;
 163             throw LDAPReferralException(urls);
 164         }
 165         break;
 166         default :
 167             delete res;
 168             delete msg;
 169             throw LDAPException(resCode);
 170     }
 171 }
 172
 173 void LDAPConnection::modify(const string& dn, const LDAPModList* mods,
 174         const LDAPConstraints* cons){
 175     DEBUG(LDAP_DEBUG_TRACE,"LDAPConnection::modify" << endl);
 176     LDAPMessageQueue* msg=0;
 177     LDAPResult* res=0;
 178     try{
 179         msg = LDAPAsynConnection::modify(dn,mods,cons);
 180         res = (LDAPResult*)msg->getNext();
 181     }catch(LDAPException e){
 182         delete msg;
 183         delete res;
 184         throw;
 185     }
 186     int resCode=res->getResultCode();
 187     switch (resCode){
 188         case LDAPResult::SUCCESS :
 189             delete res;
 190             delete msg;
 191         break;
 192         case LDAPResult::REFERRAL :
 193         {
 194             LDAPUrlList urls = res->getReferralUrls();
 195             delete res;
 196             delete msg;
 197             throw LDAPReferralException(urls);
 198         }
 199         break;
 200         default :
 201             delete res;
 202             delete msg;
 203             throw LDAPException(resCode);
 204     }
 205
 206 }
 207
 208 void LDAPConnection::rename(const string& dn, const string& newRDN,
 209         bool delOldRDN, const string& newParentDN,
 210         const LDAPConstraints* cons=0){
 211     DEBUG(LDAP_DEBUG_TRACE,"LDAPConnection::rename" << endl);
 212     LDAPMessageQueue* msg=0;
 213     LDAPResult* res=0;
 214     try{
 215         msg = LDAPAsynConnection::rename(dn,newRDN,delOldRDN, newParentDN,
 216                 cons);
 217         res = (LDAPResult*)msg->getNext();
 218     }catch(LDAPException e){
 219         delete msg;
 220         delete res;
 221         throw;
 222     }
 223     int resCode=res->getResultCode();
 224     switch (resCode){
 225         case LDAPResult::SUCCESS :
 226             delete res;
 227             delete msg;
 228         break;
 229         case LDAPResult::REFERRAL :
 230         {
 231             LDAPUrlList urls = res->getReferralUrls();
 232             delete res;
 233             delete msg;
 234             throw LDAPReferralException(urls);
 235         }
 236         break;
 237         default :
 238             delete res;
 239             delete msg;
 240             throw LDAPException(resCode);
 241     }
 242 }
 243
 244 LDAPSearchResults* LDAPConnection::search(const string& base, int scope,
 245         const string& filter, const StringList& attrs, bool attrsOnly,
 246         const LDAPConstraints* cons){
 247     DEBUG(LDAP_DEBUG_TRACE,"LDAPConnection::search" << endl);
 248     LDAPMessageQueue* msgq=0;
 249     LDAPResult* res=0;
 250     LDAPSearchResults* results= 0;
 251
 252     try{
 253         results = new LDAPSearchResults();
 254         msgq = LDAPAsynConnection::search(base,scope, filter, attrs, attrsOnly,
 255                 cons);
 256         res = results->readMessageQueue(msgq);
 257     }catch(LDAPException e){
 258         delete results; // memcheck
 259         delete msgq;
 260         throw;
 261     }
 262     if(res != 0){
 263         int resCode=res->getResultCode();
 264         switch (resCode){
 265             case LDAPResult::SUCCESS :
 266                 delete res;
 267                 delete msgq;
 268                 return results;
 269             break;
 270             case LDAPResult::REFERRAL :
 271             {
 272                 LDAPUrlList urls = res->getReferralUrls();
 273                 delete results; // memcheck
 274                 delete res;
 275                 delete msgq;
 276                 throw LDAPReferralException(urls);
 277             }
 278             break;
 279             default :
 280                 delete results; // memcheck
 281                 delete res;
 282                 delete msgq;
 283                 throw LDAPException(resCode);
 284         }
 285     }
 286     return 0;
 287 }
 288
 289 LDAPExtResult* LDAPConnection::extOperation(const string& oid,
 290         const string& value, const LDAPConstraints *cons = 0){
 291     DEBUG(LDAP_DEBUG_TRACE,"LDAPConnection::extOperation" << endl);
 292     LDAPMessageQueue* msg=0;
 293     LDAPExtResult* res=0;
 294     try{
 295         msg = LDAPAsynConnection::extOperation(oid,value,cons);
 296         res = (LDAPExtResult*)msg->getNext();
 297     }catch(LDAPException e){
 298         delete msg;
 299         delete res;
 300         throw;
 301     }
 302     int resCode=res->getResultCode();
 303     switch (resCode){
 304         case LDAPResult::SUCCESS :
 305             delete msg;
 306             return res;
 307         case LDAPResult::REFERRAL :
 308         {
 309             LDAPUrlList urls = res->getReferralUrls();
 310             delete res;
 311             delete msg;
 312             throw LDAPReferralException(urls);
 313         }
 314         break;
 315         default :
 316             delete res;
 317             delete msg;
 318             throw LDAPException(resCode);
 319     }
 320 }
 321
 322 const string& LDAPConnection::getHost() const{
 323     return LDAPAsynConnection::getHost();
 324 }
 325
 326 int LDAPConnection::getPort() const{
 327     return LDAPAsynConnection::getPort();
 328 }
 329
 330 void LDAPConnection::setConstraints(LDAPConstraints* cons){
 331     LDAPAsynConnection::setConstraints(cons);
 332 }
 333
 334 const LDAPConstraints* LDAPConnection::getConstraints() const{
 335     return LDAPAsynConnection::getConstraints();
 336 }
 337
 338 int LDAPConnection::enableCache(long timeout, long maxmem) {
 339     return LDAPAsynConnection::enableCache(timeout, maxmem);
 340 }
 341
 342
 343 void LDAPConnection::disableCache() {
 344     LDAPAsynConnection::disableCache();
 345 }
 346
 347 bool LDAPConnection::getCacheEnabled() {
 348     return LDAPAsynConnection::getCacheEnabled();
 349 }
 350
 351 void LDAPConnection::uncache_entry(string &dn) {
 352     LDAPAsynConnection::uncache_entry(dn);
 353 }
 354
 355 void LDAPConnection::flush_cache()
 356 {
 357     LDAPAsynConnection::flush_cache();
 358 }
 359