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

   1 /*
   2  * Copyright 2000, OpenLDAP Foundation, All Rights Reserved.
   3  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   4  */
   5
   6 // $Id: LDAPMessageQueue.cpp,v 1.17 2000/08/31 17:43:48 rhafer Exp $
   7
   8 #include "config.h"
   9 #include "debug.h"
  10 #include <ldap.h>
  11 #include "LDAPMessageQueue.h"
  12 #include "LDAPRequest.h"
  13 #include "LDAPAsynConnection.h"
  14 #include "LDAPMessage.h"
  15 #include "LDAPResult.h"
  16 #include "LDAPSearchReference.h"
  17 #include "LDAPSearchRequest.h"
  18 #include "LDAPUrl.h"
  19 #include "LDAPUrlList.h"
  20 #include "LDAPException.h"
  21
  22 // TODO: How to handel unsolicited notifications, like notice of
  23 //       disconnection
  24
  25 LDAPMessageQueue::LDAPMessageQueue(LDAPRequest *req){
  26     DEBUG(LDAP_DEBUG_TRACE, "LDAPMessageQueue::LDAPMessageQueue()" << endl);
  27         m_reqQueue.push(req);
  28 }
  29
  30 LDAPMessageQueue::~LDAPMessageQueue(){
  31     DEBUG(LDAP_DEBUG_TRACE, "LDAPMessageQueue::~LDAPMessageQueue()" << endl);
  32     LDAPRequest *req;
  33     while(! m_reqQueue.empty()){
  34         req=m_reqQueue.top();
  35         delete req;
  36         m_reqQueue.pop();
  37     }
  38 }
  39
  40 LDAPMsg *LDAPMessageQueue::getNext(){
  41     DEBUG(LDAP_DEBUG_TRACE,"LDAPMessageQueue::getNext()" << endl);
  42         LDAPMessage *msg;
  43     LDAPRequest *req=m_reqQueue.top();
  44     const LDAPConstraints *constr=req->getConstraints();
  45     int msg_id = req->getMsgID();
  46         int res;
  47     const  LDAPAsynConnection *con=req->getConnection();
  48         res=ldap_result(con->getSessionHandle(),msg_id,0,0,&msg);
  49         if (res <= 0){
  50         ldap_msgfree(msg);
  51                 throw  LDAPException(con);
  52         }else{
  53                 LDAPMsg *ret = LDAPMsg::create(req,msg);
  54         ldap_msgfree(msg);
  55         switch (ret->getMessageType()) {
  56             case LDAPMsg::SEARCH_REFERENCE :
  57                 if (constr->getReferralChase() ){
  58                     LDAPSearchReference *ref=(LDAPSearchReference *)ret;
  59                     LDAPRequest *refReq=chaseReferral(ref->getURLs());
  60                     if(refReq != 0){
  61                         m_reqQueue.push(refReq);
  62                         return getNext();
  63                     }
  64                 }
  65                 return ret;
  66             break;
  67             case LDAPMsg::SEARCH_ENTRY :
  68                 return ret;
  69             break;
  70             case LDAPMsg::SEARCH_DONE :
  71                 if (req->isReferral()){
  72                     LDAPResult* res_p=(LDAPResult*)ret;
  73                     switch (res_p->getResultCode()) {
  74                         case LDAPResult::REFERRAL :
  75                             DEBUG(LDAP_DEBUG_TRACE,
  76                                     "referral chasing to be implemented"
  77                                     << endl);
  78                             return ret;
  79                         break;
  80                         default:
  81                             return ret;
  82                     }
  83                     delete req;
  84                     m_reqQueue.pop();
  85                     return getNext();
  86                 }else{
  87                     return ret;
  88                 }
  89             break;
  90             //must be some kind of LDAPResultMessage
  91             default:
  92                 LDAPResult* res_p=(LDAPResult*)ret;
  93                 switch (res_p->getResultCode()) {
  94                     case LDAPResult::REFERRAL :
  95                         DEBUG(LDAP_DEBUG_TRACE,
  96                                "referral chasing to be implemented"
  97                                 << endl);
  98                         //for now just end it here
  99                         delete req;
 100                         return ret;
 101                     break;
 102                     default:
 103                         delete req;
 104                         m_reqQueue.pop();
 105                         return ret;
 106                 }
 107             break;
 108         }
 109         }
 110 }
 111
 112 // TODO Maybe moved to LDAPRequest::followReferral seems more reasonable
 113 //there
 114 LDAPRequest* LDAPMessageQueue::chaseReferral(LDAPUrlList *refs){
 115     DEBUG(LDAP_DEBUG_TRACE,"LDAPMessageQueue::chaseReferra()" << endl);
 116     LDAPRequest *req=m_reqQueue.top();
 117     LDAPRequest *refReq=req->followReferral(refs);
 118     if(refReq !=0){
 119         try {
 120             refReq->sendRequest();
 121             return refReq;
 122         }catch (LDAPException e){
 123             cout << e << endl;
 124             DEBUG(LDAP_DEBUG_TRACE,"   caught exception" << endl);
 125             return 0;
 126         }
 127     }else{
 128         return 0;
 129     }
 130 }
 131
 132 LDAPRequestStack* LDAPMessageQueue::getRequestStack(){
 133     return &m_reqQueue;
 134 }
 135