packet.cpp

/*
 * packet.cpp
 *
 *  Created on: Sep 15, 2017
 *      Author: root
 */

#include "common.h"
#include "log.h"
#include "packet.h"
#include "misc.h"

int iv_min = 4;
int iv_max = 32;  //< 256;
u64_t packet_send_count = 0;
u64_t dup_packet_send_count = 0;
u64_t packet_recv_count = 0;
u64_t dup_packet_recv_count = 0;

typedef u64_t anti_replay_seq_t;
int disable_replay_filter = 0;

int disable_obscure = 0;
int disable_xor = 0;

int random_drop = 0;

char key_string[1000] = "";

// int local_listen_fd=-1;

void encrypt_0(char *input, int &len, char *key) {
    int i, j;
    if (key[0] == 0) return;
    for (i = 0, j = 0; i < len; i++, j++) {
        if (key[j] == 0) j = 0;
        input[i] ^= key[j];
    }
}

void decrypt_0(char *input, int &len, char *key) {
    int i, j;
    if (key[0] == 0) return;
    for (i = 0, j = 0; i < len; i++, j++) {
        if (key[j] == 0) j = 0;
        input[i] ^= key[j];
    }
}
int do_obscure_old(const char *input, int in_len, char *output, int &out_len) {
    // memcpy(output,input,in_len);
    //	out_len=in_len;
    // return 0;

    int i, j, k;
    if (in_len > 65535 || in_len < 0)
        return -1;
    int iv_len = iv_min + rand() % (iv_max - iv_min);
    get_fake_random_chars(output, iv_len);
    memcpy(output + iv_len, input, in_len);

    output[iv_len + in_len] = (uint8_t)iv_len;

    output[iv_len + in_len] ^= output[0];
    output[iv_len + in_len] ^= key_string[0];

    for (i = 0, j = 0, k = 1; i < in_len; i++, j++, k++) {
        if (j == iv_len) j = 0;
        if (key_string[k] == 0) k = 0;
        output[iv_len + i] ^= output[j];
        output[iv_len + i] ^= key_string[k];
    }

    out_len = iv_len + in_len + 1;
    return 0;
}

int do_obscure(char *data, int &len) {
    assert(len >= 0);
    assert(len < buf_len);

    int iv_len = random_between(iv_min, iv_max);
    get_fake_random_chars(data + len, iv_len);
    data[iv_len + len] = (uint8_t)iv_len;
    for (int i = 0, j = 0; i < len; i++, j++) {
        if (j == iv_len) j = 0;
        data[i] ^= data[len + j];
    }

    len = len + iv_len + 1;
    return 0;
}

int de_obscure(char *data, int &len) {
    if (len < 1) return -1;
    int iv_len = int((uint8_t)data[len - 1]);

    if (len < 1 + iv_len) return -1;

    len = len - 1 - iv_len;
    for (int i = 0, j = 0; i < len; i++, j++) {
        if (j == iv_len) j = 0;
        data[i] ^= data[len + j];
    }

    return 0;
}
int de_obscure_old(const char *input, int in_len, char *output, int &out_len) {
    // memcpy(output,input,in_len);
    // out_len=in_len;
    // return 0;

    int i, j, k;
    if (in_len > 65535 || in_len < 0) {
        mylog(log_debug, "in_len > 65535||in_len<0 ,  %d", in_len);
        return -1;
    }
    int iv_len = int((uint8_t)(input[in_len - 1] ^ input[0] ^ key_string[0]));
    out_len = in_len - 1 - iv_len;
    if (out_len < 0) {
        mylog(log_debug, "%d %d\n", in_len, out_len);
        return -1;
    }
    for (i = 0, j = 0, k = 1; i < in_len; i++, j++, k++) {
        if (j == iv_len) j = 0;
        if (key_string[k] == 0) k = 0;
        output[i] = input[iv_len + i] ^ input[j] ^ key_string[k];
    }
    dup_packet_recv_count++;
    return 0;
}

