Exemple #1
0
colog_matches_t match(const char *pattern, const char *source)
{
  colog_matches_t matches;
  int analyzed_length;
  char* extract = NULL;
  char* analyzed = xalloc((strlen(source) + 1) * sizeof(char));
  char* tmp;
  int cont = 1;

  matches.list = NULL;
  matches.length = 0;
  strcpy(analyzed, source);
  while (cont) {
    extract = execute_regex(pattern, analyzed);
    if (extract) {
      if (!in_array(extract, matches.list, matches.length)) {
        matches.list = xrealloc(matches.list, (matches.length + 1) * sizeof(char *));
        matches.list[matches.length] = xalloc((strlen(extract) + 1) * sizeof(char));
        strcpy(matches.list[matches.length], extract);
        matches.length++;
        tmp = str_replace(analyzed, extract, "");
        free(analyzed);
        analyzed = tmp;
      }
      free(extract);
    } else {
      cont = 0;
    }
  }
  free(analyzed);

  return matches;
}
Exemple #2
0
size_t get_file_size(char *haystack)
{

    size_t result = 0;
    int scanned = 0;
    char *match;

    match = execute_regex("size=(\\d+)", haystack, 1);

    scanned = sscanf(match, "%ld", &result);
    if (scanned != 1) {
	fprintf(stderr,
		"Regex Scanning Error. Probably a badly formatted ybegin line!\n");
	return 0;
    }


    free(match);

    return result;
}
Exemple #3
0
//compile and select the correct regex string depending on type.
int regex_string(char* source, char* dest, int type)
{
    regex_t reg;
    char* query;

    switch(type)
    {
        case DOMAIN: query = regtable[DOMAIN];
            break;
        case PROTOCOL: query = regtable[PROTOCOL];
            break;
    }

    printf ("Searching for '%s' in '%s'\n", query, source);

    if (regcomp(&reg, query, REG_EXTENDED|REG_NEWLINE) != 0)
        printf("Failed to compile %s", query);

    execute_regex(&reg, source, dest);
    regfree(&reg);
}
Exemple #4
0
int main(int argc, char *argv[])
{
    char *data_head = NULL;
    char *data_tail = NULL;
    char *data = NULL;
    char *output_data = NULL;
    int parse_result = 0;
    int output_data_length, intput_data_length;
    size_t file_size;
    char *file_name = NULL;
    FILE *fp;
    DWORD checksum;

    /* needs at least 1 argument! */
    if (argc < 2) {
	fprintf(stderr, "Too few arguments! usage: %s somefile.txt\n",
		argv[0]);
	return 1;
    }


    parse_result = parse_file(argv[1], &data_head, &data_tail,
			      &data, &intput_data_length);

    if (parse_result != 1)
	return parse_result;


    if (!data_head || !data_tail || !data) {
	fprintf(stderr, "Not a YEnc file!\n");
	return 1;
    }


    file_size = get_file_size(data_head);
    file_name = execute_regex("name=(\\S+)", data_head, 1);
    if (!file_name)
	file_name = "output.txt";

    output_data = (char *) malloc(file_size);
    decode(data, file_size, output_data, &output_data_length,
	   intput_data_length);

    fp = fopen(file_name, "wb");
    fwrite(output_data, 1, output_data_length, fp);

    checksum = crc32buf(output_data, output_data_length);
    fprintf(stderr, "Checksum: %x\n", checksum);



    fclose(fp);

    free(file_name);
    free(data_head);
    free(data_tail);
    free(data);


    return 0;

}