std::string join_headers( std::string header1, std::string header2 )
{
std::vector<std::string> vs1 = tokenize_string( header1, "\t" );
std::vector<std::string> vs2 = tokenize_string( header2, "\t" );
std::vector<std::string> intercept = intercept_cols( vs1, vs2 );
std::string header;
for ( int i = 0; i < vs1.size(); i++ )
{
int j = 0;
for ( j = 0; j < intercept.size(); j++ )
{
if ( compare_without_star( vs1[i], intercept[j] ))
break;
}
if ( j == intercept.size() )
{
if ( vs1[i][0] == '*' )
header.append( vs1[i].substr( 1, vs1[i].size() ) );
else
header.append( vs1[i] );
header.push_back( '\t' );
} // current col_name is not in intercept,
}
for ( int i = 0; i < intercept.size(); i++)
{
if ( intercept[i][0] == '*' )
header.append( intercept[i].substr( 1, vs1[i].size() ) );
else
header.append( intercept[i] );
header.push_back( '\t' );
}
for ( int i = 0; i < vs2.size(); i++ )
{
int j = 0;
for ( j = 0; j < intercept.size(); j++ )
{
if ( compare_without_star( vs2[i], intercept[j] ))
break;
}
if ( j == intercept.size() )
{
if ( vs2[i][0] == '*' )
header.append( vs2[i].substr( 1, vs2[i].size() ) );
else
header.append( vs2[i] );
header.push_back( '\t' );
} // j reach the end, current std::string is not in intercept
}
return header;
}
token_type_t get_token(tokenizer_t* t)
{
if (t->token_value) {
free(t->token_value);
t->token_value = NULL;
}
eatwhitespace(t);
stack_push(t->index_stack, &t->source_index);
if ('\0' == t->source[t->source_index]) {
t->token_type = TT_EOF;
return TT_EOF;
}
if (is_digit(t->source[t->source_index])) {
tokenize_number(t);
return TT_NUMBER;
}
if (is_alpha(t->source[t->source_index])) {
tokenize_identifier(t);
return TT_IDENT;
}
if ('"' == t->source[t->source_index]) {
tokenize_string(t);
return TT_STRING;
}
return TT_UNKNOWN;
}
int main() {
char buffer[BUFFERSIZE];
char **path = init_path();
int path_length = 1;
while (1) {
char *filename = 0;
printf("%s", "whoosh > ");
if (fgets(buffer, BUFFERSIZE, stdin) != NULL) {
int command_length = 0;
char **commands = tokenize_string(trim_whitespace(buffer), &command_length);
if (check_if_built_in_command(commands, command_length) != 0) {
if (strcmp(commands[0], "exit") == 0)
exit(0);
else if (strcmp(commands[0], "pwd") == 0) {
char buff[PATH_MAX + 1];
printf("%s\n", getcwd(buff, PATH_MAX + 1));
}
else if (strcmp(commands[0], "cd") == 0) {
char *dir = command_length == 1 ? getenv("HOME") : commands[1];
if (chdir(dir) != 0)
error_output();
}
else if (strcmp(commands[0], "path") == 0) {
path = commands + 1;
path_length = command_length - 1;
}
}
else if (command_length != 0 && (check_command_syntax(commands, command_length, &filename) != 0 ||
run_shell_commands(commands, command_length, path, path_length, filename) != 0))
error_output();
}
else
error_output();
}
}
void append_string_to_args( char * sin ,
int argc , char * argv[] ,
int * new_argc , char *** new_argv )
{
int n_argc , ii , ntok=0 ;
char ** n_argv , ** stok=NULL ;
char * cpt , * sss ;
if( new_argc == NULL || new_argv == NULL ) return ; /* error */
if( sin == NULL || sin[0] == '\0' ){ *new_argv = NULL; return; } /* do nothing */
tokenize_string( sin , &ntok , &stok ) ;
if( stok == NULL || ntok < 1 ){ *new_argv = NULL; return; } /* do nothing */
/* copy input args to output */
if( argc > 0 ){
duplicate_string_list( argc , argv , &n_argv ) ;
n_argc = argc ;
} else { /* shouldn't happen */
n_argv = NULL ;
n_argc = 0 ;
}
/* append token list to output */
appendto_string_list( &n_argc , &n_argv , ntok , stok ) ;
free_string_list( ntok , stok ) ;
*new_argc = n_argc ; /* the results! */
*new_argv = n_argv ;
return ;
}
int get_col_pos( std::string col, std::string header ){
std::vector<std::string> vh = tokenize_string( header, "\t" );
int i = 0;
if( col[0] == '*' || col[0] == '&' )
col = col.substr( 1, col.size() );
for ( std::vector<std::string>::iterator itr = vh.begin() ; itr != vh.end(); itr++ )
{
//std::cout << *itr << " " << col << std::endl;
if ( compare_without_star(*itr, col ) ){
return i;
}
i++;
}
return -1;
}
void prepend_string_to_args( char * sin ,
int argc , char * argv[] ,
int * new_argc , char *** new_argv )
{
int n_argc , ii , ntok=0 ;
char ** n_argv , ** stok=NULL ;
char * cpt , * sss ;
if( new_argc == NULL || new_argv == NULL ) return ; /* error */
if( sin == NULL || sin[0] == '\0' ){ *new_argv = NULL; return; } /* do nothing */
/*-- if no inputs after argv[0], prepend and append are identical --*/
if( argc < 2 ){
append_string_to_args( sin , argc , argv , new_argc , new_argv ) ;
return ;
}
/*-- OK, must do it my way --*/
tokenize_string( sin , &ntok , &stok ) ;
if( stok == NULL || ntok < 1 ){ *new_argv = NULL; return; } /* do nothing */
/* copy first input arg to output */
duplicate_string_list( 1 , argv , &n_argv ) ;
n_argc = 1 ;
/* append token list to output */
appendto_string_list( &n_argc , &n_argv , ntok , stok ) ;
free_string_list( ntok , stok ) ;
/* append rest of input args to output */
appendto_string_list( &n_argc , &n_argv , argc-1 , argv+1 ) ;
*new_argc = n_argc ; /* the results! */
*new_argv = n_argv ;
return ;
}
void FileSystem::CleanFilename(const std::string &filename, std::string &cleaned) {
int i, j;
std::string itermediate = filename;
// Replace backslashes with forward slashes
i = 0;
while(i < (int)itermediate.size()) {
j = (int)itermediate.find('\\', i);
if(j != -1) {
itermediate[j] = '/';
i = j+1;
} else {
break;
}
}
// Find double-dots and deal with them
std::list<std::string> pieces;
tokenize_string(itermediate, "/", pieces);
std::list<std::string>::reverse_iterator ritr;
cleaned = "";
for(ritr = pieces.rbegin(); ritr != pieces.rend(); ritr++) {
i = 0;
while((*ritr) == "..") {
ritr++;
i++;
if(ritr == pieces.rend()) { return; }
}
while(i > 0) {
ritr++;
i--;
if(ritr == pieces.rend()) { return; }
}
cleaned = (*ritr) + "/" + cleaned;
}
}
token_t
tokenizer_next_string(tokenizer_t *tokenizer, string_type_t string_type)
{
token_t tok;
int len = 1;
int newline = FALSE;
const char *offset;
int string;
if (tokenizer->to_use == &tokenizer->previous) {
tokenizer->to_use = &tokenizer->current;
return tokenizer_current(tokenizer);
}
if (END == tokenizer->to_use->token.type &&
tokenizer->to_use->valid)
{
return tokenizer_current(tokenizer);
}
offset = tokenizer->current.offset;
tokenizer->previous = tokenizer->current;
if (string_type == NAME && tokenize_name_string(offset, &tok, &len)) string = TRUE;
else if (string_type == INTEGER && tokenize_integer_string(offset, &tok, &len)) string = TRUE;
else if (string_type == HEX && tokenize_hex_string(offset, &tok, &len)) string = TRUE;
else if (string_type == COMMENT_TEXT && tokenize_comment_text(offset, &tok, &len)) string = TRUE;
else string = FALSE;
if (string) {
/* Do nothing */
} else if (offset[0] == '\0') {
tok.type = END;
} else if (offset[0] == '<') {
if (offset[1] == '?') {
tok.type = PI_START;
len = 2;
} else if (offset[1] == '/') {
tok.type = CLOSE_TAG_START;
len = 2;
} else if (offset[1] == '!' &&
offset[2] == '-' &&
offset[3] == '-'
)
{
tok.type = COMMENT_START;
len = 4;
} else {
tok.type = LT;
}
} else if (offset[0] == '&') {
if (offset[1] == '#') {
if (offset[2] == 'x') {
tok.type = CHAR_REF_HEX;
len = 3;
} else {
tok.type = CHAR_REF;
len = 2;
}
} else {
tok.type = AMP;
}
} else if (string_type == ATTR_VALUE_QUOT && (*offset != '"')) {
len = tokenize_string(offset, &tok, "\"");
} else if (string_type == ATTR_VALUE_APOS && (*offset != '\'')) {
len = tokenize_string(offset, &tok, "'");
} else if (string_type == CHARDATA) {
len = tokenize_string(offset, &tok, "<&");
/* TODO: Check for ]]> */
} else if (offset[0] == ' ' ||
offset[0] == '\t' ||
offset[0] == '\n' ||
offset[0] == '\r') {
tok.type = SPACE;
if (offset[0] == '\n' ||
offset[0] == '\r') {
newline = TRUE;
}
} else if (offset[0] == '>') {
tok.type = GT;
} else if (offset[0] == '?' && offset[1] == '>') {
tok.type = PI_END;
len = 2;
} else if (offset[0] == '-' &&
offset[1] == '-' &&
offset[2] == '>')
{
tok.type = COMMENT_END;
len = 3;
} else if (offset[0] == '/') {
tok.type = SLASH;
} else if (offset[0] == '=') {
tok.type = EQ;
} else if (offset[0] == '\'') {
tok.type = APOS;
} else if (offset[0] == '"') {
tok.type = QUOT;
} else if (offset[0] == ';') {
tok.type = SEMICOLON;
} else {
abort();
}
tokenizer->current.valid = TRUE;
tokenizer->current.context = tokenizer->next_context;
tokenizer->current.token = tok;
tokenizer->current.offset += len;
/* This seems ugly */
if (newline) {
tokenizer->next_context.line++;
tokenizer->next_context.column = 0;
} else {
tokenizer->next_context.column += len;
}
tokenizer->next_context.offset += len;
return tok;
}
int main(int argc, char ** argv)
{
int result = 0;
if (argc != 4)
{
print_usage();
result = 1;
}
else
{
FILE * token_output_f = 0;
FILE * grammar_output_f = 0;
FILE * grammar_source_f = 0;
grammar_source_f = fopen(argv[3],"r");
if (grammar_source_f == 0) { result = 1; }
if (result == 0)
{
literal literals[1024];
int t = 0;
char l[2048];
while (1)
{
if (fgets(l,2048,grammar_source_f) != 0)
{
char * c = l;
while (1)
{
char * c1 = strchr(c,'`');
if (c1 != 0)
{
char * c2 = strchr(c1+1,'`');
if (c2 != 0)
{
literals[t].string = copy_string(c1+1,c2-c1-1);
literals[t].token = tokenize_string(literals[t].string);
t += 1;
c = c2+1;
}
else
break;
}
else
break;
}
}
else
{
break;
}
}
literals[t].string = 0;
literals[t].token = 0;
qsort(literals,t,sizeof(literal),cmp_literal);
{
int p = 1;
int i = 1;
while (literals[i].string != 0)
{
if (strcmp(literals[p-1].string,literals[i].string) != 0)
{
literals[p] = literals[i];
p += 1;
}
i += 1;
}
literals[p].string = 0;
literals[p].token = 0;
t = p;
}
token_output_f = fopen(argv[2],"w");
if (token_output_f != 0)
{
int i = 0;
while (literals[i].string != 0)
{
fprintf(token_output_f," { \"%s\", %s },\n",literals[i].string,literals[i].token);
i += 1;
}
fclose(token_output_f);
}
else
result = 1;
if (result == 0)
{
grammar_output_f = fopen(argv[1],"w");
if (grammar_output_f != 0)
{
int i = 0;
while (literals[i].string != 0)
{
fprintf(grammar_output_f,"%%token %s\n",literals[i].token);
i += 1;
}
rewind(grammar_source_f);
while (1)
{
if (fgets(l,2048,grammar_source_f) != 0)
{
char * c = l;
while (1)
{
char * c1 = strchr(c,'`');
if (c1 != 0)
{
char * c2 = strchr(c1+1,'`');
if (c2 != 0)
{
literal key;
literal * replacement = 0;
key.string = copy_string(c1+1,c2-c1-1);
key.token = 0;
replacement = (literal*)bsearch(
&key,literals,t,sizeof(literal),cmp_literal);
*c1 = 0;
fprintf(grammar_output_f,"%s%s",c,replacement->token);
c = c2+1;
}
else
{
fprintf(grammar_output_f,"%s",c);
break;
}
}
else
{
fprintf(grammar_output_f,"%s",c);
break;
}
}
}
else
{
break;
}
}
fclose(grammar_output_f);
}
else
result = 1;
}
}
if (result != 0)
{
perror("yyacc");
}
}
return result;
}
/**
* Execute query.
* @param query the query to execute.
* @param playlist set to TRUE to search only songs in the playlist.
*
* @returns the search result in a #MpdData list.
*/
MpdData *advanced_search(const gchar * query, int in_playlist)
{
MpdData *data_return = NULL;
gchar **text = g_regex_split(search_regex, query, 0);
int i = 0;
gboolean found = FALSE;
for (i = 0; text && text[i]; i++)
{
int type;
/* Or sign, if hit, a new query is started */
if (strcmp(text[i], "||") == 0)
{
MpdData *data;
/* Commit the currently in active search and append the results */
if (in_playlist)
data = mpd_playlist_search_commit(connection);
else
data = mpd_database_search_commit(connection);
data_return = mpd_data_concatenate(data_return, data);
found = FALSE;
continue;
}
/* empty element */
if (text[i][0] == '\0')
continue;
/* Parse the tag name. */
type = mpd_misc_get_tag_by_name(g_strstrip(text[i]));
if (type != MPD_TAG_NOT_FOUND && text[i + 1])
{
gchar **split = tokenize_string(text[i + 1]);
int j;
for (j = 0; split && split[j]; j++)
{
if (!found)
{
if (in_playlist)
mpd_playlist_search_start(connection, FALSE);
else
mpd_database_search_start(connection, FALSE);
found = TRUE;
}
if (in_playlist)
mpd_playlist_search_add_constraint(connection, type, g_strstrip(split[j]));
else
mpd_database_search_add_constraint(connection, type, g_strstrip(split[j]));
}
if (split)
g_strfreev(split);
i++;
} else
{
gchar **split = tokenize_string(text[i]);
int j;
for (j = 0; split && split[j]; j++)
{
if (!found)
{
if (in_playlist)
mpd_playlist_search_start(connection, FALSE);
else
mpd_database_search_start(connection, FALSE);
found = TRUE;
}
if (in_playlist)
mpd_playlist_search_add_constraint(connection, MPD_TAG_ITEM_ANY, split[j]);
else
mpd_database_search_add_constraint(connection, MPD_TAG_ITEM_ANY, split[j]);
}
if (split)
g_strfreev(split);
}
}
if (text)
g_strfreev(text);
/* Execute the active search and append the results */
if (found)
{
MpdData *data;
if (in_playlist)
data = mpd_playlist_search_commit(connection);
else
data = mpd_database_search_commit(connection);
data_return = mpd_data_concatenate(data_return, data);
}
/* remove possible duplicates (because of concatenating queries) */
return misc_mpddata_remove_duplicate_songs(data_return);
}
/** Parse and validate the ASCII-encoded v2 descriptor in <b>desc</b>,
* write the parsed descriptor to the newly allocated *<b>parsed_out</b>, the
* binary descriptor ID of length DIGEST_LEN to <b>desc_id_out</b>, the
* encrypted introduction points to the newly allocated
* *<b>intro_points_encrypted_out</b>, their encrypted size to
* *<b>intro_points_encrypted_size_out</b>, the size of the encoded descriptor
* to *<b>encoded_size_out</b>, and a pointer to the possibly next
* descriptor to *<b>next_out</b>; return 0 for success (including validation)
* and -1 for failure.
*
* If <b>as_hsdir</b> is 1, we're parsing this as an HSDir, and we should
* be strict about time formats.
*/
int
rend_parse_v2_service_descriptor(rend_service_descriptor_t **parsed_out,
char *desc_id_out,
char **intro_points_encrypted_out,
size_t *intro_points_encrypted_size_out,
size_t *encoded_size_out,
const char **next_out, const char *desc,
int as_hsdir)
{
rend_service_descriptor_t *result =
tor_malloc_zero(sizeof(rend_service_descriptor_t));
char desc_hash[DIGEST_LEN];
const char *eos;
smartlist_t *tokens = smartlist_new();
directory_token_t *tok;
char secret_id_part[DIGEST_LEN];
int i, version, num_ok=1;
smartlist_t *versions;
char public_key_hash[DIGEST_LEN];
char test_desc_id[DIGEST_LEN];
memarea_t *area = NULL;
const int strict_time_fmt = as_hsdir;
tor_assert(desc);
/* Check if desc starts correctly. */
if (strcmpstart(desc, "rendezvous-service-descriptor ")) {
log_info(LD_REND, "Descriptor does not start correctly.");
goto err;
}
/* Compute descriptor hash for later validation. */
if (router_get_hash_impl(desc, strlen(desc), desc_hash,
"rendezvous-service-descriptor ",
"\nsignature", '\n', DIGEST_SHA1) < 0) {
log_warn(LD_REND, "Couldn't compute descriptor hash.");
goto err;
}
/* Determine end of string. */
eos = strstr(desc, "\nrendezvous-service-descriptor ");
if (!eos)
eos = desc + strlen(desc);
else
eos = eos + 1;
/* Check length. */
if (eos-desc > REND_DESC_MAX_SIZE) {
/* XXXX+ If we are parsing this descriptor as a server, this
* should be a protocol warning. */
log_warn(LD_REND, "Descriptor length is %d which exceeds "
"maximum rendezvous descriptor size of %d bytes.",
(int)(eos-desc), REND_DESC_MAX_SIZE);
goto err;
}
/* Tokenize descriptor. */
area = memarea_new();
if (tokenize_string(area, desc, eos, tokens, desc_token_table, 0)) {
log_warn(LD_REND, "Error tokenizing descriptor.");
goto err;
}
/* Set next to next descriptor, if available. */
*next_out = eos;
/* Set length of encoded descriptor. */
*encoded_size_out = eos - desc;
/* Check min allowed length of token list. */
if (smartlist_len(tokens) < 7) {
log_warn(LD_REND, "Impossibly short descriptor.");
goto err;
}
/* Parse base32-encoded descriptor ID. */
tok = find_by_keyword(tokens, R_RENDEZVOUS_SERVICE_DESCRIPTOR);
tor_assert(tok == smartlist_get(tokens, 0));
tor_assert(tok->n_args == 1);
if (!rend_valid_descriptor_id(tok->args[0])) {
log_warn(LD_REND, "Invalid descriptor ID: '%s'", tok->args[0]);
goto err;
}
if (base32_decode(desc_id_out, DIGEST_LEN,
tok->args[0], REND_DESC_ID_V2_LEN_BASE32) < 0) {
log_warn(LD_REND, "Descriptor ID contains illegal characters: %s",
tok->args[0]);
goto err;
}
/* Parse descriptor version. */
tok = find_by_keyword(tokens, R_VERSION);
tor_assert(tok->n_args == 1);
result->version =
(int) tor_parse_long(tok->args[0], 10, 0, INT_MAX, &num_ok, NULL);
if (result->version != 2 || !num_ok) {
/* If it's <2, it shouldn't be under this format. If the number
* is greater than 2, we bumped it because we broke backward
* compatibility. See how version numbers in our other formats
* work. */
log_warn(LD_REND, "Unrecognized descriptor version: %s",
escaped(tok->args[0]));
goto err;
}
/* Parse public key. */
tok = find_by_keyword(tokens, R_PERMANENT_KEY);
result->pk = tok->key;
tok->key = NULL; /* Prevent free */
/* Parse secret ID part. */
tok = find_by_keyword(tokens, R_SECRET_ID_PART);
tor_assert(tok->n_args == 1);
if (strlen(tok->args[0]) != REND_SECRET_ID_PART_LEN_BASE32 ||
strspn(tok->args[0], BASE32_CHARS) != REND_SECRET_ID_PART_LEN_BASE32) {
log_warn(LD_REND, "Invalid secret ID part: '%s'", tok->args[0]);
goto err;
}
if (base32_decode(secret_id_part, DIGEST_LEN, tok->args[0], 32) < 0) {
log_warn(LD_REND, "Secret ID part contains illegal characters: %s",
tok->args[0]);
goto err;
}
/* Parse publication time -- up-to-date check is done when storing the
* descriptor. */
tok = find_by_keyword(tokens, R_PUBLICATION_TIME);
tor_assert(tok->n_args == 1);
if (parse_iso_time_(tok->args[0], &result->timestamp,
strict_time_fmt, 0) < 0) {
log_warn(LD_REND, "Invalid publication time: '%s'", tok->args[0]);
goto err;
}
/* Parse protocol versions. */
tok = find_by_keyword(tokens, R_PROTOCOL_VERSIONS);
tor_assert(tok->n_args == 1);
versions = smartlist_new();
smartlist_split_string(versions, tok->args[0], ",",
SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
for (i = 0; i < smartlist_len(versions); i++) {
version = (int) tor_parse_long(smartlist_get(versions, i),
10, 0, INT_MAX, &num_ok, NULL);
if (!num_ok) /* It's a string; let's ignore it. */
continue;
if (version >= REND_PROTOCOL_VERSION_BITMASK_WIDTH)
/* Avoid undefined left-shift behaviour. */
continue;
result->protocols |= 1 << version;
}
SMARTLIST_FOREACH(versions, char *, cp, tor_free(cp));
smartlist_free(versions);
/* Parse encrypted introduction points. Don't verify. */
tok = find_opt_by_keyword(tokens, R_INTRODUCTION_POINTS);
if (tok) {
if (strcmp(tok->object_type, "MESSAGE")) {
log_warn(LD_DIR, "Bad object type: introduction points should be of "
"type MESSAGE");
goto err;
}
*intro_points_encrypted_out = tor_memdup(tok->object_body,
tok->object_size);
*intro_points_encrypted_size_out = tok->object_size;
} else {
*intro_points_encrypted_out = NULL;
*intro_points_encrypted_size_out = 0;
}
/* Parse and verify signature. */
tok = find_by_keyword(tokens, R_SIGNATURE);
if (check_signature_token(desc_hash, DIGEST_LEN, tok, result->pk, 0,
"v2 rendezvous service descriptor") < 0)
goto err;
/* Verify that descriptor ID belongs to public key and secret ID part. */
if (crypto_pk_get_digest(result->pk, public_key_hash) < 0) {
log_warn(LD_REND, "Unable to compute rend descriptor public key digest");
goto err;
}
rend_get_descriptor_id_bytes(test_desc_id, public_key_hash,
secret_id_part);
if (tor_memneq(desc_id_out, test_desc_id, DIGEST_LEN)) {
log_warn(LD_REND, "Parsed descriptor ID does not match "
"computed descriptor ID.");
goto err;
}
goto done;
err:
rend_service_descriptor_free(result);
result = NULL;
done:
if (tokens) {
SMARTLIST_FOREACH(tokens, directory_token_t *, t, token_clear(t));
smartlist_free(tokens);
}
if (area)
memarea_drop_all(area);
*parsed_out = result;
if (result)
return 0;
return -1;
}
/** Parse the content of a client_key file in <b>ckstr</b> and add
* rend_authorized_client_t's for each parsed client to
* <b>parsed_clients</b>. Return the number of parsed clients as result
* or -1 for failure. */
int
rend_parse_client_keys(strmap_t *parsed_clients, const char *ckstr)
{
int result = -1;
smartlist_t *tokens;
directory_token_t *tok;
const char *current_entry = NULL;
memarea_t *area = NULL;
char *err_msg = NULL;
if (!ckstr || strlen(ckstr) == 0)
return -1;
tokens = smartlist_new();
/* Begin parsing with first entry, skipping comments or whitespace at the
* beginning. */
area = memarea_new();
current_entry = eat_whitespace(ckstr);
while (!strcmpstart(current_entry, "client-name ")) {
rend_authorized_client_t *parsed_entry;
/* Determine end of string. */
const char *eos = strstr(current_entry, "\nclient-name ");
if (!eos)
eos = current_entry + strlen(current_entry);
else
eos = eos + 1;
/* Free tokens and clear token list. */
SMARTLIST_FOREACH(tokens, directory_token_t *, t, token_clear(t));
smartlist_clear(tokens);
memarea_clear(area);
/* Tokenize string. */
if (tokenize_string(area, current_entry, eos, tokens,
client_keys_token_table, 0)) {
log_warn(LD_REND, "Error tokenizing client keys file.");
goto err;
}
/* Advance to next entry, if available. */
current_entry = eos;
/* Check minimum allowed length of token list. */
if (smartlist_len(tokens) < 2) {
log_warn(LD_REND, "Impossibly short client key entry.");
goto err;
}
/* Parse client name. */
tok = find_by_keyword(tokens, C_CLIENT_NAME);
tor_assert(tok == smartlist_get(tokens, 0));
tor_assert(tok->n_args == 1);
if (!rend_valid_client_name(tok->args[0])) {
log_warn(LD_CONFIG, "Illegal client name: %s. (Length must be "
"between 1 and %d, and valid characters are "
"[A-Za-z0-9+-_].)", tok->args[0], REND_CLIENTNAME_MAX_LEN);
goto err;
}
/* Check if client name is duplicate. */
if (strmap_get(parsed_clients, tok->args[0])) {
log_warn(LD_CONFIG, "HiddenServiceAuthorizeClient contains a "
"duplicate client name: '%s'. Ignoring.", tok->args[0]);
goto err;
}
parsed_entry = tor_malloc_zero(sizeof(rend_authorized_client_t));
parsed_entry->client_name = tor_strdup(tok->args[0]);
strmap_set(parsed_clients, parsed_entry->client_name, parsed_entry);
/* Parse client key. */
tok = find_opt_by_keyword(tokens, C_CLIENT_KEY);
if (tok) {
parsed_entry->client_key = tok->key;
tok->key = NULL; /* Prevent free */
}
/* Parse descriptor cookie. */
tok = find_by_keyword(tokens, C_DESCRIPTOR_COOKIE);
tor_assert(tok->n_args == 1);
if (rend_auth_decode_cookie(tok->args[0], parsed_entry->descriptor_cookie,
NULL, &err_msg) < 0) {
tor_assert(err_msg);
log_warn(LD_REND, "%s", err_msg);
tor_free(err_msg);
goto err;
}
}
result = strmap_size(parsed_clients);
goto done;
err:
result = -1;
done:
/* Free tokens and clear token list. */
SMARTLIST_FOREACH(tokens, directory_token_t *, t, token_clear(t));
smartlist_free(tokens);
if (area)
memarea_drop_all(area);
return result;
}
/** Parse the encoded introduction points in <b>intro_points_encoded</b> of
* length <b>intro_points_encoded_size</b> and write the result to the
* descriptor in <b>parsed</b>; return the number of successfully parsed
* introduction points or -1 in case of a failure. */
int
rend_parse_introduction_points(rend_service_descriptor_t *parsed,
const char *intro_points_encoded,
size_t intro_points_encoded_size)
{
const char *current_ipo, *end_of_intro_points;
smartlist_t *tokens = NULL;
directory_token_t *tok;
rend_intro_point_t *intro;
extend_info_t *info;
int result, num_ok=1;
memarea_t *area = NULL;
tor_assert(parsed);
/** Function may only be invoked once. */
tor_assert(!parsed->intro_nodes);
if (!intro_points_encoded || intro_points_encoded_size == 0) {
log_warn(LD_REND, "Empty or zero size introduction point list");
goto err;
}
/* Consider one intro point after the other. */
current_ipo = intro_points_encoded;
end_of_intro_points = intro_points_encoded + intro_points_encoded_size;
tokens = smartlist_new();
parsed->intro_nodes = smartlist_new();
area = memarea_new();
while (!fast_memcmpstart(current_ipo, end_of_intro_points-current_ipo,
"introduction-point ")) {
/* Determine end of string. */
const char *eos = tor_memstr(current_ipo, end_of_intro_points-current_ipo,
"\nintroduction-point ");
if (!eos)
eos = end_of_intro_points;
else
eos = eos+1;
tor_assert(eos <= intro_points_encoded+intro_points_encoded_size);
/* Free tokens and clear token list. */
SMARTLIST_FOREACH(tokens, directory_token_t *, t, token_clear(t));
smartlist_clear(tokens);
memarea_clear(area);
/* Tokenize string. */
if (tokenize_string(area, current_ipo, eos, tokens, ipo_token_table, 0)) {
log_warn(LD_REND, "Error tokenizing introduction point");
goto err;
}
/* Advance to next introduction point, if available. */
current_ipo = eos;
/* Check minimum allowed length of introduction point. */
if (smartlist_len(tokens) < 5) {
log_warn(LD_REND, "Impossibly short introduction point.");
goto err;
}
/* Allocate new intro point and extend info. */
intro = tor_malloc_zero(sizeof(rend_intro_point_t));
info = intro->extend_info = tor_malloc_zero(sizeof(extend_info_t));
/* Parse identifier. */
tok = find_by_keyword(tokens, R_IPO_IDENTIFIER);
if (base32_decode(info->identity_digest, DIGEST_LEN,
tok->args[0], REND_INTRO_POINT_ID_LEN_BASE32) < 0) {
log_warn(LD_REND, "Identity digest contains illegal characters: %s",
tok->args[0]);
rend_intro_point_free(intro);
goto err;
}
/* Write identifier to nickname. */
info->nickname[0] = '$';
base16_encode(info->nickname + 1, sizeof(info->nickname) - 1,
info->identity_digest, DIGEST_LEN);
/* Parse IP address. */
tok = find_by_keyword(tokens, R_IPO_IP_ADDRESS);
if (tor_addr_parse(&info->addr, tok->args[0])<0) {
log_warn(LD_REND, "Could not parse introduction point address.");
rend_intro_point_free(intro);
goto err;
}
if (tor_addr_family(&info->addr) != AF_INET) {
log_warn(LD_REND, "Introduction point address was not ipv4.");
rend_intro_point_free(intro);
goto err;
}
/* Parse onion port. */
tok = find_by_keyword(tokens, R_IPO_ONION_PORT);
info->port = (uint16_t) tor_parse_long(tok->args[0],10,1,65535,
&num_ok,NULL);
if (!info->port || !num_ok) {
log_warn(LD_REND, "Introduction point onion port %s is invalid",
escaped(tok->args[0]));
rend_intro_point_free(intro);
goto err;
}
/* Parse onion key. */
tok = find_by_keyword(tokens, R_IPO_ONION_KEY);
if (!crypto_pk_public_exponent_ok(tok->key)) {
log_warn(LD_REND,
"Introduction point's onion key had invalid exponent.");
rend_intro_point_free(intro);
goto err;
}
info->onion_key = tok->key;
tok->key = NULL; /* Prevent free */
/* Parse service key. */
tok = find_by_keyword(tokens, R_IPO_SERVICE_KEY);
if (!crypto_pk_public_exponent_ok(tok->key)) {
log_warn(LD_REND,
"Introduction point key had invalid exponent.");
rend_intro_point_free(intro);
goto err;
}
intro->intro_key = tok->key;
tok->key = NULL; /* Prevent free */
/* Add extend info to list of introduction points. */
smartlist_add(parsed->intro_nodes, intro);
}
result = smartlist_len(parsed->intro_nodes);
goto done;
err:
result = -1;
done:
/* Free tokens and clear token list. */
if (tokens) {
SMARTLIST_FOREACH(tokens, directory_token_t *, t, token_clear(t));
smartlist_free(tokens);
}
if (area)
memarea_drop_all(area);
return result;
}
bool num_comparison( expression * ep, std::string header, std::string row )
{
if ( !ep )
return false;
std::vector<std::string> cols = tokenize_string( header, "\t" );
expression* node[2];
node[0] = ep->values[0].ep;
node[1] = ep->values[1].ep;
int v_lhs = 0;
int v_rhs = 0;
int ops[2];
// tokenize row
std::vector<std::string> row_v;
char *s = toChars( row );
char *token;
token = strtok( s, "\t" );
while ( token )
{
row_v.push_back( std::string( token ) );
token = strtok ( NULL, "\t" );
}
if ( row_v.size() != cols.size() )
return false;
// see if nodes are number or std::string,
// if it is std::string, we need to find the actual value in database
for ( int i = 0; i < 2; i++ )
{
if ( node[i]->func != OP_COLNAME && node[i]->func != OP_NUMBER )
{
ops[i] = arithmetic( node[i], header, row );
}
else if ( node[i]->func == OP_NUMBER )
{
ops[i] = node[i]->values[0].num;
}
else if ( node[i]->func == OP_COLNAME )
{
int pos = get_col_pos( std::string( node[i]->values[0].name ), header );
if ( pos < 0 )
{
std::cout << "column does not exist!" << std::endl;
return false;
}
ops[i] = atoi( row_v[pos].c_str() );
}
}
// start comparison
switch( ep->func ){
case OP_EQUAL: return ops[0] == ops[1]; break;
case OP_NOTEQ: return ops[0] != ops[1]; break;
case OP_LEQ: return ops[0] <= ops[1]; break;
case OP_GEQ: return ops[0] >= ops[1]; break;
case OP_LT: return ops[0] < ops[1]; break;
case OP_GT: return ops[0] > ops[1]; break;
default :
std::cout << "OPERATOR NOT SUPPORTED! " << std::endl;
return false;
break;
}
}
bool string_comparison( expression * ep, std::string header, std::string row )
{
//cout << "here " << std::endl;
if ( !ep )
return false;
std::vector<std::string> cols = tokenize_string( header, "\t" );
//cout << "what?" << std::endl;
expression* node[2];
node[0] = ep->values[0].ep;
node[1] = ep->values[1].ep;
std::string ops[2];
std::vector<std::string> row_v;
char *s = toChars( row );
char *token;
token = strtok( s, "\t" );
while ( token )
{
row_v.push_back( std::string( token ) );
token = strtok ( NULL, "\t" );
}
if ( row_v.size() != cols.size() )
return false;
// see if nodes are number or std::string,
// if it is std::string, we need to find the actual value in database
for ( int i = 0; i < 2; i++ )
{
if ( node[i]->func == OP_STRING )
{
ops[i] = std::string( node[i]->values[0].data );
//cout << "!" << ops[i] << std::endl;
}
else if ( node[i]->func == OP_COLNAME )
{
//cout << node[i]->values[i].name << std::endl;
int pos = get_col_pos( node[i]->values[i].name, header );
if ( pos < 0 )
{
std::cout << "column does not exist!" << std::endl;
return false;
}
ops[i] = std::string( row_v[pos] );
}
}
switch( ep->func ){
case OP_EQUAL: return (ops[0].compare( ops[1] ) == 0 ); break;
case OP_NOTEQ: return (ops[0].compare( ops[1] ) != 0 ); break;
case OP_LEQ: return (ops[0].compare( ops[1] ) <= 0 ); break;
case OP_GEQ: return (ops[0].compare( ops[1] ) >= 0 ); break;
case OP_LT: return (ops[0].compare( ops[1] ) < 0 ); break;
case OP_GT: return (ops[0].compare( ops[1] ) > 0 ); break;
default :
std::cout << "OPERATOR ON std::string NOT SUPPORTED! " << std::endl;
return false;
break;
}
}
