OsSSLConnectionSocket.h

Go to the documentation of this file.

//
// Copyright (C) 2004-2006 SIPfoundry Inc.
// Licensed by SIPfoundry under the LGPL license.
//
// Copyright (C) 2004-2006 Pingtel Corp.  All rights reserved.
// Licensed to SIPfoundry under a Contributor Agreement.
//
// $$

#ifndef _OsSSLConnectionSocket_h_
#define _OsSSLConnectionSocket_h_

#ifdef HAVE_SSL

// SYSTEM INCLUDES
//#include <...>

// APPLICATION INCLUDES                      
#include <utl/UtlSList.h>
#include <utl/UtlString.h>
#include <os/OsConnectionSocket.h>

#include <openssl/crypto.h>
#include <openssl/x509.h>
#include <openssl/pem.h>
#include <openssl/ssl.h>
#include <openssl/err.h>

// DEFINES
// MACROS
// EXTERNAL FUNCTIONS                                       
// EXTERNAL VARIABLES
// CONSTANTS
// STRUCTS
// TYPEDEFS
// FORWARD DECLARATIONS

class OsSSLConnectionSocket : public OsConnectionSocket
{
/* //////////////////////////// PUBLIC //////////////////////////////////// */
public:

/* ============================ CREATORS ================================== */

   OsSSLConnectionSocket(int         remoteHostPort,
                         const char* remoteHostName,
                         long        timeoutInSecs = 0
                         );

   OsSSLConnectionSocket(int connectedSocketDescriptor, long timeoutInSecs = 0); 

   OsSSLConnectionSocket(SSL *s, int connectedSocketDescriptor);

  virtual
   ~OsSSLConnectionSocket();
     //:Destructor

/* ============================ MANIPULATORS ============================== */
 
   virtual UtlBoolean reconnect();
   //: Sets up the connection again, assuming the connection failed

   virtual int write(const char* buffer, int bufferLength);
   //:Blocking write to the socket
   // Write the characters in the given buffer to the socket.
   // This method will block until all of the bytes are written.

   virtual int write(const char* buffer, int bufferLength, long waitMilliseconds);
   //:Non-blocking or limited blocking write to socket
   // Same as blocking version except that this write will block
   // for no more than the specified length of time.

   virtual int read(char* buffer, int bufferLength);
   //:Blocking read from the socket
   // Read bytes into the buffer from the socket up to a maximum of 
   // bufferLength bytes.  This method will block until there is
   // something to read from the socket.

   virtual int read(char* buffer, int bufferLength, 
                    UtlString* ipAddress, int* port);
   //:Blocking read from the socket
   // Read bytes into the buffer from the socket up to a maximum of 
   // bufferLength bytes.  This method will block until there is
   // something to read from the socket.

   virtual int read(char* buffer, int bufferLength, long waitMilliseconds);
   //: Non-blocking or limited blocking read from socket
   // Same as blocking version except that this read will block
   // for no more than the specified length of time.

/* ============================ ACCESSORS ================================= */

   virtual void close();
   //: Closes the SSL socket

/* ============================ INQUIRY =================================== */

   virtual OsSocket::IpProtocolSocketType getIpProtocol() const;
   //: Returns the protocol type of this socket

   virtual bool isEncrypted() const;
   
   virtual bool peerIdentity( UtlSList* altNames 
                             ,UtlString* commonName 
                             ) const;
/* //////////////////////////// PROTECTED ///////////////////////////////// */
protected:

/* //////////////////////////// PRIVATE /////////////////////////////////// */
private:
   SSL*     mSSL;

   // cached copies of peer information - parsing the cert is expensive
   mutable enum 
   {
      NOT_IDENTIFIED,
      TRUSTED,
      UNTRUSTED
   }         mPeerIdentity;
   mutable UtlSList  mAltNames;
   mutable UtlString mCommonName;

   UtlBoolean mbExternalSSLSocket;
     //:Should this object clean up SSL when shutdown.
     //:It shouldn't if SSL is managed by a parent class
   void SSLInitSocket(int socket, long timeoutInSecs);

   OsSSLConnectionSocket(const OsSSLConnectionSocket& rOsSSLConnectionSocket);
     //:Disable copy constructor

   OsSSLConnectionSocket();
     //:Disable default constructor

   OsSSLConnectionSocket& operator=(const OsSSLConnectionSocket& rhs);
     //:Disable Assignment operator
};

/* ============================ INLINE METHODS ============================ */

#endif // HAVE_SSL

#endif  // _OsSSLConnectionSocket_h_