00001
00002
00010
00011
00012 #include "policy-build.h"
00013 #include "memory.h"
00014 #include "protocols.h"
00015 #include <stdio.h>
00016
00017 #ifndef DEBUG_POLICY_BUILD
00018 #ifdef DEBUG
00019 #define DEBUG_POLICY_BUILD DEBUG
00020 #else
00021 #define DEBUG_POLICY_BUILD 0
00022 #endif
00023 #endif
00024
00025 POLICY_HEAD *newPolicy(void){
00026 POLICY_HEAD *ret;
00027 if(DEBUG_POLICY_BUILD>=DEBUG_DO_ENTRY_SOME){
00028 printf("Enter newPolicy\n");
00029 }
00030 ret = (POLICY_HEAD*)malloc_safe(sizeof(POLICY_HEAD));
00031 if(ret){
00032 ret->top = (POLICY_PROTO*)0;
00033 ret->def = (POLICY_OUTPUT*)0;
00034 ret->inits = (POLICY_INITS*)0;
00035 ret->input = (POLICY_INPUT*)0;
00036 }
00037 else printf("ERR: malloc failed\n");
00038
00039 return ret;
00040 }
00041
00042
00043 POLICY_TEST *createBlankTest(void){
00044 POLICY_TEST *ret;
00045 if(DEBUG_POLICY_BUILD>=DEBUG_DO_ENTRY_SOME){
00046 printf("Enter createBlankTest\n");
00047 }
00048 ret = (POLICY_TEST*)malloc_safe(sizeof(POLICY_TEST));
00049 if(ret){
00050 ret->test_type = POLICY_TEST_TYPE_MASKED;
00051 ret->p_num = PROTO_ANY_NUM;
00052 ret->p_name = strdup_safe(PROTO_ANY_NAME);
00053 ret->m_val = (BYTE*)0;
00054 ret->m_mask = (BYTE*)0;
00055 ret->m_offset = 0;
00056 ret->m_len = 0;
00057 ret->m_type = '=';
00058 ret->v_val = 0;
00059 ret->v_vType = POLICY_TEST_V_TYPE_U32;
00060 ret->v_tType = strdup_safe("==");
00061 ret->a_name = (char*)0;
00062 ret->a_args = (char*)0;
00063 ret->result = (POLICY_RESULT*)0;
00064 }
00065 else printf("ERR: malloc failed\n");
00066
00067 return ret;
00068 }
00069
00070 POLICY_TEST *createAnalysisTest(char *plug,char *arg, char*protoname, PROTO num){
00071 POLICY_TEST *ret;
00072 if(DEBUG_POLICY_BUILD>=DEBUG_DO_ENTRY_SOME){
00073 printf("Enter createAnalysisTest(char*plug(%s),char*arg(%s))\n",plug,arg);
00074 }
00075 ret = (POLICY_TEST*)malloc_safe(sizeof(POLICY_TEST));
00076 if(ret){
00077 ret->p_num = num;
00078 ret->p_name = strdup_safe(protoname);
00079 ret->test_type = POLICY_TEST_TYPE_ANALYSIS;
00080 ret->a_name = strdup_safe(plug);
00081 ret->a_args = strdup_safe(arg);
00082 ret->result = (POLICY_RESULT*)0;
00083 }
00084 else printf("ERR: malloc failed\n");
00085
00086 return ret;
00087 }
00088
00089 POLICY_TEST *createDefaultTest(void){
00090 return createBlankTest();
00091 }
00092
00093 POLICY_TEST *attachTestToResult(POLICY_RESULT *r,POLICY_TEST *t){
00094 POLICY_OUTPUT *o;
00095 if(DEBUG_POLICY_BUILD>=DEBUG_DO_ENTRY_SOME){
00096 printf("Enter attachTestToResult(POLICY_RESULT*r(%p),POLICY_TEST*t(%p))\n",r,t);
00097 }
00098 if(!r || !t) return (POLICY_TEST*)0;
00099 o = addOutputToResult(r,(char*)0,(char*)0,(char)0);
00100 if(!o) return (POLICY_TEST*)0;
00101 return attachTestToOutput(o,t);
00102 }
00103
00104 POLICY_TEST *attachTestToProto(POLICY_PROTO *p,POLICY_TEST *t){
00105 if(DEBUG_POLICY_BUILD>=DEBUG_DO_ENTRY_SOME){
00106 printf("Enter attachTestToProto(POLICY_PROTO*p(%p),POLICY_TEST*t(%p))\n",p,t);
00107 }
00108 if(!p || !t) return (POLICY_TEST*)0;
00109
00110 if(p->test){
00111 return (POLICY_TEST*)0;
00112 }
00113 else p->test = t;
00114
00115 return t;
00116 }
00117
00118 POLICY_TEST *attachTestToOutput(POLICY_OUTPUT *o,POLICY_TEST *t){
00119 POLICY_OUTPUT *oo;
00120 if(DEBUG_POLICY_BUILD>=DEBUG_DO_ENTRY_SOME){
00121 printf("Enter attachTestToOutput(POLICY_OUTPUT*o(%p),POLICY_TEST*t(%p))\n",o,t);
00122 }
00123 if(!o || !t) return (POLICY_TEST*)0;
00124 oo = o;
00125 while(oo->tNext){
00126 if(!(oo->oNext)){
00127 oo->oNext = (POLICY_OUTPUT*)malloc_safe(sizeof(POLICY_OUTPUT));
00128 if(!(oo->oNext)){
00129 printf("ERR: malloc failed\n");
00130 return (POLICY_TEST*)0;
00131 }
00132 oo->oNext->name = (char*)0;
00133 oo->oNext->args = (char*)0;
00134 oo->oNext->oNext = (POLICY_OUTPUT*)0;
00135 oo->oNext->tNext = (POLICY_TEST*)0;
00136 }
00137 oo = oo->oNext;
00138 }
00139 oo->tNext = t;
00140 return t;
00141 }
00142
00143 POLICY_TEST *attachTestToPolicy(POLICY_HEAD *h,POLICY_TEST *t){
00144 POLICY_PROTO *p;
00145 if(DEBUG_POLICY_BUILD>=DEBUG_DO_ENTRY_SOME){
00146 printf("Enter attachTestToPolicy(POLICY_HEAD*h(%p),POLICY_TEST*t(%p))\n",h,t);
00147 }
00148 if(!h || !t) return (POLICY_TEST*)0;
00149 p = addProtoToPolicy(h,t->p_num, t->p_name);
00150 return attachTestToProto(p,t);
00151 }
00152
00153 POLICY_PROTO *addProtoToPolicy(POLICY_HEAD *h,PROTO num,char *name){
00154 POLICY_PROTO *p;
00155 if(DEBUG_POLICY_BUILD>=DEBUG_DO_ENTRY_SOME){
00156 printf("Enter addProtoToPolicy(POLICY_HEAD*h(%p),PROTO num(%lx),char*name(%s))\n",h,num,name);
00157 }
00158
00159 if(h->top){
00160 p = h->top;
00161 while(p->next){
00162 if(p->proto_num == num){
00163 return p;
00164 }
00165 p = p->next;
00166 }
00167 if(p->proto_num == num){
00168 return p;
00169 }
00170 p->next = (POLICY_PROTO*)malloc_safe(sizeof(POLICY_PROTO));
00171 if(!p->next){
00172 printf("ERR: malloc failed\n");
00173 return (POLICY_PROTO*)0;
00174 }
00175 p = p->next;
00176 }
00177 else {
00178 h->top = (POLICY_PROTO*)malloc_safe(sizeof(POLICY_PROTO));
00179 if(!h->top){
00180 printf("ERR: malloc failed\n");
00181 return (POLICY_PROTO*)0;
00182 }
00183 p = h->top;
00184 }
00185 p->proto_num = num;
00186 p->proto_name = strdup_safe(name);
00187 p->test = (POLICY_TEST*)0;
00188 p->next = (POLICY_PROTO*)0;
00189 return p;
00190 }
00191
00192 POLICY_RESULT *addResultToTest(POLICY_TEST *t,char *sRes, unsigned short iRes){
00193 POLICY_RESULT *r;
00194 if(DEBUG_POLICY_BUILD>=DEBUG_DO_ENTRY_SOME){
00195 printf("Enter addResultToTest(POLICY_TEST*t(%p),char*sRes(%s),ushort iRes(%hu))\n",t,sRes,iRes);
00196 }
00197 if(!t) return (POLICY_RESULT*)0;
00198 r = t->result;
00199 if(!r){
00200 r = (POLICY_RESULT*)malloc_safe(sizeof(POLICY_RESULT));
00201 if(!r){
00202 printf("ERR: malloc failed\n");
00203 return (POLICY_RESULT*)0;
00204 }
00205 if(sRes) r->sResult = strdup_safe(sRes);
00206 else r->sResult = (char*)0;
00207 r->iResult = iRes;
00208 r->next = (POLICY_RESULT*)0;
00209 r->match = (POLICY_OUTPUT*)0;
00210 return r;
00211 }
00212 while(r){
00213 if(r->iResult==iRes){
00214 if(r->sResult==sRes) return r;
00215 else if(r->sResult && sRes){
00216 if(!strcmp(sRes, r->sResult)) return r;
00217 }
00218 }
00219 if(!(r->next)){
00220 r->next = (POLICY_RESULT*)malloc_safe(sizeof(POLICY_RESULT));
00221 if(!(r->next)){
00222 printf("ERR: malloc failed\n");
00223 return (POLICY_RESULT*)0;
00224 }
00225 r = r->next;
00226 if(sRes) r->sResult = strdup_safe(sRes);
00227 else r->sResult = (char*)0;
00228 r->iResult = iRes;
00229 r->next = (POLICY_RESULT*)0;
00230 r->match = (POLICY_OUTPUT*)0;
00231 return r;
00232 }
00233 r = r->next;
00234 }
00235
00236 return (POLICY_RESULT*)0;
00237 }
00238
00239 POLICY_OUTPUT *addOutputToResult(POLICY_RESULT *r,char *name,char *arg, char eof){
00240 POLICY_OUTPUT *o;
00241 if(DEBUG_POLICY_BUILD>=DEBUG_DO_ENTRY_SOME){
00242 printf("Enter addOutputToResult(POLICY_RESULT*r(%p),char*name(%s),char*arg(%s))\n",r,name,arg);
00243 }
00244 if(!r) return (POLICY_OUTPUT*)0;
00245 if(r->match){
00246 o = r->match;
00247 while(o->oNext){
00248 o = o->oNext;
00249 }
00250 o->oNext = (POLICY_OUTPUT*)malloc_safe(sizeof(POLICY_OUTPUT));
00251 o = o->oNext;
00252 }
00253 else{
00254 r->match = (POLICY_OUTPUT*)malloc_safe(sizeof(POLICY_OUTPUT));
00255 o = r->match;
00256 }
00257 if(o){
00258 if(name) o->name = strdup_safe(name);
00259 else o->name = (char*)0;
00260 if(arg) o->args = strdup_safe(arg);
00261 else o->args = (char*)0;
00262 o->eof = eof;
00263 o->oNext = (POLICY_OUTPUT*)0;
00264 o->tNext = (POLICY_TEST*)0;
00265 }
00266 else {
00267 printf("ERR: malloc failed\n");
00268 }
00269
00270 return o;
00271 }
00272 POLICY_OUTPUT *addOutputToOutput(POLICY_OUTPUT *oo,char *name,char *arg, char eof){
00273 POLICY_OUTPUT *o;
00274 if(DEBUG_POLICY_BUILD>=DEBUG_DO_ENTRY_SOME){
00275 printf("Enter addOutputToOutput(POLICY_OUTPUT*oo(%p),char*name(%s),char*arg(%s),char eof(%hhd))\n",oo,name,arg,eof);
00276 }
00277 if(!oo) return (POLICY_OUTPUT*)0;
00278
00279 o = oo;
00280 while(o->oNext){
00281 o = o->oNext;
00282 }
00283 o->oNext = (POLICY_OUTPUT*)malloc_safe(sizeof(POLICY_OUTPUT));
00284 o = o->oNext;
00285
00286 if(o){
00287 if(name) o->name = strdup(name);
00288 else o->name = (char*)0;
00289 if(arg) o->args = strdup_safe(arg);
00290 else o->args = (char*)0;
00291 o->eof = eof;
00292 o->oNext = (POLICY_OUTPUT*)0;
00293 o->tNext = (POLICY_TEST*)0;
00294 }
00295 else {
00296 printf("ERR: malloc failed\n");
00297 }
00298
00299 return o;
00300 }
00301
00302
00303 POLICY_HEAD *addInputToPolicy(POLICY_HEAD *h,char *name, unsigned short weight,char *sSrc, int iSrc){
00304 POLICY_INPUT *i;
00305 if(DEBUG_POLICY_BUILD>=DEBUG_DO_ENTRY_SOME){
00306 printf("Enter addInputToPolicy(POLICY_HEAD*h(%p),char*name(%s),ushort weight(%hu),char*sSrc(%s),int iSrc(%d))\n",h,name,weight,sSrc,iSrc);
00307 }
00308 if(!h || !name) return (POLICY_HEAD*)0;
00309
00310 if(h->input){
00311 i = h->input;
00312 while(i->next){
00313 if(!strcmp(i->plugname, name) && i->weight==weight && i->iSrc==iSrc){
00314 if(sSrc==i->sSrc) return h;
00315 else if(sSrc && i->sSrc){
00316 if(!strcmp(sSrc, i->sSrc)) return h;
00317 }
00318 }
00319 i = i->next;
00320 }
00321 if(!strcmp(i->plugname, name) && i->weight==weight && i->iSrc==iSrc){
00322 if(sSrc==i->sSrc) return h;
00323 else if(sSrc && i->sSrc){
00324 if(!strcmp(sSrc, i->sSrc)) return h;
00325 }
00326 }
00327 i->next = (POLICY_INPUT*)malloc_safe(sizeof(POLICY_INPUT));
00328 i = i->next;
00329 }
00330 else {
00331 h->input = (POLICY_INPUT*)malloc_safe(sizeof(POLICY_INPUT));
00332 i = h->input;
00333 }
00334 if(i){
00335 i->plugname = strdup_safe(name);
00336 i->weight = weight;
00337 i->sSrc = strdup_safe(sSrc);
00338 i->iSrc = iSrc;
00339 return h;
00340 }
00341 else {
00342 printf("ERR: malloc failed\n");
00343 }
00344 return 0;
00345 }
00346
00347
00348 POLICY_HEAD *addInitToPolicy(POLICY_HEAD *h,char *name,char *init){
00349 POLICY_INITS *i;
00350 unsigned int u;
00351 if(DEBUG_POLICY_BUILD>=DEBUG_DO_ENTRY_SOME){
00352 printf("Enter addInitToPolicy(POLICY_HEAD*h(%p),char*name(%s),char*init(%s)\n",h,name,init);
00353 }
00354 if(!h || !name || !init) return (POLICY_HEAD*)0;
00355 if(h->inits){
00356 i = h->inits;
00357 while(i->next){
00358 if(!strcmp(name, i->plugname)) break;
00359 i = i->next;
00360 }
00361 if(!strcmp(name, i->plugname)){
00362 for(u=0;u<i->string_count;u++){
00363 if((i->init_string)[u]){
00364 if(!strcmp((i->init_string)[u],init)){
00365 return h;
00366 }
00367 }
00368 }
00369 }
00370 else {
00371 i->next = (POLICY_INITS*)malloc_safe(sizeof(POLICY_INITS));
00372 if(!i->next){
00373 printf("ERR: malloc failed\n");
00374 return (POLICY_HEAD*)0;
00375 }
00376 i = i->next;
00377 i->plugname = strdup_safe(name);
00378 i->space = 100;
00379 i->init_string = (char**)malloc_safe(sizeof(char*)*i->space);
00380 if(!i->init_string){
00381 printf("ERR: malloc failed\n");
00382 free_safe(i);
00383 return (POLICY_HEAD*)0;
00384 }
00385 i->string_count = 0;
00386 }
00387 if(i->space<=i->string_count){
00388 i->space+=100;
00389 i->init_string = (char**)realloc_safe(i->init_string, sizeof(char*)*i->space);
00390 if(!i->init_string){
00391 printf("ERR: malloc failed\n");
00392 return (POLICY_HEAD*)0;
00393 }
00394 }
00395 (i->init_string)[i->string_count] = strdup_safe(init);
00396 i->string_count++;
00397 }
00398 else {
00399 h->inits = (POLICY_INITS*)malloc_safe(sizeof(POLICY_INITS));
00400 if(!h->inits){
00401 printf("ERR: malloc failed\n");
00402 return (POLICY_HEAD*)0;
00403 }
00404 i = h->inits;
00405 i->plugname = strdup_safe(name);
00406 i->space = 100;
00407 i->init_string = (char**)malloc_safe(sizeof(char*)*i->space);
00408 if(!i->init_string){
00409 printf("ERR: malloc failed\n");
00410 free_safe(i);
00411 return (POLICY_HEAD*)0;
00412 }
00413 i->string_count = 1;
00414 (i->init_string)[0] = strdup_safe(init);
00415 return h;
00416 }
00417 return (POLICY_HEAD*)0;
00418 }