← Back to branch summary

~ttx/openldap/lucid-gssapi-495418

« back to all changes in this revision

Viewing changes to contrib/ldapc++/src/LDAPConnection.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Mathias Gug
  • Date: 2008-07-10 14:45:49 UTC
  • Revision ID: james.westby@ubuntu.com-20080710144549-wck73med0e72gfyo
Tags: upstream-2.4.10
Import upstream version 2.4.10

Show diffs side-by-side

added added

removed removed

Lines of Context:
contrib/ldapc++/src/LDAPConnection.cpp
 
1
// $OpenLDAP: pkg/ldap/contrib/ldapc++/src/LDAPConnection.cpp,v 1.10.4.3 2008/04/14 23:28:11 quanah Exp $
 
2
/*
 
3
 * Copyright 2000, OpenLDAP Foundation, All Rights Reserved.
 
4
 * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
 
5
 */
 
6
 
 
7
#include "debug.h"
 
8
 
 
9
#include "LDAPResult.h"
 
10
#include "LDAPException.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::saslInteractiveBind( const std::string &mech,
 
64
                        int flags,
 
65
                        SaslInteractionHandler *sih,
 
66
                        const LDAPConstraints *cons)
 
67
{
 
68
    DEBUG(LDAP_DEBUG_TRACE,"LDAPConnection::bind" << endl);
 
69
    LDAPMessageQueue* msg=0;
 
70
    LDAPResult* res=0;
 
71
    try{
 
72
        msg = LDAPAsynConnection::saslInteractiveBind(mech, flags, sih, 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
    if(resCode != LDAPResult::SUCCESS) {
 
81
        if(resCode == LDAPResult::REFERRAL){
 
82
            LDAPUrlList urls = res->getReferralUrls();
 
83
            delete res;
 
84
            delete msg;
 
85
            throw LDAPReferralException(urls);
 
86
        }else{
 
87
            string srvMsg = res->getErrMsg();
 
88
            delete res;
 
89
            delete msg;
 
90
            throw LDAPException(resCode, srvMsg);
 
91
        }
 
92
    }
 
93
    delete res;
 
94
    delete msg;
 
95
}
 
96
 
 
97
void LDAPConnection::unbind(){
 
98
    LDAPAsynConnection::unbind();
 
99
}
 
100
 
 
101
bool LDAPConnection::compare(const string& dn, const LDAPAttribute& attr,
 
102
        LDAPConstraints* cons){
 
103
    DEBUG(LDAP_DEBUG_TRACE,"LDAPConnection::compare" << endl);
 
104
    LDAPMessageQueue* msg=0;
 
105
    LDAPResult* res=0;
 
106
    try{
 
107
        msg = LDAPAsynConnection::compare(dn,attr,cons);
 
108
        res = (LDAPResult*)msg->getNext();
 
109
    }catch(LDAPException e){
 
110
        delete msg;
 
111
        delete res;
 
112
        throw;
 
113
    }
 
114
    int resCode=res->getResultCode();
 
115
    switch (resCode){
 
116
        case LDAPResult::COMPARE_TRUE :
 
117
            delete res; 
 
118
            delete msg;
 
119
            return true;
 
120
        break;
 
121
        case LDAPResult::COMPARE_FALSE :
 
122
            delete res;
 
123
            delete msg;
 
124
            return false;
 
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
void LDAPConnection::del(const string& dn, const LDAPConstraints* cons){
 
143
    DEBUG(LDAP_DEBUG_TRACE,"LDAPConnection::del" << endl);
 
144
    LDAPMessageQueue* msg=0;
 
145
    LDAPResult* res=0;
 
146
    try{
 
147
        msg = LDAPAsynConnection::del(dn,cons);
 
148
        res = (LDAPResult*)msg->getNext();
 
149
    }catch(LDAPException e){
 
150
        delete msg;
 
151
        delete res;
 
152
        throw;
 
153
    }
 
154
    int resCode=res->getResultCode();
 
155
    switch (resCode){
 
156
        case LDAPResult::SUCCESS :
 
157
            delete res; 
 
158
            delete msg;
 
159
        break;
 
160
        case LDAPResult::REFERRAL :
 
161
        {
 
162
            LDAPUrlList urls = res->getReferralUrls();
 
163
            delete res;
 
164
            delete msg;
 
165
            throw LDAPReferralException(urls);
 
166
        }
 
167
        break;
 
168
        default :
 
169
            string srvMsg = res->getErrMsg();
 
170
            delete res;
 
171
            delete msg;
 
172
            throw LDAPException(resCode, srvMsg);
 
173
    }
 
174
 
 
175
}
 
176
 
 
177
void LDAPConnection::add(const LDAPEntry* le, const LDAPConstraints* cons){
 
178
    DEBUG(LDAP_DEBUG_TRACE,"LDAPConnection::add" << endl);
 
179
    LDAPMessageQueue* msg=0;
 
180
    LDAPResult* res=0;
 
181
    try{
 
182
        msg = LDAPAsynConnection::add(le,cons);
 
183
        res = (LDAPResult*)msg->getNext();
 
184
    }catch(LDAPException e){
 
185
        delete msg;
 
186
        delete res;
 
187
        throw;
 
188
    }
 
189
    int resCode=res->getResultCode();
 
190
    switch (resCode){
 
191
        case LDAPResult::SUCCESS :
 
192
            delete res; 
 
193
            delete msg;
 
194
        break;
 
195
        case LDAPResult::REFERRAL :
 
196
        {
 
197
            LDAPUrlList urls = res->getReferralUrls();
 
198
            delete res;
 
199
            delete msg;
 
200
            throw LDAPReferralException(urls);
 
201
        }
 
202
        break;
 
203
        default :
 
204
            string srvMsg = res->getErrMsg();
 
205
            delete res;
 
206
            delete msg;
 
207
            throw LDAPException(resCode, srvMsg);
 
208
    }
 
209
}
 
210
 
 
211
void LDAPConnection::modify(const string& dn, const LDAPModList* mods,
 
212
        const LDAPConstraints* cons){
 
213
    DEBUG(LDAP_DEBUG_TRACE,"LDAPConnection::modify" << endl);
 
214
    LDAPMessageQueue* msg=0;
 
215
    LDAPResult* res=0;
 
216
    try{
 
217
        msg = LDAPAsynConnection::modify(dn,mods,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
            string srvMsg = res->getErrMsg();
 
240
            delete res;
 
241
            delete msg;
 
242
            throw LDAPException(resCode, srvMsg);
 
243
    }
 
244
    
 
245
}
 
246
 
 
247
void LDAPConnection::rename(const string& dn, const string& newRDN,
 
248
        bool delOldRDN, const string& newParentDN, 
 
249
        const LDAPConstraints* cons){
 
250
    DEBUG(LDAP_DEBUG_TRACE,"LDAPConnection::rename" << endl);
 
251
    LDAPMessageQueue* msg=0;
 
252
    LDAPResult* res=0;
 
253
    try{
 
254
        msg = LDAPAsynConnection::rename(dn,newRDN,delOldRDN, newParentDN,
 
255
                cons);
 
256
        res = (LDAPResult*)msg->getNext();
 
257
    }catch(LDAPException e){
 
258
        delete msg;
 
259
        delete res;
 
260
        throw;
 
261
    }
 
262
    int resCode=res->getResultCode();
 
263
    switch (resCode){
 
264
        case LDAPResult::SUCCESS :
 
265
            delete res; 
 
266
            delete msg;
 
267
        break;
 
268
        case LDAPResult::REFERRAL :
 
269
        {
 
270
            LDAPUrlList urls = res->getReferralUrls();
 
271
            delete res;
 
272
            delete msg;
 
273
            throw LDAPReferralException(urls);
 
274
        }
 
275
        break;
 
276
        default :
 
277
            string srvMsg = res->getErrMsg();
 
278
            delete res;
 
279
            delete msg;
 
280
            throw LDAPException(resCode, srvMsg);
 
281
    }
 
282
}
 
283
 
 
284
LDAPSearchResults* LDAPConnection::search(const string& base, int scope,
 
285
        const string& filter, const StringList& attrs, bool attrsOnly, 
 
286
        const LDAPConstraints* cons){
 
287
    DEBUG(LDAP_DEBUG_TRACE,"LDAPConnection::search" << endl);
 
288
    LDAPMessageQueue* msgq=0;
 
289
    LDAPResult* res=0;
 
290
    LDAPSearchResults* results= 0;
 
291
    
 
292
    try{
 
293
        results = new LDAPSearchResults();
 
294
        msgq = LDAPAsynConnection::search(base,scope, filter, attrs, attrsOnly,
 
295
                cons);
 
296
        res = results->readMessageQueue(msgq);
 
297
    }catch(LDAPException e){
 
298
        delete results; // memcheck
 
299
        delete msgq;
 
300
        throw;
 
301
    }
 
302
    if(res != 0){
 
303
        int resCode=res->getResultCode();
 
304
        switch (resCode){
 
305
            case LDAPResult::SUCCESS :
 
306
                delete res; 
 
307
                delete msgq;
 
308
                return results;
 
309
            break;
 
310
            case LDAPResult::REFERRAL :
 
311
            {
 
312
                LDAPUrlList urls = res->getReferralUrls();
 
313
                delete results; // memcheck
 
314
                delete res;
 
315
                delete msgq;
 
316
                throw LDAPReferralException(urls);
 
317
            }
 
318
            break;
 
319
            default :
 
320
                string srvMsg = res->getErrMsg();
 
321
                delete results; // memcheck
 
322
                delete res;
 
323
                delete msgq;
 
324
                throw LDAPException(resCode, srvMsg);
 
325
        }
 
326
    }        
 
327
    return 0;
 
328
}
 
329
 
 
330
LDAPExtResult* LDAPConnection::extOperation(const string& oid, 
 
331
        const string& value, const LDAPConstraints *cons){
 
332
    DEBUG(LDAP_DEBUG_TRACE,"LDAPConnection::extOperation" << endl);
 
333
    LDAPMessageQueue* msg=0;
 
334
    LDAPExtResult* res=0;
 
335
    try{
 
336
        msg = LDAPAsynConnection::extOperation(oid,value,cons);
 
337
        res = (LDAPExtResult*)msg->getNext();
 
338
    }catch(LDAPException e){
 
339
        delete msg;
 
340
        delete res;
 
341
        throw;
 
342
    }
 
343
    int resCode=res->getResultCode();
 
344
    switch (resCode){
 
345
        case LDAPResult::SUCCESS :
 
346
            delete msg;
 
347
            return res;
 
348
        case LDAPResult::REFERRAL :
 
349
        {
 
350
            LDAPUrlList urls = res->getReferralUrls();
 
351
            delete res;
 
352
            delete msg;
 
353
            throw LDAPReferralException(urls);
 
354
        }
 
355
        break;
 
356
        default :
 
357
            string srvMsg = res->getErrMsg();
 
358
            delete res;
 
359
            delete msg;
 
360
            throw LDAPException(resCode, srvMsg);
 
361
    }
 
362
}
 
363
 
 
364
const string& LDAPConnection::getHost() const{
 
365
    return LDAPAsynConnection::getHost();
 
366
}
 
367
 
 
368
int LDAPConnection::getPort() const{
 
369
    return LDAPAsynConnection::getPort();
 
370
}
 
371
 
 
372
void LDAPConnection::setConstraints(LDAPConstraints* cons){
 
373
    LDAPAsynConnection::setConstraints(cons);
 
374
}
 
375
 
 
376
const LDAPConstraints* LDAPConnection::getConstraints() const{
 
377
    return LDAPAsynConnection::getConstraints();
 
378
}