(const char*)&ison,
#else
                                   (void*)&ison,
#endif
                                   sizeof( int ) );
            }
#endif
            errno = EPERM;
            return -1;
        }

                Socket::SocketDesc
        Socket::getFD() const
        { return ( isOpen() ? *(m_handle.get()) : Socket::INVALIDSOCKET ); }

        bool
        Socket::isOpen() const
        { return m_handle.get() != NULL; }

        bool
        Socket::isConnected() const
        {
            return getPeer() != Addr();
        }

        Addr
        Socket::getDest() const
        { return getPeer(); }

        int
        Socket::send( const char* msg,
                      size_t len,
                      const Addr& dest,
                      int flags,
                      CheckingType check )
        {
            if( check == DONT_CHECK )
            {
                return ::sendto( getFD(), msg,
#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
                                                                (int)len,
#else
                                                                len,
#endif
                                                                flags,
                                 (struct sockaddr *)&( dest.getAddr() ),
                                 sizeof( dest.getAddr() ) );
            }
            else
            {
                for(;;)
                {
                    int sent = ::sendto( getFD(), msg,
#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
                                                                                 (int)len,
#else
                                                                                 len,
#endif
                                                                                 flags,
                                         (struct sockaddr *)&( dest.getAddr() ),
                                         sizeof( dest.getAddr() ) );
                    if( sent != -1
                        || ( errno != EINTR
#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
                                                     && errno != WSAEWOULDBLOCK
#else
                                                     && errno != EWOULDBLOCK
#endif
                                                        ) )
                        return sent;
                }
            }
        }

        int
        Socket::send( const char* msg,
                      size_t len,
                      int flags,
                      CheckingType check )
        {
            if( check == DONT_CHECK )
            {
                return ::send( getFD(), msg,
#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
                                                           (int)len,
#else
                                                           len,
#endif
                                                           flags );
            }
            else
            {
                for(;;)
                {
                    int sent = ::send( getFD(), msg,
#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
                                                           (int)len,
#else
                                                           len,
#endif
                                                           flags );
                    if( sent != -1
                        || ( errno != EINTR
#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
                                                     && errno != WSAEWOULDBLOCK
#else
                                                     && errno != EWOULDBLOCK
#endif
                                                        ) )
                        return sent;
                }
            }
        }

        int
        Socket::recv( char* msg,
                      size_t len,
                      Addr& from,
                      int flags,
                      CheckingType check )
        {
            if( check == DONT_CHECK )
            {
                Addr::AddrType addr;
                socklen_t from_len = sizeof( addr );
                int rval = ::recvfrom( getFD(), msg,
#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
                                                                           (int)len,
#else
                                                                           len,
#endif
                                                                           flags,
                                       (struct sockaddr *)&addr, &from_len );
                from = Addr( addr );
                return rval;
            }
            else
            {
                for(;;)
                {
                    Addr::AddrType addr;
                    socklen_t from_len = sizeof( addr );
                    int received = ::recvfrom( getFD(), msg,
#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
                                                                                  (int)len,
#else
                                                                                   len,
#endif
                                                                                   flags,
                                               (struct sockaddr *)&addr,
                                               &from_len );
                    from = Addr( addr );
                    if( received != -1
                        || errno != EINTR )
                        return received;
                }
            }
        }

        int
        Socket::recv( char* msg,
                      size_t len,
                      int flags,
                      CheckingType check )
        {
            if( check == DONT_CHECK )
                return ::recv( getFD(), msg,
#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
                                                      (int)len,
#else
                                                          len,
#endif
                                                          flags );
            else
            {
                for(;;)
                {
                    int received = ::recv( getFD(), msg,
#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
                                                                               (int)len,
#else
                                                                               len,
#endif
                                                                               flags );
                    if( received != -1
                        || errno != EINTR )
                        return received;
                }
            }
        }

        bool
        Socket::listen( int backlog )
        {
            return ::listen( getFD(), backlog ) == 0;
        }

        bool
        Socket::accept( Socket& sock )
        {
            SocketDesc fd = ::accept( getFD(), NULL, 0 );
            if( fd == INVALIDSOCKET )
                return false;
            sock = TCPSocket( fd );
            return true;
        }
        
        Socket* Socket::accept(Addr& addr)
        {
            socklen_t len = sizeof(struct sockaddr);
            SocketDesc fd = ::accept( getFD(), 
                                      (struct sockaddr *)&( addr.getAddr() ),
                                      &len
                                      );

            if (fd == INVALIDSOCKET )
                {
                    return 0;
                }

            return new TCPSocket(fd);
        }

        int
        Socket::recv( int timeout,
                      char* msg,
                      size_t len,
                      Addr& from,
                      int flags )
        {
#if defined (HAVE_POLL_H)
            pollfd fd = { getFD(), POLLIN | POLLPRI, 0 };
            int res = poll( &fd, 1, timeout );
            if( res == 0 )
            {
                errno = EAGAIN;
                return -1;
            }
            else if( res == 1 )
            {
                return recv( msg,
#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
                                                         (int)len,
#else
                                                         len,
#endif
                                                         from, flags );
            }
            else
            {
                return res;
            }
#else
            errno = EPERM;
            return -1;
#endif
        }

        int
        Socket::recv( int timeout,
                      char* msg,
                      size_t len,
                      int flags )
        {
#if defined (HAVE_POLL_H)
            pollfd fd = { getFD(), POLLIN | POLLPRI, 0 };
            int res = poll( &fd, 1, timeout );
            if( res == 0 )
            {
                errno = EAGAIN;
                return -1;
            }
            else if( res == 1 )
            {
                return recv( msg,
#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
                                                         (int)len,
#else
                                                         len,
#endif
                                                         flags );
            }
            else
            {
                return res;
            }
#else
            errno = EPERM;
            return -1;
#endif
        }
    }
}