matter/libmp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Releases 1 Activity

update: refactoring and small fixes

Browse Source
This commit is contained in:
ngn
2024-07-31 21:16:19 +03:00
parent 3f794e1a90
commit 9cd4eb9905
41 changed files with 779 additions and 752 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
src/package/data.c
View File

@ -7,48 +7,48 @@
#include <string.h>
#include <ini.h>
int lm_package_data_handler(void *data, const char *_section, const char *_key, const char *_value) {
int lm_package_data_handler(void *_data, const char *_section, const char *_key, const char *_value) {
char *section = (char *)_section, *value = (char *)_value, *key = (char *)_key;
lm_pkg_t *pkg = data;
lm_pkg_data_t *data = _data;
if(NULL == pkg->name){
if(NULL == data->name){
if(!package_name_valid(section))
return 0;
pkg->name = strdup(section);
data->name = strdup(section);
}
else if(!eq(pkg->name, section))
else if(!eq(data->name, section))
return 0;
if(eq(key, PKG_DATA_DESC))
pkg->desc = strdup(value);
data->desc = strdup(value);
else if(eq(key, PKG_DATA_VERSION)){
if(!package_version_valid(value))
return 0;
pkg->version = strdup(value);
data->version = strdup(value);
}
else if(eq(key, PKG_DATA_SIZE))
pkg->size = atol(value);
data->size = atol(value);
else if(eq(key, PKG_DATA_DEPENDS)){
if(!lm_package_depend_add(pkg, value))
if(!lm_package_data_depend_add(data, value))
return 0;
}
else if(eq(key, PKG_DATA_KEEPS)){
if(!lm_package_keep_add(pkg, value))
if(!lm_package_data_keep_add(data, value))
return 0;
}
return 1;
}
bool lm_package_data_load(lm_pkg_t *pkg, char *file){
lm_package_data_free(pkg);
bool lm_package_data_load(lm_pkg_data_t *data, char *file){
lm_package_data_free(data);
if (ini_parse(file, lm_package_data_handler, pkg) < 0) {
if (ini_parse(file, lm_package_data_handler, data) < 0) {
lm_error_set(LM_ERR_PkgDataBad);
return false;
}
@ -56,11 +56,11 @@ bool lm_package_data_load(lm_pkg_t *pkg, char *file){
return true;
}
void lm_package_data_free(lm_pkg_t *pkg){
free(pkg->desc);
free(pkg->name);
free(pkg->version);
lm_package_depend_free(pkg);
lm_package_keep_free(pkg);
void lm_package_data_free(lm_pkg_data_t *data){
free(data->name);
free(data->desc);
free(data->version);
lm_package_data_depend_free(data);
lm_package_data_keep_free(data);
bzero(&data, sizeof(lm_pkg_data_t));
}

81
src/package/depend.c
View File

@ -1,24 +1,23 @@
#include "../../include/package.h"
#include "../../include/error.h"
#include "../../include/types.h"
#include "../../include/util.h"
#include <stdlib.h>
#include <string.h>
size_t lm_package_depend_count(lm_pkg_t *pkg){
ssize_t lm_package_data_depend_count(lm_pkg_data_t *data){
size_t index = 0;
if(NULL == pkg->depends)
if(NULL == data->depends)
return index;
while(pkg->depends[index] != NULL)
while(data->depends[index] != NULL)
index++;
return index;
}
bool lm_package_depend_add(lm_pkg_t *pkg, char *depend){
bool lm_package_data_depend_add(lm_pkg_data_t *data, char *depend){
if(NULL == depend){
lm_error_set(LM_ERR_ArgNULL);
return false;
@ -29,76 +28,76 @@ bool lm_package_depend_add(lm_pkg_t *pkg, char *depend){
return false;
}
if(NULL == pkg->depends){
pkg->depends = malloc(sizeof(char*)*2);
pkg->depends[0] = strdup(depend);
pkg->depends[1] = NULL;
if(NULL == data->depends){
data->depends = malloc(sizeof(char*)*2);
data->depends[0] = strdup(depend);
data->depends[1] = NULL;
return true;
}
size_t count = lm_package_depend_count(pkg);
pkg->depends = realloc(pkg->depends, sizeof(char*)*(count+2));
pkg->depends[count++] = strdup(depend);
pkg->depends[count] = NULL;
size_t count = lm_package_data_depend_count(data);
data->depends = realloc(data->depends, sizeof(char*)*(count+2));
data->depends[count++] = strdup(depend);
data->depends[count] = NULL;
return true;
}
void lm_package_depend_free(lm_pkg_t *pkg){
if(NULL == pkg)
void lm_package_data_depend_free(lm_pkg_data_t *data){
if(NULL == data)
return;
if(NULL == pkg->depends)
if(NULL == data->depends)
return;
for(int i = 0; pkg->depends[i] != NULL; i++)
free(pkg->depends[i]);
free(pkg->depends);
for(int i = 0; data->depends[i] != NULL; i++)
free(data->depends[i]);
free(data->depends);
pkg->depends = NULL;
data->depends = NULL;
}
size_t lm_package_depend_strlen(lm_pkg_t *pkg){
ssize_t lm_package_data_depend_strlen(lm_pkg_data_t *data){
size_t len = 1;
if(NULL == pkg->depends)
if(NULL == data->depends)
return len;
for(int i = 0; NULL != pkg->depends[i]; i++)
len += strlen(pkg->depends[i])+1;
for(int i = 0; NULL != data->depends[i]; i++)
len += strlen(data->depends[i])+1;
return len;
}
char *lm_package_depend_tostr(lm_pkg_t *pkg, char *buffer){
if(NULL == pkg){
char *lm_package_data_depend_tostr(lm_pkg_data_t *data, char *buffer){
if(NULL == data){
lm_error_set(LM_ERR_ArgNULL);
return NULL;
}
if(NULL == buffer){
size_t buflen = lm_package_depend_strlen(pkg)+1;
size_t buflen = lm_package_data_depend_strlen(data)+1;
buffer = malloc(buflen);
bzero(buffer, buflen);
}
if(NULL == pkg->depends){
if(NULL == data->depends){
buffer[0] = 0;
return buffer;
}
size_t bufsz = 0, depsz = 0;
for(int i = 0; NULL != pkg->depends[i]; i++){
depsz = strlen(pkg->depends[i]);
for(int i = 0; NULL != data->depends[i]; i++){
depsz = strlen(data->depends[i]);
if(i == 0){
memcpy(buffer, pkg->depends[i], depsz);
memcpy(buffer, data->depends[i], depsz);
bufsz += depsz;
continue;
}
buffer[bufsz++] = ',';
memcpy(buffer+bufsz, pkg->depends[i], depsz);
memcpy(buffer+bufsz, data->depends[i], depsz);
bufsz += depsz;
}
@ -106,13 +105,13 @@ char *lm_package_depend_tostr(lm_pkg_t *pkg, char *buffer){
return buffer;
}
bool lm_package_depend_fromstr(lm_pkg_t *pkg, char *buffer){
if(NULL == pkg){
bool lm_package_data_depend_fromstr(lm_pkg_data_t *data, char *buffer){
if(NULL == data){
lm_error_set(LM_ERR_ArgNULL);
return false;
}
lm_package_depend_free(pkg);
lm_package_data_depend_free(data);
if(NULL == buffer)
return true;
@ -124,24 +123,24 @@ bool lm_package_depend_fromstr(lm_pkg_t *pkg, char *buffer){
return true;
do {
if(!lm_package_depend_add(pkg, dep))
if(!lm_package_data_depend_add(data, dep))
return false;
}while((dep = strtok_r(NULL, ",", &save)) != NULL);
return true;
}
bool lm_package_depends(lm_pkg_t *pkg, char *dep){
if(NULL == pkg || NULL == dep){
bool lm_package_data_depends(lm_pkg_data_t *data, char *dep){
if(NULL == data || NULL == dep){
lm_error_set(LM_ERR_ArgNULL);
return false;
}
if(NULL == pkg->depends)
if(NULL == data->depends)
return false;
for(int i = 0; pkg->depends[i] != NULL; i++)
if(eq(pkg->depends[i], dep))
for(int i = 0; data->depends[i] != NULL; i++)
if(eq(data->depends[i], dep))
return true;
return false;
}

49
src/package/keep.c
View File

@ -1,69 +1,68 @@
#include "../../include/package.h"
#include "../../include/types.h"
#include "../../include/error.h"
#include "../../include/util.h"
#include <stdlib.h>
#include <string.h>
size_t lm_package_keep_count(lm_pkg_t *pkg){
size_t lm_package_data_keep_count(lm_pkg_data_t *data){
size_t index = 0;
if(NULL == pkg->keeps)
if(NULL == data->keeps)
return index;
while(pkg->keeps[index] != NULL)
while(data->keeps[index] != NULL)
index++;
return index;
}
bool lm_package_keep_add(lm_pkg_t *pkg, char *path){
bool lm_package_data_keep_add(lm_pkg_data_t *data, char *path){
if(NULL == path){
lm_error_set(LM_ERR_ArgNULL);
return false;
}
if(NULL == pkg->keeps){
pkg->keeps = malloc(sizeof(char*)*2);
pkg->keeps[0] = strdup(path);
pkg->keeps[1] = NULL;
if(NULL == data->keeps){
data->keeps = malloc(sizeof(char*)*2);
data->keeps[0] = strdup(path);
data->keeps[1] = NULL;
return true;
}
size_t count = lm_package_depend_count(pkg);
pkg->keeps = realloc(pkg->depends, sizeof(char*)*(count+2));
pkg->keeps[count++] = strdup(path);
pkg->keeps[count] = NULL;
size_t count = lm_package_data_depend_count(data);
data->keeps = realloc(data->depends, sizeof(char*)*(count+2));
data->keeps[count++] = strdup(path);
data->keeps[count] = NULL;
return true;
}
bool lm_package_keep_contains(lm_pkg_t *pkg, char *path){
if(NULL == pkg || NULL == path){
bool lm_package_data_keep_contains(lm_pkg_data_t *data, char *path){
if(NULL == data || NULL == path){
lm_error_set(LM_ERR_ArgNULL);
return false;
}
if(NULL == pkg->keeps)
if(NULL == data->keeps)
return false;
for(int i = 0; NULL != pkg->keeps[i]; i++)
if(eq(pkg->keeps[i], path))
for(int i = 0; NULL != data->keeps[i]; i++)
if(eq(data->keeps[i], path))
return true;
return false;
}
void lm_package_keep_free(lm_pkg_t *pkg){
if(NULL == pkg)
void lm_package_data_keep_free(lm_pkg_data_t *data){
if(NULL == data)
return;
if(NULL == pkg->keeps)
if(NULL == data->keeps)
return;
for(int i = 0; pkg->keeps[i] != NULL; i++)
free(pkg->keeps[i]);
free(pkg->keeps);
for(int i = 0; data->keeps[i] != NULL; i++)
free(data->keeps[i]);
free(data->keeps);
pkg->keeps = NULL;
data->keeps = NULL;
}

47
src/package/package.c
View File

@ -1,6 +1,5 @@
#include "../../include/package.h"
#include "../../include/error.h"
#include "../../include/types.h"
#include "../../include/mptp.h"
#include "../../include/util.h"
@ -26,7 +25,7 @@ bool lm_package_downloaded(lm_pkg_t *pkg){
return false;
}
if(!exists(pkg->paths.archive) || !exists(pkg->paths.signature)){
if(!exists(pkg->archive) || !exists(pkg->signature)){
lm_error_set(LM_ERR_PkgNotDownloaded);
return false;
}
@ -35,12 +34,12 @@ bool lm_package_downloaded(lm_pkg_t *pkg){
}
bool lm_package_remove_download(lm_pkg_t *pkg){
if(unlink(pkg->paths.archive) < 0 && errno != ENOENT){
if(unlink(pkg->archive) < 0 && errno != ENOENT){
lm_error_set(LM_ERR_PkgRemoveDownloadFail);
return false;
}
if(unlink(pkg->paths.signature) < 0 && errno != ENOENT){
if(unlink(pkg->signature) < 0 && errno != ENOENT){
lm_error_set(LM_ERR_PkgRemoveDownloadFail);
return false;
}
@ -54,41 +53,15 @@ bool lm_package_is_same(lm_pkg_t *one, lm_pkg_t *two){
return false;
}
return eq(one->version, two->version) &&
eq(one->name, two->name) &&
eq(one->desc, two->desc) &&
one->size == two->size;
}
bool lm_package_copy(lm_pkg_t *dst, lm_pkg_t *src){
lm_package_init(dst);
if(NULL != src->name)
dst->name = strdup(src->name);
if(NULL != src->version)
dst->version = strdup(src->version);
if(NULL != src->desc)
dst->desc = strdup(src->desc);
dst->size = src->size;
dst->pool = src->pool;
if(NULL != src->keeps){
for(int i = 0; src->keeps[i] != NULL; i++)
lm_package_keep_add(dst, src->keeps[i]);
}
if(NULL != src->depends){
for(int i = 0; src->depends[i] != NULL; i++)
lm_package_depend_add(dst, src->depends[i]);
}
return lm_package_path_copy(dst, src);
return eq(one->data.version, two->data.version) &&
eq(one->data.name, two->data.name) &&
eq(one->data.desc, two->data.desc) &&
one->data.size == two->data.size;
}
void lm_package_free(lm_pkg_t *pkg){
lm_package_data_free(pkg);
free(pkg->archive);
free(pkg->signature);
lm_package_data_free(&pkg->data);
bzero(pkg, sizeof(lm_pkg_t));
}

30
src/package/path.c
View File

@ -1,14 +1,13 @@
#include "../../include/package.h"
#include "../../include/error.h"
#include "../../include/types.h"
#include "../../include/util.h"
#include <stdlib.h>
#include <string.h>
bool lm_package_path_set_archive(lm_pkg_t *pkg, char *archive_path){
free(pkg->paths.archive);
pkg->paths.archive = NULL;
free(pkg->archive);
pkg->archive = NULL;
if(NULL == archive_path)
return true;
@ -16,13 +15,13 @@ bool lm_package_path_set_archive(lm_pkg_t *pkg, char *archive_path){
if(is_dir(archive_path))
return false;
pkg->paths.archive = strdup(archive_path);
pkg->archive = strdup(archive_path);
return true;
}
bool lm_package_path_set_signature(lm_pkg_t *pkg, char *signature_path){
free(pkg->paths.signature);
pkg->paths.signature = NULL;
free(pkg->signature);
pkg->signature = NULL;
if(NULL == signature_path)
return true;
@ -30,13 +29,13 @@ bool lm_package_path_set_signature(lm_pkg_t *pkg, char *signature_path){
if(is_dir(signature_path))
return false;
pkg->paths.signature = strdup(signature_path);
pkg->signature = strdup(signature_path);
return true;
}
bool lm_package_path_is_empty(lm_pkg_t *pkg){
return NULL == pkg->paths.signature ||
NULL == pkg->paths.archive;
return NULL == pkg->signature ||
NULL == pkg->archive;
}
bool lm_package_path_copy(lm_pkg_t *dst, lm_pkg_t *src){
@ -45,16 +44,11 @@ bool lm_package_path_copy(lm_pkg_t *dst, lm_pkg_t *src){
return false;
}
if(NULL != src->paths.archive)
dst->paths.archive = strdup(src->paths.archive);
if(NULL != src->archive)
dst->archive = strdup(src->archive);
if(NULL != src->paths.signature)
dst->paths.signature = strdup(src->paths.signature);
if(NULL != src->signature)
dst->signature = strdup(src->signature);
return true;
}
void lm_package_path_free(lm_pkg_t *pkg){
free(pkg->paths.signature);
free(pkg->paths.archive);
}

12
src/package/verify.c
View File

@ -26,27 +26,27 @@ bool lm_package_verify(lm_pkg_t *pkg){
err = gpgme_new(&ctx);
if (err != GPG_ERR_NO_ERROR) {
pdebug(__func__, "(%s) failed to create gpgme: %s", pkg->name, gpgme_strerror(err));
pdebug(__func__, "(%s) failed to create gpgme: %s", pkg->data.name, gpgme_strerror(err));
lm_error_set(LM_ERR_PkgGPGFail);
return false;
}
gpgme_op_import(ctx, NULL);
if((err = gpgme_data_new_from_file(&sig, pkg->paths.signature, 1)) != GPG_ERR_NO_ERROR){
pdebug(__func__, "(%s) failed to import package signature %s", pkg->name, gpgme_strerror(err));
if((err = gpgme_data_new_from_file(&sig, pkg->signature, 1)) != GPG_ERR_NO_ERROR){
pdebug(__func__, "(%s) failed to import package signature %s", pkg->data.name, gpgme_strerror(err));
lm_error_set(LM_ERR_PkgGPGSigFail);
goto end;
}
if ((err = gpgme_data_new_from_file(&text, pkg->paths.archive, 1)) != GPG_ERR_NO_ERROR) {
pdebug(__func__, "(%s) failed to import package archive %s", pkg->name, gpgme_strerror(err));
if ((err = gpgme_data_new_from_file(&text, pkg->archive, 1)) != GPG_ERR_NO_ERROR) {
pdebug(__func__, "(%s) failed to import package archive %s", pkg->data.name, gpgme_strerror(err));
lm_error_set(LM_ERR_PkgGPGArchiveFail);
goto end;
}
if ((err = gpgme_op_verify(ctx, sig, text, NULL)) != GPG_ERR_NO_ERROR) {
pdebug(__func__, "(%s) failed to verify package archive %s", pkg->name, gpgme_strerror(err));
pdebug(__func__, "(%s) failed to verify package archive %s", pkg->data.name, gpgme_strerror(err));
lm_error_set(LM_ERR_PkgSigNoResult);
goto end;
}