Back to index

lightning-sunbird  0.9+nobinonly
Functions | Variables
testmime.c File Reference
#include "ical.h"
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

Go to the source code of this file.

Functions

char * read_stream (char *s, size_t size, void *d)
int main (int argc, char *argv[])

Variables

char * major_type_string []
char * minor_type_string []

Function Documentation

int main ( int  argc,
char *  argv[] 
)

Definition at line 89 of file testmime.c.

                                 {

    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;
       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){
       sleep(opt.sleep);
    }

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

    icalmemory_free_ring();

    return 0;

}

Here is the call graph for this function:

char* read_stream ( char *  s,
size_t  size,
void d 
)

Definition at line 80 of file testmime.c.

{
    char *c = fgets(s,size, (FILE*)d);

    return c;

}

Here is the call graph for this function:


Variable Documentation

Initial value:
 {
    "TEXT",
    "IMAGE",
    "AUDIO",
    "VIDEO",
    "APPLICATION",
    "MULTIPART",
    "MESSAGE",
    "UNKNOWN",
    "NO"
}

Definition at line 53 of file testmime.c.

Initial value:
 {
    "ANY",
    "PLAIN",
    "RFC822",
    "DIGEST",
    "CALENDAR",
    "MIXED",
    "RELATED",
    "ALTERNATIVE",
    "PARALLEL",
    "UNKNOWN",
    "NO"
}

Definition at line 65 of file testmime.c.