commit of partial code about BLKTYP

diff --git a/app/scanner.c b/app/scanner.c
index f307413b23eb5d14e9823cbf6c7070f5bb563863..0723ba7c99c6d28323472bd3095e8674f4bcf104 100644 (file)
--- a/app/scanner.c
+++ b/app/scanner.c
@@ -40,7 +40,7 @@ typedef struct  {
 /*      remote ip credibility.                          */
 /*                                                     */
 /********************************************************/
-static void check_credibility(SCATYP *scanref,char **dnsbls,int num,char *rmtip)
+static void check_credibility(SCATYP *scanref,BLKTYP **dnsblk,int num,char *rmtip)
 
 {
 #define OPEP    "scanner.c:check_credibilty,"
@@ -80,14 +80,14 @@ while (proceed==true) {
     case 3      :       //updating record according blacklisting
       srv->credit=0;
       srv->lastscan=time((time_t *)0);
-      if (dnsbls!=(char **)0) {
-        while (*dnsbls!=(char *)0) {
+      if (dnsblk!=(BLKTYP **)0) {
+        while (*dnsblk!=(BLKTYP *)0) {
           char *report;
           char *listed;
           char cst[100];
 
           report=(char *)0;
-          listed=dns_is_blacklisted(*dnsbls,reversip);
+          listed=dns_is_blacklisted(*dnsblk,reversip);
           (void) snprintf(cst,sizeof(cst),"IP[%02d]: %s\t",num,rmtip);
           if (listed!=(char *)0) {
             (void) rou_asprintf(&report,"%s%s",cst,listed);
@@ -96,11 +96,12 @@ while (proceed==true) {
               srv->listing=strdup(listed);
             }
           else
-            (void) rou_asprintf(&report,"%s%s -> NOT listed",cst,*dnsbls);
+            (void) rou_asprintf(&report,"%s%s -> NOT listed",cst,
+                                                             (*dnsblk)->sitename);
           (void) log_fprintlog(scanref->logptr,true,report); 
           report=rou_freestr(report);
           listed=rou_freestr(listed);
-          dnsbls++;
+          dnsblk++;
           }
         (void) log_fprintlog(scanref->logptr,true,"IP[%02d]: %s\tRVS='%s'\tCurrent "
                                                   "credit='%3d'",
@@ -136,20 +137,20 @@ afn=afn_freeipnum(afn);
 /*      remote ip credibility.                          */
 /*                                                     */
 /********************************************************/
-static char **load_dnsbls()
+static BLKTYP **load_dnsbls()
 
 {
 #define OPEP    "scanner.c:load_dnsbls,"
 
 const char *blcklist="BLACKLISTER";
 
-char **dnsbls;
+BLKTYP **dnsblk;
 FILE *blkfile;
 const char *filename;
 int phase;
 _Bool proceed;
 
-dnsbls=(char **)0;
+dnsblk=(BLKTYP **)0;
 blkfile=(FILE *)0;
 phase=0;
 proceed=true;
@@ -181,9 +182,7 @@ while (proceed==true) {
 
         while (fgets(line,sizeof(line)-1,blkfile)!=(char *)0) {
           (void) rou_clean_conf_line(line);
-          if (strlen(line)>0) {
-            dnsbls=(char **)rou_addlist((void **)dnsbls,(void *)strdup(line)); 
-            }
+          dnsblk=dns_addblklist(dnsblk,line);
           }
         (void) fclose(blkfile);
         }
@@ -194,7 +193,7 @@ while (proceed==true) {
     }
   phase++;
   }
-return dnsbls;
+return dnsblk;
 
 #undef  OPEP
 }
@@ -214,7 +213,7 @@ static void doscanning(int frequency)
 
 unsigned long cycle;
 SCATYP scanref;
-char **dnsbls;
+BLKTYP **dnsblk;
 char **rmtip;
 int delay;
 int phase;
@@ -222,13 +221,13 @@ _Bool proceed;
 
 cycle=0;
 (void) memset(&scanref,'\000',sizeof(scanref));
-dnsbls=load_dnsbls();
+dnsblk=load_dnsbls();
 rmtip=(char **)0;
 delay=60;       //60 second sleeping time
 if (debug>0)
   delay/=10;
 phase=0;
-proceed=(dnsbls!=(char **)0);
+proceed=(dnsblk!=(BLKTYP **)0);
 while (proceed==true) {
   //(void) rou_alert(0,"JMPDBG %s phase='%d'",OPEP,phase);
   switch (phase) {
@@ -252,10 +251,10 @@ while (proceed==true) {
       break;
     case 3      :       //refreshing the dnsbls list
       if ((cycle%100)==0) {
-        dnsbls=(char **)rou_freelist((void **)dnsbls,(genfree_t)rou_freestr);
-        dnsbls=load_dnsbls();
+        dnsblk=(BLKTYP **)rou_freelist((void **)dnsblk,(genfree_t)dns_freeblk);
+        dnsblk=load_dnsbls();
         }
-      proceed=(dnsbls!=(char **)0);
+      proceed=(dnsblk!=(BLKTYP **)0);
       break;
     case 4      :       //opening database
       if ((scanref.sqlptr=sql_opensql())==(SQLPTR *)0) {
@@ -287,7 +286,7 @@ while (proceed==true) {
       break;
     case 7      :       //check entries
       for (int i=0;rmtip[i]!=(char *)0;i++) {
-        (void) check_credibility(&scanref,dnsbls,i+1,rmtip[i]);
+        (void) check_credibility(&scanref,dnsblk,i+1,rmtip[i]);
         if ((hangup==true)||((reload==true))) 
           break;        //No need to check other remote
         }
@@ -306,7 +305,7 @@ while (proceed==true) {
     }
   phase++;
   }
-dnsbls=(char **)rou_freelist((void **)dnsbls,(genfree_t)rou_freestr);
+dnsblk=(BLKTYP **)rou_freelist((void **)dnsblk,(genfree_t)dns_freeblk);
 
 #undef  OPEP
 }

diff --git a/lib/unidns.c b/lib/unidns.c
index a8af0703a8d83bc18c164a634d77259df9cb2a23..366c36571e8ce578d6384fe7d7795145bf7c58d8 100644 (file)
--- a/lib/unidns.c
+++ b/lib/unidns.c
@@ -308,6 +308,63 @@ return iplist;
 */
 /********************************************************/
 /*                                                      */
+/*     Procedure to free memory used by BLKTYP entry   */
+/*                                                      */
+/********************************************************/
+PUBLIC BLKTYP *dns_freeblk(BLKTYP *blk)
+
+{
+if (blk!=(BLKTYP *)0) {
+  blk->sitename=rou_freestr(blk->sitename);
+  blk->target=rou_freestr(blk->target);
+  (void) free(blk);
+  blk=(BLKTYP *)0;
+  }
+return blk;
+}
+/*
+^L
+*/
+/********************************************************/
+/*                                                      */
+/*     Procedure to add and entry with the list of     */
+/*      blacklist site.                                 */
+/*                                                      */
+/********************************************************/
+PUBLIC BLKTYP **dns_addblklist(BLKTYP **blklist,char *entry)
+
+
+{
+#define OPEP    "unidns.c:dns_addblklist,"
+
+if ((entry!=(char *)0)&&(strlen(entry)>0)) {
+  int delta;
+  char target[300];
+  char sitename[300];
+
+  (void) memset(target,'\000',sizeof(target));
+  (void) memset(sitename,'\000',sizeof(sitename));
+  if (sscanf(entry,"%d %s %s",&delta,target,sitename)==3) {
+    BLKTYP *blk;
+
+    blk=calloc(1,sizeof(BLKTYP));
+    blk->delta=delta;
+    blk->target=strdup(target);
+    blk->sitename=strdup(sitename);
+    blklist=(BLKTYP **)rou_addlist((void **)blklist,(void *)blk);
+    }
+  else 
+    (void) rou_alert(0,"%s, entry wrong format <%s> (config?)",OPEP,entry);
+  }
+return blklist;
+
+#undef  OPEP
+}
+/*
+^L
+*/
+/********************************************************/
+/*                                                      */
 /*     Procedure to extract IPs from an hostname       */
 /*                                                      */
 /********************************************************/
@@ -624,7 +681,7 @@ return status;
 /*     remote IP and return a TXT if it is blacklisted.*/
 /*                                                     */
 /********************************************************/
-PUBLIC char *dns_is_blacklisted(char *blssite,char *reversip)
+PUBLIC char *dns_is_blacklisted(BLKTYP *blk,char *reversip)
 
 {
 #define OPEP    "unidns.c:dns_is_blacklisted,"
@@ -634,10 +691,25 @@ char **txt;
 char dnsquest[300];
 
 listed=(char *)0;
-(void) snprintf(dnsquest,sizeof(dnsquest),"%s.%s",reversip,blssite);
-//(void) rou_alert(0,"%s, JMPDBG checking <%s>",OPEP,dnsquest);
+(void) snprintf(dnsquest,sizeof(dnsquest),"%s.%s",reversip,blk->sitename);
+(void) rou_alert(0,"%s, JMPDBG checking <%s>",OPEP,dnsquest);
+if ((txt=gettxt(dnsquest,T_PTR,"TXT"))!=(char **)0) {
+  int num;
+  char **ptr;
+
+  num=0;
+  ptr=txt;
+  while (*ptr!=(char *)0) {
+    (void) rou_alert(0,"JMPDBG site <%s> got txt[%d]=<%s>",
+                        blk->sitename,num,*ptr);
+    num++;
+    ptr++;
+    }
+  (void) rou_asprintf(&listed,"IP %s -> %s",blk->sitename,txt[0]);
+  txt=(char **)rou_freelist((void **)txt,(genfree_t)rou_freestr);
+  }
 if ((txt=gettxt(dnsquest,T_TXT,"TXT"))!=(char **)0) {
-  (void) rou_asprintf(&listed,"%s -> %s",blssite,txt[0]);
+  (void) rou_asprintf(&listed,"%s -> %s",blk->sitename,txt[0]);
   txt=(char **)rou_freelist((void **)txt,(genfree_t)rou_freestr);
   }
 return listed;

diff --git a/lib/unidns.h b/lib/unidns.h
index 2f0b111f20c972fd474eb5a1337a59b04adb7ac0..10cb8bf70e16cc0d910034f4ad243d89d1ddbb75 100644 (file)
--- a/lib/unidns.h
+++ b/lib/unidns.h
@@ -19,6 +19,13 @@ typedef      struct  {
         char **mxip;    //MX IPNUM list
        }MXTYP;
 
+//defining a blacklist entrry
+typedef struct  {
+        int delta;      //black list delta value
+        char *target;   //listing entry;
+        char *sitename; //black lister domain entry
+        }BLKTYP;
+
 typedef enum    {       //domain MX status
         dns_nomx,       //Domain without MX
         dns_local,      //Domain is local
@@ -26,13 +33,18 @@ typedef enum    {       //domain MX status
         dns_unknown     //Unknow domain status.
         }LOCTYP;
 
+//procedure to free on blklist entry
+extern BLKTYP *dns_freeblk(BLKTYP *blk);
+
+extern BLKTYP **dns_addblklist(BLKTYP **blklist,char *entry);
+
 //Procedure to get a list of IP related to a hostname
 extern char **dns_get_ip_list(char *hostname);
 
 //Procedure to get ONE SPF entry within domain dns
 extern char *dns_getspf(char *domain);
 
-//procedure to free un list de MX related to domain
+//procedure to free a list of MX related to domain
 extern MXTYP **dns_freemxlist(MXTYP **mxlist);
 
 //procedure to get a list of MX IP releated to a specific
@@ -48,7 +60,7 @@ extern _Bool dns_matchiprec(char *hostname,AFNTYP *afnnum,int mask);
 extern LOCTYP dns_is_domain_local(const char *domain,AFNTYP **afns);
 
 //procedure returning a string if remote IP si blacklisted
-extern char *dns_is_blacklisted(char *blssite,char *reversip);
+extern char *dns_is_blacklisted(BLKTYP *blk,char *reversip);
 
 //procedure returning the IP reverss address as a string 
 extern char *dns_get_reverse_addr(char *reversip);