GreekStapler
/
libvieter
forked from vieter-v/libvieter
1
0
Fork 0
Code Issues Pull Requests Releases Activity

chore(package): ran fmt

Jef Roosens 2023-02-02 11:17:16 +01:00
parent bfa1130478
commit 655daff485
Signed by: Jef Roosens
GPG Key ID: B75D4F293C7052DB
4 changed files with 302 additions and 291 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
include/vieter_package.h
View File

@ -17,12 +17,13 @@ vieter_package *vieter_package_init();
/* /*
* Parse package file into something usable by libvieter. * Parse package file into something usable by libvieter.
*/ */
vieter_package_error vieter_package_read_archive(vieter_package *pkg, const char *pkg_path); vieter_package_error vieter_package_read_archive(vieter_package *pkg,
const char *pkg_path);
/* /*
* Deallocate a package. * Deallocate a package.
*/ */
void vieter_package_free(vieter_package ** ptp); void vieter_package_free(vieter_package **ptp);
/* /*
* Create string that will become the package's desc file. * Create string that will become the package's desc file.

65
src/package/vieter_package.c
View File

@ -1,13 +1,15 @@
#include <stdlib.h>
#include <stdbool.h>
#include <archive.h> #include <archive.h>
#include <archive_entry.h> #include <archive_entry.h>
#include <stdbool.h>
#include <stdlib.h>
#include "vieter_package_internal.h"
#include "sha256.h" #include "sha256.h"
#include "vieter_package_internal.h"
#define ADD_STRING(section, field) if (pkg_info->field != 0) { \ #define ADD_STRING(section, field) \
size_to_be_written = snprintf(aux, small_buff_size, section, pkg_info->field); \ if (pkg_info->field != 0) { \
size_to_be_written = \
snprintf(aux, small_buff_size, section, pkg_info->field); \
if (size_to_be_written > small_buff_size) { \ if (size_to_be_written > small_buff_size) { \
aux = realloc(aux, size_to_be_written + 1); \ aux = realloc(aux, size_to_be_written + 1); \
small_buff_size = size_to_be_written + 1; \ small_buff_size = size_to_be_written + 1; \
@ -18,29 +20,29 @@
buff_size *= 2; \ buff_size *= 2; \
} \ } \
strcat(description, aux); \ strcat(description, aux); \
} }
#define ADD_ARRAY(section, field) i = 0; if (pkg_info->field != NULL) { \ #define ADD_ARRAY(section, field) \
ADD_STRING(section, field->array[i]); i++; \ i = 0; \
if (pkg_info->field != NULL) { \
ADD_STRING(section, field->array[i]); \
i++; \
while (pkg_info->field->array[i] != NULL) { \ while (pkg_info->field->array[i] != NULL) { \
ADD_STRING("\n%s", field->array[i]); i++; \ ADD_STRING("\n%s", field->array[i]); \
i++; \
} \ } \
} }
static char *ignored_names[5] = { static char *ignored_names[5] = {".BUILDINFO", ".INSTALL", ".MTREE", ".PKGINFO",
".BUILDINFO", ".CHANGELOG"};
".INSTALL",
".MTREE",
".PKGINFO",
".CHANGELOG"
};
static size_t ignored_words_len = sizeof(ignored_names) / sizeof(char *); static size_t ignored_words_len = sizeof(ignored_names) / sizeof(char *);
vieter_package *vieter_package_init() { vieter_package *vieter_package_init() {
return calloc(sizeof(vieter_package_info), 1); return calloc(sizeof(vieter_package_info), 1);
} }
vieter_package_error vieter_package_read_archive(vieter_package *pkg, const char *pkg_path) { vieter_package_error vieter_package_read_archive(vieter_package *pkg,
const char *pkg_path) {
struct archive *a = archive_read_new(); struct archive *a = archive_read_new();
struct archive_entry *entry = archive_entry_new(); struct archive_entry *entry = archive_entry_new();
@ -141,10 +143,10 @@ void vieter_package_sha256sum(vieter_package *pkg, char *res) {
free(in); free(in);
free(ctx); free(ctx);
// We need to convert the bytes in the hash to get a string representation of its hex values // We need to convert the bytes in the hash to get a string representation of
// i.e. turn 1001 1111 into the string "9f" // its hex values i.e. turn 1001 1111 into the string "9f" Each byte of the
// Each byte of the hash is going to turn into two bytes in the final string // hash is going to turn into two bytes in the final string so we are going to
// so we are going to convert each half byte into a char // convert each half byte into a char
unsigned int half_byte = 0; unsigned int half_byte = 0;
int j = 0; int j = 0;
@ -154,9 +156,9 @@ void vieter_package_sha256sum(vieter_package *pkg, char *res) {
// each byte from becoming reversed in the final string // each byte from becoming reversed in the final string
half_byte = hash[i] & 0b1111; half_byte = hash[i] & 0b1111;
if (half_byte < 10) { if (half_byte < 10) {
res[j+1] = half_byte + 48; res[j + 1] = half_byte + 48;
} else { } else {
res[j+1] = half_byte + 87; res[j + 1] = half_byte + 87;
} }
hash[i] = hash[i] >> 4; hash[i] = hash[i] >> 4;
half_byte = hash[i] & 0b1111; half_byte = hash[i] & 0b1111;
@ -171,8 +173,6 @@ void vieter_package_sha256sum(vieter_package *pkg, char *res) {
res[j] = '\0'; res[j] = '\0';
} }
char *vieter_package_to_description(vieter_package *pkg) { char *vieter_package_to_description(vieter_package *pkg) {
vieter_package_info *pkg_info = pkg->info; vieter_package_info *pkg_info = pkg->info;
@ -185,17 +185,19 @@ char *vieter_package_to_description(vieter_package *pkg) {
int i; int i;
// special case for FILENAME // special case for FILENAME
// assuming .pkg.tar.zst; other formats are valid, this should account for that // assuming .pkg.tar.zst; other formats are valid, this should account for
size_to_be_written = snprintf(aux, small_buff_size, "%%FILENAME%%\n%s-%s-%s.pkg.tar.zst", pkg_info->name, // that
pkg_info->version, pkg_info->arch); size_to_be_written =
snprintf(aux, small_buff_size, "%%FILENAME%%\n%s-%s-%s.pkg.tar.zst",
pkg_info->name, pkg_info->version, pkg_info->arch);
// We neither want to let an arbritrarily long input to overflow the buffer // We neither want to let an arbritrarily long input to overflow the buffer
// nor to truncate perfectly valid inputs // nor to truncate perfectly valid inputs
if (size_to_be_written > small_buff_size) { if (size_to_be_written > small_buff_size) {
aux = realloc(aux, size_to_be_written + 1); aux = realloc(aux, size_to_be_written + 1);
small_buff_size = size_to_be_written + 1; small_buff_size = size_to_be_written + 1;
snprintf(aux, small_buff_size, "%%FILENAME%%\n%s-%s-%s.pkg.tar.zst", pkg_info->name, snprintf(aux, small_buff_size, "%%FILENAME%%\n%s-%s-%s.pkg.tar.zst",
pkg_info->version, pkg_info->arch); pkg_info->name, pkg_info->version, pkg_info->arch);
} }
strcpy(description, aux); strcpy(description, aux);
@ -241,5 +243,4 @@ void vieter_package_free(vieter_package **ptp) {
vieter_package_dynarray_free((*ptp)->files); vieter_package_dynarray_free((*ptp)->files);
free(*ptp); free(*ptp);
*ptp = NULL; *ptp = NULL;
} }

14
src/package/vieter_package_dynarray.c
View File

@ -9,21 +9,23 @@ vieter_package_dynarray *vieter_package_dynarray_init(size_t initial_capacity) {
} }
void vieter_package_dynarray_add(vieter_package_dynarray *da, const char *s) { void vieter_package_dynarray_add(vieter_package_dynarray *da, const char *s) {
// An empty vieter_package_dynarray does not have an allocated internal array yet // An empty vieter_package_dynarray does not have an allocated internal array
// yet
if (da->size == 0) { if (da->size == 0) {
da->array = malloc(sizeof(char*) * da->capacity); da->array = malloc(sizeof(char *) * da->capacity);
// Initialise all char*'s to 0 so array[i] == NULL can be used to see if field is empty // Initialise all char*'s to 0 so array[i] == NULL can be used to see if
memset(da->array, 0, sizeof(char*) * da->capacity); // field is empty
memset(da->array, 0, sizeof(char *) * da->capacity);
} }
// Double array size if it's full // Double array size if it's full
else if (da->size == da->capacity) { else if (da->size == da->capacity) {
// if the realloc fails, access to memory in da->array is lost // if the realloc fails, access to memory in da->array is lost
da->array = realloc(da->array, sizeof(char*) * da->capacity * 2); da->array = realloc(da->array, sizeof(char *) * da->capacity * 2);
da->capacity *= 2; da->capacity *= 2;
// Same as the previous memset, but only for newly allocated pointers // Same as the previous memset, but only for newly allocated pointers
memset(da->array + da->size, 0, sizeof(char*) * da->capacity / 2); memset(da->array + da->size, 0, sizeof(char *) * da->capacity / 2);
} }
da->array[da->size] = strdup(s); da->array[da->size] = strdup(s);

33
src/package/vieter_package_info.c
View File

@ -2,30 +2,37 @@
#include "vieter_package_info.h" #include "vieter_package_info.h"
#define PKG_INFO_STRING(key_ptr, field) if ((value_ptr = strstr(value_ptr, key_ptr)) != NULL) { \ #define PKG_INFO_STRING(key_ptr, field) \
value_ptr += strlen(key_ptr);\ if ((value_ptr = strstr(value_ptr, key_ptr)) != NULL) { \
tail_ptr = strchr(value_ptr, '\n');\ value_ptr += strlen(key_ptr); \
tail_ptr = strchr(value_ptr, '\n'); \
tail_ptr[0] = '\0'; \ tail_ptr[0] = '\0'; \
pkg_info->field = strdup(value_ptr); \ pkg_info->field = strdup(value_ptr); \
tail_ptr[0] = '\n'; \ tail_ptr[0] = '\n'; \
} value_ptr = tail_ptr; } \
value_ptr = tail_ptr;
#define PKG_INFO_INT(key_ptr, field) value_ptr = strstr(value_ptr, key_ptr) + strlen(key_ptr);\ #define PKG_INFO_INT(key_ptr, field) \
tail_ptr = strchr(value_ptr, '\n');\ value_ptr = strstr(value_ptr, key_ptr) + strlen(key_ptr); \
tail_ptr = strchr(value_ptr, '\n'); \
tail_ptr[0] = '\0'; \ tail_ptr[0] = '\0'; \
pkg_info->field = atoi(value_ptr); \ pkg_info->field = atoi(value_ptr); \
tail_ptr[0] = '\n'; \ tail_ptr[0] = '\n'; \
value_ptr = tail_ptr; value_ptr = tail_ptr;
#define PKG_INFO_ARRAY(key_ptr, field) while((value_ptr = strstr(value_ptr, key_ptr)) != NULL){ \ #define PKG_INFO_ARRAY(key_ptr, field) \
value_ptr = value_ptr + strlen(key_ptr);\ while ((value_ptr = strstr(value_ptr, key_ptr)) != NULL) { \
value_ptr = value_ptr + strlen(key_ptr); \
tail_ptr = strchr(value_ptr, '\n'); \ tail_ptr = strchr(value_ptr, '\n'); \
tail_ptr[0] = '\0'; \ tail_ptr[0] = '\0'; \
if(pkg_info->field == NULL) { pkg_info->field = vieter_package_dynarray_init(4); } \ if (pkg_info->field == NULL) { \
pkg_info->field = vieter_package_dynarray_init(4); \
} \
vieter_package_dynarray_add(pkg_info->field, value_ptr); \ vieter_package_dynarray_add(pkg_info->field, value_ptr); \
tail_ptr[0] = '\n'; \ tail_ptr[0] = '\n'; \
value_ptr = tail_ptr;\ value_ptr = tail_ptr; \
} value_ptr = tail_ptr; } \
value_ptr = tail_ptr;
vieter_package_info *vieter_package_info_init() { vieter_package_info *vieter_package_info_init() {
return calloc(1, sizeof(vieter_package_info)); return calloc(1, sizeof(vieter_package_info));
@ -54,7 +61,8 @@ void vieter_package_info_free(vieter_package_info *pkg_info) {
free(pkg_info); free(pkg_info);
} }
void vieter_package_info_parse(vieter_package_info *pkg_info, char *pkg_info_str) { void vieter_package_info_parse(vieter_package_info *pkg_info,
char *pkg_info_str) {
char *value_ptr = pkg_info_str, *tail_ptr; char *value_ptr = pkg_info_str, *tail_ptr;
PKG_INFO_STRING("\npkgname = ", name); PKG_INFO_STRING("\npkgname = ", name);
@ -75,5 +83,4 @@ void vieter_package_info_parse(vieter_package_info *pkg_info, char *pkg_info_str
PKG_INFO_ARRAY("\noptdepend = ", optdepends); PKG_INFO_ARRAY("\noptdepend = ", optdepends);
PKG_INFO_ARRAY("\nmakedepend = ", makedepends); PKG_INFO_ARRAY("\nmakedepend = ", makedepends);
PKG_INFO_ARRAY("\ncheckdepend = ", checkdepends); PKG_INFO_ARRAY("\ncheckdepend = ", checkdepends);
} }