socket.hxx

Go to the documentation of this file.

/*
 *   xyzzy
 *   Copyright (C) 2007    Karl W. Pfalzer
 *
 *   This program 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; either version 2
 *   of the License, or (at your option) any later version.
 *
 *   This program 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 this program; if not, write to the
 *   Free Software Foundation, Inc.
 *   51 Franklin Street, Fifth Floor
 *   Boston, MA  02110-1301, USA.
 */
#if !defined(_xyzzy_socket_hxx_)
#    define  _xyzzy_socket_hxx_

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string>
#include "xyzzy/exception.hxx"
#include "xyzzy/refcnt.hxx"

namespace xyzzy
{

using namespace xyzzy;
using std::string;

class TSocket
{
public:
    static const size_t cDfltSz = 1024;

    class Exception : public TException
    {
    public:
        explicit Exception(const char *from);

        const int m_errno;

        virtual ~Exception();

    private:
        const char* mkMessage(const char *from);
    };

    class Connection : public TRcObj
    {
    public:
        explicit Connection(int id, size_t sz= cDfltSz);

        const char* recv(ssize_t &nrd, bool nonBlocking = true) 
            throw(Exception);

        bool send(const void *buf, size_t len = 0, bool nonBlocking = true) 
            throw(Exception);

        virtual ~Connection();

    private:
        const size_t    m_cBufSz;
        char*           mp_buf;
        int             m_id;
    };

    typedef PTRcObjPtr<Connection>  TRcConnection;

    virtual ~TSocket();

protected:
    explicit TSocket(u_int16_t port, string naddr = "127.0.0.1") 
        throw(Exception);

    const u_int16_t     m_port;
    const string        m_addr;
    int                 m_sockId;
    struct sockaddr_in  m_sockAddr;

private:
    void init() throw(Exception);
};

class TServerSocket : public TSocket
{
public:
    explicit TServerSocket(u_int16_t port, size_t bufSz = cDfltSz)
        throw(Exception);

    // Simply listen/block, accept and return Connection
    TRcConnection accept() throw(Exception);

    virtual ~TServerSocket();

private:
    const size_t    m_cBufSz;
    int             m_sid;
};

class TClientSocket : public TSocket
{
public:
    explicit TClientSocket(u_int16_t port, string naddr = "127.0.0.1", 
                           size_t bufSz = cDfltSz) 
        throw(Exception);

    const char* recv(ssize_t &nrd, bool nonBlocking = true) 
        throw(Exception)
    {
        return m_conn->recv(nrd, nonBlocking);
    }

    bool send(const void *buf, size_t len = 0, bool nonBlocking = true) 
        throw(Exception)
    {
        return m_conn->send(buf, len, nonBlocking);
    }

    virtual ~TClientSocket();

private:
    TRcConnection   m_conn;

    void init(size_t bufSz) throw(Exception);
};

}

#endif

---