/home/tai/chorist/xian-1.2/src/xmm.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 <linux/netdevice.h>
#include <linux/kernel.h>
#include <linux/delay.h>

#include "include/xian_proto.h"
#include "include/itm.h"
#include "include/ksi.h"

//#include <linux/config.h>
#include <linux/version.h>
#include <linux/module.h>
#if defined(MODVERSIONS)
#include <linux/modversions.h>
#endif
#include <linux/fs.h>
#include <linux/string.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/sched.h>
#include <linux/smp_lock.h>
#include <asm/signal.h>
#include <asm/semaphore.h>

MODULE_DESCRIPTION("XMM - XIAN Metric Manager Module");
MODULE_LICENSE("GPL");

struct metric_conf tab[NB_MAX_INDEX];//table for configuration 
struct tab_mac{
  unsigned char mac[IEEE80211_MAC_ADDR_LEN+1];
  struct tab_mac *next;
};
struct tab_mac *tab_mac_to_broadcast;

/**************************************************************************************************************************************/
void insert_mac_to_broadcast(unsigned char *saddr){
  struct tab_mac *tmp, *new;
  
  tmp=tab_mac_to_broadcast;
  while(tmp!=NULL){
    if(strncmp(tmp->mac,saddr,IEEE80211_MAC_ADDR_LEN+1)==0){
      return;
    }
    // printk(KERN_ALERT "[XIAN Metric MANAGER] insert_mac_to_broadcast(%s)\n", saddr);
    tmp=tmp->next;
  }
  new=kmalloc(sizeof(struct tab_mac), GFP_KERNEL);
  strncpy(new->mac,saddr,IEEE80211_MAC_ADDR_LEN+1);
  new->next=tab_mac_to_broadcast;
  tab_mac_to_broadcast=new;
}
XIAN_EXPORT_SYMBOL(insert_mac_to_broadcast);

/**************************************************************************************************************************************/
void delete_mac_to_broadcast(unsigned char *saddr){
  struct tab_mac *tmp, *old;
  tmp=tab_mac_to_broadcast;
  old=tmp;
  while(tmp!=NULL){
    if(strncmp(tmp->mac,saddr,IEEE80211_MAC_ADDR_LEN+1)==0){
      old->next=tmp->next;
      kfree(tmp);
      return;
    }
    old=tmp;
    tmp=tmp->next;
  }
}
XIAN_EXPORT_SYMBOL(delete_mac_to_broadcast);
/********************************************************************************************/
void free_mac_to_broadcast(void)
{
  struct tab_mac *prev;
  while (tab_mac_to_broadcast!= NULL)
    {
      prev=tab_mac_to_broadcast;
      tab_mac_to_broadcast = tab_mac_to_broadcast->next;
      kfree(prev);
    } 
}
XIAN_EXPORT_SYMBOL(free_mac_to_broadcast);
/**************************************************************************************************************************************/
/* a structure to store all information we need
   for our thread */
typedef struct
{
  /* Linux task structure of thread */
  struct task_struct *thread;
  /* semaphore needed on start and creation of thread */
  struct semaphore   startstop_sem;
  /* flag to tell thread whether to die or not */
  int terminate;
  /* queue thread is waiting on */
  struct wait_queue *queue;
  /* process id of the thread */
  pid_t pid;
  void *data;
} my_threads;

/* prototype of our function thread */
void thread_function(my_threads *thread);

/* prototype to create a new thread */
static void launch_thread(void (*func),void *data, my_threads *thread);

/* prototype to kill a running thread */
static void kill_thread(my_threads *thread);

/* the variable that contains the thread data */
my_threads kthreads[NB_MAX_INDEX];

/* create a new kernel thread */
static void launch_thread(void (*func),void *data, my_threads *thread)
{
  init_MUTEX_LOCKED(&thread->startstop_sem);
  thread->data=data;

  /* create the new thread */
  kernel_thread(func, (void *)thread, 0);
  
  /* wait till it has reached the setup_thread routine */
  down(&thread->startstop_sem);
}

static void kill_thread(my_threads *thread)
{
  if (thread->thread == NULL)
    {
      //printk("[XMM] Killing non existing thread!\n");
      return;
    }
  
  /* get the global lock to prevent a race in the
     fall-asleep phase of the thread */
  init_MUTEX_LOCKED(&thread->startstop_sem);
  
#ifdef __alpha
  /* on Alpha platfrom we need to do a memory barrier
     here to be sure that the flags are visible on
     all CPUs. This is not portable, we should e.g.
     use atomic_t here for passing the information.
  */
  mb();
#endif
  
  /* set flag to request thread termination */
  thread->terminate = 1;
#ifdef __alpha
  /* on Alpha platfrom we need to do a memory barrier
     here to be sure that the flags are visible on
     all CPUs. This is not portable, we should e.g.
     use atomic_t here for passing the information.
  */
  mb();
#endif
  kill_proc(SIGKILL, thread->pid, 1);
  
  /* block till thread terminated */
  down(&thread->startstop_sem);
}

