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