pppoem.c

适用于linux2.4版本内核的pppoe监控程序源代码

 return(1);
}


int Pppoem_poll_open(mon,flag)
struct PppoeM *mon;
int flag;
{
 int started= 0,linecount=0,ret= 0;
 char line[4096],filename[80],dummy[4096];
 FILE *fp= NULL;

 if(mon->is_open==2) {
   if(mon->dev_name[0]==0 || strcmp(mon->dev_name,"-")==0 ||
      mon->dev_automatic) {
     fprintf(stderr,"-pretend \"on\" needs -dev_name\n");
     return(-1);
   } else
     return(2);
 }

 strcpy(filename,"/proc/net/pppoe");
 fp= fopen(filename,"r");
 if(fp==NULL) {
   if(! mon->missing_pppoe_reported) {
     sprintf(line,"\ncannot open %s ",filename);
     perror(line);
     mon->missing_pppoe_reported= 1;
   }
   ret= 0; goto ex;
 } else {
   if(mon->missing_pppoe_reported)
     fprintf(stderr,"previously missing file %s appeared\n",filename);
   mon->missing_pppoe_reported= 0;
 }
 while(!feof(fp)) {
   if(fgets(line,sizeof(line),fp)==NULL)
 break;
   linecount++;
   if(mon->dev_name[0]==0 || strcmp(mon->dev_name,"-")==0 || mon->dev_automatic)
     if(linecount==2)
       sscanf(line,"%s %s %s",dummy,dummy,mon->dev_name);
 }
 mon->is_open= (linecount>1);
 ret= mon->is_open;
ex:;
 if(fp!=NULL)
   fclose(fp);
 return(ret);
}


int Pppoem_poll_count(mon,flag)
struct PppoeM *mon;
int flag;
{
 char line[1001],filename[80],*cpt;
 FILE *fp= NULL;
 int ret,i;
 double received,sent,r,bytes,diff;
 
 mon->ring_counts[mon->ring_cursor]= 0;
 mon->ring_times[mon->ring_cursor]= Sfile_microtime(0);

 if(mon->dev_name[0]==0 || strcmp(mon->dev_name,"-")==0)
   {ret= 2; goto ex;} 

 /* read in /proc/net/dev from line $dev_name column 0 and 8 */

 strcpy(filename,"/proc/net/dev");
 fp= fopen(filename,"r");
 if(fp==NULL) {
   sprintf(line,"cannot open %s ",filename);
   perror(line);
   ret= -1; goto ex;
 }
 while(!feof(fp)) {
   if(fgets(line,sizeof(line),fp)==NULL)
 break;
   for(cpt=line;(*cpt)!=0;cpt++)
     if((*cpt)!=' ')
   break;
   if(strncmp(cpt,mon->dev_name,strlen(mon->dev_name))!=0)
 continue;
   cpt+= strlen(mon->dev_name);
   if((*cpt)!=':')
 continue;
   cpt++;
   sscanf(cpt,"%lf  %lf  %lf  %lf  %lf  %lf  %lf  %lf  %lf",
          &received,&r  ,&r  ,&r  ,&r  ,&r  ,&r  ,&r  ,&sent);
   bytes= received+sent;
 
   if(mon->ring_cursor>0 || mon->ring_full) {
     diff= bytes - mon->last_bytes;

     /* >>> check for plausibility */
     while(diff<0) {
       diff+= 4294967296.0;
       mon->start_bytes-= 4294967296.0;
     }

     mon->ring_counts[mon->ring_cursor]= diff;
   }
   mon->last_time= mon->ring_times[mon->ring_cursor]= Sfile_microtime(0);
   mon->last_bytes= bytes;
   if(mon->start_time==0.0) {
     mon->start_time= mon->last_time;
     mon->start_bytes= mon->last_bytes;
   }
   ret= 1; goto ex;
 }
 ret= 0;
ex:;
 Pppoem_ring_index(mon,mon->ring_cursor+1,&(mon->ring_cursor),1);
 if(mon->ring_cursor==0)
   mon->ring_full= 1;
 if(fp!=NULL)
   fclose(fp);
 return(ret);
}


