pegasus/src/Pegasus/Common/Attic/pegasus_socket.h - diff

Return to pegasus_socket.h CVS log

Up to [Pegasus] / pegasus / src / Pegasus / Common / Attic

Diff for /pegasus/src/Pegasus/Common/Attic/pegasus_socket.h between version 1.11 and 1.12

version 1.11, 2004/01/16 19:21:56

version 1.12, 2004/04/08 08:23:31

Line 25

// Author: Mike Day (mdday@us.ibm.com)

// Modified By:

// Modified By: Amit Arora (amita@in.ibm.com) for Bug#1170

//%/////////////////////////////////////////////////////////////////////////////

Line 64

Line 63

# include <Pegasus/Common/SocketzOS_inline.h>

#endif

#include <Pegasus/Common/Linkage.h>

#include <Pegasus/Common/Sharable.h>

PEGASUS_NAMESPACE_BEGIN

Line 97

*****************************************************************/

class abstract_socket;

class socket_factory;

class PEGASUS_COMMON_LINKAGE abstract_socket : public Sharable

{

public:

abstract_socket(void) { }

virtual ~abstract_socket(void){ }

virtual operator Sint32() const = 0;

virtual int socket(int sock_type, int sock_style, int sock_protocol, void *ssl_context = 0) = 0;

virtual Sint32 read(void* ptr, Uint32 size) = 0;

virtual Sint32 write(const void* ptr, Uint32 size) = 0;

virtual int close(void) = 0;

virtual int enableBlocking(void) = 0;

virtual int disableBlocking(void) = 0;

virtual int getsockname (struct sockaddr *addr, PEGASUS_SOCKLEN_SIZE *length_ptr) = 0;

virtual int bind (struct sockaddr *addr, PEGASUS_SOCKLEN_SIZE length) = 0;

virtual abstract_socket* accept(struct sockaddr *addr, PEGASUS_SOCKLEN_SIZE *length_ptr) = 0;

virtual int connect (struct sockaddr *addr, PEGASUS_SOCKLEN_SIZE length) = 0;

virtual int shutdown(int how) = 0;

virtual int listen(int q) = 0;

virtual int getpeername (struct sockaddr *addr, PEGASUS_SOCKLEN_SIZE *length_ptr) = 0;

virtual int send (void *buffer, PEGASUS_SOCKLEN_SIZE size, int flags) = 0;

virtual int recv (void *buffer, PEGASUS_SOCKLEN_SIZE size, int flags) = 0;

virtual int sendto(void *buffer, PEGASUS_SOCKLEN_SIZE size, int flags, struct sockaddr *addr, PEGASUS_SOCKLEN_SIZE length) = 0;

virtual int recvfrom(void *buffer, PEGASUS_SOCKLEN_SIZE size, int flags, struct sockaddr *addr, PEGASUS_SOCKLEN_SIZE *length_ptr) = 0;

virtual int setsockopt (int level, int optname, void *optval, PEGASUS_SOCKLEN_SIZE optlen) = 0;

virtual int getsockopt (int level, int optname, void *optval, PEGASUS_SOCKLEN_SIZE *optlen_ptr) = 0;

virtual Boolean incompleteReadOccurred(Sint32 retCode) = 0;

virtual Boolean is_secure(void) = 0;

virtual void set_close_on_exec(void) = 0;

virtual const char* get_err_string(void) = 0;

private:

abstract_socket(const abstract_socket& );

abstract_socket& operator=(const abstract_socket& );

};

