socket.h

/*
 * socket.h
 * This file is part of dbPager Classes Library (DCL)
 *
 * Copyright (c) 2008 Dennis Prochko <wolfsoft@mail.ru>
 *
 * DCL is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation version 3.
 *
 * DCL 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with DCL; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor,
 * Boston, MA  02110-1301  USA
 */

#ifndef _SOCKET_H_
#define _SOCKET_H_

#include <vector>
#include <string>

#include <dcl/exception.h>

namespace dbp {


class socket_exception: public exception {
public:
        socket_exception(const std::string &msg = "") throw(): exception(msg) { }
};

class socket_address: public std::vector<std::string> {
public:
        int port;
        std::string host;
        socket_address(): port(0), host("") {};

        socket_address(const std::string &addr) { parse(addr); };

        socket_address(const std::string &address, int port): port(port),
          host(address) { };

        void parse(const std::string &addr);
};


class socket {
public:
        typedef enum {
                data_not_ready = -1,
                io_error = -2
        } error;
        socket();
        socket(const socket &src) {
                socket_fd = src.socket_fd;
                _port = src._port;
                _address = src._address;
                const_cast<socket&>(src).socket_fd = -1;
        }
        socket& operator=(const socket &src) {
                socket_fd = src.socket_fd;
                _port = src._port;
                _address = src._address;
                const_cast<socket&>(src).socket_fd = -1;
                return *this;
        }
        virtual ~socket();
        virtual int handle() const {
                return socket_fd;
        }

        bool connect(const std::string &address, int port);

        void bind(const socket_address &address);

        void listen();

        socket accept();

        virtual int read(int bytes_to_read, char *buffer);

        virtual int write(int bytes_to_write, const char *buffer);

        virtual void shutdown();

        const std::string& address() const {
                return _address;
        }

        int port() const {
                return _port;
        }
protected:
        int socket_fd;
        std::string _address;
        int _port;
private:
        void set_blocked(bool state);
};

class tcp_socket: public socket {
public:
        tcp_socket();
};

class udp_socket: public socket {
public:
        udp_socket();
};

class unix_socket: public socket {
public:
        unix_socket();
};

}

#endif /*_SOCKET_H_*/