Main Page   Alphabetical List   Compound List   File List   Compound Members   File Members   Related Pages  

policy-build.c

Go to the documentation of this file.
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 /* processing rules */
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 /* input rules */
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 /* inits */
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 }

Generated at Mon Jul 8 15:16:50 2002 for RUBICON by doxygen1.2.1 written by Dimitri van Heesch, © 1997-2000