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