/*
int sendto_fd_ip_port (int fd,u32_t ip,int port,char * buf, int len,int flags)
{

        sockaddr_in tmp_sockaddr;

        memset(&tmp_sockaddr,0,sizeof(tmp_sockaddr));
        tmp_sockaddr.sin_family = AF_INET;
        tmp_sockaddr.sin_addr.s_addr = ip;
        tmp_sockaddr.sin_port = htons(uint16_t(port));

        return sendto(fd, buf,
                        len , 0,
                        (struct sockaddr *) &tmp_sockaddr,
                        sizeof(tmp_sockaddr));
}*/

int sendto_fd_addr(int fd, address_t addr, char *buf, int len, int flags) {
    return sendto(fd, buf,
                  len, 0,
                  (struct sockaddr *)&addr.inner,
                  addr.get_len());
}
/*
int sendto_ip_port (u32_t ip,int port,char * buf, int len,int flags)
{
        return sendto_fd_ip_port(local_listen_fd,ip,port,buf,len,flags);
}*/

int send_fd(int fd, char *buf, int len, int flags) {
    return send(fd, buf, len, flags);
}

int my_send(const dest_t &dest, char *data, int len) {
    if (dest.cook) {
        do_cook(data, len);
    }
    switch (dest.type) {
        case type_fd_addr: {
            return sendto_fd_addr(dest.inner.fd, dest.inner.fd_addr.addr, data, len, 0);
            break;
        }
        case type_fd64_addr: {
            if (!fd_manager.exist(dest.inner.fd64)) return -1;
            int fd = fd_manager.to_fd(dest.inner.fd64);

            return sendto_fd_addr(fd, dest.inner.fd64_addr.addr, data, len, 0);
            break;
        }
        case type_fd: {
            return send_fd(dest.inner.fd, data, len, 0);
            break;
        }
        case type_write_fd: {
            return write(dest.inner.fd, data, len);
            break;
        }
        case type_fd64: {
            if (!fd_manager.exist(dest.inner.fd64)) return -1;
            int fd = fd_manager.to_fd(dest.inner.fd64);

            return send_fd(fd, data, len, 0);
            break;
        }
        /*
        case type_fd64_ip_port_conv:
        {
                if(!fd_manager.exist(dest.inner.fd64)) return -1;
                int fd=fd_manager.to_fd(dest.inner.fd64);

                char *new_data;
                int new_len;

                put_conv(dest.conv,data,len,new_data,new_len);
                return sendto_fd_ip_port(fd,dest.inner.fd64_ip_port.ip_port.ip,dest.inner.fd64_ip_port.ip_port.port,new_data,new_len,0);
                break;
        }*/

        /*
        case type_fd64_conv:
        {
                char *new_data;
                int new_len;
                put_conv(dest.conv,data,len,new_data,new_len);

                if(!fd_manager.exist(dest.inner.fd64)) return -1;
                int fd=fd_manager.to_fd(dest.inner.fd64);
                return send_fd(fd,new_data,new_len,0);
        }*/
        /*
        case type_fd:
        {
                send_fd(dest.inner.fd,data,len,0);
                break;
        }*/
        default:
            assert(0 == 1);
    }
    return 0;
}

/*
 *  this function comes from  http://www.hackersdelight.org/hdcodetxt/crc.c.txt
 */
unsigned int crc32h(unsigned char *message, int len) {
    assert(len >= 0);
    int i, crc;
    unsigned int byte, c;
    const unsigned int g0 = 0xEDB88320, g1 = g0 >> 1,
                       g2 = g0 >> 2, g3 = g0 >> 3, g4 = g0 >> 4, g5 = g0 >> 5,
                       g6 = (g0 >> 6) ^ g0, g7 = ((g0 >> 6) ^ g0) >> 1;

    i = 0;
    crc = 0xFFFFFFFF;
    while (i != len) {  // Get next byte.
        byte = message[i];
        crc = crc ^ byte;
        c = ((crc << 31 >> 31) & g7) ^ ((crc << 30 >> 31) & g6) ^
            ((crc << 29 >> 31) & g5) ^ ((crc << 28 >> 31) & g4) ^
            ((crc << 27 >> 31) & g3) ^ ((crc << 26 >> 31) & g2) ^
            ((crc << 25 >> 31) & g1) ^ ((crc << 24 >> 31) & g0);
        crc = ((unsigned)crc >> 8) ^ c;
        i = i + 1;
    }
    return ~crc;
}