static void setup_thread(my_threads *thread)
{
  /* lock the kernel */
  lock_kernel();
  
  /* fill in thread structure */
  thread->thread = current;
  
  /* set signal mask to what we want to respond */
  siginitsetinv(&current->blocked, sigmask(SIGKILL)|sigmask(SIGINT)|sigmask(SIGTERM));
  
  /* initialise wait queue */
  thread->queue = NULL;
  
  /* initialise termination flag */
  thread->terminate = 0;
  
  /* let others run */
  unlock_kernel();
  
  /* tell the creator that we are ready and let him run */
  up(&thread->startstop_sem);
  
}

static void leave_thread(my_threads *thread)
{
  /* we are terminating */
  
  /* lock the kernel, the exit will unlock it */
  thread->thread = NULL;
#ifdef __alpha
  mb();
#endif
  /* notify the kill_thread() routine that we are terminating. */
  up(&thread->startstop_sem);
}

/**************************************************************************************************************************************/
void print_tab(void){
  int i,j;
  for(i=0;i<NB_MAX_INDEX;i++){
    printk("[%u] nb=%u", i, tab[i].nb);
    for(j=0;j<tab[i].nb;j++){
      if(j<NB_METRICS){
        printk(" id[%u]=%u metrics[%u]=%u", j, tab[i].id[j], j , tab[i].metrics[j]);
      }
    }
    printk("\n");
  }
  printk("\n");
} 

/**************************************************************************************************************************************/
void register_id(unsigned int id, unsigned int metric, char dev[IFNAMESIZ+1], char mac[IEEE80211_MAC_ADDR_LEN+1], unsigned int freq, void * pf){
  int i,j;
  //printk("[XMM] New metric registered\n");
  for(i=0;i<NB_MAX_INDEX;i++){
    if(tab[i].id[0]!=0){//metric already configured
      if((tab[i].frequency==freq) && (strcmp(tab[i].dev_name,dev)==0) && (strcmp(tab[i].macadd,mac)==0)){
        if(tab[i].nb<NB_METRICS){
          for(j=0;((j<tab[i].nb) && (j<NB_METRICS));j++){
            if((tab[i].id[j]==id) && (tab[i].metrics[j]==metric) &&  (tab[i].function[j]==pf)){//already present
              return;
            }
          }
          tab[i].id[tab[i].nb]=id;
          tab[i].metrics[tab[i].nb]=metric;
          tab[i].function[tab[i].nb]=pf;
          tab[i].nb=(tab[i].nb)+1;
          printk ( "nb = %u", tab[i].nb);
          return;
        }
      }
    }
  }
  
  for(i=0;i<NB_MAX_INDEX;i++){//frequency not present
    printk("[XMM] New metric registered\n");
    if(tab[i].id[0]==0){
      tab[i].index=i+1;
      tab[i].nb=1;
      tab[i].id[0]=id;
      tab[i].metrics[0]=metric;
      strncpy(tab[i].dev_name, dev, IFNAMESIZ+1); 
      strncpy(tab[i].macadd, mac, IEEE80211_MAC_ADDR_LEN+1); 
      tab[i].frequency=freq;
      tab[i].function[0]=pf;
      /* create a new kernel thread */
      if(tab[i].frequency!=0){//no sending report
        launch_thread(thread_function, &tab[i], &kthreads[i]);
      }
      return;
    }
  }
}
XIAN_EXPORT_SYMBOL(register_id);

/**************************************************************************************************************************************/
void register_id_no_report(unsigned int id, unsigned int metric, char dev[IFNAMESIZ+1], char mac[IEEE80211_MAC_ADDR_LEN+1], void * pf){
  register_id(id, metric, dev, mac, 0, pf);
}
XIAN_EXPORT_SYMBOL(register_id_no_report);

/**************************************************************************************************************************************/
void unregister_id(unsigned int id, unsigned int metric){
  int bool;
  int i,j,k;
  bool=0;
  for(i=0;i<NB_MAX_INDEX;i++){//find where is the metric
    for(j=0;j<tab[i].nb;j++){
      if((tab[i].id[j]==id)&&(tab[i].metrics[j]==metric)){
        if(tab[i].nb==1){
          tab[i].index=0;
          tab[i].id[0]=0;
          tab[i].nb=0;
          /* terminate the kernel thread */
          if(tab[i].frequency!=0){//no sending report
            kill_thread(&kthreads[i]);
          }
        }else{//metric is not alone
          for(k=0;k<tab[i].nb;k++){//frequency not present
            if(bool==0){//metric already unregistered => recopy k to k-1
              tab[i].id[k-1]=tab[i].id[k];
              tab[i].metrics[k-1]=tab[i].metrics[k];
              tab[i].function[k-1]=tab[i].function[k];
              tab[i].value[k-1]=tab[i].value[k];
            } 
            if(tab[i].metrics[k]==metric){
              bool=0;
            }
          }
          tab[i].nb--;
        }
      }
    }
  }
}
XIAN_EXPORT_SYMBOL(unregister_id);

