/xmlbench/trunk

To get this branch, use:
bzr branch http://darksoft.org/webbzr/xmlbench/trunk

« back to all changes in this revision

Viewing changes to security/tools.h

  • Committer: Suren A. Chilingaryan
  • Date: 2009-02-16 09:27:17 UTC
  • Revision ID: csa@dside.dyndns.org-20090216092717-wipyvaaw2srxhgns
Initial import

Show diffs side-by-side

added added

removed removed

Lines of Context:
security/tools.h
 
1
#include <stdlib.h>
 
2
#include <unistd.h>
 
3
#include <sys/types.h>
 
4
#include <sys/stat.h>
 
5
 
 
6
#include "../tools/disp2.h"
 
7
#include "../xmlgen/xmlgen.h"
 
8
#include "../xmlgen/opcgen.h"
 
9
 
 
10
struct TestData {
 
11
    unsigned long iterations;
 
12
    
 
13
    char *fn;
 
14
    char *xml;
 
15
    unsigned long xmllen;
 
16
    unsigned long size;
 
17
};
 
18
 
 
19
char *ReadFile(char *fn) {
 
20
    FILE *f;
 
21
    struct stat st;
 
22
    char *buf;
 
23
    
 
24
    f=fopen(fn,"r");
 
25
    if (!f) {
 
26
        printf("Can't open XML file!\n");
 
27
        exit(1);
 
28
    }
 
29
    fstat(f->_fileno,&st);
 
30
    buf=(char*)malloc(st.st_size+1+sizeof(unsigned long));
 
31
    if (!buf) {
 
32
        printf("Can't allocate memory!\n");
 
33
        exit(1);
 
34
    }
 
35
    ((unsigned long*)buf)[0]=st.st_size;
 
36
    fread(buf+sizeof(unsigned long),st.st_size,1,f);
 
37
    fclose(f);
 
38
    buf[st.st_size+sizeof(unsigned long)]=0;
 
39
    return buf;
 
40
}
 
41
 
 
42
void ReadConfig(struct TestData *td) {
 
43
    FILE *f;
 
44
    f=fopen("config","r");
 
45
    if (!f) {
 
46
        printf("Error opening config file!\n");
 
47
        exit(1);
 
48
    }
 
49
    fscanf(f,"%lu",&(td->iterations));
 
50
    fclose(f);
 
51
}
 
52
 
 
53
void parseXML(struct TestData *td, unsigned long iter);
 
54
void signXML(struct TestData *td, unsigned long iter);
 
55
void verifyXML(struct TestData *td, unsigned long iter);
 
56
void encryptXML(struct TestData *td, unsigned long iter);
 
57
void decryptXML(struct TestData *td, unsigned long iter);
 
58
void initXML(struct TestData *td);
 
59
void initXML_Security(struct TestData *td);
 
60
void releaseXML(struct TestData *td);
 
61
 
 
62
 
 
63
void Usage(char *myname) {
 
64
    printf("Usage:\n\t%s <iterations> [<xml file>|xmlgen|opcgen] [<size>]\n",myname);
 
65
    exit(0);
 
66
}
 
