diff --git a/lib/ftplistparser.c b/lib/ftplistparser.c deleted file mode 100644 index 716ff381727a249ae8c3a8bbfa2c5ae3c745445c..0000000000000000000000000000000000000000 --- a/lib/ftplistparser.c +++ /dev/null @@ -1,1018 +0,0 @@ -/*************************************************************************** - * _ _ ____ _ - * Project ___| | | | _ \| | - * / __| | | | |_) | | - * | (__| |_| | _ <| |___ - * \___|\___/|_| \_\_____| - * - * Copyright (C) 1998 - 2021, Daniel Stenberg, , et al. - * - * This software is licensed as described in the file COPYING, which - * you should have received as part of this distribution. The terms - * are also available at https://curl.se/docs/copyright.html. - * - * You may opt to use, copy, modify, merge, publish, distribute and/or sell - * copies of the Software, and permit persons to whom the Software is - * furnished to do so, under the terms of the COPYING file. - * - * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY - * KIND, either express or implied. - * - ***************************************************************************/ - -/** - * Now implemented: - * - * 1) Unix version 1 - * drwxr-xr-x 1 user01 ftp 512 Jan 29 23:32 prog - * 2) Unix version 2 - * drwxr-xr-x 1 user01 ftp 512 Jan 29 1997 prog - * 3) Unix version 3 - * drwxr-xr-x 1 1 1 512 Jan 29 23:32 prog - * 4) Unix symlink - * lrwxr-xr-x 1 user01 ftp 512 Jan 29 23:32 prog -> prog2000 - * 5) DOS style - * 01-29-97 11:32PM prog - */ - -#include "curl_setup.h" - -#ifndef CURL_DISABLE_FTP - -#include - -#include "urldata.h" -#include "fileinfo.h" -#include "llist.h" -#include "strtoofft.h" -#include "ftp.h" -#include "ftplistparser.h" -#include "curl_fnmatch.h" -#include "curl_memory.h" -#include "multiif.h" -/* The last #include file should be: */ -#include "memdebug.h" - -/* allocs buffer which will contain one line of LIST command response */ -#define FTP_BUFFER_ALLOCSIZE 160 - -typedef enum { - PL_UNIX_TOTALSIZE = 0, - PL_UNIX_FILETYPE, - PL_UNIX_PERMISSION, - PL_UNIX_HLINKS, - PL_UNIX_USER, - PL_UNIX_GROUP, - PL_UNIX_SIZE, - PL_UNIX_TIME, - PL_UNIX_FILENAME, - PL_UNIX_SYMLINK -} pl_unix_mainstate; - -typedef union { - enum { - PL_UNIX_TOTALSIZE_INIT = 0, - PL_UNIX_TOTALSIZE_READING - } total_dirsize; - - enum { - PL_UNIX_HLINKS_PRESPACE = 0, - PL_UNIX_HLINKS_NUMBER - } hlinks; - - enum { - PL_UNIX_USER_PRESPACE = 0, - PL_UNIX_USER_PARSING - } user; - - enum { - PL_UNIX_GROUP_PRESPACE = 0, - PL_UNIX_GROUP_NAME - } group; - - enum { - PL_UNIX_SIZE_PRESPACE = 0, - PL_UNIX_SIZE_NUMBER - } size; - - enum { - PL_UNIX_TIME_PREPART1 = 0, - PL_UNIX_TIME_PART1, - PL_UNIX_TIME_PREPART2, - PL_UNIX_TIME_PART2, - PL_UNIX_TIME_PREPART3, - PL_UNIX_TIME_PART3 - } time; - - enum { - PL_UNIX_FILENAME_PRESPACE = 0, - PL_UNIX_FILENAME_NAME, - PL_UNIX_FILENAME_WINDOWSEOL - } filename; - - enum { - PL_UNIX_SYMLINK_PRESPACE = 0, - PL_UNIX_SYMLINK_NAME, - PL_UNIX_SYMLINK_PRETARGET1, - PL_UNIX_SYMLINK_PRETARGET2, - PL_UNIX_SYMLINK_PRETARGET3, - PL_UNIX_SYMLINK_PRETARGET4, - PL_UNIX_SYMLINK_TARGET, - PL_UNIX_SYMLINK_WINDOWSEOL - } symlink; -} pl_unix_substate; - -typedef enum { - PL_WINNT_DATE = 0, - PL_WINNT_TIME, - PL_WINNT_DIRORSIZE, - PL_WINNT_FILENAME -} pl_winNT_mainstate; - -typedef union { - enum { - PL_WINNT_TIME_PRESPACE = 0, - PL_WINNT_TIME_TIME - } time; - enum { - PL_WINNT_DIRORSIZE_PRESPACE = 0, - PL_WINNT_DIRORSIZE_CONTENT - } dirorsize; - enum { - PL_WINNT_FILENAME_PRESPACE = 0, - PL_WINNT_FILENAME_CONTENT, - PL_WINNT_FILENAME_WINEOL - } filename; -} pl_winNT_substate; - -/* This struct is used in wildcard downloading - for parsing LIST response */ -struct ftp_parselist_data { - enum { - OS_TYPE_UNKNOWN = 0, - OS_TYPE_UNIX, - OS_TYPE_WIN_NT - } os_type; - - union { - struct { - pl_unix_mainstate main; - pl_unix_substate sub; - } UNIX; - - struct { - pl_winNT_mainstate main; - pl_winNT_substate sub; - } NT; - } state; - - CURLcode error; - struct fileinfo *file_data; - unsigned int item_length; - size_t item_offset; - struct { - size_t filename; - size_t user; - size_t group; - size_t time; - size_t perm; - size_t symlink_target; - } offsets; -}; - -struct ftp_parselist_data *Curl_ftp_parselist_data_alloc(void) -{ - return calloc(1, sizeof(struct ftp_parselist_data)); -} - - -void Curl_ftp_parselist_data_free(struct ftp_parselist_data **parserp) -{ - struct ftp_parselist_data *parser = *parserp; - if(parser) - Curl_fileinfo_cleanup(parser->file_data); - free(parser); - *parserp = NULL; -} - - -CURLcode Curl_ftp_parselist_geterror(struct ftp_parselist_data *pl_data) -{ - return pl_data->error; -} - - -#define FTP_LP_MALFORMATED_PERM 0x01000000 - -static int ftp_pl_get_permission(const char *str) -{ - int permissions = 0; - /* USER */ - if(str[0] == 'r') - permissions |= 1 << 8; - else if(str[0] != '-') - permissions |= FTP_LP_MALFORMATED_PERM; - if(str[1] == 'w') - permissions |= 1 << 7; - else if(str[1] != '-') - permissions |= FTP_LP_MALFORMATED_PERM; - - if(str[2] == 'x') - permissions |= 1 << 6; - else if(str[2] == 's') { - permissions |= 1 << 6; - permissions |= 1 << 11; - } - else if(str[2] == 'S') - permissions |= 1 << 11; - else if(str[2] != '-') - permissions |= FTP_LP_MALFORMATED_PERM; - /* GROUP */ - if(str[3] == 'r') - permissions |= 1 << 5; - else if(str[3] != '-') - permissions |= FTP_LP_MALFORMATED_PERM; - if(str[4] == 'w') - permissions |= 1 << 4; - else if(str[4] != '-') - permissions |= FTP_LP_MALFORMATED_PERM; - if(str[5] == 'x') - permissions |= 1 << 3; - else if(str[5] == 's') { - permissions |= 1 << 3; - permissions |= 1 << 10; - } - else if(str[5] == 'S') - permissions |= 1 << 10; - else if(str[5] != '-') - permissions |= FTP_LP_MALFORMATED_PERM; - /* others */ - if(str[6] == 'r') - permissions |= 1 << 2; - else if(str[6] != '-') - permissions |= FTP_LP_MALFORMATED_PERM; - if(str[7] == 'w') - permissions |= 1 << 1; - else if(str[7] != '-') - permissions |= FTP_LP_MALFORMATED_PERM; - if(str[8] == 'x') - permissions |= 1; - else if(str[8] == 't') { - permissions |= 1; - permissions |= 1 << 9; - } - else if(str[8] == 'T') - permissions |= 1 << 9; - else if(str[8] != '-') - permissions |= FTP_LP_MALFORMATED_PERM; - - return permissions; -} - -static CURLcode ftp_pl_insert_finfo(struct Curl_easy *data, - struct fileinfo *infop) -{ - curl_fnmatch_callback compare; - struct WildcardData *wc = &data->wildcard; - struct ftp_wc *ftpwc = wc->protdata; - struct Curl_llist *llist = &wc->filelist; - struct ftp_parselist_data *parser = ftpwc->parser; - bool add = TRUE; - struct curl_fileinfo *finfo = &infop->info; - - /* move finfo pointers to b_data */ - char *str = finfo->b_data; - finfo->filename = str + parser->offsets.filename; - finfo->strings.group = parser->offsets.group ? - str + parser->offsets.group : NULL; - finfo->strings.perm = parser->offsets.perm ? - str + parser->offsets.perm : NULL; - finfo->strings.target = parser->offsets.symlink_target ? - str + parser->offsets.symlink_target : NULL; - finfo->strings.time = str + parser->offsets.time; - finfo->strings.user = parser->offsets.user ? - str + parser->offsets.user : NULL; - - /* get correct fnmatch callback */ - compare = data->set.fnmatch; - if(!compare) - compare = Curl_fnmatch; - - /* filter pattern-corresponding filenames */ - Curl_set_in_callback(data, true); - if(compare(data->set.fnmatch_data, wc->pattern, - finfo->filename) == 0) { - /* discard symlink which is containing multiple " -> " */ - if((finfo->filetype == CURLFILETYPE_SYMLINK) && finfo->strings.target && - (strstr(finfo->strings.target, " -> "))) { - add = FALSE; - } - } - else { - add = FALSE; - } - Curl_set_in_callback(data, false); - - if(add) { - Curl_llist_insert_next(llist, llist->tail, finfo, &infop->list); - } - else { - Curl_fileinfo_cleanup(infop); - } - - ftpwc->parser->file_data = NULL; - return CURLE_OK; -} - -size_t Curl_ftp_parselist(char *buffer, size_t size, size_t nmemb, - void *connptr) -{ - size_t bufflen = size*nmemb; - struct Curl_easy *data = (struct Curl_easy *)connptr; - struct ftp_wc *ftpwc = data->wildcard.protdata; - struct ftp_parselist_data *parser = ftpwc->parser; - struct fileinfo *infop; - struct curl_fileinfo *finfo; - unsigned long i = 0; - CURLcode result; - size_t retsize = bufflen; - - if(parser->error) { /* error in previous call */ - /* scenario: - * 1. call => OK.. - * 2. call => OUT_OF_MEMORY (or other error) - * 3. (last) call => is skipped RIGHT HERE and the error is hadled later - * in wc_statemach() - */ - goto fail; - } - - if(parser->os_type == OS_TYPE_UNKNOWN && bufflen > 0) { - /* considering info about FILE response format */ - parser->os_type = (buffer[0] >= '0' && buffer[0] <= '9') ? - OS_TYPE_WIN_NT : OS_TYPE_UNIX; - } - - while(i < bufflen) { /* FSM */ - - char c = buffer[i]; - if(!parser->file_data) { /* tmp file data is not allocated yet */ - parser->file_data = Curl_fileinfo_alloc(); - if(!parser->file_data) { - parser->error = CURLE_OUT_OF_MEMORY; - goto fail; - } - parser->file_data->info.b_data = malloc(FTP_BUFFER_ALLOCSIZE); - if(!parser->file_data->info.b_data) { - parser->error = CURLE_OUT_OF_MEMORY; - goto fail; - } - parser->file_data->info.b_size = FTP_BUFFER_ALLOCSIZE; - parser->item_offset = 0; - parser->item_length = 0; - } - - infop = parser->file_data; - finfo = &infop->info; - finfo->b_data[finfo->b_used++] = c; - - if(finfo->b_used >= finfo->b_size - 1) { - /* if it is important, extend buffer space for file data */ - char *tmp = realloc(finfo->b_data, - finfo->b_size + FTP_BUFFER_ALLOCSIZE); - if(tmp) { - finfo->b_size += FTP_BUFFER_ALLOCSIZE; - finfo->b_data = tmp; - } - else { - Curl_fileinfo_cleanup(parser->file_data); - parser->file_data = NULL; - parser->error = CURLE_OUT_OF_MEMORY; - goto fail; - } - } - - switch(parser->os_type) { - case OS_TYPE_UNIX: - switch(parser->state.UNIX.main) { - case PL_UNIX_TOTALSIZE: - switch(parser->state.UNIX.sub.total_dirsize) { - case PL_UNIX_TOTALSIZE_INIT: - if(c == 't') { - parser->state.UNIX.sub.total_dirsize = PL_UNIX_TOTALSIZE_READING; - parser->item_length++; - } - else { - parser->state.UNIX.main = PL_UNIX_FILETYPE; - /* start FSM again not considering size of directory */ - finfo->b_used = 0; - continue; - } - break; - case PL_UNIX_TOTALSIZE_READING: - parser->item_length++; - if(c == '\r') { - parser->item_length--; - finfo->b_used--; - } - else if(c == '\n') { - finfo->b_data[parser->item_length - 1] = 0; - if(strncmp("total ", finfo->b_data, 6) == 0) { - char *endptr = finfo->b_data + 6; - /* here we can deal with directory size, pass the leading - whitespace and then the digits */ - while(ISSPACE(*endptr)) - endptr++; - while(ISDIGIT(*endptr)) - endptr++; - if(*endptr) { - parser->error = CURLE_FTP_BAD_FILE_LIST; - goto fail; - } - parser->state.UNIX.main = PL_UNIX_FILETYPE; - finfo->b_used = 0; - } - else { - parser->error = CURLE_FTP_BAD_FILE_LIST; - goto fail; - } - } - break; - } - break; - case PL_UNIX_FILETYPE: - switch(c) { - case '-': - finfo->filetype = CURLFILETYPE_FILE; - break; - case 'd': - finfo->filetype = CURLFILETYPE_DIRECTORY; - break; - case 'l': - finfo->filetype = CURLFILETYPE_SYMLINK; - break; - case 'p': - finfo->filetype = CURLFILETYPE_NAMEDPIPE; - break; - case 's': - finfo->filetype = CURLFILETYPE_SOCKET; - break; - case 'c': - finfo->filetype = CURLFILETYPE_DEVICE_CHAR; - break; - case 'b': - finfo->filetype = CURLFILETYPE_DEVICE_BLOCK; - break; - case 'D': - finfo->filetype = CURLFILETYPE_DOOR; - break; - default: - parser->error = CURLE_FTP_BAD_FILE_LIST; - goto fail; - } - parser->state.UNIX.main = PL_UNIX_PERMISSION; - parser->item_length = 0; - parser->item_offset = 1; - break; - case PL_UNIX_PERMISSION: - parser->item_length++; - if(parser->item_length <= 9) { - if(!strchr("rwx-tTsS", c)) { - parser->error = CURLE_FTP_BAD_FILE_LIST; - goto fail; - } - } - else if(parser->item_length == 10) { - unsigned int perm; - if(c != ' ') { - parser->error = CURLE_FTP_BAD_FILE_LIST; - goto fail; - } - finfo->b_data[10] = 0; /* terminate permissions */ - perm = ftp_pl_get_permission(finfo->b_data + parser->item_offset); - if(perm & FTP_LP_MALFORMATED_PERM) { - parser->error = CURLE_FTP_BAD_FILE_LIST; - goto fail; - } - parser->file_data->info.flags |= CURLFINFOFLAG_KNOWN_PERM; - parser->file_data->info.perm = perm; - parser->offsets.perm = parser->item_offset; - - parser->item_length = 0; - parser->state.UNIX.main = PL_UNIX_HLINKS; - parser->state.UNIX.sub.hlinks = PL_UNIX_HLINKS_PRESPACE; - } - break; - case PL_UNIX_HLINKS: - switch(parser->state.UNIX.sub.hlinks) { - case PL_UNIX_HLINKS_PRESPACE: - if(c != ' ') { - if(c >= '0' && c <= '9') { - parser->item_offset = finfo->b_used - 1; - parser->item_length = 1; - parser->state.UNIX.sub.hlinks = PL_UNIX_HLINKS_NUMBER; - } - else { - parser->error = CURLE_FTP_BAD_FILE_LIST; - goto fail; - } - } - break; - case PL_UNIX_HLINKS_NUMBER: - parser->item_length ++; - if(c == ' ') { - char *p; - long int hlinks; - finfo->b_data[parser->item_offset + parser->item_length - 1] = 0; - hlinks = strtol(finfo->b_data + parser->item_offset, &p, 10); - if(p[0] == '\0' && hlinks != LONG_MAX && hlinks != LONG_MIN) { - parser->file_data->info.flags |= CURLFINFOFLAG_KNOWN_HLINKCOUNT; - parser->file_data->info.hardlinks = hlinks; - } - parser->item_length = 0; - parser->item_offset = 0; - parser->state.UNIX.main = PL_UNIX_USER; - parser->state.UNIX.sub.user = PL_UNIX_USER_PRESPACE; - } - else if(c < '0' || c > '9') { - parser->error = CURLE_FTP_BAD_FILE_LIST; - goto fail; - } - break; - } - break; - case PL_UNIX_USER: - switch(parser->state.UNIX.sub.user) { - case PL_UNIX_USER_PRESPACE: - if(c != ' ') { - parser->item_offset = finfo->b_used - 1; - parser->item_length = 1; - parser->state.UNIX.sub.user = PL_UNIX_USER_PARSING; - } - break; - case PL_UNIX_USER_PARSING: - parser->item_length++; - if(c == ' ') { - finfo->b_data[parser->item_offset + parser->item_length - 1] = 0; - parser->offsets.user = parser->item_offset; - parser->state.UNIX.main = PL_UNIX_GROUP; - parser->state.UNIX.sub.group = PL_UNIX_GROUP_PRESPACE; - parser->item_offset = 0; - parser->item_length = 0; - } - break; - } - break; - case PL_UNIX_GROUP: - switch(parser->state.UNIX.sub.group) { - case PL_UNIX_GROUP_PRESPACE: - if(c != ' ') { - parser->item_offset = finfo->b_used - 1; - parser->item_length = 1; - parser->state.UNIX.sub.group = PL_UNIX_GROUP_NAME; - } - break; - case PL_UNIX_GROUP_NAME: - parser->item_length++; - if(c == ' ') { - finfo->b_data[parser->item_offset + parser->item_length - 1] = 0; - parser->offsets.group = parser->item_offset; - parser->state.UNIX.main = PL_UNIX_SIZE; - parser->state.UNIX.sub.size = PL_UNIX_SIZE_PRESPACE; - parser->item_offset = 0; - parser->item_length = 0; - } - break; - } - break; - case PL_UNIX_SIZE: - switch(parser->state.UNIX.sub.size) { - case PL_UNIX_SIZE_PRESPACE: - if(c != ' ') { - if(c >= '0' && c <= '9') { - parser->item_offset = finfo->b_used - 1; - parser->item_length = 1; - parser->state.UNIX.sub.size = PL_UNIX_SIZE_NUMBER; - } - else { - parser->error = CURLE_FTP_BAD_FILE_LIST; - goto fail; - } - } - break; - case PL_UNIX_SIZE_NUMBER: - parser->item_length++; - if(c == ' ') { - char *p; - curl_off_t fsize; - finfo->b_data[parser->item_offset + parser->item_length - 1] = 0; - if(!curlx_strtoofft(finfo->b_data + parser->item_offset, - &p, 10, &fsize)) { - if(p[0] == '\0' && fsize != CURL_OFF_T_MAX && - fsize != CURL_OFF_T_MIN) { - parser->file_data->info.flags |= CURLFINFOFLAG_KNOWN_SIZE; - parser->file_data->info.size = fsize; - } - parser->item_length = 0; - parser->item_offset = 0; - parser->state.UNIX.main = PL_UNIX_TIME; - parser->state.UNIX.sub.time = PL_UNIX_TIME_PREPART1; - } - } - else if(!ISDIGIT(c)) { - parser->error = CURLE_FTP_BAD_FILE_LIST; - goto fail; - } - break; - } - break; - case PL_UNIX_TIME: - switch(parser->state.UNIX.sub.time) { - case PL_UNIX_TIME_PREPART1: - if(c != ' ') { - if(ISALNUM(c)) { - parser->item_offset = finfo->b_used -1; - parser->item_length = 1; - parser->state.UNIX.sub.time = PL_UNIX_TIME_PART1; - } - else { - parser->error = CURLE_FTP_BAD_FILE_LIST; - goto fail; - } - } - break; - case PL_UNIX_TIME_PART1: - parser->item_length++; - if(c == ' ') { - parser->state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; - } - else if(!ISALNUM(c) && c != '.') { - parser->error = CURLE_FTP_BAD_FILE_LIST; - goto fail; - } - break; - case PL_UNIX_TIME_PREPART2: - parser->item_length++; - if(c != ' ') { - if(ISALNUM(c)) { - parser->state.UNIX.sub.time = PL_UNIX_TIME_PART2; - } - else { - parser->error = CURLE_FTP_BAD_FILE_LIST; - goto fail; - } - } - break; - case PL_UNIX_TIME_PART2: - parser->item_length++; - if(c == ' ') { - parser->state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; - } - else if(!ISALNUM(c) && c != '.') { - parser->error = CURLE_FTP_BAD_FILE_LIST; - goto fail; - } - break; - case PL_UNIX_TIME_PREPART3: - parser->item_length++; - if(c != ' ') { - if(ISALNUM(c)) { - parser->state.UNIX.sub.time = PL_UNIX_TIME_PART3; - } - else { - parser->error = CURLE_FTP_BAD_FILE_LIST; - goto fail; - } - } - break; - case PL_UNIX_TIME_PART3: - parser->item_length++; - if(c == ' ') { - finfo->b_data[parser->item_offset + parser->item_length -1] = 0; - parser->offsets.time = parser->item_offset; - /* - if(ftp_pl_gettime(parser, finfo->b_data + parser->item_offset)) { - parser->file_data->flags |= CURLFINFOFLAG_KNOWN_TIME; - } - */ - if(finfo->filetype == CURLFILETYPE_SYMLINK) { - parser->state.UNIX.main = PL_UNIX_SYMLINK; - parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; - } - else { - parser->state.UNIX.main = PL_UNIX_FILENAME; - parser->state.UNIX.sub.filename = PL_UNIX_FILENAME_PRESPACE; - } - } - else if(!ISALNUM(c) && c != '.' && c != ':') { - parser->error = CURLE_FTP_BAD_FILE_LIST; - goto fail; - } - break; - } - break; - case PL_UNIX_FILENAME: - switch(parser->state.UNIX.sub.filename) { - case PL_UNIX_FILENAME_PRESPACE: - if(c != ' ') { - parser->item_offset = finfo->b_used - 1; - parser->item_length = 1; - parser->state.UNIX.sub.filename = PL_UNIX_FILENAME_NAME; - } - break; - case PL_UNIX_FILENAME_NAME: - parser->item_length++; - if(c == '\r') { - parser->state.UNIX.sub.filename = PL_UNIX_FILENAME_WINDOWSEOL; - } - else if(c == '\n') { - finfo->b_data[parser->item_offset + parser->item_length - 1] = 0; - parser->offsets.filename = parser->item_offset; - parser->state.UNIX.main = PL_UNIX_FILETYPE; - result = ftp_pl_insert_finfo(data, infop); - if(result) { - parser->error = result; - goto fail; - } - } - break; - case PL_UNIX_FILENAME_WINDOWSEOL: - if(c == '\n') { - finfo->b_data[parser->item_offset + parser->item_length - 1] = 0; - parser->offsets.filename = parser->item_offset; - parser->state.UNIX.main = PL_UNIX_FILETYPE; - result = ftp_pl_insert_finfo(data, infop); - if(result) { - parser->error = result; - goto fail; - } - } - else { - parser->error = CURLE_FTP_BAD_FILE_LIST; - goto fail; - } - break; - } - break; - case PL_UNIX_SYMLINK: - switch(parser->state.UNIX.sub.symlink) { - case PL_UNIX_SYMLINK_PRESPACE: - if(c != ' ') { - parser->item_offset = finfo->b_used - 1; - parser->item_length = 1; - parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; - } - break; - case PL_UNIX_SYMLINK_NAME: - parser->item_length++; - if(c == ' ') { - parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRETARGET1; - } - else if(c == '\r' || c == '\n') { - parser->error = CURLE_FTP_BAD_FILE_LIST; - goto fail; - } - break; - case PL_UNIX_SYMLINK_PRETARGET1: - parser->item_length++; - if(c == '-') { - parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRETARGET2; - } - else if(c == '\r' || c == '\n') { - parser->error = CURLE_FTP_BAD_FILE_LIST; - goto fail; - } - else { - parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; - } - break; - case PL_UNIX_SYMLINK_PRETARGET2: - parser->item_length++; - if(c == '>') { - parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRETARGET3; - } - else if(c == '\r' || c == '\n') { - parser->error = CURLE_FTP_BAD_FILE_LIST; - goto fail; - } - else { - parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; - } - break; - case PL_UNIX_SYMLINK_PRETARGET3: - parser->item_length++; - if(c == ' ') { - parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRETARGET4; - /* now place where is symlink following */ - finfo->b_data[parser->item_offset + parser->item_length - 4] = 0; - parser->offsets.filename = parser->item_offset; - parser->item_length = 0; - parser->item_offset = 0; - } - else if(c == '\r' || c == '\n') { - parser->error = CURLE_FTP_BAD_FILE_LIST; - goto fail; - } - else { - parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; - } - break; - case PL_UNIX_SYMLINK_PRETARGET4: - if(c != '\r' && c != '\n') { - parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; - parser->item_offset = finfo->b_used - 1; - parser->item_length = 1; - } - else { - parser->error = CURLE_FTP_BAD_FILE_LIST; - goto fail; - } - break; - case PL_UNIX_SYMLINK_TARGET: - parser->item_length++; - if(c == '\r') { - parser->state.UNIX.sub.symlink = PL_UNIX_SYMLINK_WINDOWSEOL; - } - else if(c == '\n') { - finfo->b_data[parser->item_offset + parser->item_length - 1] = 0; - parser->offsets.symlink_target = parser->item_offset; - result = ftp_pl_insert_finfo(data, infop); - if(result) { - parser->error = result; - goto fail; - } - parser->state.UNIX.main = PL_UNIX_FILETYPE; - } - break; - case PL_UNIX_SYMLINK_WINDOWSEOL: - if(c == '\n') { - finfo->b_data[parser->item_offset + parser->item_length - 1] = 0; - parser->offsets.symlink_target = parser->item_offset; - result = ftp_pl_insert_finfo(data, infop); - if(result) { - parser->error = result; - goto fail; - } - parser->state.UNIX.main = PL_UNIX_FILETYPE; - } - else { - parser->error = CURLE_FTP_BAD_FILE_LIST; - goto fail; - } - break; - } - break; - } - break; - case OS_TYPE_WIN_NT: - switch(parser->state.NT.main) { - case PL_WINNT_DATE: - parser->item_length++; - if(parser->item_length < 9) { - if(!strchr("0123456789-", c)) { /* only simple control */ - parser->error = CURLE_FTP_BAD_FILE_LIST; - goto fail; - } - } - else if(parser->item_length == 9) { - if(c == ' ') { - parser->state.NT.main = PL_WINNT_TIME; - parser->state.NT.sub.time = PL_WINNT_TIME_PRESPACE; - } - else { - parser->error = CURLE_FTP_BAD_FILE_LIST; - goto fail; - } - } - else { - parser->error = CURLE_FTP_BAD_FILE_LIST; - goto fail; - } - break; - case PL_WINNT_TIME: - parser->item_length++; - switch(parser->state.NT.sub.time) { - case PL_WINNT_TIME_PRESPACE: - if(!ISSPACE(c)) { - parser->state.NT.sub.time = PL_WINNT_TIME_TIME; - } - break; - case PL_WINNT_TIME_TIME: - if(c == ' ') { - parser->offsets.time = parser->item_offset; - finfo->b_data[parser->item_offset + parser->item_length -1] = 0; - parser->state.NT.main = PL_WINNT_DIRORSIZE; - parser->state.NT.sub.dirorsize = PL_WINNT_DIRORSIZE_PRESPACE; - parser->item_length = 0; - } - else if(!strchr("APM0123456789:", c)) { - parser->error = CURLE_FTP_BAD_FILE_LIST; - goto fail; - } - break; - } - break; - case PL_WINNT_DIRORSIZE: - switch(parser->state.NT.sub.dirorsize) { - case PL_WINNT_DIRORSIZE_PRESPACE: - if(c != ' ') { - parser->item_offset = finfo->b_used - 1; - parser->item_length = 1; - parser->state.NT.sub.dirorsize = PL_WINNT_DIRORSIZE_CONTENT; - } - break; - case PL_WINNT_DIRORSIZE_CONTENT: - parser->item_length ++; - if(c == ' ') { - finfo->b_data[parser->item_offset + parser->item_length - 1] = 0; - if(strcmp("", finfo->b_data + parser->item_offset) == 0) { - finfo->filetype = CURLFILETYPE_DIRECTORY; - finfo->size = 0; - } - else { - char *endptr; - if(curlx_strtoofft(finfo->b_data + - parser->item_offset, - &endptr, 10, &finfo->size)) { - parser->error = CURLE_FTP_BAD_FILE_LIST; - goto fail; - } - /* correct file type */ - parser->file_data->info.filetype = CURLFILETYPE_FILE; - } - - parser->file_data->info.flags |= CURLFINFOFLAG_KNOWN_SIZE; - parser->item_length = 0; - parser->state.NT.main = PL_WINNT_FILENAME; - parser->state.NT.sub.filename = PL_WINNT_FILENAME_PRESPACE; - } - break; - } - break; - case PL_WINNT_FILENAME: - switch(parser->state.NT.sub.filename) { - case PL_WINNT_FILENAME_PRESPACE: - if(c != ' ') { - parser->item_offset = finfo->b_used -1; - parser->item_length = 1; - parser->state.NT.sub.filename = PL_WINNT_FILENAME_CONTENT; - } - break; - case PL_WINNT_FILENAME_CONTENT: - parser->item_length++; - if(c == '\r') { - parser->state.NT.sub.filename = PL_WINNT_FILENAME_WINEOL; - finfo->b_data[finfo->b_used - 1] = 0; - } - else if(c == '\n') { - parser->offsets.filename = parser->item_offset; - finfo->b_data[finfo->b_used - 1] = 0; - result = ftp_pl_insert_finfo(data, infop); - if(result) { - parser->error = result; - goto fail; - } - parser->state.NT.main = PL_WINNT_DATE; - parser->state.NT.sub.filename = PL_WINNT_FILENAME_PRESPACE; - } - break; - case PL_WINNT_FILENAME_WINEOL: - if(c == '\n') { - parser->offsets.filename = parser->item_offset; - result = ftp_pl_insert_finfo(data, infop); - if(result) { - parser->error = result; - goto fail; - } - parser->state.NT.main = PL_WINNT_DATE; - parser->state.NT.sub.filename = PL_WINNT_FILENAME_PRESPACE; - } - else { - parser->error = CURLE_FTP_BAD_FILE_LIST; - goto fail; - } - break; - } - break; - } - break; - default: - retsize = bufflen + 1; - goto fail; - } - - i++; - } - return retsize; - -fail: - - /* Clean up any allocated memory. */ - if(parser->file_data) { - Curl_fileinfo_cleanup(parser->file_data); - parser->file_data = NULL; - } - - return retsize; -} - -#endif /* CURL_DISABLE_FTP */ diff --git a/lib/ftplistparser.rs b/lib/ftplistparser.rs new file mode 100644 index 0000000000000000000000000000000000000000..2d5a00fec0dfc3598f505def13c6157dae44aa7a --- /dev/null +++ b/lib/ftplistparser.rs @@ -0,0 +1,31510 @@ +#![allow(dead_code, mutable_transmutes, non_camel_case_types, non_snake_case, non_upper_case_globals, unused_assignments, unused_mut)] +#![register_tool(c2rust)] +#![feature(extern_types, register_tool)] +extern "C" { + pub type _IO_wide_data; + pub type _IO_codecvt; + pub type _IO_marker; + pub type Curl_URL; + pub type thread_data; + pub type altsvcinfo; + pub type hsts; + pub type TELNET; + pub type smb_request; + pub type ldapreqinfo; + pub type contenc_writer; + pub type psl_ctx_st; + pub type Curl_share; + pub type curl_pushheaders; + pub type http_connect_state; + pub type ldapconninfo; + pub type tftp_state_data; + pub type nghttp2_session; + pub type ssl_backend_data; + fn Curl_isalnum(c: libc::c_int) -> libc::c_int; + fn Curl_isdigit(c: libc::c_int) -> libc::c_int; + fn Curl_isspace(c: libc::c_int) -> libc::c_int; + fn strtol( + _: *const libc::c_char, + _: *mut *mut libc::c_char, + _: libc::c_int, + ) -> libc::c_long; + fn strcmp(_: *const libc::c_char, _: *const libc::c_char) -> libc::c_int; + fn strncmp( + _: *const libc::c_char, + _: *const libc::c_char, + _: libc::c_ulong, + ) -> libc::c_int; + fn strchr(_: *const libc::c_char, _: libc::c_int) -> *mut libc::c_char; + fn strstr(_: *const libc::c_char, _: *const libc::c_char) -> *mut libc::c_char; + fn Curl_llist_insert_next( + _: *mut Curl_llist, + _: *mut Curl_llist_element, + _: *const libc::c_void, + node: *mut Curl_llist_element, + ); + fn Curl_fileinfo_alloc() -> *mut fileinfo; + fn Curl_fileinfo_cleanup(finfo: *mut fileinfo); + fn curlx_strtoofft( + str: *const libc::c_char, + endp: *mut *mut libc::c_char, + base: libc::c_int, + num: *mut curl_off_t, + ) -> CURLofft; + fn Curl_fnmatch( + ptr: *mut libc::c_void, + pattern: *const libc::c_char, + string: *const libc::c_char, + ) -> libc::c_int; + static mut Curl_cmalloc: curl_malloc_callback; + static mut Curl_cfree: curl_free_callback; + static mut Curl_crealloc: curl_realloc_callback; + static mut Curl_ccalloc: curl_calloc_callback; + fn Curl_set_in_callback(data: *mut Curl_easy, value: bool); +} +pub type __uint8_t = libc::c_uchar; +pub type __int32_t = libc::c_int; +pub type __uint32_t = libc::c_uint; +pub type __off_t = libc::c_long; +pub type __off64_t = libc::c_long; +pub type __pid_t = libc::c_int; +pub type __time_t = libc::c_long; +pub type __ssize_t = libc::c_long; +pub type __socklen_t = libc::c_uint; +pub type pid_t = __pid_t; +pub type ssize_t = __ssize_t; +pub type time_t = __time_t; +pub type size_t = libc::c_ulong; +pub type int32_t = __int32_t; +pub type socklen_t = __socklen_t; +pub type sa_family_t = libc::c_ushort; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct sockaddr { + pub sa_family: sa_family_t, + pub sa_data: [libc::c_char; 14], +} +pub type curl_socklen_t = socklen_t; +pub type curl_off_t = libc::c_long; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct _IO_FILE { + pub _flags: libc::c_int, + pub _IO_read_ptr: *mut libc::c_char, + pub _IO_read_end: *mut libc::c_char, + pub _IO_read_base: *mut libc::c_char, + pub _IO_write_base: *mut libc::c_char, + pub _IO_write_ptr: *mut libc::c_char, + pub _IO_write_end: *mut libc::c_char, + pub _IO_buf_base: *mut libc::c_char, + pub _IO_buf_end: *mut libc::c_char, + pub _IO_save_base: *mut libc::c_char, + pub _IO_backup_base: *mut libc::c_char, + pub _IO_save_end: *mut libc::c_char, + pub _markers: *mut _IO_marker, + pub _chain: *mut _IO_FILE, + pub _fileno: libc::c_int, + pub _flags2: libc::c_int, + pub _old_offset: __off_t, + pub _cur_column: libc::c_ushort, + pub _vtable_offset: libc::c_schar, + pub _shortbuf: [libc::c_char; 1], + pub _lock: *mut libc::c_void, + pub _offset: __off64_t, + pub _codecvt: *mut _IO_codecvt, + pub _wide_data: *mut _IO_wide_data, + pub _freeres_list: *mut _IO_FILE, + pub _freeres_buf: *mut libc::c_void, + pub __pad5: size_t, + pub _mode: libc::c_int, + pub _unused2: [libc::c_char; 20], +} +pub type _IO_lock_t = (); +pub type FILE = _IO_FILE; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct Curl_easy { + pub magic: libc::c_uint, + pub next: *mut Curl_easy, + pub prev: *mut Curl_easy, + pub conn: *mut connectdata, + pub connect_queue: Curl_llist_element, + pub conn_queue: Curl_llist_element, + pub mstate: CURLMstate, + pub result: CURLcode, + pub msg: Curl_message, + pub sockets: [curl_socket_t; 5], + pub actions: [libc::c_uchar; 5], + pub numsocks: libc::c_int, + pub dns: Names, + pub multi: *mut Curl_multi, + pub multi_easy: *mut Curl_multi, + pub share: *mut Curl_share, + pub psl: *mut PslCache, + pub req: SingleRequest, + pub set: UserDefined, + pub cookies: *mut CookieInfo, + pub hsts: *mut hsts, + pub asi: *mut altsvcinfo, + pub progress: Progress, + pub state: UrlState, + pub wildcard: WildcardData, + pub info: PureInfo, + pub tsi: curl_tlssessioninfo, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct curl_tlssessioninfo { + pub backend: curl_sslbackend, + pub internals: *mut libc::c_void, +} +pub type curl_sslbackend = libc::c_uint; +pub const CURLSSLBACKEND_RUSTLS: curl_sslbackend = 14; +pub const CURLSSLBACKEND_BEARSSL: curl_sslbackend = 13; +pub const CURLSSLBACKEND_MESALINK: curl_sslbackend = 12; +pub const CURLSSLBACKEND_MBEDTLS: curl_sslbackend = 11; +pub const CURLSSLBACKEND_AXTLS: curl_sslbackend = 10; +pub const CURLSSLBACKEND_SECURETRANSPORT: curl_sslbackend = 9; +pub const CURLSSLBACKEND_SCHANNEL: curl_sslbackend = 8; +pub const CURLSSLBACKEND_WOLFSSL: curl_sslbackend = 7; +pub const CURLSSLBACKEND_POLARSSL: curl_sslbackend = 6; +pub const CURLSSLBACKEND_GSKIT: curl_sslbackend = 5; +pub const CURLSSLBACKEND_OBSOLETE4: curl_sslbackend = 4; +pub const CURLSSLBACKEND_NSS: curl_sslbackend = 3; +pub const CURLSSLBACKEND_GNUTLS: curl_sslbackend = 2; +pub const CURLSSLBACKEND_OPENSSL: curl_sslbackend = 1; +pub const CURLSSLBACKEND_NONE: curl_sslbackend = 0; +#[derive(Copy, Clone, BitfieldStruct)] +#[repr(C)] +pub struct PureInfo { + pub httpcode: libc::c_int, + pub httpproxycode: libc::c_int, + pub httpversion: libc::c_int, + pub filetime: time_t, + pub header_size: curl_off_t, + pub request_size: curl_off_t, + pub proxyauthavail: libc::c_ulong, + pub httpauthavail: libc::c_ulong, + pub numconnects: libc::c_long, + pub contenttype: *mut libc::c_char, + pub wouldredirect: *mut libc::c_char, + pub retry_after: curl_off_t, + pub conn_primary_ip: [libc::c_char; 46], + pub conn_primary_port: libc::c_int, + pub conn_local_ip: [libc::c_char; 46], + pub conn_local_port: libc::c_int, + pub conn_scheme: *const libc::c_char, + pub conn_protocol: libc::c_uint, + pub certs: curl_certinfo, + pub pxcode: CURLproxycode, + #[bitfield(name = "timecond", ty = "bit", bits = "0..=0")] + pub timecond: [u8; 1], + #[bitfield(padding)] + pub c2rust_padding: [u8; 3], +} +pub type bit = libc::c_uint; +pub type CURLproxycode = libc::c_uint; +pub const CURLPX_LAST: CURLproxycode = 34; +pub const CURLPX_USER_REJECTED: CURLproxycode = 33; +pub const CURLPX_UNKNOWN_MODE: CURLproxycode = 32; +pub const CURLPX_UNKNOWN_FAIL: CURLproxycode = 31; +pub const CURLPX_SEND_REQUEST: CURLproxycode = 30; +pub const CURLPX_SEND_CONNECT: CURLproxycode = 29; +pub const CURLPX_SEND_AUTH: CURLproxycode = 28; +pub const CURLPX_RESOLVE_HOST: CURLproxycode = 27; +pub const CURLPX_REQUEST_FAILED: CURLproxycode = 26; +pub const CURLPX_REPLY_UNASSIGNED: CURLproxycode = 25; +pub const CURLPX_REPLY_TTL_EXPIRED: CURLproxycode = 24; +pub const CURLPX_REPLY_NOT_ALLOWED: CURLproxycode = 23; +pub const CURLPX_REPLY_NETWORK_UNREACHABLE: CURLproxycode = 22; +pub const CURLPX_REPLY_HOST_UNREACHABLE: CURLproxycode = 21; +pub const CURLPX_REPLY_GENERAL_SERVER_FAILURE: CURLproxycode = 20; +pub const CURLPX_REPLY_CONNECTION_REFUSED: CURLproxycode = 19; +pub const CURLPX_REPLY_COMMAND_NOT_SUPPORTED: CURLproxycode = 18; +pub const CURLPX_REPLY_ADDRESS_TYPE_NOT_SUPPORTED: CURLproxycode = 17; +pub const CURLPX_RECV_REQACK: CURLproxycode = 16; +pub const CURLPX_RECV_CONNECT: CURLproxycode = 15; +pub const CURLPX_RECV_AUTH: CURLproxycode = 14; +pub const CURLPX_RECV_ADDRESS: CURLproxycode = 13; +pub const CURLPX_NO_AUTH: CURLproxycode = 12; +pub const CURLPX_LONG_USER: CURLproxycode = 11; +pub const CURLPX_LONG_PASSWD: CURLproxycode = 10; +pub const CURLPX_LONG_HOSTNAME: CURLproxycode = 9; +pub const CURLPX_IDENTD_DIFFER: CURLproxycode = 8; +pub const CURLPX_IDENTD: CURLproxycode = 7; +pub const CURLPX_GSSAPI_PROTECTION: CURLproxycode = 6; +pub const CURLPX_GSSAPI_PERMSG: CURLproxycode = 5; +pub const CURLPX_GSSAPI: CURLproxycode = 4; +pub const CURLPX_CLOSED: CURLproxycode = 3; +pub const CURLPX_BAD_VERSION: CURLproxycode = 2; +pub const CURLPX_BAD_ADDRESS_TYPE: CURLproxycode = 1; +pub const CURLPX_OK: CURLproxycode = 0; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct curl_certinfo { + pub num_of_certs: libc::c_int, + pub certinfo: *mut *mut curl_slist, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct curl_slist { + pub data: *mut libc::c_char, + pub next: *mut curl_slist, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct WildcardData { + pub state: wildcard_states, + pub path: *mut libc::c_char, + pub pattern: *mut libc::c_char, + pub filelist: Curl_llist, + pub protdata: *mut libc::c_void, + pub dtor: wildcard_dtor, + pub customptr: *mut libc::c_void, +} +pub type wildcard_dtor = Option:: ()>; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct Curl_llist { + pub head: *mut Curl_llist_element, + pub tail: *mut Curl_llist_element, + pub dtor: Curl_llist_dtor, + pub size: size_t, +} +pub type Curl_llist_dtor = Option::< + unsafe extern "C" fn(*mut libc::c_void, *mut libc::c_void) -> (), +>; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct Curl_llist_element { + pub ptr: *mut libc::c_void, + pub prev: *mut Curl_llist_element, + pub next: *mut Curl_llist_element, +} +pub type wildcard_states = libc::c_uint; +pub const CURLWC_DONE: wildcard_states = 7; +pub const CURLWC_ERROR: wildcard_states = 6; +pub const CURLWC_SKIP: wildcard_states = 5; +pub const CURLWC_CLEAN: wildcard_states = 4; +pub const CURLWC_DOWNLOADING: wildcard_states = 3; +pub const CURLWC_MATCHING: wildcard_states = 2; +pub const CURLWC_INIT: wildcard_states = 1; +pub const CURLWC_CLEAR: wildcard_states = 0; +#[derive(Copy, Clone, BitfieldStruct)] +#[repr(C)] +pub struct UrlState { + pub conn_cache: *mut conncache, + pub keeps_speed: curltime, + pub lastconnect_id: libc::c_long, + pub headerb: dynbuf, + pub buffer: *mut libc::c_char, + pub ulbuf: *mut libc::c_char, + pub current_speed: curl_off_t, + pub first_host: *mut libc::c_char, + pub retrycount: libc::c_int, + pub first_remote_port: libc::c_int, + pub session: *mut Curl_ssl_session, + pub sessionage: libc::c_long, + pub tempwrite: [tempbuf; 3], + pub tempcount: libc::c_uint, + pub os_errno: libc::c_int, + pub scratch: *mut libc::c_char, + pub followlocation: libc::c_long, + pub prev_signal: Option:: ()>, + pub digest: digestdata, + pub proxydigest: digestdata, + pub authhost: auth, + pub authproxy: auth, + pub async_0: Curl_async, + pub engine: *mut libc::c_void, + pub expiretime: curltime, + pub timenode: Curl_tree, + pub timeoutlist: Curl_llist, + pub expires: [time_node; 13], + pub most_recent_ftp_entrypath: *mut libc::c_char, + pub httpwant: libc::c_uchar, + pub httpversion: libc::c_uchar, + #[bitfield(name = "prev_block_had_trailing_cr", ty = "bit", bits = "0..=0")] + pub prev_block_had_trailing_cr: [u8; 1], + #[bitfield(padding)] + pub c2rust_padding: [u8; 5], + pub crlf_conversions: curl_off_t, + pub range: *mut libc::c_char, + pub resume_from: curl_off_t, + pub rtsp_next_client_CSeq: libc::c_long, + pub rtsp_next_server_CSeq: libc::c_long, + pub rtsp_CSeq_recv: libc::c_long, + pub infilesize: curl_off_t, + pub drain: size_t, + pub fread_func: curl_read_callback, + pub in_0: *mut libc::c_void, + pub stream_depends_on: *mut Curl_easy, + pub stream_weight: libc::c_int, + pub uh: *mut CURLU, + pub up: urlpieces, + pub httpreq: Curl_HttpReq, + pub url: *mut libc::c_char, + pub referer: *mut libc::c_char, + pub cookielist: *mut curl_slist, + pub resolve: *mut curl_slist, + pub trailers_bytes_sent: size_t, + pub trailers_buf: dynbuf, + pub trailers_state: trailers_state, + pub aptr: dynamically_allocated_data, + #[bitfield(name = "multi_owned_by_easy", ty = "bit", bits = "0..=0")] + #[bitfield(name = "this_is_a_follow", ty = "bit", bits = "1..=1")] + #[bitfield(name = "refused_stream", ty = "bit", bits = "2..=2")] + #[bitfield(name = "errorbuf", ty = "bit", bits = "3..=3")] + #[bitfield(name = "allow_port", ty = "bit", bits = "4..=4")] + #[bitfield(name = "authproblem", ty = "bit", bits = "5..=5")] + #[bitfield(name = "ftp_trying_alternative", ty = "bit", bits = "6..=6")] + #[bitfield(name = "wildcardmatch", ty = "bit", bits = "7..=7")] + #[bitfield(name = "expect100header", ty = "bit", bits = "8..=8")] + #[bitfield(name = "disableexpect", ty = "bit", bits = "9..=9")] + #[bitfield(name = "use_range", ty = "bit", bits = "10..=10")] + #[bitfield(name = "rangestringalloc", ty = "bit", bits = "11..=11")] + #[bitfield(name = "done", ty = "bit", bits = "12..=12")] + #[bitfield(name = "stream_depends_e", ty = "bit", bits = "13..=13")] + #[bitfield(name = "previouslypending", ty = "bit", bits = "14..=14")] + #[bitfield(name = "cookie_engine", ty = "bit", bits = "15..=15")] + #[bitfield(name = "prefer_ascii", ty = "bit", bits = "16..=16")] + #[bitfield(name = "list_only", ty = "bit", bits = "17..=17")] + #[bitfield(name = "url_alloc", ty = "bit", bits = "18..=18")] + #[bitfield(name = "referer_alloc", ty = "bit", bits = "19..=19")] + #[bitfield(name = "wildcard_resolve", ty = "bit", bits = "20..=20")] + pub multi_owned_by_easy_this_is_a_follow_refused_stream_errorbuf_allow_port_authproblem_ftp_trying_alternative_wildcardmatch_expect100header_disableexpect_use_range_rangestringalloc_done_stream_depends_e_previouslypending_cookie_engine_prefer_ascii_list_only_url_alloc_referer_alloc_wildcard_resolve: [u8; 3], + #[bitfield(padding)] + pub c2rust_padding_0: [u8; 5], +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct dynamically_allocated_data { + pub proxyuserpwd: *mut libc::c_char, + pub uagent: *mut libc::c_char, + pub accept_encoding: *mut libc::c_char, + pub userpwd: *mut libc::c_char, + pub rangeline: *mut libc::c_char, + pub ref_0: *mut libc::c_char, + pub host: *mut libc::c_char, + pub cookiehost: *mut libc::c_char, + pub rtsp_transport: *mut libc::c_char, + pub te: *mut libc::c_char, + pub user: *mut libc::c_char, + pub passwd: *mut libc::c_char, + pub proxyuser: *mut libc::c_char, + pub proxypasswd: *mut libc::c_char, +} +pub type trailers_state = libc::c_uint; +pub const TRAILERS_DONE: trailers_state = 3; +pub const TRAILERS_SENDING: trailers_state = 2; +pub const TRAILERS_INITIALIZED: trailers_state = 1; +pub const TRAILERS_NONE: trailers_state = 0; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct dynbuf { + pub bufr: *mut libc::c_char, + pub leng: size_t, + pub allc: size_t, + pub toobig: size_t, +} +pub type Curl_HttpReq = libc::c_uint; +pub const HTTPREQ_HEAD: Curl_HttpReq = 5; +pub const HTTPREQ_PUT: Curl_HttpReq = 4; +pub const HTTPREQ_POST_MIME: Curl_HttpReq = 3; +pub const HTTPREQ_POST_FORM: Curl_HttpReq = 2; +pub const HTTPREQ_POST: Curl_HttpReq = 1; +pub const HTTPREQ_GET: Curl_HttpReq = 0; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct urlpieces { + pub scheme: *mut libc::c_char, + pub hostname: *mut libc::c_char, + pub port: *mut libc::c_char, + pub user: *mut libc::c_char, + pub password: *mut libc::c_char, + pub options: *mut libc::c_char, + pub path: *mut libc::c_char, + pub query: *mut libc::c_char, +} +pub type CURLU = Curl_URL; +pub type curl_read_callback = Option::< + unsafe extern "C" fn(*mut libc::c_char, size_t, size_t, *mut libc::c_void) -> size_t, +>; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct time_node { + pub list: Curl_llist_element, + pub time: curltime, + pub eid: expire_id, +} +pub type expire_id = libc::c_uint; +pub const EXPIRE_LAST: expire_id = 13; +pub const EXPIRE_QUIC: expire_id = 12; +pub const EXPIRE_TOOFAST: expire_id = 11; +pub const EXPIRE_TIMEOUT: expire_id = 10; +pub const EXPIRE_SPEEDCHECK: expire_id = 9; +pub const EXPIRE_RUN_NOW: expire_id = 8; +pub const EXPIRE_MULTI_PENDING: expire_id = 7; +pub const EXPIRE_HAPPY_EYEBALLS: expire_id = 6; +pub const EXPIRE_HAPPY_EYEBALLS_DNS: expire_id = 5; +pub const EXPIRE_DNS_PER_NAME2: expire_id = 4; +pub const EXPIRE_DNS_PER_NAME: expire_id = 3; +pub const EXPIRE_CONNECTTIMEOUT: expire_id = 2; +pub const EXPIRE_ASYNC_NAME: expire_id = 1; +pub const EXPIRE_100_TIMEOUT: expire_id = 0; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct curltime { + pub tv_sec: time_t, + pub tv_usec: libc::c_int, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct Curl_tree { + pub smaller: *mut Curl_tree, + pub larger: *mut Curl_tree, + pub samen: *mut Curl_tree, + pub samep: *mut Curl_tree, + pub key: curltime, + pub payload: *mut libc::c_void, +} +#[derive(Copy, Clone, BitfieldStruct)] +#[repr(C)] +pub struct Curl_async { + pub hostname: *mut libc::c_char, + pub dns: *mut Curl_dns_entry, + pub tdata: *mut thread_data, + pub resolver: *mut libc::c_void, + pub port: libc::c_int, + pub status: libc::c_int, + #[bitfield(name = "done", ty = "bit", bits = "0..=0")] + pub done: [u8; 1], + #[bitfield(padding)] + pub c2rust_padding: [u8; 7], +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct Curl_dns_entry { + pub addr: *mut Curl_addrinfo, + pub timestamp: time_t, + pub inuse: libc::c_long, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct Curl_addrinfo { + pub ai_flags: libc::c_int, + pub ai_family: libc::c_int, + pub ai_socktype: libc::c_int, + pub ai_protocol: libc::c_int, + pub ai_addrlen: curl_socklen_t, + pub ai_canonname: *mut libc::c_char, + pub ai_addr: *mut sockaddr, + pub ai_next: *mut Curl_addrinfo, +} +#[derive(Copy, Clone, BitfieldStruct)] +#[repr(C)] +pub struct auth { + pub want: libc::c_ulong, + pub picked: libc::c_ulong, + pub avail: libc::c_ulong, + #[bitfield(name = "done", ty = "bit", bits = "0..=0")] + #[bitfield(name = "multipass", ty = "bit", bits = "1..=1")] + #[bitfield(name = "iestyle", ty = "bit", bits = "2..=2")] + pub done_multipass_iestyle: [u8; 1], + #[bitfield(padding)] + pub c2rust_padding: [u8; 7], +} +#[derive(Copy, Clone, BitfieldStruct)] +#[repr(C)] +pub struct digestdata { + pub nonce: *mut libc::c_char, + pub cnonce: *mut libc::c_char, + pub realm: *mut libc::c_char, + pub algo: libc::c_int, + pub opaque: *mut libc::c_char, + pub qop: *mut libc::c_char, + pub algorithm: *mut libc::c_char, + pub nc: libc::c_int, + #[bitfield(name = "stale", ty = "bit", bits = "0..=0")] + #[bitfield(name = "userhash", ty = "bit", bits = "1..=1")] + pub stale_userhash: [u8; 1], + #[bitfield(padding)] + pub c2rust_padding: [u8; 3], +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct tempbuf { + pub b: dynbuf, + pub type_0: libc::c_int, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct Curl_ssl_session { + pub name: *mut libc::c_char, + pub conn_to_host: *mut libc::c_char, + pub scheme: *const libc::c_char, + pub sessionid: *mut libc::c_void, + pub idsize: size_t, + pub age: libc::c_long, + pub remote_port: libc::c_int, + pub conn_to_port: libc::c_int, + pub ssl_config: ssl_primary_config, +} +#[derive(Copy, Clone, BitfieldStruct)] +#[repr(C)] +pub struct ssl_primary_config { + pub version: libc::c_long, + pub version_max: libc::c_long, + pub CApath: *mut libc::c_char, + pub CAfile: *mut libc::c_char, + pub issuercert: *mut libc::c_char, + pub clientcert: *mut libc::c_char, + pub random_file: *mut libc::c_char, + pub egdsocket: *mut libc::c_char, + pub cipher_list: *mut libc::c_char, + pub cipher_list13: *mut libc::c_char, + pub pinned_key: *mut libc::c_char, + pub cert_blob: *mut curl_blob, + pub ca_info_blob: *mut curl_blob, + pub issuercert_blob: *mut curl_blob, + pub curves: *mut libc::c_char, + #[bitfield(name = "verifypeer", ty = "bit", bits = "0..=0")] + #[bitfield(name = "verifyhost", ty = "bit", bits = "1..=1")] + #[bitfield(name = "verifystatus", ty = "bit", bits = "2..=2")] + #[bitfield(name = "sessionid", ty = "bit", bits = "3..=3")] + pub verifypeer_verifyhost_verifystatus_sessionid: [u8; 1], + #[bitfield(padding)] + pub c2rust_padding: [u8; 7], +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct curl_blob { + pub data: *mut libc::c_void, + pub len: size_t, + pub flags: libc::c_uint, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct conncache { + pub hash: Curl_hash, + pub num_conn: size_t, + pub next_connection_id: libc::c_long, + pub last_cleanup: curltime, + pub closure_handle: *mut Curl_easy, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct Curl_hash { + pub table: *mut Curl_llist, + pub hash_func: hash_function, + pub comp_func: comp_function, + pub dtor: Curl_hash_dtor, + pub slots: libc::c_int, + pub size: size_t, +} +pub type Curl_hash_dtor = Option:: ()>; +pub type comp_function = Option::< + unsafe extern "C" fn(*mut libc::c_void, size_t, *mut libc::c_void, size_t) -> size_t, +>; +pub type hash_function = Option::< + unsafe extern "C" fn(*mut libc::c_void, size_t, size_t) -> size_t, +>; +#[derive(Copy, Clone, BitfieldStruct)] +#[repr(C)] +pub struct Progress { + pub lastshow: time_t, + pub size_dl: curl_off_t, + pub size_ul: curl_off_t, + pub downloaded: curl_off_t, + pub uploaded: curl_off_t, + pub current_speed: curl_off_t, + pub width: libc::c_int, + pub flags: libc::c_int, + pub timespent: timediff_t, + pub dlspeed: curl_off_t, + pub ulspeed: curl_off_t, + pub t_nslookup: timediff_t, + pub t_connect: timediff_t, + pub t_appconnect: timediff_t, + pub t_pretransfer: timediff_t, + pub t_starttransfer: timediff_t, + pub t_redirect: timediff_t, + pub start: curltime, + pub t_startsingle: curltime, + pub t_startop: curltime, + pub t_acceptdata: curltime, + pub ul_limit_start: curltime, + pub ul_limit_size: curl_off_t, + pub dl_limit_start: curltime, + pub dl_limit_size: curl_off_t, + pub speeder: [curl_off_t; 6], + pub speeder_time: [curltime; 6], + pub speeder_c: libc::c_int, + #[bitfield(name = "callback", ty = "bit", bits = "0..=0")] + #[bitfield(name = "is_t_startransfer_set", ty = "bit", bits = "1..=1")] + pub callback_is_t_startransfer_set: [u8; 1], + #[bitfield(padding)] + pub c2rust_padding: [u8; 3], +} +pub type timediff_t = curl_off_t; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct CookieInfo { + pub cookies: [*mut Cookie; 256], + pub filename: *mut libc::c_char, + pub numcookies: libc::c_long, + pub running: bool, + pub newsession: bool, + pub lastct: libc::c_int, + pub next_expiration: curl_off_t, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct Cookie { + pub next: *mut Cookie, + pub name: *mut libc::c_char, + pub value: *mut libc::c_char, + pub path: *mut libc::c_char, + pub spath: *mut libc::c_char, + pub domain: *mut libc::c_char, + pub expires: curl_off_t, + pub expirestr: *mut libc::c_char, + pub version: *mut libc::c_char, + pub maxage: *mut libc::c_char, + pub tailmatch: bool, + pub secure: bool, + pub livecookie: bool, + pub httponly: bool, + pub creationtime: libc::c_int, + pub prefix: libc::c_uchar, +} +#[derive(Copy, Clone, BitfieldStruct)] +#[repr(C)] +pub struct UserDefined { + pub err: *mut FILE, + pub debugdata: *mut libc::c_void, + pub errorbuffer: *mut libc::c_char, + pub proxyport: libc::c_long, + pub out: *mut libc::c_void, + pub in_set: *mut libc::c_void, + pub writeheader: *mut libc::c_void, + pub rtp_out: *mut libc::c_void, + pub use_port: libc::c_long, + pub httpauth: libc::c_ulong, + pub proxyauth: libc::c_ulong, + pub socks5auth: libc::c_ulong, + pub maxredirs: libc::c_long, + pub keep_post: libc::c_int, + pub postfields: *mut libc::c_void, + pub seek_func: curl_seek_callback, + pub postfieldsize: curl_off_t, + pub localport: libc::c_ushort, + pub localportrange: libc::c_int, + pub fwrite_func: curl_write_callback, + pub fwrite_header: curl_write_callback, + pub fwrite_rtp: curl_write_callback, + pub fread_func_set: curl_read_callback, + pub fprogress: curl_progress_callback, + pub fxferinfo: curl_xferinfo_callback, + pub fdebug: curl_debug_callback, + pub ioctl_func: curl_ioctl_callback, + pub fsockopt: curl_sockopt_callback, + pub sockopt_client: *mut libc::c_void, + pub fopensocket: curl_opensocket_callback, + pub opensocket_client: *mut libc::c_void, + pub fclosesocket: curl_closesocket_callback, + pub closesocket_client: *mut libc::c_void, + pub seek_client: *mut libc::c_void, + pub convfromnetwork: curl_conv_callback, + pub convtonetwork: curl_conv_callback, + pub convfromutf8: curl_conv_callback, + pub hsts_read: curl_hstsread_callback, + pub hsts_read_userp: *mut libc::c_void, + pub hsts_write: curl_hstswrite_callback, + pub hsts_write_userp: *mut libc::c_void, + pub progress_client: *mut libc::c_void, + pub ioctl_client: *mut libc::c_void, + pub timeout: libc::c_long, + pub connecttimeout: libc::c_long, + pub accepttimeout: libc::c_long, + pub happy_eyeballs_timeout: libc::c_long, + pub server_response_timeout: libc::c_long, + pub maxage_conn: libc::c_long, + pub tftp_blksize: libc::c_long, + pub filesize: curl_off_t, + pub low_speed_limit: libc::c_long, + pub low_speed_time: libc::c_long, + pub max_send_speed: curl_off_t, + pub max_recv_speed: curl_off_t, + pub set_resume_from: curl_off_t, + pub headers: *mut curl_slist, + pub proxyheaders: *mut curl_slist, + pub httppost: *mut curl_httppost, + pub mimepost: curl_mimepart, + pub quote: *mut curl_slist, + pub postquote: *mut curl_slist, + pub prequote: *mut curl_slist, + pub source_quote: *mut curl_slist, + pub source_prequote: *mut curl_slist, + pub source_postquote: *mut curl_slist, + pub telnet_options: *mut curl_slist, + pub resolve: *mut curl_slist, + pub connect_to: *mut curl_slist, + pub timecondition: curl_TimeCond, + pub proxytype: curl_proxytype, + pub timevalue: time_t, + pub method: Curl_HttpReq, + pub httpwant: libc::c_uchar, + pub ssl: ssl_config_data, + pub proxy_ssl: ssl_config_data, + pub general_ssl: ssl_general_config, + pub dns_cache_timeout: libc::c_long, + pub buffer_size: libc::c_long, + pub upload_buffer_size: libc::c_uint, + pub private_data: *mut libc::c_void, + pub http200aliases: *mut curl_slist, + pub ipver: libc::c_uchar, + pub max_filesize: curl_off_t, + pub ftp_filemethod: curl_ftpfile, + pub ftpsslauth: curl_ftpauth, + pub ftp_ccc: curl_ftpccc, + pub ftp_create_missing_dirs: libc::c_int, + pub ssh_keyfunc: curl_sshkeycallback, + pub ssh_keyfunc_userp: *mut libc::c_void, + pub use_netrc: CURL_NETRC_OPTION, + pub use_ssl: curl_usessl, + pub new_file_perms: libc::c_long, + pub new_directory_perms: libc::c_long, + pub ssh_auth_types: libc::c_long, + pub str_0: [*mut libc::c_char; 80], + pub blobs: [*mut curl_blob; 8], + pub scope_id: libc::c_uint, + pub allowed_protocols: libc::c_long, + pub redir_protocols: libc::c_long, + pub mail_rcpt: *mut curl_slist, + pub rtspreq: Curl_RtspReq, + pub rtspversion: libc::c_long, + pub chunk_bgn: curl_chunk_bgn_callback, + pub chunk_end: curl_chunk_end_callback, + pub fnmatch: curl_fnmatch_callback, + pub fnmatch_data: *mut libc::c_void, + pub gssapi_delegation: libc::c_long, + pub tcp_keepidle: libc::c_long, + pub tcp_keepintvl: libc::c_long, + pub maxconnects: size_t, + pub expect_100_timeout: libc::c_long, + pub stream_depends_on: *mut Curl_easy, + pub stream_weight: libc::c_int, + pub stream_dependents: *mut Curl_http2_dep, + pub resolver_start: curl_resolver_start_callback, + pub resolver_start_client: *mut libc::c_void, + pub upkeep_interval_ms: libc::c_long, + pub fmultidone: multidone_func, + pub dohfor: *mut Curl_easy, + pub uh: *mut CURLU, + pub trailer_data: *mut libc::c_void, + pub trailer_callback: curl_trailer_callback, + #[bitfield(name = "is_fread_set", ty = "bit", bits = "0..=0")] + #[bitfield(name = "is_fwrite_set", ty = "bit", bits = "1..=1")] + #[bitfield(name = "free_referer", ty = "bit", bits = "2..=2")] + #[bitfield(name = "tftp_no_options", ty = "bit", bits = "3..=3")] + #[bitfield(name = "sep_headers", ty = "bit", bits = "4..=4")] + #[bitfield(name = "cookiesession", ty = "bit", bits = "5..=5")] + #[bitfield(name = "crlf", ty = "bit", bits = "6..=6")] + #[bitfield(name = "strip_path_slash", ty = "bit", bits = "7..=7")] + #[bitfield(name = "ssh_compression", ty = "bit", bits = "8..=8")] + #[bitfield(name = "get_filetime", ty = "bit", bits = "9..=9")] + #[bitfield(name = "tunnel_thru_httpproxy", ty = "bit", bits = "10..=10")] + #[bitfield(name = "prefer_ascii", ty = "bit", bits = "11..=11")] + #[bitfield(name = "remote_append", ty = "bit", bits = "12..=12")] + #[bitfield(name = "list_only", ty = "bit", bits = "13..=13")] + #[bitfield(name = "ftp_use_port", ty = "bit", bits = "14..=14")] + #[bitfield(name = "ftp_use_epsv", ty = "bit", bits = "15..=15")] + #[bitfield(name = "ftp_use_eprt", ty = "bit", bits = "16..=16")] + #[bitfield(name = "ftp_use_pret", ty = "bit", bits = "17..=17")] + #[bitfield(name = "ftp_skip_ip", ty = "bit", bits = "18..=18")] + #[bitfield(name = "hide_progress", ty = "bit", bits = "19..=19")] + #[bitfield(name = "http_fail_on_error", ty = "bit", bits = "20..=20")] + #[bitfield(name = "http_keep_sending_on_error", ty = "bit", bits = "21..=21")] + #[bitfield(name = "http_follow_location", ty = "bit", bits = "22..=22")] + #[bitfield(name = "http_transfer_encoding", ty = "bit", bits = "23..=23")] + #[bitfield(name = "allow_auth_to_other_hosts", ty = "bit", bits = "24..=24")] + #[bitfield(name = "include_header", ty = "bit", bits = "25..=25")] + #[bitfield(name = "http_set_referer", ty = "bit", bits = "26..=26")] + #[bitfield(name = "http_auto_referer", ty = "bit", bits = "27..=27")] + #[bitfield(name = "opt_no_body", ty = "bit", bits = "28..=28")] + #[bitfield(name = "upload", ty = "bit", bits = "29..=29")] + #[bitfield(name = "verbose", ty = "bit", bits = "30..=30")] + #[bitfield(name = "krb", ty = "bit", bits = "31..=31")] + #[bitfield(name = "reuse_forbid", ty = "bit", bits = "32..=32")] + #[bitfield(name = "reuse_fresh", ty = "bit", bits = "33..=33")] + #[bitfield(name = "no_signal", ty = "bit", bits = "34..=34")] + #[bitfield(name = "tcp_nodelay", ty = "bit", bits = "35..=35")] + #[bitfield(name = "ignorecl", ty = "bit", bits = "36..=36")] + #[bitfield(name = "connect_only", ty = "bit", bits = "37..=37")] + #[bitfield(name = "http_te_skip", ty = "bit", bits = "38..=38")] + #[bitfield(name = "http_ce_skip", ty = "bit", bits = "39..=39")] + #[bitfield(name = "proxy_transfer_mode", ty = "bit", bits = "40..=40")] + #[bitfield(name = "sasl_ir", ty = "bit", bits = "41..=41")] + #[bitfield(name = "wildcard_enabled", ty = "bit", bits = "42..=42")] + #[bitfield(name = "tcp_keepalive", ty = "bit", bits = "43..=43")] + #[bitfield(name = "tcp_fastopen", ty = "bit", bits = "44..=44")] + #[bitfield(name = "ssl_enable_npn", ty = "bit", bits = "45..=45")] + #[bitfield(name = "ssl_enable_alpn", ty = "bit", bits = "46..=46")] + #[bitfield(name = "path_as_is", ty = "bit", bits = "47..=47")] + #[bitfield(name = "pipewait", ty = "bit", bits = "48..=48")] + #[bitfield(name = "suppress_connect_headers", ty = "bit", bits = "49..=49")] + #[bitfield(name = "dns_shuffle_addresses", ty = "bit", bits = "50..=50")] + #[bitfield(name = "stream_depends_e", ty = "bit", bits = "51..=51")] + #[bitfield(name = "haproxyprotocol", ty = "bit", bits = "52..=52")] + #[bitfield(name = "abstract_unix_socket", ty = "bit", bits = "53..=53")] + #[bitfield(name = "disallow_username_in_url", ty = "bit", bits = "54..=54")] + #[bitfield(name = "doh", ty = "bit", bits = "55..=55")] + #[bitfield(name = "doh_get", ty = "bit", bits = "56..=56")] + #[bitfield(name = "doh_verifypeer", ty = "bit", bits = "57..=57")] + #[bitfield(name = "doh_verifyhost", ty = "bit", bits = "58..=58")] + #[bitfield(name = "doh_verifystatus", ty = "bit", bits = "59..=59")] + #[bitfield(name = "http09_allowed", ty = "bit", bits = "60..=60")] + #[bitfield(name = "mail_rcpt_allowfails", ty = "bit", bits = "61..=61")] + pub is_fread_set_is_fwrite_set_free_referer_tftp_no_options_sep_headers_cookiesession_crlf_strip_path_slash_ssh_compression_get_filetime_tunnel_thru_httpproxy_prefer_ascii_remote_append_list_only_ftp_use_port_ftp_use_epsv_ftp_use_eprt_ftp_use_pret_ftp_skip_ip_hide_progress_http_fail_on_error_http_keep_sending_on_error_http_follow_location_http_transfer_encoding_allow_auth_to_other_hosts_include_header_http_set_referer_http_auto_referer_opt_no_body_upload_verbose_krb_reuse_forbid_reuse_fresh_no_signal_tcp_nodelay_ignorecl_connect_only_http_te_skip_http_ce_skip_proxy_transfer_mode_sasl_ir_wildcard_enabled_tcp_keepalive_tcp_fastopen_ssl_enable_npn_ssl_enable_alpn_path_as_is_pipewait_suppress_connect_headers_dns_shuffle_addresses_stream_depends_e_haproxyprotocol_abstract_unix_socket_disallow_username_in_url_doh_doh_get_doh_verifypeer_doh_verifyhost_doh_verifystatus_http09_allowed_mail_rcpt_allowfails: [u8; 8], +} +pub type curl_trailer_callback = Option::< + unsafe extern "C" fn(*mut *mut curl_slist, *mut libc::c_void) -> libc::c_int, +>; +pub type multidone_func = Option::< + unsafe extern "C" fn(*mut Curl_easy, CURLcode) -> libc::c_int, +>; +pub type CURLcode = libc::c_uint; +pub const CURL_LAST: CURLcode = 99; +pub const CURLE_SSL_CLIENTCERT: CURLcode = 98; +pub const CURLE_PROXY: CURLcode = 97; +pub const CURLE_QUIC_CONNECT_ERROR: CURLcode = 96; +pub const CURLE_HTTP3: CURLcode = 95; +pub const CURLE_AUTH_ERROR: CURLcode = 94; +pub const CURLE_RECURSIVE_API_CALL: CURLcode = 93; +pub const CURLE_HTTP2_STREAM: CURLcode = 92; +pub const CURLE_SSL_INVALIDCERTSTATUS: CURLcode = 91; +pub const CURLE_SSL_PINNEDPUBKEYNOTMATCH: CURLcode = 90; +pub const CURLE_NO_CONNECTION_AVAILABLE: CURLcode = 89; +pub const CURLE_CHUNK_FAILED: CURLcode = 88; +pub const CURLE_FTP_BAD_FILE_LIST: CURLcode = 87; +pub const CURLE_RTSP_SESSION_ERROR: CURLcode = 86; +pub const CURLE_RTSP_CSEQ_ERROR: CURLcode = 85; +pub const CURLE_FTP_PRET_FAILED: CURLcode = 84; +pub const CURLE_SSL_ISSUER_ERROR: CURLcode = 83; +pub const CURLE_SSL_CRL_BADFILE: CURLcode = 82; +pub const CURLE_AGAIN: CURLcode = 81; +pub const CURLE_SSL_SHUTDOWN_FAILED: CURLcode = 80; +pub const CURLE_SSH: CURLcode = 79; +pub const CURLE_REMOTE_FILE_NOT_FOUND: CURLcode = 78; +pub const CURLE_SSL_CACERT_BADFILE: CURLcode = 77; +pub const CURLE_CONV_REQD: CURLcode = 76; +pub const CURLE_CONV_FAILED: CURLcode = 75; +pub const CURLE_TFTP_NOSUCHUSER: CURLcode = 74; +pub const CURLE_REMOTE_FILE_EXISTS: CURLcode = 73; +pub const CURLE_TFTP_UNKNOWNID: CURLcode = 72; +pub const CURLE_TFTP_ILLEGAL: CURLcode = 71; +pub const CURLE_REMOTE_DISK_FULL: CURLcode = 70; +pub const CURLE_TFTP_PERM: CURLcode = 69; +pub const CURLE_TFTP_NOTFOUND: CURLcode = 68; +pub const CURLE_LOGIN_DENIED: CURLcode = 67; +pub const CURLE_SSL_ENGINE_INITFAILED: CURLcode = 66; +pub const CURLE_SEND_FAIL_REWIND: CURLcode = 65; +pub const CURLE_USE_SSL_FAILED: CURLcode = 64; +pub const CURLE_FILESIZE_EXCEEDED: CURLcode = 63; +pub const CURLE_LDAP_INVALID_URL: CURLcode = 62; +pub const CURLE_BAD_CONTENT_ENCODING: CURLcode = 61; +pub const CURLE_PEER_FAILED_VERIFICATION: CURLcode = 60; +pub const CURLE_SSL_CIPHER: CURLcode = 59; +pub const CURLE_SSL_CERTPROBLEM: CURLcode = 58; +pub const CURLE_OBSOLETE57: CURLcode = 57; +pub const CURLE_RECV_ERROR: CURLcode = 56; +pub const CURLE_SEND_ERROR: CURLcode = 55; +pub const CURLE_SSL_ENGINE_SETFAILED: CURLcode = 54; +pub const CURLE_SSL_ENGINE_NOTFOUND: CURLcode = 53; +pub const CURLE_GOT_NOTHING: CURLcode = 52; +pub const CURLE_OBSOLETE51: CURLcode = 51; +pub const CURLE_OBSOLETE50: CURLcode = 50; +pub const CURLE_SETOPT_OPTION_SYNTAX: CURLcode = 49; +pub const CURLE_UNKNOWN_OPTION: CURLcode = 48; +pub const CURLE_TOO_MANY_REDIRECTS: CURLcode = 47; +pub const CURLE_OBSOLETE46: CURLcode = 46; +pub const CURLE_INTERFACE_FAILED: CURLcode = 45; +pub const CURLE_OBSOLETE44: CURLcode = 44; +pub const CURLE_BAD_FUNCTION_ARGUMENT: CURLcode = 43; +pub const CURLE_ABORTED_BY_CALLBACK: CURLcode = 42; +pub const CURLE_FUNCTION_NOT_FOUND: CURLcode = 41; +pub const CURLE_OBSOLETE40: CURLcode = 40; +pub const CURLE_LDAP_SEARCH_FAILED: CURLcode = 39; +pub const CURLE_LDAP_CANNOT_BIND: CURLcode = 38; +pub const CURLE_FILE_COULDNT_READ_FILE: CURLcode = 37; +pub const CURLE_BAD_DOWNLOAD_RESUME: CURLcode = 36; +pub const CURLE_SSL_CONNECT_ERROR: CURLcode = 35; +pub const CURLE_HTTP_POST_ERROR: CURLcode = 34; +pub const CURLE_RANGE_ERROR: CURLcode = 33; +pub const CURLE_OBSOLETE32: CURLcode = 32; +pub const CURLE_FTP_COULDNT_USE_REST: CURLcode = 31; +pub const CURLE_FTP_PORT_FAILED: CURLcode = 30; +pub const CURLE_OBSOLETE29: CURLcode = 29; +pub const CURLE_OPERATION_TIMEDOUT: CURLcode = 28; +pub const CURLE_OUT_OF_MEMORY: CURLcode = 27; +pub const CURLE_READ_ERROR: CURLcode = 26; +pub const CURLE_UPLOAD_FAILED: CURLcode = 25; +pub const CURLE_OBSOLETE24: CURLcode = 24; +pub const CURLE_WRITE_ERROR: CURLcode = 23; +pub const CURLE_HTTP_RETURNED_ERROR: CURLcode = 22; +pub const CURLE_QUOTE_ERROR: CURLcode = 21; +pub const CURLE_OBSOLETE20: CURLcode = 20; +pub const CURLE_FTP_COULDNT_RETR_FILE: CURLcode = 19; +pub const CURLE_PARTIAL_FILE: CURLcode = 18; +pub const CURLE_FTP_COULDNT_SET_TYPE: CURLcode = 17; +pub const CURLE_HTTP2: CURLcode = 16; +pub const CURLE_FTP_CANT_GET_HOST: CURLcode = 15; +pub const CURLE_FTP_WEIRD_227_FORMAT: CURLcode = 14; +pub const CURLE_FTP_WEIRD_PASV_REPLY: CURLcode = 13; +pub const CURLE_FTP_ACCEPT_TIMEOUT: CURLcode = 12; +pub const CURLE_FTP_WEIRD_PASS_REPLY: CURLcode = 11; +pub const CURLE_FTP_ACCEPT_FAILED: CURLcode = 10; +pub const CURLE_REMOTE_ACCESS_DENIED: CURLcode = 9; +pub const CURLE_WEIRD_SERVER_REPLY: CURLcode = 8; +pub const CURLE_COULDNT_CONNECT: CURLcode = 7; +pub const CURLE_COULDNT_RESOLVE_HOST: CURLcode = 6; +pub const CURLE_COULDNT_RESOLVE_PROXY: CURLcode = 5; +pub const CURLE_NOT_BUILT_IN: CURLcode = 4; +pub const CURLE_URL_MALFORMAT: CURLcode = 3; +pub const CURLE_FAILED_INIT: CURLcode = 2; +pub const CURLE_UNSUPPORTED_PROTOCOL: CURLcode = 1; +pub const CURLE_OK: CURLcode = 0; +pub type curl_resolver_start_callback = Option::< + unsafe extern "C" fn( + *mut libc::c_void, + *mut libc::c_void, + *mut libc::c_void, + ) -> libc::c_int, +>; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct Curl_http2_dep { + pub next: *mut Curl_http2_dep, + pub data: *mut Curl_easy, +} +pub type curl_fnmatch_callback = Option::< + unsafe extern "C" fn( + *mut libc::c_void, + *const libc::c_char, + *const libc::c_char, + ) -> libc::c_int, +>; +pub type curl_chunk_end_callback = Option::< + unsafe extern "C" fn(*mut libc::c_void) -> libc::c_long, +>; +pub type curl_chunk_bgn_callback = Option::< + unsafe extern "C" fn( + *const libc::c_void, + *mut libc::c_void, + libc::c_int, + ) -> libc::c_long, +>; +pub type Curl_RtspReq = libc::c_uint; +pub const RTSPREQ_LAST: Curl_RtspReq = 12; +pub const RTSPREQ_RECEIVE: Curl_RtspReq = 11; +pub const RTSPREQ_RECORD: Curl_RtspReq = 10; +pub const RTSPREQ_SET_PARAMETER: Curl_RtspReq = 9; +pub const RTSPREQ_GET_PARAMETER: Curl_RtspReq = 8; +pub const RTSPREQ_TEARDOWN: Curl_RtspReq = 7; +pub const RTSPREQ_PAUSE: Curl_RtspReq = 6; +pub const RTSPREQ_PLAY: Curl_RtspReq = 5; +pub const RTSPREQ_SETUP: Curl_RtspReq = 4; +pub const RTSPREQ_ANNOUNCE: Curl_RtspReq = 3; +pub const RTSPREQ_DESCRIBE: Curl_RtspReq = 2; +pub const RTSPREQ_OPTIONS: Curl_RtspReq = 1; +pub const RTSPREQ_NONE: Curl_RtspReq = 0; +pub type curl_usessl = libc::c_uint; +pub const CURLUSESSL_LAST: curl_usessl = 4; +pub const CURLUSESSL_ALL: curl_usessl = 3; +pub const CURLUSESSL_CONTROL: curl_usessl = 2; +pub const CURLUSESSL_TRY: curl_usessl = 1; +pub const CURLUSESSL_NONE: curl_usessl = 0; +pub type CURL_NETRC_OPTION = libc::c_uint; +pub const CURL_NETRC_LAST: CURL_NETRC_OPTION = 3; +pub const CURL_NETRC_REQUIRED: CURL_NETRC_OPTION = 2; +pub const CURL_NETRC_OPTIONAL: CURL_NETRC_OPTION = 1; +pub const CURL_NETRC_IGNORED: CURL_NETRC_OPTION = 0; +pub type curl_sshkeycallback = Option::< + unsafe extern "C" fn( + *mut CURL, + *const curl_khkey, + *const curl_khkey, + curl_khmatch, + *mut libc::c_void, + ) -> libc::c_int, +>; +pub type curl_khmatch = libc::c_uint; +pub const CURLKHMATCH_LAST: curl_khmatch = 3; +pub const CURLKHMATCH_MISSING: curl_khmatch = 2; +pub const CURLKHMATCH_MISMATCH: curl_khmatch = 1; +pub const CURLKHMATCH_OK: curl_khmatch = 0; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct curl_khkey { + pub key: *const libc::c_char, + pub len: size_t, + pub keytype: curl_khtype, +} +pub type curl_khtype = libc::c_uint; +pub const CURLKHTYPE_ED25519: curl_khtype = 5; +pub const CURLKHTYPE_ECDSA: curl_khtype = 4; +pub const CURLKHTYPE_DSS: curl_khtype = 3; +pub const CURLKHTYPE_RSA: curl_khtype = 2; +pub const CURLKHTYPE_RSA1: curl_khtype = 1; +pub const CURLKHTYPE_UNKNOWN: curl_khtype = 0; +pub type CURL = Curl_easy; +pub type curl_ftpccc = libc::c_uint; +pub const CURLFTPSSL_CCC_LAST: curl_ftpccc = 3; +pub const CURLFTPSSL_CCC_ACTIVE: curl_ftpccc = 2; +pub const CURLFTPSSL_CCC_PASSIVE: curl_ftpccc = 1; +pub const CURLFTPSSL_CCC_NONE: curl_ftpccc = 0; +pub type curl_ftpauth = libc::c_uint; +pub const CURLFTPAUTH_LAST: curl_ftpauth = 3; +pub const CURLFTPAUTH_TLS: curl_ftpauth = 2; +pub const CURLFTPAUTH_SSL: curl_ftpauth = 1; +pub const CURLFTPAUTH_DEFAULT: curl_ftpauth = 0; +pub type curl_ftpfile = libc::c_uint; +pub const FTPFILE_SINGLECWD: curl_ftpfile = 3; +pub const FTPFILE_NOCWD: curl_ftpfile = 2; +pub const FTPFILE_MULTICWD: curl_ftpfile = 1; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct ssl_general_config { + pub max_ssl_sessions: size_t, +} +#[derive(Copy, Clone, BitfieldStruct)] +#[repr(C)] +pub struct ssl_config_data { + pub primary: ssl_primary_config, + pub certverifyresult: libc::c_long, + pub CRLfile: *mut libc::c_char, + pub fsslctx: curl_ssl_ctx_callback, + pub fsslctxp: *mut libc::c_void, + pub cert_type: *mut libc::c_char, + pub key: *mut libc::c_char, + pub key_blob: *mut curl_blob, + pub key_type: *mut libc::c_char, + pub key_passwd: *mut libc::c_char, + pub username: *mut libc::c_char, + pub password: *mut libc::c_char, + pub authtype: CURL_TLSAUTH, + #[bitfield(name = "certinfo", ty = "bit", bits = "0..=0")] + #[bitfield(name = "falsestart", ty = "bit", bits = "1..=1")] + #[bitfield(name = "enable_beast", ty = "bit", bits = "2..=2")] + #[bitfield(name = "no_revoke", ty = "bit", bits = "3..=3")] + #[bitfield(name = "no_partialchain", ty = "bit", bits = "4..=4")] + #[bitfield(name = "revoke_best_effort", ty = "bit", bits = "5..=5")] + #[bitfield(name = "native_ca_store", ty = "bit", bits = "6..=6")] + #[bitfield(name = "auto_client_cert", ty = "bit", bits = "7..=7")] + pub certinfo_falsestart_enable_beast_no_revoke_no_partialchain_revoke_best_effort_native_ca_store_auto_client_cert: [u8; 1], + #[bitfield(padding)] + pub c2rust_padding: [u8; 3], +} +pub type CURL_TLSAUTH = libc::c_uint; +pub const CURL_TLSAUTH_LAST: CURL_TLSAUTH = 2; +pub const CURL_TLSAUTH_SRP: CURL_TLSAUTH = 1; +pub const CURL_TLSAUTH_NONE: CURL_TLSAUTH = 0; +pub type curl_ssl_ctx_callback = Option::< + unsafe extern "C" fn(*mut CURL, *mut libc::c_void, *mut libc::c_void) -> CURLcode, +>; +pub type curl_proxytype = libc::c_uint; +pub const CURLPROXY_SOCKS5_HOSTNAME: curl_proxytype = 7; +pub const CURLPROXY_SOCKS4A: curl_proxytype = 6; +pub const CURLPROXY_SOCKS5: curl_proxytype = 5; +pub const CURLPROXY_SOCKS4: curl_proxytype = 4; +pub const CURLPROXY_HTTPS: curl_proxytype = 2; +pub const CURLPROXY_HTTP_1_0: curl_proxytype = 1; +pub const CURLPROXY_HTTP: curl_proxytype = 0; +pub type curl_TimeCond = libc::c_uint; +pub const CURL_TIMECOND_LAST: curl_TimeCond = 4; +pub const CURL_TIMECOND_LASTMOD: curl_TimeCond = 3; +pub const CURL_TIMECOND_IFUNMODSINCE: curl_TimeCond = 2; +pub const CURL_TIMECOND_IFMODSINCE: curl_TimeCond = 1; +pub const CURL_TIMECOND_NONE: curl_TimeCond = 0; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct curl_mimepart { + pub easy: *mut Curl_easy, + pub parent: *mut curl_mime, + pub nextpart: *mut curl_mimepart, + pub kind: mimekind, + pub flags: libc::c_uint, + pub data: *mut libc::c_char, + pub readfunc: curl_read_callback, + pub seekfunc: curl_seek_callback, + pub freefunc: curl_free_callback, + pub arg: *mut libc::c_void, + pub fp: *mut FILE, + pub curlheaders: *mut curl_slist, + pub userheaders: *mut curl_slist, + pub mimetype: *mut libc::c_char, + pub filename: *mut libc::c_char, + pub name: *mut libc::c_char, + pub datasize: curl_off_t, + pub state: mime_state, + pub encoder: *const mime_encoder, + pub encstate: mime_encoder_state, + pub lastreadstatus: size_t, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct mime_encoder_state { + pub pos: size_t, + pub bufbeg: size_t, + pub bufend: size_t, + pub buf: [libc::c_char; 256], +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct mime_encoder { + pub name: *const libc::c_char, + pub encodefunc: Option::< + unsafe extern "C" fn( + *mut libc::c_char, + size_t, + bool, + *mut curl_mimepart, + ) -> size_t, + >, + pub sizefunc: Option:: curl_off_t>, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct mime_state { + pub state: mimestate, + pub ptr: *mut libc::c_void, + pub offset: curl_off_t, +} +pub type mimestate = libc::c_uint; +pub const MIMESTATE_LAST: mimestate = 9; +pub const MIMESTATE_END: mimestate = 8; +pub const MIMESTATE_CONTENT: mimestate = 7; +pub const MIMESTATE_BOUNDARY2: mimestate = 6; +pub const MIMESTATE_BOUNDARY1: mimestate = 5; +pub const MIMESTATE_BODY: mimestate = 4; +pub const MIMESTATE_EOH: mimestate = 3; +pub const MIMESTATE_USERHEADERS: mimestate = 2; +pub const MIMESTATE_CURLHEADERS: mimestate = 1; +pub const MIMESTATE_BEGIN: mimestate = 0; +pub type curl_free_callback = Option:: ()>; +pub type curl_seek_callback = Option::< + unsafe extern "C" fn(*mut libc::c_void, curl_off_t, libc::c_int) -> libc::c_int, +>; +pub type mimekind = libc::c_uint; +pub const MIMEKIND_LAST: mimekind = 5; +pub const MIMEKIND_MULTIPART: mimekind = 4; +pub const MIMEKIND_CALLBACK: mimekind = 3; +pub const MIMEKIND_FILE: mimekind = 2; +pub const MIMEKIND_DATA: mimekind = 1; +pub const MIMEKIND_NONE: mimekind = 0; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct curl_mime { + pub easy: *mut Curl_easy, + pub parent: *mut curl_mimepart, + pub firstpart: *mut curl_mimepart, + pub lastpart: *mut curl_mimepart, + pub boundary: [libc::c_char; 41], + pub state: mime_state, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct curl_httppost { + pub next: *mut curl_httppost, + pub name: *mut libc::c_char, + pub namelength: libc::c_long, + pub contents: *mut libc::c_char, + pub contentslength: libc::c_long, + pub buffer: *mut libc::c_char, + pub bufferlength: libc::c_long, + pub contenttype: *mut libc::c_char, + pub contentheader: *mut curl_slist, + pub more: *mut curl_httppost, + pub flags: libc::c_long, + pub showfilename: *mut libc::c_char, + pub userp: *mut libc::c_void, + pub contentlen: curl_off_t, +} +pub type curl_hstswrite_callback = Option::< + unsafe extern "C" fn( + *mut CURL, + *mut curl_hstsentry, + *mut curl_index, + *mut libc::c_void, + ) -> CURLSTScode, +>; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct curl_index { + pub index: size_t, + pub total: size_t, +} +#[derive(Copy, Clone, BitfieldStruct)] +#[repr(C)] +pub struct curl_hstsentry { + pub name: *mut libc::c_char, + pub namelen: size_t, + #[bitfield(name = "includeSubDomains", ty = "libc::c_uint", bits = "0..=0")] + pub includeSubDomains: [u8; 1], + pub expire: [libc::c_char; 18], +} +pub type CURLSTScode = libc::c_uint; +pub const CURLSTS_FAIL: CURLSTScode = 2; +pub const CURLSTS_DONE: CURLSTScode = 1; +pub const CURLSTS_OK: CURLSTScode = 0; +pub type curl_hstsread_callback = Option::< + unsafe extern "C" fn( + *mut CURL, + *mut curl_hstsentry, + *mut libc::c_void, + ) -> CURLSTScode, +>; +pub type curl_conv_callback = Option::< + unsafe extern "C" fn(*mut libc::c_char, size_t) -> CURLcode, +>; +pub type curl_closesocket_callback = Option::< + unsafe extern "C" fn(*mut libc::c_void, curl_socket_t) -> libc::c_int, +>; +pub type curl_socket_t = libc::c_int; +pub type curl_opensocket_callback = Option::< + unsafe extern "C" fn( + *mut libc::c_void, + curlsocktype, + *mut curl_sockaddr, + ) -> curl_socket_t, +>; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct curl_sockaddr { + pub family: libc::c_int, + pub socktype: libc::c_int, + pub protocol: libc::c_int, + pub addrlen: libc::c_uint, + pub addr: sockaddr, +} +pub type curlsocktype = libc::c_uint; +pub const CURLSOCKTYPE_LAST: curlsocktype = 2; +pub const CURLSOCKTYPE_ACCEPT: curlsocktype = 1; +pub const CURLSOCKTYPE_IPCXN: curlsocktype = 0; +pub type curl_sockopt_callback = Option::< + unsafe extern "C" fn(*mut libc::c_void, curl_socket_t, curlsocktype) -> libc::c_int, +>; +pub type curl_ioctl_callback = Option::< + unsafe extern "C" fn(*mut CURL, libc::c_int, *mut libc::c_void) -> curlioerr, +>; +pub type curlioerr = libc::c_uint; +pub const CURLIOE_LAST: curlioerr = 3; +pub const CURLIOE_FAILRESTART: curlioerr = 2; +pub const CURLIOE_UNKNOWNCMD: curlioerr = 1; +pub const CURLIOE_OK: curlioerr = 0; +pub type curl_debug_callback = Option::< + unsafe extern "C" fn( + *mut CURL, + curl_infotype, + *mut libc::c_char, + size_t, + *mut libc::c_void, + ) -> libc::c_int, +>; +pub type curl_infotype = libc::c_uint; +pub const CURLINFO_END: curl_infotype = 7; +pub const CURLINFO_SSL_DATA_OUT: curl_infotype = 6; +pub const CURLINFO_SSL_DATA_IN: curl_infotype = 5; +pub const CURLINFO_DATA_OUT: curl_infotype = 4; +pub const CURLINFO_DATA_IN: curl_infotype = 3; +pub const CURLINFO_HEADER_OUT: curl_infotype = 2; +pub const CURLINFO_HEADER_IN: curl_infotype = 1; +pub const CURLINFO_TEXT: curl_infotype = 0; +pub type curl_xferinfo_callback = Option::< + unsafe extern "C" fn( + *mut libc::c_void, + curl_off_t, + curl_off_t, + curl_off_t, + curl_off_t, + ) -> libc::c_int, +>; +pub type curl_progress_callback = Option::< + unsafe extern "C" fn( + *mut libc::c_void, + libc::c_double, + libc::c_double, + libc::c_double, + libc::c_double, + ) -> libc::c_int, +>; +pub type curl_write_callback = Option::< + unsafe extern "C" fn(*mut libc::c_char, size_t, size_t, *mut libc::c_void) -> size_t, +>; +#[derive(Copy, Clone, BitfieldStruct)] +#[repr(C)] +pub struct SingleRequest { + pub size: curl_off_t, + pub maxdownload: curl_off_t, + pub bytecount: curl_off_t, + pub writebytecount: curl_off_t, + pub headerbytecount: curl_off_t, + pub deductheadercount: curl_off_t, + pub pendingheader: curl_off_t, + pub start: curltime, + pub now: curltime, + pub badheader: C2RustUnnamed_1, + pub headerline: libc::c_int, + pub str_0: *mut libc::c_char, + pub offset: curl_off_t, + pub httpcode: libc::c_int, + pub keepon: libc::c_int, + pub start100: curltime, + pub exp100: expect100, + pub upgr101: upgrade101, + pub writer_stack: *mut contenc_writer, + pub timeofdoc: time_t, + pub bodywrites: libc::c_long, + pub location: *mut libc::c_char, + pub newurl: *mut libc::c_char, + pub upload_present: ssize_t, + pub upload_fromhere: *mut libc::c_char, + pub p: C2RustUnnamed, + pub doh: *mut dohdata, + #[bitfield(name = "header", ty = "bit", bits = "0..=0")] + #[bitfield(name = "content_range", ty = "bit", bits = "1..=1")] + #[bitfield(name = "upload_done", ty = "bit", bits = "2..=2")] + #[bitfield(name = "ignorebody", ty = "bit", bits = "3..=3")] + #[bitfield(name = "http_bodyless", ty = "bit", bits = "4..=4")] + #[bitfield(name = "chunk", ty = "bit", bits = "5..=5")] + #[bitfield(name = "ignore_cl", ty = "bit", bits = "6..=6")] + #[bitfield(name = "upload_chunky", ty = "bit", bits = "7..=7")] + #[bitfield(name = "getheader", ty = "bit", bits = "8..=8")] + #[bitfield(name = "forbidchunk", ty = "bit", bits = "9..=9")] + pub header_content_range_upload_done_ignorebody_http_bodyless_chunk_ignore_cl_upload_chunky_getheader_forbidchunk: [u8; 2], + #[bitfield(padding)] + pub c2rust_padding: [u8; 6], +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct dohdata { + pub headers: *mut curl_slist, + pub probe: [dnsprobe; 2], + pub pending: libc::c_uint, + pub port: libc::c_int, + pub host: *const libc::c_char, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct dnsprobe { + pub easy: *mut CURL, + pub dnstype: libc::c_int, + pub dohbuffer: [libc::c_uchar; 512], + pub dohlen: size_t, + pub serverdoh: dynbuf, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub union C2RustUnnamed { + pub file: *mut FILEPROTO, + pub ftp: *mut FTP, + pub http: *mut HTTP, + pub imap: *mut IMAP, + pub ldap: *mut ldapreqinfo, + pub mqtt: *mut MQTT, + pub pop3: *mut POP3, + pub rtsp: *mut RTSP, + pub smb: *mut smb_request, + pub smtp: *mut SMTP, + pub ssh: *mut SSHPROTO, + pub telnet: *mut TELNET, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct SSHPROTO { + pub path: *mut libc::c_char, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct SMTP { + pub transfer: curl_pp_transfer, + pub custom: *mut libc::c_char, + pub rcpt: *mut curl_slist, + pub rcpt_had_ok: bool, + pub trailing_crlf: bool, + pub rcpt_last_error: libc::c_int, + pub eob: size_t, +} +pub type curl_pp_transfer = libc::c_uint; +pub const PPTRANSFER_NONE: curl_pp_transfer = 2; +pub const PPTRANSFER_INFO: curl_pp_transfer = 1; +pub const PPTRANSFER_BODY: curl_pp_transfer = 0; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct RTSP { + pub http_wrapper: HTTP, + pub CSeq_sent: libc::c_long, + pub CSeq_recv: libc::c_long, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct HTTP { + pub sendit: *mut curl_mimepart, + pub postsize: curl_off_t, + pub postdata: *const libc::c_char, + pub p_pragma: *const libc::c_char, + pub form: curl_mimepart, + pub backup: back, + pub sending: C2RustUnnamed_0, + pub send_buffer: dynbuf, + pub stream_id: int32_t, + pub bodystarted: bool, + pub header_recvbuf: dynbuf, + pub nread_header_recvbuf: size_t, + pub trailer_recvbuf: dynbuf, + pub status_code: libc::c_int, + pub pausedata: *const uint8_t, + pub pauselen: size_t, + pub close_handled: bool, + pub push_headers: *mut *mut libc::c_char, + pub push_headers_used: size_t, + pub push_headers_alloc: size_t, + pub error: uint32_t, + pub closed: bool, + pub mem: *mut libc::c_char, + pub len: size_t, + pub memlen: size_t, + pub upload_mem: *const uint8_t, + pub upload_len: size_t, + pub upload_left: curl_off_t, +} +pub type uint8_t = __uint8_t; +pub type uint32_t = __uint32_t; +pub type C2RustUnnamed_0 = libc::c_uint; +pub const HTTPSEND_BODY: C2RustUnnamed_0 = 2; +pub const HTTPSEND_REQUEST: C2RustUnnamed_0 = 1; +pub const HTTPSEND_NADA: C2RustUnnamed_0 = 0; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct back { + pub fread_func: curl_read_callback, + pub fread_in: *mut libc::c_void, + pub postdata: *const libc::c_char, + pub postsize: curl_off_t, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct POP3 { + pub transfer: curl_pp_transfer, + pub id: *mut libc::c_char, + pub custom: *mut libc::c_char, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct MQTT { + pub sendleftovers: *mut libc::c_char, + pub nsend: size_t, + pub npacket: size_t, + pub firstbyte: libc::c_uchar, + pub remaining_length: size_t, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct IMAP { + pub transfer: curl_pp_transfer, + pub mailbox: *mut libc::c_char, + pub uidvalidity: *mut libc::c_char, + pub uid: *mut libc::c_char, + pub mindex: *mut libc::c_char, + pub section: *mut libc::c_char, + pub partial: *mut libc::c_char, + pub query: *mut libc::c_char, + pub custom: *mut libc::c_char, + pub custom_params: *mut libc::c_char, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct FTP { + pub path: *mut libc::c_char, + pub pathalloc: *mut libc::c_char, + pub transfer: curl_pp_transfer, + pub downloadsize: curl_off_t, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct FILEPROTO { + pub path: *mut libc::c_char, + pub freepath: *mut libc::c_char, + pub fd: libc::c_int, +} +pub type upgrade101 = libc::c_uint; +pub const UPGR101_WORKING: upgrade101 = 3; +pub const UPGR101_RECEIVED: upgrade101 = 2; +pub const UPGR101_REQUESTED: upgrade101 = 1; +pub const UPGR101_INIT: upgrade101 = 0; +pub type expect100 = libc::c_uint; +pub const EXP100_FAILED: expect100 = 3; +pub const EXP100_SENDING_REQUEST: expect100 = 2; +pub const EXP100_AWAITING_CONTINUE: expect100 = 1; +pub const EXP100_SEND_DATA: expect100 = 0; +pub type C2RustUnnamed_1 = libc::c_uint; +pub const HEADER_ALLBAD: C2RustUnnamed_1 = 2; +pub const HEADER_PARTHEADER: C2RustUnnamed_1 = 1; +pub const HEADER_NORMAL: C2RustUnnamed_1 = 0; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct PslCache { + pub psl: *const psl_ctx_t, + pub expires: time_t, + pub dynamic: bool, +} +pub type psl_ctx_t = psl_ctx_st; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct Curl_multi { + pub magic: libc::c_uint, + pub easyp: *mut Curl_easy, + pub easylp: *mut Curl_easy, + pub num_easy: libc::c_int, + pub num_alive: libc::c_int, + pub msglist: Curl_llist, + pub pending: Curl_llist, + pub socket_cb: curl_socket_callback, + pub socket_userp: *mut libc::c_void, + pub push_cb: curl_push_callback, + pub push_userp: *mut libc::c_void, + pub hostcache: Curl_hash, + pub psl: PslCache, + pub timetree: *mut Curl_tree, + pub sockhash: Curl_hash, + pub conn_cache: conncache, + pub maxconnects: libc::c_long, + pub max_host_connections: libc::c_long, + pub max_total_connections: libc::c_long, + pub timer_cb: curl_multi_timer_callback, + pub timer_userp: *mut libc::c_void, + pub timer_lastcall: curltime, + pub max_concurrent_streams: libc::c_uint, + pub wakeup_pair: [curl_socket_t; 2], + pub multiplexing: bool, + pub recheckstate: bool, + pub in_callback: bool, + pub ipv6_works: bool, + pub ssl_seeded: bool, +} +pub type curl_multi_timer_callback = Option::< + unsafe extern "C" fn(*mut CURLM, libc::c_long, *mut libc::c_void) -> libc::c_int, +>; +pub type CURLM = Curl_multi; +pub type curl_push_callback = Option::< + unsafe extern "C" fn( + *mut CURL, + *mut CURL, + size_t, + *mut curl_pushheaders, + *mut libc::c_void, + ) -> libc::c_int, +>; +pub type curl_socket_callback = Option::< + unsafe extern "C" fn( + *mut CURL, + curl_socket_t, + libc::c_int, + *mut libc::c_void, + *mut libc::c_void, + ) -> libc::c_int, +>; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct Names { + pub hostcache: *mut Curl_hash, + pub hostcachetype: C2RustUnnamed_2, +} +pub type C2RustUnnamed_2 = libc::c_uint; +pub const HCACHE_SHARED: C2RustUnnamed_2 = 2; +pub const HCACHE_MULTI: C2RustUnnamed_2 = 1; +pub const HCACHE_NONE: C2RustUnnamed_2 = 0; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct Curl_message { + pub list: Curl_llist_element, + pub extmsg: CURLMsg, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct CURLMsg { + pub msg: CURLMSG, + pub easy_handle: *mut CURL, + pub data: C2RustUnnamed_3, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub union C2RustUnnamed_3 { + pub whatever: *mut libc::c_void, + pub result: CURLcode, +} +pub type CURLMSG = libc::c_uint; +pub const CURLMSG_LAST: CURLMSG = 2; +pub const CURLMSG_DONE: CURLMSG = 1; +pub const CURLMSG_NONE: CURLMSG = 0; +pub type CURLMstate = libc::c_uint; +pub const MSTATE_LAST: CURLMstate = 17; +pub const MSTATE_MSGSENT: CURLMstate = 16; +pub const MSTATE_COMPLETED: CURLMstate = 15; +pub const MSTATE_DONE: CURLMstate = 14; +pub const MSTATE_RATELIMITING: CURLMstate = 13; +pub const MSTATE_PERFORMING: CURLMstate = 12; +pub const MSTATE_DID: CURLMstate = 11; +pub const MSTATE_DOING_MORE: CURLMstate = 10; +pub const MSTATE_DOING: CURLMstate = 9; +pub const MSTATE_DO: CURLMstate = 8; +pub const MSTATE_PROTOCONNECTING: CURLMstate = 7; +pub const MSTATE_PROTOCONNECT: CURLMstate = 6; +pub const MSTATE_TUNNELING: CURLMstate = 5; +pub const MSTATE_CONNECTING: CURLMstate = 4; +pub const MSTATE_RESOLVING: CURLMstate = 3; +pub const MSTATE_CONNECT: CURLMstate = 2; +pub const MSTATE_PENDING: CURLMstate = 1; +pub const MSTATE_INIT: CURLMstate = 0; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct connectdata { + pub cnnct: connstate, + pub bundle_node: Curl_llist_element, + pub chunk: Curl_chunker, + pub fclosesocket: curl_closesocket_callback, + pub closesocket_client: *mut libc::c_void, + pub connection_id: libc::c_long, + pub dns_entry: *mut Curl_dns_entry, + pub ip_addr: *mut Curl_addrinfo, + pub tempaddr: [*mut Curl_addrinfo; 2], + pub scope_id: libc::c_uint, + pub transport: C2RustUnnamed_5, + pub host: hostname, + pub hostname_resolve: *mut libc::c_char, + pub secondaryhostname: *mut libc::c_char, + pub conn_to_host: hostname, + pub socks_proxy: proxy_info, + pub http_proxy: proxy_info, + pub port: libc::c_int, + pub remote_port: libc::c_int, + pub conn_to_port: libc::c_int, + pub secondary_port: libc::c_ushort, + pub primary_ip: [libc::c_char; 46], + pub ip_version: libc::c_uchar, + pub user: *mut libc::c_char, + pub passwd: *mut libc::c_char, + pub options: *mut libc::c_char, + pub sasl_authzid: *mut libc::c_char, + pub httpversion: libc::c_uchar, + pub now: curltime, + pub created: curltime, + pub lastused: curltime, + pub sock: [curl_socket_t; 2], + pub tempsock: [curl_socket_t; 2], + pub tempfamily: [libc::c_int; 2], + pub recv: [Option::; 2], + pub send: [Option::; 2], + pub ssl: [ssl_connect_data; 2], + pub proxy_ssl: [ssl_connect_data; 2], + pub ssl_extra: *mut libc::c_void, + pub ssl_config: ssl_primary_config, + pub proxy_ssl_config: ssl_primary_config, + pub bits: ConnectBits, + pub num_addr: libc::c_int, + pub connecttime: curltime, + pub timeoutms_per_addr: [timediff_t; 2], + pub handler: *const Curl_handler, + pub given: *const Curl_handler, + pub keepalive: curltime, + pub sockfd: curl_socket_t, + pub writesockfd: curl_socket_t, + pub easyq: Curl_llist, + pub seek_func: curl_seek_callback, + pub seek_client: *mut libc::c_void, + pub http_ntlm_state: curlntlm, + pub proxy_ntlm_state: curlntlm, + pub ntlm: ntlmdata, + pub proxyntlm: ntlmdata, + pub trailer: dynbuf, + pub proto: C2RustUnnamed_4, + pub connect_state: *mut http_connect_state, + pub bundle: *mut connectbundle, + pub unix_domain_socket: *mut libc::c_char, + pub localdev: *mut libc::c_char, + pub localportrange: libc::c_int, + pub cselect_bits: libc::c_int, + pub waitfor: libc::c_int, + pub negnpn: libc::c_int, + pub localport: libc::c_ushort, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct connectbundle { + pub multiuse: libc::c_int, + pub num_connections: size_t, + pub conn_list: Curl_llist, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub union C2RustUnnamed_4 { + pub ftpc: ftp_conn, + pub httpc: http_conn, + pub sshc: ssh_conn, + pub tftpc: *mut tftp_state_data, + pub imapc: imap_conn, + pub pop3c: pop3_conn, + pub smtpc: smtp_conn, + pub rtspc: rtsp_conn, + pub smbc: smb_conn, + pub rtmp: *mut libc::c_void, + pub ldapc: *mut ldapconninfo, + pub mqtt: mqtt_conn, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct mqtt_conn { + pub state: mqttstate, + pub nextstate: mqttstate, + pub packetid: libc::c_uint, +} +pub type mqttstate = libc::c_uint; +pub const MQTT_NOSTATE: mqttstate = 7; +pub const MQTT_PUB_REMAIN: mqttstate = 6; +pub const MQTT_PUBWAIT: mqttstate = 5; +pub const MQTT_SUBACK_COMING: mqttstate = 4; +pub const MQTT_SUBACK: mqttstate = 3; +pub const MQTT_CONNACK: mqttstate = 2; +pub const MQTT_REMAINING_LENGTH: mqttstate = 1; +pub const MQTT_FIRST: mqttstate = 0; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct smb_conn { + pub state: smb_conn_state, + pub user: *mut libc::c_char, + pub domain: *mut libc::c_char, + pub share: *mut libc::c_char, + pub challenge: [libc::c_uchar; 8], + pub session_key: libc::c_uint, + pub uid: libc::c_ushort, + pub recv_buf: *mut libc::c_char, + pub upload_size: size_t, + pub send_size: size_t, + pub sent: size_t, + pub got: size_t, +} +pub type smb_conn_state = libc::c_uint; +pub const SMB_CONNECTED: smb_conn_state = 4; +pub const SMB_SETUP: smb_conn_state = 3; +pub const SMB_NEGOTIATE: smb_conn_state = 2; +pub const SMB_CONNECTING: smb_conn_state = 1; +pub const SMB_NOT_CONNECTED: smb_conn_state = 0; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct rtsp_conn { + pub rtp_buf: *mut libc::c_char, + pub rtp_bufsize: ssize_t, + pub rtp_channel: libc::c_int, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct smtp_conn { + pub pp: pingpong, + pub state: smtpstate, + pub ssldone: bool, + pub domain: *mut libc::c_char, + pub sasl: SASL, + pub tls_supported: bool, + pub size_supported: bool, + pub utf8_supported: bool, + pub auth_supported: bool, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct SASL { + pub params: *const SASLproto, + pub state: saslstate, + pub authmechs: libc::c_ushort, + pub prefmech: libc::c_ushort, + pub authused: libc::c_ushort, + pub resetprefs: bool, + pub mutual_auth: bool, + pub force_ir: bool, +} +pub type saslstate = libc::c_uint; +pub const SASL_FINAL: saslstate = 17; +pub const SASL_CANCEL: saslstate = 16; +pub const SASL_GSASL: saslstate = 15; +pub const SASL_OAUTH2_RESP: saslstate = 14; +pub const SASL_OAUTH2: saslstate = 13; +pub const SASL_GSSAPI_NO_DATA: saslstate = 12; +pub const SASL_GSSAPI_TOKEN: saslstate = 11; +pub const SASL_GSSAPI: saslstate = 10; +pub const SASL_NTLM_TYPE2MSG: saslstate = 9; +pub const SASL_NTLM: saslstate = 8; +pub const SASL_DIGESTMD5_RESP: saslstate = 7; +pub const SASL_DIGESTMD5: saslstate = 6; +pub const SASL_CRAMMD5: saslstate = 5; +pub const SASL_EXTERNAL: saslstate = 4; +pub const SASL_LOGIN_PASSWD: saslstate = 3; +pub const SASL_LOGIN: saslstate = 2; +pub const SASL_PLAIN: saslstate = 1; +pub const SASL_STOP: saslstate = 0; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct SASLproto { + pub service: *const libc::c_char, + pub contcode: libc::c_int, + pub finalcode: libc::c_int, + pub maxirlen: size_t, + pub sendauth: Option::< + unsafe extern "C" fn( + *mut Curl_easy, + *mut connectdata, + *const libc::c_char, + *const libc::c_char, + ) -> CURLcode, + >, + pub sendcont: Option::< + unsafe extern "C" fn( + *mut Curl_easy, + *mut connectdata, + *const libc::c_char, + ) -> CURLcode, + >, + pub getmessage: Option::< + unsafe extern "C" fn(*mut libc::c_char, *mut *mut libc::c_char) -> (), + >, +} +pub type smtpstate = libc::c_uint; +pub const SMTP_LAST: smtpstate = 13; +pub const SMTP_QUIT: smtpstate = 12; +pub const SMTP_POSTDATA: smtpstate = 11; +pub const SMTP_DATA: smtpstate = 10; +pub const SMTP_RCPT: smtpstate = 9; +pub const SMTP_MAIL: smtpstate = 8; +pub const SMTP_COMMAND: smtpstate = 7; +pub const SMTP_AUTH: smtpstate = 6; +pub const SMTP_UPGRADETLS: smtpstate = 5; +pub const SMTP_STARTTLS: smtpstate = 4; +pub const SMTP_HELO: smtpstate = 3; +pub const SMTP_EHLO: smtpstate = 2; +pub const SMTP_SERVERGREET: smtpstate = 1; +pub const SMTP_STOP: smtpstate = 0; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct pingpong { + pub cache: *mut libc::c_char, + pub cache_size: size_t, + pub nread_resp: size_t, + pub linestart_resp: *mut libc::c_char, + pub pending_resp: bool, + pub sendthis: *mut libc::c_char, + pub sendleft: size_t, + pub sendsize: size_t, + pub response: curltime, + pub response_time: timediff_t, + pub sendbuf: dynbuf, + pub statemachine: Option::< + unsafe extern "C" fn(*mut Curl_easy, *mut connectdata) -> CURLcode, + >, + pub endofresp: Option::< + unsafe extern "C" fn( + *mut Curl_easy, + *mut connectdata, + *mut libc::c_char, + size_t, + *mut libc::c_int, + ) -> bool, + >, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct pop3_conn { + pub pp: pingpong, + pub state: pop3state, + pub ssldone: bool, + pub tls_supported: bool, + pub eob: size_t, + pub strip: size_t, + pub sasl: SASL, + pub authtypes: libc::c_uint, + pub preftype: libc::c_uint, + pub apoptimestamp: *mut libc::c_char, +} +pub type pop3state = libc::c_uint; +pub const POP3_LAST: pop3state = 11; +pub const POP3_QUIT: pop3state = 10; +pub const POP3_COMMAND: pop3state = 9; +pub const POP3_PASS: pop3state = 8; +pub const POP3_USER: pop3state = 7; +pub const POP3_APOP: pop3state = 6; +pub const POP3_AUTH: pop3state = 5; +pub const POP3_UPGRADETLS: pop3state = 4; +pub const POP3_STARTTLS: pop3state = 3; +pub const POP3_CAPA: pop3state = 2; +pub const POP3_SERVERGREET: pop3state = 1; +pub const POP3_STOP: pop3state = 0; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct imap_conn { + pub pp: pingpong, + pub state: imapstate, + pub ssldone: bool, + pub preauth: bool, + pub sasl: SASL, + pub preftype: libc::c_uint, + pub cmdid: libc::c_uint, + pub resptag: [libc::c_char; 5], + pub tls_supported: bool, + pub login_disabled: bool, + pub ir_supported: bool, + pub mailbox: *mut libc::c_char, + pub mailbox_uidvalidity: *mut libc::c_char, + pub dyn_0: dynbuf, +} +pub type imapstate = libc::c_uint; +pub const IMAP_LAST: imapstate = 15; +pub const IMAP_LOGOUT: imapstate = 14; +pub const IMAP_SEARCH: imapstate = 13; +pub const IMAP_APPEND_FINAL: imapstate = 12; +pub const IMAP_APPEND: imapstate = 11; +pub const IMAP_FETCH_FINAL: imapstate = 10; +pub const IMAP_FETCH: imapstate = 9; +pub const IMAP_SELECT: imapstate = 8; +pub const IMAP_LIST: imapstate = 7; +pub const IMAP_LOGIN: imapstate = 6; +pub const IMAP_AUTHENTICATE: imapstate = 5; +pub const IMAP_UPGRADETLS: imapstate = 4; +pub const IMAP_STARTTLS: imapstate = 3; +pub const IMAP_CAPABILITY: imapstate = 2; +pub const IMAP_SERVERGREET: imapstate = 1; +pub const IMAP_STOP: imapstate = 0; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct ssh_conn { + pub authlist: *const libc::c_char, + pub passphrase: *const libc::c_char, + pub rsa_pub: *mut libc::c_char, + pub rsa: *mut libc::c_char, + pub authed: bool, + pub acceptfail: bool, + pub state: sshstate, + pub nextstate: sshstate, + pub actualcode: CURLcode, + pub quote_item: *mut curl_slist, + pub quote_path1: *mut libc::c_char, + pub quote_path2: *mut libc::c_char, + pub homedir: *mut libc::c_char, + pub readdir_line: *mut libc::c_char, + pub secondCreateDirs: libc::c_int, + pub orig_waitfor: libc::c_int, + pub slash_pos: *mut libc::c_char, +} +pub type sshstate = libc::c_int; +pub const SSH_LAST: sshstate = 60; +pub const SSH_QUIT: sshstate = 59; +pub const SSH_SESSION_FREE: sshstate = 58; +pub const SSH_SESSION_DISCONNECT: sshstate = 57; +pub const SSH_SCP_CHANNEL_FREE: sshstate = 56; +pub const SSH_SCP_WAIT_CLOSE: sshstate = 55; +pub const SSH_SCP_WAIT_EOF: sshstate = 54; +pub const SSH_SCP_SEND_EOF: sshstate = 53; +pub const SSH_SCP_DONE: sshstate = 52; +pub const SSH_SCP_DOWNLOAD: sshstate = 51; +pub const SSH_SCP_DOWNLOAD_INIT: sshstate = 50; +pub const SSH_SCP_UPLOAD_INIT: sshstate = 49; +pub const SSH_SCP_TRANS_INIT: sshstate = 48; +pub const SSH_SFTP_SHUTDOWN: sshstate = 47; +pub const SSH_SFTP_CLOSE: sshstate = 46; +pub const SSH_SFTP_DOWNLOAD_STAT: sshstate = 45; +pub const SSH_SFTP_DOWNLOAD_INIT: sshstate = 44; +pub const SSH_SFTP_READDIR_DONE: sshstate = 43; +pub const SSH_SFTP_READDIR_BOTTOM: sshstate = 42; +pub const SSH_SFTP_READDIR_LINK: sshstate = 41; +pub const SSH_SFTP_READDIR: sshstate = 40; +pub const SSH_SFTP_READDIR_INIT: sshstate = 39; +pub const SSH_SFTP_CREATE_DIRS_MKDIR: sshstate = 38; +pub const SSH_SFTP_CREATE_DIRS: sshstate = 37; +pub const SSH_SFTP_CREATE_DIRS_INIT: sshstate = 36; +pub const SSH_SFTP_UPLOAD_INIT: sshstate = 35; +pub const SSH_SFTP_TRANS_INIT: sshstate = 34; +pub const SSH_SFTP_FILETIME: sshstate = 33; +pub const SSH_SFTP_GETINFO: sshstate = 32; +pub const SSH_SFTP_QUOTE_STATVFS: sshstate = 31; +pub const SSH_SFTP_QUOTE_UNLINK: sshstate = 30; +pub const SSH_SFTP_QUOTE_RMDIR: sshstate = 29; +pub const SSH_SFTP_QUOTE_RENAME: sshstate = 28; +pub const SSH_SFTP_QUOTE_MKDIR: sshstate = 27; +pub const SSH_SFTP_QUOTE_SYMLINK: sshstate = 26; +pub const SSH_SFTP_QUOTE_SETSTAT: sshstate = 25; +pub const SSH_SFTP_QUOTE_STAT: sshstate = 24; +pub const SSH_SFTP_NEXT_QUOTE: sshstate = 23; +pub const SSH_SFTP_QUOTE: sshstate = 22; +pub const SSH_SFTP_POSTQUOTE_INIT: sshstate = 21; +pub const SSH_SFTP_QUOTE_INIT: sshstate = 20; +pub const SSH_SFTP_REALPATH: sshstate = 19; +pub const SSH_SFTP_INIT: sshstate = 18; +pub const SSH_AUTH_DONE: sshstate = 17; +pub const SSH_AUTH_GSSAPI: sshstate = 16; +pub const SSH_AUTH_KEY: sshstate = 15; +pub const SSH_AUTH_KEY_INIT: sshstate = 14; +pub const SSH_AUTH_HOST: sshstate = 13; +pub const SSH_AUTH_HOST_INIT: sshstate = 12; +pub const SSH_AUTH_AGENT: sshstate = 11; +pub const SSH_AUTH_AGENT_LIST: sshstate = 10; +pub const SSH_AUTH_AGENT_INIT: sshstate = 9; +pub const SSH_AUTH_PASS: sshstate = 8; +pub const SSH_AUTH_PASS_INIT: sshstate = 7; +pub const SSH_AUTH_PKEY: sshstate = 6; +pub const SSH_AUTH_PKEY_INIT: sshstate = 5; +pub const SSH_AUTHLIST: sshstate = 4; +pub const SSH_HOSTKEY: sshstate = 3; +pub const SSH_S_STARTUP: sshstate = 2; +pub const SSH_INIT: sshstate = 1; +pub const SSH_STOP: sshstate = 0; +pub const SSH_NO_STATE: sshstate = -1; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct http_conn { + pub binsettings: [uint8_t; 80], + pub binlen: size_t, + pub trnsfr: *mut Curl_easy, + pub h2: *mut nghttp2_session, + pub send_underlying: Option::, + pub recv_underlying: Option::, + pub inbuf: *mut libc::c_char, + pub inbuflen: size_t, + pub nread_inbuf: size_t, + pub pause_stream_id: int32_t, + pub drain_total: size_t, + pub settings: h2settings, + pub local_settings: [nghttp2_settings_entry; 3], + pub local_settings_num: size_t, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct nghttp2_settings_entry { + pub settings_id: int32_t, + pub value: uint32_t, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct h2settings { + pub max_concurrent_streams: uint32_t, + pub enable_push: bool, +} +pub type Curl_recv = unsafe extern "C" fn( + *mut Curl_easy, + libc::c_int, + *mut libc::c_char, + size_t, + *mut CURLcode, +) -> ssize_t; +pub type Curl_send = unsafe extern "C" fn( + *mut Curl_easy, + libc::c_int, + *const libc::c_void, + size_t, + *mut CURLcode, +) -> ssize_t; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct ftp_conn { + pub pp: pingpong, + pub entrypath: *mut libc::c_char, + pub file: *mut libc::c_char, + pub dirs: *mut *mut libc::c_char, + pub dirdepth: libc::c_int, + pub dont_check: bool, + pub ctl_valid: bool, + pub cwddone: bool, + pub cwdcount: libc::c_int, + pub cwdfail: bool, + pub wait_data_conn: bool, + pub newport: libc::c_ushort, + pub newhost: *mut libc::c_char, + pub prevpath: *mut libc::c_char, + pub transfertype: libc::c_char, + pub count1: libc::c_int, + pub count2: libc::c_int, + pub count3: libc::c_int, + pub state: ftpstate, + pub state_saved: ftpstate, + pub retr_size_saved: curl_off_t, + pub server_os: *mut libc::c_char, + pub known_filesize: curl_off_t, +} +pub type ftpstate = libc::c_uint; +pub const FTP_LAST: ftpstate = 35; +pub const FTP_QUIT: ftpstate = 34; +pub const FTP_STOR: ftpstate = 33; +pub const FTP_RETR: ftpstate = 32; +pub const FTP_LIST: ftpstate = 31; +pub const FTP_PASV: ftpstate = 30; +pub const FTP_PRET: ftpstate = 29; +pub const FTP_PORT: ftpstate = 28; +pub const FTP_RETR_REST: ftpstate = 27; +pub const FTP_REST: ftpstate = 26; +pub const FTP_STOR_SIZE: ftpstate = 25; +pub const FTP_RETR_SIZE: ftpstate = 24; +pub const FTP_SIZE: ftpstate = 23; +pub const FTP_STOR_TYPE: ftpstate = 22; +pub const FTP_RETR_TYPE: ftpstate = 21; +pub const FTP_LIST_TYPE: ftpstate = 20; +pub const FTP_TYPE: ftpstate = 19; +pub const FTP_MDTM: ftpstate = 18; +pub const FTP_MKD: ftpstate = 17; +pub const FTP_CWD: ftpstate = 16; +pub const FTP_POSTQUOTE: ftpstate = 15; +pub const FTP_STOR_PREQUOTE: ftpstate = 14; +pub const FTP_RETR_PREQUOTE: ftpstate = 13; +pub const FTP_QUOTE: ftpstate = 12; +pub const FTP_NAMEFMT: ftpstate = 11; +pub const FTP_SYST: ftpstate = 10; +pub const FTP_PWD: ftpstate = 9; +pub const FTP_CCC: ftpstate = 8; +pub const FTP_PROT: ftpstate = 7; +pub const FTP_PBSZ: ftpstate = 6; +pub const FTP_ACCT: ftpstate = 5; +pub const FTP_PASS: ftpstate = 4; +pub const FTP_USER: ftpstate = 3; +pub const FTP_AUTH: ftpstate = 2; +pub const FTP_WAIT220: ftpstate = 1; +pub const FTP_STOP: ftpstate = 0; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct ntlmdata { + pub flags: libc::c_uint, + pub nonce: [libc::c_uchar; 8], + pub target_info_len: libc::c_uint, + pub target_info: *mut libc::c_void, + pub ntlm_auth_hlpr_socket: curl_socket_t, + pub ntlm_auth_hlpr_pid: pid_t, + pub challenge: *mut libc::c_char, + pub response: *mut libc::c_char, +} +pub type curlntlm = libc::c_uint; +pub const NTLMSTATE_LAST: curlntlm = 4; +pub const NTLMSTATE_TYPE3: curlntlm = 3; +pub const NTLMSTATE_TYPE2: curlntlm = 2; +pub const NTLMSTATE_TYPE1: curlntlm = 1; +pub const NTLMSTATE_NONE: curlntlm = 0; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct Curl_handler { + pub scheme: *const libc::c_char, + pub setup_connection: Option::< + unsafe extern "C" fn(*mut Curl_easy, *mut connectdata) -> CURLcode, + >, + pub do_it: Option:: CURLcode>, + pub done: Option:: CURLcode>, + pub do_more: Option::< + unsafe extern "C" fn(*mut Curl_easy, *mut libc::c_int) -> CURLcode, + >, + pub connect_it: Option::< + unsafe extern "C" fn(*mut Curl_easy, *mut bool) -> CURLcode, + >, + pub connecting: Option::< + unsafe extern "C" fn(*mut Curl_easy, *mut bool) -> CURLcode, + >, + pub doing: Option:: CURLcode>, + pub proto_getsock: Option::< + unsafe extern "C" fn( + *mut Curl_easy, + *mut connectdata, + *mut curl_socket_t, + ) -> libc::c_int, + >, + pub doing_getsock: Option::< + unsafe extern "C" fn( + *mut Curl_easy, + *mut connectdata, + *mut curl_socket_t, + ) -> libc::c_int, + >, + pub domore_getsock: Option::< + unsafe extern "C" fn( + *mut Curl_easy, + *mut connectdata, + *mut curl_socket_t, + ) -> libc::c_int, + >, + pub perform_getsock: Option::< + unsafe extern "C" fn( + *mut Curl_easy, + *mut connectdata, + *mut curl_socket_t, + ) -> libc::c_int, + >, + pub disconnect: Option::< + unsafe extern "C" fn(*mut Curl_easy, *mut connectdata, bool) -> CURLcode, + >, + pub readwrite: Option::< + unsafe extern "C" fn( + *mut Curl_easy, + *mut connectdata, + *mut ssize_t, + *mut bool, + ) -> CURLcode, + >, + pub connection_check: Option::< + unsafe extern "C" fn( + *mut Curl_easy, + *mut connectdata, + libc::c_uint, + ) -> libc::c_uint, + >, + pub attach: Option:: ()>, + pub defport: libc::c_int, + pub protocol: libc::c_uint, + pub family: libc::c_uint, + pub flags: libc::c_uint, +} +#[derive(Copy, Clone, BitfieldStruct)] +#[repr(C)] +pub struct ConnectBits { + pub tcpconnect: [bool; 2], + pub proxy_ssl_connected: [bool; 2], + #[bitfield(name = "httpproxy", ty = "bit", bits = "0..=0")] + #[bitfield(name = "socksproxy", ty = "bit", bits = "1..=1")] + #[bitfield(name = "proxy_user_passwd", ty = "bit", bits = "2..=2")] + #[bitfield(name = "tunnel_proxy", ty = "bit", bits = "3..=3")] + #[bitfield(name = "proxy_connect_closed", ty = "bit", bits = "4..=4")] + #[bitfield(name = "close", ty = "bit", bits = "5..=5")] + #[bitfield(name = "reuse", ty = "bit", bits = "6..=6")] + #[bitfield(name = "altused", ty = "bit", bits = "7..=7")] + #[bitfield(name = "conn_to_host", ty = "bit", bits = "8..=8")] + #[bitfield(name = "conn_to_port", ty = "bit", bits = "9..=9")] + #[bitfield(name = "proxy", ty = "bit", bits = "10..=10")] + #[bitfield(name = "user_passwd", ty = "bit", bits = "11..=11")] + #[bitfield(name = "ipv6_ip", ty = "bit", bits = "12..=12")] + #[bitfield(name = "ipv6", ty = "bit", bits = "13..=13")] + #[bitfield(name = "do_more", ty = "bit", bits = "14..=14")] + #[bitfield(name = "protoconnstart", ty = "bit", bits = "15..=15")] + #[bitfield(name = "retry", ty = "bit", bits = "16..=16")] + #[bitfield(name = "authneg", ty = "bit", bits = "17..=17")] + #[bitfield(name = "rewindaftersend", ty = "bit", bits = "18..=18")] + #[bitfield(name = "ftp_use_epsv", ty = "bit", bits = "19..=19")] + #[bitfield(name = "ftp_use_eprt", ty = "bit", bits = "20..=20")] + #[bitfield(name = "ftp_use_data_ssl", ty = "bit", bits = "21..=21")] + #[bitfield(name = "ftp_use_control_ssl", ty = "bit", bits = "22..=22")] + #[bitfield(name = "netrc", ty = "bit", bits = "23..=23")] + #[bitfield(name = "bound", ty = "bit", bits = "24..=24")] + #[bitfield(name = "multiplex", ty = "bit", bits = "25..=25")] + #[bitfield(name = "tcp_fastopen", ty = "bit", bits = "26..=26")] + #[bitfield(name = "tls_enable_npn", ty = "bit", bits = "27..=27")] + #[bitfield(name = "tls_enable_alpn", ty = "bit", bits = "28..=28")] + #[bitfield(name = "connect_only", ty = "bit", bits = "29..=29")] + #[bitfield(name = "doh", ty = "bit", bits = "30..=30")] + #[bitfield(name = "abstract_unix_socket", ty = "bit", bits = "31..=31")] + #[bitfield(name = "tls_upgraded", ty = "bit", bits = "32..=32")] + #[bitfield(name = "sock_accepted", ty = "bit", bits = "33..=33")] + #[bitfield(name = "parallel_connect", ty = "bit", bits = "34..=34")] + pub httpproxy_socksproxy_proxy_user_passwd_tunnel_proxy_proxy_connect_closed_close_reuse_altused_conn_to_host_conn_to_port_proxy_user_passwd_ipv6_ip_ipv6_do_more_protoconnstart_retry_authneg_rewindaftersend_ftp_use_epsv_ftp_use_eprt_ftp_use_data_ssl_ftp_use_control_ssl_netrc_bound_multiplex_tcp_fastopen_tls_enable_npn_tls_enable_alpn_connect_only_doh_abstract_unix_socket_tls_upgraded_sock_accepted_parallel_connect: [u8; 5], + #[bitfield(padding)] + pub c2rust_padding: [u8; 3], +} +#[derive(Copy, Clone, BitfieldStruct)] +#[repr(C)] +pub struct ssl_connect_data { + pub state: ssl_connection_state, + pub connecting_state: ssl_connect_state, + pub backend: *mut ssl_backend_data, + #[bitfield(name = "use_0", ty = "bit", bits = "0..=0")] + pub use_0: [u8; 1], + #[bitfield(padding)] + pub c2rust_padding: [u8; 7], +} +pub type ssl_connect_state = libc::c_uint; +pub const ssl_connect_done: ssl_connect_state = 5; +pub const ssl_connect_3: ssl_connect_state = 4; +pub const ssl_connect_2_writing: ssl_connect_state = 3; +pub const ssl_connect_2_reading: ssl_connect_state = 2; +pub const ssl_connect_2: ssl_connect_state = 1; +pub const ssl_connect_1: ssl_connect_state = 0; +pub type ssl_connection_state = libc::c_uint; +pub const ssl_connection_complete: ssl_connection_state = 2; +pub const ssl_connection_negotiating: ssl_connection_state = 1; +pub const ssl_connection_none: ssl_connection_state = 0; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct proxy_info { + pub host: hostname, + pub port: libc::c_long, + pub proxytype: curl_proxytype, + pub user: *mut libc::c_char, + pub passwd: *mut libc::c_char, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct hostname { + pub rawalloc: *mut libc::c_char, + pub encalloc: *mut libc::c_char, + pub name: *mut libc::c_char, + pub dispname: *const libc::c_char, +} +pub type C2RustUnnamed_5 = libc::c_uint; +pub const TRNSPRT_QUIC: C2RustUnnamed_5 = 5; +pub const TRNSPRT_UDP: C2RustUnnamed_5 = 4; +pub const TRNSPRT_TCP: C2RustUnnamed_5 = 3; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct Curl_chunker { + pub datasize: curl_off_t, + pub state: ChunkyState, + pub hexindex: libc::c_uchar, + pub hexbuffer: [libc::c_char; 17], +} +pub type ChunkyState = libc::c_uint; +pub const CHUNK_TRAILER_POSTCR: ChunkyState = 7; +pub const CHUNK_TRAILER_CR: ChunkyState = 6; +pub const CHUNK_TRAILER: ChunkyState = 5; +pub const CHUNK_STOP: ChunkyState = 4; +pub const CHUNK_POSTLF: ChunkyState = 3; +pub const CHUNK_DATA: ChunkyState = 2; +pub const CHUNK_LF: ChunkyState = 1; +pub const CHUNK_HEX: ChunkyState = 0; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct connstate { + pub state: connect_t, + pub outstanding: ssize_t, + pub outp: *mut libc::c_uchar, +} +pub type connect_t = libc::c_uint; +pub const CONNECT_DONE: connect_t = 17; +pub const CONNECT_REQ_READ_MORE: connect_t = 16; +pub const CONNECT_REQ_READ: connect_t = 15; +pub const CONNECT_REQ_SENDING: connect_t = 14; +pub const CONNECT_REQ_SEND: connect_t = 13; +pub const CONNECT_RESOLVE_REMOTE: connect_t = 12; +pub const CONNECT_RESOLVED: connect_t = 11; +pub const CONNECT_RESOLVING: connect_t = 10; +pub const CONNECT_REQ_INIT: connect_t = 9; +pub const CONNECT_AUTH_READ: connect_t = 8; +pub const CONNECT_AUTH_SEND: connect_t = 7; +pub const CONNECT_AUTH_INIT: connect_t = 6; +pub const CONNECT_GSSAPI_INIT: connect_t = 5; +pub const CONNECT_SOCKS_READ: connect_t = 4; +pub const CONNECT_SOCKS_READ_INIT: connect_t = 3; +pub const CONNECT_SOCKS_SEND: connect_t = 2; +pub const CONNECT_SOCKS_INIT: connect_t = 1; +pub const CONNECT_INIT: connect_t = 0; +pub type curlfiletype = libc::c_uint; +pub const CURLFILETYPE_UNKNOWN: curlfiletype = 8; +pub const CURLFILETYPE_DOOR: curlfiletype = 7; +pub const CURLFILETYPE_SOCKET: curlfiletype = 6; +pub const CURLFILETYPE_NAMEDPIPE: curlfiletype = 5; +pub const CURLFILETYPE_DEVICE_CHAR: curlfiletype = 4; +pub const CURLFILETYPE_DEVICE_BLOCK: curlfiletype = 3; +pub const CURLFILETYPE_SYMLINK: curlfiletype = 2; +pub const CURLFILETYPE_DIRECTORY: curlfiletype = 1; +pub const CURLFILETYPE_FILE: curlfiletype = 0; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct curl_fileinfo { + pub filename: *mut libc::c_char, + pub filetype: curlfiletype, + pub time: time_t, + pub perm: libc::c_uint, + pub uid: libc::c_int, + pub gid: libc::c_int, + pub size: curl_off_t, + pub hardlinks: libc::c_long, + pub strings: C2RustUnnamed_6, + pub flags: libc::c_uint, + pub b_data: *mut libc::c_char, + pub b_size: size_t, + pub b_used: size_t, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct C2RustUnnamed_6 { + pub time: *mut libc::c_char, + pub perm: *mut libc::c_char, + pub user: *mut libc::c_char, + pub group: *mut libc::c_char, + pub target: *mut libc::c_char, +} +pub type curl_malloc_callback = Option::< + unsafe extern "C" fn(size_t) -> *mut libc::c_void, +>; +pub type curl_realloc_callback = Option::< + unsafe extern "C" fn(*mut libc::c_void, size_t) -> *mut libc::c_void, +>; +pub type curl_calloc_callback = Option::< + unsafe extern "C" fn(size_t, size_t) -> *mut libc::c_void, +>; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct ftp_parselist_data { + pub os_type: C2RustUnnamed_22, + pub state: C2RustUnnamed_8, + pub error: CURLcode, + pub file_data: *mut fileinfo, + pub item_length: libc::c_uint, + pub item_offset: size_t, + pub offsets: C2RustUnnamed_7, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct C2RustUnnamed_7 { + pub filename: size_t, + pub user: size_t, + pub group: size_t, + pub time: size_t, + pub perm: size_t, + pub symlink_target: size_t, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct fileinfo { + pub info: curl_fileinfo, + pub list: Curl_llist_element, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub union C2RustUnnamed_8 { + pub UNIX: C2RustUnnamed_13, + pub NT: C2RustUnnamed_9, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct C2RustUnnamed_9 { + pub main: pl_winNT_mainstate, + pub sub: pl_winNT_substate, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub union pl_winNT_substate { + pub time: C2RustUnnamed_12, + pub dirorsize: C2RustUnnamed_11, + pub filename: C2RustUnnamed_10, +} +pub type C2RustUnnamed_10 = libc::c_uint; +pub const PL_WINNT_FILENAME_WINEOL: C2RustUnnamed_10 = 2; +pub const PL_WINNT_FILENAME_CONTENT: C2RustUnnamed_10 = 1; +pub const PL_WINNT_FILENAME_PRESPACE: C2RustUnnamed_10 = 0; +pub type C2RustUnnamed_11 = libc::c_uint; +pub const PL_WINNT_DIRORSIZE_CONTENT: C2RustUnnamed_11 = 1; +pub const PL_WINNT_DIRORSIZE_PRESPACE: C2RustUnnamed_11 = 0; +pub type C2RustUnnamed_12 = libc::c_uint; +pub const PL_WINNT_TIME_TIME: C2RustUnnamed_12 = 1; +pub const PL_WINNT_TIME_PRESPACE: C2RustUnnamed_12 = 0; +pub type pl_winNT_mainstate = libc::c_uint; +pub const PL_WINNT_FILENAME: pl_winNT_mainstate = 3; +pub const PL_WINNT_DIRORSIZE: pl_winNT_mainstate = 2; +pub const PL_WINNT_TIME: pl_winNT_mainstate = 1; +pub const PL_WINNT_DATE: pl_winNT_mainstate = 0; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct C2RustUnnamed_13 { + pub main: pl_unix_mainstate, + pub sub: pl_unix_substate, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub union pl_unix_substate { + pub total_dirsize: C2RustUnnamed_21, + pub hlinks: C2RustUnnamed_20, + pub user: C2RustUnnamed_19, + pub group: C2RustUnnamed_18, + pub size: C2RustUnnamed_17, + pub time: C2RustUnnamed_16, + pub filename: C2RustUnnamed_15, + pub symlink: C2RustUnnamed_14, +} +pub type C2RustUnnamed_14 = libc::c_uint; +pub const PL_UNIX_SYMLINK_WINDOWSEOL: C2RustUnnamed_14 = 7; +pub const PL_UNIX_SYMLINK_TARGET: C2RustUnnamed_14 = 6; +pub const PL_UNIX_SYMLINK_PRETARGET4: C2RustUnnamed_14 = 5; +pub const PL_UNIX_SYMLINK_PRETARGET3: C2RustUnnamed_14 = 4; +pub const PL_UNIX_SYMLINK_PRETARGET2: C2RustUnnamed_14 = 3; +pub const PL_UNIX_SYMLINK_PRETARGET1: C2RustUnnamed_14 = 2; +pub const PL_UNIX_SYMLINK_NAME: C2RustUnnamed_14 = 1; +pub const PL_UNIX_SYMLINK_PRESPACE: C2RustUnnamed_14 = 0; +pub type C2RustUnnamed_15 = libc::c_uint; +pub const PL_UNIX_FILENAME_WINDOWSEOL: C2RustUnnamed_15 = 2; +pub const PL_UNIX_FILENAME_NAME: C2RustUnnamed_15 = 1; +pub const PL_UNIX_FILENAME_PRESPACE: C2RustUnnamed_15 = 0; +pub type C2RustUnnamed_16 = libc::c_uint; +pub const PL_UNIX_TIME_PART3: C2RustUnnamed_16 = 5; +pub const PL_UNIX_TIME_PREPART3: C2RustUnnamed_16 = 4; +pub const PL_UNIX_TIME_PART2: C2RustUnnamed_16 = 3; +pub const PL_UNIX_TIME_PREPART2: C2RustUnnamed_16 = 2; +pub const PL_UNIX_TIME_PART1: C2RustUnnamed_16 = 1; +pub const PL_UNIX_TIME_PREPART1: C2RustUnnamed_16 = 0; +pub type C2RustUnnamed_17 = libc::c_uint; +pub const PL_UNIX_SIZE_NUMBER: C2RustUnnamed_17 = 1; +pub const PL_UNIX_SIZE_PRESPACE: C2RustUnnamed_17 = 0; +pub type C2RustUnnamed_18 = libc::c_uint; +pub const PL_UNIX_GROUP_NAME: C2RustUnnamed_18 = 1; +pub const PL_UNIX_GROUP_PRESPACE: C2RustUnnamed_18 = 0; +pub type C2RustUnnamed_19 = libc::c_uint; +pub const PL_UNIX_USER_PARSING: C2RustUnnamed_19 = 1; +pub const PL_UNIX_USER_PRESPACE: C2RustUnnamed_19 = 0; +pub type C2RustUnnamed_20 = libc::c_uint; +pub const PL_UNIX_HLINKS_NUMBER: C2RustUnnamed_20 = 1; +pub const PL_UNIX_HLINKS_PRESPACE: C2RustUnnamed_20 = 0; +pub type C2RustUnnamed_21 = libc::c_uint; +pub const PL_UNIX_TOTALSIZE_READING: C2RustUnnamed_21 = 1; +pub const PL_UNIX_TOTALSIZE_INIT: C2RustUnnamed_21 = 0; +pub type pl_unix_mainstate = libc::c_uint; +pub const PL_UNIX_SYMLINK: pl_unix_mainstate = 9; +pub const PL_UNIX_FILENAME: pl_unix_mainstate = 8; +pub const PL_UNIX_TIME: pl_unix_mainstate = 7; +pub const PL_UNIX_SIZE: pl_unix_mainstate = 6; +pub const PL_UNIX_GROUP: pl_unix_mainstate = 5; +pub const PL_UNIX_USER: pl_unix_mainstate = 4; +pub const PL_UNIX_HLINKS: pl_unix_mainstate = 3; +pub const PL_UNIX_PERMISSION: pl_unix_mainstate = 2; +pub const PL_UNIX_FILETYPE: pl_unix_mainstate = 1; +pub const PL_UNIX_TOTALSIZE: pl_unix_mainstate = 0; +pub type C2RustUnnamed_22 = libc::c_uint; +pub const OS_TYPE_WIN_NT: C2RustUnnamed_22 = 2; +pub const OS_TYPE_UNIX: C2RustUnnamed_22 = 1; +pub const OS_TYPE_UNKNOWN: C2RustUnnamed_22 = 0; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct ftp_wc { + pub parser: *mut ftp_parselist_data, + pub backup: C2RustUnnamed_23, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct C2RustUnnamed_23 { + pub write_function: curl_write_callback, + pub file_descriptor: *mut FILE, +} +pub type CURLofft = libc::c_uint; +pub const CURL_OFFT_INVAL: CURLofft = 2; +pub const CURL_OFFT_FLOW: CURLofft = 1; +pub const CURL_OFFT_OK: CURLofft = 0; +#[no_mangle] +pub unsafe extern "C" fn Curl_ftp_parselist_data_alloc() -> *mut ftp_parselist_data { + return Curl_ccalloc + .expect( + "non-null function pointer", + )( + 1 as libc::c_int as size_t, + ::std::mem::size_of::() as libc::c_ulong, + ) as *mut ftp_parselist_data; +} +#[no_mangle] +pub unsafe extern "C" fn Curl_ftp_parselist_data_free( + mut parserp: *mut *mut ftp_parselist_data, +) { + let mut parser: *mut ftp_parselist_data = *parserp; + if !parser.is_null() { + Curl_fileinfo_cleanup((*parser).file_data); + } + Curl_cfree.expect("non-null function pointer")(parser as *mut libc::c_void); + *parserp = 0 as *mut ftp_parselist_data; +} +#[no_mangle] +pub unsafe extern "C" fn Curl_ftp_parselist_geterror( + mut pl_data: *mut ftp_parselist_data, +) -> CURLcode { + return (*pl_data).error; +} +unsafe extern "C" fn ftp_pl_get_permission(mut str: *const libc::c_char) -> libc::c_int { + let mut permissions: libc::c_int = 0 as libc::c_int; + if *str.offset(0 as libc::c_int as isize) as libc::c_int == 'r' as i32 { + permissions |= (1 as libc::c_int) << 8 as libc::c_int; + } else if *str.offset(0 as libc::c_int as isize) as libc::c_int != '-' as i32 { + permissions |= 0x1000000 as libc::c_int; + } + if *str.offset(1 as libc::c_int as isize) as libc::c_int == 'w' as i32 { + permissions |= (1 as libc::c_int) << 7 as libc::c_int; + } else if *str.offset(1 as libc::c_int as isize) as libc::c_int != '-' as i32 { + permissions |= 0x1000000 as libc::c_int; + } + if *str.offset(2 as libc::c_int as isize) as libc::c_int == 'x' as i32 { + permissions |= (1 as libc::c_int) << 6 as libc::c_int; + } else if *str.offset(2 as libc::c_int as isize) as libc::c_int == 's' as i32 { + permissions |= (1 as libc::c_int) << 6 as libc::c_int; + permissions |= (1 as libc::c_int) << 11 as libc::c_int; + } else if *str.offset(2 as libc::c_int as isize) as libc::c_int == 'S' as i32 { + permissions |= (1 as libc::c_int) << 11 as libc::c_int; + } else if *str.offset(2 as libc::c_int as isize) as libc::c_int != '-' as i32 { + permissions |= 0x1000000 as libc::c_int; + } + if *str.offset(3 as libc::c_int as isize) as libc::c_int == 'r' as i32 { + permissions |= (1 as libc::c_int) << 5 as libc::c_int; + } else if *str.offset(3 as libc::c_int as isize) as libc::c_int != '-' as i32 { + permissions |= 0x1000000 as libc::c_int; + } + if *str.offset(4 as libc::c_int as isize) as libc::c_int == 'w' as i32 { + permissions |= (1 as libc::c_int) << 4 as libc::c_int; + } else if *str.offset(4 as libc::c_int as isize) as libc::c_int != '-' as i32 { + permissions |= 0x1000000 as libc::c_int; + } + if *str.offset(5 as libc::c_int as isize) as libc::c_int == 'x' as i32 { + permissions |= (1 as libc::c_int) << 3 as libc::c_int; + } else if *str.offset(5 as libc::c_int as isize) as libc::c_int == 's' as i32 { + permissions |= (1 as libc::c_int) << 3 as libc::c_int; + permissions |= (1 as libc::c_int) << 10 as libc::c_int; + } else if *str.offset(5 as libc::c_int as isize) as libc::c_int == 'S' as i32 { + permissions |= (1 as libc::c_int) << 10 as libc::c_int; + } else if *str.offset(5 as libc::c_int as isize) as libc::c_int != '-' as i32 { + permissions |= 0x1000000 as libc::c_int; + } + if *str.offset(6 as libc::c_int as isize) as libc::c_int == 'r' as i32 { + permissions |= (1 as libc::c_int) << 2 as libc::c_int; + } else if *str.offset(6 as libc::c_int as isize) as libc::c_int != '-' as i32 { + permissions |= 0x1000000 as libc::c_int; + } + if *str.offset(7 as libc::c_int as isize) as libc::c_int == 'w' as i32 { + permissions |= (1 as libc::c_int) << 1 as libc::c_int; + } else if *str.offset(7 as libc::c_int as isize) as libc::c_int != '-' as i32 { + permissions |= 0x1000000 as libc::c_int; + } + if *str.offset(8 as libc::c_int as isize) as libc::c_int == 'x' as i32 { + permissions |= 1 as libc::c_int; + } else if *str.offset(8 as libc::c_int as isize) as libc::c_int == 't' as i32 { + permissions |= 1 as libc::c_int; + permissions |= (1 as libc::c_int) << 9 as libc::c_int; + } else if *str.offset(8 as libc::c_int as isize) as libc::c_int == 'T' as i32 { + permissions |= (1 as libc::c_int) << 9 as libc::c_int; + } else if *str.offset(8 as libc::c_int as isize) as libc::c_int != '-' as i32 { + permissions |= 0x1000000 as libc::c_int; + } + return permissions; +} +unsafe extern "C" fn ftp_pl_insert_finfo( + mut data: *mut Curl_easy, + mut infop: *mut fileinfo, +) -> CURLcode { + let mut compare: curl_fnmatch_callback = None; + let mut wc: *mut WildcardData = &mut (*data).wildcard; + let mut ftpwc: *mut ftp_wc = (*wc).protdata as *mut ftp_wc; + let mut llist: *mut Curl_llist = &mut (*wc).filelist; + let mut parser: *mut ftp_parselist_data = (*ftpwc).parser; + let mut add: bool = 1 as libc::c_int != 0; + let mut finfo: *mut curl_fileinfo = &mut (*infop).info; + let mut str: *mut libc::c_char = (*finfo).b_data; + let ref mut fresh0 = (*finfo).filename; + *fresh0 = str.offset((*parser).offsets.filename as isize); + let ref mut fresh1 = (*finfo).strings.group; + *fresh1 = if (*parser).offsets.group != 0 { + str.offset((*parser).offsets.group as isize) + } else { + 0 as *mut libc::c_char + }; + let ref mut fresh2 = (*finfo).strings.perm; + *fresh2 = if (*parser).offsets.perm != 0 { + str.offset((*parser).offsets.perm as isize) + } else { + 0 as *mut libc::c_char + }; + let ref mut fresh3 = (*finfo).strings.target; + *fresh3 = if (*parser).offsets.symlink_target != 0 { + str.offset((*parser).offsets.symlink_target as isize) + } else { + 0 as *mut libc::c_char + }; + let ref mut fresh4 = (*finfo).strings.time; + *fresh4 = str.offset((*parser).offsets.time as isize); + let ref mut fresh5 = (*finfo).strings.user; + *fresh5 = if (*parser).offsets.user != 0 { + str.offset((*parser).offsets.user as isize) + } else { + 0 as *mut libc::c_char + }; + compare = (*data).set.fnmatch; + if compare.is_none() { + compare = Some( + Curl_fnmatch + as unsafe extern "C" fn( + *mut libc::c_void, + *const libc::c_char, + *const libc::c_char, + ) -> libc::c_int, + ); + } + Curl_set_in_callback(data, 1 as libc::c_int != 0); + if compare + .expect( + "non-null function pointer", + )((*data).set.fnmatch_data, (*wc).pattern, (*finfo).filename) == 0 as libc::c_int + { + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + && !((*finfo).strings.target).is_null() + && !(strstr( + (*finfo).strings.target, + b" -> \0" as *const u8 as *const libc::c_char, + )) + .is_null() + { + add = 0 as libc::c_int != 0; + } + } else { + add = 0 as libc::c_int != 0; + } + Curl_set_in_callback(data, 0 as libc::c_int != 0); + if add { + Curl_llist_insert_next( + llist, + (*llist).tail, + finfo as *const libc::c_void, + &mut (*infop).list, + ); + } else { + Curl_fileinfo_cleanup(infop); + } + let ref mut fresh6 = (*(*ftpwc).parser).file_data; + *fresh6 = 0 as *mut fileinfo; + return CURLE_OK; +} +#[no_mangle] +pub unsafe extern "C" fn Curl_ftp_parselist( + mut buffer: *mut libc::c_char, + mut size: size_t, + mut nmemb: size_t, + mut connptr: *mut libc::c_void, +) -> size_t { + let mut current_block: u64; + let mut bufflen: size_t = size.wrapping_mul(nmemb); + let mut data: *mut Curl_easy = connptr as *mut Curl_easy; + let mut ftpwc: *mut ftp_wc = (*data).wildcard.protdata as *mut ftp_wc; + let mut parser: *mut ftp_parselist_data = (*ftpwc).parser; + let mut infop: *mut fileinfo = 0 as *mut fileinfo; + let mut finfo: *mut curl_fileinfo = 0 as *mut curl_fileinfo; + let mut i: libc::c_ulong = 0 as libc::c_int as libc::c_ulong; + let mut result: CURLcode = CURLE_OK; + let mut retsize: size_t = bufflen; + if !((*parser).error as u64 != 0) { + if (*parser).os_type as libc::c_uint + == OS_TYPE_UNKNOWN as libc::c_int as libc::c_uint + && bufflen > 0 as libc::c_int as libc::c_ulong + { + (*parser) + .os_type = (if *buffer.offset(0 as libc::c_int as isize) as libc::c_int + >= '0' as i32 + && *buffer.offset(0 as libc::c_int as isize) as libc::c_int <= '9' as i32 + { + OS_TYPE_WIN_NT as libc::c_int + } else { + OS_TYPE_UNIX as libc::c_int + }) as C2RustUnnamed_22; + } + loop { + if !(i < bufflen) { + current_block = 12024005797910882043; + break; + } + let mut c: libc::c_char = *buffer.offset(i as isize); + if ((*parser).file_data).is_null() { + let ref mut fresh7 = (*parser).file_data; + *fresh7 = Curl_fileinfo_alloc(); + if ((*parser).file_data).is_null() { + (*parser).error = CURLE_OUT_OF_MEMORY; + current_block = 16980866091698012183; + break; + } else { + let ref mut fresh8 = (*(*parser).file_data).info.b_data; + *fresh8 = Curl_cmalloc + .expect( + "non-null function pointer", + )(160 as libc::c_int as size_t) as *mut libc::c_char; + if ((*(*parser).file_data).info.b_data).is_null() { + (*parser).error = CURLE_OUT_OF_MEMORY; + current_block = 16980866091698012183; + break; + } else { + (*(*parser).file_data) + .info + .b_size = 160 as libc::c_int as size_t; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + } + } + } + infop = (*parser).file_data; + finfo = &mut (*infop).info; + let ref mut fresh9 = (*finfo).b_used; + let fresh10 = *fresh9; + *fresh9 = (*fresh9).wrapping_add(1); + *((*finfo).b_data).offset(fresh10 as isize) = c; + if (*finfo).b_used + >= ((*finfo).b_size).wrapping_sub(1 as libc::c_int as libc::c_ulong) + { + let mut tmp: *mut libc::c_char = Curl_crealloc + .expect( + "non-null function pointer", + )( + (*finfo).b_data as *mut libc::c_void, + ((*finfo).b_size).wrapping_add(160 as libc::c_int as libc::c_ulong), + ) as *mut libc::c_char; + if !tmp.is_null() { + let ref mut fresh11 = (*finfo).b_size; + *fresh11 = (*fresh11 as libc::c_ulong) + .wrapping_add(160 as libc::c_int as libc::c_ulong) as size_t + as size_t; + let ref mut fresh12 = (*finfo).b_data; + *fresh12 = tmp; + } else { + Curl_fileinfo_cleanup((*parser).file_data); + let ref mut fresh13 = (*parser).file_data; + *fresh13 = 0 as *mut fileinfo; + (*parser).error = CURLE_OUT_OF_MEMORY; + current_block = 16980866091698012183; + break; + } + } + match (*parser).os_type as libc::c_uint { + 1 => { + match (*parser).state.UNIX.main as libc::c_uint { + 0 => { + current_block = 17024674780638317650; + match current_block { + 14897958723503621653 => { + match (*parser).state.UNIX.sub.group as libc::c_uint { + 0 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.group = PL_UNIX_GROUP_NAME; + } + } + 1 => { + let ref mut fresh21 = (*parser).item_length; + *fresh21 = (*fresh21).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.group = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_SIZE; + (*parser).state.UNIX.sub.size = PL_UNIX_SIZE_PRESPACE; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + } + } + _ => {} + } + } + 6779615841179357261 => { + match (*parser).state.UNIX.sub.filename as libc::c_uint { + 0 => { + current_block = 9460353118185870455; + match current_block { + 9460353118185870455 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.filename = PL_UNIX_FILENAME_NAME; + } + } + 237011551503419106 => { + let ref mut fresh28 = (*parser).item_length; + *fresh28 = (*fresh28).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 237011551503419106; + match current_block { + 9460353118185870455 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.filename = PL_UNIX_FILENAME_NAME; + } + } + 237011551503419106 => { + let ref mut fresh28 = (*parser).item_length; + *fresh28 = (*fresh28).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 2 => { + current_block = 8794836904205913937; + match current_block { + 9460353118185870455 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.filename = PL_UNIX_FILENAME_NAME; + } + } + 237011551503419106 => { + let ref mut fresh28 = (*parser).item_length; + *fresh28 = (*fresh28).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + 239935657650551384 => { + match (*parser).state.UNIX.sub.time as libc::c_uint { + 0 => { + current_block = 16799793128756688569; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 3676047842931404030; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 2 => { + current_block = 4348891415139402515; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 3 => { + current_block = 9778139347000538655; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 4 => { + current_block = 6646479082925444416; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 5 => { + current_block = 4328367172772116072; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + 16624850812192366308 => { + match (*parser).state.UNIX.sub.size as libc::c_uint { + 0 => { + current_block = 4003799678443473047; + match current_block { + 4003799678443473047 => { + if c as libc::c_int != ' ' as i32 { + if c as libc::c_int >= '0' as i32 + && c as libc::c_int <= '9' as i32 + { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.size = PL_UNIX_SIZE_NUMBER; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + let ref mut fresh22 = (*parser).item_length; + *fresh22 = (*fresh22).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + let mut p_0: *mut libc::c_char = 0 as *mut libc::c_char; + let mut fsize: curl_off_t = 0; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + if curlx_strtoofft( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut p_0, + 10 as libc::c_int, + &mut fsize, + ) as u64 == 0 + { + if *p_0.offset(0 as libc::c_int as isize) as libc::c_int + == '\u{0}' as i32 + && fsize != 0x7fffffffffffffff as libc::c_long + && fsize + != -(0x7fffffffffffffff as libc::c_long) - 1 as libc::c_long + { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 6 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.size = fsize; + } + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).state.UNIX.main = PL_UNIX_TIME; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART1; + } + } else if Curl_isdigit(c as libc::c_uchar as libc::c_int) + == 0 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 16318689547377354787; + match current_block { + 4003799678443473047 => { + if c as libc::c_int != ' ' as i32 { + if c as libc::c_int >= '0' as i32 + && c as libc::c_int <= '9' as i32 + { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.size = PL_UNIX_SIZE_NUMBER; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + let ref mut fresh22 = (*parser).item_length; + *fresh22 = (*fresh22).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + let mut p_0: *mut libc::c_char = 0 as *mut libc::c_char; + let mut fsize: curl_off_t = 0; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + if curlx_strtoofft( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut p_0, + 10 as libc::c_int, + &mut fsize, + ) as u64 == 0 + { + if *p_0.offset(0 as libc::c_int as isize) as libc::c_int + == '\u{0}' as i32 + && fsize != 0x7fffffffffffffff as libc::c_long + && fsize + != -(0x7fffffffffffffff as libc::c_long) - 1 as libc::c_long + { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 6 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.size = fsize; + } + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).state.UNIX.main = PL_UNIX_TIME; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART1; + } + } else if Curl_isdigit(c as libc::c_uchar as libc::c_int) + == 0 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + 2504653350889004047 => { + match (*parser).state.UNIX.sub.hlinks as libc::c_uint { + 0 => { + current_block = 3684944600068393837; + match current_block { + 3684944600068393837 => { + if c as libc::c_int != ' ' as i32 { + if c as libc::c_int >= '0' as i32 + && c as libc::c_int <= '9' as i32 + { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.hlinks = PL_UNIX_HLINKS_NUMBER; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + let ref mut fresh19 = (*parser).item_length; + *fresh19 = (*fresh19).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + let mut p: *mut libc::c_char = 0 as *mut libc::c_char; + let mut hlinks: libc::c_long = 0; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + hlinks = strtol( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut p, + 10 as libc::c_int, + ); + if *p.offset(0 as libc::c_int as isize) as libc::c_int + == '\u{0}' as i32 + && hlinks != 9223372036854775807 as libc::c_long + && hlinks + != -(9223372036854775807 as libc::c_long) + - 1 as libc::c_long + { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 7 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.hardlinks = hlinks; + } + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).state.UNIX.main = PL_UNIX_USER; + (*parser).state.UNIX.sub.user = PL_UNIX_USER_PRESPACE; + } else if (c as libc::c_int) < '0' as i32 + || c as libc::c_int > '9' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 5484315482916150815; + match current_block { + 3684944600068393837 => { + if c as libc::c_int != ' ' as i32 { + if c as libc::c_int >= '0' as i32 + && c as libc::c_int <= '9' as i32 + { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.hlinks = PL_UNIX_HLINKS_NUMBER; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + let ref mut fresh19 = (*parser).item_length; + *fresh19 = (*fresh19).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + let mut p: *mut libc::c_char = 0 as *mut libc::c_char; + let mut hlinks: libc::c_long = 0; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + hlinks = strtol( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut p, + 10 as libc::c_int, + ); + if *p.offset(0 as libc::c_int as isize) as libc::c_int + == '\u{0}' as i32 + && hlinks != 9223372036854775807 as libc::c_long + && hlinks + != -(9223372036854775807 as libc::c_long) + - 1 as libc::c_long + { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 7 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.hardlinks = hlinks; + } + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).state.UNIX.main = PL_UNIX_USER; + (*parser).state.UNIX.sub.user = PL_UNIX_USER_PRESPACE; + } else if (c as libc::c_int) < '0' as i32 + || c as libc::c_int > '9' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + 9904077679713191023 => { + let ref mut fresh18 = (*parser).item_length; + *fresh18 = (*fresh18).wrapping_add(1); + if (*parser).item_length <= 9 as libc::c_int as libc::c_uint + { + if (strchr( + b"rwx-tTsS\0" as *const u8 as *const libc::c_char, + c as libc::c_int, + )) + .is_null() + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } else if (*parser).item_length + == 10 as libc::c_int as libc::c_uint + { + let mut perm: libc::c_uint = 0; + if c as libc::c_int != ' ' as i32 { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + *((*finfo).b_data) + .offset( + 10 as libc::c_int as isize, + ) = 0 as libc::c_int as libc::c_char; + perm = ftp_pl_get_permission( + ((*finfo).b_data).offset((*parser).item_offset as isize), + ) as libc::c_uint; + if perm & 0x1000000 as libc::c_int as libc::c_uint != 0 { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 3 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.perm = perm; + (*parser).offsets.perm = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.main = PL_UNIX_HLINKS; + (*parser).state.UNIX.sub.hlinks = PL_UNIX_HLINKS_PRESPACE; + } + } + } + } + 9625400769004322558 => { + match c as libc::c_int { + 45 => { + (*finfo).filetype = CURLFILETYPE_FILE; + } + 100 => { + (*finfo).filetype = CURLFILETYPE_DIRECTORY; + } + 108 => { + (*finfo).filetype = CURLFILETYPE_SYMLINK; + } + 112 => { + (*finfo).filetype = CURLFILETYPE_NAMEDPIPE; + } + 115 => { + (*finfo).filetype = CURLFILETYPE_SOCKET; + } + 99 => { + (*finfo).filetype = CURLFILETYPE_DEVICE_CHAR; + } + 98 => { + (*finfo).filetype = CURLFILETYPE_DEVICE_BLOCK; + } + 68 => { + (*finfo).filetype = CURLFILETYPE_DOOR; + } + _ => { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + (*parser).state.UNIX.main = PL_UNIX_PERMISSION; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 1 as libc::c_int as size_t; + } + 17024674780638317650 => { + match (*parser).state.UNIX.sub.total_dirsize as libc::c_uint + { + 0 => { + current_block = 6514364568132207893; + match current_block { + 6514364568132207893 => { + if c as libc::c_int == 't' as i32 { + (*parser) + .state + .UNIX + .sub + .total_dirsize = PL_UNIX_TOTALSIZE_READING; + let ref mut fresh14 = (*parser).item_length; + *fresh14 = (*fresh14).wrapping_add(1); + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + (*finfo).b_used = 0 as libc::c_int as size_t; + continue; + } + } + _ => { + let ref mut fresh15 = (*parser).item_length; + *fresh15 = (*fresh15).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + let ref mut fresh16 = (*parser).item_length; + *fresh16 = (*fresh16).wrapping_sub(1); + let ref mut fresh17 = (*finfo).b_used; + *fresh17 = (*fresh17).wrapping_sub(1); + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_length) + .wrapping_sub(1 as libc::c_int as libc::c_uint) as isize, + ) = 0 as libc::c_int as libc::c_char; + if strncmp( + b"total \0" as *const u8 as *const libc::c_char, + (*finfo).b_data, + 6 as libc::c_int as libc::c_ulong, + ) == 0 as libc::c_int + { + let mut endptr: *mut libc::c_char = ((*finfo).b_data) + .offset(6 as libc::c_int as isize); + while Curl_isspace(*endptr as libc::c_uchar as libc::c_int) + != 0 + { + endptr = endptr.offset(1); + } + while Curl_isdigit(*endptr as libc::c_uchar as libc::c_int) + != 0 + { + endptr = endptr.offset(1); + } + if *endptr != 0 { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + (*finfo).b_used = 0 as libc::c_int as size_t; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + } + 1 => { + current_block = 13626467451598339886; + match current_block { + 6514364568132207893 => { + if c as libc::c_int == 't' as i32 { + (*parser) + .state + .UNIX + .sub + .total_dirsize = PL_UNIX_TOTALSIZE_READING; + let ref mut fresh14 = (*parser).item_length; + *fresh14 = (*fresh14).wrapping_add(1); + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + (*finfo).b_used = 0 as libc::c_int as size_t; + continue; + } + } + _ => { + let ref mut fresh15 = (*parser).item_length; + *fresh15 = (*fresh15).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + let ref mut fresh16 = (*parser).item_length; + *fresh16 = (*fresh16).wrapping_sub(1); + let ref mut fresh17 = (*finfo).b_used; + *fresh17 = (*fresh17).wrapping_sub(1); + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_length) + .wrapping_sub(1 as libc::c_int as libc::c_uint) as isize, + ) = 0 as libc::c_int as libc::c_char; + if strncmp( + b"total \0" as *const u8 as *const libc::c_char, + (*finfo).b_data, + 6 as libc::c_int as libc::c_ulong, + ) == 0 as libc::c_int + { + let mut endptr: *mut libc::c_char = ((*finfo).b_data) + .offset(6 as libc::c_int as isize); + while Curl_isspace(*endptr as libc::c_uchar as libc::c_int) + != 0 + { + endptr = endptr.offset(1); + } + while Curl_isdigit(*endptr as libc::c_uchar as libc::c_int) + != 0 + { + endptr = endptr.offset(1); + } + if *endptr != 0 { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + (*finfo).b_used = 0 as libc::c_int as size_t; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + } + _ => {} + } + } + 9811869791021064406 => { + match (*parser).state.UNIX.sub.user as libc::c_uint { + 0 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.user = PL_UNIX_USER_PARSING; + } + } + 1 => { + let ref mut fresh20 = (*parser).item_length; + *fresh20 = (*fresh20).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.user = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_GROUP; + (*parser).state.UNIX.sub.group = PL_UNIX_GROUP_PRESPACE; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + } + } + _ => {} + } + } + _ => { + match (*parser).state.UNIX.sub.symlink as libc::c_uint { + 0 => { + current_block = 17809359888120058514; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 16368170406074945475; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 2 => { + current_block = 10105930990766199517; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 3 => { + current_block = 11357570484085178253; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 4 => { + current_block = 6032193395927242546; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 5 => { + current_block = 755694297841528034; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 6 => { + current_block = 5173505947521674114; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 7 => { + current_block = 12108948829114559637; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + } + } + 1 => { + current_block = 9625400769004322558; + match current_block { + 14897958723503621653 => { + match (*parser).state.UNIX.sub.group as libc::c_uint { + 0 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.group = PL_UNIX_GROUP_NAME; + } + } + 1 => { + let ref mut fresh21 = (*parser).item_length; + *fresh21 = (*fresh21).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.group = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_SIZE; + (*parser).state.UNIX.sub.size = PL_UNIX_SIZE_PRESPACE; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + } + } + _ => {} + } + } + 6779615841179357261 => { + match (*parser).state.UNIX.sub.filename as libc::c_uint { + 0 => { + current_block = 9460353118185870455; + match current_block { + 9460353118185870455 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.filename = PL_UNIX_FILENAME_NAME; + } + } + 237011551503419106 => { + let ref mut fresh28 = (*parser).item_length; + *fresh28 = (*fresh28).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 237011551503419106; + match current_block { + 9460353118185870455 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.filename = PL_UNIX_FILENAME_NAME; + } + } + 237011551503419106 => { + let ref mut fresh28 = (*parser).item_length; + *fresh28 = (*fresh28).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 2 => { + current_block = 8794836904205913937; + match current_block { + 9460353118185870455 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.filename = PL_UNIX_FILENAME_NAME; + } + } + 237011551503419106 => { + let ref mut fresh28 = (*parser).item_length; + *fresh28 = (*fresh28).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + 239935657650551384 => { + match (*parser).state.UNIX.sub.time as libc::c_uint { + 0 => { + current_block = 16799793128756688569; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 3676047842931404030; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 2 => { + current_block = 4348891415139402515; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 3 => { + current_block = 9778139347000538655; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 4 => { + current_block = 6646479082925444416; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 5 => { + current_block = 4328367172772116072; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + 16624850812192366308 => { + match (*parser).state.UNIX.sub.size as libc::c_uint { + 0 => { + current_block = 4003799678443473047; + match current_block { + 4003799678443473047 => { + if c as libc::c_int != ' ' as i32 { + if c as libc::c_int >= '0' as i32 + && c as libc::c_int <= '9' as i32 + { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.size = PL_UNIX_SIZE_NUMBER; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + let ref mut fresh22 = (*parser).item_length; + *fresh22 = (*fresh22).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + let mut p_0: *mut libc::c_char = 0 as *mut libc::c_char; + let mut fsize: curl_off_t = 0; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + if curlx_strtoofft( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut p_0, + 10 as libc::c_int, + &mut fsize, + ) as u64 == 0 + { + if *p_0.offset(0 as libc::c_int as isize) as libc::c_int + == '\u{0}' as i32 + && fsize != 0x7fffffffffffffff as libc::c_long + && fsize + != -(0x7fffffffffffffff as libc::c_long) - 1 as libc::c_long + { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 6 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.size = fsize; + } + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).state.UNIX.main = PL_UNIX_TIME; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART1; + } + } else if Curl_isdigit(c as libc::c_uchar as libc::c_int) + == 0 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 16318689547377354787; + match current_block { + 4003799678443473047 => { + if c as libc::c_int != ' ' as i32 { + if c as libc::c_int >= '0' as i32 + && c as libc::c_int <= '9' as i32 + { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.size = PL_UNIX_SIZE_NUMBER; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + let ref mut fresh22 = (*parser).item_length; + *fresh22 = (*fresh22).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + let mut p_0: *mut libc::c_char = 0 as *mut libc::c_char; + let mut fsize: curl_off_t = 0; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + if curlx_strtoofft( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut p_0, + 10 as libc::c_int, + &mut fsize, + ) as u64 == 0 + { + if *p_0.offset(0 as libc::c_int as isize) as libc::c_int + == '\u{0}' as i32 + && fsize != 0x7fffffffffffffff as libc::c_long + && fsize + != -(0x7fffffffffffffff as libc::c_long) - 1 as libc::c_long + { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 6 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.size = fsize; + } + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).state.UNIX.main = PL_UNIX_TIME; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART1; + } + } else if Curl_isdigit(c as libc::c_uchar as libc::c_int) + == 0 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + 2504653350889004047 => { + match (*parser).state.UNIX.sub.hlinks as libc::c_uint { + 0 => { + current_block = 3684944600068393837; + match current_block { + 3684944600068393837 => { + if c as libc::c_int != ' ' as i32 { + if c as libc::c_int >= '0' as i32 + && c as libc::c_int <= '9' as i32 + { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.hlinks = PL_UNIX_HLINKS_NUMBER; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + let ref mut fresh19 = (*parser).item_length; + *fresh19 = (*fresh19).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + let mut p: *mut libc::c_char = 0 as *mut libc::c_char; + let mut hlinks: libc::c_long = 0; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + hlinks = strtol( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut p, + 10 as libc::c_int, + ); + if *p.offset(0 as libc::c_int as isize) as libc::c_int + == '\u{0}' as i32 + && hlinks != 9223372036854775807 as libc::c_long + && hlinks + != -(9223372036854775807 as libc::c_long) + - 1 as libc::c_long + { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 7 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.hardlinks = hlinks; + } + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).state.UNIX.main = PL_UNIX_USER; + (*parser).state.UNIX.sub.user = PL_UNIX_USER_PRESPACE; + } else if (c as libc::c_int) < '0' as i32 + || c as libc::c_int > '9' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 5484315482916150815; + match current_block { + 3684944600068393837 => { + if c as libc::c_int != ' ' as i32 { + if c as libc::c_int >= '0' as i32 + && c as libc::c_int <= '9' as i32 + { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.hlinks = PL_UNIX_HLINKS_NUMBER; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + let ref mut fresh19 = (*parser).item_length; + *fresh19 = (*fresh19).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + let mut p: *mut libc::c_char = 0 as *mut libc::c_char; + let mut hlinks: libc::c_long = 0; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + hlinks = strtol( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut p, + 10 as libc::c_int, + ); + if *p.offset(0 as libc::c_int as isize) as libc::c_int + == '\u{0}' as i32 + && hlinks != 9223372036854775807 as libc::c_long + && hlinks + != -(9223372036854775807 as libc::c_long) + - 1 as libc::c_long + { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 7 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.hardlinks = hlinks; + } + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).state.UNIX.main = PL_UNIX_USER; + (*parser).state.UNIX.sub.user = PL_UNIX_USER_PRESPACE; + } else if (c as libc::c_int) < '0' as i32 + || c as libc::c_int > '9' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + 9904077679713191023 => { + let ref mut fresh18 = (*parser).item_length; + *fresh18 = (*fresh18).wrapping_add(1); + if (*parser).item_length <= 9 as libc::c_int as libc::c_uint + { + if (strchr( + b"rwx-tTsS\0" as *const u8 as *const libc::c_char, + c as libc::c_int, + )) + .is_null() + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } else if (*parser).item_length + == 10 as libc::c_int as libc::c_uint + { + let mut perm: libc::c_uint = 0; + if c as libc::c_int != ' ' as i32 { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + *((*finfo).b_data) + .offset( + 10 as libc::c_int as isize, + ) = 0 as libc::c_int as libc::c_char; + perm = ftp_pl_get_permission( + ((*finfo).b_data).offset((*parser).item_offset as isize), + ) as libc::c_uint; + if perm & 0x1000000 as libc::c_int as libc::c_uint != 0 { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 3 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.perm = perm; + (*parser).offsets.perm = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.main = PL_UNIX_HLINKS; + (*parser).state.UNIX.sub.hlinks = PL_UNIX_HLINKS_PRESPACE; + } + } + } + } + 9625400769004322558 => { + match c as libc::c_int { + 45 => { + (*finfo).filetype = CURLFILETYPE_FILE; + } + 100 => { + (*finfo).filetype = CURLFILETYPE_DIRECTORY; + } + 108 => { + (*finfo).filetype = CURLFILETYPE_SYMLINK; + } + 112 => { + (*finfo).filetype = CURLFILETYPE_NAMEDPIPE; + } + 115 => { + (*finfo).filetype = CURLFILETYPE_SOCKET; + } + 99 => { + (*finfo).filetype = CURLFILETYPE_DEVICE_CHAR; + } + 98 => { + (*finfo).filetype = CURLFILETYPE_DEVICE_BLOCK; + } + 68 => { + (*finfo).filetype = CURLFILETYPE_DOOR; + } + _ => { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + (*parser).state.UNIX.main = PL_UNIX_PERMISSION; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 1 as libc::c_int as size_t; + } + 17024674780638317650 => { + match (*parser).state.UNIX.sub.total_dirsize as libc::c_uint + { + 0 => { + current_block = 6514364568132207893; + match current_block { + 6514364568132207893 => { + if c as libc::c_int == 't' as i32 { + (*parser) + .state + .UNIX + .sub + .total_dirsize = PL_UNIX_TOTALSIZE_READING; + let ref mut fresh14 = (*parser).item_length; + *fresh14 = (*fresh14).wrapping_add(1); + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + (*finfo).b_used = 0 as libc::c_int as size_t; + continue; + } + } + _ => { + let ref mut fresh15 = (*parser).item_length; + *fresh15 = (*fresh15).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + let ref mut fresh16 = (*parser).item_length; + *fresh16 = (*fresh16).wrapping_sub(1); + let ref mut fresh17 = (*finfo).b_used; + *fresh17 = (*fresh17).wrapping_sub(1); + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_length) + .wrapping_sub(1 as libc::c_int as libc::c_uint) as isize, + ) = 0 as libc::c_int as libc::c_char; + if strncmp( + b"total \0" as *const u8 as *const libc::c_char, + (*finfo).b_data, + 6 as libc::c_int as libc::c_ulong, + ) == 0 as libc::c_int + { + let mut endptr: *mut libc::c_char = ((*finfo).b_data) + .offset(6 as libc::c_int as isize); + while Curl_isspace(*endptr as libc::c_uchar as libc::c_int) + != 0 + { + endptr = endptr.offset(1); + } + while Curl_isdigit(*endptr as libc::c_uchar as libc::c_int) + != 0 + { + endptr = endptr.offset(1); + } + if *endptr != 0 { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + (*finfo).b_used = 0 as libc::c_int as size_t; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + } + 1 => { + current_block = 13626467451598339886; + match current_block { + 6514364568132207893 => { + if c as libc::c_int == 't' as i32 { + (*parser) + .state + .UNIX + .sub + .total_dirsize = PL_UNIX_TOTALSIZE_READING; + let ref mut fresh14 = (*parser).item_length; + *fresh14 = (*fresh14).wrapping_add(1); + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + (*finfo).b_used = 0 as libc::c_int as size_t; + continue; + } + } + _ => { + let ref mut fresh15 = (*parser).item_length; + *fresh15 = (*fresh15).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + let ref mut fresh16 = (*parser).item_length; + *fresh16 = (*fresh16).wrapping_sub(1); + let ref mut fresh17 = (*finfo).b_used; + *fresh17 = (*fresh17).wrapping_sub(1); + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_length) + .wrapping_sub(1 as libc::c_int as libc::c_uint) as isize, + ) = 0 as libc::c_int as libc::c_char; + if strncmp( + b"total \0" as *const u8 as *const libc::c_char, + (*finfo).b_data, + 6 as libc::c_int as libc::c_ulong, + ) == 0 as libc::c_int + { + let mut endptr: *mut libc::c_char = ((*finfo).b_data) + .offset(6 as libc::c_int as isize); + while Curl_isspace(*endptr as libc::c_uchar as libc::c_int) + != 0 + { + endptr = endptr.offset(1); + } + while Curl_isdigit(*endptr as libc::c_uchar as libc::c_int) + != 0 + { + endptr = endptr.offset(1); + } + if *endptr != 0 { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + (*finfo).b_used = 0 as libc::c_int as size_t; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + } + _ => {} + } + } + 9811869791021064406 => { + match (*parser).state.UNIX.sub.user as libc::c_uint { + 0 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.user = PL_UNIX_USER_PARSING; + } + } + 1 => { + let ref mut fresh20 = (*parser).item_length; + *fresh20 = (*fresh20).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.user = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_GROUP; + (*parser).state.UNIX.sub.group = PL_UNIX_GROUP_PRESPACE; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + } + } + _ => {} + } + } + _ => { + match (*parser).state.UNIX.sub.symlink as libc::c_uint { + 0 => { + current_block = 17809359888120058514; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 16368170406074945475; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 2 => { + current_block = 10105930990766199517; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 3 => { + current_block = 11357570484085178253; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 4 => { + current_block = 6032193395927242546; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 5 => { + current_block = 755694297841528034; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 6 => { + current_block = 5173505947521674114; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 7 => { + current_block = 12108948829114559637; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + } + } + 2 => { + current_block = 9904077679713191023; + match current_block { + 14897958723503621653 => { + match (*parser).state.UNIX.sub.group as libc::c_uint { + 0 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.group = PL_UNIX_GROUP_NAME; + } + } + 1 => { + let ref mut fresh21 = (*parser).item_length; + *fresh21 = (*fresh21).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.group = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_SIZE; + (*parser).state.UNIX.sub.size = PL_UNIX_SIZE_PRESPACE; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + } + } + _ => {} + } + } + 6779615841179357261 => { + match (*parser).state.UNIX.sub.filename as libc::c_uint { + 0 => { + current_block = 9460353118185870455; + match current_block { + 9460353118185870455 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.filename = PL_UNIX_FILENAME_NAME; + } + } + 237011551503419106 => { + let ref mut fresh28 = (*parser).item_length; + *fresh28 = (*fresh28).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 237011551503419106; + match current_block { + 9460353118185870455 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.filename = PL_UNIX_FILENAME_NAME; + } + } + 237011551503419106 => { + let ref mut fresh28 = (*parser).item_length; + *fresh28 = (*fresh28).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 2 => { + current_block = 8794836904205913937; + match current_block { + 9460353118185870455 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.filename = PL_UNIX_FILENAME_NAME; + } + } + 237011551503419106 => { + let ref mut fresh28 = (*parser).item_length; + *fresh28 = (*fresh28).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + 239935657650551384 => { + match (*parser).state.UNIX.sub.time as libc::c_uint { + 0 => { + current_block = 16799793128756688569; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 3676047842931404030; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 2 => { + current_block = 4348891415139402515; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 3 => { + current_block = 9778139347000538655; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 4 => { + current_block = 6646479082925444416; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 5 => { + current_block = 4328367172772116072; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + 16624850812192366308 => { + match (*parser).state.UNIX.sub.size as libc::c_uint { + 0 => { + current_block = 4003799678443473047; + match current_block { + 4003799678443473047 => { + if c as libc::c_int != ' ' as i32 { + if c as libc::c_int >= '0' as i32 + && c as libc::c_int <= '9' as i32 + { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.size = PL_UNIX_SIZE_NUMBER; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + let ref mut fresh22 = (*parser).item_length; + *fresh22 = (*fresh22).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + let mut p_0: *mut libc::c_char = 0 as *mut libc::c_char; + let mut fsize: curl_off_t = 0; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + if curlx_strtoofft( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut p_0, + 10 as libc::c_int, + &mut fsize, + ) as u64 == 0 + { + if *p_0.offset(0 as libc::c_int as isize) as libc::c_int + == '\u{0}' as i32 + && fsize != 0x7fffffffffffffff as libc::c_long + && fsize + != -(0x7fffffffffffffff as libc::c_long) - 1 as libc::c_long + { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 6 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.size = fsize; + } + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).state.UNIX.main = PL_UNIX_TIME; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART1; + } + } else if Curl_isdigit(c as libc::c_uchar as libc::c_int) + == 0 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 16318689547377354787; + match current_block { + 4003799678443473047 => { + if c as libc::c_int != ' ' as i32 { + if c as libc::c_int >= '0' as i32 + && c as libc::c_int <= '9' as i32 + { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.size = PL_UNIX_SIZE_NUMBER; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + let ref mut fresh22 = (*parser).item_length; + *fresh22 = (*fresh22).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + let mut p_0: *mut libc::c_char = 0 as *mut libc::c_char; + let mut fsize: curl_off_t = 0; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + if curlx_strtoofft( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut p_0, + 10 as libc::c_int, + &mut fsize, + ) as u64 == 0 + { + if *p_0.offset(0 as libc::c_int as isize) as libc::c_int + == '\u{0}' as i32 + && fsize != 0x7fffffffffffffff as libc::c_long + && fsize + != -(0x7fffffffffffffff as libc::c_long) - 1 as libc::c_long + { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 6 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.size = fsize; + } + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).state.UNIX.main = PL_UNIX_TIME; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART1; + } + } else if Curl_isdigit(c as libc::c_uchar as libc::c_int) + == 0 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + 2504653350889004047 => { + match (*parser).state.UNIX.sub.hlinks as libc::c_uint { + 0 => { + current_block = 3684944600068393837; + match current_block { + 3684944600068393837 => { + if c as libc::c_int != ' ' as i32 { + if c as libc::c_int >= '0' as i32 + && c as libc::c_int <= '9' as i32 + { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.hlinks = PL_UNIX_HLINKS_NUMBER; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + let ref mut fresh19 = (*parser).item_length; + *fresh19 = (*fresh19).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + let mut p: *mut libc::c_char = 0 as *mut libc::c_char; + let mut hlinks: libc::c_long = 0; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + hlinks = strtol( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut p, + 10 as libc::c_int, + ); + if *p.offset(0 as libc::c_int as isize) as libc::c_int + == '\u{0}' as i32 + && hlinks != 9223372036854775807 as libc::c_long + && hlinks + != -(9223372036854775807 as libc::c_long) + - 1 as libc::c_long + { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 7 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.hardlinks = hlinks; + } + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).state.UNIX.main = PL_UNIX_USER; + (*parser).state.UNIX.sub.user = PL_UNIX_USER_PRESPACE; + } else if (c as libc::c_int) < '0' as i32 + || c as libc::c_int > '9' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 5484315482916150815; + match current_block { + 3684944600068393837 => { + if c as libc::c_int != ' ' as i32 { + if c as libc::c_int >= '0' as i32 + && c as libc::c_int <= '9' as i32 + { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.hlinks = PL_UNIX_HLINKS_NUMBER; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + let ref mut fresh19 = (*parser).item_length; + *fresh19 = (*fresh19).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + let mut p: *mut libc::c_char = 0 as *mut libc::c_char; + let mut hlinks: libc::c_long = 0; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + hlinks = strtol( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut p, + 10 as libc::c_int, + ); + if *p.offset(0 as libc::c_int as isize) as libc::c_int + == '\u{0}' as i32 + && hlinks != 9223372036854775807 as libc::c_long + && hlinks + != -(9223372036854775807 as libc::c_long) + - 1 as libc::c_long + { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 7 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.hardlinks = hlinks; + } + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).state.UNIX.main = PL_UNIX_USER; + (*parser).state.UNIX.sub.user = PL_UNIX_USER_PRESPACE; + } else if (c as libc::c_int) < '0' as i32 + || c as libc::c_int > '9' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + 9904077679713191023 => { + let ref mut fresh18 = (*parser).item_length; + *fresh18 = (*fresh18).wrapping_add(1); + if (*parser).item_length <= 9 as libc::c_int as libc::c_uint + { + if (strchr( + b"rwx-tTsS\0" as *const u8 as *const libc::c_char, + c as libc::c_int, + )) + .is_null() + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } else if (*parser).item_length + == 10 as libc::c_int as libc::c_uint + { + let mut perm: libc::c_uint = 0; + if c as libc::c_int != ' ' as i32 { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + *((*finfo).b_data) + .offset( + 10 as libc::c_int as isize, + ) = 0 as libc::c_int as libc::c_char; + perm = ftp_pl_get_permission( + ((*finfo).b_data).offset((*parser).item_offset as isize), + ) as libc::c_uint; + if perm & 0x1000000 as libc::c_int as libc::c_uint != 0 { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 3 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.perm = perm; + (*parser).offsets.perm = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.main = PL_UNIX_HLINKS; + (*parser).state.UNIX.sub.hlinks = PL_UNIX_HLINKS_PRESPACE; + } + } + } + } + 9625400769004322558 => { + match c as libc::c_int { + 45 => { + (*finfo).filetype = CURLFILETYPE_FILE; + } + 100 => { + (*finfo).filetype = CURLFILETYPE_DIRECTORY; + } + 108 => { + (*finfo).filetype = CURLFILETYPE_SYMLINK; + } + 112 => { + (*finfo).filetype = CURLFILETYPE_NAMEDPIPE; + } + 115 => { + (*finfo).filetype = CURLFILETYPE_SOCKET; + } + 99 => { + (*finfo).filetype = CURLFILETYPE_DEVICE_CHAR; + } + 98 => { + (*finfo).filetype = CURLFILETYPE_DEVICE_BLOCK; + } + 68 => { + (*finfo).filetype = CURLFILETYPE_DOOR; + } + _ => { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + (*parser).state.UNIX.main = PL_UNIX_PERMISSION; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 1 as libc::c_int as size_t; + } + 17024674780638317650 => { + match (*parser).state.UNIX.sub.total_dirsize as libc::c_uint + { + 0 => { + current_block = 6514364568132207893; + match current_block { + 6514364568132207893 => { + if c as libc::c_int == 't' as i32 { + (*parser) + .state + .UNIX + .sub + .total_dirsize = PL_UNIX_TOTALSIZE_READING; + let ref mut fresh14 = (*parser).item_length; + *fresh14 = (*fresh14).wrapping_add(1); + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + (*finfo).b_used = 0 as libc::c_int as size_t; + continue; + } + } + _ => { + let ref mut fresh15 = (*parser).item_length; + *fresh15 = (*fresh15).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + let ref mut fresh16 = (*parser).item_length; + *fresh16 = (*fresh16).wrapping_sub(1); + let ref mut fresh17 = (*finfo).b_used; + *fresh17 = (*fresh17).wrapping_sub(1); + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_length) + .wrapping_sub(1 as libc::c_int as libc::c_uint) as isize, + ) = 0 as libc::c_int as libc::c_char; + if strncmp( + b"total \0" as *const u8 as *const libc::c_char, + (*finfo).b_data, + 6 as libc::c_int as libc::c_ulong, + ) == 0 as libc::c_int + { + let mut endptr: *mut libc::c_char = ((*finfo).b_data) + .offset(6 as libc::c_int as isize); + while Curl_isspace(*endptr as libc::c_uchar as libc::c_int) + != 0 + { + endptr = endptr.offset(1); + } + while Curl_isdigit(*endptr as libc::c_uchar as libc::c_int) + != 0 + { + endptr = endptr.offset(1); + } + if *endptr != 0 { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + (*finfo).b_used = 0 as libc::c_int as size_t; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + } + 1 => { + current_block = 13626467451598339886; + match current_block { + 6514364568132207893 => { + if c as libc::c_int == 't' as i32 { + (*parser) + .state + .UNIX + .sub + .total_dirsize = PL_UNIX_TOTALSIZE_READING; + let ref mut fresh14 = (*parser).item_length; + *fresh14 = (*fresh14).wrapping_add(1); + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + (*finfo).b_used = 0 as libc::c_int as size_t; + continue; + } + } + _ => { + let ref mut fresh15 = (*parser).item_length; + *fresh15 = (*fresh15).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + let ref mut fresh16 = (*parser).item_length; + *fresh16 = (*fresh16).wrapping_sub(1); + let ref mut fresh17 = (*finfo).b_used; + *fresh17 = (*fresh17).wrapping_sub(1); + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_length) + .wrapping_sub(1 as libc::c_int as libc::c_uint) as isize, + ) = 0 as libc::c_int as libc::c_char; + if strncmp( + b"total \0" as *const u8 as *const libc::c_char, + (*finfo).b_data, + 6 as libc::c_int as libc::c_ulong, + ) == 0 as libc::c_int + { + let mut endptr: *mut libc::c_char = ((*finfo).b_data) + .offset(6 as libc::c_int as isize); + while Curl_isspace(*endptr as libc::c_uchar as libc::c_int) + != 0 + { + endptr = endptr.offset(1); + } + while Curl_isdigit(*endptr as libc::c_uchar as libc::c_int) + != 0 + { + endptr = endptr.offset(1); + } + if *endptr != 0 { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + (*finfo).b_used = 0 as libc::c_int as size_t; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + } + _ => {} + } + } + 9811869791021064406 => { + match (*parser).state.UNIX.sub.user as libc::c_uint { + 0 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.user = PL_UNIX_USER_PARSING; + } + } + 1 => { + let ref mut fresh20 = (*parser).item_length; + *fresh20 = (*fresh20).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.user = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_GROUP; + (*parser).state.UNIX.sub.group = PL_UNIX_GROUP_PRESPACE; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + } + } + _ => {} + } + } + _ => { + match (*parser).state.UNIX.sub.symlink as libc::c_uint { + 0 => { + current_block = 17809359888120058514; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 16368170406074945475; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 2 => { + current_block = 10105930990766199517; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 3 => { + current_block = 11357570484085178253; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 4 => { + current_block = 6032193395927242546; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 5 => { + current_block = 755694297841528034; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 6 => { + current_block = 5173505947521674114; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 7 => { + current_block = 12108948829114559637; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + } + } + 3 => { + current_block = 2504653350889004047; + match current_block { + 14897958723503621653 => { + match (*parser).state.UNIX.sub.group as libc::c_uint { + 0 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.group = PL_UNIX_GROUP_NAME; + } + } + 1 => { + let ref mut fresh21 = (*parser).item_length; + *fresh21 = (*fresh21).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.group = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_SIZE; + (*parser).state.UNIX.sub.size = PL_UNIX_SIZE_PRESPACE; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + } + } + _ => {} + } + } + 6779615841179357261 => { + match (*parser).state.UNIX.sub.filename as libc::c_uint { + 0 => { + current_block = 9460353118185870455; + match current_block { + 9460353118185870455 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.filename = PL_UNIX_FILENAME_NAME; + } + } + 237011551503419106 => { + let ref mut fresh28 = (*parser).item_length; + *fresh28 = (*fresh28).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 237011551503419106; + match current_block { + 9460353118185870455 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.filename = PL_UNIX_FILENAME_NAME; + } + } + 237011551503419106 => { + let ref mut fresh28 = (*parser).item_length; + *fresh28 = (*fresh28).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 2 => { + current_block = 8794836904205913937; + match current_block { + 9460353118185870455 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.filename = PL_UNIX_FILENAME_NAME; + } + } + 237011551503419106 => { + let ref mut fresh28 = (*parser).item_length; + *fresh28 = (*fresh28).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + 239935657650551384 => { + match (*parser).state.UNIX.sub.time as libc::c_uint { + 0 => { + current_block = 16799793128756688569; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 3676047842931404030; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 2 => { + current_block = 4348891415139402515; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 3 => { + current_block = 9778139347000538655; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 4 => { + current_block = 6646479082925444416; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 5 => { + current_block = 4328367172772116072; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + 16624850812192366308 => { + match (*parser).state.UNIX.sub.size as libc::c_uint { + 0 => { + current_block = 4003799678443473047; + match current_block { + 4003799678443473047 => { + if c as libc::c_int != ' ' as i32 { + if c as libc::c_int >= '0' as i32 + && c as libc::c_int <= '9' as i32 + { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.size = PL_UNIX_SIZE_NUMBER; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + let ref mut fresh22 = (*parser).item_length; + *fresh22 = (*fresh22).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + let mut p_0: *mut libc::c_char = 0 as *mut libc::c_char; + let mut fsize: curl_off_t = 0; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + if curlx_strtoofft( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut p_0, + 10 as libc::c_int, + &mut fsize, + ) as u64 == 0 + { + if *p_0.offset(0 as libc::c_int as isize) as libc::c_int + == '\u{0}' as i32 + && fsize != 0x7fffffffffffffff as libc::c_long + && fsize + != -(0x7fffffffffffffff as libc::c_long) - 1 as libc::c_long + { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 6 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.size = fsize; + } + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).state.UNIX.main = PL_UNIX_TIME; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART1; + } + } else if Curl_isdigit(c as libc::c_uchar as libc::c_int) + == 0 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 16318689547377354787; + match current_block { + 4003799678443473047 => { + if c as libc::c_int != ' ' as i32 { + if c as libc::c_int >= '0' as i32 + && c as libc::c_int <= '9' as i32 + { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.size = PL_UNIX_SIZE_NUMBER; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + let ref mut fresh22 = (*parser).item_length; + *fresh22 = (*fresh22).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + let mut p_0: *mut libc::c_char = 0 as *mut libc::c_char; + let mut fsize: curl_off_t = 0; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + if curlx_strtoofft( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut p_0, + 10 as libc::c_int, + &mut fsize, + ) as u64 == 0 + { + if *p_0.offset(0 as libc::c_int as isize) as libc::c_int + == '\u{0}' as i32 + && fsize != 0x7fffffffffffffff as libc::c_long + && fsize + != -(0x7fffffffffffffff as libc::c_long) - 1 as libc::c_long + { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 6 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.size = fsize; + } + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).state.UNIX.main = PL_UNIX_TIME; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART1; + } + } else if Curl_isdigit(c as libc::c_uchar as libc::c_int) + == 0 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + 2504653350889004047 => { + match (*parser).state.UNIX.sub.hlinks as libc::c_uint { + 0 => { + current_block = 3684944600068393837; + match current_block { + 3684944600068393837 => { + if c as libc::c_int != ' ' as i32 { + if c as libc::c_int >= '0' as i32 + && c as libc::c_int <= '9' as i32 + { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.hlinks = PL_UNIX_HLINKS_NUMBER; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + let ref mut fresh19 = (*parser).item_length; + *fresh19 = (*fresh19).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + let mut p: *mut libc::c_char = 0 as *mut libc::c_char; + let mut hlinks: libc::c_long = 0; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + hlinks = strtol( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut p, + 10 as libc::c_int, + ); + if *p.offset(0 as libc::c_int as isize) as libc::c_int + == '\u{0}' as i32 + && hlinks != 9223372036854775807 as libc::c_long + && hlinks + != -(9223372036854775807 as libc::c_long) + - 1 as libc::c_long + { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 7 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.hardlinks = hlinks; + } + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).state.UNIX.main = PL_UNIX_USER; + (*parser).state.UNIX.sub.user = PL_UNIX_USER_PRESPACE; + } else if (c as libc::c_int) < '0' as i32 + || c as libc::c_int > '9' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 5484315482916150815; + match current_block { + 3684944600068393837 => { + if c as libc::c_int != ' ' as i32 { + if c as libc::c_int >= '0' as i32 + && c as libc::c_int <= '9' as i32 + { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.hlinks = PL_UNIX_HLINKS_NUMBER; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + let ref mut fresh19 = (*parser).item_length; + *fresh19 = (*fresh19).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + let mut p: *mut libc::c_char = 0 as *mut libc::c_char; + let mut hlinks: libc::c_long = 0; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + hlinks = strtol( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut p, + 10 as libc::c_int, + ); + if *p.offset(0 as libc::c_int as isize) as libc::c_int + == '\u{0}' as i32 + && hlinks != 9223372036854775807 as libc::c_long + && hlinks + != -(9223372036854775807 as libc::c_long) + - 1 as libc::c_long + { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 7 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.hardlinks = hlinks; + } + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).state.UNIX.main = PL_UNIX_USER; + (*parser).state.UNIX.sub.user = PL_UNIX_USER_PRESPACE; + } else if (c as libc::c_int) < '0' as i32 + || c as libc::c_int > '9' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + 9904077679713191023 => { + let ref mut fresh18 = (*parser).item_length; + *fresh18 = (*fresh18).wrapping_add(1); + if (*parser).item_length <= 9 as libc::c_int as libc::c_uint + { + if (strchr( + b"rwx-tTsS\0" as *const u8 as *const libc::c_char, + c as libc::c_int, + )) + .is_null() + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } else if (*parser).item_length + == 10 as libc::c_int as libc::c_uint + { + let mut perm: libc::c_uint = 0; + if c as libc::c_int != ' ' as i32 { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + *((*finfo).b_data) + .offset( + 10 as libc::c_int as isize, + ) = 0 as libc::c_int as libc::c_char; + perm = ftp_pl_get_permission( + ((*finfo).b_data).offset((*parser).item_offset as isize), + ) as libc::c_uint; + if perm & 0x1000000 as libc::c_int as libc::c_uint != 0 { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 3 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.perm = perm; + (*parser).offsets.perm = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.main = PL_UNIX_HLINKS; + (*parser).state.UNIX.sub.hlinks = PL_UNIX_HLINKS_PRESPACE; + } + } + } + } + 9625400769004322558 => { + match c as libc::c_int { + 45 => { + (*finfo).filetype = CURLFILETYPE_FILE; + } + 100 => { + (*finfo).filetype = CURLFILETYPE_DIRECTORY; + } + 108 => { + (*finfo).filetype = CURLFILETYPE_SYMLINK; + } + 112 => { + (*finfo).filetype = CURLFILETYPE_NAMEDPIPE; + } + 115 => { + (*finfo).filetype = CURLFILETYPE_SOCKET; + } + 99 => { + (*finfo).filetype = CURLFILETYPE_DEVICE_CHAR; + } + 98 => { + (*finfo).filetype = CURLFILETYPE_DEVICE_BLOCK; + } + 68 => { + (*finfo).filetype = CURLFILETYPE_DOOR; + } + _ => { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + (*parser).state.UNIX.main = PL_UNIX_PERMISSION; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 1 as libc::c_int as size_t; + } + 17024674780638317650 => { + match (*parser).state.UNIX.sub.total_dirsize as libc::c_uint + { + 0 => { + current_block = 6514364568132207893; + match current_block { + 6514364568132207893 => { + if c as libc::c_int == 't' as i32 { + (*parser) + .state + .UNIX + .sub + .total_dirsize = PL_UNIX_TOTALSIZE_READING; + let ref mut fresh14 = (*parser).item_length; + *fresh14 = (*fresh14).wrapping_add(1); + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + (*finfo).b_used = 0 as libc::c_int as size_t; + continue; + } + } + _ => { + let ref mut fresh15 = (*parser).item_length; + *fresh15 = (*fresh15).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + let ref mut fresh16 = (*parser).item_length; + *fresh16 = (*fresh16).wrapping_sub(1); + let ref mut fresh17 = (*finfo).b_used; + *fresh17 = (*fresh17).wrapping_sub(1); + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_length) + .wrapping_sub(1 as libc::c_int as libc::c_uint) as isize, + ) = 0 as libc::c_int as libc::c_char; + if strncmp( + b"total \0" as *const u8 as *const libc::c_char, + (*finfo).b_data, + 6 as libc::c_int as libc::c_ulong, + ) == 0 as libc::c_int + { + let mut endptr: *mut libc::c_char = ((*finfo).b_data) + .offset(6 as libc::c_int as isize); + while Curl_isspace(*endptr as libc::c_uchar as libc::c_int) + != 0 + { + endptr = endptr.offset(1); + } + while Curl_isdigit(*endptr as libc::c_uchar as libc::c_int) + != 0 + { + endptr = endptr.offset(1); + } + if *endptr != 0 { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + (*finfo).b_used = 0 as libc::c_int as size_t; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + } + 1 => { + current_block = 13626467451598339886; + match current_block { + 6514364568132207893 => { + if c as libc::c_int == 't' as i32 { + (*parser) + .state + .UNIX + .sub + .total_dirsize = PL_UNIX_TOTALSIZE_READING; + let ref mut fresh14 = (*parser).item_length; + *fresh14 = (*fresh14).wrapping_add(1); + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + (*finfo).b_used = 0 as libc::c_int as size_t; + continue; + } + } + _ => { + let ref mut fresh15 = (*parser).item_length; + *fresh15 = (*fresh15).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + let ref mut fresh16 = (*parser).item_length; + *fresh16 = (*fresh16).wrapping_sub(1); + let ref mut fresh17 = (*finfo).b_used; + *fresh17 = (*fresh17).wrapping_sub(1); + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_length) + .wrapping_sub(1 as libc::c_int as libc::c_uint) as isize, + ) = 0 as libc::c_int as libc::c_char; + if strncmp( + b"total \0" as *const u8 as *const libc::c_char, + (*finfo).b_data, + 6 as libc::c_int as libc::c_ulong, + ) == 0 as libc::c_int + { + let mut endptr: *mut libc::c_char = ((*finfo).b_data) + .offset(6 as libc::c_int as isize); + while Curl_isspace(*endptr as libc::c_uchar as libc::c_int) + != 0 + { + endptr = endptr.offset(1); + } + while Curl_isdigit(*endptr as libc::c_uchar as libc::c_int) + != 0 + { + endptr = endptr.offset(1); + } + if *endptr != 0 { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + (*finfo).b_used = 0 as libc::c_int as size_t; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + } + _ => {} + } + } + 9811869791021064406 => { + match (*parser).state.UNIX.sub.user as libc::c_uint { + 0 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.user = PL_UNIX_USER_PARSING; + } + } + 1 => { + let ref mut fresh20 = (*parser).item_length; + *fresh20 = (*fresh20).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.user = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_GROUP; + (*parser).state.UNIX.sub.group = PL_UNIX_GROUP_PRESPACE; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + } + } + _ => {} + } + } + _ => { + match (*parser).state.UNIX.sub.symlink as libc::c_uint { + 0 => { + current_block = 17809359888120058514; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 16368170406074945475; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 2 => { + current_block = 10105930990766199517; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 3 => { + current_block = 11357570484085178253; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 4 => { + current_block = 6032193395927242546; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 5 => { + current_block = 755694297841528034; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 6 => { + current_block = 5173505947521674114; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 7 => { + current_block = 12108948829114559637; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + } + } + 4 => { + current_block = 9811869791021064406; + match current_block { + 14897958723503621653 => { + match (*parser).state.UNIX.sub.group as libc::c_uint { + 0 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.group = PL_UNIX_GROUP_NAME; + } + } + 1 => { + let ref mut fresh21 = (*parser).item_length; + *fresh21 = (*fresh21).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.group = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_SIZE; + (*parser).state.UNIX.sub.size = PL_UNIX_SIZE_PRESPACE; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + } + } + _ => {} + } + } + 6779615841179357261 => { + match (*parser).state.UNIX.sub.filename as libc::c_uint { + 0 => { + current_block = 9460353118185870455; + match current_block { + 9460353118185870455 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.filename = PL_UNIX_FILENAME_NAME; + } + } + 237011551503419106 => { + let ref mut fresh28 = (*parser).item_length; + *fresh28 = (*fresh28).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 237011551503419106; + match current_block { + 9460353118185870455 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.filename = PL_UNIX_FILENAME_NAME; + } + } + 237011551503419106 => { + let ref mut fresh28 = (*parser).item_length; + *fresh28 = (*fresh28).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 2 => { + current_block = 8794836904205913937; + match current_block { + 9460353118185870455 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.filename = PL_UNIX_FILENAME_NAME; + } + } + 237011551503419106 => { + let ref mut fresh28 = (*parser).item_length; + *fresh28 = (*fresh28).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + 239935657650551384 => { + match (*parser).state.UNIX.sub.time as libc::c_uint { + 0 => { + current_block = 16799793128756688569; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 3676047842931404030; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 2 => { + current_block = 4348891415139402515; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 3 => { + current_block = 9778139347000538655; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 4 => { + current_block = 6646479082925444416; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 5 => { + current_block = 4328367172772116072; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + 16624850812192366308 => { + match (*parser).state.UNIX.sub.size as libc::c_uint { + 0 => { + current_block = 4003799678443473047; + match current_block { + 4003799678443473047 => { + if c as libc::c_int != ' ' as i32 { + if c as libc::c_int >= '0' as i32 + && c as libc::c_int <= '9' as i32 + { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.size = PL_UNIX_SIZE_NUMBER; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + let ref mut fresh22 = (*parser).item_length; + *fresh22 = (*fresh22).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + let mut p_0: *mut libc::c_char = 0 as *mut libc::c_char; + let mut fsize: curl_off_t = 0; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + if curlx_strtoofft( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut p_0, + 10 as libc::c_int, + &mut fsize, + ) as u64 == 0 + { + if *p_0.offset(0 as libc::c_int as isize) as libc::c_int + == '\u{0}' as i32 + && fsize != 0x7fffffffffffffff as libc::c_long + && fsize + != -(0x7fffffffffffffff as libc::c_long) - 1 as libc::c_long + { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 6 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.size = fsize; + } + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).state.UNIX.main = PL_UNIX_TIME; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART1; + } + } else if Curl_isdigit(c as libc::c_uchar as libc::c_int) + == 0 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 16318689547377354787; + match current_block { + 4003799678443473047 => { + if c as libc::c_int != ' ' as i32 { + if c as libc::c_int >= '0' as i32 + && c as libc::c_int <= '9' as i32 + { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.size = PL_UNIX_SIZE_NUMBER; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + let ref mut fresh22 = (*parser).item_length; + *fresh22 = (*fresh22).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + let mut p_0: *mut libc::c_char = 0 as *mut libc::c_char; + let mut fsize: curl_off_t = 0; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + if curlx_strtoofft( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut p_0, + 10 as libc::c_int, + &mut fsize, + ) as u64 == 0 + { + if *p_0.offset(0 as libc::c_int as isize) as libc::c_int + == '\u{0}' as i32 + && fsize != 0x7fffffffffffffff as libc::c_long + && fsize + != -(0x7fffffffffffffff as libc::c_long) - 1 as libc::c_long + { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 6 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.size = fsize; + } + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).state.UNIX.main = PL_UNIX_TIME; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART1; + } + } else if Curl_isdigit(c as libc::c_uchar as libc::c_int) + == 0 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + 2504653350889004047 => { + match (*parser).state.UNIX.sub.hlinks as libc::c_uint { + 0 => { + current_block = 3684944600068393837; + match current_block { + 3684944600068393837 => { + if c as libc::c_int != ' ' as i32 { + if c as libc::c_int >= '0' as i32 + && c as libc::c_int <= '9' as i32 + { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.hlinks = PL_UNIX_HLINKS_NUMBER; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + let ref mut fresh19 = (*parser).item_length; + *fresh19 = (*fresh19).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + let mut p: *mut libc::c_char = 0 as *mut libc::c_char; + let mut hlinks: libc::c_long = 0; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + hlinks = strtol( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut p, + 10 as libc::c_int, + ); + if *p.offset(0 as libc::c_int as isize) as libc::c_int + == '\u{0}' as i32 + && hlinks != 9223372036854775807 as libc::c_long + && hlinks + != -(9223372036854775807 as libc::c_long) + - 1 as libc::c_long + { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 7 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.hardlinks = hlinks; + } + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).state.UNIX.main = PL_UNIX_USER; + (*parser).state.UNIX.sub.user = PL_UNIX_USER_PRESPACE; + } else if (c as libc::c_int) < '0' as i32 + || c as libc::c_int > '9' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 5484315482916150815; + match current_block { + 3684944600068393837 => { + if c as libc::c_int != ' ' as i32 { + if c as libc::c_int >= '0' as i32 + && c as libc::c_int <= '9' as i32 + { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.hlinks = PL_UNIX_HLINKS_NUMBER; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + let ref mut fresh19 = (*parser).item_length; + *fresh19 = (*fresh19).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + let mut p: *mut libc::c_char = 0 as *mut libc::c_char; + let mut hlinks: libc::c_long = 0; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + hlinks = strtol( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut p, + 10 as libc::c_int, + ); + if *p.offset(0 as libc::c_int as isize) as libc::c_int + == '\u{0}' as i32 + && hlinks != 9223372036854775807 as libc::c_long + && hlinks + != -(9223372036854775807 as libc::c_long) + - 1 as libc::c_long + { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 7 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.hardlinks = hlinks; + } + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).state.UNIX.main = PL_UNIX_USER; + (*parser).state.UNIX.sub.user = PL_UNIX_USER_PRESPACE; + } else if (c as libc::c_int) < '0' as i32 + || c as libc::c_int > '9' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + 9904077679713191023 => { + let ref mut fresh18 = (*parser).item_length; + *fresh18 = (*fresh18).wrapping_add(1); + if (*parser).item_length <= 9 as libc::c_int as libc::c_uint + { + if (strchr( + b"rwx-tTsS\0" as *const u8 as *const libc::c_char, + c as libc::c_int, + )) + .is_null() + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } else if (*parser).item_length + == 10 as libc::c_int as libc::c_uint + { + let mut perm: libc::c_uint = 0; + if c as libc::c_int != ' ' as i32 { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + *((*finfo).b_data) + .offset( + 10 as libc::c_int as isize, + ) = 0 as libc::c_int as libc::c_char; + perm = ftp_pl_get_permission( + ((*finfo).b_data).offset((*parser).item_offset as isize), + ) as libc::c_uint; + if perm & 0x1000000 as libc::c_int as libc::c_uint != 0 { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 3 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.perm = perm; + (*parser).offsets.perm = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.main = PL_UNIX_HLINKS; + (*parser).state.UNIX.sub.hlinks = PL_UNIX_HLINKS_PRESPACE; + } + } + } + } + 9625400769004322558 => { + match c as libc::c_int { + 45 => { + (*finfo).filetype = CURLFILETYPE_FILE; + } + 100 => { + (*finfo).filetype = CURLFILETYPE_DIRECTORY; + } + 108 => { + (*finfo).filetype = CURLFILETYPE_SYMLINK; + } + 112 => { + (*finfo).filetype = CURLFILETYPE_NAMEDPIPE; + } + 115 => { + (*finfo).filetype = CURLFILETYPE_SOCKET; + } + 99 => { + (*finfo).filetype = CURLFILETYPE_DEVICE_CHAR; + } + 98 => { + (*finfo).filetype = CURLFILETYPE_DEVICE_BLOCK; + } + 68 => { + (*finfo).filetype = CURLFILETYPE_DOOR; + } + _ => { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + (*parser).state.UNIX.main = PL_UNIX_PERMISSION; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 1 as libc::c_int as size_t; + } + 17024674780638317650 => { + match (*parser).state.UNIX.sub.total_dirsize as libc::c_uint + { + 0 => { + current_block = 6514364568132207893; + match current_block { + 6514364568132207893 => { + if c as libc::c_int == 't' as i32 { + (*parser) + .state + .UNIX + .sub + .total_dirsize = PL_UNIX_TOTALSIZE_READING; + let ref mut fresh14 = (*parser).item_length; + *fresh14 = (*fresh14).wrapping_add(1); + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + (*finfo).b_used = 0 as libc::c_int as size_t; + continue; + } + } + _ => { + let ref mut fresh15 = (*parser).item_length; + *fresh15 = (*fresh15).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + let ref mut fresh16 = (*parser).item_length; + *fresh16 = (*fresh16).wrapping_sub(1); + let ref mut fresh17 = (*finfo).b_used; + *fresh17 = (*fresh17).wrapping_sub(1); + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_length) + .wrapping_sub(1 as libc::c_int as libc::c_uint) as isize, + ) = 0 as libc::c_int as libc::c_char; + if strncmp( + b"total \0" as *const u8 as *const libc::c_char, + (*finfo).b_data, + 6 as libc::c_int as libc::c_ulong, + ) == 0 as libc::c_int + { + let mut endptr: *mut libc::c_char = ((*finfo).b_data) + .offset(6 as libc::c_int as isize); + while Curl_isspace(*endptr as libc::c_uchar as libc::c_int) + != 0 + { + endptr = endptr.offset(1); + } + while Curl_isdigit(*endptr as libc::c_uchar as libc::c_int) + != 0 + { + endptr = endptr.offset(1); + } + if *endptr != 0 { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + (*finfo).b_used = 0 as libc::c_int as size_t; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + } + 1 => { + current_block = 13626467451598339886; + match current_block { + 6514364568132207893 => { + if c as libc::c_int == 't' as i32 { + (*parser) + .state + .UNIX + .sub + .total_dirsize = PL_UNIX_TOTALSIZE_READING; + let ref mut fresh14 = (*parser).item_length; + *fresh14 = (*fresh14).wrapping_add(1); + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + (*finfo).b_used = 0 as libc::c_int as size_t; + continue; + } + } + _ => { + let ref mut fresh15 = (*parser).item_length; + *fresh15 = (*fresh15).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + let ref mut fresh16 = (*parser).item_length; + *fresh16 = (*fresh16).wrapping_sub(1); + let ref mut fresh17 = (*finfo).b_used; + *fresh17 = (*fresh17).wrapping_sub(1); + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_length) + .wrapping_sub(1 as libc::c_int as libc::c_uint) as isize, + ) = 0 as libc::c_int as libc::c_char; + if strncmp( + b"total \0" as *const u8 as *const libc::c_char, + (*finfo).b_data, + 6 as libc::c_int as libc::c_ulong, + ) == 0 as libc::c_int + { + let mut endptr: *mut libc::c_char = ((*finfo).b_data) + .offset(6 as libc::c_int as isize); + while Curl_isspace(*endptr as libc::c_uchar as libc::c_int) + != 0 + { + endptr = endptr.offset(1); + } + while Curl_isdigit(*endptr as libc::c_uchar as libc::c_int) + != 0 + { + endptr = endptr.offset(1); + } + if *endptr != 0 { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + (*finfo).b_used = 0 as libc::c_int as size_t; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + } + _ => {} + } + } + 9811869791021064406 => { + match (*parser).state.UNIX.sub.user as libc::c_uint { + 0 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.user = PL_UNIX_USER_PARSING; + } + } + 1 => { + let ref mut fresh20 = (*parser).item_length; + *fresh20 = (*fresh20).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.user = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_GROUP; + (*parser).state.UNIX.sub.group = PL_UNIX_GROUP_PRESPACE; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + } + } + _ => {} + } + } + _ => { + match (*parser).state.UNIX.sub.symlink as libc::c_uint { + 0 => { + current_block = 17809359888120058514; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 16368170406074945475; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 2 => { + current_block = 10105930990766199517; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 3 => { + current_block = 11357570484085178253; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 4 => { + current_block = 6032193395927242546; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 5 => { + current_block = 755694297841528034; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 6 => { + current_block = 5173505947521674114; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 7 => { + current_block = 12108948829114559637; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + } + } + 5 => { + current_block = 14897958723503621653; + match current_block { + 14897958723503621653 => { + match (*parser).state.UNIX.sub.group as libc::c_uint { + 0 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.group = PL_UNIX_GROUP_NAME; + } + } + 1 => { + let ref mut fresh21 = (*parser).item_length; + *fresh21 = (*fresh21).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.group = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_SIZE; + (*parser).state.UNIX.sub.size = PL_UNIX_SIZE_PRESPACE; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + } + } + _ => {} + } + } + 6779615841179357261 => { + match (*parser).state.UNIX.sub.filename as libc::c_uint { + 0 => { + current_block = 9460353118185870455; + match current_block { + 9460353118185870455 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.filename = PL_UNIX_FILENAME_NAME; + } + } + 237011551503419106 => { + let ref mut fresh28 = (*parser).item_length; + *fresh28 = (*fresh28).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 237011551503419106; + match current_block { + 9460353118185870455 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.filename = PL_UNIX_FILENAME_NAME; + } + } + 237011551503419106 => { + let ref mut fresh28 = (*parser).item_length; + *fresh28 = (*fresh28).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 2 => { + current_block = 8794836904205913937; + match current_block { + 9460353118185870455 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.filename = PL_UNIX_FILENAME_NAME; + } + } + 237011551503419106 => { + let ref mut fresh28 = (*parser).item_length; + *fresh28 = (*fresh28).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + 239935657650551384 => { + match (*parser).state.UNIX.sub.time as libc::c_uint { + 0 => { + current_block = 16799793128756688569; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 3676047842931404030; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 2 => { + current_block = 4348891415139402515; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 3 => { + current_block = 9778139347000538655; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 4 => { + current_block = 6646479082925444416; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 5 => { + current_block = 4328367172772116072; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + 16624850812192366308 => { + match (*parser).state.UNIX.sub.size as libc::c_uint { + 0 => { + current_block = 4003799678443473047; + match current_block { + 4003799678443473047 => { + if c as libc::c_int != ' ' as i32 { + if c as libc::c_int >= '0' as i32 + && c as libc::c_int <= '9' as i32 + { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.size = PL_UNIX_SIZE_NUMBER; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + let ref mut fresh22 = (*parser).item_length; + *fresh22 = (*fresh22).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + let mut p_0: *mut libc::c_char = 0 as *mut libc::c_char; + let mut fsize: curl_off_t = 0; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + if curlx_strtoofft( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut p_0, + 10 as libc::c_int, + &mut fsize, + ) as u64 == 0 + { + if *p_0.offset(0 as libc::c_int as isize) as libc::c_int + == '\u{0}' as i32 + && fsize != 0x7fffffffffffffff as libc::c_long + && fsize + != -(0x7fffffffffffffff as libc::c_long) - 1 as libc::c_long + { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 6 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.size = fsize; + } + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).state.UNIX.main = PL_UNIX_TIME; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART1; + } + } else if Curl_isdigit(c as libc::c_uchar as libc::c_int) + == 0 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 16318689547377354787; + match current_block { + 4003799678443473047 => { + if c as libc::c_int != ' ' as i32 { + if c as libc::c_int >= '0' as i32 + && c as libc::c_int <= '9' as i32 + { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.size = PL_UNIX_SIZE_NUMBER; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + let ref mut fresh22 = (*parser).item_length; + *fresh22 = (*fresh22).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + let mut p_0: *mut libc::c_char = 0 as *mut libc::c_char; + let mut fsize: curl_off_t = 0; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + if curlx_strtoofft( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut p_0, + 10 as libc::c_int, + &mut fsize, + ) as u64 == 0 + { + if *p_0.offset(0 as libc::c_int as isize) as libc::c_int + == '\u{0}' as i32 + && fsize != 0x7fffffffffffffff as libc::c_long + && fsize + != -(0x7fffffffffffffff as libc::c_long) - 1 as libc::c_long + { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 6 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.size = fsize; + } + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).state.UNIX.main = PL_UNIX_TIME; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART1; + } + } else if Curl_isdigit(c as libc::c_uchar as libc::c_int) + == 0 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + 2504653350889004047 => { + match (*parser).state.UNIX.sub.hlinks as libc::c_uint { + 0 => { + current_block = 3684944600068393837; + match current_block { + 3684944600068393837 => { + if c as libc::c_int != ' ' as i32 { + if c as libc::c_int >= '0' as i32 + && c as libc::c_int <= '9' as i32 + { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.hlinks = PL_UNIX_HLINKS_NUMBER; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + let ref mut fresh19 = (*parser).item_length; + *fresh19 = (*fresh19).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + let mut p: *mut libc::c_char = 0 as *mut libc::c_char; + let mut hlinks: libc::c_long = 0; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + hlinks = strtol( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut p, + 10 as libc::c_int, + ); + if *p.offset(0 as libc::c_int as isize) as libc::c_int + == '\u{0}' as i32 + && hlinks != 9223372036854775807 as libc::c_long + && hlinks + != -(9223372036854775807 as libc::c_long) + - 1 as libc::c_long + { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 7 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.hardlinks = hlinks; + } + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).state.UNIX.main = PL_UNIX_USER; + (*parser).state.UNIX.sub.user = PL_UNIX_USER_PRESPACE; + } else if (c as libc::c_int) < '0' as i32 + || c as libc::c_int > '9' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 5484315482916150815; + match current_block { + 3684944600068393837 => { + if c as libc::c_int != ' ' as i32 { + if c as libc::c_int >= '0' as i32 + && c as libc::c_int <= '9' as i32 + { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.hlinks = PL_UNIX_HLINKS_NUMBER; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + let ref mut fresh19 = (*parser).item_length; + *fresh19 = (*fresh19).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + let mut p: *mut libc::c_char = 0 as *mut libc::c_char; + let mut hlinks: libc::c_long = 0; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + hlinks = strtol( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut p, + 10 as libc::c_int, + ); + if *p.offset(0 as libc::c_int as isize) as libc::c_int + == '\u{0}' as i32 + && hlinks != 9223372036854775807 as libc::c_long + && hlinks + != -(9223372036854775807 as libc::c_long) + - 1 as libc::c_long + { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 7 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.hardlinks = hlinks; + } + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).state.UNIX.main = PL_UNIX_USER; + (*parser).state.UNIX.sub.user = PL_UNIX_USER_PRESPACE; + } else if (c as libc::c_int) < '0' as i32 + || c as libc::c_int > '9' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + 9904077679713191023 => { + let ref mut fresh18 = (*parser).item_length; + *fresh18 = (*fresh18).wrapping_add(1); + if (*parser).item_length <= 9 as libc::c_int as libc::c_uint + { + if (strchr( + b"rwx-tTsS\0" as *const u8 as *const libc::c_char, + c as libc::c_int, + )) + .is_null() + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } else if (*parser).item_length + == 10 as libc::c_int as libc::c_uint + { + let mut perm: libc::c_uint = 0; + if c as libc::c_int != ' ' as i32 { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + *((*finfo).b_data) + .offset( + 10 as libc::c_int as isize, + ) = 0 as libc::c_int as libc::c_char; + perm = ftp_pl_get_permission( + ((*finfo).b_data).offset((*parser).item_offset as isize), + ) as libc::c_uint; + if perm & 0x1000000 as libc::c_int as libc::c_uint != 0 { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 3 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.perm = perm; + (*parser).offsets.perm = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.main = PL_UNIX_HLINKS; + (*parser).state.UNIX.sub.hlinks = PL_UNIX_HLINKS_PRESPACE; + } + } + } + } + 9625400769004322558 => { + match c as libc::c_int { + 45 => { + (*finfo).filetype = CURLFILETYPE_FILE; + } + 100 => { + (*finfo).filetype = CURLFILETYPE_DIRECTORY; + } + 108 => { + (*finfo).filetype = CURLFILETYPE_SYMLINK; + } + 112 => { + (*finfo).filetype = CURLFILETYPE_NAMEDPIPE; + } + 115 => { + (*finfo).filetype = CURLFILETYPE_SOCKET; + } + 99 => { + (*finfo).filetype = CURLFILETYPE_DEVICE_CHAR; + } + 98 => { + (*finfo).filetype = CURLFILETYPE_DEVICE_BLOCK; + } + 68 => { + (*finfo).filetype = CURLFILETYPE_DOOR; + } + _ => { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + (*parser).state.UNIX.main = PL_UNIX_PERMISSION; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 1 as libc::c_int as size_t; + } + 17024674780638317650 => { + match (*parser).state.UNIX.sub.total_dirsize as libc::c_uint + { + 0 => { + current_block = 6514364568132207893; + match current_block { + 6514364568132207893 => { + if c as libc::c_int == 't' as i32 { + (*parser) + .state + .UNIX + .sub + .total_dirsize = PL_UNIX_TOTALSIZE_READING; + let ref mut fresh14 = (*parser).item_length; + *fresh14 = (*fresh14).wrapping_add(1); + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + (*finfo).b_used = 0 as libc::c_int as size_t; + continue; + } + } + _ => { + let ref mut fresh15 = (*parser).item_length; + *fresh15 = (*fresh15).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + let ref mut fresh16 = (*parser).item_length; + *fresh16 = (*fresh16).wrapping_sub(1); + let ref mut fresh17 = (*finfo).b_used; + *fresh17 = (*fresh17).wrapping_sub(1); + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_length) + .wrapping_sub(1 as libc::c_int as libc::c_uint) as isize, + ) = 0 as libc::c_int as libc::c_char; + if strncmp( + b"total \0" as *const u8 as *const libc::c_char, + (*finfo).b_data, + 6 as libc::c_int as libc::c_ulong, + ) == 0 as libc::c_int + { + let mut endptr: *mut libc::c_char = ((*finfo).b_data) + .offset(6 as libc::c_int as isize); + while Curl_isspace(*endptr as libc::c_uchar as libc::c_int) + != 0 + { + endptr = endptr.offset(1); + } + while Curl_isdigit(*endptr as libc::c_uchar as libc::c_int) + != 0 + { + endptr = endptr.offset(1); + } + if *endptr != 0 { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + (*finfo).b_used = 0 as libc::c_int as size_t; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + } + 1 => { + current_block = 13626467451598339886; + match current_block { + 6514364568132207893 => { + if c as libc::c_int == 't' as i32 { + (*parser) + .state + .UNIX + .sub + .total_dirsize = PL_UNIX_TOTALSIZE_READING; + let ref mut fresh14 = (*parser).item_length; + *fresh14 = (*fresh14).wrapping_add(1); + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + (*finfo).b_used = 0 as libc::c_int as size_t; + continue; + } + } + _ => { + let ref mut fresh15 = (*parser).item_length; + *fresh15 = (*fresh15).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + let ref mut fresh16 = (*parser).item_length; + *fresh16 = (*fresh16).wrapping_sub(1); + let ref mut fresh17 = (*finfo).b_used; + *fresh17 = (*fresh17).wrapping_sub(1); + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_length) + .wrapping_sub(1 as libc::c_int as libc::c_uint) as isize, + ) = 0 as libc::c_int as libc::c_char; + if strncmp( + b"total \0" as *const u8 as *const libc::c_char, + (*finfo).b_data, + 6 as libc::c_int as libc::c_ulong, + ) == 0 as libc::c_int + { + let mut endptr: *mut libc::c_char = ((*finfo).b_data) + .offset(6 as libc::c_int as isize); + while Curl_isspace(*endptr as libc::c_uchar as libc::c_int) + != 0 + { + endptr = endptr.offset(1); + } + while Curl_isdigit(*endptr as libc::c_uchar as libc::c_int) + != 0 + { + endptr = endptr.offset(1); + } + if *endptr != 0 { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + (*finfo).b_used = 0 as libc::c_int as size_t; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + } + _ => {} + } + } + 9811869791021064406 => { + match (*parser).state.UNIX.sub.user as libc::c_uint { + 0 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.user = PL_UNIX_USER_PARSING; + } + } + 1 => { + let ref mut fresh20 = (*parser).item_length; + *fresh20 = (*fresh20).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.user = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_GROUP; + (*parser).state.UNIX.sub.group = PL_UNIX_GROUP_PRESPACE; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + } + } + _ => {} + } + } + _ => { + match (*parser).state.UNIX.sub.symlink as libc::c_uint { + 0 => { + current_block = 17809359888120058514; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 16368170406074945475; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 2 => { + current_block = 10105930990766199517; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 3 => { + current_block = 11357570484085178253; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 4 => { + current_block = 6032193395927242546; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 5 => { + current_block = 755694297841528034; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 6 => { + current_block = 5173505947521674114; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 7 => { + current_block = 12108948829114559637; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + } + } + 6 => { + current_block = 16624850812192366308; + match current_block { + 14897958723503621653 => { + match (*parser).state.UNIX.sub.group as libc::c_uint { + 0 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.group = PL_UNIX_GROUP_NAME; + } + } + 1 => { + let ref mut fresh21 = (*parser).item_length; + *fresh21 = (*fresh21).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.group = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_SIZE; + (*parser).state.UNIX.sub.size = PL_UNIX_SIZE_PRESPACE; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + } + } + _ => {} + } + } + 6779615841179357261 => { + match (*parser).state.UNIX.sub.filename as libc::c_uint { + 0 => { + current_block = 9460353118185870455; + match current_block { + 9460353118185870455 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.filename = PL_UNIX_FILENAME_NAME; + } + } + 237011551503419106 => { + let ref mut fresh28 = (*parser).item_length; + *fresh28 = (*fresh28).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 237011551503419106; + match current_block { + 9460353118185870455 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.filename = PL_UNIX_FILENAME_NAME; + } + } + 237011551503419106 => { + let ref mut fresh28 = (*parser).item_length; + *fresh28 = (*fresh28).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 2 => { + current_block = 8794836904205913937; + match current_block { + 9460353118185870455 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.filename = PL_UNIX_FILENAME_NAME; + } + } + 237011551503419106 => { + let ref mut fresh28 = (*parser).item_length; + *fresh28 = (*fresh28).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + 239935657650551384 => { + match (*parser).state.UNIX.sub.time as libc::c_uint { + 0 => { + current_block = 16799793128756688569; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 3676047842931404030; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 2 => { + current_block = 4348891415139402515; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 3 => { + current_block = 9778139347000538655; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 4 => { + current_block = 6646479082925444416; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 5 => { + current_block = 4328367172772116072; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + 16624850812192366308 => { + match (*parser).state.UNIX.sub.size as libc::c_uint { + 0 => { + current_block = 4003799678443473047; + match current_block { + 4003799678443473047 => { + if c as libc::c_int != ' ' as i32 { + if c as libc::c_int >= '0' as i32 + && c as libc::c_int <= '9' as i32 + { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.size = PL_UNIX_SIZE_NUMBER; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + let ref mut fresh22 = (*parser).item_length; + *fresh22 = (*fresh22).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + let mut p_0: *mut libc::c_char = 0 as *mut libc::c_char; + let mut fsize: curl_off_t = 0; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + if curlx_strtoofft( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut p_0, + 10 as libc::c_int, + &mut fsize, + ) as u64 == 0 + { + if *p_0.offset(0 as libc::c_int as isize) as libc::c_int + == '\u{0}' as i32 + && fsize != 0x7fffffffffffffff as libc::c_long + && fsize + != -(0x7fffffffffffffff as libc::c_long) - 1 as libc::c_long + { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 6 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.size = fsize; + } + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).state.UNIX.main = PL_UNIX_TIME; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART1; + } + } else if Curl_isdigit(c as libc::c_uchar as libc::c_int) + == 0 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 16318689547377354787; + match current_block { + 4003799678443473047 => { + if c as libc::c_int != ' ' as i32 { + if c as libc::c_int >= '0' as i32 + && c as libc::c_int <= '9' as i32 + { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.size = PL_UNIX_SIZE_NUMBER; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + let ref mut fresh22 = (*parser).item_length; + *fresh22 = (*fresh22).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + let mut p_0: *mut libc::c_char = 0 as *mut libc::c_char; + let mut fsize: curl_off_t = 0; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + if curlx_strtoofft( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut p_0, + 10 as libc::c_int, + &mut fsize, + ) as u64 == 0 + { + if *p_0.offset(0 as libc::c_int as isize) as libc::c_int + == '\u{0}' as i32 + && fsize != 0x7fffffffffffffff as libc::c_long + && fsize + != -(0x7fffffffffffffff as libc::c_long) - 1 as libc::c_long + { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 6 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.size = fsize; + } + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).state.UNIX.main = PL_UNIX_TIME; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART1; + } + } else if Curl_isdigit(c as libc::c_uchar as libc::c_int) + == 0 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + 2504653350889004047 => { + match (*parser).state.UNIX.sub.hlinks as libc::c_uint { + 0 => { + current_block = 3684944600068393837; + match current_block { + 3684944600068393837 => { + if c as libc::c_int != ' ' as i32 { + if c as libc::c_int >= '0' as i32 + && c as libc::c_int <= '9' as i32 + { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.hlinks = PL_UNIX_HLINKS_NUMBER; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + let ref mut fresh19 = (*parser).item_length; + *fresh19 = (*fresh19).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + let mut p: *mut libc::c_char = 0 as *mut libc::c_char; + let mut hlinks: libc::c_long = 0; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + hlinks = strtol( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut p, + 10 as libc::c_int, + ); + if *p.offset(0 as libc::c_int as isize) as libc::c_int + == '\u{0}' as i32 + && hlinks != 9223372036854775807 as libc::c_long + && hlinks + != -(9223372036854775807 as libc::c_long) + - 1 as libc::c_long + { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 7 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.hardlinks = hlinks; + } + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).state.UNIX.main = PL_UNIX_USER; + (*parser).state.UNIX.sub.user = PL_UNIX_USER_PRESPACE; + } else if (c as libc::c_int) < '0' as i32 + || c as libc::c_int > '9' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 5484315482916150815; + match current_block { + 3684944600068393837 => { + if c as libc::c_int != ' ' as i32 { + if c as libc::c_int >= '0' as i32 + && c as libc::c_int <= '9' as i32 + { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.hlinks = PL_UNIX_HLINKS_NUMBER; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + let ref mut fresh19 = (*parser).item_length; + *fresh19 = (*fresh19).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + let mut p: *mut libc::c_char = 0 as *mut libc::c_char; + let mut hlinks: libc::c_long = 0; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + hlinks = strtol( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut p, + 10 as libc::c_int, + ); + if *p.offset(0 as libc::c_int as isize) as libc::c_int + == '\u{0}' as i32 + && hlinks != 9223372036854775807 as libc::c_long + && hlinks + != -(9223372036854775807 as libc::c_long) + - 1 as libc::c_long + { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 7 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.hardlinks = hlinks; + } + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).state.UNIX.main = PL_UNIX_USER; + (*parser).state.UNIX.sub.user = PL_UNIX_USER_PRESPACE; + } else if (c as libc::c_int) < '0' as i32 + || c as libc::c_int > '9' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + 9904077679713191023 => { + let ref mut fresh18 = (*parser).item_length; + *fresh18 = (*fresh18).wrapping_add(1); + if (*parser).item_length <= 9 as libc::c_int as libc::c_uint + { + if (strchr( + b"rwx-tTsS\0" as *const u8 as *const libc::c_char, + c as libc::c_int, + )) + .is_null() + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } else if (*parser).item_length + == 10 as libc::c_int as libc::c_uint + { + let mut perm: libc::c_uint = 0; + if c as libc::c_int != ' ' as i32 { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + *((*finfo).b_data) + .offset( + 10 as libc::c_int as isize, + ) = 0 as libc::c_int as libc::c_char; + perm = ftp_pl_get_permission( + ((*finfo).b_data).offset((*parser).item_offset as isize), + ) as libc::c_uint; + if perm & 0x1000000 as libc::c_int as libc::c_uint != 0 { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 3 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.perm = perm; + (*parser).offsets.perm = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.main = PL_UNIX_HLINKS; + (*parser).state.UNIX.sub.hlinks = PL_UNIX_HLINKS_PRESPACE; + } + } + } + } + 9625400769004322558 => { + match c as libc::c_int { + 45 => { + (*finfo).filetype = CURLFILETYPE_FILE; + } + 100 => { + (*finfo).filetype = CURLFILETYPE_DIRECTORY; + } + 108 => { + (*finfo).filetype = CURLFILETYPE_SYMLINK; + } + 112 => { + (*finfo).filetype = CURLFILETYPE_NAMEDPIPE; + } + 115 => { + (*finfo).filetype = CURLFILETYPE_SOCKET; + } + 99 => { + (*finfo).filetype = CURLFILETYPE_DEVICE_CHAR; + } + 98 => { + (*finfo).filetype = CURLFILETYPE_DEVICE_BLOCK; + } + 68 => { + (*finfo).filetype = CURLFILETYPE_DOOR; + } + _ => { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + (*parser).state.UNIX.main = PL_UNIX_PERMISSION; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 1 as libc::c_int as size_t; + } + 17024674780638317650 => { + match (*parser).state.UNIX.sub.total_dirsize as libc::c_uint + { + 0 => { + current_block = 6514364568132207893; + match current_block { + 6514364568132207893 => { + if c as libc::c_int == 't' as i32 { + (*parser) + .state + .UNIX + .sub + .total_dirsize = PL_UNIX_TOTALSIZE_READING; + let ref mut fresh14 = (*parser).item_length; + *fresh14 = (*fresh14).wrapping_add(1); + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + (*finfo).b_used = 0 as libc::c_int as size_t; + continue; + } + } + _ => { + let ref mut fresh15 = (*parser).item_length; + *fresh15 = (*fresh15).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + let ref mut fresh16 = (*parser).item_length; + *fresh16 = (*fresh16).wrapping_sub(1); + let ref mut fresh17 = (*finfo).b_used; + *fresh17 = (*fresh17).wrapping_sub(1); + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_length) + .wrapping_sub(1 as libc::c_int as libc::c_uint) as isize, + ) = 0 as libc::c_int as libc::c_char; + if strncmp( + b"total \0" as *const u8 as *const libc::c_char, + (*finfo).b_data, + 6 as libc::c_int as libc::c_ulong, + ) == 0 as libc::c_int + { + let mut endptr: *mut libc::c_char = ((*finfo).b_data) + .offset(6 as libc::c_int as isize); + while Curl_isspace(*endptr as libc::c_uchar as libc::c_int) + != 0 + { + endptr = endptr.offset(1); + } + while Curl_isdigit(*endptr as libc::c_uchar as libc::c_int) + != 0 + { + endptr = endptr.offset(1); + } + if *endptr != 0 { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + (*finfo).b_used = 0 as libc::c_int as size_t; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + } + 1 => { + current_block = 13626467451598339886; + match current_block { + 6514364568132207893 => { + if c as libc::c_int == 't' as i32 { + (*parser) + .state + .UNIX + .sub + .total_dirsize = PL_UNIX_TOTALSIZE_READING; + let ref mut fresh14 = (*parser).item_length; + *fresh14 = (*fresh14).wrapping_add(1); + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + (*finfo).b_used = 0 as libc::c_int as size_t; + continue; + } + } + _ => { + let ref mut fresh15 = (*parser).item_length; + *fresh15 = (*fresh15).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + let ref mut fresh16 = (*parser).item_length; + *fresh16 = (*fresh16).wrapping_sub(1); + let ref mut fresh17 = (*finfo).b_used; + *fresh17 = (*fresh17).wrapping_sub(1); + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_length) + .wrapping_sub(1 as libc::c_int as libc::c_uint) as isize, + ) = 0 as libc::c_int as libc::c_char; + if strncmp( + b"total \0" as *const u8 as *const libc::c_char, + (*finfo).b_data, + 6 as libc::c_int as libc::c_ulong, + ) == 0 as libc::c_int + { + let mut endptr: *mut libc::c_char = ((*finfo).b_data) + .offset(6 as libc::c_int as isize); + while Curl_isspace(*endptr as libc::c_uchar as libc::c_int) + != 0 + { + endptr = endptr.offset(1); + } + while Curl_isdigit(*endptr as libc::c_uchar as libc::c_int) + != 0 + { + endptr = endptr.offset(1); + } + if *endptr != 0 { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + (*finfo).b_used = 0 as libc::c_int as size_t; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + } + _ => {} + } + } + 9811869791021064406 => { + match (*parser).state.UNIX.sub.user as libc::c_uint { + 0 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.user = PL_UNIX_USER_PARSING; + } + } + 1 => { + let ref mut fresh20 = (*parser).item_length; + *fresh20 = (*fresh20).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.user = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_GROUP; + (*parser).state.UNIX.sub.group = PL_UNIX_GROUP_PRESPACE; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + } + } + _ => {} + } + } + _ => { + match (*parser).state.UNIX.sub.symlink as libc::c_uint { + 0 => { + current_block = 17809359888120058514; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 16368170406074945475; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 2 => { + current_block = 10105930990766199517; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 3 => { + current_block = 11357570484085178253; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 4 => { + current_block = 6032193395927242546; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 5 => { + current_block = 755694297841528034; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 6 => { + current_block = 5173505947521674114; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 7 => { + current_block = 12108948829114559637; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + } + } + 7 => { + current_block = 239935657650551384; + match current_block { + 14897958723503621653 => { + match (*parser).state.UNIX.sub.group as libc::c_uint { + 0 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.group = PL_UNIX_GROUP_NAME; + } + } + 1 => { + let ref mut fresh21 = (*parser).item_length; + *fresh21 = (*fresh21).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.group = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_SIZE; + (*parser).state.UNIX.sub.size = PL_UNIX_SIZE_PRESPACE; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + } + } + _ => {} + } + } + 6779615841179357261 => { + match (*parser).state.UNIX.sub.filename as libc::c_uint { + 0 => { + current_block = 9460353118185870455; + match current_block { + 9460353118185870455 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.filename = PL_UNIX_FILENAME_NAME; + } + } + 237011551503419106 => { + let ref mut fresh28 = (*parser).item_length; + *fresh28 = (*fresh28).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 237011551503419106; + match current_block { + 9460353118185870455 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.filename = PL_UNIX_FILENAME_NAME; + } + } + 237011551503419106 => { + let ref mut fresh28 = (*parser).item_length; + *fresh28 = (*fresh28).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 2 => { + current_block = 8794836904205913937; + match current_block { + 9460353118185870455 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.filename = PL_UNIX_FILENAME_NAME; + } + } + 237011551503419106 => { + let ref mut fresh28 = (*parser).item_length; + *fresh28 = (*fresh28).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + 239935657650551384 => { + match (*parser).state.UNIX.sub.time as libc::c_uint { + 0 => { + current_block = 16799793128756688569; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 3676047842931404030; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 2 => { + current_block = 4348891415139402515; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 3 => { + current_block = 9778139347000538655; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 4 => { + current_block = 6646479082925444416; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 5 => { + current_block = 4328367172772116072; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + 16624850812192366308 => { + match (*parser).state.UNIX.sub.size as libc::c_uint { + 0 => { + current_block = 4003799678443473047; + match current_block { + 4003799678443473047 => { + if c as libc::c_int != ' ' as i32 { + if c as libc::c_int >= '0' as i32 + && c as libc::c_int <= '9' as i32 + { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.size = PL_UNIX_SIZE_NUMBER; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + let ref mut fresh22 = (*parser).item_length; + *fresh22 = (*fresh22).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + let mut p_0: *mut libc::c_char = 0 as *mut libc::c_char; + let mut fsize: curl_off_t = 0; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + if curlx_strtoofft( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut p_0, + 10 as libc::c_int, + &mut fsize, + ) as u64 == 0 + { + if *p_0.offset(0 as libc::c_int as isize) as libc::c_int + == '\u{0}' as i32 + && fsize != 0x7fffffffffffffff as libc::c_long + && fsize + != -(0x7fffffffffffffff as libc::c_long) - 1 as libc::c_long + { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 6 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.size = fsize; + } + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).state.UNIX.main = PL_UNIX_TIME; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART1; + } + } else if Curl_isdigit(c as libc::c_uchar as libc::c_int) + == 0 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 16318689547377354787; + match current_block { + 4003799678443473047 => { + if c as libc::c_int != ' ' as i32 { + if c as libc::c_int >= '0' as i32 + && c as libc::c_int <= '9' as i32 + { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.size = PL_UNIX_SIZE_NUMBER; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + let ref mut fresh22 = (*parser).item_length; + *fresh22 = (*fresh22).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + let mut p_0: *mut libc::c_char = 0 as *mut libc::c_char; + let mut fsize: curl_off_t = 0; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + if curlx_strtoofft( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut p_0, + 10 as libc::c_int, + &mut fsize, + ) as u64 == 0 + { + if *p_0.offset(0 as libc::c_int as isize) as libc::c_int + == '\u{0}' as i32 + && fsize != 0x7fffffffffffffff as libc::c_long + && fsize + != -(0x7fffffffffffffff as libc::c_long) - 1 as libc::c_long + { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 6 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.size = fsize; + } + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).state.UNIX.main = PL_UNIX_TIME; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART1; + } + } else if Curl_isdigit(c as libc::c_uchar as libc::c_int) + == 0 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + 2504653350889004047 => { + match (*parser).state.UNIX.sub.hlinks as libc::c_uint { + 0 => { + current_block = 3684944600068393837; + match current_block { + 3684944600068393837 => { + if c as libc::c_int != ' ' as i32 { + if c as libc::c_int >= '0' as i32 + && c as libc::c_int <= '9' as i32 + { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.hlinks = PL_UNIX_HLINKS_NUMBER; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + let ref mut fresh19 = (*parser).item_length; + *fresh19 = (*fresh19).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + let mut p: *mut libc::c_char = 0 as *mut libc::c_char; + let mut hlinks: libc::c_long = 0; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + hlinks = strtol( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut p, + 10 as libc::c_int, + ); + if *p.offset(0 as libc::c_int as isize) as libc::c_int + == '\u{0}' as i32 + && hlinks != 9223372036854775807 as libc::c_long + && hlinks + != -(9223372036854775807 as libc::c_long) + - 1 as libc::c_long + { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 7 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.hardlinks = hlinks; + } + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).state.UNIX.main = PL_UNIX_USER; + (*parser).state.UNIX.sub.user = PL_UNIX_USER_PRESPACE; + } else if (c as libc::c_int) < '0' as i32 + || c as libc::c_int > '9' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 5484315482916150815; + match current_block { + 3684944600068393837 => { + if c as libc::c_int != ' ' as i32 { + if c as libc::c_int >= '0' as i32 + && c as libc::c_int <= '9' as i32 + { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.hlinks = PL_UNIX_HLINKS_NUMBER; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + let ref mut fresh19 = (*parser).item_length; + *fresh19 = (*fresh19).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + let mut p: *mut libc::c_char = 0 as *mut libc::c_char; + let mut hlinks: libc::c_long = 0; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + hlinks = strtol( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut p, + 10 as libc::c_int, + ); + if *p.offset(0 as libc::c_int as isize) as libc::c_int + == '\u{0}' as i32 + && hlinks != 9223372036854775807 as libc::c_long + && hlinks + != -(9223372036854775807 as libc::c_long) + - 1 as libc::c_long + { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 7 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.hardlinks = hlinks; + } + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).state.UNIX.main = PL_UNIX_USER; + (*parser).state.UNIX.sub.user = PL_UNIX_USER_PRESPACE; + } else if (c as libc::c_int) < '0' as i32 + || c as libc::c_int > '9' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + 9904077679713191023 => { + let ref mut fresh18 = (*parser).item_length; + *fresh18 = (*fresh18).wrapping_add(1); + if (*parser).item_length <= 9 as libc::c_int as libc::c_uint + { + if (strchr( + b"rwx-tTsS\0" as *const u8 as *const libc::c_char, + c as libc::c_int, + )) + .is_null() + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } else if (*parser).item_length + == 10 as libc::c_int as libc::c_uint + { + let mut perm: libc::c_uint = 0; + if c as libc::c_int != ' ' as i32 { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + *((*finfo).b_data) + .offset( + 10 as libc::c_int as isize, + ) = 0 as libc::c_int as libc::c_char; + perm = ftp_pl_get_permission( + ((*finfo).b_data).offset((*parser).item_offset as isize), + ) as libc::c_uint; + if perm & 0x1000000 as libc::c_int as libc::c_uint != 0 { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 3 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.perm = perm; + (*parser).offsets.perm = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.main = PL_UNIX_HLINKS; + (*parser).state.UNIX.sub.hlinks = PL_UNIX_HLINKS_PRESPACE; + } + } + } + } + 9625400769004322558 => { + match c as libc::c_int { + 45 => { + (*finfo).filetype = CURLFILETYPE_FILE; + } + 100 => { + (*finfo).filetype = CURLFILETYPE_DIRECTORY; + } + 108 => { + (*finfo).filetype = CURLFILETYPE_SYMLINK; + } + 112 => { + (*finfo).filetype = CURLFILETYPE_NAMEDPIPE; + } + 115 => { + (*finfo).filetype = CURLFILETYPE_SOCKET; + } + 99 => { + (*finfo).filetype = CURLFILETYPE_DEVICE_CHAR; + } + 98 => { + (*finfo).filetype = CURLFILETYPE_DEVICE_BLOCK; + } + 68 => { + (*finfo).filetype = CURLFILETYPE_DOOR; + } + _ => { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + (*parser).state.UNIX.main = PL_UNIX_PERMISSION; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 1 as libc::c_int as size_t; + } + 17024674780638317650 => { + match (*parser).state.UNIX.sub.total_dirsize as libc::c_uint + { + 0 => { + current_block = 6514364568132207893; + match current_block { + 6514364568132207893 => { + if c as libc::c_int == 't' as i32 { + (*parser) + .state + .UNIX + .sub + .total_dirsize = PL_UNIX_TOTALSIZE_READING; + let ref mut fresh14 = (*parser).item_length; + *fresh14 = (*fresh14).wrapping_add(1); + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + (*finfo).b_used = 0 as libc::c_int as size_t; + continue; + } + } + _ => { + let ref mut fresh15 = (*parser).item_length; + *fresh15 = (*fresh15).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + let ref mut fresh16 = (*parser).item_length; + *fresh16 = (*fresh16).wrapping_sub(1); + let ref mut fresh17 = (*finfo).b_used; + *fresh17 = (*fresh17).wrapping_sub(1); + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_length) + .wrapping_sub(1 as libc::c_int as libc::c_uint) as isize, + ) = 0 as libc::c_int as libc::c_char; + if strncmp( + b"total \0" as *const u8 as *const libc::c_char, + (*finfo).b_data, + 6 as libc::c_int as libc::c_ulong, + ) == 0 as libc::c_int + { + let mut endptr: *mut libc::c_char = ((*finfo).b_data) + .offset(6 as libc::c_int as isize); + while Curl_isspace(*endptr as libc::c_uchar as libc::c_int) + != 0 + { + endptr = endptr.offset(1); + } + while Curl_isdigit(*endptr as libc::c_uchar as libc::c_int) + != 0 + { + endptr = endptr.offset(1); + } + if *endptr != 0 { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + (*finfo).b_used = 0 as libc::c_int as size_t; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + } + 1 => { + current_block = 13626467451598339886; + match current_block { + 6514364568132207893 => { + if c as libc::c_int == 't' as i32 { + (*parser) + .state + .UNIX + .sub + .total_dirsize = PL_UNIX_TOTALSIZE_READING; + let ref mut fresh14 = (*parser).item_length; + *fresh14 = (*fresh14).wrapping_add(1); + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + (*finfo).b_used = 0 as libc::c_int as size_t; + continue; + } + } + _ => { + let ref mut fresh15 = (*parser).item_length; + *fresh15 = (*fresh15).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + let ref mut fresh16 = (*parser).item_length; + *fresh16 = (*fresh16).wrapping_sub(1); + let ref mut fresh17 = (*finfo).b_used; + *fresh17 = (*fresh17).wrapping_sub(1); + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_length) + .wrapping_sub(1 as libc::c_int as libc::c_uint) as isize, + ) = 0 as libc::c_int as libc::c_char; + if strncmp( + b"total \0" as *const u8 as *const libc::c_char, + (*finfo).b_data, + 6 as libc::c_int as libc::c_ulong, + ) == 0 as libc::c_int + { + let mut endptr: *mut libc::c_char = ((*finfo).b_data) + .offset(6 as libc::c_int as isize); + while Curl_isspace(*endptr as libc::c_uchar as libc::c_int) + != 0 + { + endptr = endptr.offset(1); + } + while Curl_isdigit(*endptr as libc::c_uchar as libc::c_int) + != 0 + { + endptr = endptr.offset(1); + } + if *endptr != 0 { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + (*finfo).b_used = 0 as libc::c_int as size_t; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + } + _ => {} + } + } + 9811869791021064406 => { + match (*parser).state.UNIX.sub.user as libc::c_uint { + 0 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.user = PL_UNIX_USER_PARSING; + } + } + 1 => { + let ref mut fresh20 = (*parser).item_length; + *fresh20 = (*fresh20).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.user = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_GROUP; + (*parser).state.UNIX.sub.group = PL_UNIX_GROUP_PRESPACE; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + } + } + _ => {} + } + } + _ => { + match (*parser).state.UNIX.sub.symlink as libc::c_uint { + 0 => { + current_block = 17809359888120058514; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 16368170406074945475; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 2 => { + current_block = 10105930990766199517; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 3 => { + current_block = 11357570484085178253; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 4 => { + current_block = 6032193395927242546; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 5 => { + current_block = 755694297841528034; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 6 => { + current_block = 5173505947521674114; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 7 => { + current_block = 12108948829114559637; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + } + } + 8 => { + current_block = 6779615841179357261; + match current_block { + 14897958723503621653 => { + match (*parser).state.UNIX.sub.group as libc::c_uint { + 0 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.group = PL_UNIX_GROUP_NAME; + } + } + 1 => { + let ref mut fresh21 = (*parser).item_length; + *fresh21 = (*fresh21).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.group = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_SIZE; + (*parser).state.UNIX.sub.size = PL_UNIX_SIZE_PRESPACE; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + } + } + _ => {} + } + } + 6779615841179357261 => { + match (*parser).state.UNIX.sub.filename as libc::c_uint { + 0 => { + current_block = 9460353118185870455; + match current_block { + 9460353118185870455 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.filename = PL_UNIX_FILENAME_NAME; + } + } + 237011551503419106 => { + let ref mut fresh28 = (*parser).item_length; + *fresh28 = (*fresh28).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 237011551503419106; + match current_block { + 9460353118185870455 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.filename = PL_UNIX_FILENAME_NAME; + } + } + 237011551503419106 => { + let ref mut fresh28 = (*parser).item_length; + *fresh28 = (*fresh28).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 2 => { + current_block = 8794836904205913937; + match current_block { + 9460353118185870455 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.filename = PL_UNIX_FILENAME_NAME; + } + } + 237011551503419106 => { + let ref mut fresh28 = (*parser).item_length; + *fresh28 = (*fresh28).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + 239935657650551384 => { + match (*parser).state.UNIX.sub.time as libc::c_uint { + 0 => { + current_block = 16799793128756688569; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 3676047842931404030; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 2 => { + current_block = 4348891415139402515; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 3 => { + current_block = 9778139347000538655; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 4 => { + current_block = 6646479082925444416; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 5 => { + current_block = 4328367172772116072; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + 16624850812192366308 => { + match (*parser).state.UNIX.sub.size as libc::c_uint { + 0 => { + current_block = 4003799678443473047; + match current_block { + 4003799678443473047 => { + if c as libc::c_int != ' ' as i32 { + if c as libc::c_int >= '0' as i32 + && c as libc::c_int <= '9' as i32 + { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.size = PL_UNIX_SIZE_NUMBER; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + let ref mut fresh22 = (*parser).item_length; + *fresh22 = (*fresh22).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + let mut p_0: *mut libc::c_char = 0 as *mut libc::c_char; + let mut fsize: curl_off_t = 0; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + if curlx_strtoofft( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut p_0, + 10 as libc::c_int, + &mut fsize, + ) as u64 == 0 + { + if *p_0.offset(0 as libc::c_int as isize) as libc::c_int + == '\u{0}' as i32 + && fsize != 0x7fffffffffffffff as libc::c_long + && fsize + != -(0x7fffffffffffffff as libc::c_long) - 1 as libc::c_long + { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 6 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.size = fsize; + } + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).state.UNIX.main = PL_UNIX_TIME; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART1; + } + } else if Curl_isdigit(c as libc::c_uchar as libc::c_int) + == 0 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 16318689547377354787; + match current_block { + 4003799678443473047 => { + if c as libc::c_int != ' ' as i32 { + if c as libc::c_int >= '0' as i32 + && c as libc::c_int <= '9' as i32 + { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.size = PL_UNIX_SIZE_NUMBER; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + let ref mut fresh22 = (*parser).item_length; + *fresh22 = (*fresh22).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + let mut p_0: *mut libc::c_char = 0 as *mut libc::c_char; + let mut fsize: curl_off_t = 0; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + if curlx_strtoofft( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut p_0, + 10 as libc::c_int, + &mut fsize, + ) as u64 == 0 + { + if *p_0.offset(0 as libc::c_int as isize) as libc::c_int + == '\u{0}' as i32 + && fsize != 0x7fffffffffffffff as libc::c_long + && fsize + != -(0x7fffffffffffffff as libc::c_long) - 1 as libc::c_long + { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 6 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.size = fsize; + } + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).state.UNIX.main = PL_UNIX_TIME; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART1; + } + } else if Curl_isdigit(c as libc::c_uchar as libc::c_int) + == 0 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + 2504653350889004047 => { + match (*parser).state.UNIX.sub.hlinks as libc::c_uint { + 0 => { + current_block = 3684944600068393837; + match current_block { + 3684944600068393837 => { + if c as libc::c_int != ' ' as i32 { + if c as libc::c_int >= '0' as i32 + && c as libc::c_int <= '9' as i32 + { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.hlinks = PL_UNIX_HLINKS_NUMBER; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + let ref mut fresh19 = (*parser).item_length; + *fresh19 = (*fresh19).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + let mut p: *mut libc::c_char = 0 as *mut libc::c_char; + let mut hlinks: libc::c_long = 0; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + hlinks = strtol( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut p, + 10 as libc::c_int, + ); + if *p.offset(0 as libc::c_int as isize) as libc::c_int + == '\u{0}' as i32 + && hlinks != 9223372036854775807 as libc::c_long + && hlinks + != -(9223372036854775807 as libc::c_long) + - 1 as libc::c_long + { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 7 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.hardlinks = hlinks; + } + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).state.UNIX.main = PL_UNIX_USER; + (*parser).state.UNIX.sub.user = PL_UNIX_USER_PRESPACE; + } else if (c as libc::c_int) < '0' as i32 + || c as libc::c_int > '9' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 5484315482916150815; + match current_block { + 3684944600068393837 => { + if c as libc::c_int != ' ' as i32 { + if c as libc::c_int >= '0' as i32 + && c as libc::c_int <= '9' as i32 + { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.hlinks = PL_UNIX_HLINKS_NUMBER; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + let ref mut fresh19 = (*parser).item_length; + *fresh19 = (*fresh19).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + let mut p: *mut libc::c_char = 0 as *mut libc::c_char; + let mut hlinks: libc::c_long = 0; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + hlinks = strtol( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut p, + 10 as libc::c_int, + ); + if *p.offset(0 as libc::c_int as isize) as libc::c_int + == '\u{0}' as i32 + && hlinks != 9223372036854775807 as libc::c_long + && hlinks + != -(9223372036854775807 as libc::c_long) + - 1 as libc::c_long + { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 7 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.hardlinks = hlinks; + } + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).state.UNIX.main = PL_UNIX_USER; + (*parser).state.UNIX.sub.user = PL_UNIX_USER_PRESPACE; + } else if (c as libc::c_int) < '0' as i32 + || c as libc::c_int > '9' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + 9904077679713191023 => { + let ref mut fresh18 = (*parser).item_length; + *fresh18 = (*fresh18).wrapping_add(1); + if (*parser).item_length <= 9 as libc::c_int as libc::c_uint + { + if (strchr( + b"rwx-tTsS\0" as *const u8 as *const libc::c_char, + c as libc::c_int, + )) + .is_null() + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } else if (*parser).item_length + == 10 as libc::c_int as libc::c_uint + { + let mut perm: libc::c_uint = 0; + if c as libc::c_int != ' ' as i32 { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + *((*finfo).b_data) + .offset( + 10 as libc::c_int as isize, + ) = 0 as libc::c_int as libc::c_char; + perm = ftp_pl_get_permission( + ((*finfo).b_data).offset((*parser).item_offset as isize), + ) as libc::c_uint; + if perm & 0x1000000 as libc::c_int as libc::c_uint != 0 { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 3 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.perm = perm; + (*parser).offsets.perm = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.main = PL_UNIX_HLINKS; + (*parser).state.UNIX.sub.hlinks = PL_UNIX_HLINKS_PRESPACE; + } + } + } + } + 9625400769004322558 => { + match c as libc::c_int { + 45 => { + (*finfo).filetype = CURLFILETYPE_FILE; + } + 100 => { + (*finfo).filetype = CURLFILETYPE_DIRECTORY; + } + 108 => { + (*finfo).filetype = CURLFILETYPE_SYMLINK; + } + 112 => { + (*finfo).filetype = CURLFILETYPE_NAMEDPIPE; + } + 115 => { + (*finfo).filetype = CURLFILETYPE_SOCKET; + } + 99 => { + (*finfo).filetype = CURLFILETYPE_DEVICE_CHAR; + } + 98 => { + (*finfo).filetype = CURLFILETYPE_DEVICE_BLOCK; + } + 68 => { + (*finfo).filetype = CURLFILETYPE_DOOR; + } + _ => { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + (*parser).state.UNIX.main = PL_UNIX_PERMISSION; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 1 as libc::c_int as size_t; + } + 17024674780638317650 => { + match (*parser).state.UNIX.sub.total_dirsize as libc::c_uint + { + 0 => { + current_block = 6514364568132207893; + match current_block { + 6514364568132207893 => { + if c as libc::c_int == 't' as i32 { + (*parser) + .state + .UNIX + .sub + .total_dirsize = PL_UNIX_TOTALSIZE_READING; + let ref mut fresh14 = (*parser).item_length; + *fresh14 = (*fresh14).wrapping_add(1); + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + (*finfo).b_used = 0 as libc::c_int as size_t; + continue; + } + } + _ => { + let ref mut fresh15 = (*parser).item_length; + *fresh15 = (*fresh15).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + let ref mut fresh16 = (*parser).item_length; + *fresh16 = (*fresh16).wrapping_sub(1); + let ref mut fresh17 = (*finfo).b_used; + *fresh17 = (*fresh17).wrapping_sub(1); + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_length) + .wrapping_sub(1 as libc::c_int as libc::c_uint) as isize, + ) = 0 as libc::c_int as libc::c_char; + if strncmp( + b"total \0" as *const u8 as *const libc::c_char, + (*finfo).b_data, + 6 as libc::c_int as libc::c_ulong, + ) == 0 as libc::c_int + { + let mut endptr: *mut libc::c_char = ((*finfo).b_data) + .offset(6 as libc::c_int as isize); + while Curl_isspace(*endptr as libc::c_uchar as libc::c_int) + != 0 + { + endptr = endptr.offset(1); + } + while Curl_isdigit(*endptr as libc::c_uchar as libc::c_int) + != 0 + { + endptr = endptr.offset(1); + } + if *endptr != 0 { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + (*finfo).b_used = 0 as libc::c_int as size_t; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + } + 1 => { + current_block = 13626467451598339886; + match current_block { + 6514364568132207893 => { + if c as libc::c_int == 't' as i32 { + (*parser) + .state + .UNIX + .sub + .total_dirsize = PL_UNIX_TOTALSIZE_READING; + let ref mut fresh14 = (*parser).item_length; + *fresh14 = (*fresh14).wrapping_add(1); + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + (*finfo).b_used = 0 as libc::c_int as size_t; + continue; + } + } + _ => { + let ref mut fresh15 = (*parser).item_length; + *fresh15 = (*fresh15).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + let ref mut fresh16 = (*parser).item_length; + *fresh16 = (*fresh16).wrapping_sub(1); + let ref mut fresh17 = (*finfo).b_used; + *fresh17 = (*fresh17).wrapping_sub(1); + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_length) + .wrapping_sub(1 as libc::c_int as libc::c_uint) as isize, + ) = 0 as libc::c_int as libc::c_char; + if strncmp( + b"total \0" as *const u8 as *const libc::c_char, + (*finfo).b_data, + 6 as libc::c_int as libc::c_ulong, + ) == 0 as libc::c_int + { + let mut endptr: *mut libc::c_char = ((*finfo).b_data) + .offset(6 as libc::c_int as isize); + while Curl_isspace(*endptr as libc::c_uchar as libc::c_int) + != 0 + { + endptr = endptr.offset(1); + } + while Curl_isdigit(*endptr as libc::c_uchar as libc::c_int) + != 0 + { + endptr = endptr.offset(1); + } + if *endptr != 0 { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + (*finfo).b_used = 0 as libc::c_int as size_t; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + } + _ => {} + } + } + 9811869791021064406 => { + match (*parser).state.UNIX.sub.user as libc::c_uint { + 0 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.user = PL_UNIX_USER_PARSING; + } + } + 1 => { + let ref mut fresh20 = (*parser).item_length; + *fresh20 = (*fresh20).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.user = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_GROUP; + (*parser).state.UNIX.sub.group = PL_UNIX_GROUP_PRESPACE; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + } + } + _ => {} + } + } + _ => { + match (*parser).state.UNIX.sub.symlink as libc::c_uint { + 0 => { + current_block = 17809359888120058514; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 16368170406074945475; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 2 => { + current_block = 10105930990766199517; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 3 => { + current_block = 11357570484085178253; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 4 => { + current_block = 6032193395927242546; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 5 => { + current_block = 755694297841528034; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 6 => { + current_block = 5173505947521674114; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 7 => { + current_block = 12108948829114559637; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + } + } + 9 => { + current_block = 12270305463401793827; + match current_block { + 14897958723503621653 => { + match (*parser).state.UNIX.sub.group as libc::c_uint { + 0 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.group = PL_UNIX_GROUP_NAME; + } + } + 1 => { + let ref mut fresh21 = (*parser).item_length; + *fresh21 = (*fresh21).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.group = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_SIZE; + (*parser).state.UNIX.sub.size = PL_UNIX_SIZE_PRESPACE; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + } + } + _ => {} + } + } + 6779615841179357261 => { + match (*parser).state.UNIX.sub.filename as libc::c_uint { + 0 => { + current_block = 9460353118185870455; + match current_block { + 9460353118185870455 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.filename = PL_UNIX_FILENAME_NAME; + } + } + 237011551503419106 => { + let ref mut fresh28 = (*parser).item_length; + *fresh28 = (*fresh28).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 237011551503419106; + match current_block { + 9460353118185870455 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.filename = PL_UNIX_FILENAME_NAME; + } + } + 237011551503419106 => { + let ref mut fresh28 = (*parser).item_length; + *fresh28 = (*fresh28).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 2 => { + current_block = 8794836904205913937; + match current_block { + 9460353118185870455 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.filename = PL_UNIX_FILENAME_NAME; + } + } + 237011551503419106 => { + let ref mut fresh28 = (*parser).item_length; + *fresh28 = (*fresh28).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + 239935657650551384 => { + match (*parser).state.UNIX.sub.time as libc::c_uint { + 0 => { + current_block = 16799793128756688569; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 3676047842931404030; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 2 => { + current_block = 4348891415139402515; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 3 => { + current_block = 9778139347000538655; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 4 => { + current_block = 6646479082925444416; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 5 => { + current_block = 4328367172772116072; + match current_block { + 16799793128756688569 => { + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART1; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 6646479082925444416 => { + let ref mut fresh26 = (*parser).item_length; + *fresh26 = (*fresh26).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART3; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 9778139347000538655 => { + let ref mut fresh25 = (*parser).item_length; + *fresh25 = (*fresh25).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART3; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 4348891415139402515 => { + let ref mut fresh24 = (*parser).item_length; + *fresh24 = (*fresh24).wrapping_add(1); + if c as libc::c_int != ' ' as i32 { + if Curl_isalnum(c as libc::c_uchar as libc::c_int) != 0 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PART2; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + 3676047842931404030 => { + let ref mut fresh23 = (*parser).item_length; + *fresh23 = (*fresh23).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART2; + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + let ref mut fresh27 = (*parser).item_length; + *fresh27 = (*fresh27).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.time = (*parser).item_offset; + if (*finfo).filetype as libc::c_uint + == CURLFILETYPE_SYMLINK as libc::c_int as libc::c_uint + { + (*parser).state.UNIX.main = PL_UNIX_SYMLINK; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_PRESPACE; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILENAME; + (*parser) + .state + .UNIX + .sub + .filename = PL_UNIX_FILENAME_PRESPACE; + } + } else if Curl_isalnum(c as libc::c_uchar as libc::c_int) + == 0 && c as libc::c_int != '.' as i32 + && c as libc::c_int != ':' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + 16624850812192366308 => { + match (*parser).state.UNIX.sub.size as libc::c_uint { + 0 => { + current_block = 4003799678443473047; + match current_block { + 4003799678443473047 => { + if c as libc::c_int != ' ' as i32 { + if c as libc::c_int >= '0' as i32 + && c as libc::c_int <= '9' as i32 + { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.size = PL_UNIX_SIZE_NUMBER; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + let ref mut fresh22 = (*parser).item_length; + *fresh22 = (*fresh22).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + let mut p_0: *mut libc::c_char = 0 as *mut libc::c_char; + let mut fsize: curl_off_t = 0; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + if curlx_strtoofft( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut p_0, + 10 as libc::c_int, + &mut fsize, + ) as u64 == 0 + { + if *p_0.offset(0 as libc::c_int as isize) as libc::c_int + == '\u{0}' as i32 + && fsize != 0x7fffffffffffffff as libc::c_long + && fsize + != -(0x7fffffffffffffff as libc::c_long) - 1 as libc::c_long + { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 6 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.size = fsize; + } + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).state.UNIX.main = PL_UNIX_TIME; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART1; + } + } else if Curl_isdigit(c as libc::c_uchar as libc::c_int) + == 0 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 16318689547377354787; + match current_block { + 4003799678443473047 => { + if c as libc::c_int != ' ' as i32 { + if c as libc::c_int >= '0' as i32 + && c as libc::c_int <= '9' as i32 + { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.size = PL_UNIX_SIZE_NUMBER; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + let ref mut fresh22 = (*parser).item_length; + *fresh22 = (*fresh22).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + let mut p_0: *mut libc::c_char = 0 as *mut libc::c_char; + let mut fsize: curl_off_t = 0; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + if curlx_strtoofft( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut p_0, + 10 as libc::c_int, + &mut fsize, + ) as u64 == 0 + { + if *p_0.offset(0 as libc::c_int as isize) as libc::c_int + == '\u{0}' as i32 + && fsize != 0x7fffffffffffffff as libc::c_long + && fsize + != -(0x7fffffffffffffff as libc::c_long) - 1 as libc::c_long + { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 6 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.size = fsize; + } + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).state.UNIX.main = PL_UNIX_TIME; + (*parser).state.UNIX.sub.time = PL_UNIX_TIME_PREPART1; + } + } else if Curl_isdigit(c as libc::c_uchar as libc::c_int) + == 0 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + 2504653350889004047 => { + match (*parser).state.UNIX.sub.hlinks as libc::c_uint { + 0 => { + current_block = 3684944600068393837; + match current_block { + 3684944600068393837 => { + if c as libc::c_int != ' ' as i32 { + if c as libc::c_int >= '0' as i32 + && c as libc::c_int <= '9' as i32 + { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.hlinks = PL_UNIX_HLINKS_NUMBER; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + let ref mut fresh19 = (*parser).item_length; + *fresh19 = (*fresh19).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + let mut p: *mut libc::c_char = 0 as *mut libc::c_char; + let mut hlinks: libc::c_long = 0; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + hlinks = strtol( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut p, + 10 as libc::c_int, + ); + if *p.offset(0 as libc::c_int as isize) as libc::c_int + == '\u{0}' as i32 + && hlinks != 9223372036854775807 as libc::c_long + && hlinks + != -(9223372036854775807 as libc::c_long) + - 1 as libc::c_long + { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 7 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.hardlinks = hlinks; + } + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).state.UNIX.main = PL_UNIX_USER; + (*parser).state.UNIX.sub.user = PL_UNIX_USER_PRESPACE; + } else if (c as libc::c_int) < '0' as i32 + || c as libc::c_int > '9' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 5484315482916150815; + match current_block { + 3684944600068393837 => { + if c as libc::c_int != ' ' as i32 { + if c as libc::c_int >= '0' as i32 + && c as libc::c_int <= '9' as i32 + { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.hlinks = PL_UNIX_HLINKS_NUMBER; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + _ => { + let ref mut fresh19 = (*parser).item_length; + *fresh19 = (*fresh19).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + let mut p: *mut libc::c_char = 0 as *mut libc::c_char; + let mut hlinks: libc::c_long = 0; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + hlinks = strtol( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut p, + 10 as libc::c_int, + ); + if *p.offset(0 as libc::c_int as isize) as libc::c_int + == '\u{0}' as i32 + && hlinks != 9223372036854775807 as libc::c_long + && hlinks + != -(9223372036854775807 as libc::c_long) + - 1 as libc::c_long + { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 7 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.hardlinks = hlinks; + } + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).state.UNIX.main = PL_UNIX_USER; + (*parser).state.UNIX.sub.user = PL_UNIX_USER_PRESPACE; + } else if (c as libc::c_int) < '0' as i32 + || c as libc::c_int > '9' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + 9904077679713191023 => { + let ref mut fresh18 = (*parser).item_length; + *fresh18 = (*fresh18).wrapping_add(1); + if (*parser).item_length <= 9 as libc::c_int as libc::c_uint + { + if (strchr( + b"rwx-tTsS\0" as *const u8 as *const libc::c_char, + c as libc::c_int, + )) + .is_null() + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } else if (*parser).item_length + == 10 as libc::c_int as libc::c_uint + { + let mut perm: libc::c_uint = 0; + if c as libc::c_int != ' ' as i32 { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + *((*finfo).b_data) + .offset( + 10 as libc::c_int as isize, + ) = 0 as libc::c_int as libc::c_char; + perm = ftp_pl_get_permission( + ((*finfo).b_data).offset((*parser).item_offset as isize), + ) as libc::c_uint; + if perm & 0x1000000 as libc::c_int as libc::c_uint != 0 { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 3 as libc::c_int) as libc::c_uint; + (*(*parser).file_data).info.perm = perm; + (*parser).offsets.perm = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.main = PL_UNIX_HLINKS; + (*parser).state.UNIX.sub.hlinks = PL_UNIX_HLINKS_PRESPACE; + } + } + } + } + 9625400769004322558 => { + match c as libc::c_int { + 45 => { + (*finfo).filetype = CURLFILETYPE_FILE; + } + 100 => { + (*finfo).filetype = CURLFILETYPE_DIRECTORY; + } + 108 => { + (*finfo).filetype = CURLFILETYPE_SYMLINK; + } + 112 => { + (*finfo).filetype = CURLFILETYPE_NAMEDPIPE; + } + 115 => { + (*finfo).filetype = CURLFILETYPE_SOCKET; + } + 99 => { + (*finfo).filetype = CURLFILETYPE_DEVICE_CHAR; + } + 98 => { + (*finfo).filetype = CURLFILETYPE_DEVICE_BLOCK; + } + 68 => { + (*finfo).filetype = CURLFILETYPE_DOOR; + } + _ => { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + (*parser).state.UNIX.main = PL_UNIX_PERMISSION; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 1 as libc::c_int as size_t; + } + 17024674780638317650 => { + match (*parser).state.UNIX.sub.total_dirsize as libc::c_uint + { + 0 => { + current_block = 6514364568132207893; + match current_block { + 6514364568132207893 => { + if c as libc::c_int == 't' as i32 { + (*parser) + .state + .UNIX + .sub + .total_dirsize = PL_UNIX_TOTALSIZE_READING; + let ref mut fresh14 = (*parser).item_length; + *fresh14 = (*fresh14).wrapping_add(1); + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + (*finfo).b_used = 0 as libc::c_int as size_t; + continue; + } + } + _ => { + let ref mut fresh15 = (*parser).item_length; + *fresh15 = (*fresh15).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + let ref mut fresh16 = (*parser).item_length; + *fresh16 = (*fresh16).wrapping_sub(1); + let ref mut fresh17 = (*finfo).b_used; + *fresh17 = (*fresh17).wrapping_sub(1); + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_length) + .wrapping_sub(1 as libc::c_int as libc::c_uint) as isize, + ) = 0 as libc::c_int as libc::c_char; + if strncmp( + b"total \0" as *const u8 as *const libc::c_char, + (*finfo).b_data, + 6 as libc::c_int as libc::c_ulong, + ) == 0 as libc::c_int + { + let mut endptr: *mut libc::c_char = ((*finfo).b_data) + .offset(6 as libc::c_int as isize); + while Curl_isspace(*endptr as libc::c_uchar as libc::c_int) + != 0 + { + endptr = endptr.offset(1); + } + while Curl_isdigit(*endptr as libc::c_uchar as libc::c_int) + != 0 + { + endptr = endptr.offset(1); + } + if *endptr != 0 { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + (*finfo).b_used = 0 as libc::c_int as size_t; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + } + 1 => { + current_block = 13626467451598339886; + match current_block { + 6514364568132207893 => { + if c as libc::c_int == 't' as i32 { + (*parser) + .state + .UNIX + .sub + .total_dirsize = PL_UNIX_TOTALSIZE_READING; + let ref mut fresh14 = (*parser).item_length; + *fresh14 = (*fresh14).wrapping_add(1); + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + (*finfo).b_used = 0 as libc::c_int as size_t; + continue; + } + } + _ => { + let ref mut fresh15 = (*parser).item_length; + *fresh15 = (*fresh15).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + let ref mut fresh16 = (*parser).item_length; + *fresh16 = (*fresh16).wrapping_sub(1); + let ref mut fresh17 = (*finfo).b_used; + *fresh17 = (*fresh17).wrapping_sub(1); + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_length) + .wrapping_sub(1 as libc::c_int as libc::c_uint) as isize, + ) = 0 as libc::c_int as libc::c_char; + if strncmp( + b"total \0" as *const u8 as *const libc::c_char, + (*finfo).b_data, + 6 as libc::c_int as libc::c_ulong, + ) == 0 as libc::c_int + { + let mut endptr: *mut libc::c_char = ((*finfo).b_data) + .offset(6 as libc::c_int as isize); + while Curl_isspace(*endptr as libc::c_uchar as libc::c_int) + != 0 + { + endptr = endptr.offset(1); + } + while Curl_isdigit(*endptr as libc::c_uchar as libc::c_int) + != 0 + { + endptr = endptr.offset(1); + } + if *endptr != 0 { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + (*finfo).b_used = 0 as libc::c_int as size_t; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + } + _ => {} + } + } + 9811869791021064406 => { + match (*parser).state.UNIX.sub.user as libc::c_uint { + 0 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.user = PL_UNIX_USER_PARSING; + } + } + 1 => { + let ref mut fresh20 = (*parser).item_length; + *fresh20 = (*fresh20).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.user = (*parser).item_offset; + (*parser).state.UNIX.main = PL_UNIX_GROUP; + (*parser).state.UNIX.sub.group = PL_UNIX_GROUP_PRESPACE; + (*parser).item_offset = 0 as libc::c_int as size_t; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + } + } + _ => {} + } + } + _ => { + match (*parser).state.UNIX.sub.symlink as libc::c_uint { + 0 => { + current_block = 17809359888120058514; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 16368170406074945475; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 2 => { + current_block = 10105930990766199517; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 3 => { + current_block = 11357570484085178253; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 4 => { + current_block = 6032193395927242546; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 5 => { + current_block = 755694297841528034; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 6 => { + current_block = 5173505947521674114; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 7 => { + current_block = 12108948829114559637; + match current_block { + 17809359888120058514 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 5173505947521674114 => { + let ref mut fresh33 = (*parser).item_length; + *fresh33 = (*fresh33).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_WINDOWSEOL; + } else if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } + } + 755694297841528034 => { + if c as libc::c_int != '\r' as i32 + && c as libc::c_int != '\n' as i32 + { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_TARGET; + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 6032193395927242546 => { + let ref mut fresh32 = (*parser).item_length; + *fresh32 = (*fresh32).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET4; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(4 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.filename = (*parser).item_offset; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).item_offset = 0 as libc::c_int as size_t; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 11357570484085178253 => { + let ref mut fresh31 = (*parser).item_length; + *fresh31 = (*fresh31).wrapping_add(1); + if c as libc::c_int == '>' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET3; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 10105930990766199517 => { + let ref mut fresh30 = (*parser).item_length; + *fresh30 = (*fresh30).wrapping_add(1); + if c as libc::c_int == '-' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET2; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.sub.symlink = PL_UNIX_SYMLINK_NAME; + } + } + 16368170406074945475 => { + let ref mut fresh29 = (*parser).item_length; + *fresh29 = (*fresh29).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + (*parser) + .state + .UNIX + .sub + .symlink = PL_UNIX_SYMLINK_PRETARGET1; + } else if c as libc::c_int == '\r' as i32 + || c as libc::c_int == '\n' as i32 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).offsets.symlink_target = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.UNIX.main = PL_UNIX_FILETYPE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + } + } + _ => {} + } + } + 2 => { + match (*parser).state.NT.main as libc::c_uint { + 0 => { + current_block = 10276754450170513663; + match current_block { + 10276754450170513663 => { + let ref mut fresh34 = (*parser).item_length; + *fresh34 = (*fresh34).wrapping_add(1); + if (*parser).item_length < 9 as libc::c_int as libc::c_uint + { + if (strchr( + b"0123456789-\0" as *const u8 as *const libc::c_char, + c as libc::c_int, + )) + .is_null() + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } else if (*parser).item_length + == 9 as libc::c_int as libc::c_uint + { + if c as libc::c_int == ' ' as i32 { + (*parser).state.NT.main = PL_WINNT_TIME; + (*parser).state.NT.sub.time = PL_WINNT_TIME_PRESPACE; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 538492802611270279 => { + match (*parser).state.NT.sub.dirorsize as libc::c_uint { + 0 => { + current_block = 5336772990438301456; + match current_block { + 5336772990438301456 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser) + .state + .NT + .sub + .dirorsize = PL_WINNT_DIRORSIZE_CONTENT; + } + } + _ => { + let ref mut fresh36 = (*parser).item_length; + *fresh36 = (*fresh36).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + if strcmp( + b"\0" as *const u8 as *const libc::c_char, + ((*finfo).b_data).offset((*parser).item_offset as isize), + ) == 0 as libc::c_int + { + (*finfo).filetype = CURLFILETYPE_DIRECTORY; + (*finfo).size = 0 as libc::c_int as curl_off_t; + } else { + let mut endptr_0: *mut libc::c_char = 0 + as *mut libc::c_char; + if curlx_strtoofft( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut endptr_0, + 10 as libc::c_int, + &mut (*finfo).size, + ) as u64 != 0 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*(*parser).file_data).info.filetype = CURLFILETYPE_FILE; + } + } + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 6 as libc::c_int) as libc::c_uint; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).state.NT.main = PL_WINNT_FILENAME; + (*parser) + .state + .NT + .sub + .filename = PL_WINNT_FILENAME_PRESPACE; + } + } + } + } + 1 => { + current_block = 9790556430701464115; + match current_block { + 5336772990438301456 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser) + .state + .NT + .sub + .dirorsize = PL_WINNT_DIRORSIZE_CONTENT; + } + } + _ => { + let ref mut fresh36 = (*parser).item_length; + *fresh36 = (*fresh36).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + if strcmp( + b"\0" as *const u8 as *const libc::c_char, + ((*finfo).b_data).offset((*parser).item_offset as isize), + ) == 0 as libc::c_int + { + (*finfo).filetype = CURLFILETYPE_DIRECTORY; + (*finfo).size = 0 as libc::c_int as curl_off_t; + } else { + let mut endptr_0: *mut libc::c_char = 0 + as *mut libc::c_char; + if curlx_strtoofft( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut endptr_0, + 10 as libc::c_int, + &mut (*finfo).size, + ) as u64 != 0 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*(*parser).file_data).info.filetype = CURLFILETYPE_FILE; + } + } + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 6 as libc::c_int) as libc::c_uint; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).state.NT.main = PL_WINNT_FILENAME; + (*parser) + .state + .NT + .sub + .filename = PL_WINNT_FILENAME_PRESPACE; + } + } + } + } + _ => {} + } + } + 9608327422557688744 => { + let ref mut fresh35 = (*parser).item_length; + *fresh35 = (*fresh35).wrapping_add(1); + match (*parser).state.NT.sub.time as libc::c_uint { + 0 => { + current_block = 2747568622853712931; + match current_block { + 2747568622853712931 => { + if Curl_isspace(c as libc::c_uchar as libc::c_int) == 0 { + (*parser).state.NT.sub.time = PL_WINNT_TIME_TIME; + } + } + _ => { + if c as libc::c_int == ' ' as i32 { + (*parser).offsets.time = (*parser).item_offset; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).state.NT.main = PL_WINNT_DIRORSIZE; + (*parser) + .state + .NT + .sub + .dirorsize = PL_WINNT_DIRORSIZE_PRESPACE; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + } else if (strchr( + b"APM0123456789:\0" as *const u8 as *const libc::c_char, + c as libc::c_int, + )) + .is_null() + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 13271080678501671613; + match current_block { + 2747568622853712931 => { + if Curl_isspace(c as libc::c_uchar as libc::c_int) == 0 { + (*parser).state.NT.sub.time = PL_WINNT_TIME_TIME; + } + } + _ => { + if c as libc::c_int == ' ' as i32 { + (*parser).offsets.time = (*parser).item_offset; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).state.NT.main = PL_WINNT_DIRORSIZE; + (*parser) + .state + .NT + .sub + .dirorsize = PL_WINNT_DIRORSIZE_PRESPACE; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + } else if (strchr( + b"APM0123456789:\0" as *const u8 as *const libc::c_char, + c as libc::c_int, + )) + .is_null() + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + _ => { + match (*parser).state.NT.sub.filename as libc::c_uint { + 0 => { + current_block = 10190897281885295872; + match current_block { + 10190897281885295872 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.NT.sub.filename = PL_WINNT_FILENAME_CONTENT; + } + } + 12975579885717081312 => { + let ref mut fresh37 = (*parser).item_length; + *fresh37 = (*fresh37).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser).state.NT.sub.filename = PL_WINNT_FILENAME_WINEOL; + *((*finfo).b_data) + .offset( + ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + } else if c as libc::c_int == '\n' as i32 { + (*parser).offsets.filename = (*parser).item_offset; + *((*finfo).b_data) + .offset( + ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.NT.main = PL_WINNT_DATE; + (*parser) + .state + .NT + .sub + .filename = PL_WINNT_FILENAME_PRESPACE; + } + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + (*parser).offsets.filename = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.NT.main = PL_WINNT_DATE; + (*parser) + .state + .NT + .sub + .filename = PL_WINNT_FILENAME_PRESPACE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 12975579885717081312; + match current_block { + 10190897281885295872 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.NT.sub.filename = PL_WINNT_FILENAME_CONTENT; + } + } + 12975579885717081312 => { + let ref mut fresh37 = (*parser).item_length; + *fresh37 = (*fresh37).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser).state.NT.sub.filename = PL_WINNT_FILENAME_WINEOL; + *((*finfo).b_data) + .offset( + ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + } else if c as libc::c_int == '\n' as i32 { + (*parser).offsets.filename = (*parser).item_offset; + *((*finfo).b_data) + .offset( + ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.NT.main = PL_WINNT_DATE; + (*parser) + .state + .NT + .sub + .filename = PL_WINNT_FILENAME_PRESPACE; + } + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + (*parser).offsets.filename = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.NT.main = PL_WINNT_DATE; + (*parser) + .state + .NT + .sub + .filename = PL_WINNT_FILENAME_PRESPACE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 2 => { + current_block = 3027624313100770395; + match current_block { + 10190897281885295872 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.NT.sub.filename = PL_WINNT_FILENAME_CONTENT; + } + } + 12975579885717081312 => { + let ref mut fresh37 = (*parser).item_length; + *fresh37 = (*fresh37).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser).state.NT.sub.filename = PL_WINNT_FILENAME_WINEOL; + *((*finfo).b_data) + .offset( + ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + } else if c as libc::c_int == '\n' as i32 { + (*parser).offsets.filename = (*parser).item_offset; + *((*finfo).b_data) + .offset( + ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.NT.main = PL_WINNT_DATE; + (*parser) + .state + .NT + .sub + .filename = PL_WINNT_FILENAME_PRESPACE; + } + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + (*parser).offsets.filename = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.NT.main = PL_WINNT_DATE; + (*parser) + .state + .NT + .sub + .filename = PL_WINNT_FILENAME_PRESPACE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + } + } + 1 => { + current_block = 9608327422557688744; + match current_block { + 10276754450170513663 => { + let ref mut fresh34 = (*parser).item_length; + *fresh34 = (*fresh34).wrapping_add(1); + if (*parser).item_length < 9 as libc::c_int as libc::c_uint + { + if (strchr( + b"0123456789-\0" as *const u8 as *const libc::c_char, + c as libc::c_int, + )) + .is_null() + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } else if (*parser).item_length + == 9 as libc::c_int as libc::c_uint + { + if c as libc::c_int == ' ' as i32 { + (*parser).state.NT.main = PL_WINNT_TIME; + (*parser).state.NT.sub.time = PL_WINNT_TIME_PRESPACE; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 538492802611270279 => { + match (*parser).state.NT.sub.dirorsize as libc::c_uint { + 0 => { + current_block = 5336772990438301456; + match current_block { + 5336772990438301456 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser) + .state + .NT + .sub + .dirorsize = PL_WINNT_DIRORSIZE_CONTENT; + } + } + _ => { + let ref mut fresh36 = (*parser).item_length; + *fresh36 = (*fresh36).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + if strcmp( + b"\0" as *const u8 as *const libc::c_char, + ((*finfo).b_data).offset((*parser).item_offset as isize), + ) == 0 as libc::c_int + { + (*finfo).filetype = CURLFILETYPE_DIRECTORY; + (*finfo).size = 0 as libc::c_int as curl_off_t; + } else { + let mut endptr_0: *mut libc::c_char = 0 + as *mut libc::c_char; + if curlx_strtoofft( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut endptr_0, + 10 as libc::c_int, + &mut (*finfo).size, + ) as u64 != 0 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*(*parser).file_data).info.filetype = CURLFILETYPE_FILE; + } + } + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 6 as libc::c_int) as libc::c_uint; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).state.NT.main = PL_WINNT_FILENAME; + (*parser) + .state + .NT + .sub + .filename = PL_WINNT_FILENAME_PRESPACE; + } + } + } + } + 1 => { + current_block = 9790556430701464115; + match current_block { + 5336772990438301456 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser) + .state + .NT + .sub + .dirorsize = PL_WINNT_DIRORSIZE_CONTENT; + } + } + _ => { + let ref mut fresh36 = (*parser).item_length; + *fresh36 = (*fresh36).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + if strcmp( + b"\0" as *const u8 as *const libc::c_char, + ((*finfo).b_data).offset((*parser).item_offset as isize), + ) == 0 as libc::c_int + { + (*finfo).filetype = CURLFILETYPE_DIRECTORY; + (*finfo).size = 0 as libc::c_int as curl_off_t; + } else { + let mut endptr_0: *mut libc::c_char = 0 + as *mut libc::c_char; + if curlx_strtoofft( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut endptr_0, + 10 as libc::c_int, + &mut (*finfo).size, + ) as u64 != 0 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*(*parser).file_data).info.filetype = CURLFILETYPE_FILE; + } + } + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 6 as libc::c_int) as libc::c_uint; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).state.NT.main = PL_WINNT_FILENAME; + (*parser) + .state + .NT + .sub + .filename = PL_WINNT_FILENAME_PRESPACE; + } + } + } + } + _ => {} + } + } + 9608327422557688744 => { + let ref mut fresh35 = (*parser).item_length; + *fresh35 = (*fresh35).wrapping_add(1); + match (*parser).state.NT.sub.time as libc::c_uint { + 0 => { + current_block = 2747568622853712931; + match current_block { + 2747568622853712931 => { + if Curl_isspace(c as libc::c_uchar as libc::c_int) == 0 { + (*parser).state.NT.sub.time = PL_WINNT_TIME_TIME; + } + } + _ => { + if c as libc::c_int == ' ' as i32 { + (*parser).offsets.time = (*parser).item_offset; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).state.NT.main = PL_WINNT_DIRORSIZE; + (*parser) + .state + .NT + .sub + .dirorsize = PL_WINNT_DIRORSIZE_PRESPACE; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + } else if (strchr( + b"APM0123456789:\0" as *const u8 as *const libc::c_char, + c as libc::c_int, + )) + .is_null() + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 13271080678501671613; + match current_block { + 2747568622853712931 => { + if Curl_isspace(c as libc::c_uchar as libc::c_int) == 0 { + (*parser).state.NT.sub.time = PL_WINNT_TIME_TIME; + } + } + _ => { + if c as libc::c_int == ' ' as i32 { + (*parser).offsets.time = (*parser).item_offset; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).state.NT.main = PL_WINNT_DIRORSIZE; + (*parser) + .state + .NT + .sub + .dirorsize = PL_WINNT_DIRORSIZE_PRESPACE; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + } else if (strchr( + b"APM0123456789:\0" as *const u8 as *const libc::c_char, + c as libc::c_int, + )) + .is_null() + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + _ => { + match (*parser).state.NT.sub.filename as libc::c_uint { + 0 => { + current_block = 10190897281885295872; + match current_block { + 10190897281885295872 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.NT.sub.filename = PL_WINNT_FILENAME_CONTENT; + } + } + 12975579885717081312 => { + let ref mut fresh37 = (*parser).item_length; + *fresh37 = (*fresh37).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser).state.NT.sub.filename = PL_WINNT_FILENAME_WINEOL; + *((*finfo).b_data) + .offset( + ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + } else if c as libc::c_int == '\n' as i32 { + (*parser).offsets.filename = (*parser).item_offset; + *((*finfo).b_data) + .offset( + ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.NT.main = PL_WINNT_DATE; + (*parser) + .state + .NT + .sub + .filename = PL_WINNT_FILENAME_PRESPACE; + } + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + (*parser).offsets.filename = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.NT.main = PL_WINNT_DATE; + (*parser) + .state + .NT + .sub + .filename = PL_WINNT_FILENAME_PRESPACE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 12975579885717081312; + match current_block { + 10190897281885295872 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.NT.sub.filename = PL_WINNT_FILENAME_CONTENT; + } + } + 12975579885717081312 => { + let ref mut fresh37 = (*parser).item_length; + *fresh37 = (*fresh37).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser).state.NT.sub.filename = PL_WINNT_FILENAME_WINEOL; + *((*finfo).b_data) + .offset( + ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + } else if c as libc::c_int == '\n' as i32 { + (*parser).offsets.filename = (*parser).item_offset; + *((*finfo).b_data) + .offset( + ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.NT.main = PL_WINNT_DATE; + (*parser) + .state + .NT + .sub + .filename = PL_WINNT_FILENAME_PRESPACE; + } + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + (*parser).offsets.filename = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.NT.main = PL_WINNT_DATE; + (*parser) + .state + .NT + .sub + .filename = PL_WINNT_FILENAME_PRESPACE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 2 => { + current_block = 3027624313100770395; + match current_block { + 10190897281885295872 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.NT.sub.filename = PL_WINNT_FILENAME_CONTENT; + } + } + 12975579885717081312 => { + let ref mut fresh37 = (*parser).item_length; + *fresh37 = (*fresh37).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser).state.NT.sub.filename = PL_WINNT_FILENAME_WINEOL; + *((*finfo).b_data) + .offset( + ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + } else if c as libc::c_int == '\n' as i32 { + (*parser).offsets.filename = (*parser).item_offset; + *((*finfo).b_data) + .offset( + ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.NT.main = PL_WINNT_DATE; + (*parser) + .state + .NT + .sub + .filename = PL_WINNT_FILENAME_PRESPACE; + } + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + (*parser).offsets.filename = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.NT.main = PL_WINNT_DATE; + (*parser) + .state + .NT + .sub + .filename = PL_WINNT_FILENAME_PRESPACE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + } + } + 2 => { + current_block = 538492802611270279; + match current_block { + 10276754450170513663 => { + let ref mut fresh34 = (*parser).item_length; + *fresh34 = (*fresh34).wrapping_add(1); + if (*parser).item_length < 9 as libc::c_int as libc::c_uint + { + if (strchr( + b"0123456789-\0" as *const u8 as *const libc::c_char, + c as libc::c_int, + )) + .is_null() + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } else if (*parser).item_length + == 9 as libc::c_int as libc::c_uint + { + if c as libc::c_int == ' ' as i32 { + (*parser).state.NT.main = PL_WINNT_TIME; + (*parser).state.NT.sub.time = PL_WINNT_TIME_PRESPACE; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 538492802611270279 => { + match (*parser).state.NT.sub.dirorsize as libc::c_uint { + 0 => { + current_block = 5336772990438301456; + match current_block { + 5336772990438301456 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser) + .state + .NT + .sub + .dirorsize = PL_WINNT_DIRORSIZE_CONTENT; + } + } + _ => { + let ref mut fresh36 = (*parser).item_length; + *fresh36 = (*fresh36).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + if strcmp( + b"\0" as *const u8 as *const libc::c_char, + ((*finfo).b_data).offset((*parser).item_offset as isize), + ) == 0 as libc::c_int + { + (*finfo).filetype = CURLFILETYPE_DIRECTORY; + (*finfo).size = 0 as libc::c_int as curl_off_t; + } else { + let mut endptr_0: *mut libc::c_char = 0 + as *mut libc::c_char; + if curlx_strtoofft( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut endptr_0, + 10 as libc::c_int, + &mut (*finfo).size, + ) as u64 != 0 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*(*parser).file_data).info.filetype = CURLFILETYPE_FILE; + } + } + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 6 as libc::c_int) as libc::c_uint; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).state.NT.main = PL_WINNT_FILENAME; + (*parser) + .state + .NT + .sub + .filename = PL_WINNT_FILENAME_PRESPACE; + } + } + } + } + 1 => { + current_block = 9790556430701464115; + match current_block { + 5336772990438301456 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser) + .state + .NT + .sub + .dirorsize = PL_WINNT_DIRORSIZE_CONTENT; + } + } + _ => { + let ref mut fresh36 = (*parser).item_length; + *fresh36 = (*fresh36).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + if strcmp( + b"\0" as *const u8 as *const libc::c_char, + ((*finfo).b_data).offset((*parser).item_offset as isize), + ) == 0 as libc::c_int + { + (*finfo).filetype = CURLFILETYPE_DIRECTORY; + (*finfo).size = 0 as libc::c_int as curl_off_t; + } else { + let mut endptr_0: *mut libc::c_char = 0 + as *mut libc::c_char; + if curlx_strtoofft( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut endptr_0, + 10 as libc::c_int, + &mut (*finfo).size, + ) as u64 != 0 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*(*parser).file_data).info.filetype = CURLFILETYPE_FILE; + } + } + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 6 as libc::c_int) as libc::c_uint; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).state.NT.main = PL_WINNT_FILENAME; + (*parser) + .state + .NT + .sub + .filename = PL_WINNT_FILENAME_PRESPACE; + } + } + } + } + _ => {} + } + } + 9608327422557688744 => { + let ref mut fresh35 = (*parser).item_length; + *fresh35 = (*fresh35).wrapping_add(1); + match (*parser).state.NT.sub.time as libc::c_uint { + 0 => { + current_block = 2747568622853712931; + match current_block { + 2747568622853712931 => { + if Curl_isspace(c as libc::c_uchar as libc::c_int) == 0 { + (*parser).state.NT.sub.time = PL_WINNT_TIME_TIME; + } + } + _ => { + if c as libc::c_int == ' ' as i32 { + (*parser).offsets.time = (*parser).item_offset; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).state.NT.main = PL_WINNT_DIRORSIZE; + (*parser) + .state + .NT + .sub + .dirorsize = PL_WINNT_DIRORSIZE_PRESPACE; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + } else if (strchr( + b"APM0123456789:\0" as *const u8 as *const libc::c_char, + c as libc::c_int, + )) + .is_null() + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 13271080678501671613; + match current_block { + 2747568622853712931 => { + if Curl_isspace(c as libc::c_uchar as libc::c_int) == 0 { + (*parser).state.NT.sub.time = PL_WINNT_TIME_TIME; + } + } + _ => { + if c as libc::c_int == ' ' as i32 { + (*parser).offsets.time = (*parser).item_offset; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).state.NT.main = PL_WINNT_DIRORSIZE; + (*parser) + .state + .NT + .sub + .dirorsize = PL_WINNT_DIRORSIZE_PRESPACE; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + } else if (strchr( + b"APM0123456789:\0" as *const u8 as *const libc::c_char, + c as libc::c_int, + )) + .is_null() + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + _ => { + match (*parser).state.NT.sub.filename as libc::c_uint { + 0 => { + current_block = 10190897281885295872; + match current_block { + 10190897281885295872 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.NT.sub.filename = PL_WINNT_FILENAME_CONTENT; + } + } + 12975579885717081312 => { + let ref mut fresh37 = (*parser).item_length; + *fresh37 = (*fresh37).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser).state.NT.sub.filename = PL_WINNT_FILENAME_WINEOL; + *((*finfo).b_data) + .offset( + ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + } else if c as libc::c_int == '\n' as i32 { + (*parser).offsets.filename = (*parser).item_offset; + *((*finfo).b_data) + .offset( + ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.NT.main = PL_WINNT_DATE; + (*parser) + .state + .NT + .sub + .filename = PL_WINNT_FILENAME_PRESPACE; + } + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + (*parser).offsets.filename = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.NT.main = PL_WINNT_DATE; + (*parser) + .state + .NT + .sub + .filename = PL_WINNT_FILENAME_PRESPACE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 12975579885717081312; + match current_block { + 10190897281885295872 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.NT.sub.filename = PL_WINNT_FILENAME_CONTENT; + } + } + 12975579885717081312 => { + let ref mut fresh37 = (*parser).item_length; + *fresh37 = (*fresh37).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser).state.NT.sub.filename = PL_WINNT_FILENAME_WINEOL; + *((*finfo).b_data) + .offset( + ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + } else if c as libc::c_int == '\n' as i32 { + (*parser).offsets.filename = (*parser).item_offset; + *((*finfo).b_data) + .offset( + ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.NT.main = PL_WINNT_DATE; + (*parser) + .state + .NT + .sub + .filename = PL_WINNT_FILENAME_PRESPACE; + } + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + (*parser).offsets.filename = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.NT.main = PL_WINNT_DATE; + (*parser) + .state + .NT + .sub + .filename = PL_WINNT_FILENAME_PRESPACE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 2 => { + current_block = 3027624313100770395; + match current_block { + 10190897281885295872 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.NT.sub.filename = PL_WINNT_FILENAME_CONTENT; + } + } + 12975579885717081312 => { + let ref mut fresh37 = (*parser).item_length; + *fresh37 = (*fresh37).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser).state.NT.sub.filename = PL_WINNT_FILENAME_WINEOL; + *((*finfo).b_data) + .offset( + ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + } else if c as libc::c_int == '\n' as i32 { + (*parser).offsets.filename = (*parser).item_offset; + *((*finfo).b_data) + .offset( + ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.NT.main = PL_WINNT_DATE; + (*parser) + .state + .NT + .sub + .filename = PL_WINNT_FILENAME_PRESPACE; + } + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + (*parser).offsets.filename = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.NT.main = PL_WINNT_DATE; + (*parser) + .state + .NT + .sub + .filename = PL_WINNT_FILENAME_PRESPACE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + } + } + 3 => { + current_block = 2336264180246734603; + match current_block { + 10276754450170513663 => { + let ref mut fresh34 = (*parser).item_length; + *fresh34 = (*fresh34).wrapping_add(1); + if (*parser).item_length < 9 as libc::c_int as libc::c_uint + { + if (strchr( + b"0123456789-\0" as *const u8 as *const libc::c_char, + c as libc::c_int, + )) + .is_null() + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } else if (*parser).item_length + == 9 as libc::c_int as libc::c_uint + { + if c as libc::c_int == ' ' as i32 { + (*parser).state.NT.main = PL_WINNT_TIME; + (*parser).state.NT.sub.time = PL_WINNT_TIME_PRESPACE; + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + 538492802611270279 => { + match (*parser).state.NT.sub.dirorsize as libc::c_uint { + 0 => { + current_block = 5336772990438301456; + match current_block { + 5336772990438301456 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser) + .state + .NT + .sub + .dirorsize = PL_WINNT_DIRORSIZE_CONTENT; + } + } + _ => { + let ref mut fresh36 = (*parser).item_length; + *fresh36 = (*fresh36).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + if strcmp( + b"\0" as *const u8 as *const libc::c_char, + ((*finfo).b_data).offset((*parser).item_offset as isize), + ) == 0 as libc::c_int + { + (*finfo).filetype = CURLFILETYPE_DIRECTORY; + (*finfo).size = 0 as libc::c_int as curl_off_t; + } else { + let mut endptr_0: *mut libc::c_char = 0 + as *mut libc::c_char; + if curlx_strtoofft( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut endptr_0, + 10 as libc::c_int, + &mut (*finfo).size, + ) as u64 != 0 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*(*parser).file_data).info.filetype = CURLFILETYPE_FILE; + } + } + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 6 as libc::c_int) as libc::c_uint; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).state.NT.main = PL_WINNT_FILENAME; + (*parser) + .state + .NT + .sub + .filename = PL_WINNT_FILENAME_PRESPACE; + } + } + } + } + 1 => { + current_block = 9790556430701464115; + match current_block { + 5336772990438301456 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser) + .state + .NT + .sub + .dirorsize = PL_WINNT_DIRORSIZE_CONTENT; + } + } + _ => { + let ref mut fresh36 = (*parser).item_length; + *fresh36 = (*fresh36).wrapping_add(1); + if c as libc::c_int == ' ' as i32 { + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + if strcmp( + b"\0" as *const u8 as *const libc::c_char, + ((*finfo).b_data).offset((*parser).item_offset as isize), + ) == 0 as libc::c_int + { + (*finfo).filetype = CURLFILETYPE_DIRECTORY; + (*finfo).size = 0 as libc::c_int as curl_off_t; + } else { + let mut endptr_0: *mut libc::c_char = 0 + as *mut libc::c_char; + if curlx_strtoofft( + ((*finfo).b_data).offset((*parser).item_offset as isize), + &mut endptr_0, + 10 as libc::c_int, + &mut (*finfo).size, + ) as u64 != 0 + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } else { + (*(*parser).file_data).info.filetype = CURLFILETYPE_FILE; + } + } + (*(*parser).file_data).info.flags + |= ((1 as libc::c_int) << 6 as libc::c_int) as libc::c_uint; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + (*parser).state.NT.main = PL_WINNT_FILENAME; + (*parser) + .state + .NT + .sub + .filename = PL_WINNT_FILENAME_PRESPACE; + } + } + } + } + _ => {} + } + } + 9608327422557688744 => { + let ref mut fresh35 = (*parser).item_length; + *fresh35 = (*fresh35).wrapping_add(1); + match (*parser).state.NT.sub.time as libc::c_uint { + 0 => { + current_block = 2747568622853712931; + match current_block { + 2747568622853712931 => { + if Curl_isspace(c as libc::c_uchar as libc::c_int) == 0 { + (*parser).state.NT.sub.time = PL_WINNT_TIME_TIME; + } + } + _ => { + if c as libc::c_int == ' ' as i32 { + (*parser).offsets.time = (*parser).item_offset; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).state.NT.main = PL_WINNT_DIRORSIZE; + (*parser) + .state + .NT + .sub + .dirorsize = PL_WINNT_DIRORSIZE_PRESPACE; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + } else if (strchr( + b"APM0123456789:\0" as *const u8 as *const libc::c_char, + c as libc::c_int, + )) + .is_null() + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 13271080678501671613; + match current_block { + 2747568622853712931 => { + if Curl_isspace(c as libc::c_uchar as libc::c_int) == 0 { + (*parser).state.NT.sub.time = PL_WINNT_TIME_TIME; + } + } + _ => { + if c as libc::c_int == ' ' as i32 { + (*parser).offsets.time = (*parser).item_offset; + *((*finfo).b_data) + .offset( + ((*parser).item_offset) + .wrapping_add((*parser).item_length as libc::c_ulong) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + (*parser).state.NT.main = PL_WINNT_DIRORSIZE; + (*parser) + .state + .NT + .sub + .dirorsize = PL_WINNT_DIRORSIZE_PRESPACE; + (*parser).item_length = 0 as libc::c_int as libc::c_uint; + } else if (strchr( + b"APM0123456789:\0" as *const u8 as *const libc::c_char, + c as libc::c_int, + )) + .is_null() + { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + _ => { + match (*parser).state.NT.sub.filename as libc::c_uint { + 0 => { + current_block = 10190897281885295872; + match current_block { + 10190897281885295872 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.NT.sub.filename = PL_WINNT_FILENAME_CONTENT; + } + } + 12975579885717081312 => { + let ref mut fresh37 = (*parser).item_length; + *fresh37 = (*fresh37).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser).state.NT.sub.filename = PL_WINNT_FILENAME_WINEOL; + *((*finfo).b_data) + .offset( + ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + } else if c as libc::c_int == '\n' as i32 { + (*parser).offsets.filename = (*parser).item_offset; + *((*finfo).b_data) + .offset( + ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.NT.main = PL_WINNT_DATE; + (*parser) + .state + .NT + .sub + .filename = PL_WINNT_FILENAME_PRESPACE; + } + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + (*parser).offsets.filename = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.NT.main = PL_WINNT_DATE; + (*parser) + .state + .NT + .sub + .filename = PL_WINNT_FILENAME_PRESPACE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 1 => { + current_block = 12975579885717081312; + match current_block { + 10190897281885295872 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.NT.sub.filename = PL_WINNT_FILENAME_CONTENT; + } + } + 12975579885717081312 => { + let ref mut fresh37 = (*parser).item_length; + *fresh37 = (*fresh37).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser).state.NT.sub.filename = PL_WINNT_FILENAME_WINEOL; + *((*finfo).b_data) + .offset( + ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + } else if c as libc::c_int == '\n' as i32 { + (*parser).offsets.filename = (*parser).item_offset; + *((*finfo).b_data) + .offset( + ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.NT.main = PL_WINNT_DATE; + (*parser) + .state + .NT + .sub + .filename = PL_WINNT_FILENAME_PRESPACE; + } + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + (*parser).offsets.filename = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.NT.main = PL_WINNT_DATE; + (*parser) + .state + .NT + .sub + .filename = PL_WINNT_FILENAME_PRESPACE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + 2 => { + current_block = 3027624313100770395; + match current_block { + 10190897281885295872 => { + if c as libc::c_int != ' ' as i32 { + (*parser) + .item_offset = ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong); + (*parser).item_length = 1 as libc::c_int as libc::c_uint; + (*parser).state.NT.sub.filename = PL_WINNT_FILENAME_CONTENT; + } + } + 12975579885717081312 => { + let ref mut fresh37 = (*parser).item_length; + *fresh37 = (*fresh37).wrapping_add(1); + if c as libc::c_int == '\r' as i32 { + (*parser).state.NT.sub.filename = PL_WINNT_FILENAME_WINEOL; + *((*finfo).b_data) + .offset( + ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + } else if c as libc::c_int == '\n' as i32 { + (*parser).offsets.filename = (*parser).item_offset; + *((*finfo).b_data) + .offset( + ((*finfo).b_used) + .wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize, + ) = 0 as libc::c_int as libc::c_char; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.NT.main = PL_WINNT_DATE; + (*parser) + .state + .NT + .sub + .filename = PL_WINNT_FILENAME_PRESPACE; + } + } + } + _ => { + if c as libc::c_int == '\n' as i32 { + (*parser).offsets.filename = (*parser).item_offset; + result = ftp_pl_insert_finfo(data, infop); + if result as u64 != 0 { + (*parser).error = result; + current_block = 16980866091698012183; + break; + } else { + (*parser).state.NT.main = PL_WINNT_DATE; + (*parser) + .state + .NT + .sub + .filename = PL_WINNT_FILENAME_PRESPACE; + } + } else { + (*parser).error = CURLE_FTP_BAD_FILE_LIST; + current_block = 16980866091698012183; + break; + } + } + } + } + _ => {} + } + } + } + } + _ => {} + } + } + _ => { + retsize = bufflen.wrapping_add(1 as libc::c_int as libc::c_ulong); + current_block = 16980866091698012183; + break; + } + } + i = i.wrapping_add(1); + } + match current_block { + 16980866091698012183 => {} + _ => return retsize, + } + } + if !((*parser).file_data).is_null() { + Curl_fileinfo_cleanup((*parser).file_data); + let ref mut fresh38 = (*parser).file_data; + *fresh38 = 0 as *mut fileinfo; + } + return retsize; +}