Session.hpp

Go to the documentation of this file.

// ANNA - Anna is Not Nothingness Anymore                                                         //
//                                                                                                //
// (c) Copyright 2005-2015 Eduardo Ramos Testillano & Francisco Ruiz Rayo                         //
//                                                                                                //
// See project site at http://redmine.teslayout.com/projects/anna-suite                           //
// See accompanying file LICENSE or copy at http://www.teslayout.com/projects/public/anna.LICENSE //


#ifndef anna_ldap_Session_hpp
#define anna_ldap_Session_hpp

#include <string>

#include <anna/core/util/SortedVector.hpp>

#include <anna/comm/Handler.hpp>

#include <anna/ldap/defines.hpp>
#include <anna/ldap/ClassCode.hpp>

namespace anna {

namespace xml {
class Node;
}

namespace ldap {

class Request;
class Response;
class Timer;
class Engine;
class ResultCode;

class Session : public comm::Handler {
public:
  struct State {
    enum _v {
      Closed, 
      WaitingBind, 
      Bound 
    };
  };

  struct Option {
    struct Defer {
      enum _v {
        Never, 
        Searching, 
        Finding, 
        Always
      };
    };
    struct Referral { enum _v { Off, On }; };
  };

  static const Millisecond DefaultTimeout;

  const std::string& getURL() const { return a_url; }

  const std::string& getUser() const { return a_user; }

  const std::string& getPassword() const { return a_password; }

  int getCategory() const { return a_category; }

  int getExternalID() const { return a_externalID; }

  void* getLDAP() { return a_ldap; }

  int getDangerousFileDescriptor() const noexcept(false);

  Option::Defer::_v getDefer() const { return a_defer; }

  Option::Referral::_v getReferral() const { return a_referral; }

  State::_v getState() const { return a_state; }

  const Millisecond &getTimeout(const ClassCode::_v v) const { return a_timeouts [v]; }

  Millisecond getNetworkTimeout() const {
    Millisecond result(1000 * a_networkTimeout.tv_sec);
    return Millisecond(result + a_networkTimeout.tv_usec / 1000);
  }

  bool hasNetworkTimeout() const { return a_networkTimeout.tv_sec != -1; }

  void bind() noexcept(false);

  bool isBound() const { return a_state == State::Bound; }

  void setOption(const Option::Defer::_v defer) { a_defer = defer; }

  void setOption(const Option::Referral::_v referral) { a_referral = referral; }

  void setNetworkTimeout(const Millisecond &timeout) { a_networkTimeout.tv_sec = timeout / 1000; a_networkTimeout.tv_usec = (timeout % 1000) * 1000; }

  void clearNetworkTimeout() { a_networkTimeout.tv_sec = -1; a_networkTimeout.tv_usec = 0; }

  void setTimeout(const ClassCode::_v v, const Millisecond &millisecond) { a_timeouts [v] = millisecond;  }

  const Response* send(const Request* request) noexcept(false);

  const Response* send(const Request& request) noexcept(false) { return send(&request); }

  void unbind() noexcept(false);

  std::string asString() const ;

  xml::Node* asXML(xml::Node* parent) const ;

protected:
  Session();

  virtual void eventServerShutdown() {;}

  virtual void eventResponse(const Response& response) noexcept(false) = 0;

  virtual void eventResponseError(const ResultCode& resultCode, const bool disconnect) {;}

  virtual void eventIntermediateResponseError(const Response& response) {;}

private:
  struct SortById {
    static IdMessage value(const Response*) ;
  };
  typedef SortedVector <Response, SortById, IdMessage> response_container;
  typedef response_container::iterator response_iterator;
  typedef response_container::const_iterator const_response_iterator;

  typedef void* HandleLDAP;
  typedef void* HandleMessage;

  int a_category;
  HandleLDAP a_ldap;
  State::_v a_state;
  std::string a_url;
  std::string a_user;
  std::string a_password;
  Option::Defer::_v a_defer;
  Option::Referral::_v a_referral;
  response_container a_responses;
  int a_externalID;
  Millisecond a_timeouts [ClassCode::Max];
  struct timeval a_networkTimeout;

  /* Dependiendo de cómo se cree la sesión este miembro puede ser una copia de a_user
   * o el identificador numérico que pasaron como parámetro al crear la sesión
   */
  std::string a_keymap;

  void apply() noexcept(false);
  void receiveBind(const IdMessage, HandleMessage) noexcept(false);
  void receiveEntry(const IdMessage, HandleMessage) noexcept(false);
  void receiveReference(const IdMessage, HandleMessage) noexcept(false);
  void receiveResult(const IdMessage, HandleMessage) noexcept(false);
  void expireResponse(Response*) ;

  void finalize() ;

  response_iterator response_begin() { return a_responses.begin(); }
  response_iterator response_end() { return a_responses.end(); }
  void response_add(Response* response) ;
  void response_erase(Response* response) ;
  Response* response_find(const IdMessage idMessage) noexcept(false);

  static Response* response(response_iterator ii) { return response_container::data(ii); }

  const_response_iterator response_begin() const { return a_responses.begin(); }
  const_response_iterator response_end() const { return a_responses.end(); }
  static const Response* response(const_response_iterator ii) { return response_container::data(ii); }

  static const char* asText(const State::_v) ;

  friend class Timer;
  friend class Engine;
};

}
}

#endif