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

Go to the documentation of this file.
00001 
00011  /*  Copyright (C) 2006 THALES Communications
00012  *
00013  *  This file is part of XIAN software.
00014  *
00015  *  XIAN is free software; you can redistribute it and/or modify it
00016  *  under the terms of the GNU General Public License as published by
00017  *  the Free Software Foundation.
00018  *
00019  *  XIAN software is distributed in the hope that it will be useful,
00020  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
00021  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00022  *  GNU General Public License for more details.
00023  *
00024  *  You should have received a copy of the GNU General Public License
00025  *  along with XIAN software; if not, write to the Free Software
00026  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
00027  *
00028  *  */
00029 
00030 /************************************************************************************************/
00031  
00032 
00033 #include <linux/init.h>
00034 #include <linux/module.h>
00035 #include <linux/netdevice.h>
00036 #include <linux/kernel.h>
00037 #include <linux/delay.h>
00038 
00039 #include "include/xian_proto.h"
00040 #include "include/itm.h"
00041 #include "include/ksi.h"
00042 
00043 //#include <linux/config.h>
00044 #include <linux/version.h>
00045 #include <linux/module.h>
00046 #if defined(MODVERSIONS)
00047 #include <linux/modversions.h>
00048 #endif
00049 #include <linux/fs.h>
00050 #include <linux/string.h>
00051 #include <linux/module.h>
00052 #include <linux/errno.h>
00053 #include <linux/sched.h>
00054 #include <linux/smp_lock.h>
00055 #include <asm/signal.h>
00056 #include <asm/semaphore.h>
00057 
00058 MODULE_DESCRIPTION("XMM - XIAN Metric Manager Module");
00059 MODULE_LICENSE("GPL");
00060 
00061 struct metric_conf tab[NB_MAX_INDEX];//table for configuration 
00062 struct tab_mac{
00063   unsigned char mac[IEEE80211_MAC_ADDR_LEN+1];
00064   struct tab_mac *next;
00065 };
00066 struct tab_mac *tab_mac_to_broadcast;
00067 
00068 /**************************************************************************************************************************************/
00074 void insert_mac_to_broadcast(unsigned char *saddr){
00075   struct tab_mac *tmp, *new;
00076   
00077   tmp=tab_mac_to_broadcast;
00078   while(tmp!=NULL){
00079     if(strncmp(tmp->mac,saddr,IEEE80211_MAC_ADDR_LEN+1)==0){
00080       return;
00081     }
00082     // printk(KERN_ALERT "[XIAN Metric MANAGER] insert_mac_to_broadcast(%s)\n", saddr);
00083     tmp=tmp->next;
00084   }
00085   new=kmalloc(sizeof(struct tab_mac), GFP_KERNEL);
00086   strncpy(new->mac,saddr,IEEE80211_MAC_ADDR_LEN+1);
00087   new->next=tab_mac_to_broadcast;
00088   tab_mac_to_broadcast=new;
00089 }
00090 XIAN_EXPORT_SYMBOL(insert_mac_to_broadcast);
00091 
00092 /**************************************************************************************************************************************/
00097 void delete_mac_to_broadcast(unsigned char *saddr){
00098   struct tab_mac *tmp, *old;
00099   tmp=tab_mac_to_broadcast;
00100   old=tmp;
00101   while(tmp!=NULL){
00102     if(strncmp(tmp->mac,saddr,IEEE80211_MAC_ADDR_LEN+1)==0){
00103       old->next=tmp->next;
00104       kfree(tmp);
00105       return;
00106     }
00107     old=tmp;
00108     tmp=tmp->next;
00109   }
00110 }
00111 XIAN_EXPORT_SYMBOL(delete_mac_to_broadcast);
00112 /********************************************************************************************/
00113 void free_mac_to_broadcast(void)
00114 {
00115   struct tab_mac *prev;
00116   while (tab_mac_to_broadcast!= NULL)
00117     {
00118       prev=tab_mac_to_broadcast;
00119       tab_mac_to_broadcast = tab_mac_to_broadcast->next;
00120       kfree(prev);
00121     } 
00122 }
00123 XIAN_EXPORT_SYMBOL(free_mac_to_broadcast);
00124 /**************************************************************************************************************************************/
00127 /* a structure to store all information we need
00128    for our thread */
00129 typedef struct
00130 {
00131   /* Linux task structure of thread */
00132   struct task_struct *thread;
00133   /* semaphore needed on start and creation of thread */
00134   struct semaphore   startstop_sem;
00135   /* flag to tell thread whether to die or not */
00136   int terminate;
00137   /* queue thread is waiting on */
00138   struct wait_queue *queue;
00139   /* process id of the thread */
00140   pid_t pid;
00141   void *data;
00142 } my_threads;
00143 
00144 /* prototype of our function thread */
00145 void thread_function(my_threads *thread);
00146 
00147 /* prototype to create a new thread */
00148 static void launch_thread(void (*func),void *data, my_threads *thread);
00149 
00150 /* prototype to kill a running thread */
00151 static void kill_thread(my_threads *thread);
00152 
00153 /* the variable that contains the thread data */
00154 my_threads kthreads[NB_MAX_INDEX];
00155 
00156 /* create a new kernel thread */
00157 static void launch_thread(void (*func),void *data, my_threads *thread)
00158 {
00159   init_MUTEX_LOCKED(&thread->startstop_sem);
00160   thread->data=data;
00161 
00162   /* create the new thread */
00163   kernel_thread(func, (void *)thread, 0);
00164   
00165   /* wait till it has reached the setup_thread routine */
00166   down(&thread->startstop_sem);
00167 }
00168 
00169 static void kill_thread(my_threads *thread)
00170 {
00171   if (thread->thread == NULL)
00172     {
00173       //printk("[XMM] Killing non existing thread!\n");
00174       return;
00175     }
00176   
00177   /* get the global lock to prevent a race in the
00178      fall-asleep phase of the thread */
00179   init_MUTEX_LOCKED(&thread->startstop_sem);
00180   
00181 #ifdef __alpha
00182   /* on Alpha platfrom we need to do a memory barrier
00183      here to be sure that the flags are visible on
00184      all CPUs. This is not portable, we should e.g.
00185      use atomic_t here for passing the information.
00186   */
00187   mb();
00188 #endif
00189   
00190   /* set flag to request thread termination */
00191   thread->terminate = 1;
00192 #ifdef __alpha
00193   /* on Alpha platfrom we need to do a memory barrier
00194      here to be sure that the flags are visible on
00195      all CPUs. This is not portable, we should e.g.
00196      use atomic_t here for passing the information.
00197   */
00198   mb();
00199 #endif
00200   kill_proc(SIGKILL, thread->pid, 1);
00201   
00202   /* block till thread terminated */
00203   down(&thread->startstop_sem);
00204 }
00205 
00206 static void setup_thread(my_threads *thread)
00207 {
00208   /* lock the kernel */
00209   lock_kernel();
00210   
00211   /* fill in thread structure */
00212   thread->thread = current;
00213   
00214   /* set signal mask to what we want to respond */
00215   siginitsetinv(&current->blocked, sigmask(SIGKILL)|sigmask(SIGINT)|sigmask(SIGTERM));
00216   
00217   /* initialise wait queue */
00218   thread->queue = NULL;
00219   
00220   /* initialise termination flag */
00221   thread->terminate = 0;
00222   
00223   /* let others run */
00224   unlock_kernel();
00225   
00226   /* tell the creator that we are ready and let him run */
00227   up(&thread->startstop_sem);
00228   
00229 }
00230 
00231 static void leave_thread(my_threads *thread)
00232 {
00233   /* we are terminating */
00234   
00235   /* lock the kernel, the exit will unlock it */
00236   thread->thread = NULL;
00237 #ifdef __alpha
00238   mb();
00239 #endif
00240   /* notify the kill_thread() routine that we are terminating. */
00241   up(&thread->startstop_sem);
00242 }
00243 
00244 /**************************************************************************************************************************************/
00247 void print_tab(void){
00248   int i,j;
00249   for(i=0;i<NB_MAX_INDEX;i++){
00250     printk("[%u] nb=%u", i, tab[i].nb);
00251     for(j=0;j<tab[i].nb;j++){
00252       if(j<NB_METRICS){
00253         printk(" id[%u]=%u metrics[%u]=%u", j, tab[i].id[j], j , tab[i].metrics[j]);
00254       }
00255     }
00256     printk("\n");
00257   }
00258   printk("\n");
00259 } 
00260 
00261 /**************************************************************************************************************************************/
00271 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){
00272   int i,j;
00273   //printk("[XMM] New metric registered\n");
00274   for(i=0;i<NB_MAX_INDEX;i++){
00275     if(tab[i].id[0]!=0){//metric already configured
00276       if((tab[i].frequency==freq) && (strcmp(tab[i].dev_name,dev)==0) && (strcmp(tab[i].macadd,mac)==0)){
00277         if(tab[i].nb<NB_METRICS){
00278           for(j=0;((j<tab[i].nb) && (j<NB_METRICS));j++){
00279             if((tab[i].id[j]==id) && (tab[i].metrics[j]==metric) &&  (tab[i].function[j]==pf)){//already present
00280               return;
00281             }
00282           }
00283           tab[i].id[tab[i].nb]=id;
00284           tab[i].metrics[tab[i].nb]=metric;
00285           tab[i].function[tab[i].nb]=pf;
00286           tab[i].nb=(tab[i].nb)+1;
00287           printk ( "nb = %u", tab[i].nb);
00288           return;
00289         }
00290       }
00291     }
00292   }
00293   
00294   for(i=0;i<NB_MAX_INDEX;i++){//frequency not present
00295     printk("[XMM] New metric registered\n");
00296     if(tab[i].id[0]==0){
00297       tab[i].index=i+1;
00298       tab[i].nb=1;
00299       tab[i].id[0]=id;
00300       tab[i].metrics[0]=metric;
00301       strncpy(tab[i].dev_name, dev, IFNAMESIZ+1); 
00302       strncpy(tab[i].macadd, mac, IEEE80211_MAC_ADDR_LEN+1); 
00303       tab[i].frequency=freq;
00304       tab[i].function[0]=pf;
00305       /* create a new kernel thread */
00306       if(tab[i].frequency!=0){//no sending report
00307         launch_thread(thread_function, &tab[i], &kthreads[i]);
00308       }
00309       return;
00310     }
00311   }
00312 }
00313 XIAN_EXPORT_SYMBOL(register_id);
00314 
00315 /**************************************************************************************************************************************/
00324 void register_id_no_report(unsigned int id, unsigned int metric, char dev[IFNAMESIZ+1], char mac[IEEE80211_MAC_ADDR_LEN+1], void * pf){
00325   register_id(id, metric, dev, mac, 0, pf);
00326 }
00327 XIAN_EXPORT_SYMBOL(register_id_no_report);
00328 
00329 /**************************************************************************************************************************************/
00335 void unregister_id(unsigned int id, unsigned int metric){
00336   int bool;
00337   int i,j,k;
00338   bool=0;
00339   for(i=0;i<NB_MAX_INDEX;i++){//find where is the metric
00340     for(j=0;j<tab[i].nb;j++){
00341       if((tab[i].id[j]==id)&&(tab[i].metrics[j]==metric)){
00342         if(tab[i].nb==1){
00343           tab[i].index=0;
00344           tab[i].id[0]=0;
00345           tab[i].nb=0;
00346           /* terminate the kernel thread */
00347           if(tab[i].frequency!=0){//no sending report
00348             kill_thread(&kthreads[i]);
00349           }
00350         }else{//metric is not alone
00351           for(k=0;k<tab[i].nb;k++){//frequency not present
00352             if(bool==0){//metric already unregistered => recopy k to k-1
00353               tab[i].id[k-1]=tab[i].id[k];
00354               tab[i].metrics[k-1]=tab[i].metrics[k];
00355               tab[i].function[k-1]=tab[i].function[k];
00356               tab[i].value[k-1]=tab[i].value[k];
00357             } 
00358             if(tab[i].metrics[k]==metric){
00359               bool=0;
00360             }
00361           }
00362           tab[i].nb--;
00363         }
00364       }
00365     }
00366   }
00367 }
00368 XIAN_EXPORT_SYMBOL(unregister_id);
00369 
00370 /**************************************************************************************************************************************/
00376 int XIAN_Manager_receive(unsigned char *saddr, struct xian_msg *stat){
00377   int i,j,k;
00378   unsigned char mac_broad_converted[ETH_ALEN];
00379   convert_mac_addr("ff:ff:ff:ff:ff:ff", mac_broad_converted, 0);
00380   /*
00381   printk("[XIAN MANAGER] Metrics received");
00382   printk(" version=%u", stat->version);
00383   printk(" sequence_number=%u", stat->id);  
00384   printk(" length=%u\n", stat->length);  
00385   */
00386   for(i=0; i<stat->length; i++){//xian_msg
00387     for(j=0;j<NB_MAX_INDEX;j++){//tab
00388       if(tab[j].index!=0){
00389         //if((strcmp_mac(saddr,tab[j].macadd)==0)||(strcmp_mac(saddr,mac_broad_converted)==0)){//metric founded
00390         for(k=0;k<tab[j].nb;k++){//tab[j]
00391           if(tab[j].metrics[k]==stat->msg[i].type){
00392             unsigned char mac_saddr[IEEE80211_MAC_ADDR_LEN+1];
00393             convert_hexamac(saddr,mac_saddr);
00394             tab[j].function[k](mac_saddr, &stat->msg[i]);
00395           }
00396         }
00397       }
00398     }
00399   }
00400   return 0;
00401 }
00402 XIAN_EXPORT_SYMBOL(XIAN_Manager_receive);
00403 
00404 int xian_man_init(void){
00405   int i;
00406   printk("Init XIAN XMM (XIAN Metric Manager module)\n");
00407   //registration for XIAN Handler
00408   config_relay(&XIAN_Manager_receive);
00409 
00410   memset(&tab, 0, sizeof(tab));
00411   for(i=0;i<NB_MAX_INDEX;i++){  
00412     //initialisation of metric_conf
00413     tab[i].index=0;
00414     tab[i].id[0]=0;
00415     tab[i].nb=0;
00416     //print_tab();
00417   }
00418   tab_mac_to_broadcast=NULL;
00419   return 0;
00420 }
00421 
00422 void xian_man_exit(void){
00423   int i;
00424   config_relay(NULL);
00425   //kill thread
00426   for(i=0; i<NB_MAX_INDEX; i++){
00427     kill_thread(&kthreads[i]);
00428   }
00429   printk("Unload XIAN XMM (XIAN Metric Manager module)\n");
00430 }
00431 
00432 module_init(xian_man_init);
00433 module_exit(xian_man_exit);
00434 
00435 /**************************************************************************************************************************************/
00444 struct xian_float get_metric(char dev_name[IFNAMESIZ+1], char macaddr[IEEE80211_MAC_ADDR_LEN+1], unsigned int metric, unsigned int *code_err){
00445   unsigned char mac_addr_converted[ETH_ALEN];
00446   struct xian_float value;
00447   unsigned int id_error;
00448   value=int2xian_float(0);
00449 
00450   convert_mac_addr(macaddr, mac_addr_converted, &(id_error));  
00451   //get metric => test on metric to call the good function like itm.c
00452   if(metric>181){
00453     value=get_xian_stat(macaddr,dev_name,metric,code_err);
00454     if(*code_err==UNKNOW_METRIC){
00455       printk("[XMM] Unknown Specified  Metric.\n");
00456     }
00457   }else{
00458   switch (metric){
00459     //NODE METRICS
00460   case NODE_TXPOWER:
00461     value=int2xian_float(get_node_txpower(mac_addr_converted,dev_name,code_err));
00462     break;
00463   case NODE_RSSI:
00464     value=int2xian_float(get_node_rssi(mac_addr_converted,dev_name,code_err));
00465     break;
00466   case NODE_NEGOTIATED_RATE:
00467     value=int2xian_float(get_node_negotiated_rate(mac_addr_converted,dev_name,code_err));
00468     break;
00469   case NODE_RX_DATA:
00470     value=int2xian_float(get_node_rx_data(mac_addr_converted,dev_name,code_err));
00471     break;
00472   case NODE_RX_MGMT:
00473     value=int2xian_float(get_node_rx_mgmt(mac_addr_converted,dev_name,code_err));
00474     break;
00475   case NODE_RX_CTRL:
00476     value=int2xian_float(get_node_rx_ctrl(mac_addr_converted,dev_name,code_err));
00477     break;
00478   case NODE_RX_UCAST:
00479     value=int2xian_float(get_node_rx_ucast(mac_addr_converted,dev_name,code_err));
00480     break;
00481   case NODE_RX_MCAST:
00482     value=int2xian_float(get_node_rx_mcast(mac_addr_converted,dev_name,code_err));
00483     break;
00484   case NODE_RX_BYTES:
00485     value=int2xian_float(get_node_rx_bytes(mac_addr_converted,dev_name,code_err));
00486     break;
00487   case NODE_RX_BEACONS:
00488     value=int2xian_float(get_node_rx_beacons(mac_addr_converted,dev_name,code_err));
00489     break;
00490   case NODE_RX_PROBERESP:
00491     value=int2xian_float(get_node_rx_proberesp(mac_addr_converted,dev_name,code_err));
00492     break;
00493   case NODE_RX_DUP:
00494     value=int2xian_float(get_node_rx_dup(mac_addr_converted,dev_name,code_err));
00495     break;
00496   case NODE_RX_NOPRIVACY:
00497     value=int2xian_float(get_node_rx_noprivacy(mac_addr_converted,dev_name,code_err));
00498     break;
00499   case NODE_RX_WEPFAIL:
00500     value=int2xian_float(get_node_rx_wepfail(mac_addr_converted,dev_name,code_err));
00501     break;
00502   case NODE_RX_DEMICFAIL:
00503     value=int2xian_float(get_node_rx_demicfail(mac_addr_converted,dev_name,code_err));
00504     break;
00505   case NODE_RX_DECAP:
00506     value=int2xian_float(get_node_rx_decap(mac_addr_converted,dev_name,code_err));
00507     break;
00508   case NODE_RX_DEFRAG:
00509     value=int2xian_float(get_node_rx_defrag(mac_addr_converted,dev_name,code_err));
00510     break;
00511   case NODE_RX_DISASSOC:
00512     value=int2xian_float(get_node_rx_disassoc(mac_addr_converted,dev_name,code_err));
00513     break;
00514   case NODE_RX_DEAUTH:
00515     value=int2xian_float(get_node_rx_deauth(mac_addr_converted,dev_name,code_err));
00516     break;
00517   case NODE_RX_DECRYPTCRC:
00518     value=int2xian_float(get_node_rx_decryptcrc(mac_addr_converted,dev_name,code_err));
00519     break;
00520   case NODE_RX_UNAUTH:
00521     value=int2xian_float(get_node_rx_unauth(mac_addr_converted,dev_name,code_err));
00522     break;
00523   case NODE_RX_UNENCRYPTED:
00524     value=int2xian_float(get_node_rx_unencrypted(mac_addr_converted,dev_name,code_err));
00525     break;
00526   case NODE_TX_DATA:
00527     value=int2xian_float(get_node_tx_data(mac_addr_converted,dev_name,code_err));
00528     break;
00529   case NODE_TX_MGMT:
00530     value=int2xian_float(get_node_tx_mgmt(mac_addr_converted,dev_name,code_err));
00531     break;
00532   case NODE_TX_UCAST:
00533     value=int2xian_float(get_node_tx_ucast(mac_addr_converted,dev_name,code_err));
00534     break;
00535   case NODE_TX_MCAST:
00536     value=int2xian_float(get_node_tx_mcast(mac_addr_converted,dev_name,code_err));
00537     break;
00538   case NODE_TX_BYTES:
00539     value=int2xian_float(get_node_tx_bytes(mac_addr_converted,dev_name,code_err));
00540     break;
00541   case NODE_TX_PROBEREQ:
00542     value=int2xian_float(get_node_tx_probereq(mac_addr_converted,dev_name,code_err));
00543     break;
00544   case NODE_TX_NOVLANTAG:
00545     value=int2xian_float(get_node_tx_novlantag(mac_addr_converted,dev_name,code_err));
00546     break;
00547   case NODE_TX_VLANMISMATCH:
00548     value=int2xian_float(get_node_tx_vlanmismatch(mac_addr_converted,dev_name,code_err));
00549     break;
00550   case NODE_PS_DISCARD:
00551     value=int2xian_float(get_node_ps_discard(mac_addr_converted,dev_name,code_err));
00552     break;
00553   case NODE_TX_ASSOC:
00554     value=int2xian_float(get_node_tx_assoc(mac_addr_converted,dev_name,code_err));
00555     break;
00556   case NODE_TX_ASSOC_FAIL:
00557     value=int2xian_float(get_node_tx_assoc_fail(mac_addr_converted,dev_name,code_err));
00558     break;
00559   case NODE_TX_AUTH:
00560     value=int2xian_float(get_node_tx_auth(mac_addr_converted,dev_name,code_err));
00561     break;
00562   case NODE_TX_AUTH_FAIL:
00563     value=int2xian_float(get_node_tx_auth_fail(mac_addr_converted,dev_name,code_err));
00564     break;
00565   case NODE_TX_DEAUTH:
00566     value=int2xian_float(get_node_tx_deauth(mac_addr_converted,dev_name,code_err));
00567     break;
00568   case NODE_TX_DEAUTH_CODE:
00569     value=int2xian_float(get_node_tx_deauth_code(mac_addr_converted,dev_name,code_err));
00570     break;
00571   case NODE_TX_DISASSOC:
00572     value=int2xian_float(get_node_tx_disassoc(mac_addr_converted,dev_name,code_err));
00573     break;
00574   case NODE_TX_DISASSOC_CODE:
00575     value=int2xian_float(get_node_tx_disassoc_code(mac_addr_converted,dev_name,code_err));
00576     break;
00577   case NODE_ON_TX_ERR:
00578     value=int2xian_float(get_node_on_tx_err(mac_addr_converted,dev_name,code_err));
00579     break;
00580   case NODE_ON_TX_OK:
00581     value=int2xian_float(get_node_on_tx_ok(mac_addr_converted,dev_name,code_err));
00582     break;
00583   case NODE_ON_TX_RETR:
00584     value=int2xian_float(get_node_on_tx_retr(mac_addr_converted,dev_name,code_err));
00585     break;
00586     //AST METRICS
00587   case AST_WATCHDOG:
00588     value=int2xian_float(get_ast_watchdog(dev_name,code_err));
00589     break;
00590   case AST_HARDWARE:
00591     value=int2xian_float(get_ast_hardware(dev_name,code_err));
00592     break;
00593   case AST_BMISS:
00594     break;
00595     value=int2xian_float(get_ast_bmiss(dev_name,code_err));
00596     break;
00597   case AST_BSTUCK:
00598     value=int2xian_float(get_ast_bstuck(dev_name,code_err));
00599     break;
00600   case AST_RXORN:
00601     value=int2xian_float(get_ast_rxorn(dev_name,code_err));
00602     break;
00603   case AST_RXEOL:
00604     value=int2xian_float(get_ast_rxeol(dev_name,code_err));
00605     break;
00606   case AST_TXURN:
00607     value=int2xian_float(get_ast_txurn(dev_name,code_err));
00608     break;
00609   case AST_MIB:
00610     value=int2xian_float(get_ast_mib(dev_name,code_err));
00611     break;
00612   case AST_INTRCOAL:
00613     value=int2xian_float(get_ast_intrcoal(dev_name,code_err));
00614     break;
00615   case AST_TX_PACKETS:
00616     value=int2xian_float(get_ast_tx_packets(dev_name,code_err));
00617     break;
00618   case AST_TX_MGMT:
00619     value=int2xian_float(get_ast_tx_mgmt(dev_name,code_err));
00620     break;
00621   case AST_TX_DISCARD:
00622     value=int2xian_float(get_ast_tx_discard(dev_name,code_err));
00623     break;
00624   case AST_TX_INVALID:
00625     value=int2xian_float(get_ast_tx_invalid(dev_name,code_err));
00626     break;
00627   case AST_TX_QSTOP:
00628     value=int2xian_float(get_ast_tx_qstop(dev_name,code_err));
00629     break;
00630   case AST_TX_ENCAP:
00631     value=int2xian_float(get_ast_tx_encap(dev_name,code_err));
00632     break;
00633   case AST_TX_NONODE:
00634     value=int2xian_float(get_ast_tx_nonode(dev_name,code_err));
00635     break;
00636   case AST_TX_NOBUF:
00637     value=int2xian_float(get_ast_tx_nobuf(dev_name,code_err));
00638     break;
00639   case AST_TX_NOBUFMGT:
00640     value=int2xian_float(get_ast_tx_nobufmgt(dev_name,code_err));
00641     break;
00642   case AST_TX_LINEAR:
00643     value=int2xian_float(get_ast_tx_linear(dev_name,code_err));
00644     break;
00645   case AST_TX_NODATA:
00646     value=int2xian_float(get_ast_tx_nodata(dev_name,code_err));
00647     break;
00648   case AST_TX_BUSDMA:
00649     value=int2xian_float(get_ast_tx_busdma(dev_name,code_err));
00650     break;
00651   case AST_TX_XRETRIES:
00652     value=int2xian_float(get_ast_tx_xretries(dev_name,code_err));
00653     break;
00654   case AST_TX_FIFOERR:
00655     value=int2xian_float(get_ast_tx_fifoerr(dev_name,code_err));
00656     break;
00657   case AST_TX_FILTERED:
00658     value=int2xian_float(get_ast_tx_filtered(dev_name,code_err));
00659     break;
00660   case AST_TX_SHORTRETRY:
00661     value=int2xian_float(get_ast_tx_shortretry(dev_name,code_err));
00662     break;
00663   case AST_TX_LONGRETRY:
00664     value=int2xian_float(get_ast_tx_longretry(dev_name,code_err));
00665     break;
00666   case AST_TX_BADRATE:
00667     value=int2xian_float(get_ast_tx_badrate(dev_name,code_err));
00668     break;
00669   case AST_TX_NOACK:
00670     value=int2xian_float(get_ast_tx_noack(dev_name,code_err));
00671     break;
00672   case AST_TX_RTS:
00673     value=int2xian_float(get_ast_tx_rts(dev_name,code_err));
00674     break;
00675   case AST_TX_CTS:
00676     value=int2xian_float(get_ast_tx_cts(dev_name,code_err));
00677     break;
00678   case AST_TX_SHORTPRE:
00679     value=int2xian_float(get_ast_tx_shortpre(dev_name,code_err));
00680     break;
00681   case AST_TX_ALTRATE:
00682     value=int2xian_float(get_ast_tx_altrate(dev_name,code_err));
00683     break;
00684   case AST_TX_PROTECT:
00685     value=int2xian_float(get_ast_tx_protect(dev_name,code_err));
00686     break;
00687   case AST_TX_CTSBURST:
00688     value=int2xian_float(get_ast_tx_ctsburst(dev_name,code_err));
00689     break;
00690   case AST_TX_CTSEXT:
00691     value=int2xian_float(get_ast_tx_ctsext(dev_name,code_err));
00692     break;
00693   case AST_RX_NOBUF:
00694     value=int2xian_float(get_ast_rx_nobuf(dev_name,code_err));
00695     break;
00696   case AST_RX_BUSDMA:
00697     value=int2xian_float(get_ast_rx_busdma(dev_name,code_err));
00698     break;
00699   case AST_RX_ORN:
00700     value=int2xian_float(get_ast_rx_orn(dev_name,code_err));
00701     break;
00702   case AST_RX_CRCERR:
00703     value=int2xian_float(get_ast_rx_crcerr(dev_name,code_err));
00704     break;
00705   case AST_RX_FIFOERR:
00706     value=int2xian_float(get_ast_rx_fifoerr(dev_name,code_err));
00707     break;
00708   case AST_RX_BADCRYPT:
00709     value=int2xian_float(get_ast_rx_badcrypt(dev_name,code_err));
00710     break;
00711   case AST_RX_BADMIC:
00712     value=int2xian_float(get_ast_rx_badmic(dev_name,code_err));
00713     break;
00714   case AST_RX_PHYERR:
00715     value=int2xian_float(get_ast_rx_phyerr(dev_name,code_err));
00716     break;
00717   case AST_RX_TOOSHORT:
00718     value=int2xian_float(get_ast_rx_tooshort(dev_name,code_err));
00719     break;
00720   case AST_RX_TOOBIG:
00721     value=int2xian_float(get_ast_rx_toobig(dev_name,code_err));
00722     break;
00723   case AST_RX_PACKETS:
00724     value=int2xian_float(get_ast_rx_packets(dev_name,code_err));
00725     break;
00726   case AST_RX_MGT:
00727     value=int2xian_float(get_ast_rx_mgt(dev_name,code_err));
00728     break;
00729   case AST_RX_CTL:
00730     value=int2xian_float(get_ast_rx_ctl(dev_name,code_err));
00731     break;
00732   case AST_TX_RSSI:
00733     value=int2xian_float(get_ast_tx_rssi(dev_name,code_err));
00734     break;
00735   case AST_RX_RSSI:
00736     value=int2xian_float(get_ast_rx_rssi(dev_name,code_err));
00737     break;
00738   case AST_BE_XMIT:
00739     value=int2xian_float(get_ast_be_xmit(dev_name,code_err));
00740     break;
00741   case AST_BE_NOBUF:
00742     value=int2xian_float(get_ast_be_nobuf(dev_name,code_err));
00743     break;
00744   case AST_PER_CAL:
00745     value=int2xian_float(get_ast_per_cal(dev_name,code_err));
00746     break;
00747   case AST_PER_CALFAIL:
00748     value=int2xian_float(get_ast_per_calfail(dev_name,code_err));
00749     break;
00750   case AST_PER_RFGAIN:
00751     value=int2xian_float(get_ast_per_rfgain(dev_name,code_err));
00752     break;
00753   case AST_RATE_CALLS:
00754     value=int2xian_float(get_ast_rate_calls(dev_name,code_err));
00755     break;
00756   case AST_RATE_RAISE:
00757     value=int2xian_float(get_ast_rate_raise(dev_name,code_err));
00758     break;
00759   case AST_RATE_DROP:
00760     value=int2xian_float(get_ast_rate_drop(dev_name,code_err));
00761     break;
00762   case AST_ANT_DEFSWITCH:
00763     value=int2xian_float(get_ast_ant_defswitch(dev_name,code_err));
00764     break;
00765   case AST_ANT_TXSWITCH:
00766     value=int2xian_float(get_ast_ant_txswitch(dev_name,code_err));
00767     break;
00768     //IS METRICS
00769   case IS_RX_BADVERSION:
00770     value=int2xian_float(get_is_rx_badversion(dev_name,code_err));
00771     break;
00772   case IS_RX_TOOSHORT:
00773     value=int2xian_float(get_is_rx_tooshort(dev_name,code_err));
00774     break;
00775   case IS_RX_WRONGBSS:
00776     value=int2xian_float(get_is_rx_wrongbss(dev_name,code_err));
00777     break;
00778   case IS_RX_DUP:
00779     value=int2xian_float(get_is_rx_dup(dev_name,code_err));
00780     break;
00781   case IS_RX_WRONGDIR:
00782     value=int2xian_float(get_is_rx_wrongdir(dev_name,code_err));
00783     break;
00784   case IS_RX_MCASTECHO:
00785     value=int2xian_float(get_is_rx_mcastecho(dev_name,code_err));
00786     break;
00787   case IS_RX_NOTASSOC:
00788     value=int2xian_float(get_is_rx_notassoc(dev_name,code_err));
00789     break;
00790   case IS_RX_NOPRIVACY:
00791     value=int2xian_float(get_is_rx_noprivacy(dev_name,code_err));
00792     break;
00793   case IS_RX_UNENCRYPTED:
00794     value=int2xian_float(get_is_rx_unencrypted(dev_name,code_err));
00795     break;
00796   case IS_RX_WEPFAIL:
00797     value=int2xian_float(get_is_rx_wepfail(dev_name,code_err));
00798     break;
00799   case IS_RX_DECAP:
00800     value=int2xian_float(get_is_rx_decap(dev_name,code_err));
00801     break;
00802   case IS_RX_MGTDISCARD:
00803     value=int2xian_float(get_is_rx_mgtdiscard(dev_name,code_err));
00804     break;
00805   case IS_RX_CTL:
00806     value=int2xian_float(get_is_rx_ctl(dev_name,code_err));
00807     break;
00808   case IS_RX_BEACON:
00809     value=int2xian_float(get_is_rx_beacon(dev_name,code_err));
00810     break;
00811   case IS_RX_RSTOOBIG:
00812     value=int2xian_float(get_is_rx_rstoobig(dev_name,code_err));
00813     break;
00814   case IS_RX_ELEM_MISSING:
00815     value=int2xian_float(get_is_rx_elem_missing(dev_name,code_err));
00816     break;
00817   case IS_RX_ELEM_TOOBIG:
00818     value=int2xian_float(get_is_rx_elem_toobig(dev_name,code_err));
00819     break;
00820   case IS_RX_ELEM_TOOSMALL:
00821     value=int2xian_float(get_is_rx_elem_toosmall(dev_name,code_err));
00822     break;
00823   case IS_RX_ELEM_UNKNOWN:
00824     value=int2xian_float(get_is_rx_elem_unknown(dev_name,code_err));
00825     break;
00826   case IS_RX_BADCHAN:
00827     value=int2xian_float(get_is_rx_badchan(dev_name,code_err));
00828     break;
00829   case IS_RX_CHANMISMATCH:
00830     value=int2xian_float(get_is_rx_chanmismatch(dev_name,code_err));
00831     break;
00832   case IS_RX_NODEALLOC:
00833     value=int2xian_float(get_is_rx_nodealloc(dev_name,code_err));
00834     break;
00835   case IS_RX_SSIDMISMATCH:
00836     value=int2xian_float(get_is_rx_ssidmismatch(dev_name,code_err));
00837     break;
00838   case IS_RX_AUTH_UNSUPPORTED:
00839     value=int2xian_float(get_is_rx_auth_unsupported(dev_name,code_err));
00840     break;
00841   case IS_RX_AUTH_FAIL:
00842     value=int2xian_float(get_is_rx_auth_fail(dev_name,code_err));
00843     break;
00844   case IS_RX_AUTH_COUNTERMEASURES:
00845     value=int2xian_float(get_is_rx_auth_countermeasures(dev_name,code_err));
00846     break;
00847   case IS_RX_ASSOC_BSS:
00848     value=int2xian_float(get_is_rx_assoc_bss(dev_name,code_err));
00849     break;
00850   case IS_RX_ASSOC_NOTAUTH:
00851     value=int2xian_float(get_is_rx_assoc_notauth(dev_name,code_err));
00852     break;
00853   case IS_RX_ASSOC_CAPMISMATCH:
00854     value=int2xian_float(get_is_rx_assoc_capmismatch(dev_name,code_err));
00855     break;
00856   case IS_RX_ASSOC_NORATE:
00857     value=int2xian_float(get_is_rx_assoc_norate(dev_name,code_err));
00858     break;
00859   case IS_RX_ASSOC_BADWPAIE:
00860     value=int2xian_float(get_is_rx_assoc_badwpaie(dev_name,code_err));
00861     break;
00862   case IS_RX_DEAUTH:
00863     value=int2xian_float(get_is_rx_deauth(dev_name,code_err));
00864     break;
00865   case IS_RX_DISASSOC:
00866     value=int2xian_float(get_is_rx_disassoc(dev_name,code_err));
00867     break;
00868   case IS_RX_BADSUBTYPE:
00869     value=int2xian_float(get_is_rx_badsubtype(dev_name,code_err));
00870     break;
00871   case IS_RX_NOBUF:
00872     value=int2xian_float(get_is_rx_nobuf(dev_name,code_err));
00873     break;
00874   case IS_RX_DECRYPTCRC:
00875     value=int2xian_float(get_is_rx_decryptcrc(dev_name,code_err));
00876     break;
00877   case IS_RX_AHDEMO_MGT:
00878     value=int2xian_float(get_is_rx_ahdemo_mgt(dev_name,code_err));
00879     break;
00880   case IS_RX_BAD_AUTH:
00881     value=int2xian_float(get_is_rx_bad_auth(dev_name,code_err));
00882     break;
00883   case IS_RX_UNAUTH:
00884     value=int2xian_float(get_is_rx_unauth(dev_name,code_err));
00885     break;/* BUG
00886   case IS_RX_BADKEYID:
00887     value=int2xian_float(get_is_rx_badkeyid(dev_name,code_err));
00888     break;
00889   case IS_RX_CCMPREPLAY:
00890     value=int2xian_float(get_is_rx_ccmpreplay(dev_name,code_err));
00891     break;
00892   case IS_RX_CCMPFORMAT:
00893     value=int2xian_float(get_is_rx_ccmpformat(dev_name,code_err));
00894     break;
00895   case IS_RX_CCMPMIC:
00896     value=int2xian_float(get_is_rx_ccmpmic(dev_name,code_err));
00897     break;
00898   case IS_RX_TKIPREPLAY:
00899     value=int2xian_float(get_is_rx_tkipreplay(dev_name,code_err));
00900     break;
00901   case IS_RX_TKIPFORMAT:
00902     value=int2xian_float(get_is_rx_tkipformat(dev_name,code_err));
00903     break;
00904   case IS_RX_TKIPMIC:
00905     value=int2xian_float(get_is_rx_tkipmic(dev_name,code_err));
00906     break;
00907   case IS_RX_TKIPICV:
00908     value=int2xian_float(get_is_rx_tkipicv(dev_name,code_err));
00909     break;
00910   case IS_RX_BADCIPHER:
00911     value=int2xian_float(get_is_rx_badcipher(dev_name,code_err));
00912     break;
00913   case IS_RX_NOCIPHERCTX:
00914     value=int2xian_float(get_is_rx_nocipherctx(dev_name,code_err));
00915     break;
00916   case IS_RX_ACL:
00917     value=int2xian_float(get_is_rx_acl(dev_name,code_err));
00918     break;
00919   case IS_TX_NOBUF:
00920     value=int2xian_float(get_is_tx_nobuf(dev_name,code_err));
00921     break;
00922   case IS_TX_NONODE:
00923     value=int2xian_float(get_is_tx_nonode(dev_name,code_err));
00924     break;
00925   case IS_TX_UNKNOWNMGT:
00926     value=int2xian_float(get_is_tx_unknownmgt(dev_name,code_err));
00927     break;
00928   case IS_TX_BADCIPHER:
00929     value=int2xian_float(get_is_tx_badcipher(dev_name,code_err));
00930     break;
00931   case IS_TX_NODEFKEY:
00932     value=int2xian_float(get_is_tx_nodefkey(dev_name,code_err));
00933     break;
00934   case IS_TX_NOHEADROOM:
00935     value=int2xian_float(get_is_tx_noheadroom(dev_name,code_err));
00936     break;
00937   case IS_SCAN_ACTIVE:
00938     value=int2xian_float(get_is_scan_active(dev_name,code_err));
00939     break;
00940   case IS_SCAN_PASSIVE:
00941     value=int2xian_float(get_is_scan_passive(dev_name,code_err));
00942     break;
00943   case IS_NODE_TIMEOUT:
00944     value=int2xian_float(get_is_node_timeout(dev_name,code_err));
00945     break;
00946   case IS_CRYPTO_NOMEM:
00947     value=int2xian_float(get_is_crypto_nomem(dev_name,code_err));
00948     break;
00949   case IS_CRYPTO_TKIP:
00950     value=int2xian_float(get_is_crypto_tkip(dev_name,code_err));
00951     break;
00952   case IS_CRYPTO_TKIPENMIC:
00953     value=int2xian_float(get_is_crypto_tkipenmic(dev_name,code_err));
00954     break;
00955   case IS_CRYPTO_TKIPDEMIC:
00956     value=int2xian_float(get_is_crypto_tkipdemic(dev_name,code_err));
00957     break;
00958   case IS_CRYPTO_TKIPCM:
00959     value=int2xian_float(get_is_crypto_tkipcm(dev_name,code_err));
00960     break;
00961   case IS_CRYPTO_CCMP:
00962     value=int2xian_float(get_is_crypto_ccmp(dev_name,code_err));
00963     break;
00964   case IS_CRYPTO_WEP:
00965     value=int2xian_float(get_is_crypto_wep(dev_name,code_err));
00966     break;
00967   case IS_CRYPTO_SETKEY_CIPHER:
00968     value=int2xian_float(get_is_crypto_setkey_cipher(dev_name,code_err));
00969     break;
00970   case IS_CRYPTO_SETKEY_NOKEY:
00971     value=int2xian_float(get_is_crypto_setkey_nokey(dev_name,code_err));
00972     break;
00973   case IS_CRYPTO_DELKEY:
00974     value=int2xian_float(get_is_crypto_delkey(dev_name,code_err));
00975     break;
00976   case IS_CRYPTO_BADCIPHER:
00977     value=int2xian_float(get_is_crypto_badcipher(dev_name,code_err));
00978     break;
00979   case IS_CRYPTO_NOCIPHER:
00980     value=int2xian_float(get_is_crypto_nocipher(dev_name,code_err));
00981     break;
00982   case IS_CRYPTO_ATTACHFAIL:
00983     value=int2xian_float(get_is_crypto_attachfail(dev_name,code_err));
00984     break;
00985   case IS_CRYPTO_SWFALLBACK:
00986     value=int2xian_float(get_is_crypto_swfallback(dev_name,code_err));
00987     break;
00988   case IS_CRYPTO_KEYFAIL:
00989     value=int2xian_float(get_is_crypto_keyfail(dev_name,code_err));
00990     break;
00991   case IS_CRYPTO_ENMICFAIL:
00992     value=int2xian_float(get_is_crypto_enmicfail(dev_name,code_err));
00993     break;
00994   case IS_IBSS_CAPMISMATCH:
00995     value=int2xian_float(get_is_ibss_capmismatch(dev_name,code_err));
00996     break;
00997   case IS_IBSS_NORATE:
00998     value=int2xian_float(get_is_ibss_norate(dev_name,code_err));
00999     break;
01000   case IS_PS_UNASSOC:
01001     value=int2xian_float(get_is_ps_unassoc(dev_name,code_err));
01002     break;
01003   case IS_PS_BADAID:
01004     value=int2xian_float(get_is_ps_badaid(dev_name,code_err));
01005     break;
01006   case IS_PS_QEMPTY:
01007     value=int2xian_float(get_is_ps_qempty(dev_name,code_err));
01008     break;*/
01009   default :
01010     {
01011       if(*code_err==UNKNOW_METRIC){
01012         printk("[XMM] Unknown Specified  Metric.\n");
01013       }
01014       break;
01015     }
01016   }
01017   }//END ELSE
01018   return value;
01019 }
01020 XIAN_EXPORT_SYMBOL(get_metric);
01021 
01022 
01023 /**************************************************************************************************************************************/
01028 void thread_function(my_threads *thread){
01029   int i,j;
01030   unsigned long timeout;
01031   unsigned int code_err;
01032   unsigned char mac[ETH_ALEN];
01033   struct xian_float value;
01034   struct metric_conf *tmp;
01035   struct tab_mac *tmp_mac;
01036   struct qos_metric_proto_msg msg;  
01037   /* setup the thread environment */
01038   setup_thread(thread);
01039    
01040   print_tab();
01041   tmp=(struct metric_conf *)thread->data;
01042   if(tmp->index==0){
01043     leave_thread(thread);
01044     return;
01045   }
01046   strcpy(msg.macaddr, tmp->macadd);
01047   strcpy(msg.dev_name, tmp->dev_name);
01048      
01049   code_err = 0;
01050  
01051   while(1){
01052     msg.nb=0;
01053     if(strncmp(msg.macaddr, "FF:FF:FF:FF:FF:FF", IEEE80211_MAC_ADDR_LEN)==0){
01054       //send metric with macadd present in tab_mac_to_broadcast
01055       tmp_mac=tab_mac_to_broadcast;
01056       i=0;
01057       while((tmp_mac!=NULL) && (i<NB_METRICS)){
01058         i++;
01059         convert_mac_addr(tmp_mac->mac, mac, 0);
01060         for(j=0;(j<NB_METRICS)&&(j<tmp->nb);j++){
01061           value=get_metric(msg.dev_name, tmp_mac->mac, tmp->metrics[j], &code_err);
01062           //insert_metric in the XIAN message
01063           kinsert_metric(&msg, tmp->metrics[j], tmp->id[j], 0, mac, value);//TODO encoding_type
01064         }
01065         tmp_mac=tmp_mac->next;
01066       }
01067       if(tab_mac_to_broadcast==NULL){
01068         convert_mac_addr(msg.macaddr, mac, 0);
01069         for(j=0;(j<NB_METRICS)&&(j<tmp->nb);j++){
01070           value=get_metric(msg.dev_name, msg.macaddr, tmp->metrics[j], &code_err);
01071           kinsert_metric(&msg, tmp->metrics[j], tmp->id[j], 0, mac, value);//TODO encoding_type
01072         }
01073       }
01074       //send_metric if last metric
01075      
01076       ksend_metric(msg.dev_name, msg.macaddr, msg, &code_err);
01077     }else{//No broadcast
01078       for(i=0;(i<tmp->nb) && (i<NB_METRICS);i++){
01079         tmp->value[i]=get_metric(msg.dev_name, msg.macaddr, tmp->metrics[i], &code_err);
01080         convert_mac_addr(msg.macaddr, mac, 0);
01081         //insert_metric in the XIAN message
01082         kinsert_metric(&msg, tmp->metrics[i], tmp->id[i], 0, mac, tmp->value[i]);//TODO encoding_type
01083         
01084         if((i==((tmp->nb)-1))||(i==((NB_METRICS)-1))){
01085           //send_metric if last metric
01086           ksend_metric(msg.dev_name, msg.macaddr, msg, &code_err);
01087         }
01088       }
01089     }
01090     //mdelay(tmp->frequency);//CPU => 100%
01091     //msleep(tmp->frequency);//not present in kernel 2.4
01092     timeout = ((HZ * tmp->frequency + 999) / 1000) + 1;
01093     set_current_state(TASK_UNINTERRUPTIBLE);
01094     timeout = schedule_timeout(timeout);
01095     if (thread->terminate)
01096       {
01097         /* we received a request to terminate ourself */
01098         break;    
01099       }
01100   }
01101   
01102   /* here we go only in case of termination of the thread */
01103   /* cleanup the thread, leave */
01104   
01105   leave_thread(thread);
01106 }
01107 

Generated on Mon Jan 21 12:31:46 2008 for XIAN by  doxygen 1.5.3