/**************************************************************************************************************************************/
int XIAN_Manager_receive(unsigned char *saddr, struct xian_msg *stat){
  int i,j,k;
  unsigned char mac_broad_converted[ETH_ALEN];
  convert_mac_addr("ff:ff:ff:ff:ff:ff", mac_broad_converted, 0);
  /*
  printk("[XIAN MANAGER] Metrics received");
  printk(" version=%u", stat->version);
  printk(" sequence_number=%u", stat->id);  
  printk(" length=%u\n", stat->length);  
  */
  for(i=0; i<stat->length; i++){//xian_msg
    for(j=0;j<NB_MAX_INDEX;j++){//tab
      if(tab[j].index!=0){
        //if((strcmp_mac(saddr,tab[j].macadd)==0)||(strcmp_mac(saddr,mac_broad_converted)==0)){//metric founded
        for(k=0;k<tab[j].nb;k++){//tab[j]
          if(tab[j].metrics[k]==stat->msg[i].type){
            unsigned char mac_saddr[IEEE80211_MAC_ADDR_LEN+1];
            convert_hexamac(saddr,mac_saddr);
            tab[j].function[k](mac_saddr, &stat->msg[i]);
          }
        }
      }
    }
  }
  return 0;
}
XIAN_EXPORT_SYMBOL(XIAN_Manager_receive);

int xian_man_init(void){
  int i;
  printk("Init XIAN XMM (XIAN Metric Manager module)\n");
  //registration for XIAN Handler
  config_relay(&XIAN_Manager_receive);

  memset(&tab, 0, sizeof(tab));
  for(i=0;i<NB_MAX_INDEX;i++){  
    //initialisation of metric_conf
    tab[i].index=0;
    tab[i].id[0]=0;
    tab[i].nb=0;
    //print_tab();
  }
  tab_mac_to_broadcast=NULL;
  return 0;
}

void xian_man_exit(void){
  int i;
  config_relay(NULL);
  //kill thread
  for(i=0; i<NB_MAX_INDEX; i++){
    kill_thread(&kthreads[i]);
  }
  printk("Unload XIAN XMM (XIAN Metric Manager module)\n");
}

module_init(xian_man_init);
module_exit(xian_man_exit);

/**************************************************************************************************************************************/
struct xian_float get_metric(char dev_name[IFNAMESIZ+1], char macaddr[IEEE80211_MAC_ADDR_LEN+1], unsigned int metric, unsigned int *code_err){
  unsigned char mac_addr_converted[ETH_ALEN];
  struct xian_float value;
  unsigned int id_error;
  value=int2xian_float(0);