int Pppoem_poll_stdin(mon,flag)
/*
poll for a "%ld %s %lf %lf" formatted message at stdin :
  mon->is_open , mon->dev_name , mon->ring_times[] , mon->ring_counts[]
*/
struct PppoeM *mon;
int flag;
/*
 bit0= read only a single line
*/
{
 int ret,is_open= -1,seen_open= 0,first_try= 1;
 char line[1024],dev_name[1024];
 double timestamp= -1.0, count= -1.0, total_count= 0.0;

 mon->ring_counts[mon->ring_cursor]= 0;
 mon->ring_times[mon->ring_cursor]= Sfile_microtime(0);

get_line:;
 /* read message from stdin */;
 if(fgets(line,sizeof(line)-1,stdin)==NULL) {
   perror("while reading from stdandard input :");
   return(-1);
 }

 /* decode */
 sscanf(line,"%ld %s %lf %lf",&is_open,dev_name,&timestamp,&count);
 if(timestamp<0 || count<0 )
   {ret= 0; goto ex;}

 /* >>> check for plausibility */

 total_count+= count;
 /* if(first_try) fprintf(stderr,"\n");
    fprintf(stderr,"total_count=%lf , count=%lf\n",total_count,count);
 */
 if(is_open>seen_open)
   seen_open= is_open;

 /* to compensate interfering intervals one must be able to
    read more than one sample per try */
 first_try= 0;
 if(!(flag&1) && Sfile_fd_is_ready(fileno(stdin),0,1)>0) {
   /* fprintf(stderr,"extra line at stdin detected\n"); */
   goto get_line;
 }

 mon->is_open= seen_open;
 strncpy(mon->dev_name,dev_name,sizeof(mon->dev_name)-1);
 mon->dev_name[sizeof(mon->dev_name)-1]= 0;
 mon->last_time= mon->ring_times[mon->ring_cursor]= timestamp;
 mon->ring_counts[mon->ring_cursor]= total_count;
 mon->last_bytes+= total_count;

 if(mon->start_time==0.0) {
   mon->start_time= mon->last_time;
   mon->start_bytes= mon->last_bytes;
 }
 ret= 1;
ex:;
 Pppoem_ring_index(mon,mon->ring_cursor+1,&(mon->ring_cursor),1);
 if(mon->ring_cursor==0)
   mon->ring_full= 1;
 return(ret);
}


int Pppoem_poll(mon,flag)
struct PppoeM *mon;
int flag;
/*
 bit0= in listen_stdin-mode: one line only
*/
{
 int ret,was_open,idx;

 if(mon==NULL)
   return(0);

 was_open= mon->is_open;
 if(mon->listen_stdin) {
   ret= Pppoem_poll_stdin(mon,flag&1);
   if(ret<0)
     goto ex;
 } else {
   ret= Pppoem_poll_open(mon,0);
   if(ret<0)
     goto ex;
   ret= Pppoem_poll_count(mon,0);
   if(ret<0)
     goto ex;
 }
 mon->poll_count++;
 if(mon->is_open>0 && was_open<=0) {
   /* New connection */
   mon->start_time= mon->last_time;
   mon->start_bytes= mon->last_bytes;
   if(Pppoem_ring_index(mon,mon->ring_cursor-1,&idx,0)>0) {
     mon->ring_counts[0]= mon->ring_counts[idx];
     mon->ring_times[0]= mon->ring_times[idx];
   }
   mon->ring_cursor= 1;
   mon->ring_full= 0;
   mon->conn_count++;
 }
 ret= 1;
ex:;
 return(ret);
}


