sockbase.h

Go to the documentation of this file.

/*
    socklibpp library
    Copyright (C) 2005  Daniel K. O. <danielosmari at users.sf.net>

    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 St, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef SOCK_BASE_H
#define SOCK_BASE_H



#include "sockaddr.h"

namespace socklibpp {


struct sock
{

        enum format {
                pf_unspec       = PF_UNSPEC,    
                pf_unix         = PF_UNIX,      
                pf_inet         = PF_INET,      
                pf_inet6        = PF_INET6,     
                pf_max          = PF_MAX        
        };
        
        enum type {
                sock_stream     = SOCK_STREAM,  
                sock_dgram      = SOCK_DGRAM,   
                sock_raw        = SOCK_RAW,     
                sock_rdm        = SOCK_RDM,
                sock_seqpacket  = SOCK_SEQPACKET
        };

        enum protocol {
                proto_ip        = IPPROTO_IP,   
                proto_icmp      = IPPROTO_ICMP, 
                proto_tcp       = IPPROTO_TCP,  
                proto_pup       = IPPROTO_PUP,  
                proto_udp       = IPPROTO_UDP,  
                proto_idp       = IPPROTO_IDP,  
                proto_raw       = IPPROTO_RAW,  
                proto_max       = IPPROTO_MAX   
                /* TODO (DanielKO#2#): Support IPv6 protocol options */
        };

        enum {
                invalid_socket  = INVALID_SOCKET        
        };

        enum msgflag {
                msg_none        = 0,            
                msg_oob         = MSG_OOB,      
                msg_peek        = MSG_PEEK,     
                msg_dontroute   = MSG_DONTROUTE 
        };

        enum shuthow {
                shut_recv       = 0,    
                shut_send       = 1,    
                shut_both       = 2     
        };

        enum errors {
                /* TODO (DanielKO#2#): Add more error enums here */
                socket_error    = SOCKET_ERROR, 

                eintr           = WSAEINTR,
                ebadf           = WSAEBADF,
                eacces          = WSAEACCES,
                efault          = WSAEFAULT,
                einval          = WSAEINVAL,
                emfile          = WSAEMFILE,
                ewouldblock     = WSAEWOULDBLOCK,       
                einprogress     = WSAEINPROGRESS,
                ealready        = WSAEALREADY,
                enotsock        = WSAENOTSOCK,
                edestaddrreq    = WSAEDESTADDRREQ,
                emsgsize        = WSAEMSGSIZE,
                eprototype      = WSAEPROTOTYPE,
                enoprotoopt     = WSAENOPROTOOPT,
                eprotonosupport = WSAEPROTONOSUPPORT,
                esocktnotsupport = WSAESOCKTNOSUPPORT,
                eopnotsupp      = WSAEOPNOTSUPP,
                epfnosupport    = WSAEPFNOSUPPORT,
                afnosupport     = WSAEAFNOSUPPORT,
                eaddrinuse      = WSAEADDRINUSE,
                eaddrnotavail   = WSAEADDRNOTAVAIL,
                enetdown        = WSAENETDOWN,
                enetunreach     = WSAENETUNREACH,
                enetreset       = WSAENETRESET,
                econnaborted    = WSAECONNABORTED,
                econnreset      = WSAECONNRESET,
                enobufs         = WSAENOBUFS,
                eisconn         = WSAEISCONN,
                enotconn        = WSAENOTCONN,
                eshutdown       = WSAESHUTDOWN,
                etoomanyrefs    = WSAETOOMANYREFS,
                etimedout       = WSAETIMEDOUT,
                econnrefused    = WSAECONNREFUSED,
                eloop           = WSAELOOP,
                enametoolong    = WSAENAMETOOLONG,
                ehostdown       = WSAEHOSTDOWN,
                ehostunreach    = WSAEHOSTUNREACH,
                host_not_found  = WSAHOST_NOT_FOUND,
                try_again       = WSATRY_AGAIN,
                no_recovery     = WSANO_RECOVERY,
                no_data         = WSANO_DATA
        };

        enum ioctl_cmd {
                fionbio         = FIONBIO,      
                fionread        = FIONREAD,     
                siocatmark      = SIOCATMARK    
        };

        enum mode {
                passive,        
                active          
        };
        
        enum optlevel {
                sol_socket      = SOL_SOCKET,
                ipproto_tcp     = IPPROTO_TCP
        };
        
        enum optname {
                so_acceptconn   = SO_ACCEPTCONN,        
                so_broadcast    = SO_BROADCAST,         
                so_debug        = SO_DEBUG,             
//                so_dontlinger   = SO_DONTLINGER,        ///< (bool) If true, the so_linger option is disabled..
                so_dontroute    = SO_DONTROUTE,         
                so_error        = SO_ERROR,             
                so_keepalive    = SO_KEEPALIVE,         
                so_linger       = SO_LINGER,            
                so_oobinline    = SO_OOBINLINE,         
                so_rcvbuf       = SO_RCVBUF,            
                so_reuseaddr    = SO_REUSEADDR,         
                so_sndbuf       = SO_SNDBUF,            
                so_type         = SO_TYPE,              
                tcp_nodelay     = TCP_NODELAY           
        };

        enum selectstate {
                readable = 1,   
                writable = 2,   
                exceptable = 4  
        };


        // Here are the two data members of socklibpp::sock

        socket_type fd;
        
        
        mutable int error;
        

        sock() throw() : fd(invalid_socket), error(0)  {}

        sock(socket_type fd_) throw() : fd(fd_), error(0) {}


        sock(format, type, protocol = proto_ip) throw();


        sock accept() throw();

        sock accept(addr&) throw();


        bool bind(const addr&) throw();


        bool close() throw();


        bool connect(const addr&) throw();


        bool peername(addr&) const throw();
        

        bool sockname(addr&) throw();


        /* TODO (DanielKO#2#): Support the so_linger option */
        bool getsockopt(optlevel, optname, int&) const throw();
        bool getsockopt(optlevel, optname, bool&) const throw();


        bool ioctl(ioctl_cmd, unsigned long&) throw();


        bool listen(int=3) throw();
        

        int recv(char *, int, msgflag=msg_none) throw();


        int recvfrom(addr&, char*, int, msgflag=msg_none) throw();


        // for select()
        bool can_read(long=0, long=0) const throw();

        bool wait_read(long&, long&) const throw();
        
        bool wait_read() const throw();
        
        bool can_write(int=0, int=0) throw();
        bool can_except(int=0, int=0) throw();

        unsigned select(int=0, int=0) throw();

        int send(const char*, int, msgflag=msg_none) throw();

        int sendto(const addr&, const char*, int, msgflag=msg_none) throw();

        /* TODO (DanielKO#2#): Support the so_linger option */
        bool setsockopt(optlevel, optname, int) throw();


        bool shutdown(shuthow) throw();
        
        
        bool create(format, type, protocol = proto_ip) throw();

        inline bool socket(format fmt, type tp, protocol pr = proto_ip) throw()
        {       return create(fmt, tp, pr);     }




        // ****************** Convenience functions **********************


        bool sendall(const char*, int, msgflag=msg_none) throw();


        bool recvall(char *, int, msgflag=msg_none) throw();


        bool block(bool) throw();


        bool reuseaddr() const throw();

        bool reuseaddr(bool) throw();


        int sendbuf() const throw();

        void sendbuf(int) throw();
        

        int recvbuf() const throw();

        void recvbuf(int) throw();

        /* TODO (DanielKO#2#): Add more convenience methods for {set|get}sockopt */

};



}

#endif

---