  convert_mac_addr(macaddr, mac_addr_converted, &(id_error));  
  //get metric => test on metric to call the good function like itm.c
  if(metric>181){
    value=get_xian_stat(macaddr,dev_name,metric,code_err);
    if(*code_err==UNKNOW_METRIC){
      printk("[XMM] Unknown Specified  Metric.\n");
    }
  }else{
  switch (metric){
    //NODE METRICS
  case NODE_TXPOWER:
    value=int2xian_float(get_node_txpower(mac_addr_converted,dev_name,code_err));
    break;
  case NODE_RSSI:
    value=int2xian_float(get_node_rssi(mac_addr_converted,dev_name,code_err));
    break;
  case NODE_NEGOTIATED_RATE:
    value=int2xian_float(get_node_negotiated_rate(mac_addr_converted,dev_name,code_err));
    break;
  case NODE_RX_DATA:
    value=int2xian_float(get_node_rx_data(mac_addr_converted,dev_name,code_err));
    break;
  case NODE_RX_MGMT:
    value=int2xian_float(get_node_rx_mgmt(mac_addr_converted,dev_name,code_err));
    break;
  case NODE_RX_CTRL:
    value=int2xian_float(get_node_rx_ctrl(mac_addr_converted,dev_name,code_err));
    break;
  case NODE_RX_UCAST:
    value=int2xian_float(get_node_rx_ucast(mac_addr_converted,dev_name,code_err));
    break;
  case NODE_RX_MCAST:
    value=int2xian_float(get_node_rx_mcast(mac_addr_converted,dev_name,code_err));
    break;
  case NODE_RX_BYTES:
    value=int2xian_float(get_node_rx_bytes(mac_addr_converted,dev_name,code_err));
    break;
  case NODE_RX_BEACONS:
    value=int2xian_float(get_node_rx_beacons(mac_addr_converted,dev_name,code_err));
    break;
  case NODE_RX_PROBERESP:
    value=int2xian_float(get_node_rx_proberesp(mac_addr_converted,dev_name,code_err));
    break;
  case NODE_RX_DUP:
    value=int2xian_float(get_node_rx_dup(mac_addr_converted,dev_name,code_err));
    break;
  case NODE_RX_NOPRIVACY:
    value=int2xian_float(get_node_rx_noprivacy(mac_addr_converted,dev_name,code_err));
    break;
  case NODE_RX_WEPFAIL:
    value=int2xian_float(get_node_rx_wepfail(mac_addr_converted,dev_name,code_err));
    break;
  case NODE_RX_DEMICFAIL:
    value=int2xian_float(get_node_rx_demicfail(mac_addr_converted,dev_name,code_err));
    break;
  case NODE_RX_DECAP:
    value=int2xian_float(get_node_rx_decap(mac_addr_converted,dev_name,code_err));
    break;
  case NODE_RX_DEFRAG:
    value=int2xian_float(get_node_rx_defrag(mac_addr_converted,dev_name,code_err));
    break;
  case NODE_RX_DISASSOC:
    value=int2xian_float(get_node_rx_disassoc(mac_addr_converted,dev_name,code_err));
    break;
  case NODE_RX_DEAUTH:
    value=int2xian_float(get_node_rx_deauth(mac_addr_converted,dev_name,code_err));
    break;
  case NODE_RX_DECRYPTCRC:
    value=int2xian_float(get_node_rx_decryptcrc(mac_addr_converted,dev_name,code_err));
    break;
  case NODE_RX_UNAUTH:
    value=int2xian_float(get_node_rx_unauth(mac_addr_converted,dev_name,code_err));
    break;
  case NODE_RX_UNENCRYPTED:
    value=int2xian_float(get_node_rx_unencrypted(mac_addr_converted,dev_name,code_err));
    break;
  case NODE_TX_DATA:
    value=int2xian_float(get_node_tx_data(mac_addr_converted,dev_name,code_err));
    break;
  case NODE_TX_MGMT:
    value=int2xian_float(get_node_tx_mgmt(mac_addr_converted,dev_name,code_err));
    break;
  case NODE_TX_UCAST:
    value=int2xian_float(get_node_tx_ucast(mac_addr_converted,dev_name,code_err));
    break;
  case NODE_TX_MCAST:
    value=int2xian_float(get_node_tx_mcast(mac_addr_converted,dev_name,code_err));
    break;
  case NODE_TX_BYTES:
    value=int2xian_float(get_node_tx_bytes(mac_addr_converted,dev_name,code_err));
    break;
  case NODE_TX_PROBEREQ:
    value=int2xian_float(get_node_tx_probereq(mac_addr_converted,dev_name,code_err));
    break;
  case NODE_TX_NOVLANTAG:
    value=int2xian_float(get_node_tx_novlantag(mac_addr_converted,dev_name,code_err));
    break;
  case NODE_TX_VLANMISMATCH:
    value=int2xian_float(get_node_tx_vlanmismatch(mac_addr_converted,dev_name,code_err));
    break;
  case NODE_PS_DISCARD:
    value=int2xian_float(get_node_ps_discard(mac_addr_converted,dev_name,code_err));
    break;
  case NODE_TX_ASSOC:
    value=int2xian_float(get_node_tx_assoc(mac_addr_converted,dev_name,code_err));
    break;
  case NODE_TX_ASSOC_FAIL:
    value=int2xian_float(get_node_tx_assoc_fail(mac_addr_converted,dev_name,code_err));
    break;
  case NODE_TX_AUTH:
    value=int2xian_float(get_node_tx_auth(mac_addr_converted,dev_name,code_err));
    break;
  case NODE_TX_AUTH_FAIL:
    value=int2xian_float(get_node_tx_auth_fail(mac_addr_converted,dev_name,code_err));
    break;
  case NODE_TX_DEAUTH:
    value=int2xian_float(get_node_tx_deauth(mac_addr_converted,dev_name,code_err));
    break;
  case NODE_TX_DEAUTH_CODE:
    value=int2xian_float(get_node_tx_deauth_code(mac_addr_converted,dev_name,code_err));
    break;
  case NODE_TX_DISASSOC:
    value=int2xian_float(get_node_tx_disassoc(mac_addr_converted,dev_name,code_err));
    break;
  case NODE_TX_DISASSOC_CODE:
    value=int2xian_float(get_node_tx_disassoc_code(mac_addr_converted,dev_name,code_err));
    break;
  case NODE_ON_TX_ERR:
    value=int2xian_float(get_node_on_tx_err(mac_addr_converted,dev_name,code_err));
    break;
  case NODE_ON_TX_OK:
    value=int2xian_float(get_node_on_tx_ok(mac_addr_converted,dev_name,code_err));
    break;
  case NODE_ON_TX_RETR:
    value=int2xian_float(get_node_on_tx_retr(mac_addr_converted,dev_name,code_err));
    break;
    //AST METRICS
  case AST_WATCHDOG:
    value=int2xian_float(get_ast_watchdog(dev_name,code_err));
    break;
  case AST_HARDWARE:
    value=int2xian_float(get_ast_hardware(dev_name,code_err));
    break;
  case AST_BMISS:
    break;
    value=int2xian_float(get_ast_bmiss(dev_name,code_err));
    break;
  case AST_BSTUCK:
    value=int2xian_float(get_ast_bstuck(dev_name,code_err));
    break;
  case AST_RXORN:
    value=int2xian_float(get_ast_rxorn(dev_name,code_err));
    break;
  case AST_RXEOL:
    value=int2xian_float(get_ast_rxeol(dev_name,code_err));
    break;
  case AST_TXURN:
    value=int2xian_float(get_ast_txurn(dev_name,code_err));
    break;
  case AST_MIB:
    value=int2xian_float(get_ast_mib(dev_name,code_err));
    break;
  case AST_INTRCOAL:
    value=int2xian_float(get_ast_intrcoal(dev_name,code_err));
    break;
  case AST_TX_PACKETS:
    value=int2xian_float(get_ast_tx_packets(dev_name,code_err));
    break;
  case AST_TX_MGMT:
    value=int2xian_float(get_ast_tx_mgmt(dev_name,code_err));
    break;
  case AST_TX_DISCARD:
    value=int2xian_float(get_ast_tx_discard(dev_name,code_err));
    break;
  case AST_TX_INVALID:
    value=int2xian_float(get_ast_tx_invalid(dev_name,code_err));
    break;
  case AST_TX_QSTOP:
    value=int2xian_float(get_ast_tx_qstop(dev_name,code_err));
    break;
  case AST_TX_ENCAP:
    value=int2xian_float(get_ast_tx_encap(dev_name,code_err));
    break;
  case AST_TX_NONODE:
    value=int2xian_float(get_ast_tx_nonode(dev_name,code_err));
    break;
  case AST_TX_NOBUF:
    value=int2xian_float(get_ast_tx_nobuf(dev_name,code_err));
    break;
  case AST_TX_NOBUFMGT:
    value=int2xian_float(get_ast_tx_nobufmgt(dev_name,code_err));
    break;
  case AST_TX_LINEAR:
    value=int2xian_float(get_ast_tx_linear(dev_name,code_err));
    break;
  case AST_TX_NODATA:
    value=int2xian_float(get_ast_tx_nodata(dev_name,code_err));
    break;
  case AST_TX_BUSDMA:
    value=int2xian_float(get_ast_tx_busdma(dev_name,code_err));
    break;
  case AST_TX_XRETRIES:
    value=int2xian_float(get_ast_tx_xretries(dev_name,code_err));
    break;
  case AST_TX_FIFOERR:
    value=int2xian_float(get_ast_tx_fifoerr(dev_name,code_err));
    break;
  case AST_TX_FILTERED:
    value=int2xian_float(get_ast_tx_filtered(dev_name,code_err));
    break;
  case AST_TX_SHORTRETRY:
    value=int2xian_float(get_ast_tx_shortretry(dev_name,code_err));
    break;
  case AST_TX_LONGRETRY:
    value=int2xian_float(get_ast_tx_longretry(dev_name,code_err));
    break;
  case AST_TX_BADRATE:
    value=int2xian_float(get_ast_tx_badrate(dev_name,code_err));
    break;
  case AST_TX_NOACK:
    value=int2xian_float(get_ast_tx_noack(dev_name,code_err));
    break;
  case AST_TX_RTS:
    value=int2xian_float(get_ast_tx_rts(dev_name,code_err));
    break;
  case AST_TX_CTS:
    value=int2xian_float(get_ast_tx_cts(dev_name,code_err));
    break;
  case AST_TX_SHORTPRE:
    value=int2xian_float(get_ast_tx_shortpre(dev_name,code_err));
    break;
  case AST_TX_ALTRATE:
    value=int2xian_float(get_ast_tx_altrate(dev_name,code_err));
    break;
  case AST_TX_PROTECT:
    value=int2xian_float(get_ast_tx_protect(dev_name,code_err));
    break;
  case AST_TX_CTSBURST:
    value=int2xian_float(get_ast_tx_ctsburst(dev_name,code_err));
    break;
  case AST_TX_CTSEXT:
    value=int2xian_float(get_ast_tx_ctsext(dev_name,code_err));
    break;
  case AST_RX_NOBUF:
    value=int2xian_float(get_ast_rx_nobuf(dev_name,code_err));
    break;
  case AST_RX_BUSDMA:
    value=int2xian_float(get_ast_rx_busdma(dev_name,code_err));
    break;
  case AST_RX_ORN:
    value=int2xian_float(get_ast_rx_orn(dev_name,code_err));
    break;
  case AST_RX_CRCERR:
    value=int2xian_float(get_ast_rx_crcerr(dev_name,code_err));
    break;
  case AST_RX_FIFOERR:
    value=int2xian_float(get_ast_rx_fifoerr(dev_name,code_err));
    break;
  case AST_RX_BADCRYPT:
    value=int2xian_float(get_ast_rx_badcrypt(dev_name,code_err));
    break;
  case AST_RX_BADMIC:
    value=int2xian_float(get_ast_rx_badmic(dev_name,code_err));
    break;
  case AST_RX_PHYERR:
    value=int2xian_float(get_ast_rx_phyerr(dev_name,code_err));
    break;
  case AST_RX_TOOSHORT:
    value=int2xian_float(get_ast_rx_tooshort(dev_name,code_err));
    break;
  case AST_RX_TOOBIG:
    value=int2xian_float(get_ast_rx_toobig(dev_name,code_err));
    break;
  case AST_RX_PACKETS:
    value=int2xian_float(get_ast_rx_packets(dev_name,code_err));
    break;
  case AST_RX_MGT:
    value=int2xian_float(get_ast_rx_mgt(dev_name,code_err));
    break;
  case AST_RX_CTL:
    value=int2xian_float(get_ast_rx_ctl(dev_name,code_err));
    break;
  case AST_TX_RSSI:
    value=int2xian_float(get_ast_tx_rssi(dev_name,code_err));
    break;
  case AST_RX_RSSI:
    value=int2xian_float(get_ast_rx_rssi(dev_name,code_err));
    break;
  case AST_BE_XMIT:
    value=int2xian_float(get_ast_be_xmit(dev_name,code_err));
    break;
  case AST_BE_NOBUF:
    value=int2xian_float(get_ast_be_nobuf(dev_name,code_err));
    break;
  case AST_PER_CAL:
    value=int2xian_float(get_ast_per_cal(dev_name,code_err));
    break;
  case AST_PER_CALFAIL:
    value=int2xian_float(get_ast_per_calfail(dev_name,code_err));
    break;
  case AST_PER_RFGAIN:
    value=int2xian_float(get_ast_per_rfgain(dev_name,code_err));
    break;
  case AST_RATE_CALLS:
    value=int2xian_float(get_ast_rate_calls(dev_name,code_err));
    break;
  case AST_RATE_RAISE:
    value=int2xian_float(get_ast_rate_raise(dev_name,code_err));
    break;
  case AST_RATE_DROP:
    value=int2xian_float(get_ast_rate_drop(dev_name,code_err));
    break;
  case AST_ANT_DEFSWITCH:
    value=int2xian_float(get_ast_ant_defswitch(dev_name,code_err));
    break;
  case AST_ANT_TXSWITCH:
    value=int2xian_float(get_ast_ant_txswitch(dev_name,code_err));
    break;
    //IS METRICS
  case IS_RX_BADVERSION:
    value=int2xian_float(get_is_rx_badversion(dev_name,code_err));
    break;
  case IS_RX_TOOSHORT:
    value=int2xian_float(get_is_rx_tooshort(dev_name,code_err));
    break;
  case IS_RX_WRONGBSS:
    value=int2xian_float(get_is_rx_wrongbss(dev_name,code_err));
    break;
  case IS_RX_DUP:
    value=int2xian_float(get_is_rx_dup(dev_name,code_err));
    break;
  case IS_RX_WRONGDIR:
    value=int2xian_float(get_is_rx_wrongdir(dev_name,code_err));
    break;
  case IS_RX_MCASTECHO:
    value=int2xian_float(get_is_rx_mcastecho(dev_name,code_err));
    break;
  case IS_RX_NOTASSOC:
    value=int2xian_float(get_is_rx_notassoc(dev_name,code_err));
    break;
  case IS_RX_NOPRIVACY:
    value=int2xian_float(get_is_rx_noprivacy(dev_name,code_err));
    break;
  case IS_RX_UNENCRYPTED:
    value=int2xian_float(get_is_rx_unencrypted(dev_name,code_err));
    break;
  case IS_RX_WEPFAIL:
    value=int2xian_float(get_is_rx_wepfail(dev_name,code_err));
    break;
  case IS_RX_DECAP:
    value=int2xian_float(get_is_rx_decap(dev_name,code_err));
    break;
  case IS_RX_MGTDISCARD:
    value=int2xian_float(get_is_rx_mgtdiscard(dev_name,code_err));
    break;
  case IS_RX_CTL:
    value=int2xian_float(get_is_rx_ctl(dev_name,code_err));
    break;
  case IS_RX_BEACON:
    value=int2xian_float(get_is_rx_beacon(dev_name,code_err));
    break;
  case IS_RX_RSTOOBIG:
    value=int2xian_float(get_is_rx_rstoobig(dev_name,code_err));
    break;
  case IS_RX_ELEM_MISSING:
    value=int2xian_float(get_is_rx_elem_missing(dev_name,code_err));
    break;
  case IS_RX_ELEM_TOOBIG:
    value=int2xian_float(get_is_rx_elem_toobig(dev_name,code_err));
    break;
  case IS_RX_ELEM_TOOSMALL:
    value=int2xian_float(get_is_rx_elem_toosmall(dev_name,code_err));
    break;
  case IS_RX_ELEM_UNKNOWN:
    value=int2xian_float(get_is_rx_elem_unknown(dev_name,code_err));
    break;
  case IS_RX_BADCHAN:
    value=int2xian_float(get_is_rx_badchan(dev_name,code_err));
    break;
  case IS_RX_CHANMISMATCH:
    value=int2xian_float(get_is_rx_chanmismatch(dev_name,code_err));
    break;
  case IS_RX_NODEALLOC:
    value=int2xian_float(get_is_rx_nodealloc(dev_name,code_err));
    break;
  case IS_RX_SSIDMISMATCH:
    value=int2xian_float(get_is_rx_ssidmismatch(dev_name,code_err));
    break;
  case IS_RX_AUTH_UNSUPPORTED:
    value=int2xian_float(get_is_rx_auth_unsupported(dev_name,code_err));
    break;
  case IS_RX_AUTH_FAIL:
    value=int2xian_float(get_is_rx_auth_fail(dev_name,code_err));
    break;
  case IS_RX_AUTH_COUNTERMEASURES:
    value=int2xian_float(get_is_rx_auth_countermeasures(dev_name,code_err));
    break;
  case IS_RX_ASSOC_BSS:
    value=int2xian_float(get_is_rx_assoc_bss(dev_name,code_err));
    break;
  case IS_RX_ASSOC_NOTAUTH:
    value=int2xian_float(get_is_rx_assoc_notauth(dev_name,code_err));
    break;
  case IS_RX_ASSOC_CAPMISMATCH:
    value=int2xian_float(get_is_rx_assoc_capmismatch(dev_name,code_err));
    break;
  case IS_RX_ASSOC_NORATE:
    value=int2xian_float(get_is_rx_assoc_norate(dev_name,code_err));
    break;
  case IS_RX_ASSOC_BADWPAIE:
    value=int2xian_float(get_is_rx_assoc_badwpaie(dev_name,code_err));
    break;
  case IS_RX_DEAUTH:
    value=int2xian_float(get_is_rx_deauth(dev_name,code_err));
    break;
  case IS_RX_DISASSOC:
    value=int2xian_float(get_is_rx_disassoc(dev_name,code_err));
    break;
  case IS_RX_BADSUBTYPE:
    value=int2xian_float(get_is_rx_badsubtype(dev_name,code_err));
    break;
  case IS_RX_NOBUF:
    value=int2xian_float(get_is_rx_nobuf(dev_name,code_err));
    break;
  case IS_RX_DECRYPTCRC:
    value=int2xian_float(get_is_rx_decryptcrc(dev_name,code_err));
    break;
  case IS_RX_AHDEMO_MGT:
    value=int2xian_float(get_is_rx_ahdemo_mgt(dev_name,code_err));
    break;
  case IS_RX_BAD_AUTH:
    value=int2xian_float(get_is_rx_bad_auth(dev_name,code_err));
    break;
  case IS_RX_UNAUTH:
    value=int2xian_float(get_is_rx_unauth(dev_name,code_err));
    break;/* BUG
  case IS_RX_BADKEYID:
    value=int2xian_float(get_is_rx_badkeyid(dev_name,code_err));
    break;
  case IS_RX_CCMPREPLAY:
    value=int2xian_float(get_is_rx_ccmpreplay(dev_name,code_err));
    break;
  case IS_RX_CCMPFORMAT:
    value=int2xian_float(get_is_rx_ccmpformat(dev_name,code_err));
    break;
  case IS_RX_CCMPMIC:
    value=int2xian_float(get_is_rx_ccmpmic(dev_name,code_err));
    break;
  case IS_RX_TKIPREPLAY:
    value=int2xian_float(get_is_rx_tkipreplay(dev_name,code_err));
    break;
  case IS_RX_TKIPFORMAT:
    value=int2xian_float(get_is_rx_tkipformat(dev_name,code_err));
    break;
  case IS_RX_TKIPMIC:
    value=int2xian_float(get_is_rx_tkipmic(dev_name,code_err));
    break;
  case IS_RX_TKIPICV:
    value=int2xian_float(get_is_rx_tkipicv(dev_name,code_err));
    break;
  case IS_RX_BADCIPHER:
    value=int2xian_float(get_is_rx_badcipher(dev_name,code_err));
    break;
  case IS_RX_NOCIPHERCTX:
    value=int2xian_float(get_is_rx_nocipherctx(dev_name,code_err));
    break;
  case IS_RX_ACL:
    value=int2xian_float(get_is_rx_acl(dev_name,code_err));
    break;
  case IS_TX_NOBUF:
    value=int2xian_float(get_is_tx_nobuf(dev_name,code_err));
    break;
  case IS_TX_NONODE:
    value=int2xian_float(get_is_tx_nonode(dev_name,code_err));
    break;
  case IS_TX_UNKNOWNMGT:
    value=int2xian_float(get_is_tx_unknownmgt(dev_name,code_err));
    break;
  case IS_TX_BADCIPHER:
    value=int2xian_float(get_is_tx_badcipher(dev_name,code_err));
    break;
  case IS_TX_NODEFKEY:
    value=int2xian_float(get_is_tx_nodefkey(dev_name,code_err));
    break;
  case IS_TX_NOHEADROOM:
    value=int2xian_float(get_is_tx_noheadroom(dev_name,code_err));
    break;
  case IS_SCAN_ACTIVE:
    value=int2xian_float(get_is_scan_active(dev_name,code_err));
    break;
  case IS_SCAN_PASSIVE:
    value=int2xian_float(get_is_scan_passive(dev_name,code_err));
    break;
  case IS_NODE_TIMEOUT:
    value=int2xian_float(get_is_node_timeout(dev_name,code_err));
    break;
  case IS_CRYPTO_NOMEM:
    value=int2xian_float(get_is_crypto_nomem(dev_name,code_err));
    break;
  case IS_CRYPTO_TKIP:
    value=int2xian_float(get_is_crypto_tkip(dev_name,code_err));
    break;
  case IS_CRYPTO_TKIPENMIC:
    value=int2xian_float(get_is_crypto_tkipenmic(dev_name,code_err));
    break;
  case IS_CRYPTO_TKIPDEMIC:
    value=int2xian_float(get_is_crypto_tkipdemic(dev_name,code_err));
    break;
  case IS_CRYPTO_TKIPCM:
    value=int2xian_float(get_is_crypto_tkipcm(dev_name,code_err));
    break;
  case IS_CRYPTO_CCMP:
    value=int2xian_float(get_is_crypto_ccmp(dev_name,code_err));
    break;
  case IS_CRYPTO_WEP:
    value=int2xian_float(get_is_crypto_wep(dev_name,code_err));
    break;
  case IS_CRYPTO_SETKEY_CIPHER:
    value=int2xian_float(get_is_crypto_setkey_cipher(dev_name,code_err));
    break;
  case IS_CRYPTO_SETKEY_NOKEY:
    value=int2xian_float(get_is_crypto_setkey_nokey(dev_name,code_err));
    break;
  case IS_CRYPTO_DELKEY:
    value=int2xian_float(get_is_crypto_delkey(dev_name,code_err));
    break;
  case IS_CRYPTO_BADCIPHER:
    value=int2xian_float(get_is_crypto_badcipher(dev_name,code_err));
    break;
  case IS_CRYPTO_NOCIPHER:
    value=int2xian_float(get_is_crypto_nocipher(dev_name,code_err));
    break;
  case IS_CRYPTO_ATTACHFAIL:
    value=int2xian_float(get_is_crypto_attachfail(dev_name,code_err));
    break;
  case IS_CRYPTO_SWFALLBACK:
    value=int2xian_float(get_is_crypto_swfallback(dev_name,code_err));
    break;
  case IS_CRYPTO_KEYFAIL:
    value=int2xian_float(get_is_crypto_keyfail(dev_name,code_err));
    break;
  case IS_CRYPTO_ENMICFAIL:
    value=int2xian_float(get_is_crypto_enmicfail(dev_name,code_err));
    break;
  case IS_IBSS_CAPMISMATCH:
    value=int2xian_float(get_is_ibss_capmismatch(dev_name,code_err));
    break;
  case IS_IBSS_NORATE:
    value=int2xian_float(get_is_ibss_norate(dev_name,code_err));
    break;
  case IS_PS_UNASSOC:
    value=int2xian_float(get_is_ps_unassoc(dev_name,code_err));
    break;
  case IS_PS_BADAID:
    value=int2xian_float(get_is_ps_badaid(dev_name,code_err));
    break;
  case IS_PS_QEMPTY:
    value=int2xian_float(get_is_ps_qempty(dev_name,code_err));
    break;*/
  default :
    {
      if(*code_err==UNKNOW_METRIC){
        printk("[XMM] Unknown Specified  Metric.\n");
      }
      break;
    }
  }
  }//END ELSE
  return value;
}
XIAN_EXPORT_SYMBOL(get_metric);


