src/net/packet.cpp

Go to the documentation of this file.

#include <stdio.h>
#include <string.h>
#include <malloc.h>
#include <arpa/inet.h>
#include "tools/log.h"
#include "net/packet.h"

Packet::Packet()
{
        buf = NULL;
        buf_len = 0;
        read_off = 0;
}

Packet::Packet(const char* raw)
{
        buf_len = ntohl(*(unsigned int*)raw);
        buf_len -= 4;
        buf = (char*)malloc(buf_len);
        memcpy(buf, raw + 4, buf_len);
        read_off = 0;
}

Packet::~Packet()
{
        if(buf)
                free(buf);
}

void Packet::Push(const char* _buf, unsigned int _len)
{
        Push(_len);

        if(_len)
        {
                buf = (char*) realloc(buf, buf_len + _len);
                memcpy(buf + buf_len, _buf, _len);
                buf_len += _len;
        }
}

void Packet::Push(std::string str)
{
        Push(str.c_str(), str.size() + 1);
}

void Packet::Push(int nbr)
{
        int nbr_endian = htonl(nbr);
        buf = (char*) realloc(buf, buf_len + sizeof(int));
        memcpy(buf + buf_len, &nbr_endian, sizeof(int));
        buf_len += sizeof(int);
}

void Packet::Push(unsigned int nbr)
{
        unsigned int nbr_endian = htonl(nbr);
        buf = (char*) realloc(buf, buf_len + sizeof(unsigned int));
        memcpy(buf + buf_len, &nbr_endian, sizeof(unsigned int));
        buf_len += sizeof(unsigned int);
}

void Packet::Push(long nbr)
{
        long nbr_endian = htonl(nbr);
        buf = (char*) realloc(buf, buf_len + sizeof(long));
        memcpy(buf + buf_len, &nbr_endian, sizeof(long));
        buf_len += sizeof(long);
}

void Packet::Push(unsigned long nbr)
{
        unsigned long nbr_endian = htonl(nbr);
        buf = (char*) realloc(buf, buf_len + sizeof(unsigned long));
        memcpy(buf + buf_len, &nbr_endian, sizeof(unsigned long));
        buf_len += sizeof(unsigned long);
}

char* Packet::PopBin(unsigned int& _len)
{
        if(!buf)
        {
                log(LogError, "Empty packet while trying to read binary data");
                return NULL;
        }

        _len = PopUInt();

        if(_len)
        {
                if(_len > buf_len - read_off)
                {
                        log(LogError, "Invalid packet received");
                        return NULL;
                }
                char* _buf = (char*)malloc(_len);
                memcpy(_buf, buf + read_off, _len);
                read_off += _len;
                return _buf;
        }
        return NULL;
}

std::string Packet::PopString()
{
        if(!buf)
        {
                log(LogError, "Empty packet while trying to read a string");
                return "";
        }

        unsigned int str_len = PopUInt();

        if(str_len > buf_len - read_off)
        {
                log(LogError, "Invalid packet received");
                return "";
        }

        if(str_len == 0)
                return "";

        std::string str(buf + read_off, str_len - 1);
        read_off += str_len;
        return str;
}

int Packet::PopInt()
{
        if(!buf)
        {
                log(LogError, "Empty packet while trying to read an integer");
                return 0;
        }

        if(sizeof(int) > buf_len - read_off)
        {
                log(LogError, "Invalid packet received");
                return 0;
        }

        int tmp = *(int*)(buf + read_off);
        read_off += sizeof(int);
        return ntohl(tmp);
}

unsigned int Packet::PopUInt()
{
        if(!buf)
        {
                log(LogError, "Empty packet while trying to read an unsigned integer");
                return 0;
        }

        if(sizeof(unsigned int) > buf_len - read_off)
        {
                log(LogError, "Invalid packet received");
                return 0;
        }

        unsigned int tmp = *(unsigned int*)(buf + read_off);
        read_off += sizeof(unsigned int);
        return ntohl(tmp);
}

long Packet::PopLong()
{
        if(!buf)
        {
                log(LogError, "Empty packet while trying to read a long");
                return 0;
        }

        if(sizeof(long) > buf_len - read_off)
        {
                log(LogError, "Invalid packet received");
                return 0;
        }

        long tmp = *(long*)(buf + read_off);
        read_off += sizeof(long);
        return ntohl(tmp);
}

unsigned long Packet::PopULong()
{
        if(!buf)
        {
                log(LogError, "Empty packet while trying to read a unsigned long");
                return 0;
        }

        if(sizeof(unsigned long) > buf_len - read_off)
        {
                log(LogError, "Invalid packet received");
                return 0;
        }

        unsigned long tmp = *(unsigned long*)(buf + read_off);
        read_off += sizeof(unsigned long);
        return ntohl(tmp);
}

void Packet::DumpRaw(char* & pckt, unsigned int & len)
{
        len = buf_len + 4;
        pckt = (char*) malloc(len);
        *(unsigned int*)pckt = (unsigned int)htonl(len);
        memcpy(pckt + 4, buf, buf_len);
}

---