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){
 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             string srvMsg = res->getErrMsg();
 202             delete res;
 203             delete msg;
 204             throw LDAPException(resCode,srvMsg);
 205     }
 206
 207 }
 208
 209 void LDAPConnection::rename(const string& dn, const string& newRDN,
 210         bool delOldRDN, const string& newParentDN,
 211         const LDAPConstraints* cons){
 212     DEBUG(LDAP_DEBUG_TRACE,"LDAPConnection::rename" << endl);
 213     LDAPMessageQueue* msg=0;
 214     LDAPResult* res=0;
 215     try{
 216         msg = LDAPAsynConnection::rename(dn,newRDN,delOldRDN, newParentDN,
 217                 cons);
 218         res = (LDAPResult*)msg->getNext();
 219     }catch(LDAPException e){
 220         delete msg;
 221         delete res;
 222         throw;
 223     }
 224     int resCode=res->getResultCode();
 225     switch (resCode){
 226         case LDAPResult::SUCCESS :
 227             delete res;
 228             delete msg;
 229         break;
 230         case LDAPResult::REFERRAL :
 231         {
 232             LDAPUrlList urls = res->getReferralUrls();
 233             delete res;
 234             delete msg;
 235             throw LDAPReferralException(urls);
 236         }
 237         break;
 238         default :
 239             delete res;
 240             delete msg;
 241             throw LDAPException(resCode);
 242     }
 243 }
 244
 245 LDAPSearchResults* LDAPConnection::search(const string& base, int scope,
 246         const string& filter, const StringList& attrs, bool attrsOnly,
 247         const LDAPConstraints* cons){
 248     DEBUG(LDAP_DEBUG_TRACE,"LDAPConnection::search" << endl);
 249     LDAPMessageQueue* msgq=0;
 250     LDAPResult* res=0;
 251     LDAPSearchResults* results= 0;
 252
 253     try{
 254         results = new LDAPSearchResults();
 255         msgq = LDAPAsynConnection::search(base,scope, filter, attrs, attrsOnly,
 256                 cons);
 257         res = results->readMessageQueue(msgq);
 258     }catch(LDAPException e){
 259         delete results; // memcheck
 260         delete msgq;
 261         throw;
 262     }
 263     if(res != 0){
 264         int resCode=res->getResultCode();
 265         switch (resCode){
 266             case LDAPResult::SUCCESS :
 267                 delete res;
 268                 delete msgq;
 269                 return results;
 270             break;
 271             case LDAPResult::REFERRAL :
 272             {
 273                 LDAPUrlList urls = res->getReferralUrls();
 274                 delete results; // memcheck
 275                 delete res;
 276                 delete msgq;
 277                 throw LDAPReferralException(urls);
 278             }
 279             break;
 280             default :
 281                 delete results; // memcheck
 282                 delete res;
 283                 delete msgq;
 284                 throw LDAPException(resCode);
 285         }
 286     }
 287     return 0;
 288 }
 289
 290 LDAPExtResult* LDAPConnection::extOperation(const string& oid,
 291         const string& value, const LDAPConstraints *cons){
 292     DEBUG(LDAP_DEBUG_TRACE,"LDAPConnection::extOperation" << endl);
 293     LDAPMessageQueue* msg=0;
 294     LDAPExtResult* res=0;
 295     try{
 296         msg = LDAPAsynConnection::extOperation(oid,value,cons);
 297         res = (LDAPExtResult*)msg->getNext();
 298     }catch(LDAPException e){
 299         delete msg;
 300         delete res;
 301         throw;
 302     }
 303     int resCode=res->getResultCode();
 304     switch (resCode){
 305         case LDAPResult::SUCCESS :
 306             delete msg;
 307             return res;
 308         case LDAPResult::REFERRAL :
 309         {
 310             LDAPUrlList urls = res->getReferralUrls();
 311             delete res;
 312             delete msg;
 313             throw LDAPReferralException(urls);
 314         }
 315         break;
 316         default :
 317             delete res;
 318             delete msg;
 319             throw LDAPException(resCode);
 320     }
 321 }
 322
 323 const string& LDAPConnection::getHost() const{
 324     return LDAPAsynConnection::getHost();
 325 }
 326
 327 int LDAPConnection::getPort() const{
 328     return LDAPAsynConnection::getPort();
 329 }
 330
 331 void LDAPConnection::setConstraints(LDAPConstraints* cons){
 332     LDAPAsynConnection::setConstraints(cons);
 333 }
 334
 335 const LDAPConstraints* LDAPConnection::getConstraints() const{
 336     return LDAPAsynConnection::getConstraints();
 337 }