---

more/net/ldap.h

Go to the documentation of this file.

//  Copyright (C) 2002  Petter Urkedal (petter.urkedal@matfys.lth.se)
//
//  This file is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This file is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//  As a special exception, you may use this file as part of a free
//  software library without restriction.  Specifically, if other files
//  instantiate templates or use macros or inline functions from this
//  file, or you compile this file and link it with other files to
//  produce an executable, this file does not by itself cause the
//  resulting executable to be covered by the GNU General Public
//  License.  This exception does not however invalidate any other
//  reasons why the executable file might be covered by the GNU General
//  Public License.
//
//  $Id: ldap.h,v 1.2 2002/06/02 21:39:53 petter_urkedal Exp $

#ifndef MORE_NET_LDAP_H
#define MORE_NET_LDAP_H

#include <more/gen/utility.h>
#include <more/bits/experimental.h> // !! and unfinished !!
#include <more/io/fwd.h>
#include <map>

namespace more {
namespace net {

  class ldap_connection;

  enum ldap_dn_syntax {
      ldap_dn_syntax_none,
      ldap_dn_syntax_rfc,
      ldap_dn_syntax_osf
  };

  struct ldap_dn
  {
  private:
      struct content : gen::handle_data
      {
          ~content()
          {
              if (m_cxt && m_cxt->unref() == 0)
                  delete m_cxt;
          }

          std::string m_rdn;
          content const* m_cxt;
      };

      explicit ldap_dn(content const* cxt)
          : m_data(cxt) {}

  public:
      ldap_dn(std::string dn,
              ldap_dn_syntax stx = ldap_dn_syntax_none)
      {
          m_data.set_data(init(0, dn, stx));
      }

      ldap_dn(ldap_dn const& cxt, std::string const& rdn,
              ldap_dn_syntax stx = ldap_dn_syntax_none)
      {
          m_data.set_data(init(cxt.m_data.data_ref(), rdn, stx));
      }

      ~ldap_dn();

      std::string const& rdn() const { return m_data.data()->m_rdn; }

      bool is_single_rdn() const { return m_data.data()->m_cxt == 0; }

      ldap_dn context() const
      {
#ifndef MORE_NDEBUG
          if (m_data.data()->m_cxt == 0)
              throw std::logic_error("more::net::ldap_dn::context: "
                                     "Toplevel DN has no context.");
#endif
          return ldap_dn(m_data.data()->m_cxt);
      }

      bool operator==(ldap_dn const& rhs) const
      {
          return m_data.data() == rhs.m_data.data();
      }

  private:
      static content*
      init(content const* cxt,
           std::string const& rdn, ldap_dn_syntax stx);

      gen::handle<content> m_data;
  };

  std::ostream& operator<<(std::ostream& os, ldap_dn const& dn);

  struct ldap_entry_ref
  {
  private:
      typedef std::multimap<std::string, std::string> multimap_type;

      struct content : gen::handle_data
      {
          ldap_connection*      m_connection;
          ldap_dn               m_current_dn;
          multimap_type         m_current_attrs;
          ldap_dn               m_update_dn;
          multimap_type         m_update_attrs;
      };

      ldap_entry_ref(content* c)
          : m_data(c) {}

  public:
      ldap_entry_ref() {}

      ldap_dn const& dn() const { return m_data.datachk()->m_current_dn; }

      bool is_changed() const
      {
          return m_data.datachk()->m_current_dn == m_data.data()->m_update_dn
              && m_data.data()->m_current_attrs
              == m_data.data()->m_update_attrs;
      }

      void commit() const;

      /** Full comparison of DN and content. */
//       bool operator==(ldap_entry_ref const& rhs) const
//       {
//        return m_dn == rhs.m_dn
//            && *static_cast<std::multimap<std::string, std::string>*>(this)
//            == rhs;
//       }

    private:
      gen::handle<content> m_data;
      friend class ldap_connection;
  };

  /** \class ldap_connection ldap.h more/net/ldap.h
   **
   ** A connection to an LDAP server.  */
  struct ldap_connection : gen::noncopyable
  {
      enum search_scope_type
      {
          search_scope_base,
          search_scope_one,
          search_scope_sub
      };

      ldap_connection();

      /** Include some common LDAP options in the \a cl command-line
       ** parser.  \c cl.parse(...) must be called before \c bind(). */
      void declare_options(io::cmdline& cl);

      void bind();

      ldap_entry_ref const& checkout(ldap_dn const& dn);

      template<typename OutputIterator>
      void search(std::string const& base, search_scope_type scope,
                  std::string const& filter, OutputIterator it_out);
      // XX skipped args char* attrs[], bool attrs_only.

    private:
      gen::degenerate_set<ldap_entry_ref> m_cache;
  };

}} // more::net

#endif

---