radlist.c

This program is a RADIUS RFC-compliant daemon, which is derived from original Livingston Enterprise

    char fstr[100];
    char *str_port_type;
    char client_ip[100];
    struct tm *time_info;
    char *fmt;

    for (i=0; i<number; i++,tpe++) {
	time_info = localtime(&(tpe->time));
	fmt = format;
	snprintf(str_time, sizeof(str_time),
		 "%02d/%s/%02d %02d:%02d:%02d",
		 time_info->tm_mday, months[time_info->tm_mon], 
		 time_info->tm_year, time_info->tm_hour, time_info->tm_min, 
		 time_info->tm_sec);
	memset(client_ip, 0, sizeof(client_ip));
	ipaddr2str(client_ip,sizeof(client_ip),tpe->client_ip);
	switch (tpe->port_type) {
	    case 0:
		str_port_type = "Async";
		break;
	    case 1:
		str_port_type = "Sync";
		break;
	    case 2:
		str_port_type = "ISDN";
		break;
	    case 3:
		str_port_type = "ISDN/V120";
		break;
	    case 4:
		str_port_type = "ISDN/V110";
		break;
	    default:
		str_port_type = "UNKNOWN";
		break;
	}

    while (*fmt) {
      switch (*fmt) {
        case '%':
	  fmt++;
	  width=parse_width(&fmt);
	  if (width) snprintf(fstr,sizeof(fstr),"%%%d",width);
	  else strcpy(fstr,"%");
	  switch (*fmt) {
	     case 'd':
	       strcat(fstr,"s"); printf(fstr,str_time);
	       break;
	     case 'P':
	       strcat(fstr,"s"); printf(fstr,str_port_type);
	       break;
	     case 'p':
	       strcat(fstr,"d"); printf(fstr,tpe->port_number);
	       break;
	     case 'a':
	       strcat(fstr,"s"); printf(fstr,ip_hostname(tpe->nas_ip));
	       break;
	     case 'y':
	       strcat(fstr,"s"); printf(fstr,proto_type_str(tpe->proto));
	       break;
	     case 'c':
	       strcat(fstr,"s"); printf(fstr,client_ip);
	       break;
	     default:
	       fstr[strlen(fstr)+1]='\0';
	       fstr[strlen(fstr)]=*fmt;
	       parse_format(fstr,entry,tmp,datasize,mday,month,stat);
	       break;
	  }
	  break;

        case '\\':
          fmt++;
          switch(*fmt)
            {
            case 'n':
              printf("\n");
              break;
            case 't':
              printf("\t");
              break;
            case 'r':
              printf("\r");
              break;
            case '\\':
              printf("\\");
            default:
              break;
          }
          break;

	default:
          putchar(*fmt);
	  break;
      }
      fmt++;
    }
    }
}

static void 
print_user_entry(char *format, char *entry, user_entry *tmp, int datasize, int mday,int month,int stat)
{
    if ((tmp->logins == 0) && !dostat ) {
      if ( username != NULL ) error("user '%s' not logged\n",username);
      return;
    }

    if ((tmp->logins != 0) && portinfo ) {

      int port_data_size, present_entries;

      port_data_size  = datasize - sizeof(user_entry);
      present_entries = port_data_size/sizeof(port_entry);
      if ( format!=NULL ) {
        parse_pformat(format,entry,tmp,datasize,mday,month,stat,
	              (port_entry*)((char*)tmp+sizeof(user_entry)),
		      present_entries);
        return;
      }
      if (traditional) {
         parse_pformat("%12l %4s %4n %10T %6I/%6O/%6M %6G %8k\n",
	      entry,tmp,datasize,mday,month,stat,
              (port_entry*)((char*)tmp+sizeof(user_entry)),
	      present_entries);
         return;
      }
      if (brief) { 
         parse_pformat( "%l/%ssess/%nlogs/%tsecs/%I/%O/%M/%G/%ksecs\n",
	      entry,tmp,datasize,mday,month,stat,
              (port_entry*)((char*)tmp+sizeof(user_entry)),
	      present_entries);
         return;
      }
      parse_pformat("%12l %d %y %Y%p %c\n",
	      entry,tmp,datasize,mday,month,stat,
              (port_entry*)((char*)tmp+sizeof(user_entry)),
	      present_entries);
      return;

/*
	printf("  [%s] %s-%d %s %s %s\n",
	       str_time,
	       str_port_type, tpe->port_number,
	       ip_hostname(tpe->nas_ip),
	       proto_type_str(tpe->proto),
	       client_ip);
*/
    }

    if ( format!=NULL ) {
      parse_format(format,entry,tmp,datasize,mday,month,stat);
      return;
    }
    if (traditional) {
      parse_format("%12l %4s %4n %10T %6I/%6O/%6M %6G %8k\n",
	           entry,tmp,datasize,mday,month,stat);
      return;
    }
    if (brief) { 
       parse_format( "%l/%ssess/%nlogs/%tsecs/%I/%O/%M/%G/%ksecs\n",
                     entry,tmp,datasize,mday,month,stat); 
       return;
    }
    parse_format( "\nUsername = %l\n"
      	      "Current-Sessions = %s\n"
	      "Logins = %n\n"
	      "Input-Traffic = %I\n"
	      "Output-Traffic = %O\n"
              "Total-Traffic = %M\n"
	      "Mean-Traffic = %gB\n"
	      "Mean-Session-Time = %ksecs\n",
              entry,tmp,datasize,mday,month,stat); 
}






