libaeon.h

Go to the documentation of this file.

/*********************************************************************
 * libaeon - A simple, lightweight, cross platform networking library
 * Copyright 2006-2007 (c) Elden Armbrust
 * This software is licensed under the BSD software license.
 *********************************************************************/
#ifndef _LIBAEON_H
#define _LIBAEON_H

#ifdef _WIN32
    #define WIN32_LEAN_AND_MEAN
    #define _CRT_SECURE_NO_DEPRECATE 1
    #include <winsock2.h>
    typedef int socklen_t;
#endif
#ifdef __linux__
    #include <sys/socket.h>
    #include <netdb.h>
    #include <arpa/inet.h>
    #include <netinet/in.h>
    #include <sys/types.h>
    #include <fcntl.h>
#endif

//multi-platform includes
#include <string>
#include <vector>


//generic error, state, and name defines.  *deprecating*
//define states
#define SOCK_RESOLVE 1
#define SOCK_ACCEPT 3
#define SOCK_CONNECT 4
#define SOCK_CREATE 2
//define codes
#define ERR_NONE 0
#define ERR_NOHOST 1
#define ERR_NOSOCKET 2
//various defines
//#define BUF_SIZE 256
#define AEON 1

//#define DEFAULT_NET AF_INET

namespace net
{
    class CSocket
    {
    public:
        static const int MaxBufferSize = 256;
        static const int StreamSocketType = SOCK_STREAM;
        static const int DatagramSocketType = SOCK_STREAM;
        static const int DefaultSocketType = CSocket::StreamSocketType;


        static const int DefaultFamilyType = AF_INET;
        int SetBlocking(bool flag);
        static const int NULLFlag = 0;
        int Write(char* data, int size);
        int Write(char* data);
        int Write(std::string data);
        int Read();
        int Read(char* buffer, int size);
        int ReadLine(char* buffer, int size);
        int ReadUntil(char* buffer, int size);
        std::string Read(int size);
        CSocket();
        CSocket(int family_type);
        ~CSocket();
        bool Close();
        int operator<<(char* data);
        int operator<<(std::string data);
        std::string operator>>(std::string);
        int sockfd, n;
        struct sockaddr_in remote_addr;
        bool connected;
    protected:
        int flags;
        int net_family;
        int token_size;
        bool blocking;
        char inbuffer[CSocket::MaxBufferSize];
        char outbuffer[CSocket::MaxBufferSize];
        std::string remote_host;
        std::string remote_ip;
        int connect_code;
        int error_code;
        int error_state;
        int GetState();
        int GetError();
        void SetError(int error);

        int port;

        void ClearBuffers();
        void ClearBuffer(char* buffer, int size);
#ifdef WIN32
        int wsaret;
        WSADATA wsadata;
#endif
    };


    class CClientSocket : public CSocket
    {
    public:
        bool Connect();
        bool Connect(const char* remote, int port);
        CClientSocket();
        CClientSocket(std::string *remote, int port);
        CClientSocket(const char* remote, int port);
        ~CClientSocket();
    protected:
        struct sockaddr_in serv_addr;
        struct hostent *server;
    };

    class CServerSocket : public CSocket
    {
    public:
        CServerSocket();
        ~CServerSocket();
        bool Listen();
        bool Listen(int port);
        CSocket* Accept();
    protected:
        struct sockaddr_in serv_addr;
        struct hostent *server;
        int server_socket;
    };



    class CEventSocket: public CSocket
    {
    public:
        bool OnRead(const char* buffer, int size);
        void OnWrite(const char* buffer, int size, int sentsize);
        int Write(char* data);
        int Write(std::string data);
        bool Poll();

    };

    class CEventClientSocket: public CClientSocket
        {};


    class CEventServerSocket: public CServerSocket, public CEventSocket
        {};


    class CSocketSet
    {
    public:
        std::vector<CSocket*> Sockets;
        bool Add(CSocket* socket_ref);
        bool Add();
        bool Remove(int index);
        bool Remove(int index, int count);
        int Size();
    };

    class CEventSocketSet
    {
    public:
        std::vector<CEventSocket*> Sockets;
        bool Add(CEventSocket* socket_ref);
        bool Add();
        bool Remove(int index);
        bool Remove(int index, int count);
        int Size();
        void Poll();
        void Cleanup();

    };

    class CSocketUDP : public CSocket
    {
    public:
    CSocketUDP();
        int Write(char* data, int size);
        int Write(char* data);
        int Write(std::string data);
        int Read();
        int Read(char* buffer, int size);
        int ReadUntil(char* buffer, int size);
        std::string Read(int size);
        static const int DefaultSocketType = SOCK_DGRAM;
    };


}
#endif

---