/**************************************************************************************************************************************/
void thread_function(my_threads *thread){
  int i,j;
  unsigned long timeout;
  unsigned int code_err;
  unsigned char mac[ETH_ALEN];
  struct xian_float value;
  struct metric_conf *tmp;
  struct tab_mac *tmp_mac;
  struct qos_metric_proto_msg msg;  
  /* setup the thread environment */
  setup_thread(thread);
   
  print_tab();
  tmp=(struct metric_conf *)thread->data;
  if(tmp->index==0){
    leave_thread(thread);
    return;
  }
  strcpy(msg.macaddr, tmp->macadd);
  strcpy(msg.dev_name, tmp->dev_name);
     
  code_err = 0;
 
  while(1){
    msg.nb=0;
    if(strncmp(msg.macaddr, "FF:FF:FF:FF:FF:FF", IEEE80211_MAC_ADDR_LEN)==0){
      //send metric with macadd present in tab_mac_to_broadcast
      tmp_mac=tab_mac_to_broadcast;
      i=0;
      while((tmp_mac!=NULL) && (i<NB_METRICS)){
        i++;
        convert_mac_addr(tmp_mac->mac, mac, 0);
        for(j=0;(j<NB_METRICS)&&(j<tmp->nb);j++){
          value=get_metric(msg.dev_name, tmp_mac->mac, tmp->metrics[j], &code_err);
          //insert_metric in the XIAN message
          kinsert_metric(&msg, tmp->metrics[j], tmp->id[j], 0, mac, value);//TODO encoding_type
        }
        tmp_mac=tmp_mac->next;
      }
      if(tab_mac_to_broadcast==NULL){
        convert_mac_addr(msg.macaddr, mac, 0);
        for(j=0;(j<NB_METRICS)&&(j<tmp->nb);j++){
          value=get_metric(msg.dev_name, msg.macaddr, tmp->metrics[j], &code_err);
          kinsert_metric(&msg, tmp->metrics[j], tmp->id[j], 0, mac, value);//TODO encoding_type
        }
      }
      //send_metric if last metric
     
      ksend_metric(msg.dev_name, msg.macaddr, msg, &code_err);
    }else{//No broadcast
      for(i=0;(i<tmp->nb) && (i<NB_METRICS);i++){
        tmp->value[i]=get_metric(msg.dev_name, msg.macaddr, tmp->metrics[i], &code_err);
        convert_mac_addr(msg.macaddr, mac, 0);
        //insert_metric in the XIAN message
        kinsert_metric(&msg, tmp->metrics[i], tmp->id[i], 0, mac, tmp->value[i]);//TODO encoding_type
        
        if((i==((tmp->nb)-1))||(i==((NB_METRICS)-1))){
          //send_metric if last metric
          ksend_metric(msg.dev_name, msg.macaddr, msg, &code_err);
        }
      }
    }
    //mdelay(tmp->frequency);//CPU => 100%
    //msleep(tmp->frequency);//not present in kernel 2.4
    timeout = ((HZ * tmp->frequency + 999) / 1000) + 1;
    set_current_state(TASK_UNINTERRUPTIBLE);
    timeout = schedule_timeout(timeout);
    if (thread->terminate)
      {
        /* we received a request to terminate ourself */
        break;    
      }
  }
  
  /* here we go only in case of termination of the thread */
  /* cleanup the thread, leave */
  
  leave_thread(thread);
}

---