/home/tai/chorist/xian-1.2/src/xmr.c

Go to the documentation of this file.

/*
 *  Copyright (C) 2006 THALES Communications
 *
 *  This file is part of XIAN software.
 *
 *  XIAN is free software; you can redistribute it and/or modify it
 *  under the terms of the GNU General Public License as published by
 *  the Free Software Foundation.
 *
 *  XIAN software is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with XIAN software; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  */

/************************************************************************************************/
 

#include <linux/init.h>
#include <linux/module.h>
#include "include/xian_proto.h"

MODULE_DESCRIPTION("XMR - XIAN Metric Repository Module");
MODULE_LICENSE("GPL");

struct xian_stats *stats;

/**************************************************************************************************************************************/
struct xian_float xian_float_add(struct xian_float a, struct xian_float b){
  struct xian_float value;
  value.numerator=0;
  value.denominator=0;
  if(a.denominator==0){
    return b;
  }else{
    if(b.denominator==0){
    return a;
    }else{
      value.denominator=a.denominator*b.denominator;
      value.numerator=(a.numerator*b.denominator)+(b.numerator*a.denominator);
      return value;
    }
  }
}
XIAN_EXPORT_SYMBOL(xian_float_add);

/**************************************************************************************************************************************/
struct xian_float xian_float_mult(struct xian_float a, struct xian_float b){
  struct xian_float value;
  value.numerator=a.numerator*b.numerator;
  value.denominator=a.denominator*b.denominator;
  return value;
}
XIAN_EXPORT_SYMBOL(xian_float_mult);

/**************************************************************************************************************************************/
struct xian_float xian_float_div(struct xian_float a, struct xian_float b){
  struct xian_float value;
  struct xian_float inv;
  inv.numerator=b.denominator;
  inv.denominator=b.numerator;
  if(b.numerator!=0){
    value=xian_float_mult(a, inv);
  }
  return value;
}
XIAN_EXPORT_SYMBOL(xian_float_div);

/**************************************************************************************************************************************/
int xian_float_cmp(struct xian_float a, struct xian_float b){
  int c,d;
  c=a.numerator*b.denominator;
  d=b.numerator*a.denominator;
  if(c==d){//a==b
    return 0;
  }else{
    if(c<d){//a<b
      return -1;
    }else{//a>b
      return 1;
    }
  }
}
XIAN_EXPORT_SYMBOL(xian_float_cmp);

/**************************************************************************************************************************************/
struct xian_float int2xian_float(unsigned int x){
  struct xian_float value;
  value.numerator=x;
  value.denominator=1;
  return value;
}
XIAN_EXPORT_SYMBOL(int2xian_float);

/**************************************************************************************************************************************/
void print_stats(void){
  struct xian_stats *cur_stats;
  struct xian_stat *cur_stat;
  if(stats!=NULL){
    cur_stats=stats;
    while(cur_stats!=NULL){
      printk(KERN_ALERT "[XMR] id_conf=%d", cur_stats->id_conf);
      cur_stat=cur_stats->stat;
      while(cur_stat!=NULL){
        printk("\tmetric send by %02x:%02x:%02x:%02x:%02x:%02x", cur_stat->saddr[0], cur_stat->saddr[1], cur_stat->saddr[2], cur_stat->saddr[3], cur_stat->saddr[4], cur_stat->saddr[5]);
        printk(" val=%llu/%llu", cur_stat->value.numerator, cur_stat->value.denominator);
        cur_stat=cur_stat->next_stat;
      }
      printk("\n");
      cur_stats=cur_stats->next_stats;
    }
  }else{
    printk(KERN_ALERT "[XMR] vide\n");
  }
}

/**************************************************************************************************************************************/
struct xian_float
get_xian_stat(unsigned char macadd[IEEE80211_MAC_ADDR_LEN+1], 
              unsigned char dev_name[IFNAMESIZ+1],
              unsigned int id_conf,
              unsigned int *code_err){
  struct xian_float value;
  unsigned int code;
  unsigned char mac_addr_converted[ETH_ALEN];

  struct xian_stats *cur_stats;
  struct xian_stat *cur_stat;
  value.numerator = 0;
  value.denominator = 0;
  cur_stats=stats;
  while(cur_stats!=NULL){
    if(cur_stats->id_conf==id_conf){
      cur_stat=cur_stats->stat;
      convert_mac_addr(macadd, mac_addr_converted, &code);
      //printk("MAC to find=%02x:%02x:%02x:%02x:%02x:%02x\n", mac_addr_converted[0], mac_addr_converted[1], mac_addr_converted[2], mac_addr_converted[3], mac_addr_converted[4], mac_addr_converted[5]);
      while(cur_stat!=NULL){
        if(strcmp_mac(cur_stat->saddr,mac_addr_converted)==0){//metric founded
          value = cur_stat->value;
          return value;
        }
        cur_stat = cur_stat->next_stat;
      }
    }
    cur_stats = cur_stats->next_stats;
  }
  code=UNKNOW_METRIC;
  return value;
}
XIAN_EXPORT_SYMBOL(get_xian_stat);

