nss/utility.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2001 by Rick L. Vinyard, Jr.                            *
 *   rvinyard@cs.nmsu.edu                                                  *
 *                                                                         *
 *   This file is part of the conexus library.                             *
 *                                                                         *
 *   The conexus library is free software; you can redistribute it and/or  *
 *   modify it under the terms of the GNU General Public License           *
 *   version 3 as published by the Free Software Foundation.               *
 *                                                                         *
 *   The conexus library 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 software. If not see <http://www.gnu.org/licenses/>.  *
 ***************************************************************************/
#ifndef CONEXUSNSSUTILITY_H
#define CONEXUSNSSUTILITY_H

#include <string>

#include <nspr.h>
#include <pk11func.h>
#include <ssl.h>
#include <nss.h>

#include <sigc++/sigc++.h>

#include <conexus-nss/enums.h>

namespace Conexus
{

  namespace NSS
  {

    bool init ( bool use_dispatcher_default = false,
                    const std::string& nss_config_dir = std::string(),
                    EXPORT_POLICY policy = EXPORT_NONE,
                    bool read_write = false );

    bool initialized();

    bool set_ssl_default_option ( uint32_t option, bool on=true );

    bool is_ssl_default_option_set( uint32_t option );

    bool enable_default_cipher( uint32_t cipher, bool enabled=true );

    bool is_default_cipher_enabled( uint32_t cipher );

    void clear_session_cache( );

    bool configure_server_session_cache ( int max_cache_entries = 0,
                                          uint32_t timeout = 0,
                                          uint32_t ssl3_timeout = 0,
                                          const char* cache_directory = NULL,
                                          bool multi_processor = false );

    bool inherit_server_session_cache( const char* env_string = NULL );

    bool set_export_policy( EXPORT_POLICY export_policy );

    bool set_cipher_policy( uint32_t cipher, POLICY policy );

    POLICY get_cipher_policy( uint32_t cipher );

    long int send_client_hello_cache_hits();

    long int send_client_hello_cache_misses();

    long int send_client_hello_cache_not_ok();

    long int handle_server_hello_cache_hits();

    long int handle_server_hello_cache_misses();

    long int handle_server_hello_cache_not_ok();

    long int handle_client_hello_cache_hits();

    long int handle_client_hello_cache_misses();

    long int handle_client_hello_cache_not_ok();

    void finalize( );

    struct password_accumulator {
      typedef std::string result_type;
      template<typename T_iterator>
          result_type operator()(T_iterator first, T_iterator last) const
      {
        result_type result;
        for (; first != last; ++first)
        {
          result = *first;
          if ( result.size() != 0 ) return result;
        }
        return NULL;
      }
    };

    extern sigc::signal<std::string,PK11SlotInfo*,PRBool,void*>::accumulated<password_accumulator> signal_pk11_password_request;

    void disable_all_ssl_ciphers();


  }

}

bool operator<( const SECItem& a, const SECItem& b );
bool operator<=( const SECItem& a, const SECItem& b );
bool operator==( const SECItem& a, const SECItem& b );
bool operator!=( const SECItem& a, const SECItem& b );
bool operator>=( const SECItem& a, const SECItem& b );
bool operator>( const SECItem& a, const SECItem& b );

#endif