int 
main(int argc, char ** argv)
{
    GDBM_FILE dbf;
    datum key, content, nextkey;
    int flag;
    int  stat=YEARLY_STAT;
    time_t crt_time;
    int month, mday, year;
    struct tm *time_info;
    char dbfile_name[PATH_MAX];
    char *cp;
    char *format = NULL;
    const char *radius_dir;
    
    extern char *optarg;
    extern int optind, opterr, optopt;

    progname = argv[0];
    crt_time = time(NULL);
    time_info = localtime(&crt_time);
    memset(dbfile_name, 0, PATH_MAX);

    month = time_info->tm_mon;
    mday  = time_info->tm_mday-1;
    year  = 1900+time_info->tm_year;
    radius_dir = RADACCT_DIR;

    while ((flag=getopt(argc,argv,"tDMYf:F:m:y:d:bu:psnh")) != EOF) {
	switch (flag) {
	    case 'D':
	       stat = DAILY_STAT;
	       break;

	    case 'M':
	       stat = MONTHLY_STAT;
	       break;

	    case 'Y':
	       stat = YEARLY_STAT;
	       break;
	    
	    case 'F':
	       format = optarg;
	       break;

	    case 'f':
		strncpy( dbfile_name,optarg,PATH_MAX-1 );
		break;

	    case 'm':
		month = strtol(optarg, &cp, 10);
		if (*cp) {
		    /* not a number ... */
		    error("month should be a number\n");
		    radlist_usage();
		}
		if ((month < 1) || (month > 12)) {
		    error("month should be between 1 and 12\n");
		    /* not a valid month */
		    radlist_usage();
		}
		month--;
		break;

	    case 'y':
		year = strtol(optarg, &cp, 10);
		if (*cp) {
		    /* not a number ... */
		    error("year should be a number greater than 1970\n");
		    radlist_usage();
		}
		if (year < 1970) {
		    error("year should be after 1970\n");
		    /* not a valid year */
		    radlist_usage();
		}
		break;

	    case 'd':
		mday = strtol(optarg, &cp, 10);
		if (*cp) {
		    /* not a number ... */
		    error("day should be a number\n");
		    radlist_usage();
		}
		if ((mday < 1) || (mday > 31)) {
		    error("day should be between 1 and 31\n");
		    /* not a valid day */
		    radlist_usage();
		}
		mday--;
		break;

	    case 't':
		traditional++;
		break;

	    case 'b':
		brief++;
		if (traditional) traditional=0;
		break;

	    case 'u':
		username = optarg;
		break;

	    case 'p':
		portinfo++;
		break;
	
	    case 's':
	    	dostat++; /* write statistics */
		break;
	    
	    case 'n':
	    	noheader++;
		break;

	    case 'h':
	    default:
		radlist_usage();
	}
    }
	
    if ( !strcmp(dbfile_name,"") )
       snprintf(dbfile_name, sizeof(dbfile_name),"%s/%d/%s",radius_dir,year,
                RADIUS_USER_STATS);
    dbf = gdbm_open(dbfile_name,0,GDBM_READER,0600,NULL);
    if (dbf == NULL) {
	error("cannot open '%s' database\n",dbfile_name);
	return -1;
    }

    if ( format != NULL ) {
    	traditional=0;
	brief=0;
	noheader=1;
    }

    if (traditional && !noheader) {
          printf(hdrstr);
    }

    if (username != NULL) {
	key.dptr=username;
	key.dsize=strlen(username);
		
	content = gdbm_fetch(dbf, key);
	if (content.dptr == NULL) {
	    error("info for user '%s' not found\n",username);
	    gdbm_close(dbf);
	    exit(-1);
        }
	print_user_entry(format,(char *)key.dptr, 
	                 (user_entry *)content.dptr, 
			 content.dsize, mday, month, stat);
    } else {
	static char str_user[1024];
	int cp_size;
	key = gdbm_firstkey(dbf);
	while (key.dptr != NULL) {
	    content = gdbm_fetch(dbf, key);
	    if (content.dptr == NULL) {
		error("cannot retrieve data in database\n");
		gdbm_close(dbf);
		free(key.dptr);
		return -1;
	    }
	    cp_size = key.dsize;
	    if (cp_size > sizeof(str_user)-1)
		cp_size = sizeof(str_user)-1;
	    memset(str_user, 0, sizeof(str_user));
	    strncpy(str_user, (char*)key.dptr, cp_size);
	    print_user_entry(format,str_user, (user_entry*)content.dptr, 
	                     content.dsize, mday, month,stat );
	    nextkey = gdbm_nextkey(dbf,key);
	    free(key.dptr);
	    key=nextkey;
	}
    }
    gdbm_close(dbf);
    return 0;
}

void 
rad_exit(int code)
{ exit(code); }