/**************************************************************************************************************************************/
void update_xian_stat(unsigned char saddr[IEEE80211_MAC_ADDR_LEN+1], unsigned char dev_name[IFNAMESIZ+1], unsigned int id_conf, struct xian_float value){  
  unsigned char saddr_converted[ETH_ALEN];
  unsigned int code;
  unsigned int ok;
  int i;
  struct xian_stats *cur_stats, *new_stats;
  struct xian_stat *cur_stat, *new_stat;

  //printk(KERN_ALERT "\n");
  //printk(KERN_ALERT "[XMR] update BEGINNING %d %s\n", id_conf, saddr);
  //print_stats();
  code=NO_ERRORS;//=0
  ok=1;
  convert_mac_addr(saddr, saddr_converted, &code);
  if(code==INVALID_MAC_ADDR){
    printk(KERN_ALERT "[XMR] INVALID_MAC_ADDR\n");
    return;
  }
  cur_stats=stats;
  while(cur_stats!=NULL){
    if(cur_stats->id_conf==id_conf){
      cur_stat=cur_stats->stat;
      while(cur_stat!=NULL){
        if(strcmp_mac(cur_stat->saddr,saddr_converted)==0){//metric founded
          cur_stat->value=value;
          //printk(KERN_ALERT "[XMR] stat updated\n");
          ok=0;
        }  
        cur_stat=cur_stat->next_stat;
      }
      if(ok!=0){//insert at beginning of xian_stats
        struct xian_stat *new_stat;
        new_stat=kmalloc(sizeof(struct xian_stat),GFP_KERNEL);
        for(i=0; i<ETH_ALEN; i++){
          new_stat->saddr[i]=saddr_converted[i];
        }
        new_stat->value=value;
        new_stat->next_stat=cur_stats->stat;
        cur_stats->stat=new_stat;
        printk(KERN_ALERT "[XMR] stat inserted\n");
        ok=0;
      }
    }
    cur_stats=cur_stats->next_stats;
  }
  if(ok!=0){//insert at beginning of stats
    new_stats=kmalloc(sizeof(struct xian_stats),GFP_KERNEL);
    new_stats->next_stats=stats;
    new_stats->id_conf=id_conf;
    //new metric
    new_stat=kmalloc(sizeof(struct xian_stat),GFP_KERNEL);
    new_stat->next_stat=NULL;
    //memcpy(new_stat->saddr,saddr_converted,ETH_ALEN);
    for(i=0; i<ETH_ALEN; i++){
      new_stat->saddr[i]=saddr_converted[i];
    }
    new_stat->value=value;
    new_stats->stat=new_stat;
    stats=new_stats;
    printk(KERN_ALERT "[XMR] new stats inserted\n");
  }
  //print_stats();
  //printk(KERN_ALERT "[XMR] update END\n");
}
XIAN_EXPORT_SYMBOL(update_xian_stat);

/**************************************************************************************************************************************/
void del_xian_stat(unsigned char dev_name[IFNAMESIZ+1], unsigned int id_conf){//to do : macadd
  struct xian_stats *cur_stats;
  struct xian_stats *previous;
  struct xian_stat *cur_stat;
  struct xian_stat *prev;
  if(stats!=NULL){
    if((stats->next_stats==NULL)&&(stats->id_conf==id_conf)){
      stats=NULL;
    }else{
      cur_stats=stats;
      previous=stats;
      while(cur_stats!=NULL){
        if(cur_stats->id_conf==id_conf){
          cur_stat=cur_stats->stat;
          while(cur_stat!=NULL){
            prev=cur_stat;
            cur_stat=cur_stat->next_stat;
            kfree(prev);
          }
          previous->next_stats=cur_stats->next_stats;
          kfree(cur_stats);
        }
        previous=cur_stats;
        cur_stats=cur_stats->next_stats;
      }
    }
  }
  //print_stats();
}
XIAN_EXPORT_SYMBOL(del_xian_stat);


int xian_stats_init(void){
  printk(KERN_ALERT "Init XIAN XMR (XIAN Metric Repository module)\n");
  stats=NULL;
  return 0;
}

void xian_stats_exit(void){
  printk(KERN_ALERT "Unload XIAN XMR (XIAN Metric Repository module)\n");
  kfree(stats);
}

module_init(xian_stats_init);
module_exit(xian_stats_exit);

---