67
 
 
68
 
 
69
int Test(int argc, char *argv[]) {
 
70
    int i,j;
 
71
    struct timeval pre_time,post_time;
 
72
    struct timezone tz;
 
73
    unsigned long init_time,init_time2,time;
 
74
    double init_dtime,init_d;
 
75
    unsigned long parse_s;
 
76
    double parse_m,parse_d;
 
77
    unsigned char mode=0;       /* 0 - file, 1 - xmlgen, 2 - opcgen */
 
78
    struct TestData td;
 
79
    char *xmlbuf,*xsdbuf;
 
80
    disp ds,de;
 
81
 
 
82
    if ((argc<3)||(argc>4)) Usage(argv[0]);
 
83
 
 
84
    td.iterations = atol(argv[1]);
 
85
    if (td.iterations<=0) Usage(argv[0]);
 
86
    
 
87
    if (!strncmp(argv[2],"xmlgen",6)) mode=1;
 
88
    else if (!strncmp(argv[2],"opcgen",6)) mode=2;
 
89
    td.fn=argv[2];
 
90
 
 
91
    if (mode) {
 
92
        td.size = atol(argv[3]);
 
93
        if (td.size<=0) Usage(argv[0]);
 
94
        
 
95
        rnd_init();     /* Initialising Random Generator */
 
96
    }
 
97
 
 
98
    switch (mode) {
 
99
        case 0:
 
100
            xmlbuf=ReadFile(argv[2]);
 
101
            if (!xmlbuf) {
 
102
                fprintf(stderr,"Can't read XML file!\n");
 
103
                exit(0);
 
104
            }
 
105
            td.xml=xmlbuf+sizeof(unsigned long);
 
106
            td.xmllen=((unsigned long*)xmlbuf)[0];
 
107
        break;
 
108
        case 1:
 
109
            xmlbuf=xmlgen_init(td.size);
 
110
            td.xml=xmlbuf;
 
111
            td.xmllen=xmlgen();
 
112
        break;
 
113
        case 2:
 
114
            xmlbuf=opcgen_init(td.size);
 
115
            td.xml=xmlbuf;
 
116
            td.xmllen=opcgen();
 
117
        break;
 
118
    }
 
119
 
 
120
    initXML(&td);
 
121
    parseXML(&td,0);
 
122
 
 
123
    gettimeofday(&pre_time,NULL);
 
124
    initXML_Security(&td);
 
125
    gettimeofday(&post_time,NULL);
 
126
    init_time=(post_time.tv_sec-pre_time.tv_sec)*1000000+(post_time.tv_usec-pre_time.tv_usec);
 
127
 
 
128
    gettimeofday(&pre_time,NULL);
 
129
    encryptXML(&td,0);
 
130
    decryptXML(&td,0);
 
131
    signXML(&td,0);
 
132
    verifyXML(&td,0);
 
133
    gettimeofday(&post_time,NULL);
 
134
    init_time2=(post_time.tv_sec-pre_time.tv_sec)*1000000+(post_time.tv_usec-pre_time.tv_usec);
 
135
    
 
136
    ds=disp_init();
 
137
    de=disp_init();
 
138
    for (i=1;i<=td.iterations;i++) {
 
139
        switch (mode) {
 
140
            case 1:
 
141
                td.xmllen=xmlgen();
 
142
            break;
 
143
            case 2:
 
144
                td.xmllen=opcgen();
 
145
            break;
 
146
        }
 
147
        parseXML(&td,i);
 
148
        gettimeofday(&pre_time,NULL);
 
149
        encryptXML(&td,i);
 
150
        decryptXML(&td,i);
 
151
        gettimeofday(&post_time,NULL);
 
152
        time=(post_time.tv_sec-pre_time.tv_sec)*1000000+(post_time.tv_usec-pre_time.tv_usec);
 
153
        disp_event(de,time);
 
154
//      printf("%lu, ",time);
 
155
 
 
156
        gettimeofday(&pre_time,NULL);
 
157
        signXML(&td,i);
 
158
        verifyXML(&td,i);
 
159
        gettimeofday(&post_time,NULL);
 
160
        time=(post_time.tv_sec-pre_time.tv_sec)*1000000+(post_time.tv_usec-pre_time.tv_usec);
 
161
        disp_event(ds,time);
 
162
 
 
163
//      printf("%lu\n",time);
 
164
    }
 
165
    disp_post(de);
 
166
    disp_post(ds);
 
167
 
 
168
    releaseXML(&td);
 
169
    
 
170
    switch (mode) {
 
171
        case 0:
 
172
            free(xmlbuf);
 
173
        break;
 
174
        case 1:
 
175
            xmlgen_deinit();
 
176
        break;
 
177
        case 2:
 
178
            opcgen_deinit();
 
179
        break;
 
180
    }
 
181
 
 
182
    if (mode==2) {
 
183
        printf("Signing/Verifying Time %lf ms for %lu messages\n", ((double)(ds->disp_s)) / 1000,td.iterations);
 
184
        printf("Encrypting/Decrypting Time %lf ms for %lu messages\n", ((double)(de->disp_s)) / 1000,td.iterations);
 
185
    } else {
 
186
        init_dtime=(init_time2 - ds->disp_m - de->disp_m);
 
187
        if (init_dtime<10) {
 
188
            init_d=0;
 
189
            init_dtime=0;
 
190
        } else {
 
191
            init_d=300 * (de->disp_d+ds->disp_d) / init_dtime;
 
192
            init_dtime/=1000;
 
193
        }
 
194
        printf("Initialisation time %.3lf + %.3lf(%.2lf%) ms\n",(1. * init_time) / 1000, init_dtime, init_d);
 
195
        printf("Signing/Verifying Time %.3lf(%.2lf%) ms\n", (ds->disp_m) / 1000, ds->disp_m ? 300*(ds->disp_d)/(ds->disp_m) : 0);       
 
196
        printf("Encrypting/Decrypting Time %.3lf(%.2lf%) ms\n", (de->disp_m) / 1000, de->disp_m ? 300*(de->disp_d)/(de->disp_m) : 0);
 
197
    }
 
198
    return 0;
 
199
}
 
200