int Pppoem_ring_index(mon,idx,result,flag)
struct PppoeM *mon;
int idx;
int *result;
int flag;
/*
 bit0= allow unused indice
*/
{
 *result= 0;
 if((!mon->ring_full)&&!(flag&1)) 
   if(idx<0 || idx>=mon->ring_cursor)
     return(0);
 *result= idx % mon->ring_size;
 if(*result<0)
   (*result)+= mon->ring_size;
 return(1);
}


int Pppoem_get_interval(mon,off1,off2,count,timespan,flag)
struct PppoeM *mon;
int off1,off2;
double *count;
double *timespan;
int flag;
/*
 bit0= get whole interval of connection
*/
{
 int i,i1,i2,tr,ret;

 *count= 0;
 *timespan= 0;

 if(mon==NULL)
   return(0);

 if(flag&1) {
   *timespan= mon->last_time - mon->start_time;
   *count= mon->last_bytes - mon->start_bytes;
   return(1); 
 }
 if(off1>off2)
   { tr= off1; off1= off2; off2= tr;}
 if(off1==off2)
   off2++;
 if(off2>=mon->ring_size)
   return(0);
 ret= Pppoem_ring_index(mon,mon->ring_cursor-1-off1,&i1,0);
 if(ret<=0)
   return(ret);
 ret= Pppoem_ring_index(mon,mon->ring_cursor-1-off2,&i2,0);
 if(ret<=0)
   return(ret);
 for(i= i1; i!=i2; ) {
   (*count)+= mon->ring_counts[i];
   Pppoem_ring_index(mon,i-1,&i,0);
 }
 *timespan= mon->ring_times[i1]-mon->ring_times[i2];
 return(1);
}


int Pppoem_format_bps(mon,off1,off2,result,flag)
struct PppoeM *mon;
char result[160];
int flag;
{
 int ret;
 double count,timespan;

 ret= Pppoem_get_interval(mon,off1,off2,&count,&timespan,0);
 if(ret<0)
   return(ret);
 if(ret>0 && timespan>0) {
   Sfile_scale(count/timespan,result,7,1e5,1);
 } else
   sprintf(result,"%7.7s","     -1");
 return(1);
}


int Pppoem_format_stat(mon,result,flag)
struct PppoeM *mon;
char result[160];
int flag;
/*
 bit0= no on_off status
 bit1= no date string
 bit2= no throughput
 bit3= short line: No "DSL", only total throughput
*/
{
 int i,ret,idx;
 time_t tim;
 char bps1[80],bps2[80],bps3[80],total[80],on_off[80],datestr[80];
 char rate_text[80],count_text[80];
 char scale_c,scales[6];
 double t,count,rate;

 strcpy(scales,"bkmgt");
 result[0]= 0;

 if(mon==NULL)
   return(0);

 if(!(flag&1)) {
   if(mon->is_open==2)
     strncpy(on_off,mon->dev_name,sizeof(on_off)-1);
   else if(mon->is_open>0)
     sprintf(on_off,"DSL ON");
   else
     sprintf(on_off,"DSL OFF");
   on_off[sizeof(on_off)-1]= 0;
   if((flag&8) && mon->is_open==2)
     sprintf(result,"%.8s ",on_off);
   else if(flag&8) 
     sprintf(result,"%-3.3s ",on_off+4);
   else
     sprintf(result,"%-8.8s ",on_off);
 }
 if(!(flag&2)) {
   ret= Pppoem_ring_index(mon,mon->ring_cursor-1,&idx,0);
   if(ret>0)
     tim= mon->ring_times[idx];
   else
     tim= time(0);
   strcpy(datestr,Sfile_datestr(tim,3|(mon->use_local_time<<8)));
   sprintf(result+strlen(result),"%s ",datestr);
 }
 if(!(flag&(4|8))) {
   ret= Pppoem_format_bps(mon,0,mon->time_spans[0],bps1,0);
   if(ret<=0)
     return(ret);
   ret= Pppoem_format_bps(mon,0,mon->time_spans[1],bps2,0);
   if(ret<=0)
     return(ret);
   ret= Pppoem_format_bps(mon,0,mon->time_spans[2],bps3,0);
   if(ret<=0)
     return(ret);
   sprintf(result+strlen(result),"%s %s %s ",bps1,bps2,bps3);
 }
 if(!(flag&4)) {
   t= mon->last_time - mon->start_time;
   count= mon->last_bytes - mon->start_bytes;
   if(t>0)
     rate= count/t;
   else
     rate= 0;
   Sfile_scale(count,count_text,7,1e5,0);
   Sfile_scale(rate,rate_text,7,1e5,1);
   sprintf(total,"%s =%s / %.lfs",rate_text,count_text,t);
   strcat(result,total);
 }
 return(1);
}


