protohackersc/data.c

//
// Created by Ajurna on 28/07/2025.
//

#include "data.h"

#include <stdlib.h>
#include <string.h>
#define PORT 40000
SOCKET get_listen_socket() {
    WSADATA WSAData;

    SOCKADDR_IN serverAddr;

    WSAStartup(MAKEWORD(2,0), &WSAData);
    SOCKET server = socket(AF_INET, SOCK_STREAM, 0);

    serverAddr.sin_addr.s_addr = INADDR_ANY;
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_port = htons(PORT);

    bind(server, (SOCKADDR *)&serverAddr, sizeof(serverAddr));
    listen(server, 0);
    return server;
}

char_array_t *char_array_create(int capacity) {
    char_array_t *array = malloc(sizeof(char_array_t));
    array->capacity = capacity;
    array->size = 0;
    array->data = calloc(capacity, sizeof(char));
    return array;
}
void char_array_destroy(char_array_t *array) {
    free(array->data);
    free(array);
};
void char_array_append(char_array_t *array, char *value, size_t length) {
    if (array->data == NULL) {
        exit(1);
    }
    // char *temp = calloc(length+1, sizeof(char));
    // memcpy(temp, value, length);
    // printf("Appending '%s' bytes\n", temp);
    // free(temp);
    size_t new_size = array->size + length;
    if (new_size > array->capacity) {
        array->capacity = new_size;
        char *new_array = realloc(array->data, array->capacity);
        array->data = new_array;
        if (array->data == NULL) {
            printf("Failed to allocate memory for array\n");
            exit(1);
        }
    }
    memcpy(array->data+array->size, value, length);
    array->size = new_size;
};

void char_array_print(const char_array_t *array) {
    printf("%s", array->data);
};

void char_array_print_hex(const char_array_t *array) {
    printf("array: ");
    for (int i = 0; i < array->size; i++) {
        printf("%02x:", array->data[i]);
    }
    printf("\n");
};

void char_array_wipe(char_array_t *array) {
    array->size = 0;
    memset(array->data, 0, array->capacity);
};

bool char_array_has_char(char_array_t *array, char c) {
    const char *ret = memchr(array->data, c, array->size);
    if (ret == NULL) {
        return false;
    }
    return true;
};
char *char_array_get_until_char(char_array_t *array, char c) {
    size_t idx = 0;
    for (size_t i = 0; i < array->size; i++) {
        if (array->data[i] == c) {
            idx = i;
            break;
        }
    }
    if (idx == 0) {
        return NULL;
    }
    char *ret = malloc(idx+1);
    memcpy(ret, array->data, idx);
    ret[idx] = '\0';
    char_array_shift_bytes(array, idx+1);
    return ret;
};

char *char_array_get_bytes(char_array_t *array, size_t length) {
    if (length > array->size) {
        return NULL;
    }

    char *ret = calloc(length, sizeof(char));
    printf("before: %c %02x:%02x:%02x:%02x %02x:%02x:%02x:%02x\n", ret[0], ret[1], ret[2], ret[3], ret[4], ret[5], ret[6], ret[7], ret[8]);
    memcpy(ret, array->data, length);
    printf("after:  %c %02x:%02x:%02x:%02x %02x:%02x:%02x:%02x\n", ret[0], ret[1], ret[2], ret[3], ret[4], ret[5], ret[6], ret[7], ret[8]);
    printf("weird: %x\n", ret[3]);
    printf("weird: %x\n", array->data[3]);
    char_array_shift_bytes(array, length);
    return ret;
}
void char_array_shift_bytes(char_array_t *array, size_t length) {
    if (length >= array->size) {
        array->size = 0;
        return;
    }

    memmove(array->data, array->data + length, array->size - length);
    array->size -= length;

}

byte_array_t *byte_array_create(int size) {
    byte_array_t *array = malloc(sizeof(byte_array_t));
    array->capacity = size;
    array->size = 0;
    array->data = calloc(size, sizeof(uint8_t));
    return array;
}
void byte_array_destroy(byte_array_t *array) {
    free(array->data);
    free(array);
};
void byte_array_append(byte_array_t *array, byte *value, size_t length) {
    if (array->data == NULL) {
        exit(1);
    }
    size_t new_size = array->size + length;
    if (new_size > array->capacity) {
        array->capacity = new_size;
        uint8_t *new_array = realloc(array->data, array->capacity);
        array->data = new_array;
        if (array->data == NULL) {}
    }
    memcpy(array->data+array->size, value, length);
    array->size = new_size;
}
void byte_array_print(const byte_array_t *array) {
    printf("btye_array size %llu: ", array->size);
    for (int i = 0; i < array->size; i++) {
        printf("%02x:", array->data[i]);
    }
    printf("\n");
}
uint8_t *byte_array_get_until_byte(byte_array_t *array, uint8_t b) {
    size_t idx = 0;
    for (size_t i = 0; i < array->size; i++) {
        if (array->data[i] == b) {
            idx = i;
            break;
        }
    }
    if (idx == 0) {
        return NULL;
    }
    uint8_t *ret = malloc(idx+1);
    memcpy(ret, array->data, idx);
    ret[idx] = '\0';
    byte_array_shift_bytes(array, idx+1);
    return ret;
}
void byte_array_shift_bytes(byte_array_t *array, size_t length) {
    if (length >= array->size) {
        array->size = 0;
        return;
    }
    memmove(array->data, array->data + length, array->size - length);
    array->size -= length;
}
uint8_t *byte_array_get_bytes(byte_array_t *array, size_t length) {
    if (length > array->size) {
        return NULL;
    }
    // printf("array size: %llu\n", array->size);
    uint8_t *ret = calloc(length, sizeof(uint8_t));
    // printf("calloc done\n");
    memcpy(ret, array->data, length);
    // printf("memcpy done\n");
    byte_array_shift_bytes(array, length);
    return ret;
}