datagram/datagram.h

/*--------------------------------------------------------------------------

  This is part of the Messaging system of the Karoo project.

  (C) 2009 Brian Modra <brian@zwartberg.com>

  This library is free software; you can redistribute them 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 these libraries; if not, write to the Free Software Foundation,
  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

--------------------------------------------------------------------------*/
#ifndef datagram_h
#define datagram_h

#ifndef _REENTRANT
#define _REENTRANT
#endif

#include "config.h"
#include <netinet/in.h>
#include <iostream>
#include "queue.h"
#include "util.h"
#include <stdexcept>

using std::exception;
using std::ostream;

namespace karoo {

    enum datagram_status_enum {
        DATAGRAM_OK = 0,
        DATAGRAM_RECEIVE_FAILED,
        DATAGRAM_SEND_FAILED,
        DATAGRAM_UNINITIALISED,
        DATAGRAM_CREATE_FAILED,
        DATAGRAM_BIND_FAILED
    };

    class bad_address : public exception {
        char* str;
    public:
        bad_address() throw()
            : exception()
        {
            str = NULL;
        }
        bad_address(const text& s) throw()
            : exception()
        {
            try {
                this->str = s.new_clone();
            }
            catch (...) {
                str = NULL;
            }
        }
        bad_address(const bad_address& ref) throw()
            : exception()
        {
            try {
                if (ref.str) {
                    size_t len = strlen(ref.str)+1;
                    this->str = new char[len];
                    memcpy(this->str, ref.str, len);
                    return;
                }
            }
            catch (...) {}
            str = NULL;
        }
        bad_address& operator=(const bad_address& ref) throw()
        {
            try {
                if (str) {
                    delete [] str;
                    str = NULL;
                }
                if (ref.str) {
                    size_t len = strlen(ref.str)+1;
                    this->str = new char[len];
                    memcpy(this->str, ref.str, len);
                }
                else {
                    str = NULL;
                }
            }
            catch (...) {
                str = NULL;
            }
            return *this;
        }
        virtual ~bad_address() throw()
        {
            try {
                if (str)
                    delete [] str;
            }
            catch (...) {}
        }
        virtual const char* what() const throw()
        {
            if (str) {
                return str;
            }
            else {
                return "";
            }
        }
    };

    class datagram_status
    {
    private:
        mutable karoo_mutex sem;
        enum datagram_status_enum status;
    public:
        datagram_status();
        datagram_status(const enum datagram_status_enum ref);
        datagram_status(const datagram_status& ref);

        virtual ~datagram_status();

        enum datagram_status_enum operator=(const datagram_status& ref);
        enum datagram_status_enum operator=(enum datagram_status_enum ref);

        operator bool() const;
        operator enum datagram_status_enum() const;
        operator text() const;
    };

    extern ostream& operator << (ostream& os, const datagram_status& s);
    extern logstream& operator << (logstream& os, const datagram_status& s);

    class datagram_message : public pebble
    {
    protected:
        size_t addrlen;
        struct sockaddr* addr;
        size_t size;
        size_t alloc_size;
        uint8_t* data;
        friend class datagram_server;
        friend class datagram_client;
    public:
        datagram_message(size_t alloc_size);
        datagram_message(size_t alloc_size, const text& ip, int port);
        datagram_message(const void* data, size_t size, const text& ip, int port);
        virtual ~datagram_message();

        virtual datagram_message* clone(size_t alloc_size = 0) const = 0;
        virtual datagram_message* clone(int port, size_t alloc_size = 0) const = 0;


        void init(const text& ip, int port);

        size_t getSize() const { return size; }

        uint8_t* getDataPtr() { return data; }
    };

    class datagram_message_factory
    {
    private:
    protected:
    public:
        datagram_message_factory() {}
        virtual ~datagram_message_factory() {}

        virtual datagram_message* create_datagram_message(size_t alloc_size) = 0;
    };

    class datagram_server : public pebble
    {
    private:
    protected:
        int port;
        struct sockaddr_in addr;
        int sock;
        datagram_status status;
        size_t message_size;
        exeque* output_queue;
        exeque* run_queue;
        datagram_message_factory* factory;
        mutable karoo_mutex running_sem;
        bool running;

        unsigned fail_count;

        log logger;

        void close();

        datagram_status read(datagram_message* message);

    public:
        datagram_server(int port, size_t message_size, exeque* output_queue, exeque* run_queue, datagram_message_factory* factory);
        virtual ~datagram_server();

        void setLogger(const log& logger);

        datagram_status create();
        void run();

        void start();
        void stop();

        datagram_status getStatus() const { return status; }
    };

    class datagram_client
    {
    private:
    protected:
        karoo_mutex sem;
        int sock;
        datagram_status status;
        log logger;

        void close();
    public:
        datagram_client();
        virtual ~datagram_client();

        void setLogger(const log& logger) { this->logger = logger; }

        datagram_status create();
        datagram_status write(datagram_message* message);
        datagram_status getStatus() const { return status; }
    };

}

#endif

---