int Pppoem_show_stat(mon,flag)
struct PppoeM *mon;
int flag;
/*
 bit0= clear status line and return
 bit1= print headline and return
*/
{
 char line[160];
 int ret;

 if(mon!=NULL)
   if(mon->quiet)
     return(2);

 fprintf(stderr,"\r%-79.79s\r"," ");
 fflush(stderr);
 if(flag&1)
   return(1);
 if(mon==NULL)
   return(0);

 if(flag&2)
   goto headline;

 ret= Pppoem_format_stat(mon,line,(mon->is_open<=0)<<2);
 if(ret<=0)
   return(ret);
 fprintf(stderr,"\r%s ",line);
 fflush(stderr);
 return(1);

headline:;
 fprintf(stderr,"%8s %13s %6lds %6lds %6lds  %s\n",
         " State  ",(mon->use_local_time?" Time (local)":" Time (GMT)"),
         (int) (mon->delay*mon->time_spans[0]),
         (int) (mon->delay*mon->time_spans[1]),
         (int) (mon->delay*mon->time_spans[2]),
         " total =  bytes / uptime");
 fflush(stderr);
 return(1);
}


int Pppoem_report(mon,msg,flag)
struct PppoeM *mon;
char *msg;
int flag;
/*
 bit0= do not print throughput information
 bit1= append "$dev_name"
*/
{
 char statstr[160],form[80];
 int ret,l;

 if(mon==NULL)
   return(0);

 if(mon->quiet)
   return(2);

 statstr[0]= 0;
 ret= Pppoem_format_stat(mon,statstr,1|((flag&1)<<2));
 if(ret<=0)
   return(ret);
 Pppoem_show_stat(mon,1);
 if(flag&2) {
   l= 8+1+strlen(statstr)+strlen(mon->dev_name);
   if(l<79) {
     sprintf(form,"%%-8.8s %%s%%%ld.%lds%%s\n",79-l,79-l);
     fprintf(stdout,form,msg,statstr," ",mon->dev_name);
   } else
     fprintf(stdout,"%-8.8s %s\n",msg,statstr);
 } else
   fprintf(stdout,"%-8.8s %s\n",msg,statstr);
 fflush(stdout);
 return(1);
}


int Pppoem_forward(mon,flag)
struct PppoeM *mon;
int flag;
{
 int ret,idx;

 if(mon==NULL)
   return(0);
 if(mon->quiet!=2)
   return(2);

 ret= Pppoem_ring_index(mon,mon->ring_cursor-1,&idx,0);
 if(ret<=0)
   return(ret);
 printf("%ld %.512s %lf %lf\n",mon->is_open,mon->dev_name,
                               mon->ring_times[idx],mon->ring_counts[idx]);
 fflush(stdout);
 return(1);
}


