sprint/io/network/socket.h

Go to the documentation of this file.

/******************************************************************************
*  Multi Platform Network Library
*
*   Copyright (C) 2005-2011  Paolo Medici <www.pmx.it>
*
*  This library is free software; you can redistribute it and/or
*  modify it under the terms of the GNU Lesser General Public
*  License as published by the Free Software Foundation; either
*  version 2.1 of the License, or (at your option) any later version.
*
*  This 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
*  Lesser General Public License for more details.
*
*  You should have received a copy of the GNU Lesser General Public
*  License along with this library; if not, write to the Free Software
*  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*
*******************************************************************************/

#ifndef _SPRINT_SOCKET_H
#define _SPRINT_SOCKET_H

#include <sprint/network_headers.h>

#include <sprint/cpptraits.h>
#include <sprint/io/network/nettools.h>

namespace sprint {

namespace detail {

template<bool bManaged>
class socket: public if_copiable<!bManaged> {
protected:    
        SOCKET s;
public:

        socket(SOCKET _s = INVALID_SOCKET) : s(_s) {}

        ~socket() { 
        if(bManaged) 
             close(); 
        }

        SOCKET handle() const { return s; }

        inline void shutdown() const { ::shutdown(s, SD_BOTH); }
        
        inline void close() { if(s!=INVALID_SOCKET) ::closesocket(s); s = INVALID_SOCKET; }
        inline bool is_valid() const { return s!=INVALID_SOCKET; }

        bool getsockname(sockaddr_in *target) const
        {
        int ret;
        socklen_t len = sizeof(sockaddr_in);
        ret = ::getsockname(s, (SOCKADDR *) target, &len);
        return ret==0;
        }
        
        bool getpeername(sockaddr_in *target) const
        {
        int ret;
        socklen_t len = sizeof(sockaddr_in);
        ret = ::getpeername(s, (SOCKADDR *) target, &len);
        return ret==0;
        }
        
        inline int listen(int backlog) const
        {
                return ::listen(s, backlog);
        }

        bool set_ttl(int ttl)
        {
    if(::setsockopt(s,IPPROTO_IP,IP_MULTICAST_TTL, (LPCSTR) &ttl,sizeof(ttl))<0) 
         {
         // logPutsf(LOG_LEVEL_WARNING, "setsockopt: cannot set TTL = %u", ttl);      
     return false;
         }
    else
     return true;
    }

        bool connect(LPCSTR server_name, WORD port)
         {
         return sprint::socket_connect(s, server_name, port);
     }

        bool bind(WORD wPort)
        {
         return sprint::socket_bind(s, wPort);
     }
        


        SOCKET accept(sockaddr_in *paddr)
        {
        socklen_t len;
        len = sizeof(sockaddr_in);
        return ::accept(s, (struct sockaddr *) paddr, &len);
        }
  
    bool accept(socket<true> & target, sockaddr_in & addr)
    {
         return sprint::socket_accept(s, target.s, addr);
     }
 
        SOCKET accept(void)
        {
        sockaddr_in addr;
        return accept(&addr);   
        }
        #ifdef LINUX

        inline int ioctl(long cmd, void *argp) const
        {
                return ::ioctl(s,cmd, argp);
        }
        #else

        inline int ioctl(long cmd, u_long *argp) const
        {
                return ::ioctlsocket(s,cmd, argp);
        }
        #endif

        inline int write(const char *buf, unsigned int len) const
        {
         return (sprint::aff_write(s, buf, len)==0) ? int(len) : -1;
        }

        template<class T>
        inline int write(const T & item) const
                {
                        return write((const char *)(&item), sizeof(item) );
                }

        inline int send(const char *buf, unsigned int len) const
        {
                return ::send(s, (const char *) buf, len, 0);
        }

        template<class T>
        inline int send(const T & item) const
                {
                        return send((const char *)(&item), sizeof(item) );
                }

        inline int read(char *buf, unsigned int len) const
        {
                return ::recv(s, (char*) buf, len, 0 );
        }

#ifdef WIN32

        inline int AsynchSelect(HWND hwnd, unsigned int wMsg, long lEvent)
        {
                return ::WSAAsyncSelect(s, hwnd, wMsg, lEvent);
        }
        inline int EventSelect(WSAEVENT hEventObject,   long lNetworkEvents)
        {
        return ::WSAEventSelect(s, hEventObject, lNetworkEvents);       
    }
#endif

};

template<bool bManaged>
class udp_socket: public socket<bManaged> {
public:
        udp_socket() : socket<bManaged>(::socket(AF_INET, SOCK_DGRAM, 0)) { }
        udp_socket(SOCKET _s) : socket<bManaged>(_s) {}

        template<bool T>
        udp_socket(const udp_socket<T> & s) : socket<bManaged>(s.handle()) {}   

};

template<bool bManaged>
class multicast_socket: public udp_socket<bManaged> {
        struct ip_mreq mreq;
public:
        bool add_membership(LPCSTR mcastgroup)
        {
        return sprint::mcast_add_membership(this->s, mcastgroup, &mreq);         
        }
        bool drop_membership()
        {
        return sprint::mcast_drop_membership(this->s, &mreq);
        }
};

template<bool bManaged>
class tcp_socket: public socket<bManaged> {
public:
        tcp_socket() : socket<bManaged>( ::socket(AF_INET, SOCK_STREAM, 0) ) { }
        tcp_socket(SOCKET _s) : socket<bManaged>(_s) {}

        template<bool T>
        tcp_socket(const tcp_socket<T> & s) : socket<bManaged>(s.handle()) {}   

};

} // namespace detail

typedef detail::socket<true>  socket;

typedef detail::socket<false> socket_handle;

typedef detail::udp_socket<true>  udp_socket;

typedef detail::udp_socket<false> udp_socket_handle;

typedef detail::tcp_socket<true>  tcp_socket;

typedef detail::tcp_socket<false> tcp_socket_handle;

}; // namespace sprint

#endif