From 6e57027641296e679fa109a8edd3ff53c745a6de Mon Sep 17 00:00:00 2001 From: Andreas Fankhauser hiddenalpha.ch Date: Thu, 28 Sep 2023 21:42:24 +0200 Subject: Bunch of formatting changes --- src/gateleen_resclone/gateleen_resclone.c | 343 +++++++++++++++--------------- 1 file changed, 166 insertions(+), 177 deletions(-) diff --git a/src/gateleen_resclone/gateleen_resclone.c b/src/gateleen_resclone/gateleen_resclone.c index 4501125..f97373b 100644 --- a/src/gateleen_resclone/gateleen_resclone.c +++ b/src/gateleen_resclone/gateleen_resclone.c @@ -8,7 +8,6 @@ #include #include #include -#include #include /* Libs */ @@ -30,128 +29,123 @@ /** Operation mode. */ -typedef enum opMode { +typedef enum OpMode { MODE_NULL =0, MODE_FETCH=1, MODE_PUSH =2 -} opMode_t; +} OpMode; /** Main module handle representing an instance. */ -typedef struct this { - enum opMode mode; +typedef struct Resclone { + enum OpMode mode; /** Base URL where to upload to / download from. */ char *url; /** Array of regex patterns to use per segment. */ regex_t *filter; size_t filter_len; /** Says if only start or whole path needs to match the pattern. */ - bool isFilterFull; + int isFilterFull; /* Path to archive file to use. Using stdin/stdout if NULL. */ char *file; -} this_t; +} Resclone; /** Closure for a download instructed by external caller. */ -typedef struct cls_dload { - struct this *this; +typedef struct ClsDload { + struct Resclone *resclone; char *rootUrl; struct archive *dstArchive; struct archive_entry *tmpEntry; char *archiveFile; CURL *curl; -} cls_dload_t; +} ClsDload; /** Closure for a collection (directory) download. */ -typedef struct cls_resourceDir { - struct cls_dload *dload; +typedef struct ResourceDir { + struct ClsDload *dload; //yajl_handle yajl; <- TODO Obsolete - struct cls_resourceDir *parentDir; + struct ResourceDir *parentDir; char *rspBody; size_t rspBody_len; size_t rspBody_cap; short rspCode; char *name; -} cls_resourceDir_t; +} ResourceDir; /** Closure for a file download. */ -typedef struct cls_resourceFile { - struct cls_dload *dload; +typedef struct ResourceFile { + struct ClsDload *dload; size_t srcChunkIdx; char *url; char *buf; int buf_len; int buf_memSz; -} cls_resourceFile_t; +} ResourceFile; /** Closure for an upload instructed by external caller. */ -typedef struct cls_upload { - struct this *this; +typedef struct Upload { + struct Resclone *resclone; char *rootUrl; char *archiveFile; struct archive *srcArchive; CURL *curl; -} cls_upload_t; +} Upload; /** Closure for a PUT of a single resource. */ -typedef struct cls_put { - struct cls_upload *upload; +typedef struct Put { + struct Upload *upload; /* Path (relative to rootUrl) of the resource to be uploaded. */ char *name; -} cls_put_t; +} Put; /* Operations ****************************************************************/ -TPL_ARRAY( str, char*, 16 ); +TPL_ARRAY(str, char*, 16); -static void -printHelp( void ) -{ - char filename[sizeof(__FILE__)]; - strcpy( filename, __FILE__ ); +static void printHelp( void ){ printf("%s%s%s", - "\n" - " ", basename(filename), " - " STR_QUOT(PROJECT_VERSION) "\n" - "\n" - "Options:\n" - "\n" + " \n" + " ", strrchr(filename,'/')+1, " - " STR_QUOT(PROJECT_VERSION) "\n" + " \n" + " Options:\n" + " \n" " --pull|--push\n" " Choose to download or upload.\n" - "\n" + " \n" " --url \n" - " Root node of remote tree.\n" - "\n" + " Root node of remote tre\n" " --filter-part \n" - " Regex pattern applied as predicate to the path starting after the path\n" - " specified in '--url'. Each path segment will be handled as its\n" - " individual pattern. If there are longer paths to process, they will be\n" - " accepted, as long they at least start-with specified filter.\n" + " Regex pattern applied as predicate to the path starting after\n" + " the path specified in '--url'. Each path segment will be\n" + " handled as its individual pattern. If there are longer paths to\n" + " process, they will be accepted, as long they at least\n" + " start-with specified filter.\n" " Example: /foo/[0-9]+/bar\n" - "\n" + " \n" " --filter-full \n" - " Nearly same as '--filter-part'. But paths with more segments than the\n" - " pattern, will be rejected.\n" - "\n" + " Nearly same as '--filter-part'. But paths with more segments\n" + " than the pattern, will be rejected.\n" + " \n" " --file \n" " (optional) Path to the archive file to read/write. Defaults to\n" " stdin/stdout if ommitted.\n" - "\n" + " \n" + " \n" ); } -static int -parseArgs( int argc, char**argv, opMode_t*mode, char**url, regex_t**filter, size_t*filter_cnt, - bool*isFilterFull, char**file ){ - ssize_t err, ret=0; +static int parseArgs( int argc, char**argv, OpMode*mode, char**url, regex_t**filter, size_t*filter_cnt, int*isFilterFull, char**file ){ + ssize_t err; char *filterRaw = NULL; if( argc == -1 ){ // -1 indicates the call to free our resources. So simply jump goto fail; // to 'fail' because that has the same effect. @@ -160,77 +154,77 @@ parseArgs( int argc, char**argv, opMode_t*mode, char**url, regex_t**filter, size *url = NULL; *filter = NULL; *filter_cnt = 0; - *isFilterFull = false; + *isFilterFull = 0; *file = NULL; for( int i=1 ; i ", tmp); if( tmp == NULL ){ fprintf(stderr, "%s%d%s\n", "[ERROR] realloc(", filter_cap*sizeof**filter, ")"); - ret = -ENOMEM; goto fail; } + err = -ENOMEM; goto fail; } *filter = tmp; } //fprintf(stderr, "%s%d%s%s%s\n", "[DEBUG] filter[", iSegm, "] -> '", beg-1, "'"); - err = regcomp( (*filter)+iSegm, beg-1, REG_EXTENDED); + err = regcomp((*filter)+iSegm, beg-1, REG_EXTENDED); if( err ){ fprintf(stderr, "%s%s%s%d\n", "[ERROR] regcomp(", beg, ") -> ", err); - ret = -1; goto fail; } - // Restore surrounding stuff. + err = -1; goto fail; } + /* Restore surrounding stuff. */ beg[-1] = origBeg; - *end = origSep; // <- Restore tmp 'end-of-match' ($). - end[1] = origNext; // <- Restore tmp termination. - if( *end=='\0' ){ // EOF + *end = origSep; /* <- Restore tmp 'end-of-match' ($) */ + end[1] = origNext; /* <- Restore tmp termination. */ + if( *end == '\0' ){ /* EOF */ *filter_cnt = iSegm +1; - *filter = realloc(*filter, *filter_cnt *sizeof(**filter)); // Trim result. + *filter = realloc(*filter, *filter_cnt *sizeof(**filter)); /* Trim result. */ assert(*filter != NULL); free(buf); buf = NULL; break; @@ -285,27 +279,26 @@ parseArgs( int argc, char**argv, opMode_t*mode, char**url, regex_t**filter, size if( *mode == MODE_PUSH && *filter ){ fprintf(stderr, "%s\n", "[ERROR] Filtering not supported for push mode."); - ret = -1; goto fail; + err = -1; goto fail; } return 0; fail: free(*url); *url = NULL; for( uint_t i=0 ; i<*filter_cnt ; ++i ){ - regfree( &(filter[0][i]) ); + regfree(&(filter[0][i])); } *filter_cnt = 0; free(*filter); *filter = NULL; - return ret; + return err; } -static size_t -onCurlDirRsp( char*buf, size_t size, size_t nmemb, void*cls_resourceDir_ ){ +static size_t onCurlDirRsp( char*buf, size_t size, size_t nmemb, void*ResourceDir_ ){ fprintf(stderr, "%s%s%s%p%s%ld%s%ld%s%p%s\n", "[TRACE] ", __func__, "( buf=", buf, - ", size=", size, ", nmemb=", nmemb, ", cls=", cls_resourceDir_, " )"); - cls_resourceDir_t *resourceDir = cls_resourceDir_; - cls_dload_t *dload = resourceDir->dload; + ", size=", size, ", nmemb=", nmemb, ", cls=", ResourceDir_, " )"); + ResourceDir *resourceDir = ResourceDir_; + ClsDload *dload = resourceDir->dload; CURL *curl = dload->curl; const size_t buf_len = size * nmemb; @@ -322,7 +315,7 @@ onCurlDirRsp( char*buf, size_t size, size_t nmemb, void*cls_resourceDir_ ){ resourceDir->rspBody_cap = resourceDir->rspBody_len + buf_len + 1024; void *tmp = realloc(resourceDir->rspBody, resourceDir->rspBody_cap); if( tmp == NULL ){ - err = size*nmemb/*TODO could we return anything better here?*/; goto endFn; } + err = size * nmemb/*TODO could we return anything better here?*/; goto endFn; } resourceDir->rspBody = tmp; } memcpy(resourceDir->rspBody+resourceDir->rspBody_len, buf, buf_len); @@ -331,16 +324,15 @@ onCurlDirRsp( char*buf, size_t size, size_t nmemb, void*cls_resourceDir_ ){ // Parsing occurs in the caller, as soon we processed whole response. - err = size*nmemb; + err = size * nmemb; endFn: return err; } -static size_t -onResourceChunk( char*buf, size_t size, size_t nmemb, void*cls_resourceFile_ ){ +static size_t onResourceChunk( char*buf, size_t size, size_t nmemb, void*ResourceFile_ ){ const int buf_len = size * nmemb; - cls_resourceFile_t *resourceFile = cls_resourceFile_; + ResourceFile *resourceFile = ResourceFile_; const int avail = resourceFile->buf_memSz - resourceFile->buf_len; if( avail <= buf_len ){ @@ -358,10 +350,9 @@ onResourceChunk( char*buf, size_t size, size_t nmemb, void*cls_resourceFile_ ){ } -static ssize_t -collectResourceIntoMemory( cls_resourceFile_t*resourceFile, char*url ){ +static ssize_t collectResourceIntoMemory( ResourceFile*resourceFile, char*url ){ ssize_t err; - cls_dload_t *dload = resourceFile->dload; + ClsDload *dload = resourceFile->dload; CURL *curl = dload->curl; err = CURLE_OK!= curl_easy_setopt(curl, CURLOPT_URL, url) @@ -369,7 +360,7 @@ collectResourceIntoMemory( cls_resourceFile_t*resourceFile, char*url ){ || CURLE_OK!= curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, onResourceChunk) || CURLE_OK!= curl_easy_setopt(curl, CURLOPT_WRITEDATA, resourceFile) ; - if( err ){ assert(!err); err=-1; goto endFn; } + if( err ){ assert(!err); err = -1; goto endFn; } err = curl_easy_perform(curl); if( err != CURLE_OK ){ @@ -384,14 +375,13 @@ endFn: } -static ssize_t -copyBufToArchive( cls_resourceFile_t*resourceFile ){ +static ssize_t copyBufToArchive( ResourceFile*resourceFile ){ ssize_t err; - cls_dload_t *dload = resourceFile->dload; + ClsDload *dload = resourceFile->dload; char *fileName = resourceFile->url + strlen(resourceFile->dload->rootUrl); if( ! dload->dstArchive ){ - // Setup archive if not setup yet. + /* Setup archive if not setup yet. */ dload->dstArchive = archive_write_new(); err = archive_write_set_format_pax_restricted(dload->dstArchive) || archive_write_open_filename(dload->dstArchive, dload->archiveFile) @@ -403,7 +393,7 @@ copyBufToArchive( cls_resourceFile_t*resourceFile ){ } } - if( ! dload->tmpEntry ){ + if( dload->tmpEntry == NULL ){ dload->tmpEntry = archive_entry_new(); }else{ dload->tmpEntry = archive_entry_clear(dload->tmpEntry); @@ -413,8 +403,7 @@ copyBufToArchive( cls_resourceFile_t*resourceFile ){ archive_entry_set_size(dload->tmpEntry, resourceFile->buf_len); archive_entry_set_perm(dload->tmpEntry, 0644); err = archive_write_header(dload->dstArchive, dload->tmpEntry); - if( err ){ - err=-1; goto endFn; } + if( err ){ err = -1; goto endFn; } ssize_t written = archive_write_data(dload->dstArchive, resourceFile->buf, resourceFile->buf_len); if( written < 0 ){ @@ -435,18 +424,18 @@ endFn: /** @return 0:Reject, 1:Accept, <0:ERROR */ -static ssize_t pathFilterAcceptsEntry( cls_dload_t*dload, cls_resourceDir_t*resourceDir, const char*nameOrig ){ +static ssize_t pathFilterAcceptsEntry( ClsDload*dload, ResourceDir*resourceDir, const char*nameOrig ){ ssize_t err; - char *name = strdup( nameOrig ); - uint_t name_len = strlen( name ); + char *name = strdup(nameOrig); + uint_t name_len = strlen(name); - if( dload->this->filter ){ + if( dload->resclone->filter ){ // Count parents to find correct regex to apply. uint_t idx = 0; - for( cls_resourceDir_t*it=resourceDir->parentDir ; it ; it=it->parentDir ){ ++idx; } + for( ResourceDir*it=resourceDir->parentDir ; it ; it=it->parentDir ){ ++idx; } // Check if we even have such a long filter at all. - if( idx >= dload->this->filter_len ){ - if( dload->this->isFilterFull ){ + if( idx >= dload->resclone->filter_len ){ + if( dload->resclone->isFilterFull ){ //fprintf(stderr, "%s\n", "[DEBUG] Path longer than --filter-full -> reject."); err = 0; goto endFn; }else{ @@ -455,14 +444,14 @@ static ssize_t pathFilterAcceptsEntry( cls_dload_t*dload, cls_resourceDir_t*reso } } // We have a regex. Setup the check. - bool restoreEndSlash = false; - if( name[name_len-1]=='/' ){ - restoreEndSlash = true; + int restoreEndSlash = 0; + if( name[name_len-1] == '/' ){ + restoreEndSlash = !0; name[name_len-1] = '\0'; } //fprintf(stderr, "%s%u%s%s%s\n", "[DEBUG] idx=", idx," name='", name, "'"); - regex_t *filterArr = dload->this->filter; - regex_t *r = filterArr + (idx); + regex_t *filterArr = dload->resclone->filter; + regex_t *r = filterArr + idx; err = regexec(r, name, 0, 0, 0); if( !err ){ //fprintf(stderr, "%s\n", "[DEBUG] Segment accepted by filter."); @@ -489,14 +478,14 @@ endFn: /** Gets called for every resource to scan/download. * HINT: Gets called recursively. */ -static ssize_t gateleenResclone_download( cls_dload_t*dload , cls_resourceDir_t*parentResourceDir , char*entryName ){ +static ssize_t gateleenResclone_download( ClsDload*dload , ResourceDir*parentResourceDir , char*entryName ){ ssize_t err; char *url = NULL; int url_len = 0; cJSON *jsonRoot = NULL; int resUrl_len = 0; - cls_resourceDir_t *resourceDir = NULL; - cls_resourceFile_t *resourceFile = NULL; + ResourceDir *resourceDir = NULL; + ResourceFile *resourceFile = NULL; if( entryName == NULL ){ /* Is the case when its the root call and not a recursive one */ @@ -504,7 +493,7 @@ static ssize_t gateleenResclone_download( cls_dload_t*dload , cls_resourceDir_t* } // Stack-Alloc resourceDir-closure. - cls_resourceDir_t _1={0}; resourceDir =&_1; + ResourceDir _1 = {0}; resourceDir = &_1; resourceDir->dload = dload; resourceDir->parentDir = parentResourceDir; resourceDir->name = strdup(entryName); @@ -512,13 +501,13 @@ static ssize_t gateleenResclone_download( cls_dload_t*dload , cls_resourceDir_t* // Configure client { url_len = 0; - for( cls_resourceDir_t*d=resourceDir ; d ; d=d->parentDir ){ + for( ResourceDir*d=resourceDir ; d ; d=d->parentDir ){ int len = strlen(d->name) - strspn(d->name, "/"); url_len += len; } url = malloc(url_len +1 /*MayPreventReallocLaterForName*/+24); char *u = url + url_len; - for( cls_resourceDir_t*d=resourceDir ; d ; d=d->parentDir ){ + for( ResourceDir*d=resourceDir ; d ; d=d->parentDir ){ char *name = d->name + strspn(d->name, "/"); int name_len = strlen(name); memcpy(u-name_len, name, name_len); u -= name_len; @@ -574,7 +563,7 @@ static ssize_t gateleenResclone_download( cls_dload_t*dload , cls_resourceDir_t* } // Iterate all the entries we have to process. - cls_resourceFile_t _2 = {0}; resourceFile =&_2; + ResourceFile _2 = {0}; resourceFile =&_2; resourceFile->dload = dload; uint_t iDirEntry = 0; for( cJSON *arrEntry=data->child ; arrEntry!=NULL ; arrEntry=arrEntry->next ){ @@ -588,21 +577,21 @@ static ssize_t gateleenResclone_download( cls_dload_t*dload , cls_resourceDir_t* int name_len = strlen(name); err = pathFilterAcceptsEntry(dload, resourceDir, name); - if( err < 0 ){ // ERROR + if( err < 0 ){ /* ERROR */ goto endFn; - }else if( err == 0 ){ // REJECT + }else if( err == 0 ){ /* REJECT */ fprintf(stderr, "%s%s%s%s\n", "[INFO ] Skip '", url, name, "' (filtered)"); continue; - }else{ // ACCEPT - // Go ahead. + }else{ /* ACCEPT */ + /* Go ahead */ } - if( name[name_len-1] == '/' ){ // Gateleen reports a 'directory' + if( name[name_len-1] == '/' ){ /* Gateleen reports a 'directory' */ //fprintf(stderr, "%s%s%s%s\n", "[DEBUG] Scan '", url, name,"'"); err = gateleenResclone_download(dload, resourceDir, name); if( err ){ goto endFn; } - }else{ // Not a 'dir'? Then assume 'file' + }else{ /* Not a 'dir'? Then assume 'file' */ int requiredLen = url_len + 1/*slash*/ + name_len; if( resUrl_len < requiredLen ){ void *tmp = realloc(resourceFile->url, requiredLen +1); @@ -637,36 +626,36 @@ endFn: } -static void this_free( this_t*this ){ - if( this == NULL ) return; +static void Resclone_free( Resclone*resclone ){ + if( resclone == NULL ) return; // TODO need free? -> char *url; // TODO need free? -> regex_t *filter; // TODO need free? -> char *file; - free(this); + free(resclone); } -static this_t* this_alloc(){ +static Resclone* Resclone_alloc(){ ssize_t err; - this_t *this = NULL; + Resclone *resclone = NULL; err = curl_global_init(CURL_GLOBAL_ALL); if( err ){ assert(!err); goto fail; } - this = calloc(1, sizeof*this); + resclone = calloc(1, sizeof*resclone); - return this; + return resclone; fail: - this_free(this); + Resclone_free(resclone); return NULL; } -static size_t onUploadChunkRequested( char*buf, size_t size, size_t count, void*cls_put_ ){ +static size_t onUploadChunkRequested( char*buf, size_t size, size_t count, void*Put_ ){ int err; - cls_put_t *put = cls_put_; - cls_upload_t *upload = put->upload; + Put *put = Put_; + Upload *upload = put->upload; const size_t buf_len = size * count; ssize_t readLen = archive_read_data(upload->srcArchive, buf, buf_len); @@ -691,10 +680,10 @@ endFn: } -static ssize_t addContentTypeHeader( cls_put_t*put, struct curl_slist *reqHdrs ){ +static ssize_t addContentTypeHeader( Put*put, struct curl_slist *reqHdrs ){ ssize_t err; char *contentTypeHdr = NULL; - cls_upload_t *upload = put->upload; + Upload *upload = put->upload; const char *name = put->name; uint_t name_len = strlen(put->name); @@ -737,9 +726,9 @@ endFn: } -static ssize_t httpPutEntry( cls_put_t*put ){ +static ssize_t httpPutEntry( Put*put ){ ssize_t err; - cls_upload_t *upload = put->upload; + Upload *upload = put->upload; char *url = NULL; struct curl_slist *reqHdrs = NULL; @@ -782,9 +771,9 @@ endFn: } -static ssize_t readArchive( cls_upload_t*upload ){ +static ssize_t readArchive( Upload*upload ){ ssize_t err; - cls_put_t *put = NULL; + Put *put = NULL; upload->srcArchive = archive_read_new(); if( ! upload->srcArchive ){ @@ -816,7 +805,7 @@ static ssize_t readArchive( cls_upload_t*upload ){ continue; } //fprintf(stderr, "%s%s%s\n", "[DEBUG] Reading '",name,"'"); - cls_put_t _1 = { + Put _1 = { .upload = upload, .name = (char*)name }; put = &_1; @@ -833,22 +822,22 @@ endFn: } -static ssize_t pull( this_t*this ){ +static ssize_t pull( Resclone*resclone ){ ssize_t err; - cls_dload_t *dload = NULL; + ClsDload *dload = NULL; - if( this->file == NULL && isatty(1) ){ + if( resclone->file == NULL && isatty(1) ){ fprintf(stderr, "%s\n", "[ERROR] Are you sure you wanna write binary content to tty?"); err = -1; goto endFn; } - cls_dload_t _1 = {0}; dload =&_1; - dload->this = this; - dload->rootUrl = this->url; - dload->archiveFile = this->file; + ClsDload _1 = {0}; dload =&_1; + dload->resclone = resclone; + dload->rootUrl = resclone->url; + dload->archiveFile = resclone->file; dload->curl = curl_easy_init(); - if( ! dload->curl ){ + if( dload->curl == NULL ){ fprintf(stderr, "%s\n", "[ERROR] curl_easy_init() -> NULL"); err = -1; goto endFn; } @@ -874,14 +863,14 @@ endFn: } -static ssize_t push( this_t*this ){ +static ssize_t push( Resclone*resclone ){ ssize_t err; - cls_upload_t *upload = NULL; + Upload *upload = NULL; - cls_upload_t _1={0}; upload =&_1; - upload->this = this; - upload->archiveFile = this->file; - upload->rootUrl = this->url; + Upload _1={0}; upload =&_1; + upload->resclone = resclone; + upload->archiveFile = resclone->file; + upload->rootUrl = resclone->url; upload->curl = curl_easy_init(); if( ! upload->curl ){ fprintf(stderr, "%s\n", "[ERROR] curl_easy_init() -> NULL"); @@ -904,31 +893,31 @@ endFn: ssize_t gateleenResclone_run( int argc, char**argv ){ ssize_t err; - this_t *this = NULL; + Resclone *resclone = NULL; - this = this_alloc(); - if( this == NULL ){ + resclone = Resclone_alloc(); + if( resclone == NULL ){ err = -1; goto endFn; } - err = parseArgs(argc, argv, &this->mode, &this->url, &this->filter, - &this->filter_len, &this->isFilterFull, &this->file); + err = parseArgs(argc, argv, &resclone->mode, &resclone->url, &resclone->filter, + &resclone->filter_len, &resclone->isFilterFull, &resclone->file); if( err ){ err = -1; goto endFn; } - if( this->mode == MODE_FETCH ){ - err = pull(this); goto endFn; - }else if( this->mode == MODE_PUSH ){ - err = push(this); goto endFn; + if( resclone->mode == MODE_FETCH ){ + err = pull(resclone); goto endFn; + }else if( resclone->mode == MODE_PUSH ){ + err = push(resclone); goto endFn; }else{ err = -1; goto endFn; } assert(!"Unreachable"); endFn: - parseArgs(-1, argv, &this->mode, &this->url, &this->filter, &this->filter_len, - &this->isFilterFull, &this->file); - this->mode = MODE_NULL; this->url = NULL; this->file = NULL; - this_free(this); + parseArgs(-1, argv, &resclone->mode, &resclone->url, &resclone->filter, &resclone->filter_len, + &resclone->isFilterFull, &resclone->file); + resclone->mode = MODE_NULL; resclone->url = NULL; resclone->file = NULL; + Resclone_free(resclone); return err; } -- cgit v1.1