int Pppoem_loop(mon,flag)
struct PppoeM *mon;
int flag;
{
 int ret,was_open;
 unsigned long microsec;
 was_open= -1;

 if(mon==NULL)
   return(0);

 ret= Pppoem_report(mon,"PPPOEM S",1|2);
 if(ret<=0)
   goto ex;
 if(! mon->headlines_on) 
   Pppoem_show_stat(mon,2);                             /* one headline */

 do {
   ret= Pppoem_poll(mon,1);
   if(ret<=0)
     goto ex;
   if(mon->is_open!=was_open) {
     if(mon->is_open==2) {
       ret= Pppoem_report(mon,mon->dev_name,1|2);
     } else if(mon->is_open>0) {
       ret= Pppoem_report(mon,"DSL ON",1|2);
     } else {
       ret= Pppoem_report(mon,"DSL OFF",0);
     }
     if(ret<=0)
       goto ex;
   } else {
     ret= Pppoem_show_stat(mon,0);
     if(ret<=0)
       goto ex;
   }
   Pppoem_forward(mon,0);
   if(!mon->listen_stdin) {
     microsec= mon->delay*1e6;
     Sfile_microsleep(microsec,0);
   }
   if(mon->is_open!=was_open && mon->is_open>0 && mon->headlines_on) 
     Pppoem_show_stat(mon,2);                  /* new headline */
   was_open= mon->is_open;
 } while(1);
 
 ret= 1;
ex:;
 return(ret);
}


int Pppoem_arg_interpreter(mon,argc,argv,flag)
struct PppoeM *mon;
int argc;
char **argv;
int flag;
/*
 bit0= ignore first argument
*/
{
 int ret,i;

 for(i=(flag&1);i<argc;i++) {
   if(strcmp(argv[i],"-dev_name")==0 && i+1<argc) {
     i++;
     strncpy(mon->dev_name,argv[i],sizeof(mon->dev_name)-1);
     mon->dev_name[sizeof(mon->dev_name)-1]= 0;
     mon->dev_automatic= 0;
     if(strcmp(mon->dev_name,"-")==0 || mon->dev_name[0]==0)
        mon->dev_automatic= 1;
   } else if(strcmp(argv[i],"-help")==0 || strcmp(argv[i],"-h")==0) {
     fprintf(stderr,"usage: %s [options]\n\n",argv[0]);
     Pppoem__help_stderr(1);
   } else if(strcmp(argv[i],"-listen_stdin")==0 && i+1<argc) {
     i++;
     if(strcmp(argv[i],"on")==0)
       mon->listen_stdin= 1;
     else
       mon->listen_stdin= 0;
   } else if(strcmp(argv[i],"-pretend")==0 && i+1<argc) {
     i++;
     if(strcmp(argv[i],"on")==0)
       mon->is_open= 2;
     else
       mon->is_open= -1;
   } else if(strcmp(argv[i],"-report")==0 && i+1<argc) {
     i++;
     if(strcmp(argv[i],"off")==0)
       mon->quiet= 1;
     else if(strcmp(argv[i],"forward")==0)
       mon->quiet= 2;
     else
       mon->quiet= 0;
   } else if(strcmp(argv[i],"-show")==0 && i+1<argc) {
     int time_spans[3],max_span= -1;
     int j;

     i++;
     for(j=0;j<3;j++)
       time_spans[j]= -1;
     sscanf(argv[i],"%ld:%ld:%ld",time_spans,time_spans+1,time_spans+2);
     for(j=0;j<3;j++) {
       if(time_spans[j]<=0) {
         fprintf(stderr,"-show: no three usable time spans : %s\n",
                        argv[i+1]);
         ret= 0; goto ex;
       }
       if(time_spans[j]>max_span)
         max_span= time_spans[j];
     }
     ret= Pppoem_new_ring(mon,max_span+1,0);
     if(ret<=0)
       goto ex;
     for(j=0;j<3;j++)
       mon->time_spans[j]= time_spans[j];
   } else {
     fprintf(stderr,"unknown or incomplete option : %s\n",argv[i]);
     ret= 0;
     goto ex;
   }
 }
 ret= 1;
ex:;
 return(ret);
}