(file) Return to Socket.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/Socket.cpp between version 1.9.4.7 and 1.21

version 1.9.4.7, 2003/08/13 19:39:50 version 1.21, 2005/10/05 20:28:32
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2005////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,  // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
 // The Open Group, Tivoli Systems  // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
   // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation, The Open Group.
   // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; VERITAS Software Corporation; The Open Group.
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 23 
Line 29 
 // //
 // Author: Mike Brasher (mbrasher@bmc.com) // Author: Mike Brasher (mbrasher@bmc.com)
 // //
 // Modified By:  // Modified By: Josephine Eskaline Joyce, IBM (jojustin@in.ibm.com) for Bug#2513
   //              David Dillard, Symantec Corp.,  (david_dillard@symantec.com)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 57 
Line 64 
  
 static Uint32 _socketInterfaceRefCount = 0; static Uint32 _socketInterfaceRefCount = 0;
  
 Sint32 Socket::read(Sint32 socket, void* ptr, Uint32 size)  Sint32 Socket::read(PEGASUS_SOCKET socket, void* ptr, Uint32 size)
 { {
 #ifdef PEGASUS_OS_TYPE_WINDOWS #ifdef PEGASUS_OS_TYPE_WINDOWS
     return ::recv(socket, (char*)ptr, size, 0);     return ::recv(socket, (char*)ptr, size, 0);
 #elif defined(PEGASUS_OS_ZOS)  
     int i=::read(socket, (char*)ptr, size);  
     __atoe_l((char *)ptr,size);  
     return i;  
 #else #else
   #if defined (__GNUC__) && !defined(PEGASUS_OS_SOLARIS) && !defined(PEGASUS_OS_DARWIN) && !defined(PEGASUS_OS_LSB)
 #if defined (__GNUC__)  
     int ccode = TEMP_FAILURE_RETRY(::read(socket, (char*)ptr, size));     int ccode = TEMP_FAILURE_RETRY(::read(socket, (char*)ptr, size));
     return ccode;     return ccode;
 #else #else
Line 76 
Line 78 
 #endif #endif
 } }
  
 Sint32 Socket::write(Sint32 socket, const void* ptr, Uint32 size)  Sint32 Socket::write(PEGASUS_SOCKET socket, const void* ptr, Uint32 size)
 { {
 #ifdef PEGASUS_OS_TYPE_WINDOWS #ifdef PEGASUS_OS_TYPE_WINDOWS
     return ::send(socket, (const char*)ptr, size, 0);     return ::send(socket, (const char*)ptr, size, 0);
 #elif defined(PEGASUS_OS_ZOS)  
     char * ptr2 = (char *)malloc(size);  
     int i;  
     memcpy(ptr2,ptr,size);  
     __etoa_l(ptr2,size);  
     i = ::write(socket, ptr2, size);  
     free(ptr2);  
     return i;  
 #else #else
 #if (__GNUC__)  #if (__GNUC__) && !defined(PEGASUS_OS_SOLARIS) && !defined(PEGASUS_OS_DARWIN) && !defined(PEGASUS_OS_LSB)
     int ccode = TEMP_FAILURE_RETRY(::write(socket, (char*)ptr, size));     int ccode = TEMP_FAILURE_RETRY(::write(socket, (char*)ptr, size));
     return ccode;     return ccode;
 #else #else
Line 98 
Line 92 
 #endif #endif
 } }
  
 void Socket::close(Sint32 socket)  void Socket::close(PEGASUS_SOCKET socket)
 { {
 #ifdef PEGASUS_OS_TYPE_WINDOWS    if(-1 != socket)
     closesocket(socket);  
 #else  
 #if (__GNUC__)  
     TEMP_FAILURE_RETRY(::close(socket));  
 #else  
     ::close(socket);  
 #endif  
 #endif  
 }  
   
 int Socket::close2(Sint32 socket)  
 { {
 #ifdef PEGASUS_OS_TYPE_WINDOWS #ifdef PEGASUS_OS_TYPE_WINDOWS
     return closesocket(socket);      if(!closesocket(socket)) socket=-1;
 #else #else
 #if (__GNUC__)      #if (__GNUC__) && !defined(PEGASUS_OS_SOLARIS) && !defined(PEGASUS_OS_DARWIN) && !defined(PEGASUS_OS_LSB)
     int ccode = TEMP_FAILURE_RETRY(::close(socket));         if(!TEMP_FAILURE_RETRY(::close(socket))) socket = -1;
     return ccode;  
 #else #else
     return ::close(socket);         if(!::close(socket)) socket = -1;
 #endif #endif
 #endif #endif
 } }
   }
  
   void Socket::enableBlocking(PEGASUS_SOCKET socket)
 void Socket::enableBlocking(Sint32 socket)  
 { {
 #ifdef PEGASUS_OS_TYPE_WINDOWS #ifdef PEGASUS_OS_TYPE_WINDOWS
     unsigned long flag = 0;     unsigned long flag = 0;
Line 138 
Line 120 
 #endif #endif
 } }
  
 int Socket::enableBlocking2(Sint32 socket)  void Socket::disableBlocking(PEGASUS_SOCKET socket)
 {  
 #ifdef PEGASUS_OS_TYPE_WINDOWS  
     unsigned long flag = 0;  
     return ioctlsocket(socket, FIONBIO, &flag);  
 #else  
     int flags = fcntl(socket, F_GETFL, 0);  
     flags &= ~O_NONBLOCK;  
     return fcntl(socket, F_SETFL, flags);  
 #endif  
 }  
   
 void Socket::disableBlocking(Sint32 socket)  
 { {
 #ifdef PEGASUS_OS_TYPE_WINDOWS #ifdef PEGASUS_OS_TYPE_WINDOWS
     unsigned long flag = 1;     unsigned long flag = 1;
Line 162 
Line 132 
 #endif #endif
 } }
  
 int Socket::disableBlocking2(Sint32 socket)  
 {  
 #ifdef PEGASUS_OS_TYPE_WINDOWS  
     unsigned long flag = 1;  
     return ioctlsocket(socket, FIONBIO, &flag);  
 #else  
     int flags = fcntl(socket, F_GETFL, 0);  
     flags |= O_NONBLOCK;  
     return fcntl(socket, F_SETFL, flags);  
 #endif  
 }  
   
 void Socket::initializeInterface() void Socket::initializeInterface()
 { {
 #ifdef PEGASUS_OS_TYPE_WINDOWS #ifdef PEGASUS_OS_TYPE_WINDOWS
Line 200 
Line 158 
 } }
  
  
 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, size_t *length_ptr) = 0;  
       virtual int bind (struct sockaddr *addr, size_t length) = 0;  
   
       // change size_t to size_t for ZOS and windows  
       virtual abstract_socket* accept(struct sockaddr *addr, size_t *length_ptr) = 0;  
       virtual int connect (struct sockaddr *addr, size_t length) = 0;  
       virtual int shutdown(int how) = 0;  
       virtual int listen(int q) = 0;  
       virtual int getpeername (struct sockaddr *addr, size_t *length_ptr) = 0;  
       virtual int send (void *buffer, size_t size, int flags) = 0;  
       virtual int recv (void *buffer, size_t size, int flags) = 0;  
       virtual int sendto(void *buffer, size_t size, int flags, struct sockaddr *addr, size_t length) = 0;  
       virtual int recvfrom(void *buffer, size_t size, int flags, struct sockaddr *addr, size_t *length_ptr) = 0;  
       virtual int setsockopt (int level, int optname, void *optval, size_t optlen) = 0;  
       virtual int getsockopt (int level, int optname, void *optval, size_t *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 ;}  
   
       Sint32 read(void* ptr, Uint32 size) { return -1 ;}  
       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, size_t *length_ptr){ return -1 ;}  
        int bind (struct sockaddr *addr, size_t length) { return -1;}  
   
       // change size_t to size_t for ZOS and windows  
        abstract_socket* accept(struct sockaddr *addr, size_t *length_ptr) { return 0;}  
        int connect (struct sockaddr *addr, size_t length) { return -1;}  
        int shutdown(int how) { return -1;}  
        int listen(int queue_len ) { return -1;}  
       int getpeername (struct sockaddr *addr, size_t *length_ptr) { return -1;}  
        int send (void *buffer, size_t size, int flags) { return -1;}  
        int recv (void *buffer, size_t size, int flags) { return -1;}  
        int sendto(void *buffer, size_t size, int flags, struct sockaddr *addr, size_t length) { return -1;}  
        int recvfrom(void *buffer, size_t size, int flags, struct sockaddr *addr, size_t *length_ptr) { return -1;}  
       int setsockopt (int level, int optname, void *optval, size_t optlen) { return -1;}  
       int getsockopt (int level, int optname, void *optval, size_t *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 and file_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);  
   
       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, size_t *length_ptr);  
       virtual int bind (struct sockaddr *addr, size_t length);  
   
       // change size_t to size_t for ZOS and windows  
       virtual abstract_socket* accept(struct sockaddr *addr, size_t *length_ptr);  
       virtual int connect (struct sockaddr *addr, size_t length);  
       virtual int shutdown(int how);  
       virtual int listen(int queue_len );  
       int getpeername (struct sockaddr *addr, size_t *length_ptr);  
       virtual int send (void *buffer, size_t size, int flags);  
       virtual int recv (void *buffer, size_t size, int flags);  
       virtual int sendto(void *buffer, size_t size, int flags, struct sockaddr *addr, size_t length);  
       virtual int recvfrom(void *buffer, size_t size, int flags, struct sockaddr *addr, size_t *length_ptr);  
       int setsockopt (int level, int optname, void *optval, size_t optlen);  
       int getsockopt (int level, int optname, void *optval, size_t *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)  
             {  
             }  
             ~_library_init(void)  
             {  
             }  
       };  
   
       static struct _library_init _lib_init;  
   
       int _socket;  
       void *_ssl_context;  
       int _errno;  
       char _strerr[256];  
 };  
   
   
   
   
 #if defined(__GNUC__) && GCC_VERSION >= 30200  
 // TEMP_FAILURE_RETRY (expression)  
 #else  
   
 #endif  
   
   
 /**  
  * default constructor for an (uninitialized) bsd socket  
  */  
 bsd_socket_rep::bsd_socket_rep(void)  
    :_errno(0)  
 {  
 }  
   
 bsd_socket_rep::bsd_socket_rep(int sock)  
    : _socket(sock)  
 {  
 }  
   
   
 /**  
  * default destructor for bsd_socket_rep  
  *  
  */  
 bsd_socket_rep::~bsd_socket_rep(void)  
 {  
   
 }  
   
 int bsd_socket_rep::shutdown(int how)  
 {  
    int ccode = ::shutdown(_socket, how);  
    if(ccode == -1)  
       _errno = errno;  
    return ccode;  
 }  
   
 bsd_socket_rep::operator Sint32() const  
 {  
    return (Sint32)_socket;  
 }  
   
 int bsd_socket_rep::socket(int sock_type, int sock_style, int sock_protocol, void *ssl_context)  
 {  
    _socket = ::socket(sock_type, sock_style, sock_protocol);  
    if(-1 == _socket )  
    {  
       _errno = errno;  
    }  
    return _socket;  
 }  
   
   
 Sint32 bsd_socket_rep::read(void* ptr, Uint32 size)  
 {  
    int ccode = Socket::read(_socket, ptr, size);  
    if(ccode == -1)  
       _errno = errno;  
    return ccode;  
 }  
   
   
 Sint32 bsd_socket_rep::write(const void* ptr, Uint32 size)  
 {  
    int ccode = Socket::write(_socket, ptr, size);  
    if(ccode == -1)  
       errno = _errno;  
    return ccode;  
 }  
   
   
 int bsd_socket_rep::close(void)  
 {  
    int ccode;  
   
    shutdown(2);  
    ccode = Socket::close2(_socket);  
    if(ccode == -1)  
       _errno = errno;  
    return ccode;  
 }  
   
   
   
 int  bsd_socket_rep::enableBlocking(void)  
 {  
    return Socket::enableBlocking2(_socket);  
 }  
   
 int bsd_socket_rep::disableBlocking(void)  
 {  
    return Socket::disableBlocking2(_socket);  
 }  
   
 int bsd_socket_rep::getsockname (struct sockaddr *addr, size_t *length_ptr)  
 {  
    int ccode = ::getsockname(_socket, addr, length_ptr);  
    if(ccode == -1)  
       _errno = errno;  
    return ccode;  
 }  
   
 /**  
  * default implementation allows reuseof address  
  * sockaddr structure needs to be fully initialized or call will fail  
  */  
 int bsd_socket_rep::bind (struct sockaddr *addr, size_t length)  
 {  
    int opt = 1;  
    int ccode = setsockopt(SOL_SOCKET, SO_REUSEADDR, (char *)&opt, sizeof(opt));  
    if(ccode < 0)  
    {  
       _errno = errno;  
       return ccode;  
    }  
    return ::bind(_socket, addr, length);  
 }  
   
 abstract_socket* bsd_socket_rep::accept(struct sockaddr *addr, size_t *length_ptr)  
 {  
    int new_sock = ::accept(_socket, addr, length_ptr);  
    if(new_sock == -1)  
    {  
       _errno = errno;  
       return 0;  
    }  
   
    bsd_socket_rep *rep = new bsd_socket_rep(new_sock);  
    // set the close-on-exec flag  
    rep->set_close_on_exec();  
    return rep;  
 }  
   
 int bsd_socket_rep::connect (struct sockaddr *addr, size_t length)  
 {  
    int ccode = ::connect(_socket, addr, length);  
    if(ccode == -1)  
       _errno = errno;  
    return ccode;  
 }  
   
   
 int bsd_socket_rep::listen(int queue_len)  
 {  
    int ccode = ::listen(_socket, queue_len);  
    if(ccode == -1)  
       _errno = errno;  
    return ccode;  
 }  
   
   
 int bsd_socket_rep::getpeername (struct sockaddr *addr, size_t *length_ptr)  
 {  
    int ccode = ::getpeername(_socket, addr, length_ptr);  
    if(ccode == -1 )  
       _errno = errno;  
    return ccode;  
 }  
   
 int bsd_socket_rep::send (void *buffer, size_t size, int flags)  
 {  
    int ccode = ::send(_socket, buffer, size, flags);  
    if(ccode == -1)  
       _errno = errno;  
    return ccode;  
 }  
   
   
 int bsd_socket_rep::recv (void *buffer, size_t size, int flags)  
 {  
    int ccode = ::recv(_socket, buffer, size, flags);  
    if(ccode == -1)  
       _errno = errno;  
    return ccode;  
 }  
   
 int bsd_socket_rep::sendto(void *buffer, size_t size, int flags, struct sockaddr *addr, size_t length)  
 {  
    int ccode = ::sendto(_socket, buffer, size, flags, addr, length);  
       if(ccode == -1)  
       _errno = errno;  
    return ccode;  
 }  
   
   
 int bsd_socket_rep::recvfrom(void *buffer,  
                              size_t size,  
                              int flags,  
                              struct sockaddr *addr,  
                              size_t *length_ptr)  
 {  
    int ccode = ::recvfrom(_socket, buffer, size, flags, addr, length_ptr);  
    if(ccode == -1)  
       _errno = errno;  
    return ccode;  
 }  
   
 int bsd_socket_rep::setsockopt (int level, int optname, void *optval, size_t optlen)  
 {  
    int ccode = ::setsockopt(_socket, level, optname, optval, optlen);  
    if(ccode == -1)  
       _errno = errno;  
    return ccode;  
 }  
   
   
 int bsd_socket_rep::getsockopt (int level, int optname, void *optval, size_t *optlen_ptr)  
 {  
    int ccode = ::getsockopt(_socket, level, optname, optval, optlen_ptr);  
    if(ccode == -1)  
       _errno = errno;  
    return ccode;  
 }  
   
   
 Boolean bsd_socket_rep::incompleteReadOccurred(Sint32 retCode)  
 {  
    return false;  
 }  
   
 Boolean bsd_socket_rep::is_secure(void)  
 {  
    return false;  
 }  
   
 void bsd_socket_rep::set_close_on_exec(void)  
 {  
    int sock_flags;  
    if( (sock_flags = fcntl(_socket, F_GETFD, 0)) >= 0)  
    {  
       sock_flags |= FD_CLOEXEC;  
       fcntl(_socket, F_SETFD, sock_flags);  
    }  
 }  
   
   
 const char* bsd_socket_rep::get_err_string(void)  
 {  
    strncpy(_strerr, strerror(_errno), 255);  
    return _strerr;  
 }  
   
   
 bsd_socket_factory::bsd_socket_factory(void)  
 {  
 }  
   
 bsd_socket_factory::~bsd_socket_factory(void)  
 {  
 }  
   
 abstract_socket* bsd_socket_factory::make_socket(void)  
 {  
    return new bsd_socket_rep();  
 }  
   
   
   
   
 /**  
  * pegasus_socket - the high level socket object in pegasus  
  *  
  **/  
   
 pegasus_socket::pegasus_socket(void)  
 {  
    _rep = new empty_socket_rep();  
 }  
   
   
 pegasus_socket::pegasus_socket(socket_factory *factory)  
 {  
    _rep = factory->make_socket();  
 }  
   
 pegasus_socket::pegasus_socket(const pegasus_socket& s)  
 {  
    if(this != &s)  
    {  
       Inc(this->_rep = s._rep);  
    }  
 };  
   
 pegasus_socket::pegasus_socket(abstract_socket* s)  
 {  
    Inc(this->_rep = s);  
 }  
   
   
 pegasus_socket::~pegasus_socket(void)  
 {  
    Dec(_rep);  
 }  
   
 pegasus_socket& pegasus_socket::operator =(const pegasus_socket& s)  
 {  
    if(this != &s)  
    {  
       Dec(_rep);  
       Inc(this->_rep = s._rep);  
    }  
    return *this;  
 }  
   
 pegasus_socket::operator Sint32() const  
 {  
    return _rep->operator Sint32();  
 }  
   
 int pegasus_socket::socket(int type, int style, int protocol, void *ssl_context)  
 {  
    return _rep->socket(type, style, protocol, ssl_context);  
 }  
   
   
 Sint32 pegasus_socket::read(void* ptr, Uint32 size)  
 {  
    return _rep->read(ptr, size);  
 }  
   
 Sint32 pegasus_socket::write(const void* ptr, Uint32 size)  
 {  
    return _rep->write(ptr, size);  
 }  
   
 int pegasus_socket::close(void)  
 {  
    return _rep->close();  
 }  
   
 int pegasus_socket::enableBlocking(void)  
 {  
    return _rep->enableBlocking();  
 }  
   
 int pegasus_socket::disableBlocking(void)  
 {  
    return _rep->disableBlocking();  
 }  
   
 int pegasus_socket::getsockname (struct sockaddr *addr, size_t *length_ptr)  
 {  
    return _rep->getsockname(addr, length_ptr);  
 }  
   
 int pegasus_socket::bind (struct sockaddr *addr, size_t length)  
 {  
    return _rep->bind(addr, length);  
 }  
   
 // change socklen_t to size_t for ZOS and windows  
 pegasus_socket pegasus_socket::accept(struct sockaddr *addr, size_t *length_ptr)  
 {  
    return pegasus_socket(_rep->accept(addr, length_ptr));  
 }  
   
 int pegasus_socket::connect (struct sockaddr *addr, size_t length)  
 {  
    return _rep->connect(addr, length);  
 }  
   
 int pegasus_socket::shutdown(int how)  
 {  
    return _rep->shutdown(how);  
 }  
   
 int pegasus_socket::listen(int q)  
 {  
    return _rep->listen(q);  
 }  
   
 int pegasus_socket::getpeername (struct sockaddr *addr, size_t *length_ptr)  
 {  
    return _rep->getpeername(addr, length_ptr);  
 }  
   
 int pegasus_socket::send(void *buffer, size_t size, int flags)  
 {  
    return _rep->send(buffer, size, flags);  
 }  
   
 int pegasus_socket::recv(void *buffer, size_t size, int flags)  
 {  
    return _rep->recv(buffer, size, flags);  
 }  
   
 int pegasus_socket::sendto(void *buffer, size_t size, int flags, struct sockaddr *addr, size_t length)  
 {  
    return _rep->sendto(buffer, size, flags, addr, length);  
 }  
   
 int pegasus_socket::recvfrom(void *buffer, size_t size, int flags, struct sockaddr *addr, size_t *length_ptr)  
 {  
    return _rep->recvfrom(buffer, size, flags, addr, length_ptr);  
 }  
   
 int pegasus_socket::setsockopt (int level, int optname, void *optval, size_t optlen)  
 {  
    return _rep->setsockopt(level, optname, optval, optlen);  
 }  
   
 int pegasus_socket::getsockopt (int level, int optname, void *optval, size_t *optlen_ptr)  
 {  
    return _rep->getsockopt(level, optname, optval, optlen_ptr);  
 }  
   
 Boolean pegasus_socket::incompleteReadOccurred(Sint32 retCode)  
 {  
    return _rep->incompleteReadOccurred(retCode);  
 }  
   
 Boolean pegasus_socket::is_secure(void)  
 {  
    return _rep->is_secure();  
 }  
   
 void pegasus_socket::set_close_on_exec(void)  
 {  
    return _rep->set_close_on_exec();  
 }  
   
   
 const char* pegasus_socket::get_err_string(void)  
 {  
    return _rep->get_err_string();  
 }  
   
   
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END
  

Legend:
Removed from v.1.9.4.7  
changed lines
  Added in v.1.21
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2