int put_conv0(u32_t conv, const char *input, int len_in, char *&output, int &len_out) {
    assert(len_in >= 0);
    static char buf[buf_len];
    output = buf;
    u32_t n_conv = htonl(conv);
    memcpy(output, &n_conv, sizeof(n_conv));
    memcpy(output + sizeof(n_conv), input, len_in);
    u32_t crc32 = crc32h((unsigned char *)output, len_in + sizeof(crc32));
    u32_t crc32_n = htonl(crc32);
    len_out = len_in + (int)(sizeof(n_conv)) + (int)sizeof(crc32_n);
    memcpy(output + len_in + (int)(sizeof(n_conv)), &crc32_n, sizeof(crc32_n));
    return 0;
}
int get_conv0(u32_t &conv, const char *input, int len_in, char *&output, int &len_out) {
    assert(len_in >= 0);
    u32_t n_conv;
    memcpy(&n_conv, input, sizeof(n_conv));
    conv = ntohl(n_conv);
    output = (char *)input + sizeof(n_conv);
    u32_t crc32_n;
    len_out = len_in - (int)sizeof(n_conv) - (int)sizeof(crc32_n);
    if (len_out < 0) {
        mylog(log_debug, "len_out<0\n");
        return -1;
    }
    memcpy(&crc32_n, input + len_in - (int)sizeof(crc32_n), sizeof(crc32_n));
    u32_t crc32 = ntohl(crc32_n);
    if (crc32 != crc32h((unsigned char *)input, len_in - (int)sizeof(crc32_n))) {
        mylog(log_debug, "crc32 check failed\n");
        return -1;
    }
    return 0;
}
int put_crc32(char *s, int &len) {
    if (disable_checksum) return 0;
    assert(len >= 0);
    // if(len<0) return -1;
    u32_t crc32 = crc32h((unsigned char *)s, len);
    write_u32(s + len, crc32);
    len += sizeof(u32_t);

    return 0;
}

int do_cook(char *data, int &len) {
    put_crc32(data, len);
    if (!disable_obscure) do_obscure(data, len);
    if (!disable_xor) encrypt_0(data, len, key_string);
    return 0;
}

int de_cook(char *s, int &len) {
    if (!disable_xor) decrypt_0(s, len, key_string);
    if (!disable_obscure) {
        int ret = de_obscure(s, len);
        if (ret != 0) {
            mylog(log_debug, "de_obscure fail\n");
            return ret;
        }
    }
    int ret = rm_crc32(s, len);
    if (ret != 0) {
        mylog(log_debug, "rm_crc32 fail\n");
        return ret;
    }
    return 0;
}
int rm_crc32(char *s, int &len) {
    if (disable_checksum) return 0;
    assert(len >= 0);
    len -= sizeof(u32_t);
    if (len < 0) return -1;
    u32_t crc32_in = read_u32(s + len);
    u32_t crc32 = crc32h((unsigned char *)s, len);
    if (crc32 != crc32_in) return -1;
    return 0;
}
/*
int do_obs()
{

}
int de_obs()*/
int put_conv(u32_t conv, const char *input, int len_in, char *&output, int &len_out) {
    static char buf[buf_len];
    output = buf;
    u32_t n_conv = htonl(conv);
    memcpy(output, &n_conv, sizeof(n_conv));
    memcpy(output + sizeof(n_conv), input, len_in);
    len_out = len_in + (int)(sizeof(n_conv));

    return 0;
}
int get_conv(u32_t &conv, const char *input, int len_in, char *&output, int &len_out) {
    u32_t n_conv;
    memcpy(&n_conv, input, sizeof(n_conv));
    conv = ntohl(n_conv);
    output = (char *)input + sizeof(n_conv);
    len_out = len_in - (int)sizeof(n_conv);
    if (len_out < 0) {
        mylog(log_debug, "len_out<0\n");
        return -1;
    }
    return 0;
}