socket.h

/* $Id */

#ifndef __FFL_IPC_SOCKET__
#define __FFL_IPC_SOCKET__

#include <iostream>
#include <string>
#include <list>

#ifdef _WIN32
#       include <winsock2.h>
#       include <WS2tcpip.h>
#else
#       include <sys/socket.h>
#       include <unistd.h>
#       include <netinet/in.h>
#       include <arpa/inet.h>
#       include <netdb.h>
#       include <sys/time.h>
#endif // _WIN32

#include <co.h>

namespace ffl
{

        namespace ipc
        {

                class socket
                {
                public:

                        class failure:public std::exception
                        {
                        private:

                                int code;                       //<! Код ошибки.

                        public:

                                failure(int _errno) throw();

                                failure() throw();

                                const char * what() const throw();

                        };

                        class connection_gracefully_closed:public std::exception
                        {
                        public:

                                const char* what() const throw(){return "Connection gracefully closed";}

                        };

                        class io_timeout:public std::exception
                        {
                        public:

                                const char* what() const throw(){return "IO operation timeout";}

                        };

                        class address;

                        class address
                        {
                                friend class socket;

                                sockaddr_storage Address;

                                socklen_t Length;

                                address(struct sockaddr* _a, socklen_t _l) throw();

                        public:

                                enum family
                                {
                                        UNSPEC = AF_UNSPEC,             
                                        INET4 = AF_INET,                
                                        INET6 = AF_INET6                
                                };

                                address() throw();

                                address(const address& _a) throw():Address(_a.Address), Length(_a.Length){}

                                enum hint
                                {
                                        LOCAL,          
                                        REMOTE,         
                                };

                                address(const socket& _s, hint _h = LOCAL) throw(...);

                                struct info
                                {
                                        enum hint
                                        {
                                                NOFQDN          = NI_NOFQDN,            
                                                NUMERICHOST = NI_NUMERICHOST,   
                                                NAMEREQD        = NI_NAMEREQD,          
                                                NUMERICSERV     = NI_NUMERICSERV,       
                                                DGRAM           = NI_DGRAM                      
                                        };

                                        typedef int hints;

                                        family Family;                  
                                        std::string Host;               
                                        std::string Service;    

                                        info(const address& _a, hints _h = 0) throw(...);

                                };

                        };

                        enum type
                        {
                                ANYTYPE         = 0,                            
                                STREAM          = SOCK_STREAM,          
                                DGRAM           = SOCK_DGRAM,           
                        };

                        enum protocol
                        {
                                ANYPROTO                = 0,                    
                                ICMP            = IPPROTO_ICMP,         
                                IGMP            = IPPROTO_IGMP,         
                                TCP                     = IPPROTO_TCP,          
                                UDP                     = IPPROTO_UDP,          
                                ICMPV6          = IPPROTO_ICMPV6,       
#if(_WIN32_WINNT >= 0x0600)    
                                RM                      = IPPROTO_PGM,          
#endif
                        };

                        class environment
                        {
                        public:

                                environment() throw(...);

                                ~environment() throw();

                                const char* spell(address::family _f) throw();

                                const char* spell(type _t) throw();

                                const char* spell(protocol _p) throw();

                        };

                        enum hint
                        {
                                PASSIVE                                 = AI_PASSIVE,
                                CANONNAME                               = AI_CANONNAME,
                                NUMERICHOST                             = AI_NUMERICHOST,
                                ADDRCONFIG                              = AI_ADDRCONFIG,
                                NON_AUTHORITATIVE               = AI_NON_AUTHORITATIVE,
                                SECURE                                  = AI_SECURE,
                                RETURN_PREFERRED_NAMES  = AI_RETURN_PREFERRED_NAMES
                        };

                        typedef int hints;      

                        struct info
                        {
                                address::family Family; 
                                type Type;                              
                                protocol Protocol;              
                                address Address;                
                                std::string Name;               

                                info() throw() {}

                                info
                                        (
                                                address::family _f,
                                                type _t,
                                                protocol _p,
                                                address _a,
                                                const char* _n
                                        ) throw() :Family(_f), Type(_t), Protocol(_p), Address(_a), Name(_n ? _n:""){}

                                info(const info& _info) throw() :Family(_info.Family), Type(_info.Type), Protocol(_info.Protocol), Address(_info.Address), Name(_info.Name){}

                        };

                        static void find
                                (
                                        environment& _e, 
                                        std::list<info>& _r, 
                                        const char* _n, 
                                        const char* _s, 
                                        hints _h = 0, 
                                        address::family _f = address::UNSPEC, 
                                        type _t = ANYTYPE, 
                                        protocol _p = ANYPROTO
                                ) throw(...);

                        class set
                        {

                                friend class socket;

                                fd_set Set;

#ifndef _WIN32
                                int maxfd;
#endif

                        public:

                                set() throw()
                                {
                                        FD_ZERO(&Set);
#ifndef _WIN32
                                        maxfd = 0;
#endif
                                }

                                void zero() throw()
                                {
                                        FD_ZERO(&Set);
#ifndef _WIN32
                                        maxfd = 0;
#endif
                                }

                                set& operator +=(socket* _s) throw()
                                {
                                        FD_SET(_s->Socket, &Set);
#ifndef _WIN32
                                        if(_s->Socket > maxfd)
                                                maxfd = _s->Socket;
#endif
                                        return *this;
                                }

                                bool contains(socket* _s) throw(){return FD_ISSET(_s->Socket, &Set) != 0;}

                        };

                        socket(environment& _e) throw();

                        socket(environment& _e, address::family _f, type _t, protocol _p = ANYPROTO) throw(...);

                        socket(environment& _e, socket& _s) throw(...);

                        socket(const socket& _s) throw():Socket(_s.Socket){}

                        virtual ~socket();

                        unsigned char get() throw(...);

                        unsigned char get(long _t) throw(...);

                        size_t read(char* _b, size_t _l) throw(...);

                        void read(char* _b, size_t _l, long _t) throw(...);

                        void put(unsigned char _c) throw(...);

                        void put(unsigned char _c, long _t) throw(...);

                        size_t write(const char* _b, size_t _l) throw(...);

                        void write(const char* _b, size_t _l, long _timeout) throw(...);

                        void write(const co_table& _t) throw(...);

                        void write(const co_table& _t, long _timeout) throw(...);

                        void read(co_table& _t) throw(...);

                        void read(co_table& _t, long _timeout) throw(...);

                        void blocking(bool _flag = true) throw(...);

                        void bind(const address& _a) throw(...);

                        static const int MaxBackLog;

                        void listen(int _backlog = MaxBackLog) throw(...);

                        void connect(const address& _a) throw(...);

                        static size_t wait(socket::set* _r, socket::set* _w, socket::set* _e, long _t) throw(...);

                        enum parameter
                        {
                                RCVBUF  =       SO_RCVBUF,      
                                SNDBUF  =       SO_SNDBUF,      
                        };

                        int option(parameter _p) throw(...);

                        void option(parameter _p, int _v) throw(...);

                protected:

#ifdef _WIN32
                        SOCKET Socket;
#else
                        int Socket;
#endif

                };

        }

}
  
#endif  // __FFL_IPC_SOCKET__