/**

* null socket class -

* error handling rep for empty pegasus_sockets -

class empty_socket_rep : public abstract_socket

{

public:

empty_socket_rep(void){ }

~empty_socket_rep(void){ }

operator Sint32() const { return -1 ;}

int socket(int sock_type, int sock_style,

int sock_protocol, void *ssl_context = 0) { return -1 ;}

virtual Sint32 read(void* ptr, Uint32 size) { return -1 ;}

virtual Sint32 write(const void* ptr, Uint32 size){ return -1 ;}

int close(void){ return -1 ;}

int enableBlocking(void){ return -1 ;}

int disableBlocking(void){ return -1 ;}

int getsockname (struct sockaddr *addr, PEGASUS_SOCKLEN_SIZE *length_ptr){ return -1 ;}

int bind (struct sockaddr *addr, PEGASUS_SOCKLEN_SIZE length) { return -1;}

abstract_socket* accept(struct sockaddr *addr, PEGASUS_SOCKLEN_SIZE *length_ptr) { return 0;}

int connect (struct sockaddr *addr, PEGASUS_SOCKLEN_SIZE length) { return -1;}

int shutdown(int how) { return -1;}

int listen(int queue_len ) { return -1;}

int getpeername (struct sockaddr *addr, PEGASUS_SOCKLEN_SIZE *length_ptr) { return -1;}

int send (void *buffer, PEGASUS_SOCKLEN_SIZE size, int flags) { return -1;}

int recv (void *buffer, PEGASUS_SOCKLEN_SIZE size, int flags) { return -1;}

int sendto(void *buffer, PEGASUS_SOCKLEN_SIZE size, int flags, struct sockaddr *addr, PEGASUS_SOCKLEN_SIZE length) { return -1;}

int recvfrom(void *buffer, PEGASUS_SOCKLEN_SIZE size, int flags, struct sockaddr *addr, PEGASUS_SOCKLEN_SIZE *length_ptr) { return -1;}

int setsockopt (int level, int optname, void *optval, PEGASUS_SOCKLEN_SIZE optlen) { return -1;}

int getsockopt (int level, int optname, void *optval, PEGASUS_SOCKLEN_SIZE *optlen_ptr) { return -1;}

Boolean incompleteReadOccurred(Sint32 retCode) { return false;}

Boolean is_secure(void) { return false;}

void set_close_on_exec(void) { }

const char* get_err_string(void)

{

static const char* msg = "Unsupported.";

return msg;

}

private:

empty_socket_rep(int);

};

/**

* internet socket class

* designed to be overriden by ssl_socket_rep

class bsd_socket_rep : public abstract_socket

{

public:

/**

* map to pegasus_socket::sock_err

bsd_socket_rep(void);

virtual ~bsd_socket_rep(void);

// used to allow the accept method to work

bsd_socket_rep(int sock);

virtual operator Sint32() const;

int socket(int sock_type, int sock_style, int sock_protocol, void *ssl_context = 0);

virtual Sint32 read(void* ptr, Uint32 size);

virtual Sint32 write(const void* ptr, Uint32 size);

virtual int close(void);

int enableBlocking(void);

int disableBlocking(void);

virtual int getsockname (struct sockaddr *addr, PEGASUS_SOCKLEN_SIZE *length_ptr);

virtual int bind (struct sockaddr *addr, PEGASUS_SOCKLEN_SIZE length);

virtual abstract_socket* accept(struct sockaddr *addr, PEGASUS_SOCKLEN_SIZE *length_ptr);

virtual int connect (struct sockaddr *addr, PEGASUS_SOCKLEN_SIZE length);

virtual int shutdown(int how);

virtual int listen(int queue_len );

int getpeername (struct sockaddr *addr, PEGASUS_SOCKLEN_SIZE *length_ptr);

virtual int send (void *buffer, PEGASUS_SOCKLEN_SIZE size, int flags);

virtual int recv (void *buffer, PEGASUS_SOCKLEN_SIZE size, int flags);

virtual int sendto(void *buffer, PEGASUS_SOCKLEN_SIZE size, int flags, struct sockaddr *addr, PEGASUS_SOCKLEN_SIZE length);

virtual int recvfrom(void *buffer, PEGASUS_SOCKLEN_SIZE size, int flags, struct sockaddr *addr, PEGASUS_SOCKLEN_SIZE *length_ptr);

int setsockopt (int level, int optname, void *optval, PEGASUS_SOCKLEN_SIZE optlen);

int getsockopt (int level, int optname, void *optval, PEGASUS_SOCKLEN_SIZE *optlen_ptr);

virtual Boolean incompleteReadOccurred(Sint32 retCode);

virtual Boolean is_secure(void);

void set_close_on_exec(void);

virtual const char* get_err_string(void);

private:

bsd_socket_rep& operator=(const bsd_socket_rep& );

// use to perform one-time initializion and destruction

struct _library_init

{

_library_init(void)

{

#ifdef PEGASUS_OS_TYPE_WINDOWS

Socket::initializeInterface();

#endif

}

~_library_init(void)

{

#ifdef PEGASUS_OS_TYPE_WINDOWS

Socket::uninitializeInterface();

#endif

}

};

protected:

static struct _library_init _lib_init;

int _socket;

//void *_ssl_context;

int _errno;

char _strerr[256];

};

class PEGASUS_COMMON_LINKAGE pegasus_socket

{

Legend:

Removed from v.1.11
changed lines
	Added in v.1.12

No CVS admin address has been configured