Beispiel #1
0
int main(int argc, char* argv[]) {

    FILE *f;
    int c;
    extern char *optarg;
    extern int optind, optopt;
    int errflg=0;
    char* program_name;

    struct options{
	    int normal;
	    int stress;
	    int base64;
	    int qp;
	    int sleep;
	    int count;
	    char* input_file;
    } opt;

    memset(&opt,0,sizeof(opt));
    
    program_name = (char*)strrchr((char*)argv[0],'/');
    program_name++;

    while ((c = getopt(argc, argv, "nsbqi:S:c:")) != -1) {
	switch (c) {
	    case 'i': { /* Input comes from named file */
		opt.input_file = strdup(optarg);
		break;
	    }
	    case 'n':{ /* Normal */

		if(opt.stress+opt.base64+opt.qp != 0){
		    fprintf(stderr,
			    "%s: Use only one of  n,s,b and q\n",
			    program_name);
		}
		opt.normal = 1;
		break;
	    }
	    case 's':{ /* Stress-test*/
		if(opt.base64+opt.normal+opt.qp != 0){
		    fprintf(stderr,
			    "%s: Use only one of  n,s,b and q\n",
			    program_name);
		}
		opt.stress = 1;
		break;
	    }
	    case 'b':{ /* test base64 decoding*/
		if(opt.stress+opt.normal+opt.qp != 0){
		    fprintf(stderr,
			    "%s: Use only one of  n,s,b and q\n",
			    program_name);
		}
		opt.base64 = 1;
		break;
	    }
	    case 'q':{ /* test quoted-printable decoding*/
		if(opt.stress+opt.base64+opt.normal != 0){
		    fprintf(stderr,
			    "%s: Use only one of  n,s,b and q\n",
			    program_name);
		}
		opt.qp = 1;
		break;
	    }
	    case 'S':{ /* sleep at end of run */
		opt.sleep = atoi(optarg);
		break;
	    }

	    case 'c':{ /* number of iterations of stress test */
		opt.count = atoi(optarg);
		break;
	    }
	    
	    case ':': {/* Option given without an operand */
		fprintf(stderr,
			"%s: Option -%c requires an operand\n", 
			program_name,optopt);
		errflg++;
		break;
	    }
	    case '?': {
		errflg++;
	    }
	}
    }
    
    if (errflg >0){
	fprintf(stderr,"Usage: %s [-n|-s|-b|-q] [-i input_file]\n",
		program_name);
	exit(1);
    }
    
    if(opt.stress+opt.base64+opt.normal+opt.qp == 0){
	fprintf(stderr,
		"%s: Must have one of n,s,b or q\n",
		program_name);
    }
    
    if(opt.input_file){
	f = fopen(opt.input_file,"r");
	if (f == 0){
	    fprintf(stderr,"Could not open input file \"%s\"\n",
		    opt.input_file);
	    exit(1);
	}
    } else {
	f = stdin;
    }
	
 	

    if(opt.normal == 1){
	icalcomponent *c;

	c = icalmime_parse(read_stream,f);
	
	printf("%s\n",icalcomponent_as_ical_string(c));

	icalcomponent_free(c);

    }  else if (opt.stress==1 ){
	/* Read file in by lines, then randomize the lines into a
           string buffer */

	char *array[1024];
	char temp[1024];
       	char *buf;
	int i,last;
	int size = 0;
	int non_rand;
	int rand_lines;
	int r;
	int j;
	icalcomponent *c;
	struct slg_data {
		char* pos;
		char* str;
	} d;
    
	for(i=0; !feof(f); i++){
	    fgets(temp,1024,f);
	    array[i] = strdup(temp);
	    size += strlen(temp);
	}
	last = i;
 
	buf = malloc(size*2);
	assert(buf != 0);
	

	for(j=0; j<opt.count; j++){

	    srand(j);
	    memset(buf,0,size*2);
	    /* First insert some non-randomized lines */
	    non_rand = ((float)rand()/(float)RAND_MAX) * last;
	    for(i=0;i<non_rand;i++){
		strcat(buf,array[i]);
	    }
	    
	    /* Then, insert some lines at random */
	    
	    rand_lines = last - non_rand;
	    
	    for(i=0;i<rand_lines;i++){
		srand(i);
		r = ((float)rand()/(float)RAND_MAX) * rand_lines;
		strcat(buf,array[r+non_rand]);
		
	    }

	    d.pos = 0;
	    d.str = buf;

	    c = icalmime_parse(icalparser_string_line_generator,&d);

	    printf("%s\n",icalcomponent_as_ical_string(c));

	    icalcomponent_free(c);
	    
	}

	free(buf);

	for(i=0; i<last; i++){
	    free(array[i]);
	}

    } else if(opt.qp == 1){	
	char str[4096];
	char conv[4096];
	
	memset(str,0,4096);
	
	while(!feof(f) && fgets(str,4096,f)!=0){
	    size_t size;
	    
	    size = strlen(str);
	    memset(conv,0,4096);
	    decode_quoted_printable(conv,str,&size);
	    
	    conv[size] = '\0';
	    printf("%s",conv);
	    memset(str,0,4096);
	    
	}
    } else if (opt.base64 == 1) {
	char str[4096];
	char conv[4096];
	
	memset(str,0,4096);
	
	while(!feof(f) && fgets(str,4096,f)!=0){
	    size_t size;
	    
	    size = strlen(str);
	    memset(conv,0,4096);
	    decode_base64(conv,str,&size);
	    
	    conv[size] = '\0';
	    printf("%s",conv);
	    memset(str,0,4096);
	    
	}
    }

    if (opt.sleep != 0){
#ifdef WIN32
        _sleep(opt.sleep*1000);
#else
	sleep(opt.sleep);
#endif
    }

    if(	opt.input_file != 0){
	free(opt.input_file);
    }

    icalmemory_free_ring();

    return 0;

}
Beispiel #2
0
int main(int argc, char *argv[])
{
    icalset *cin;
    struct icaltimetype next;
    icalcomponent *itr;
    icalproperty *desc, *dtstart, *rrule;
    struct icalrecurrencetype recur;
    icalrecur_iterator* ritr;
    time_t tt;
    char* file;

    icalerror_set_error_state(ICAL_PARSE_ERROR, ICAL_ERROR_NONFATAL);

#ifndef WIN32
    signal(SIGALRM,sig_alrm);
#endif

    if (argc <= 1) {
        file = "../../test-data/recur.txt";
    } else if (argc == 2) {
        file = argv[1];
    } else {
        fprintf(stderr,"usage: recur [input file]\n");
        exit(1);
    }

#ifndef WIN32
    alarm(300); /* to get file lock */
#endif
    cin = icalfileset_new(file);
#ifndef WIN32
    alarm(0);
#endif

    if(cin == 0) {
        fprintf(stderr,"recur: can't open file %s\n",file);
        exit(1);
    }


    for (itr = icalfileset_get_first_component(cin);
            itr != 0;
            itr = icalfileset_get_next_component(cin)) {

        struct icaltimetype start = icaltime_from_timet(1,0);
        struct icaltimetype end = icaltime_today();



        desc = icalcomponent_get_first_property(itr,ICAL_DESCRIPTION_PROPERTY);
        dtstart = icalcomponent_get_first_property(itr,ICAL_DTSTART_PROPERTY);
        rrule = icalcomponent_get_first_property(itr,ICAL_RRULE_PROPERTY);

        if (desc == 0 || dtstart == 0 || rrule == 0) {
            printf("\n******** Error in input component ********\n");
            printf("The following component is malformed:\n %s\n",
                   icalcomponent_as_ical_string(itr));
            continue;
        }

        printf("\n\n#### %s\n",icalproperty_get_description(desc));
        printf("#### %s\n",icalvalue_as_ical_string(icalproperty_get_value(rrule)));
        recur = icalproperty_get_rrule(rrule);
        start = icalproperty_get_dtstart(dtstart);

        ritr = icalrecur_iterator_new(recur,start);

        tt = icaltime_as_timet(start);

        printf("#### %s\n",ctime(&tt ));

        icalrecur_iterator_free(ritr);

        for(ritr = icalrecur_iterator_new(recur,start),
                next = icalrecur_iterator_next(ritr);
                !icaltime_is_null_time(next);
                next = icalrecur_iterator_next(ritr)) {

            tt = icaltime_as_timet(next);

            printf("  %s",ctime(&tt ));

        }
        icalrecur_iterator_free(ritr);

        icalcomponent_foreach_recurrence(itr, start, end,
                                         recur_callback, NULL);



    }

    icalset_free(cin);

    icaltimezone_free_builtin_timezones();

    icalmemory_free_ring();

    free_zone_directory();

    return 0;
}