XIAN: /home/tai/chorist/xian-1.2/src/usi.c Source File

00001 
00023 /************************************************************************************************/
00029 #include "stdio.h"
00030 #include "sys/types.h"
00031 #include "unistd.h"
00032 #include "fcntl.h"
00033 #include <string.h>
00034 
00035 #include "include/itm.h"
00036 #include "include/usi.h"
00037 
00038 /***************************************************************************************************
00039  ***************************************************************************************************
00040  *
00041  *  NODE METRICS OFFERED 
00042  *
00043  *  - rx data frame
00044  *  - rx management frames
00045  *  - rx control frames
00046  *  - rx unicast frames
00047  *  - rx multi/broadcast frames
00048  *  - rx data count (bytes)
00049  *  - rx beacon frames
00050  *  - rx probe response frames
00051  *  - rx discard 'cuz dup
00052  *  - rx w/ wep but privacy off
00053  *  - rx wep processing failed
00054  *  - rx demic failed
00055  *  - rx decapsulation failed
00056  *  - rx defragmentation failed
00057  *  - rx disassociation
00058  *  - rx deauthentication
00059  *  - rx decrypt failed on crc
00060  *  - rx on unauthorized port
00061  *  - rx unecrypted w/ privacy
00062  *   
00063  *  - tx data frames
00064  *  - tx management frames
00065  *  - tx unicast frames
00066  *  - tx multi/broadcast frames
00067  *  - tx data count (bytes)
00068  *  - tx probe request frames
00069  *  - tx discard 'cuz no tag
00070  *  - tx discard 'cuz bad tag
00071  *  - ps discard 'cuz of age
00072  *  
00073  *  => MIB-related state
00074  *
00075  *  - [re]associations
00076  *  - [re]association failures
00077  *  - [re]authentications
00078  *  - [re]authentication failures
00079  *  - deauthentications
00080  *  - last deauth reason
00081  *  - disassociations
00082  *  - last disassociation reason
00083  * 
00084  *  - negotiated rate or transmission rate
00085  *  - rssi
00086  *  - transmit power metric
00087  *
00088  *  - tx !ok packet (error count of tx frame with no ack)
00089  *  - tx ok packet count 
00090  *  - tx retry count
00091  *
00092  ***************************************************************************************************
00093  ***************************************************************************************************/
00094 
00095 /**************************************************************************************************************************************/
00101 struct xian_float xian_float_add(struct xian_float a, struct xian_float b){
00102   struct xian_float value;
00103   value.numerator=0;
00104   value.denominator=0;
00105   if(a.denominator==0){
00106     return b;
00107   }else{
00108     if(b.denominator==0){
00109     return a;
00110     }else{
00111       value.denominator=a.denominator*b.denominator;
00112       value.numerator=(a.numerator*b.denominator)+(b.numerator*a.denominator);
00113       return value;
00114     }
00115   }
00116 }
00117 
00118 /**************************************************************************************************************************************/
00124 struct xian_float xian_float_mult(struct xian_float a, struct xian_float b){
00125   struct xian_float value;
00126   value.numerator=a.numerator*b.numerator;
00127   value.denominator=a.denominator*b.denominator;
00128   return value;
00129 }
00130 
00131 /**************************************************************************************************************************************/
00137 struct xian_float xian_float_div(struct xian_float a, struct xian_float b){
00138   struct xian_float value;
00139   struct xian_float inv;
00140   inv.numerator=b.denominator;
00141   inv.denominator=b.numerator;
00142   if(b.numerator!=0){
00143     value=xian_float_mult(a, inv);
00144   }
00145   value=xian_float_mult(a, inv);
00146   return value;
00147 }
00148 
00149 /**************************************************************************************************************************************/
00155 int xian_float_cmp(struct xian_float a, struct xian_float b){
00156   int c,d;
00157   c=a.numerator*b.denominator;
00158   d=b.numerator*a.denominator;
00159   if(c==d){//a==b
00160     return 0;
00161   }else{
00162     if(c<d){//a<b
00163       return -1;
00164     }else{//a>b
00165       return 1;
00166     }
00167   }
00168 }
00169 
00170 /**************************************************************************************************************************************/
00175 struct xian_float int2xian_float(unsigned int x){
00176   struct xian_float value;
00177   value.numerator=x;
00178   value.denominator=1;
00179   return value;
00180 }
00181 
00182 /**************************************************************************************************************************************/
00187 float xian_float2float(struct xian_float x){
00188   float f=0;
00189   if(x.denominator!=0){
00190     f=x.numerator/x.denominator;
00191   }
00192   return f;  
00193 }
00194 
00195 /******************************************************************************************************/
00203 struct xian_float
00204 get_xian_stat_xian_float(char * macadd,
00205               char * dev_name,
00206               unsigned int id_conf,
00207               unsigned int * code_err)
00208 {
00209   int file, nb_write, nb_read;
00210   struct qos_metric_stat_msg msg;
00211 
00212   msg.struct_id    = T_QOS_METRIC_STAT_MSG;
00213   msg.type_msg     = T_QUERY_MSG;
00214   msg.id_error     = NO_ERRORS;
00215   msg.id=id_conf;
00216 
00217   if (macadd)
00218     strcpy ((char *) msg.macaddr, macadd);
00219   else
00220     msg.macaddr[0] = '\0';
00221   if (dev_name)
00222     strcpy((char *) msg.dev_name, dev_name);
00223   else
00224     msg.dev_name[0] = '\0';
00225 
00226   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
00227     {
00228       fprintf(stderr, "Can't open: ");
00229       perror(CROSS_LAYER_DEV_NAME_PATH);
00230       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
00231       msg.type_msg = T_ERROR_MSG;
00232     }
00233 
00234   nb_write = write(file, &msg, sizeof(msg));
00235   nb_read = read(file, &msg, sizeof(msg));
00236 
00237   if (nb_read == 0)
00238     {
00239       msg.id_error = COULD_NOT_READ_UNIX_DEV;
00240       msg.type_msg = T_ERROR_MSG;
00241     }  
00242   close(file);
00243   (*code_err) = msg.id_error;
00244   return msg.metric.xian_float;
00245 }
00246 
00247 /******************************************************************************************************/
00255 float
00256 get_xian_stat_float(char * macadd,
00257               char * dev_name,
00258               unsigned int id_conf,
00259               unsigned int * code_err)
00260 {
00261   float f;
00262   struct xian_float value;
00263   f=0;
00264   value=get_xian_stat_xian_float(macadd,dev_name,id_conf,code_err);
00265   if(value.denominator!=0){
00266     f=(float)value.numerator/(float)value.denominator;
00267   }
00268   return f;
00269 }
00270 
00271 /******************************************************************************************************/
00278 void insert_metric(struct qos_metric_proto_msg *msg, unsigned int type, unsigned int id, unsigned long long value){
00279   int nb;
00280   nb=msg->nb;
00281   if(nb<NB_METRICS){
00282     msg->metric_name[nb]=type;
00283     msg->id[nb]=id;
00284     msg->metric[nb].int64=value;
00285     msg->nb=nb+1;
00286   }
00287 }
00288 
00289 /******************************************************************************************************/
00296 void
00297 send_metric(char * macadd,
00298             char * dev_name,
00299             struct qos_metric_proto_msg msg,
00300             unsigned int * code_err)
00301 {
00302   int file, nb_write;
00303   
00304   msg.struct_id    = T_QOS_METRIC_PROTO_MSG;
00305   msg.type_msg     = T_SEND_MSG;
00306   msg.id_error     = NO_ERRORS;
00307   if (macadd)
00308     strcpy ((char *) msg.macaddr, macadd);
00309   else
00310     msg.macaddr[0] = '\0';
00311   if (dev_name)
00312     strcpy((char *) msg.dev_name, dev_name);
00313   else
00314     msg.dev_name[0] = '\0';
00315  
00316   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
00317     {
00318       fprintf(stderr, "Can't open: ");
00319       perror(CROSS_LAYER_DEV_NAME_PATH);
00320       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
00321       msg.type_msg = T_ERROR_MSG;
00322     }
00323 
00324   nb_write = write(file, &msg, sizeof(msg));
00325       
00326   close(file);
00327   (*code_err) = msg.id_error;
00328 }
00329 
00330 /******************************************************************************************************/
00338 unsigned int
00339 get_node_rx_data(char * macadd,
00340                  char * dev_name,
00341                  unsigned int * code_err)
00342 {
00343   int file, nb_write, nb_read;
00344   struct qos_metric_node_msg msg;
00345 
00346   msg.struct_id    = T_QOS_METRIC_NODE_MSG;
00347   msg.type_msg     = T_QUERY_MSG;
00348   msg.id_error     = NO_ERRORS;
00349   msg.metric.int32 = 0; 
00350 
00351   if (macadd)
00352     strcpy ((char *) msg.macaddr, macadd);
00353   else
00354     msg.macaddr[0] = '\0';
00355   msg.metric_name = NODE_RX_DATA;
00356   if (dev_name)
00357     strcpy((char *) msg.dev_name, dev_name);
00358   else
00359     msg.dev_name[0] = '\0';
00360 
00361   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
00362     {
00363       fprintf(stderr, "Can't open: ");
00364       perror(CROSS_LAYER_DEV_NAME_PATH);
00365       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
00366       msg.type_msg = T_ERROR_MSG;
00367     }
00368 
00369   nb_write = write(file, &msg, sizeof(msg));
00370   nb_read = read(file, &msg, sizeof(msg));
00371 
00372   if (nb_read == 0)
00373     {
00374       msg.id_error = COULD_NOT_READ_UNIX_DEV;
00375       msg.type_msg = T_ERROR_MSG;
00376     }  
00377   close(file);
00378 
00379   (*code_err) = msg.id_error;
00380   return (unsigned int) msg.metric.int32;
00381 }
00382 
00383 
00384 /*******************************************************************************************************/
00392 unsigned int
00393 get_node_rx_mgmt(char * macadd,
00394                  char * dev_name,
00395                  unsigned int * code_err)
00396 {
00397   int file, nb_write, nb_read;
00398   struct qos_metric_node_msg msg;
00399 
00400   msg.struct_id    = T_QOS_METRIC_NODE_MSG;
00401   msg.type_msg     = T_QUERY_MSG;
00402   msg.id_error     = NO_ERRORS;
00403   msg.metric.int32 = 0; 
00404 
00405   if (macadd)
00406     strcpy ((char *) msg.macaddr, macadd);
00407   else
00408     msg.macaddr[0] = '\0';
00409   msg.metric_name = NODE_RX_MGMT;
00410   if (dev_name)
00411     strcpy((char *) msg.dev_name, dev_name);
00412   else
00413     msg.dev_name[0] = '\0';
00414 
00415   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
00416     {
00417       fprintf(stderr, "Can't open: ");
00418       perror(CROSS_LAYER_DEV_NAME_PATH);
00419       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
00420       msg.type_msg = T_ERROR_MSG;
00421     }
00422   nb_write = write(file, &msg, sizeof(msg));
00423   nb_read = read(file, &msg, sizeof(msg));
00424   if (nb_read == 0)
00425     {
00426       msg.id_error = COULD_NOT_READ_UNIX_DEV;
00427       msg.type_msg = T_ERROR_MSG;
00428     }  
00429   close(file);
00430 
00431   (*code_err) = msg.id_error;
00432   return (unsigned int) msg.metric.int32;
00433 }
00434 
00435 
00436 /*********************************************************************************************************/
00444 unsigned int
00445 get_node_rx_ctrl(char * macadd,
00446                  char * dev_name,
00447                  unsigned int * code_err)
00448 {
00449   int file, nb_write, nb_read;
00450   struct qos_metric_node_msg msg;
00451 
00452   msg.struct_id    = T_QOS_METRIC_NODE_MSG;
00453   msg.type_msg     = T_QUERY_MSG;
00454   msg.id_error     = NO_ERRORS;
00455   msg.metric.int32 = 0; 
00456 
00457   if (macadd)
00458     strcpy ((char *) msg.macaddr, macadd);
00459   else
00460     msg.macaddr[0] = '\0';
00461   msg.metric_name = NODE_RX_CTRL;
00462   if (dev_name)
00463     strcpy((char *) msg.dev_name, dev_name);
00464   else
00465     msg.dev_name[0] = '\0';
00466 
00467   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
00468     {
00469       fprintf(stderr, "Can't open: ");
00470       perror(CROSS_LAYER_DEV_NAME_PATH);
00471       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
00472       msg.type_msg = T_ERROR_MSG;
00473     }
00474   nb_write = write(file, &msg, sizeof(msg));
00475   nb_read = read(file, &msg, sizeof(msg));
00476   if (nb_read == 0)
00477     {
00478       msg.id_error = COULD_NOT_READ_UNIX_DEV;
00479       msg.type_msg = T_ERROR_MSG;
00480     }  
00481   close(file);
00482 
00483   (*code_err) = msg.id_error;
00484   return (unsigned int) msg.metric.int32;
00485 }
00486 
00487 
00488 /***********************************************************************************************************/
00496 unsigned int
00497 get_node_rx_ucast(char * macadd,
00498                   char * dev_name,
00499                   unsigned int * code_err)
00500 {
00501   int file, nb_write, nb_read;
00502   struct qos_metric_node_msg msg;
00503 
00504   msg.struct_id    = T_QOS_METRIC_NODE_MSG;
00505   msg.type_msg     = T_QUERY_MSG;
00506   msg.id_error     = NO_ERRORS;
00507   msg.metric.int32 = 0; 
00508 
00509   if (macadd)
00510     strcpy ((char *) msg.macaddr, macadd);
00511   else
00512     msg.macaddr[0] = '\0';
00513   msg.metric_name = NODE_RX_UCAST;
00514   if (dev_name)
00515     strcpy((char *) msg.dev_name, dev_name);
00516   else
00517     msg.dev_name[0] = '\0';
00518 
00519   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
00520     {
00521       fprintf(stderr, "Can't open: ");
00522       perror(CROSS_LAYER_DEV_NAME_PATH);
00523       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
00524       msg.type_msg = T_ERROR_MSG;
00525     }
00526   nb_write = write(file, &msg, sizeof(msg));
00527   nb_read = read(file, &msg, sizeof(msg));
00528   if (nb_read == 0)
00529     {
00530       msg.id_error = COULD_NOT_READ_UNIX_DEV;
00531       msg.type_msg = T_ERROR_MSG;
00532     }  
00533   close(file);
00534 
00535   (*code_err) = msg.id_error;
00536   return (unsigned int) msg.metric.int32;
00537 }
00538 
00539 
00540 /***********************************************************************************************************************
00541  *  This function allows to get rx unicast/broadcast frames stats metric of a given node in function of its mac adress.   
00542  *  @param macadd MAC Address of a specified node formatted as follow XX:XX:XX:XX:XX:XX
00543  *  @param dev_name name of the network interface 
00544  *  @param code_err output a code error if an error occurs. 
00545  *  @return rx unicast/broadcast frames stats  metric of the node 
00546  **********************************************************************************************************************/
00547 
00548 unsigned int
00549 get_node_rx_mcast(char * macadd,
00550                   char * dev_name,
00551                   unsigned int * code_err)
00552 {
00553   int file, nb_write, nb_read;
00554   struct qos_metric_node_msg msg;
00555 
00556   msg.struct_id    = T_QOS_METRIC_NODE_MSG;
00557   msg.type_msg     = T_QUERY_MSG;
00558   msg.id_error     = NO_ERRORS;
00559   msg.metric.int32 = 0; 
00560 
00561   if (macadd)
00562     strcpy ((char *) msg.macaddr, macadd);
00563   else
00564     msg.macaddr[0] = '\0';
00565   msg.metric_name = NODE_RX_MCAST;
00566   if (dev_name)
00567     strcpy((char *) msg.dev_name, dev_name);
00568   else
00569     msg.dev_name[0] = '\0';
00570 
00571   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
00572     {
00573       fprintf(stderr, "Can't open: ");
00574       perror(CROSS_LAYER_DEV_NAME_PATH);
00575       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
00576       msg.type_msg = T_ERROR_MSG;
00577     }
00578   nb_write = write(file, &msg, sizeof(msg));
00579   nb_read = read(file, &msg, sizeof(msg));
00580   if (nb_read == 0)
00581     {
00582       msg.id_error = COULD_NOT_READ_UNIX_DEV;
00583       msg.type_msg = T_ERROR_MSG;
00584     }  
00585   close(file);
00586 
00587   (*code_err) = msg.id_error;
00588   return (unsigned int) msg.metric.int32;
00589 }
00590 
00591 /******************************************************************************************************************/
00599 unsigned long long 
00600 get_node_rx_bytes(char * macadd,
00601                   char * dev_name,
00602                   unsigned int * code_err)
00603 {
00604   int file, nb_write, nb_read;
00605   struct qos_metric_node_msg msg;
00606 
00607   msg.struct_id    = T_QOS_METRIC_NODE_MSG;
00608   msg.type_msg     = T_QUERY_MSG;
00609   msg.id_error     = NO_ERRORS;
00610   msg.metric.int64 = 0; 
00611 
00612   if (macadd)
00613     strcpy ((char *) msg.macaddr, macadd);
00614   else
00615     msg.macaddr[0] = '\0';
00616   msg.metric_name = NODE_RX_BYTES;
00617   if (dev_name)
00618     strcpy((char *) msg.dev_name, dev_name);
00619   else
00620     msg.dev_name[0] = '\0';
00621 
00622   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
00623     {
00624       fprintf(stderr, "Can't open: ");
00625       perror(CROSS_LAYER_DEV_NAME_PATH);
00626       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
00627       msg.type_msg = T_ERROR_MSG;
00628     }
00629   nb_write = write(file, &msg, sizeof(msg));
00630   nb_read = read(file, &msg, sizeof(msg));
00631   if (nb_read == 0)
00632     {
00633       msg.id_error = COULD_NOT_READ_UNIX_DEV;
00634       msg.type_msg = T_ERROR_MSG;
00635     }  
00636   close(file);
00637 
00638   (*code_err) = msg.id_error;
00639   return (unsigned long long) msg.metric.int64;
00640 }
00641 
00642 
00643 /************************************************************************************************************/
00651 unsigned long long
00652 get_node_rx_beacons(char * macadd,
00653                     char * dev_name,
00654                     unsigned int * code_err)
00655 {
00656   int file, nb_write, nb_read;
00657   struct qos_metric_node_msg msg;
00658 
00659   msg.struct_id    = T_QOS_METRIC_NODE_MSG;
00660   msg.type_msg     = T_QUERY_MSG;
00661   msg.id_error     = NO_ERRORS;
00662   msg.metric.int64 = 0; 
00663 
00664   if (macadd)
00665     strcpy ((char *) msg.macaddr, macadd);
00666   else
00667     msg.macaddr[0] = '\0';
00668   msg.metric_name = NODE_RX_BEACONS;
00669   if (dev_name)
00670     strcpy((char *) msg.dev_name, dev_name);
00671   else
00672     msg.dev_name[0] = '\0';
00673 
00674   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
00675     {
00676       fprintf(stderr, "Can't open: ");
00677       perror(CROSS_LAYER_DEV_NAME_PATH);
00678       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
00679       msg.type_msg = T_ERROR_MSG;
00680     }
00681   nb_write = write(file, &msg, sizeof(msg));
00682   nb_read = read(file, &msg, sizeof(msg));
00683   if (nb_read == 0)
00684     {
00685       msg.id_error = COULD_NOT_READ_UNIX_DEV;
00686       msg.type_msg = T_ERROR_MSG;
00687     }  
00688   close(file);
00689 
00690   (*code_err) = msg.id_error;
00691   return (unsigned long long) msg.metric.int64;
00692 }
00693 
00694 
00695 /******************************************************************************************************************/
00703 unsigned int 
00704 get_node_rx_proberesp(char * macadd,
00705                       char * dev_name,
00706                       unsigned int * code_err)
00707 {
00708   int file, nb_write, nb_read;
00709   struct qos_metric_node_msg msg;
00710 
00711   msg.struct_id   = T_QOS_METRIC_NODE_MSG;
00712   msg.type_msg    = T_QUERY_MSG;
00713   msg.id_error    = NO_ERRORS;
00714   msg.metric.int32 = 0; 
00715 
00716   if (macadd)
00717     strcpy ((char *) msg.macaddr, macadd);
00718   else
00719     msg.macaddr[0] = '\0';
00720   msg.metric_name = NODE_RX_PROBERESP;
00721   if (dev_name)
00722     strcpy((char *) msg.dev_name, dev_name);
00723   else
00724     msg.dev_name[0] = '\0';
00725 
00726   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
00727     {
00728       fprintf(stderr, "Can't open: ");
00729       perror(CROSS_LAYER_DEV_NAME_PATH);
00730       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
00731       msg.type_msg = T_ERROR_MSG;
00732     }
00733   nb_write = write(file, &msg, sizeof(msg));
00734   nb_read = read(file, &msg, sizeof(msg));
00735   if (nb_read == 0)
00736     {
00737       msg.id_error = COULD_NOT_READ_UNIX_DEV;
00738       msg.type_msg = T_ERROR_MSG;
00739     }  
00740   close(file);
00741 
00742   (*code_err) = msg.id_error;
00743   return (unsigned int) msg.metric.int32;
00744 }
00745 
00746 
00747 /*************************************************************************************************************/
00755 unsigned int
00756 get_node_rx_dup(char * macadd,
00757                 char * dev_name,
00758                 unsigned int * code_err)
00759 {
00760   int file, nb_write, nb_read;
00761   struct qos_metric_node_msg msg;
00762 
00763   msg.struct_id   = T_QOS_METRIC_NODE_MSG;
00764   msg.type_msg    = T_QUERY_MSG;
00765   msg.id_error    = NO_ERRORS;
00766   msg.metric.int32 = 0; 
00767 
00768   if (macadd)
00769     strcpy ((char *) msg.macaddr, macadd);
00770   else
00771     msg.macaddr[0] = '\0';
00772   msg.metric_name = NODE_RX_DUP;
00773   if (dev_name)
00774     strcpy((char *) msg.dev_name, dev_name);
00775   else
00776     msg.dev_name[0] = '\0';
00777 
00778   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
00779     {
00780       fprintf(stderr, "Can't open: ");
00781       perror(CROSS_LAYER_DEV_NAME_PATH);
00782       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
00783       msg.type_msg = T_ERROR_MSG;
00784     }
00785   nb_write = write(file, &msg, sizeof(msg));
00786   nb_read = read(file, &msg, sizeof(msg));
00787   if (nb_read == 0)
00788     {
00789       msg.id_error = COULD_NOT_READ_UNIX_DEV;
00790       msg.type_msg = T_ERROR_MSG;
00791     }  
00792   close(file);
00793 
00794   (*code_err) = msg.id_error;
00795   return (unsigned int) msg.metric.int32;
00796 }
00797 
00798 
00799 /******************************************************************************************************************/
00807 unsigned int
00808 get_node_rx_noprivacy(char * macadd,
00809                       char * dev_name,
00810                       unsigned int * code_err)
00811 {
00812   int file, nb_write, nb_read;
00813   struct qos_metric_node_msg msg;
00814 
00815   msg.struct_id    = T_QOS_METRIC_NODE_MSG;
00816   msg.type_msg     = T_QUERY_MSG;
00817   msg.id_error     = NO_ERRORS;
00818   msg.metric.int32 = 0; 
00819 
00820   if (macadd)
00821     strcpy ((char *) msg.macaddr, macadd);
00822   else
00823     msg.macaddr[0] = '\0';
00824   msg.metric_name = NODE_RX_NOPRIVACY;
00825   if (dev_name)
00826     strcpy((char *) msg.dev_name, dev_name);
00827   else
00828     msg.dev_name[0] = '\0';
00829 
00830   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
00831     {
00832       fprintf(stderr, "Can't open: ");
00833       perror(CROSS_LAYER_DEV_NAME_PATH);
00834       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
00835       msg.type_msg = T_ERROR_MSG;
00836     }
00837   nb_write = write(file, &msg, sizeof(msg));
00838   nb_read = read(file, &msg, sizeof(msg));
00839   if (nb_read == 0)
00840     {
00841       msg.id_error = COULD_NOT_READ_UNIX_DEV;
00842       msg.type_msg = T_ERROR_MSG;
00843     }  
00844   close(file);
00845 
00846   (*code_err) = msg.id_error;
00847   return (unsigned int) msg.metric.int32;
00848 }
00849 
00850 /******************************************************************************************************************/
00858 unsigned int 
00859 get_node_rx_wepfail(char * macadd,
00860                     char * dev_name,
00861                     unsigned int * code_err)
00862 {
00863   int file, nb_write, nb_read;
00864   struct qos_metric_node_msg msg;
00865 
00866   msg.struct_id    = T_QOS_METRIC_NODE_MSG;
00867   msg.type_msg     = T_QUERY_MSG;
00868   msg.id_error     = NO_ERRORS;
00869   msg.metric.int32 = 0; 
00870 
00871   if (macadd)
00872     strcpy ((char *) msg.macaddr, macadd);
00873   else
00874     msg.macaddr[0] = '\0';
00875   msg.metric_name = NODE_RX_WEPFAIL;
00876   if (dev_name)
00877     strcpy((char *) msg.dev_name, dev_name);
00878   else
00879     msg.dev_name[0] = '\0';
00880 
00881   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
00882     {
00883       fprintf(stderr, "Can't open: ");
00884       perror(CROSS_LAYER_DEV_NAME_PATH);
00885       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
00886       msg.type_msg = T_ERROR_MSG;
00887     }
00888   nb_write = write(file, &msg, sizeof(msg));
00889   nb_read = read(file, &msg, sizeof(msg));
00890   if (nb_read == 0)
00891     {
00892       msg.id_error = COULD_NOT_READ_UNIX_DEV;
00893       msg.type_msg = T_ERROR_MSG;
00894     }  
00895   close(file);
00896 
00897   (*code_err) = msg.id_error;
00898   return (unsigned int) msg.metric.int32;
00899 }
00900 
00901 
00902 /*************************************************************************************************************/
00910 unsigned int
00911 get_node_rx_demicfail(char * macadd,
00912                       char * dev_name,
00913                       unsigned int * code_err)
00914 {
00915   int file, nb_write, nb_read;
00916   struct qos_metric_node_msg msg;
00917 
00918   msg.struct_id    = T_QOS_METRIC_NODE_MSG;
00919   msg.type_msg     = T_QUERY_MSG;
00920   msg.id_error     = NO_ERRORS;
00921   msg.metric.int32 = 0; 
00922 
00923   if (macadd)
00924     strcpy ((char *) msg.macaddr, macadd);
00925   else
00926     msg.macaddr[0] = '\0';
00927   msg.metric_name = NODE_RX_DEMICFAIL;
00928   if (dev_name)
00929     strcpy((char *) msg.dev_name, dev_name);
00930   else
00931     msg.dev_name[0] = '\0';
00932 
00933   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
00934     {
00935       fprintf(stderr, "Can't open: ");
00936       perror(CROSS_LAYER_DEV_NAME_PATH);
00937       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
00938       msg.type_msg = T_ERROR_MSG;
00939     }
00940   nb_write = write(file, &msg, sizeof(msg));
00941   nb_read = read(file, &msg, sizeof(msg));
00942   if (nb_read == 0)
00943     {
00944       msg.id_error = COULD_NOT_READ_UNIX_DEV;
00945       msg.type_msg = T_ERROR_MSG;
00946     }  
00947   close(file);
00948 
00949   (*code_err) = msg.id_error;
00950   return (unsigned int) msg.metric.int32;
00951 }
00952 
00953 /******************************************************************************************************************/
00961 unsigned int
00962 get_node_rx_decap(char * macadd,
00963                   char * dev_name,
00964                   unsigned int * code_err)
00965 {
00966   int file, nb_write, nb_read;
00967   struct qos_metric_node_msg msg;
00968 
00969   msg.struct_id    = T_QOS_METRIC_NODE_MSG;
00970   msg.type_msg     = T_QUERY_MSG;
00971   msg.id_error     = NO_ERRORS;
00972   msg.metric.int32 = 0; 
00973 
00974   if (macadd)
00975     strcpy ((char *) msg.macaddr, macadd);
00976   else
00977     msg.macaddr[0] = '\0';
00978   msg.metric_name = NODE_RX_DECAP;
00979   if (dev_name)
00980     strcpy((char *) msg.dev_name, dev_name);
00981   else
00982     msg.dev_name[0] = '\0';
00983 
00984   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
00985     {
00986       fprintf(stderr, "Can't open: ");
00987       perror(CROSS_LAYER_DEV_NAME_PATH);
00988       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
00989       msg.type_msg = T_ERROR_MSG;
00990     }
00991   nb_write = write(file, &msg, sizeof(msg));
00992   nb_read = read(file, &msg, sizeof(msg));
00993   if (nb_read == 0)
00994     {
00995       msg.id_error = COULD_NOT_READ_UNIX_DEV;
00996       msg.type_msg = T_ERROR_MSG;
00997     }  
00998   close(file);
00999 
01000   (*code_err) = msg.id_error;
01001   return (unsigned int) msg.metric.int32;
01002 }
01003 
01004 
01005 /******************************************************************************************************************/
01013 unsigned int 
01014 get_node_rx_defrag(char * macadd,
01015                    char * dev_name,
01016                    unsigned int * code_err)
01017 {
01018   int file, nb_write, nb_read;
01019   struct qos_metric_node_msg msg;
01020 
01021   msg.struct_id    = T_QOS_METRIC_NODE_MSG;
01022   msg.type_msg     = T_QUERY_MSG;
01023   msg.id_error     = NO_ERRORS;
01024   msg.metric.int32 = 0; 
01025   
01026   if (macadd)
01027     strcpy ((char *) msg.macaddr, macadd);
01028   else
01029     msg.macaddr[0] = '\0';
01030   msg.metric_name = NODE_RX_DEFRAG;
01031   if (dev_name)
01032     strcpy((char *) msg.dev_name, dev_name);
01033   else
01034     msg.dev_name[0] = '\0';
01035 
01036   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
01037     {
01038       fprintf(stderr, "Can't open: ");
01039       perror(CROSS_LAYER_DEV_NAME_PATH);
01040       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
01041       msg.type_msg = T_ERROR_MSG;
01042     }
01043   nb_write = write(file, &msg, sizeof(msg));
01044   nb_read = read(file, &msg, sizeof(msg));
01045   if (nb_read == 0)
01046     {
01047       msg.id_error = COULD_NOT_READ_UNIX_DEV;
01048       msg.type_msg = T_ERROR_MSG;
01049     }  
01050   close(file);
01051 
01052   (*code_err) = msg.id_error;
01053   return (unsigned int) msg.metric.int32;
01054 }
01055 
01056 
01057 /****************************************************************************************************************/
01065 unsigned int 
01066 get_node_rx_disassoc(char * macadd,
01067                      char * dev_name,
01068                      unsigned int * code_err)
01069 {
01070   int file, nb_write, nb_read;
01071   struct qos_metric_node_msg msg;
01072 
01073   msg.struct_id    = T_QOS_METRIC_NODE_MSG;
01074   msg.type_msg     = T_QUERY_MSG;
01075   msg.id_error     = NO_ERRORS;
01076   msg.metric.int32 = 0; 
01077 
01078   if (macadd)
01079     strcpy ((char *) msg.macaddr, macadd);
01080   else
01081     msg.macaddr[0] = '\0';
01082   msg.metric_name = NODE_RX_DISASSOC;
01083   if (dev_name)
01084     strcpy((char *) msg.dev_name, dev_name);
01085   else
01086     msg.dev_name[0] = '\0';
01087 
01088   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
01089     {
01090       fprintf(stderr, "Can't open: ");
01091       perror(CROSS_LAYER_DEV_NAME_PATH);
01092       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
01093       msg.type_msg = T_ERROR_MSG;
01094     }
01095   nb_write = write(file, &msg, sizeof(msg));
01096   nb_read = read(file, &msg, sizeof(msg));
01097   if (nb_read == 0)
01098     {
01099       msg.id_error = COULD_NOT_READ_UNIX_DEV;
01100       msg.type_msg = T_ERROR_MSG;
01101     }  
01102   close(file);
01103 
01104   (*code_err) = msg.id_error;
01105   return (unsigned int) msg.metric.int32;
01106 }
01107 
01108 
01109 /****************************************************************************************************************/
01117 unsigned int 
01118 get_node_rx_deauth(char * macadd,
01119                    char * dev_name,
01120                    unsigned int * code_err)
01121 {
01122   int file, nb_write, nb_read;
01123   struct qos_metric_node_msg msg;
01124 
01125   msg.struct_id    = T_QOS_METRIC_NODE_MSG;
01126   msg.type_msg     = T_QUERY_MSG;
01127   msg.id_error     = NO_ERRORS;
01128   msg.metric.int32 = 0; 
01129 
01130   if (macadd)
01131     strcpy ((char *) msg.macaddr, macadd);
01132   else
01133     msg.macaddr[0] = '\0';
01134   msg.metric_name = NODE_RX_DEAUTH;
01135   if (dev_name)
01136     strcpy((char *) msg.dev_name, dev_name);
01137   else
01138     msg.dev_name[0] = '\0';
01139 
01140   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
01141     {
01142       fprintf(stderr, "Can't open: ");
01143       perror(CROSS_LAYER_DEV_NAME_PATH);
01144       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
01145       msg.type_msg = T_ERROR_MSG;
01146     }
01147   nb_write = write(file, &msg, sizeof(msg));
01148   nb_read = read(file, &msg, sizeof(msg));
01149   if (nb_read == 0)
01150     {
01151       msg.id_error = COULD_NOT_READ_UNIX_DEV;
01152       msg.type_msg = T_ERROR_MSG;
01153     }  
01154   close(file);
01155 
01156   (*code_err) = msg.id_error;
01157   return (unsigned int) msg.metric.int32;
01158 }
01159 
01160 
01161 /******************************************************************************************************************/
01169 unsigned int
01170 get_node_rx_decryptcrc(char * macadd,
01171                        char * dev_name,
01172                        unsigned int * code_err)
01173 {
01174   int file, nb_write, nb_read;
01175   struct qos_metric_node_msg msg;
01176 
01177   msg.struct_id    = T_QOS_METRIC_NODE_MSG;
01178   msg.type_msg     = T_QUERY_MSG;
01179   msg.id_error     = NO_ERRORS;
01180   msg.metric.int32 = 0; 
01181 
01182   if (macadd)
01183     strcpy ((char *) msg.macaddr, macadd);
01184   else
01185     msg.macaddr[0] = '\0';
01186   msg.metric_name = NODE_RX_DECRYPTCRC;
01187   if (dev_name)
01188     strcpy((char *) msg.dev_name, dev_name);
01189   else
01190     msg.dev_name[0] = '\0';
01191 
01192   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
01193     {
01194       fprintf(stderr, "Can't open: ");
01195       perror(CROSS_LAYER_DEV_NAME_PATH);
01196       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
01197       msg.type_msg = T_ERROR_MSG;
01198     }
01199   nb_write = write(file, &msg, sizeof(msg));
01200   nb_read = read(file, &msg, sizeof(msg));
01201   if (nb_read == 0)
01202     {
01203       msg.id_error = COULD_NOT_READ_UNIX_DEV;
01204       msg.type_msg = T_ERROR_MSG;
01205     }  
01206   close(file);
01207 
01208   (*code_err) = msg.id_error;
01209   return (unsigned int) msg.metric.int32;
01210 }
01211 
01212 /**********************************************************************************************************************/
01220 unsigned int
01221 get_node_rx_unauth(char * macadd,
01222                    char * dev_name,
01223                    unsigned int * code_err)
01224 {
01225   int file, nb_write, nb_read;
01226   struct qos_metric_node_msg msg;
01227 
01228   msg.struct_id    = T_QOS_METRIC_NODE_MSG;
01229   msg.type_msg     = T_QUERY_MSG;
01230   msg.id_error     = NO_ERRORS;
01231   msg.metric.int32 = 0; 
01232 
01233   if (macadd)
01234     strcpy ((char *) msg.macaddr, macadd);
01235   else
01236     msg.macaddr[0] = '\0';
01237   msg.metric_name = NODE_RX_UNAUTH;
01238   if (dev_name)
01239     strcpy((char *) msg.dev_name, dev_name);
01240   else
01241     msg.dev_name[0] = '\0';
01242 
01243   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
01244     {
01245       fprintf(stderr, "Can't open: ");
01246       perror(CROSS_LAYER_DEV_NAME_PATH);
01247       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
01248       msg.type_msg = T_ERROR_MSG;
01249     }
01250   nb_write = write(file, &msg, sizeof(msg));
01251   nb_read = read(file, &msg, sizeof(msg));
01252   if (nb_read == 0)
01253     {
01254       msg.id_error = COULD_NOT_READ_UNIX_DEV;
01255       msg.type_msg = T_ERROR_MSG;
01256     }  
01257   close(file);
01258 
01259   (*code_err) = msg.id_error;
01260   return (unsigned int) msg.metric.int32;
01261 }
01262 
01263 
01264 /********************************************************************************************************************/
01272 unsigned int 
01273 get_node_rx_unencrypted(char * macadd,
01274                         char * dev_name,
01275                         unsigned int * code_err)
01276 {
01277   int file, nb_write, nb_read;
01278   struct qos_metric_node_msg msg;
01279 
01280   msg.struct_id    = T_QOS_METRIC_NODE_MSG;
01281   msg.type_msg     = T_QUERY_MSG;
01282   msg.id_error     = NO_ERRORS;
01283   msg.metric.int32 = 0; 
01284 
01285   if (macadd)
01286     strcpy ((char *) msg.macaddr, macadd);
01287   else
01288     msg.macaddr[0] = '\0';
01289   msg.metric_name = NODE_RX_UNENCRYPTED;
01290   if (dev_name)
01291     strcpy((char *) msg.dev_name, dev_name);
01292   else
01293     msg.dev_name[0] = '\0';
01294 
01295   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
01296     {
01297       fprintf(stderr, "Can't open: ");
01298       perror(CROSS_LAYER_DEV_NAME_PATH);
01299       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
01300       msg.type_msg = T_ERROR_MSG;
01301     }
01302   nb_write = write(file, &msg, sizeof(msg));
01303   nb_read = read(file, &msg, sizeof(msg));
01304   if (nb_read == 0)
01305     {
01306       msg.id_error = COULD_NOT_READ_UNIX_DEV;
01307       msg.type_msg = T_ERROR_MSG;
01308     }  
01309   close(file);
01310 
01311   (*code_err) = msg.id_error;
01312   return (unsigned int) msg.metric.int32;
01313 }
01314 
01315 /*****************************************************************************************************************/
01323 unsigned int
01324 get_node_tx_data(char * macadd,
01325                  char * dev_name,
01326                  unsigned int * code_err)
01327 {
01328   int file, nb_write, nb_read;
01329   struct qos_metric_node_msg msg;
01330 
01331   msg.struct_id   = T_QOS_METRIC_NODE_MSG;
01332   msg.type_msg    = T_QUERY_MSG;
01333   msg.id_error    = NO_ERRORS;
01334   msg.metric.int32 = 0; 
01335 
01336   if (macadd)
01337     strcpy ((char *) msg.macaddr, macadd);
01338   else
01339     msg.macaddr[0] = '\0';
01340   msg.metric_name = NODE_TX_DATA;
01341   if (dev_name)
01342     strcpy((char *) msg.dev_name, dev_name);
01343   else
01344     msg.dev_name[0] = '\0';
01345 
01346   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
01347     {
01348       fprintf(stderr, "Can't open: ");
01349       perror(CROSS_LAYER_DEV_NAME_PATH);
01350       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
01351       msg.type_msg = T_ERROR_MSG;
01352     }
01353   nb_write = write(file, &msg, sizeof(msg));
01354   nb_read = read(file, &msg, sizeof(msg));
01355   if (nb_read == 0)
01356     {
01357       msg.id_error = COULD_NOT_READ_UNIX_DEV;
01358       msg.type_msg = T_ERROR_MSG;
01359     }  
01360   close(file);
01361 
01362   (*code_err) = msg.id_error;
01363   return (unsigned int) msg.metric.int32;
01364 }
01365 
01366 
01367 /***************************************************************************************************************/
01375 unsigned int 
01376 get_node_tx_mgmt(char * macadd,
01377                  char * dev_name,
01378                  unsigned int * code_err)
01379 {
01380   int file, nb_write, nb_read;
01381   struct qos_metric_node_msg msg;
01382 
01383   msg.struct_id    = T_QOS_METRIC_NODE_MSG;
01384   msg.type_msg     = T_QUERY_MSG;
01385   msg.id_error     = NO_ERRORS;
01386   msg.metric.int32 = 0; 
01387 
01388   if (macadd)
01389     strcpy ((char *) msg.macaddr, macadd);
01390   else
01391     msg.macaddr[0] = '\0';
01392   msg.metric_name = NODE_TX_MGMT;
01393   if (dev_name)
01394     strcpy((char *) msg.dev_name, dev_name);
01395   else
01396     msg.dev_name[0] = '\0';
01397 
01398   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
01399     {
01400       fprintf(stderr, "Can't open: ");
01401       perror(CROSS_LAYER_DEV_NAME_PATH);
01402       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
01403       msg.type_msg = T_ERROR_MSG;
01404     }
01405   nb_write = write(file, &msg, sizeof(msg));
01406   nb_read = read(file, &msg, sizeof(msg));
01407   if (nb_read == 0)
01408     {
01409       msg.id_error = COULD_NOT_READ_UNIX_DEV;
01410       msg.type_msg = T_ERROR_MSG;
01411     }  
01412   close(file);
01413 
01414   (*code_err) = msg.id_error;
01415   return (unsigned int) msg.metric.int32;
01416 }
01417 
01418 /*************************************************************************************************************/
01426 unsigned int
01427 get_node_tx_ucast(char * macadd,
01428                   char * dev_name,
01429                   unsigned int * code_err)
01430 {
01431   int file, nb_write, nb_read;
01432   struct qos_metric_node_msg msg;
01433 
01434   msg.struct_id   = T_QOS_METRIC_NODE_MSG;
01435   msg.type_msg    = T_QUERY_MSG;
01436   msg.id_error    = NO_ERRORS;
01437   msg.metric.int32 = 0; 
01438 
01439   if (macadd)
01440     strcpy ((char *) msg.macaddr, macadd);
01441   else
01442     msg.macaddr[0] = '\0';
01443   msg.metric_name = NODE_TX_UCAST;
01444   if (dev_name)
01445     strcpy((char *) msg.dev_name, dev_name);
01446   else
01447     msg.dev_name[0] = '\0';
01448 
01449   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
01450     {
01451       fprintf(stderr, "Can't open: ");
01452       perror(CROSS_LAYER_DEV_NAME_PATH);
01453       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
01454       msg.type_msg = T_ERROR_MSG;
01455     }
01456   nb_write = write(file, &msg, sizeof(msg));
01457   nb_read = read(file, &msg, sizeof(msg));
01458   if (nb_read == 0)
01459     {
01460       msg.id_error = COULD_NOT_READ_UNIX_DEV;
01461       msg.type_msg = T_ERROR_MSG;
01462     }  
01463   close(file);
01464 
01465   (*code_err) = msg.id_error;
01466   return (unsigned int) msg.metric.int32;
01467 }
01468 
01469 /******************************************************************************************************************/
01477 unsigned int
01478 get_node_tx_mcast(char * macadd,
01479                   char * dev_name,
01480                   unsigned int * code_err)
01481 {
01482   int file, nb_write, nb_read;
01483   struct qos_metric_node_msg msg;
01484 
01485   msg.struct_id    = T_QOS_METRIC_NODE_MSG;
01486   msg.type_msg     = T_QUERY_MSG;
01487   msg.id_error     = NO_ERRORS;
01488   msg.metric.int32 = 0; 
01489 
01490   if (macadd)
01491     strcpy ((char *) msg.macaddr, macadd);
01492   else
01493     msg.macaddr[0] = '\0';
01494   msg.metric_name = NODE_TX_MCAST;
01495   if (dev_name)
01496     strcpy((char *) msg.dev_name, dev_name);
01497   else
01498     msg.dev_name[0] = '\0';
01499 
01500   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
01501     {
01502       fprintf(stderr, "Can't open: ");
01503       perror(CROSS_LAYER_DEV_NAME_PATH);
01504       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
01505       msg.type_msg = T_ERROR_MSG;
01506     }
01507   nb_write = write(file, &msg, sizeof(msg));
01508   nb_read = read(file, &msg, sizeof(msg));
01509   if (nb_read == 0)
01510     {
01511       msg.id_error = COULD_NOT_READ_UNIX_DEV;
01512       msg.type_msg = T_ERROR_MSG;
01513     }  
01514   close(file);
01515 
01516   (*code_err) = msg.id_error;
01517   return (unsigned int) msg.metric.int32;
01518 }
01519 
01520 
01521 /*************************************************************************************************************/
01529 unsigned long long 
01530 get_node_tx_bytes(char * macadd,
01531                   char * dev_name,
01532                   unsigned int * code_err)
01533 {
01534   int file, nb_write, nb_read;
01535   struct qos_metric_node_msg msg;
01536 
01537   msg.struct_id    = T_QOS_METRIC_NODE_MSG;
01538   msg.type_msg     = T_QUERY_MSG;
01539   msg.id_error     = NO_ERRORS;
01540   msg.metric.int64 = 0; 
01541 
01542   if (macadd)
01543     strcpy ((char *) msg.macaddr, macadd);
01544   else
01545     msg.macaddr[0] = '\0';
01546   msg.metric_name = NODE_TX_BYTES;
01547   if (dev_name)
01548     strcpy((char *) msg.dev_name, dev_name);
01549   else
01550     msg.dev_name[0] = '\0';
01551 
01552   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
01553     {
01554       fprintf(stderr, "Can't open: ");
01555       perror(CROSS_LAYER_DEV_NAME_PATH);
01556       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
01557       msg.type_msg = T_ERROR_MSG;
01558     }
01559   nb_write = write(file, &msg, sizeof(msg));
01560   nb_read = read(file, &msg, sizeof(msg));
01561   if (nb_read == 0)
01562     {
01563       msg.id_error = COULD_NOT_READ_UNIX_DEV;
01564       msg.type_msg = T_ERROR_MSG;
01565     }  
01566   close(file);
01567 
01568   (*code_err) = msg.id_error;
01569   return (unsigned long long) msg.metric.int64;
01570 }
01571 
01572 
01573 /****************************************************************************************************************/
01581 unsigned int 
01582 get_node_tx_probereq(char * macadd,
01583                      char * dev_name,
01584                      unsigned int * code_err)
01585 {
01586   int file, nb_write, nb_read;
01587   struct qos_metric_node_msg msg;
01588 
01589   msg.struct_id    = T_QOS_METRIC_NODE_MSG;
01590   msg.type_msg     = T_QUERY_MSG;
01591   msg.id_error     = NO_ERRORS;
01592   msg.metric.int32 = 0; 
01593 
01594   if (macadd)
01595     strcpy ((char *) msg.macaddr, macadd);
01596   else
01597     msg.macaddr[0] = '\0';
01598   msg.metric_name = NODE_TX_PROBEREQ;
01599   if (dev_name)
01600     strcpy((char *) msg.dev_name, dev_name);
01601   else
01602     msg.dev_name[0] = '\0';
01603   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
01604     {
01605       fprintf(stderr, "Can't open: ");
01606       perror(CROSS_LAYER_DEV_NAME_PATH);
01607       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
01608       msg.type_msg = T_ERROR_MSG;
01609     }
01610   nb_write = write(file, &msg, sizeof(msg));
01611   nb_read = read(file, &msg, sizeof(msg));
01612   if (nb_read == 0)
01613     {
01614       msg.id_error = COULD_NOT_READ_UNIX_DEV;
01615       msg.type_msg = T_ERROR_MSG;
01616     }  
01617   close(file);
01618 
01619   (*code_err) = msg.id_error;
01620   return (unsigned int) msg.metric.int32;
01621 }
01622 
01623 
01624 /****************************************************************************************************************/
01632 unsigned int
01633 get_node_tx_novlantag(char * macadd,
01634                       char * dev_name,
01635                       unsigned int * code_err)
01636 {
01637   int file, nb_write, nb_read;
01638   struct qos_metric_node_msg msg;
01639 
01640   msg.struct_id    = T_QOS_METRIC_NODE_MSG;
01641   msg.type_msg     = T_QUERY_MSG;
01642   msg.id_error     = NO_ERRORS;
01643   msg.metric.int32 = 0; 
01644 
01645   if (macadd)
01646     strcpy ((char *) msg.macaddr, macadd);
01647   else
01648     msg.macaddr[0] = '\0';
01649   msg.metric_name = NODE_TX_NOVLANTAG;
01650   if (dev_name)
01651     strcpy((char *) msg.dev_name, dev_name);
01652   else
01653     msg.dev_name[0] = '\0';
01654 
01655   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
01656     {
01657       fprintf(stderr, "Can't open: ");
01658       perror(CROSS_LAYER_DEV_NAME_PATH);
01659       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
01660       msg.type_msg = T_ERROR_MSG;
01661     }
01662   nb_write = write(file, &msg, sizeof(msg));
01663   nb_read = read(file, &msg, sizeof(msg));
01664   if (nb_read == 0)
01665     {
01666       msg.id_error = COULD_NOT_READ_UNIX_DEV;
01667       msg.type_msg = T_ERROR_MSG;
01668     }  
01669   close(file);
01670 
01671   (*code_err) = msg.id_error;
01672   return (unsigned int) msg.metric.int32;
01673 }
01674 
01675 /****************************************************************************************************************/
01683 unsigned int
01684 get_node_tx_vlanmismatch(char * macadd,
01685                          char * dev_name,
01686                          unsigned int * code_err)
01687 
01688 {
01689   int file, nb_write, nb_read;
01690   struct qos_metric_node_msg msg;
01691 
01692   msg.struct_id    = T_QOS_METRIC_NODE_MSG;
01693   msg.type_msg     = T_QUERY_MSG;
01694   msg.id_error     = NO_ERRORS;
01695   msg.metric.int32 = 0; 
01696 
01697   if (macadd)
01698     strcpy ((char *) msg.macaddr, macadd);
01699   else
01700     msg.macaddr[0] = '\0';
01701   msg.metric_name = NODE_TX_VLANMISMATCH;
01702   if (dev_name)
01703     strcpy((char *) msg.dev_name, dev_name);
01704   else
01705     msg.dev_name[0] = '\0';
01706 
01707   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
01708     {
01709       fprintf(stderr, "Can't open: ");
01710       perror(CROSS_LAYER_DEV_NAME_PATH);
01711       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
01712       msg.type_msg = T_ERROR_MSG;
01713     }
01714   nb_write = write(file, &msg, sizeof(msg));
01715   nb_read = read(file, &msg, sizeof(msg));
01716   if (nb_read == 0)
01717     {
01718       msg.id_error = COULD_NOT_READ_UNIX_DEV;
01719       msg.type_msg = T_ERROR_MSG;
01720     }  
01721   close(file);
01722 
01723   (*code_err) = msg.id_error;
01724   return (unsigned int) msg.metric.int32;
01725 }
01726 
01727 
01728 /*****************************************************************************************************************/
01736 unsigned int
01737 get_node_ps_discard(char * macadd,
01738                     char * dev_name,
01739                     unsigned int * code_err)
01740 {
01741   int file, nb_write, nb_read;
01742   struct qos_metric_node_msg msg;
01743 
01744   msg.struct_id    = T_QOS_METRIC_NODE_MSG;
01745   msg.type_msg     = T_QUERY_MSG;
01746   msg.id_error     = NO_ERRORS;
01747   msg.metric.int32 = 0; 
01748 
01749   if (macadd)
01750     strcpy ((char *) msg.macaddr, macadd);
01751   else
01752     msg.macaddr[0] = '\0';
01753   msg.metric_name = NODE_PS_DISCARD;
01754   if (dev_name)
01755     strcpy((char *) msg.dev_name, dev_name);
01756   else
01757     msg.dev_name[0] = '\0';
01758 
01759   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
01760     {
01761       fprintf(stderr, "Can't open: ");
01762       perror(CROSS_LAYER_DEV_NAME_PATH);
01763       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
01764       msg.type_msg = T_ERROR_MSG;
01765     }
01766   nb_write = write(file, &msg, sizeof(msg));
01767   nb_read = read(file, &msg, sizeof(msg));
01768   if (nb_read == 0)
01769     {
01770       msg.id_error = COULD_NOT_READ_UNIX_DEV;
01771       msg.type_msg = T_ERROR_MSG;
01772     }  
01773   close(file);
01774 
01775   (*code_err) = msg.id_error;
01776   return (unsigned int) msg.metric.int32;
01777 }
01778 
01779 /******************************************************************************************************************************/
01787 unsigned int
01788 get_node_tx_assoc(char * macadd,
01789                   char * dev_name,
01790                   unsigned int * code_err)
01791 {
01792   int file, nb_write, nb_read;
01793   struct qos_metric_node_msg msg;
01794 
01795   msg.struct_id    = T_QOS_METRIC_NODE_MSG;
01796   msg.type_msg     = T_QUERY_MSG;
01797   msg.id_error     = NO_ERRORS;
01798   msg.metric.int32 = 0; 
01799 
01800   if (macadd)
01801     strcpy ((char *) msg.macaddr, macadd);
01802   else
01803     msg.macaddr[0] = '\0';
01804   msg.metric_name = NODE_TX_ASSOC;
01805   if (dev_name)
01806     strcpy((char *) msg.dev_name, dev_name);
01807   else
01808     msg.dev_name[0] = '\0';
01809 
01810   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
01811     {
01812       fprintf(stderr, "Can't open: ");
01813       perror(CROSS_LAYER_DEV_NAME_PATH);
01814       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
01815       msg.type_msg = T_ERROR_MSG;
01816     }
01817   nb_write = write(file, &msg, sizeof(msg));
01818   nb_read = read(file, &msg, sizeof(msg));
01819   if (nb_read == 0)
01820     {
01821       msg.id_error = COULD_NOT_READ_UNIX_DEV;
01822       msg.type_msg = T_ERROR_MSG;
01823     }  
01824   close(file);
01825 
01826   (*code_err) = msg.id_error;
01827   return (unsigned int) msg.metric.int32;
01828 }
01829 
01830 
01831 /************************************************************************************************************************************/
01839 unsigned int 
01840 get_node_tx_assoc_fail(char * macadd,
01841                        char * dev_name,
01842                        unsigned int * code_err)
01843 {
01844   int file, nb_write, nb_read;
01845   struct qos_metric_node_msg msg;
01846 
01847   msg.struct_id    = T_QOS_METRIC_NODE_MSG;
01848   msg.type_msg     = T_QUERY_MSG;
01849   msg.id_error     = NO_ERRORS;
01850   msg.metric.int32 = 0; 
01851 
01852   if (macadd)
01853     strcpy ((char *) msg.macaddr, macadd);
01854   else
01855     msg.macaddr[0] = '\0';
01856   msg.metric_name = NODE_TX_ASSOC_FAIL;
01857   if (dev_name)
01858     strcpy((char *) msg.dev_name, dev_name);
01859   else
01860     msg.dev_name[0] = '\0';
01861 
01862   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
01863     {
01864       fprintf(stderr, "Can't open: ");
01865       perror(CROSS_LAYER_DEV_NAME_PATH);
01866       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
01867       msg.type_msg = T_ERROR_MSG;
01868     }
01869   nb_write = write(file, &msg, sizeof(msg));
01870   nb_read = read(file, &msg, sizeof(msg));
01871   if (nb_read == 0)
01872     {
01873       msg.id_error = COULD_NOT_READ_UNIX_DEV;
01874       msg.type_msg = T_ERROR_MSG;
01875     }  
01876   close(file);
01877 
01878   (*code_err) = msg.id_error;
01879   return (unsigned int) msg.metric.int32;
01880 }
01881 
01882 /*********************************************************************************************************************************/
01890 unsigned int 
01891 get_node_tx_auth(char * macadd,
01892                  char * dev_name,
01893                  unsigned int * code_err)
01894 {
01895   int file, nb_write, nb_read;
01896   struct qos_metric_node_msg msg;
01897 
01898   msg.struct_id    = T_QOS_METRIC_NODE_MSG;
01899   msg.type_msg     = T_QUERY_MSG;
01900   msg.id_error     = NO_ERRORS;
01901   msg.metric.int32 = 0; 
01902 
01903   if (macadd)
01904     strcpy ((char *) msg.macaddr, macadd);
01905   else
01906     msg.macaddr[0] = '\0';
01907   msg.metric_name = NODE_TX_AUTH;
01908   if (dev_name)
01909     strcpy((char *) msg.dev_name, dev_name);
01910   else
01911     msg.dev_name[0] = '\0';
01912 
01913   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
01914     {
01915       fprintf(stderr, "Can't open: ");
01916       perror(CROSS_LAYER_DEV_NAME_PATH);
01917       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
01918       msg.type_msg = T_ERROR_MSG;
01919     }
01920   nb_write = write(file, &msg, sizeof(msg));
01921   nb_read = read(file, &msg, sizeof(msg));
01922   if (nb_read == 0)
01923     {
01924       msg.id_error = COULD_NOT_READ_UNIX_DEV;
01925       msg.type_msg = T_ERROR_MSG;
01926     }  
01927   close(file);
01928 
01929   (*code_err) = msg.id_error;
01930   return (unsigned int) msg.metric.int32;
01931 }
01932 
01933 
01934 /**************************************************************************************************************************************/
01942 unsigned int 
01943 get_node_tx_auth_fail(char * macadd,
01944                       char * dev_name,
01945                       unsigned int * code_err)
01946 {
01947   int file, nb_write, nb_read;
01948   struct qos_metric_node_msg msg;
01949 
01950   msg.struct_id    = T_QOS_METRIC_NODE_MSG;
01951   msg.type_msg     = T_QUERY_MSG;
01952   msg.id_error     = NO_ERRORS;
01953   msg.metric.int32 = 0; 
01954 
01955   if (macadd)
01956     strcpy ((char *) msg.macaddr, macadd);
01957   else
01958     msg.macaddr[0] = '\0';
01959   msg.metric_name = NODE_TX_AUTH_FAIL;
01960   if (dev_name)
01961     strcpy((char *) msg.dev_name, dev_name);
01962   else
01963     msg.dev_name[0] = '\0';
01964 
01965   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
01966     {
01967       fprintf(stderr, "Can't open: ");
01968       perror(CROSS_LAYER_DEV_NAME_PATH);
01969       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
01970       msg.type_msg = T_ERROR_MSG;
01971     }
01972   nb_write = write(file, &msg, sizeof(msg));
01973   nb_read = read(file, &msg, sizeof(msg));
01974   if (nb_read == 0)
01975     {
01976       msg.id_error = COULD_NOT_READ_UNIX_DEV;
01977       msg.type_msg = T_ERROR_MSG;
01978     }  
01979   close(file);
01980 
01981   (*code_err) = msg.id_error;
01982   return (unsigned int) msg.metric.int32;
01983 }
01984 
01985 
01986 /**************************************************************************************************************************************/
01994 unsigned int 
01995 get_node_tx_deauth(char * macadd,
01996                    char * dev_name,
01997                    unsigned int * code_err)
01998 {
01999   int file, nb_write, nb_read;
02000   struct qos_metric_node_msg msg;
02001 
02002   msg.struct_id    = T_QOS_METRIC_NODE_MSG;
02003   msg.type_msg     = T_QUERY_MSG;
02004   msg.id_error     = NO_ERRORS;
02005   msg.metric.int32 = 0; 
02006 
02007   if (macadd)
02008     strcpy ((char *) msg.macaddr, macadd);
02009   else
02010     msg.macaddr[0] = '\0';
02011   msg.metric_name = NODE_TX_DEAUTH;
02012   if (dev_name)
02013     strcpy((char *) msg.dev_name, dev_name);
02014   else
02015     msg.dev_name[0] = '\0';
02016 
02017   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
02018     {
02019       fprintf(stderr, "Can't open: ");
02020       perror(CROSS_LAYER_DEV_NAME_PATH);
02021       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
02022       msg.type_msg = T_ERROR_MSG;
02023     }
02024   nb_write = write(file, &msg, sizeof(msg));
02025   nb_read = read(file, &msg, sizeof(msg));
02026   if (nb_read == 0)
02027     {
02028       msg.id_error = COULD_NOT_READ_UNIX_DEV;
02029       msg.type_msg = T_ERROR_MSG;
02030     }  
02031   close(file);
02032 
02033   (*code_err) = msg.id_error;
02034   return (unsigned int) msg.metric.int32;
02035 }
02036 
02037 
02038 /**************************************************************************************************************************************/
02046 unsigned int 
02047 get_node_tx_deauth_code(char * macadd,
02048                         char * dev_name,
02049                         unsigned int * code_err)
02050 {
02051   int file, nb_write, nb_read;
02052   struct qos_metric_node_msg msg;
02053 
02054   msg.struct_id    = T_QOS_METRIC_NODE_MSG;
02055   msg.type_msg     = T_QUERY_MSG;
02056   msg.id_error     = NO_ERRORS;
02057   msg.metric.int32 = 0; 
02058 
02059   if (macadd)
02060     strcpy ((char *) msg.macaddr, macadd);
02061   else
02062     msg.macaddr[0] = '\0';
02063   msg.metric_name = NODE_TX_DEAUTH_CODE;
02064   if (dev_name)
02065     strcpy((char *) msg.dev_name, dev_name);
02066   else
02067     msg.dev_name[0] = '\0';
02068 
02069   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
02070     {
02071       fprintf(stderr, "Can't open: ");
02072       perror(CROSS_LAYER_DEV_NAME_PATH);
02073       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
02074       msg.type_msg = T_ERROR_MSG;
02075     }
02076   nb_write = write(file, &msg, sizeof(msg));
02077   nb_read = read(file, &msg, sizeof(msg));
02078   if (nb_read == 0)
02079     {
02080       msg.id_error = COULD_NOT_READ_UNIX_DEV;
02081       msg.type_msg = T_ERROR_MSG;
02082     }  
02083   close(file);
02084 
02085   (*code_err) = msg.id_error;
02086   return (unsigned int) msg.metric.int32;
02087 }
02088 
02089 
02090 /**************************************************************************************************************************************/
02098 unsigned int 
02099 get_node_tx_disassoc(char * macadd,
02100                      char * dev_name,
02101                      unsigned int * code_err)
02102 {
02103   int file, nb_write, nb_read;
02104   struct qos_metric_node_msg msg;
02105 
02106   msg.struct_id    = T_QOS_METRIC_NODE_MSG;
02107   msg.type_msg     = T_QUERY_MSG;
02108   msg.id_error     = NO_ERRORS;
02109   msg.metric.int32 = 0; 
02110 
02111   if (macadd)
02112     strcpy ((char *) msg.macaddr, macadd);
02113   else
02114     msg.macaddr[0] = '\0';
02115   msg.metric_name = NODE_TX_DISASSOC;
02116   if (dev_name)
02117     strcpy((char *) msg.dev_name, dev_name);
02118   else
02119     msg.dev_name[0] = '\0';  
02120 
02121   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
02122     {
02123       fprintf(stderr, "Can't open: ");
02124       perror(CROSS_LAYER_DEV_NAME_PATH);
02125       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
02126       msg.type_msg = T_ERROR_MSG;
02127     }
02128   nb_write = write(file, &msg, sizeof(msg));
02129   nb_read = read(file, &msg, sizeof(msg));
02130   if (nb_read == 0)
02131     {
02132       msg.id_error = COULD_NOT_READ_UNIX_DEV;
02133       msg.type_msg = T_ERROR_MSG;
02134     }  
02135   close(file);
02136 
02137   (*code_err) = msg.id_error;
02138   return (unsigned int) msg.metric.int32;
02139 }
02140 
02141 
02142 /*************************************************************************************************************************************/
02150 unsigned int 
02151 get_node_tx_disassoc_code(char * macadd,
02152                           char * dev_name,
02153                           unsigned int * code_err)
02154 {
02155   int file, nb_write, nb_read;
02156   struct qos_metric_node_msg msg;
02157 
02158   msg.struct_id    = T_QOS_METRIC_NODE_MSG;
02159   msg.type_msg     = T_QUERY_MSG;
02160   msg.id_error     = NO_ERRORS;
02161   msg.metric.int32 = 0; 
02162 
02163   if (macadd)
02164     strcpy ((char *) msg.macaddr, macadd);
02165   else
02166     msg.macaddr[0] = '\0';
02167   msg.metric_name = NODE_TX_DISASSOC_CODE;
02168   if (dev_name)
02169     strcpy((char *) msg.dev_name, dev_name);
02170   else
02171     msg.dev_name[0] = '\0';  
02172 
02173   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
02174     {
02175       fprintf(stderr, "Can't open: ");
02176       perror(CROSS_LAYER_DEV_NAME_PATH);
02177       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
02178       msg.type_msg = T_ERROR_MSG;
02179     }
02180   nb_write = write(file, &msg, sizeof(msg));
02181   nb_read = read(file, &msg, sizeof(msg));
02182   if (nb_read == 0)
02183     {
02184       msg.id_error = COULD_NOT_READ_UNIX_DEV;
02185       msg.type_msg = T_ERROR_MSG;
02186     }  
02187   close(file);
02188 
02189   (*code_err) = msg.id_error;
02190   return (unsigned int) msg.metric.int32;
02191 }
02192 
02193 
02194 /*************************************************************************************************************/
02202 unsigned char
02203 get_node_txpower(char * macadd,
02204                  char * dev_name,
02205                  unsigned int * code_err)
02206 {
02207   int file, nb_write, nb_read;
02208   struct qos_metric_node_msg msg;
02209 
02210   msg.struct_id    = T_QOS_METRIC_NODE_MSG;
02211   msg.type_msg     = T_QUERY_MSG;
02212   msg.id_error     = NO_ERRORS;
02213   msg.metric.int8  = 0; 
02214 
02215   if (macadd)
02216     strcpy ((char *) msg.macaddr, macadd);
02217   else
02218     msg.macaddr[0] = '\0';
02219   msg.metric_name = NODE_TXPOWER;
02220   if (dev_name)
02221     strcpy((char *) msg.dev_name, dev_name);
02222   else
02223     msg.dev_name[0] = '\0';   
02224 
02225   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
02226     {
02227       fprintf(stderr, "Can't open: ");
02228       perror(CROSS_LAYER_DEV_NAME_PATH);
02229       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
02230       msg.type_msg = T_ERROR_MSG;
02231     }
02232   nb_write = write(file, &msg, sizeof(msg));
02233   nb_read = read(file, &msg, sizeof(msg));
02234   if (nb_read == 0)
02235     {
02236       msg.id_error = COULD_NOT_READ_UNIX_DEV;
02237       msg.type_msg = T_ERROR_MSG;
02238     }  
02239   close(file);
02240 
02241   (*code_err) = msg.id_error;
02242   return (unsigned char) msg.metric.int8;
02243 }
02244 
02245 
02246 /*************************************************************************************************************/
02254 unsigned char 
02255 get_node_negotiated_rate(char * macadd,
02256                          char * dev_name,
02257                          unsigned int * code_err)
02258 {
02259   int file, nb_write, nb_read;
02260   struct qos_metric_node_msg msg;
02261 
02262   msg.struct_id    = T_QOS_METRIC_NODE_MSG;
02263   msg.type_msg     = T_QUERY_MSG;
02264   msg.id_error     = NO_ERRORS;
02265   msg.metric.int8  = 0; 
02266 
02267   if (macadd)
02268     strcpy ((char *) msg.macaddr, macadd);
02269   else
02270     msg.macaddr[0] = '\0';
02271   msg.metric_name = NODE_NEGOTIATED_RATE;
02272   if (dev_name)
02273     strcpy((char *) msg.dev_name, dev_name);
02274   else
02275     msg.dev_name[0] = '\0';   
02276 
02277   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
02278     {
02279       fprintf(stderr, "Can't open: ");
02280       perror(CROSS_LAYER_DEV_NAME_PATH);
02281       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
02282       msg.type_msg = T_ERROR_MSG;
02283     }
02284   nb_write = write(file, &msg, sizeof(msg));
02285   nb_read = read(file, &msg, sizeof(msg));
02286   if (nb_read == 0)
02287     {
02288       msg.id_error = COULD_NOT_READ_UNIX_DEV;
02289       msg.type_msg = T_ERROR_MSG;
02290     }  
02291   close(file);
02292 
02293   (*code_err) = msg.id_error;
02294   return (unsigned char) msg.metric.int8;
02295 }
02296 
02297 
02298 /*************************************************************************************************************/
02306 unsigned char
02307 get_node_rssi(char * macadd,
02308               char * dev_name,
02309               unsigned int * code_err)
02310 {
02311   int file, nb_write, nb_read;
02312   struct qos_metric_node_msg msg;
02313   
02314   msg.struct_id    = T_QOS_METRIC_NODE_MSG;
02315   msg.type_msg     = T_QUERY_MSG;
02316   msg.id_error     = NO_ERRORS;
02317   msg.metric.int8  = 0; 
02318 
02319   if (macadd)
02320     strcpy ((char *) msg.macaddr, macadd);
02321   else
02322     msg.macaddr[0] = '\0';
02323  
02324   msg.metric_name = NODE_RSSI;
02325   if (dev_name)
02326     strcpy((char *) msg.dev_name, dev_name);
02327   else
02328     msg.dev_name[0] = '\0';   
02329 
02330   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
02331     {
02332       fprintf(stderr, "Can't open: ");
02333       perror(CROSS_LAYER_DEV_NAME_PATH);
02334       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
02335       msg.type_msg = T_ERROR_MSG;
02336     }
02337   nb_write = write(file, &msg, sizeof(msg));
02338   nb_read = read(file, &msg, sizeof(msg));
02339   if (nb_read == 0)
02340     {
02341       msg.id_error = COULD_NOT_READ_UNIX_DEV;
02342       msg.type_msg = T_ERROR_MSG;
02343     }  
02344   close(file);
02345   (*code_err) = msg.id_error;
02346   return (unsigned char) msg.metric.int8;
02347 }
02348 
02349 
02350 /*************************************************************************************************************/
02359 unsigned int
02360 get_node_on_tx_err(char * macadd,
02361                    char * dev_name,
02362                    unsigned int * code_err)
02363 {
02364   int file, nb_write, nb_read;
02365   struct qos_metric_node_msg msg;
02366 
02367   msg.struct_id    = T_QOS_METRIC_NODE_MSG;
02368   msg.type_msg     = T_QUERY_MSG;
02369   msg.id_error     = NO_ERRORS;
02370   msg.metric.int32 = 0; 
02371 
02372   if (macadd)
02373     strcpy ((char *) msg.macaddr, macadd);
02374   else
02375     msg.macaddr[0] = '\0';
02376   msg.metric_name = NODE_ON_TX_ERR;
02377   if (dev_name)
02378     strcpy((char *) msg.dev_name, dev_name);
02379   else
02380     msg.dev_name[0] = '\0';   
02381 
02382   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
02383     {
02384       fprintf(stderr, "Can't open: ");
02385       perror(CROSS_LAYER_DEV_NAME_PATH);
02386       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
02387       msg.type_msg = T_ERROR_MSG;
02388     }
02389   nb_write = write(file, &msg, sizeof(msg));
02390   nb_read = read(file, &msg, sizeof(msg));
02391   if (nb_read == 0)
02392     {
02393       msg.id_error = COULD_NOT_READ_UNIX_DEV;
02394       msg.type_msg = T_ERROR_MSG;
02395     }  
02396   close(file);
02397 
02398   (*code_err) = msg.id_error;
02399   return (unsigned int) msg.metric.int32;
02400 }
02401 
02402 /*************************************************************************************************************/
02411 unsigned int
02412 get_node_on_tx_ok(char * macadd,
02413                   char * dev_name,
02414                   unsigned int * code_err)
02415 {
02416   int file, nb_write, nb_read;
02417   struct qos_metric_node_msg msg;
02418 
02419   msg.struct_id    = T_QOS_METRIC_NODE_MSG;
02420   msg.type_msg     = T_QUERY_MSG;
02421   msg.id_error     = NO_ERRORS;
02422   msg.metric.int32 = 0; 
02423 
02424   if (macadd)
02425     strcpy ((char *) msg.macaddr, macadd);
02426   else
02427     msg.macaddr[0] = '\0';
02428   msg.metric_name = NODE_ON_TX_OK;
02429   if (dev_name)
02430     strcpy((char *) msg.dev_name, dev_name);
02431   else
02432     msg.dev_name[0] = '\0';   
02433 
02434   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
02435     {
02436       fprintf(stderr, "Can't open: ");
02437       perror(CROSS_LAYER_DEV_NAME_PATH);
02438       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
02439       msg.type_msg = T_ERROR_MSG;
02440     }
02441   nb_write = write(file, &msg, sizeof(msg));
02442   nb_read = read(file, &msg, sizeof(msg));
02443   if (nb_read == 0)
02444     {
02445       msg.id_error = COULD_NOT_READ_UNIX_DEV;
02446       msg.type_msg = T_ERROR_MSG;
02447     }  
02448   close(file);
02449 
02450   (*code_err) = msg.id_error;
02451   return (unsigned int) msg.metric.int32;
02452 }
02453 
02454 
02455 /*************************************************************************************************************/
02464 unsigned int
02465 get_node_on_tx_retr(char * macadd,
02466                     char * dev_name,
02467                     unsigned int * code_err)
02468 {
02469   int file, nb_write, nb_read;
02470   struct qos_metric_node_msg msg;
02471 
02472   msg.struct_id    = T_QOS_METRIC_NODE_MSG;
02473   msg.type_msg     = T_QUERY_MSG;
02474   msg.id_error     = NO_ERRORS;
02475   msg.metric.int32 = 0; 
02476 
02477   if (macadd)
02478     strcpy ((char *) msg.macaddr, macadd);
02479   else
02480     msg.macaddr[0] = '\0';
02481   msg.metric_name = NODE_ON_TX_RETR;
02482   if (dev_name)
02483     strcpy((char *) msg.dev_name, dev_name);
02484   else
02485     msg.dev_name[0] = '\0';   
02486 
02487   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
02488     {
02489       fprintf(stderr, "Can't open: ");
02490       perror(CROSS_LAYER_DEV_NAME_PATH);
02491       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
02492       msg.type_msg = T_ERROR_MSG;
02493     }
02494   nb_write = write(file, &msg, sizeof(msg));
02495   nb_read = read(file, &msg, sizeof(msg));
02496   if (nb_read == 0)
02497     {
02498       msg.id_error = COULD_NOT_READ_UNIX_DEV;
02499       msg.type_msg = T_ERROR_MSG;
02500     }  
02501   close(file);
02502 
02503   (*code_err) = msg.id_error;
02504   return (unsigned int) msg.metric.int32;
02505 }
02506 
02507 
02508 
02509 /****************************************************************************************************************
02510  ****************************************************************************************************************
02511  *  ATH STATS METRICS
02512  *
02513  *  Number of :
02514  *  - device reset by watchdog 
02515  *  - fatal hardware error interrupts 
02516  *  - beacon miss interrupts 
02517  *  - beacon stuck interrupts 
02518  *  - rx overrun interrupts 
02519  *  - rx eol interrupts 
02520  *  - tx underrun interrupts
02521  *  - mib interrupts 
02522  *  - interrupts coalesced
02523  *  - packet sent on the interface 
02524  *  - management frames transmitted
02525  *  - frames discarded prior to assoc
02526  *  - frames discarded 'cuz device gone
02527  *  - output stopped 'cuz no buffer
02528  *  - tx encapsulation failed 
02529  *  - tx failed 'cuz no node
02530  *  - tx failed 'cuz no tx buffer (data)
02531  *  - tx failed 'cuz no tx buffer (mgmt)
02532  *  - tx linearized to cluster
02533  *  - tx discarded empty frame
02534  *  - tx failed for dma resrcs
02535  *  - tx failed 'cuz too many retries
02536 
02537  *  - tx failed 'cuz FIO underrun
02538  *  - tx failed 'cuz xmit filtered 
02539  *  - tx on-chip retries (short) 
02540  *  - tx on-chip retries (long)
02541  *  - tx failed 'cuz bogus xmit rate
02542  *  - tx frames with no ack marked
02543  *  - tx frames with rts enabled 
02544  *  - tx frames with cts enabled 
02545  *  - tx frames with short preamble
02546  *  - tx frames with alternate rate
02547  *  - tx frames with protection
02548  *  - tx frames with cts and bursting
02549  *  - tx frames with cts extension
02550  *  - rx setup failed 'cuz no skb
02551  *  - rx setup failed for dma resrcs
02552  *  - rx failed 'cuz of desc overrun
02553  *  - rx failed 'cuz of bad CRC
02554  *  - rx failed 'cuz of FIFO overrun
02555  *  - rx failed 'cuz decryption 
02556  *  - rx failed 'cuz MIC failure 
02557  *  - rx failed 'cuz of PHY err
02558  *  - rx discarded 'cuz frame too short
02559  *  - rx discarded 'cuz frame too large 
02560  *  - packet recv on the interface
02561  *  - management frames received 
02562  *  - rx discarded 'cuz ctl frame
02563  *  - tx rssi of last ack 
02564  *  - rx rssi from histogram
02565  *  - beacons transmitted 
02566  *  - beacon setup failed 'cuz no skb
02567  *  - periodic calibration calls 
02568  *  - periodic calibration failed
02569  *  - periodic calibration rfgain reset
02570  *  - rate control checks 
02571  *  - rate control raised xmit rate
02572  *  - rate control dropped xmit rate
02573  *  - rx/default antenna switches 
02574  *  - tx antenna switches
02575  *   
02576  ****************************************************************************************************************
02577  ***************************************************************************************************************/
02578 
02579 /*************************************************************************************************************/
02586 unsigned int
02587 get_ast_watchdog(char * dev_name,
02588                  unsigned int * code_err)
02589 {
02590   int file, nb_write, nb_read;
02591   struct qos_metric_ath_msg msg;
02592 
02593   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
02594   msg.type_msg     = T_QUERY_MSG;
02595   msg.id_error     = NO_ERRORS;
02596   msg.metric_name  = AST_WATCHDOG;
02597   msg.metric.int32 = 0; 
02598 
02599   if (dev_name)
02600     strcpy((char *) msg.dev_name, dev_name);
02601   else
02602     msg.dev_name[0] = '\0';   
02603 
02604   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
02605     {
02606       fprintf(stderr, "Can't open: ");
02607       perror(CROSS_LAYER_DEV_NAME_PATH);
02608       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
02609       msg.type_msg = T_ERROR_MSG;
02610     }
02611   nb_write = write(file, &msg, sizeof(msg));
02612   nb_read = read(file, &msg, sizeof(msg));
02613   if (nb_read == 0)
02614     {
02615       msg.id_error = COULD_NOT_READ_UNIX_DEV;
02616       msg.type_msg = T_ERROR_MSG;
02617     }  
02618   close(file);
02619 
02620   (*code_err) = msg.id_error;
02621   return (unsigned int) msg.metric.int32;
02622 }
02623 
02624 /*************************************************************************************************************/
02631 unsigned int
02632 get_ast_hardware(char * dev_name,
02633                  unsigned int * code_err)
02634 {
02635   int file, nb_write, nb_read;
02636   struct qos_metric_ath_msg msg;
02637 
02638   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
02639   msg.type_msg     = T_QUERY_MSG;
02640   msg.id_error     = NO_ERRORS;
02641   msg.metric_name  = AST_HARDWARE;
02642   msg.metric.int32 = 0; 
02643 
02644   if (dev_name)
02645     strcpy((char *) msg.dev_name, dev_name);
02646   else
02647     msg.dev_name[0] = '\0';   
02648 
02649   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
02650     {
02651       fprintf(stderr, "Can't open: ");
02652       perror(CROSS_LAYER_DEV_NAME_PATH);
02653       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
02654       msg.type_msg = T_ERROR_MSG;
02655     }
02656   nb_write = write(file, &msg, sizeof(msg));
02657   nb_read = read(file, &msg, sizeof(msg));
02658   if (nb_read == 0)
02659     {
02660       msg.id_error = COULD_NOT_READ_UNIX_DEV;
02661       msg.type_msg = T_ERROR_MSG;
02662     }  
02663   close(file);
02664 
02665   (*code_err) = msg.id_error;
02666   return (unsigned int) msg.metric.int32;
02667 }
02668 
02669 
02670 
02671 /*************************************************************************************************************/
02678 unsigned int
02679 get_ast_bmiss(char * dev_name,
02680                  unsigned int * code_err)
02681 {
02682   int file, nb_write, nb_read;
02683   struct qos_metric_ath_msg msg;
02684 
02685   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
02686   msg.type_msg     = T_QUERY_MSG;
02687   msg.id_error     = NO_ERRORS;
02688   msg.metric_name  = AST_BMISS;
02689   msg.metric.int32 = 0; 
02690 
02691   if (dev_name)
02692     strcpy((char *) msg.dev_name, dev_name);
02693   else
02694     msg.dev_name[0] = '\0';   
02695 
02696   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
02697     {
02698       fprintf(stderr, "Can't open: ");
02699       perror(CROSS_LAYER_DEV_NAME_PATH);
02700       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
02701       msg.type_msg = T_ERROR_MSG;
02702     }
02703   nb_write = write(file, &msg, sizeof(msg));
02704   nb_read = read(file, &msg, sizeof(msg));
02705   if (nb_read == 0)
02706     {
02707       msg.id_error = COULD_NOT_READ_UNIX_DEV;
02708       msg.type_msg = T_ERROR_MSG;
02709     }  
02710   close(file);
02711 
02712   (*code_err) = msg.id_error;
02713   return (unsigned int) msg.metric.int32;
02714 }
02715 
02716 
02717 /*************************************************************************************************************/
02724 unsigned int
02725 get_ast_bstuck(char * dev_name,
02726                unsigned int * code_err)
02727 {
02728   int file, nb_write, nb_read;
02729   struct qos_metric_ath_msg msg;
02730 
02731   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
02732   msg.type_msg     = T_QUERY_MSG;
02733   msg.id_error     = NO_ERRORS;
02734   msg.metric_name  = AST_BSTUCK;
02735   msg.metric.int32 = 0; 
02736 
02737   if (dev_name)
02738     strcpy((char *) msg.dev_name, dev_name);
02739   else
02740     msg.dev_name[0] = '\0';   
02741 
02742   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
02743     {
02744       fprintf(stderr, "Can't open: ");
02745       perror(CROSS_LAYER_DEV_NAME_PATH);
02746       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
02747       msg.type_msg = T_ERROR_MSG;
02748     }
02749   nb_write = write(file, &msg, sizeof(msg));
02750   nb_read = read(file, &msg, sizeof(msg));
02751   if (nb_read == 0)
02752     {
02753       msg.id_error = COULD_NOT_READ_UNIX_DEV;
02754       msg.type_msg = T_ERROR_MSG;
02755     }  
02756   close(file);
02757 
02758   (*code_err) = msg.id_error;
02759   return (unsigned int) msg.metric.int32;
02760 }
02761 
02762 /*************************************************************************************************************/
02769 unsigned int
02770 get_ast_rxorn(char * dev_name,
02771               unsigned int * code_err)
02772 {
02773   int file, nb_write, nb_read;
02774   struct qos_metric_ath_msg msg;
02775 
02776   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
02777   msg.type_msg     = T_QUERY_MSG;
02778   msg.id_error     = NO_ERRORS;
02779   msg.metric_name  = AST_RXORN;
02780   msg.metric.int32 = 0; 
02781 
02782   if (dev_name)
02783     strcpy((char *) msg.dev_name, dev_name);
02784   else
02785     msg.dev_name[0] = '\0';   
02786 
02787   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
02788     {
02789       fprintf(stderr, "Can't open: ");
02790       perror(CROSS_LAYER_DEV_NAME_PATH);
02791       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
02792       msg.type_msg = T_ERROR_MSG;
02793     }
02794   nb_write = write(file, &msg, sizeof(msg));
02795   nb_read = read(file, &msg, sizeof(msg));
02796   if (nb_read == 0)
02797     {
02798       msg.id_error = COULD_NOT_READ_UNIX_DEV;
02799       msg.type_msg = T_ERROR_MSG;
02800     }  
02801   close(file);
02802 
02803   (*code_err) = msg.id_error;
02804   return (unsigned int) msg.metric.int32;
02805 }
02806 
02807 
02808 /*************************************************************************************************************/
02815 unsigned int
02816 get_ast_rxeol(char * dev_name,
02817               unsigned int * code_err)
02818 {
02819   int file, nb_write, nb_read;
02820   struct qos_metric_ath_msg msg;
02821 
02822   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
02823   msg.type_msg     = T_QUERY_MSG;
02824   msg.id_error     = NO_ERRORS;
02825   msg.metric_name  = AST_RXEOL;
02826   msg.metric.int32 = 0; 
02827 
02828   if (dev_name)
02829     strcpy((char *) msg.dev_name, dev_name);
02830   else
02831     msg.dev_name[0] = '\0';   
02832 
02833   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
02834     {
02835       fprintf(stderr, "Can't open: ");
02836       perror(CROSS_LAYER_DEV_NAME_PATH);
02837       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
02838       msg.type_msg = T_ERROR_MSG;
02839     }
02840   nb_write = write(file, &msg, sizeof(msg));
02841   nb_read = read(file, &msg, sizeof(msg));
02842   if (nb_read == 0)
02843     {
02844       msg.id_error = COULD_NOT_READ_UNIX_DEV;
02845       msg.type_msg = T_ERROR_MSG;
02846     }  
02847   close(file);
02848 
02849   (*code_err) = msg.id_error;
02850   return (unsigned int) msg.metric.int32;
02851 }
02852 
02853 /*************************************************************************************************************/
02860 unsigned int
02861 get_ast_txurn(char * dev_name,
02862               unsigned int * code_err)
02863 {
02864   int file, nb_write, nb_read;
02865   struct qos_metric_ath_msg msg;
02866 
02867   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
02868   msg.type_msg     = T_QUERY_MSG;
02869   msg.id_error     = NO_ERRORS;
02870   msg.metric_name  = AST_TXURN;
02871   msg.metric.int32 = 0; 
02872 
02873   if (dev_name)
02874     strcpy((char *) msg.dev_name, dev_name);
02875   else
02876     msg.dev_name[0] = '\0';   
02877 
02878   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
02879     {
02880       fprintf(stderr, "Can't open: ");
02881       perror(CROSS_LAYER_DEV_NAME_PATH);
02882       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
02883       msg.type_msg = T_ERROR_MSG;
02884     }
02885   nb_write = write(file, &msg, sizeof(msg));
02886   nb_read = read(file, &msg, sizeof(msg));
02887   if (nb_read == 0)
02888     {
02889       msg.id_error = COULD_NOT_READ_UNIX_DEV;
02890       msg.type_msg = T_ERROR_MSG;
02891     }  
02892   close(file);
02893 
02894   (*code_err) = msg.id_error;
02895   return (unsigned int) msg.metric.int32;
02896 }
02897 
02898 /*************************************************************************************************************/
02905 unsigned int
02906 get_ast_mib(char * dev_name,
02907             unsigned int * code_err)
02908 {
02909   int file, nb_write, nb_read;
02910   struct qos_metric_ath_msg msg;
02911 
02912   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
02913   msg.type_msg     = T_QUERY_MSG;
02914   msg.id_error     = NO_ERRORS;
02915   msg.metric_name  = AST_MIB;
02916   msg.metric.int32 = 0; 
02917 
02918   if (dev_name)
02919     strcpy((char *) msg.dev_name, dev_name);
02920   else
02921     msg.dev_name[0] = '\0';   
02922 
02923   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
02924     {
02925       fprintf(stderr, "Can't open: ");
02926       perror(CROSS_LAYER_DEV_NAME_PATH);
02927       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
02928       msg.type_msg = T_ERROR_MSG;
02929     }
02930   nb_write = write(file, &msg, sizeof(msg));
02931   nb_read = read(file, &msg, sizeof(msg));
02932   if (nb_read == 0)
02933     {
02934       msg.id_error = COULD_NOT_READ_UNIX_DEV;
02935       msg.type_msg = T_ERROR_MSG;
02936     }  
02937   close(file);
02938 
02939   (*code_err) = msg.id_error;
02940   return (unsigned int) msg.metric.int32;
02941 }
02942 
02943 /*************************************************************************************************************/
02950 unsigned int
02951 get_ast_intrcoal(char * dev_name,
02952                  unsigned int * code_err)
02953 {
02954   int file, nb_write, nb_read;
02955   struct qos_metric_ath_msg msg;
02956 
02957   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
02958   msg.type_msg     = T_QUERY_MSG;
02959   msg.id_error     = NO_ERRORS;
02960   msg.metric_name  = AST_INTRCOAL;
02961   msg.metric.int32 = 0; 
02962 
02963   if (dev_name)
02964     strcpy((char *) msg.dev_name, dev_name);
02965   else
02966     msg.dev_name[0] = '\0';   
02967 
02968   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
02969     {
02970       fprintf(stderr, "Can't open: ");
02971       perror(CROSS_LAYER_DEV_NAME_PATH);
02972       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
02973       msg.type_msg = T_ERROR_MSG;
02974     }
02975   nb_write = write(file, &msg, sizeof(msg));
02976   nb_read = read(file, &msg, sizeof(msg));
02977   if (nb_read == 0)
02978     {
02979       msg.id_error = COULD_NOT_READ_UNIX_DEV;
02980       msg.type_msg = T_ERROR_MSG;
02981     }  
02982   close(file);
02983 
02984   (*code_err) = msg.id_error;
02985   return (unsigned int) msg.metric.int32;
02986 }
02987 
02988 /*************************************************************************************************************/
02995 unsigned int
02996 get_ast_tx_packets(char * dev_name,
02997                  unsigned int * code_err)
02998 {
02999   int file, nb_write, nb_read;
03000   struct qos_metric_ath_msg msg;
03001 
03002   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
03003   msg.type_msg     = T_QUERY_MSG;
03004   msg.id_error     = NO_ERRORS;
03005   msg.metric_name  = AST_TX_PACKETS;
03006   msg.metric.int32 = 0; 
03007 
03008   if (dev_name)
03009     strcpy((char *) msg.dev_name, dev_name);
03010   else
03011     msg.dev_name[0] = '\0';   
03012 
03013   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
03014     {
03015       fprintf(stderr, "Can't open: ");
03016       perror(CROSS_LAYER_DEV_NAME_PATH);
03017       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
03018       msg.type_msg = T_ERROR_MSG;
03019     }
03020   nb_write = write(file, &msg, sizeof(msg));
03021   nb_read = read(file, &msg, sizeof(msg));
03022   if (nb_read == 0)
03023     {
03024       msg.id_error = COULD_NOT_READ_UNIX_DEV;
03025       msg.type_msg = T_ERROR_MSG;
03026     }  
03027   close(file);
03028 
03029   (*code_err) = msg.id_error;
03030   return (unsigned int) msg.metric.int32;
03031 }
03032 
03033 /*************************************************************************************************************/
03040 unsigned int
03041 get_ast_tx_mgmt(char * dev_name,
03042                 unsigned int * code_err)
03043 {
03044   int file, nb_write, nb_read;
03045   struct qos_metric_ath_msg msg;
03046 
03047   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
03048   msg.type_msg     = T_QUERY_MSG;
03049   msg.id_error     = NO_ERRORS;
03050   msg.metric_name  = AST_TX_MGMT;
03051   msg.metric.int32 = 0; 
03052 
03053   if (dev_name)
03054     strcpy((char *) msg.dev_name, dev_name);
03055   else
03056     msg.dev_name[0] = '\0';   
03057 
03058   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
03059     {
03060       fprintf(stderr, "Can't open: ");
03061       perror(CROSS_LAYER_DEV_NAME_PATH);
03062       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
03063       msg.type_msg = T_ERROR_MSG;
03064     }
03065   nb_write = write(file, &msg, sizeof(msg));
03066   nb_read = read(file, &msg, sizeof(msg));
03067   if (nb_read == 0)
03068     {
03069       msg.id_error = COULD_NOT_READ_UNIX_DEV;
03070       msg.type_msg = T_ERROR_MSG;
03071     }  
03072   close(file);
03073 
03074   (*code_err) = msg.id_error;
03075   return (unsigned int) msg.metric.int32;
03076 }
03077 
03078 /*************************************************************************************************************/
03085 unsigned int
03086 get_ast_tx_discard(char * dev_name,
03087                    unsigned int * code_err)
03088 {
03089   int file, nb_write, nb_read;
03090   struct qos_metric_ath_msg msg;
03091 
03092   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
03093   msg.type_msg     = T_QUERY_MSG;
03094   msg.id_error     = NO_ERRORS;
03095   msg.metric_name  = AST_TX_DISCARD;
03096   msg.metric.int32 = 0; 
03097 
03098   if (dev_name)
03099     strcpy((char *) msg.dev_name, dev_name);
03100   else
03101     msg.dev_name[0] = '\0';   
03102 
03103   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
03104     {
03105       fprintf(stderr, "Can't open: ");
03106       perror(CROSS_LAYER_DEV_NAME_PATH);
03107       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
03108       msg.type_msg = T_ERROR_MSG;
03109     }
03110   nb_write = write(file, &msg, sizeof(msg));
03111   nb_read = read(file, &msg, sizeof(msg));
03112   if (nb_read == 0)
03113     {
03114       msg.id_error = COULD_NOT_READ_UNIX_DEV;
03115       msg.type_msg = T_ERROR_MSG;
03116     }  
03117   close(file);
03118 
03119   (*code_err) = msg.id_error;
03120   return (unsigned int) msg.metric.int32;
03121 }
03122 
03123 /*************************************************************************************************************/
03130 unsigned int
03131 get_ast_tx_invalid(char * dev_name,
03132                    unsigned int * code_err)
03133 {
03134   int file, nb_write, nb_read;
03135   struct qos_metric_ath_msg msg;
03136 
03137   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
03138   msg.type_msg     = T_QUERY_MSG;
03139   msg.id_error     = NO_ERRORS;
03140   msg.metric_name  = AST_TX_INVALID;
03141   msg.metric.int32 = 0; 
03142 
03143   if (dev_name)
03144     strcpy((char *) msg.dev_name, dev_name);
03145   else
03146     msg.dev_name[0] = '\0';   
03147 
03148   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
03149     {
03150       fprintf(stderr, "Can't open: ");
03151       perror(CROSS_LAYER_DEV_NAME_PATH);
03152       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
03153       msg.type_msg = T_ERROR_MSG;
03154     }
03155   nb_write = write(file, &msg, sizeof(msg));
03156   nb_read = read(file, &msg, sizeof(msg));
03157   if (nb_read == 0)
03158     {
03159       msg.id_error = COULD_NOT_READ_UNIX_DEV;
03160       msg.type_msg = T_ERROR_MSG;
03161     }  
03162   close(file);
03163 
03164   (*code_err) = msg.id_error;
03165   return (unsigned int) msg.metric.int32;
03166 }
03167 
03168 /*************************************************************************************************************/
03175 unsigned int
03176 get_ast_tx_qstop(char * dev_name,
03177                  unsigned int * code_err)
03178 {
03179   int file, nb_write, nb_read;
03180   struct qos_metric_ath_msg msg;
03181 
03182   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
03183   msg.type_msg     = T_QUERY_MSG;
03184   msg.id_error     = NO_ERRORS;
03185   msg.metric_name  = AST_TX_QSTOP;
03186   msg.metric.int32 = 0; 
03187 
03188   if (dev_name)
03189     strcpy((char *) msg.dev_name, dev_name);
03190   else
03191     msg.dev_name[0] = '\0';   
03192 
03193   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
03194     {
03195       fprintf(stderr, "Can't open: ");
03196       perror(CROSS_LAYER_DEV_NAME_PATH);
03197       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
03198       msg.type_msg = T_ERROR_MSG;
03199     }
03200   nb_write = write(file, &msg, sizeof(msg));
03201   nb_read = read(file, &msg, sizeof(msg));
03202   if (nb_read == 0)
03203     {
03204       msg.id_error = COULD_NOT_READ_UNIX_DEV;
03205       msg.type_msg = T_ERROR_MSG;
03206     }  
03207   close(file);
03208 
03209   (*code_err) = msg.id_error;
03210   return (unsigned int) msg.metric.int32;
03211 }
03212 
03213 /*************************************************************************************************************/
03220 unsigned int
03221 get_ast_tx_encap(char * dev_name,
03222                  unsigned int * code_err)
03223 {
03224   int file, nb_write, nb_read;
03225   struct qos_metric_ath_msg msg;
03226 
03227   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
03228   msg.type_msg     = T_QUERY_MSG;
03229   msg.id_error     = NO_ERRORS;
03230   msg.metric_name  = AST_TX_ENCAP;
03231   msg.metric.int32 = 0; 
03232 
03233   if (dev_name)
03234     strcpy((char *) msg.dev_name, dev_name);
03235   else
03236     msg.dev_name[0] = '\0';   
03237 
03238   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
03239     {
03240       fprintf(stderr, "Can't open: ");
03241       perror(CROSS_LAYER_DEV_NAME_PATH);
03242       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
03243       msg.type_msg = T_ERROR_MSG;
03244     }
03245   nb_write = write(file, &msg, sizeof(msg));
03246   nb_read = read(file, &msg, sizeof(msg));
03247   if (nb_read == 0)
03248     {
03249       msg.id_error = COULD_NOT_READ_UNIX_DEV;
03250       msg.type_msg = T_ERROR_MSG;
03251     }  
03252   close(file);
03253 
03254   (*code_err) = msg.id_error;
03255   return (unsigned int) msg.metric.int32;
03256 }
03257 
03258 /*************************************************************************************************************/
03265 unsigned int
03266 get_ast_tx_nonode(char * dev_name,
03267                   unsigned int * code_err)
03268 {
03269   int file, nb_write, nb_read;
03270   struct qos_metric_ath_msg msg;
03271 
03272   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
03273   msg.type_msg     = T_QUERY_MSG;
03274   msg.id_error     = NO_ERRORS;
03275   msg.metric_name  = AST_TX_NONODE;
03276   msg.metric.int32 = 0; 
03277 
03278   if (dev_name)
03279     strcpy((char *) msg.dev_name, dev_name);
03280   else
03281     msg.dev_name[0] = '\0';   
03282 
03283   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
03284     {
03285       fprintf(stderr, "Can't open: ");
03286       perror(CROSS_LAYER_DEV_NAME_PATH);
03287       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
03288       msg.type_msg = T_ERROR_MSG;
03289     }
03290   nb_write = write(file, &msg, sizeof(msg));
03291   nb_read = read(file, &msg, sizeof(msg));
03292   if (nb_read == 0)
03293     {
03294       msg.id_error = COULD_NOT_READ_UNIX_DEV;
03295       msg.type_msg = T_ERROR_MSG;
03296     }  
03297   close(file);
03298 
03299   (*code_err) = msg.id_error;
03300   return (unsigned int) msg.metric.int32;
03301 }
03302 
03303 /*************************************************************************************************************/
03310 unsigned int
03311 get_ast_tx_nobuf(char * dev_name,
03312               unsigned int * code_err)
03313 {
03314   int file, nb_write, nb_read;
03315   struct qos_metric_ath_msg msg;
03316 
03317   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
03318   msg.type_msg     = T_QUERY_MSG;
03319   msg.id_error     = NO_ERRORS;
03320   msg.metric_name  = AST_TX_NOBUF;
03321   msg.metric.int32 = 0; 
03322 
03323   if (dev_name)
03324     strcpy((char *) msg.dev_name, dev_name);
03325   else
03326     msg.dev_name[0] = '\0';   
03327 
03328   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
03329     {
03330       fprintf(stderr, "Can't open: ");
03331       perror(CROSS_LAYER_DEV_NAME_PATH);
03332       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
03333       msg.type_msg = T_ERROR_MSG;
03334     }
03335   nb_write = write(file, &msg, sizeof(msg));
03336   nb_read = read(file, &msg, sizeof(msg));
03337   if (nb_read == 0)
03338     {
03339       msg.id_error = COULD_NOT_READ_UNIX_DEV;
03340       msg.type_msg = T_ERROR_MSG;
03341     }  
03342   close(file);
03343 
03344   (*code_err) = msg.id_error;
03345   return (unsigned int) msg.metric.int32;
03346 }
03347 
03348 /*************************************************************************************************************/
03355 unsigned int
03356 get_ast_tx_nobufmgt(char * dev_name,
03357                     unsigned int * code_err)
03358 {
03359   int file, nb_write, nb_read;
03360   struct qos_metric_ath_msg msg;
03361 
03362   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
03363   msg.type_msg     = T_QUERY_MSG;
03364   msg.id_error     = NO_ERRORS;
03365   msg.metric_name  = AST_TX_NOBUFMGT;
03366   msg.metric.int32 = 0; 
03367 
03368   if (dev_name)
03369     strcpy((char *) msg.dev_name, dev_name);
03370   else
03371     msg.dev_name[0] = '\0';   
03372 
03373   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
03374     {
03375       fprintf(stderr, "Can't open: ");
03376       perror(CROSS_LAYER_DEV_NAME_PATH);
03377       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
03378       msg.type_msg = T_ERROR_MSG;
03379     }
03380   nb_write = write(file, &msg, sizeof(msg));
03381   nb_read = read(file, &msg, sizeof(msg));
03382   if (nb_read == 0)
03383     {
03384       msg.id_error = COULD_NOT_READ_UNIX_DEV;
03385       msg.type_msg = T_ERROR_MSG;
03386     }  
03387   close(file);
03388 
03389   (*code_err) = msg.id_error;
03390   return (unsigned int) msg.metric.int32;
03391 }
03392 
03393 /*************************************************************************************************************/
03400 unsigned int
03401 get_ast_tx_linear(char * dev_name,
03402                   unsigned int * code_err)
03403 {
03404   int file, nb_write, nb_read;
03405   struct qos_metric_ath_msg msg;
03406 
03407   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
03408   msg.type_msg     = T_QUERY_MSG;
03409   msg.id_error     = NO_ERRORS;
03410   msg.metric_name  = AST_TX_LINEAR;
03411   msg.metric.int32 = 0; 
03412 
03413   if (dev_name)
03414     strcpy((char *) msg.dev_name, dev_name);
03415   else
03416     msg.dev_name[0] = '\0';   
03417 
03418   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
03419     {
03420       fprintf(stderr, "Can't open: ");
03421       perror(CROSS_LAYER_DEV_NAME_PATH);
03422       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
03423       msg.type_msg = T_ERROR_MSG;
03424     }
03425   nb_write = write(file, &msg, sizeof(msg));
03426   nb_read = read(file, &msg, sizeof(msg));
03427   if (nb_read == 0)
03428     {
03429       msg.id_error = COULD_NOT_READ_UNIX_DEV;
03430       msg.type_msg = T_ERROR_MSG;
03431     }  
03432   close(file);
03433 
03434   (*code_err) = msg.id_error;
03435   return (unsigned int) msg.metric.int32;
03436 }
03437 
03438 /*************************************************************************************************************/
03445 unsigned int
03446 get_ast_tx_nodata(char * dev_name,
03447                   unsigned int * code_err)
03448 {
03449   int file, nb_write, nb_read;
03450   struct qos_metric_ath_msg msg;
03451 
03452   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
03453   msg.type_msg     = T_QUERY_MSG;
03454   msg.id_error     = NO_ERRORS;
03455   msg.metric_name  = AST_TX_NODATA;
03456   msg.metric.int32 = 0; 
03457 
03458   if (dev_name)
03459     strcpy((char *) msg.dev_name, dev_name);
03460   else
03461     msg.dev_name[0] = '\0';   
03462 
03463   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
03464     {
03465       fprintf(stderr, "Can't open: ");
03466       perror(CROSS_LAYER_DEV_NAME_PATH);
03467       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
03468       msg.type_msg = T_ERROR_MSG;
03469     }
03470   nb_write = write(file, &msg, sizeof(msg));
03471   nb_read = read(file, &msg, sizeof(msg));
03472   if (nb_read == 0)
03473     {
03474       msg.id_error = COULD_NOT_READ_UNIX_DEV;
03475       msg.type_msg = T_ERROR_MSG;
03476     }  
03477   close(file);
03478 
03479   (*code_err) = msg.id_error;
03480   return (unsigned int) msg.metric.int32;
03481 }
03482 
03483 /*************************************************************************************************************/
03490 unsigned int
03491 get_ast_tx_busdma(char * dev_name,
03492                   unsigned int * code_err)
03493 {
03494   int file, nb_write, nb_read;
03495   struct qos_metric_ath_msg msg;
03496 
03497   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
03498   msg.type_msg     = T_QUERY_MSG;
03499   msg.id_error     = NO_ERRORS;
03500   msg.metric_name  = AST_TX_BUSDMA;
03501   msg.metric.int32 = 0; 
03502 
03503   if (dev_name)
03504     strcpy((char *) msg.dev_name, dev_name);
03505   else
03506     msg.dev_name[0] = '\0';   
03507 
03508   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
03509     {
03510       fprintf(stderr, "Can't open: ");
03511       perror(CROSS_LAYER_DEV_NAME_PATH);
03512       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
03513       msg.type_msg = T_ERROR_MSG;
03514     }
03515   nb_write = write(file, &msg, sizeof(msg));
03516   nb_read = read(file, &msg, sizeof(msg));
03517   if (nb_read == 0)
03518     {
03519       msg.id_error = COULD_NOT_READ_UNIX_DEV;
03520       msg.type_msg = T_ERROR_MSG;
03521     }  
03522   close(file);
03523 
03524   (*code_err) = msg.id_error;
03525   return (unsigned int) msg.metric.int32;
03526 }
03527 
03528 /*************************************************************************************************************/
03535 unsigned int
03536 get_ast_tx_xretries(char * dev_name,
03537                     unsigned int * code_err)
03538 {
03539   int file, nb_write, nb_read;
03540   struct qos_metric_ath_msg msg;
03541 
03542   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
03543   msg.type_msg     = T_QUERY_MSG;
03544   msg.id_error     = NO_ERRORS;
03545   msg.metric_name  = AST_TX_XRETRIES;
03546   msg.metric.int32 = 0; 
03547 
03548   if (dev_name)
03549     strcpy((char *) msg.dev_name, dev_name);
03550   else
03551     msg.dev_name[0] = '\0';   
03552 
03553   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
03554     {
03555       fprintf(stderr, "Can't open: ");
03556       perror(CROSS_LAYER_DEV_NAME_PATH);
03557       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
03558       msg.type_msg = T_ERROR_MSG;
03559     }
03560   nb_write = write(file, &msg, sizeof(msg));
03561   nb_read = read(file, &msg, sizeof(msg));
03562   if (nb_read == 0)
03563     {
03564       msg.id_error = COULD_NOT_READ_UNIX_DEV;
03565       msg.type_msg = T_ERROR_MSG;
03566     }  
03567   close(file);
03568 
03569   (*code_err) = msg.id_error;
03570   return (unsigned int) msg.metric.int32;
03571 }
03572 
03573 /*************************************************************************************************************/
03580 unsigned int
03581 get_ast_tx_fifoerr(char * dev_name,
03582                    unsigned int * code_err)
03583 {
03584   int file, nb_write, nb_read;
03585   struct qos_metric_ath_msg msg;
03586 
03587   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
03588   msg.type_msg     = T_QUERY_MSG;
03589   msg.id_error     = NO_ERRORS;
03590   msg.metric_name  = AST_TX_FIFOERR;
03591   msg.metric.int32 = 0; 
03592 
03593   if (dev_name)
03594     strcpy((char *) msg.dev_name, dev_name);
03595   else
03596     msg.dev_name[0] = '\0';   
03597 
03598   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
03599     {
03600       fprintf(stderr, "Can't open: ");
03601       perror(CROSS_LAYER_DEV_NAME_PATH);
03602       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
03603       msg.type_msg = T_ERROR_MSG;
03604     }
03605   nb_write = write(file, &msg, sizeof(msg));
03606   nb_read = read(file, &msg, sizeof(msg));
03607   if (nb_read == 0)
03608     {
03609       msg.id_error = COULD_NOT_READ_UNIX_DEV;
03610       msg.type_msg = T_ERROR_MSG;
03611     }  
03612   close(file);
03613 
03614   (*code_err) = msg.id_error;
03615   return (unsigned int) msg.metric.int32;
03616 }
03617 
03618 /*************************************************************************************************************/
03625 unsigned int
03626 get_ast_tx_filtered(char * dev_name,
03627                     unsigned int * code_err)
03628 {
03629   int file, nb_write, nb_read;
03630   struct qos_metric_ath_msg msg;
03631 
03632   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
03633   msg.type_msg     = T_QUERY_MSG;
03634   msg.id_error     = NO_ERRORS;
03635   msg.metric_name  = AST_TX_FILTERED;
03636   msg.metric.int32 = 0; 
03637 
03638   if (dev_name)
03639     strcpy((char *) msg.dev_name, dev_name);
03640   else
03641     msg.dev_name[0] = '\0';   
03642 
03643   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
03644     {
03645       fprintf(stderr, "Can't open: ");
03646       perror(CROSS_LAYER_DEV_NAME_PATH);
03647       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
03648       msg.type_msg = T_ERROR_MSG;
03649     }
03650   nb_write = write(file, &msg, sizeof(msg));
03651   nb_read = read(file, &msg, sizeof(msg));
03652   if (nb_read == 0)
03653     {
03654       msg.id_error = COULD_NOT_READ_UNIX_DEV;
03655       msg.type_msg = T_ERROR_MSG;
03656     }  
03657   close(file);
03658 
03659   (*code_err) = msg.id_error;
03660   return (unsigned int) msg.metric.int32;
03661 }
03662 
03663 /*************************************************************************************************************/
03670 unsigned int
03671 get_ast_tx_shortretry(char * dev_name,
03672                       unsigned int * code_err)
03673 {
03674   int file, nb_write, nb_read;
03675   struct qos_metric_ath_msg msg;
03676 
03677   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
03678   msg.type_msg     = T_QUERY_MSG;
03679   msg.id_error     = NO_ERRORS;
03680   msg.metric_name  = AST_TX_SHORTRETRY;
03681   msg.metric.int32 = 0; 
03682 
03683   if (dev_name)
03684     strcpy((char *) msg.dev_name, dev_name);
03685   else
03686     msg.dev_name[0] = '\0';   
03687 
03688   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
03689     {
03690       fprintf(stderr, "Can't open: ");
03691       perror(CROSS_LAYER_DEV_NAME_PATH);
03692       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
03693       msg.type_msg = T_ERROR_MSG;
03694     }
03695   nb_write = write(file, &msg, sizeof(msg));
03696   nb_read = read(file, &msg, sizeof(msg));
03697   if (nb_read == 0)
03698     {
03699       msg.id_error = COULD_NOT_READ_UNIX_DEV;
03700       msg.type_msg = T_ERROR_MSG;
03701     }  
03702   close(file);
03703 
03704   (*code_err) = msg.id_error;
03705   return (unsigned int) msg.metric.int32;
03706 }
03707 
03708 /*************************************************************************************************************/
03715 unsigned int
03716 get_ast_tx_longretry(char * dev_name,
03717                      unsigned int * code_err)
03718 {
03719   int file, nb_write, nb_read;
03720   struct qos_metric_ath_msg msg;
03721 
03722   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
03723   msg.type_msg     = T_QUERY_MSG;
03724   msg.id_error     = NO_ERRORS;
03725   msg.metric_name  = AST_TX_LONGRETRY;
03726   msg.metric.int32 = 0; 
03727 
03728   if (dev_name)
03729     strcpy((char *) msg.dev_name, dev_name);
03730   else
03731     msg.dev_name[0] = '\0';   
03732 
03733   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
03734     {
03735       fprintf(stderr, "Can't open: ");
03736       perror(CROSS_LAYER_DEV_NAME_PATH);
03737       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
03738       msg.type_msg = T_ERROR_MSG;
03739     }
03740   nb_write = write(file, &msg, sizeof(msg));
03741   nb_read = read(file, &msg, sizeof(msg));
03742   if (nb_read == 0)
03743     {
03744       msg.id_error = COULD_NOT_READ_UNIX_DEV;
03745       msg.type_msg = T_ERROR_MSG;
03746     }  
03747   close(file);
03748 
03749   (*code_err) = msg.id_error;
03750   return (unsigned int) msg.metric.int32;
03751 }
03752 
03753 /*************************************************************************************************************/
03760 unsigned int
03761 get_ast_tx_badrate(char * dev_name,
03762                    unsigned int * code_err)
03763 {
03764   int file, nb_write, nb_read;
03765   struct qos_metric_ath_msg msg;
03766 
03767   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
03768   msg.type_msg     = T_QUERY_MSG;
03769   msg.id_error     = NO_ERRORS;
03770   msg.metric_name  = AST_TX_BADRATE;
03771   msg.metric.int32 = 0; 
03772 
03773   if (dev_name)
03774     strcpy((char *) msg.dev_name, dev_name);
03775   else
03776     msg.dev_name[0] = '\0';   
03777 
03778   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
03779     {
03780       fprintf(stderr, "Can't open: ");
03781       perror(CROSS_LAYER_DEV_NAME_PATH);
03782       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
03783       msg.type_msg = T_ERROR_MSG;
03784     }
03785   nb_write = write(file, &msg, sizeof(msg));
03786   nb_read = read(file, &msg, sizeof(msg));
03787   if (nb_read == 0)
03788     {
03789       msg.id_error = COULD_NOT_READ_UNIX_DEV;
03790       msg.type_msg = T_ERROR_MSG;
03791     }  
03792   close(file);
03793 
03794   (*code_err) = msg.id_error;
03795   return (unsigned int) msg.metric.int32;
03796 }
03797 
03798 /*************************************************************************************************************/
03805 unsigned int
03806 get_ast_tx_noack(char * dev_name,
03807                  unsigned int * code_err)
03808 {
03809   int file, nb_write, nb_read;
03810   struct qos_metric_ath_msg msg;
03811 
03812   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
03813   msg.type_msg     = T_QUERY_MSG;
03814   msg.id_error     = NO_ERRORS;
03815   msg.metric_name  = AST_TX_NOACK;
03816   msg.metric.int32 = 0; 
03817 
03818   if (dev_name)
03819     strcpy((char *) msg.dev_name, dev_name);
03820   else
03821     msg.dev_name[0] = '\0';   
03822 
03823   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
03824     {
03825       fprintf(stderr, "Can't open: ");
03826       perror(CROSS_LAYER_DEV_NAME_PATH);
03827       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
03828       msg.type_msg = T_ERROR_MSG;
03829     }
03830   nb_write = write(file, &msg, sizeof(msg));
03831   nb_read = read(file, &msg, sizeof(msg));
03832   if (nb_read == 0)
03833     {
03834       msg.id_error = COULD_NOT_READ_UNIX_DEV;
03835       msg.type_msg = T_ERROR_MSG;
03836     }  
03837   close(file);
03838 
03839   (*code_err) = msg.id_error;
03840   return (unsigned int) msg.metric.int32;
03841 }
03842 
03843 /*************************************************************************************************************/
03850 unsigned int
03851 get_ast_tx_rts(char * dev_name,
03852                unsigned int * code_err)
03853 {
03854   int file, nb_write, nb_read;
03855   struct qos_metric_ath_msg msg;
03856 
03857   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
03858   msg.type_msg     = T_QUERY_MSG;
03859   msg.id_error     = NO_ERRORS;
03860   msg.metric_name  = AST_TX_RTS;
03861   msg.metric.int32 = 0; 
03862 
03863   if (dev_name)
03864     strcpy((char *) msg.dev_name, dev_name);
03865   else
03866     msg.dev_name[0] = '\0';   
03867 
03868   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
03869     {
03870       fprintf(stderr, "Can't open: ");
03871       perror(CROSS_LAYER_DEV_NAME_PATH);
03872       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
03873       msg.type_msg = T_ERROR_MSG;
03874     }
03875   nb_write = write(file, &msg, sizeof(msg));
03876   nb_read = read(file, &msg, sizeof(msg));
03877   if (nb_read == 0)
03878     {
03879       msg.id_error = COULD_NOT_READ_UNIX_DEV;
03880       msg.type_msg = T_ERROR_MSG;
03881     }  
03882   close(file);
03883 
03884   (*code_err) = msg.id_error;
03885   return (unsigned int) msg.metric.int32;
03886 }
03887 
03888 /*************************************************************************************************************/
03895 unsigned int
03896 get_ast_tx_cts(char * dev_name,
03897                unsigned int * code_err)
03898 {
03899   int file, nb_write, nb_read;
03900   struct qos_metric_ath_msg msg;
03901 
03902   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
03903   msg.type_msg     = T_QUERY_MSG;
03904   msg.id_error     = NO_ERRORS;
03905   msg.metric_name  = AST_TX_CTS;
03906   msg.metric.int32 = 0; 
03907 
03908   if (dev_name)
03909     strcpy((char *) msg.dev_name, dev_name);
03910   else
03911     msg.dev_name[0] = '\0';   
03912 
03913   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
03914     {
03915       fprintf(stderr, "Can't open: ");
03916       perror(CROSS_LAYER_DEV_NAME_PATH);
03917       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
03918       msg.type_msg = T_ERROR_MSG;
03919     }
03920   nb_write = write(file, &msg, sizeof(msg));
03921   nb_read = read(file, &msg, sizeof(msg));
03922   if (nb_read == 0)
03923     {
03924       msg.id_error = COULD_NOT_READ_UNIX_DEV;
03925       msg.type_msg = T_ERROR_MSG;
03926     }  
03927   close(file);
03928 
03929   (*code_err) = msg.id_error;
03930   return (unsigned int) msg.metric.int32;
03931 }
03932 
03933 /*************************************************************************************************************/
03940 unsigned int
03941 get_ast_tx_shortpre(char * dev_name,
03942                     unsigned int * code_err)
03943 {
03944   int file, nb_write, nb_read;
03945   struct qos_metric_ath_msg msg;
03946 
03947   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
03948   msg.type_msg     = T_QUERY_MSG;
03949   msg.id_error     = NO_ERRORS;
03950   msg.metric_name  = AST_TX_SHORTPRE;
03951   msg.metric.int32 = 0; 
03952   
03953   if (dev_name)
03954     strcpy((char *) msg.dev_name, dev_name);
03955   else
03956     msg.dev_name[0] = '\0';   
03957 
03958   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
03959     {
03960       fprintf(stderr, "Can't open: ");
03961       perror(CROSS_LAYER_DEV_NAME_PATH);
03962       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
03963       msg.type_msg = T_ERROR_MSG;
03964     }
03965   nb_write = write(file, &msg, sizeof(msg));
03966   nb_read = read(file, &msg, sizeof(msg));
03967   if (nb_read == 0)
03968     {
03969       msg.id_error = COULD_NOT_READ_UNIX_DEV;
03970       msg.type_msg = T_ERROR_MSG;
03971     }  
03972   close(file);
03973 
03974   (*code_err) = msg.id_error;
03975   return (unsigned int) msg.metric.int32;
03976 }
03977 
03978 /*************************************************************************************************************/
03985 unsigned int
03986 get_ast_tx_altrate(char * dev_name,
03987                    unsigned int * code_err)
03988 {
03989   int file, nb_write, nb_read;
03990   struct qos_metric_ath_msg msg;
03991 
03992   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
03993   msg.type_msg     = T_QUERY_MSG;
03994   msg.id_error     = NO_ERRORS;
03995   msg.metric_name  = AST_TX_ALTRATE;
03996   msg.metric.int32 = 0; 
03997 
03998   if (dev_name)
03999     strcpy((char *) msg.dev_name, dev_name);
04000   else
04001     msg.dev_name[0] = '\0';   
04002 
04003   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
04004     {
04005       fprintf(stderr, "Can't open: ");
04006       perror(CROSS_LAYER_DEV_NAME_PATH);
04007       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
04008       msg.type_msg = T_ERROR_MSG;
04009     }
04010   nb_write = write(file, &msg, sizeof(msg));
04011   nb_read = read(file, &msg, sizeof(msg));
04012   if (nb_read == 0)
04013     {
04014       msg.id_error = COULD_NOT_READ_UNIX_DEV;
04015       msg.type_msg = T_ERROR_MSG;
04016     }  
04017   close(file);
04018 
04019   (*code_err) = msg.id_error;
04020   return (unsigned int) msg.metric.int32;
04021 }
04022 
04023 /*************************************************************************************************************/
04030 unsigned int
04031 get_ast_tx_protect(char * dev_name,
04032                    unsigned int * code_err)
04033 {
04034   int file, nb_write, nb_read;
04035   struct qos_metric_ath_msg msg;
04036 
04037   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
04038   msg.type_msg     = T_QUERY_MSG;
04039   msg.id_error     = NO_ERRORS;
04040   msg.metric_name  = AST_TX_PROTECT;
04041   msg.metric.int32 = 0; 
04042   
04043   if (dev_name)
04044     strcpy((char *) msg.dev_name, dev_name);
04045   else
04046     msg.dev_name[0] = '\0';   
04047 
04048   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
04049     {
04050       fprintf(stderr, "Can't open: ");
04051       perror(CROSS_LAYER_DEV_NAME_PATH);
04052       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
04053       msg.type_msg = T_ERROR_MSG;
04054     }
04055   nb_write = write(file, &msg, sizeof(msg));
04056   nb_read = read(file, &msg, sizeof(msg));
04057   if (nb_read == 0)
04058     {
04059       msg.id_error = COULD_NOT_READ_UNIX_DEV;
04060       msg.type_msg = T_ERROR_MSG;
04061     }  
04062   close(file);
04063 
04064   (*code_err) = msg.id_error;
04065   return (unsigned int) msg.metric.int32;
04066 }
04067 
04068 /*************************************************************************************************************/
04075 unsigned int
04076 get_ast_tx_ctsburst(char * dev_name,
04077                     unsigned int * code_err)
04078 {
04079   int file, nb_write, nb_read;
04080   struct qos_metric_ath_msg msg;
04081 
04082   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
04083   msg.type_msg     = T_QUERY_MSG;
04084   msg.id_error     = NO_ERRORS;
04085   msg.metric_name  = AST_TX_CTSBURST;
04086   msg.metric.int32 = 0; 
04087 
04088   if (dev_name)
04089     strcpy((char *) msg.dev_name, dev_name);
04090   else
04091     msg.dev_name[0] = '\0';   
04092 
04093   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
04094     {
04095       fprintf(stderr, "Can't open: ");
04096       perror(CROSS_LAYER_DEV_NAME_PATH);
04097       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
04098       msg.type_msg = T_ERROR_MSG;
04099     }
04100   nb_write = write(file, &msg, sizeof(msg));
04101   nb_read = read(file, &msg, sizeof(msg));
04102   if (nb_read == 0)
04103     {
04104       msg.id_error = COULD_NOT_READ_UNIX_DEV;
04105       msg.type_msg = T_ERROR_MSG;
04106     }  
04107   close(file);
04108 
04109   (*code_err) = msg.id_error;
04110   return (unsigned int) msg.metric.int32;
04111 }
04112 
04113 /*************************************************************************************************************/
04120 unsigned int
04121 get_ast_tx_ctsext(char * dev_name,
04122                   unsigned int * code_err)
04123 {
04124   int file, nb_write, nb_read;
04125   struct qos_metric_ath_msg msg;
04126 
04127   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
04128   msg.type_msg     = T_QUERY_MSG;
04129   msg.id_error     = NO_ERRORS;
04130   msg.metric_name  = AST_TX_CTSEXT;
04131   msg.metric.int32 = 0; 
04132 
04133   if (dev_name)
04134     strcpy((char *) msg.dev_name, dev_name);
04135   else
04136     msg.dev_name[0] = '\0';   
04137 
04138   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
04139     {
04140       fprintf(stderr, "Can't open: ");
04141       perror(CROSS_LAYER_DEV_NAME_PATH);
04142       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
04143       msg.type_msg = T_ERROR_MSG;
04144     }
04145   nb_write = write(file, &msg, sizeof(msg));
04146   nb_read = read(file, &msg, sizeof(msg));
04147   if (nb_read == 0)
04148     {
04149       msg.id_error = COULD_NOT_READ_UNIX_DEV;
04150       msg.type_msg = T_ERROR_MSG;
04151     }  
04152   close(file);
04153 
04154   (*code_err) = msg.id_error;
04155   return (unsigned int) msg.metric.int32;
04156 }
04157 
04158 /*************************************************************************************************************/
04165 unsigned int
04166 get_ast_rx_nobuf(char * dev_name,
04167                  unsigned int * code_err)
04168 {
04169   int file, nb_write, nb_read;
04170   struct qos_metric_ath_msg msg;
04171 
04172   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
04173   msg.type_msg     = T_QUERY_MSG;
04174   msg.id_error     = NO_ERRORS;
04175   msg.metric_name  = AST_RX_NOBUF;
04176   msg.metric.int32 = 0; 
04177 
04178   if (dev_name)
04179     strcpy((char *) msg.dev_name, dev_name);
04180   else
04181     msg.dev_name[0] = '\0';   
04182 
04183   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
04184     {
04185       fprintf(stderr, "Can't open: ");
04186       perror(CROSS_LAYER_DEV_NAME_PATH);
04187       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
04188       msg.type_msg = T_ERROR_MSG;
04189     }
04190   nb_write = write(file, &msg, sizeof(msg));
04191   nb_read = read(file, &msg, sizeof(msg));
04192   if (nb_read == 0)
04193     {
04194       msg.id_error = COULD_NOT_READ_UNIX_DEV;
04195       msg.type_msg = T_ERROR_MSG;
04196     }  
04197   close(file);
04198 
04199   (*code_err) = msg.id_error;
04200   return (unsigned int) msg.metric.int32;
04201 }
04202 
04203 /*************************************************************************************************************/
04210 unsigned int
04211 get_ast_rx_busdma(char * dev_name,
04212                    unsigned int * code_err)
04213 {
04214   int file, nb_write, nb_read;
04215   struct qos_metric_ath_msg msg;
04216 
04217   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
04218   msg.type_msg     = T_QUERY_MSG;
04219   msg.id_error     = NO_ERRORS;
04220   msg.metric_name  = AST_RX_BUSDMA;
04221   msg.metric.int32 = 0; 
04222   
04223   if (dev_name)
04224     strcpy((char *) msg.dev_name, dev_name);
04225   else
04226     msg.dev_name[0] = '\0';   
04227 
04228   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
04229     {
04230       fprintf(stderr, "Can't open: ");
04231       perror(CROSS_LAYER_DEV_NAME_PATH);
04232       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
04233       msg.type_msg = T_ERROR_MSG;
04234     }
04235   nb_write = write(file, &msg, sizeof(msg));
04236   nb_read = read(file, &msg, sizeof(msg));
04237   if (nb_read == 0)
04238     {
04239       msg.id_error = COULD_NOT_READ_UNIX_DEV;
04240       msg.type_msg = T_ERROR_MSG;
04241     }  
04242   close(file);
04243 
04244   (*code_err) = msg.id_error;
04245   return (unsigned int) msg.metric.int32;
04246 }
04247 
04248 /*************************************************************************************************************/
04255 unsigned int
04256 get_ast_rx_orn(char * dev_name,
04257                unsigned int * code_err)
04258 {
04259   int file, nb_write, nb_read;
04260   struct qos_metric_ath_msg msg;
04261 
04262   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
04263   msg.type_msg     = T_QUERY_MSG;
04264   msg.id_error     = NO_ERRORS;
04265   msg.metric_name  = AST_RX_ORN;
04266   msg.metric.int32 = 0; 
04267 
04268   if (dev_name)
04269     strcpy((char *) msg.dev_name, dev_name);
04270   else
04271     msg.dev_name[0] = '\0';   
04272 
04273   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
04274     {
04275       fprintf(stderr, "Can't open: ");
04276       perror(CROSS_LAYER_DEV_NAME_PATH);
04277       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
04278       msg.type_msg = T_ERROR_MSG;
04279     }
04280   nb_write = write(file, &msg, sizeof(msg));
04281   nb_read = read(file, &msg, sizeof(msg));
04282   if (nb_read == 0)
04283     {
04284       msg.id_error = COULD_NOT_READ_UNIX_DEV;
04285       msg.type_msg = T_ERROR_MSG;
04286     }  
04287   close(file);
04288 
04289   (*code_err) = msg.id_error;
04290   return (unsigned int) msg.metric.int32;
04291 }
04292 
04293 /*************************************************************************************************************/
04300 unsigned int
04301 get_ast_rx_crcerr(char * dev_name,
04302                   unsigned int * code_err)
04303 {
04304   int file, nb_write, nb_read;
04305   struct qos_metric_ath_msg msg;
04306 
04307   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
04308   msg.type_msg     = T_QUERY_MSG;
04309   msg.id_error     = NO_ERRORS;
04310   msg.metric_name  = AST_RX_CRCERR;
04311   msg.metric.int32 = 0; 
04312 
04313   if (dev_name)
04314     strcpy((char *) msg.dev_name, dev_name);
04315   else
04316     msg.dev_name[0] = '\0';   
04317 
04318   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
04319     {
04320       fprintf(stderr, "Can't open: ");
04321       perror(CROSS_LAYER_DEV_NAME_PATH);
04322       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
04323       msg.type_msg = T_ERROR_MSG;
04324     }
04325   nb_write = write(file, &msg, sizeof(msg));
04326   nb_read = read(file, &msg, sizeof(msg));
04327   if (nb_read == 0)
04328     {
04329       msg.id_error = COULD_NOT_READ_UNIX_DEV;
04330       msg.type_msg = T_ERROR_MSG;
04331     }  
04332   close(file);
04333 
04334   (*code_err) = msg.id_error;
04335   return (unsigned int) msg.metric.int32;
04336 }
04337 
04338 /*************************************************************************************************************/
04345 unsigned int
04346 get_ast_rx_fifoerr(char * dev_name,
04347                    unsigned int * code_err)
04348 {
04349   int file, nb_write, nb_read;
04350   struct qos_metric_ath_msg msg;
04351 
04352   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
04353   msg.type_msg     = T_QUERY_MSG;
04354   msg.id_error     = NO_ERRORS;
04355   msg.metric_name  = AST_RX_FIFOERR;
04356   msg.metric.int32 = 0; 
04357 
04358   if (dev_name)
04359     strcpy((char *) msg.dev_name, dev_name);
04360   else
04361     msg.dev_name[0] = '\0';   
04362 
04363   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
04364     {
04365       fprintf(stderr, "Can't open: ");
04366       perror(CROSS_LAYER_DEV_NAME_PATH);
04367       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
04368       msg.type_msg = T_ERROR_MSG;
04369     }
04370   nb_write = write(file, &msg, sizeof(msg));
04371   nb_read = read(file, &msg, sizeof(msg));
04372   if (nb_read == 0)
04373     {
04374       msg.id_error = COULD_NOT_READ_UNIX_DEV;
04375       msg.type_msg = T_ERROR_MSG;
04376     }  
04377   close(file);
04378 
04379   (*code_err) = msg.id_error;
04380   return (unsigned int) msg.metric.int32;
04381 }
04382 
04383 /*************************************************************************************************************/
04390 unsigned int
04391 get_ast_rx_badcrypt(char * dev_name,
04392                     unsigned int * code_err)
04393 {
04394   int file, nb_write, nb_read;
04395   struct qos_metric_ath_msg msg;
04396 
04397   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
04398   msg.type_msg     = T_QUERY_MSG;
04399   msg.id_error     = NO_ERRORS;
04400   msg.metric_name  = AST_RX_BADCRYPT;
04401   msg.metric.int32 = 0; 
04402 
04403   if (dev_name)
04404     strcpy((char *) msg.dev_name, dev_name);
04405   else
04406     msg.dev_name[0] = '\0';   
04407 
04408   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
04409     {
04410       fprintf(stderr, "Can't open: ");
04411       perror(CROSS_LAYER_DEV_NAME_PATH);
04412       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
04413       msg.type_msg = T_ERROR_MSG;
04414     }
04415   nb_write = write(file, &msg, sizeof(msg));
04416   nb_read = read(file, &msg, sizeof(msg));
04417   if (nb_read == 0)
04418     {
04419       msg.id_error = COULD_NOT_READ_UNIX_DEV;
04420       msg.type_msg = T_ERROR_MSG;
04421     }  
04422   close(file);
04423 
04424   (*code_err) = msg.id_error;
04425   return (unsigned int) msg.metric.int32;
04426 }
04427 
04428 /*************************************************************************************************************/
04435 unsigned int
04436 get_ast_rx_badmic(char * dev_name,
04437                     unsigned int * code_err)
04438 {
04439   int file, nb_write, nb_read;
04440   struct qos_metric_ath_msg msg;
04441 
04442   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
04443   msg.type_msg     = T_QUERY_MSG;
04444   msg.id_error     = NO_ERRORS;
04445   msg.metric_name  = AST_RX_BADMIC;
04446   msg.metric.int32 = 0; 
04447 
04448   if (dev_name)
04449     strcpy((char *) msg.dev_name, dev_name);
04450   else
04451     msg.dev_name[0] = '\0';   
04452 
04453   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
04454     {
04455       fprintf(stderr, "Can't open: ");
04456       perror(CROSS_LAYER_DEV_NAME_PATH);
04457       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
04458       msg.type_msg = T_ERROR_MSG;
04459     }
04460   nb_write = write(file, &msg, sizeof(msg));
04461   nb_read = read(file, &msg, sizeof(msg));
04462   if (nb_read == 0)
04463     {
04464       msg.id_error = COULD_NOT_READ_UNIX_DEV;
04465       msg.type_msg = T_ERROR_MSG;
04466     }  
04467   close(file);
04468 
04469   (*code_err) = msg.id_error;
04470   return (unsigned int) msg.metric.int32;
04471 }
04472 
04473 /*************************************************************************************************************/
04480 unsigned int
04481 get_ast_rx_phyerr(char * dev_name,
04482                   unsigned int * code_err)
04483 {
04484   int file, nb_write, nb_read;
04485   struct qos_metric_ath_msg msg;
04486 
04487   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
04488   msg.type_msg     = T_QUERY_MSG;
04489   msg.id_error     = NO_ERRORS;
04490   msg.metric_name  = AST_RX_PHYERR;
04491   msg.metric.int32 = 0; 
04492 
04493   if (dev_name)
04494     strcpy((char *) msg.dev_name, dev_name);
04495   else
04496     msg.dev_name[0] = '\0';   
04497 
04498   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
04499     {
04500       fprintf(stderr, "Can't open: ");
04501       perror(CROSS_LAYER_DEV_NAME_PATH);
04502       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
04503       msg.type_msg = T_ERROR_MSG;
04504     }
04505   nb_write = write(file, &msg, sizeof(msg));
04506   nb_read = read(file, &msg, sizeof(msg));
04507   if (nb_read == 0)
04508     {
04509       msg.id_error = COULD_NOT_READ_UNIX_DEV;
04510       msg.type_msg = T_ERROR_MSG;
04511     }  
04512   close(file);
04513 
04514   (*code_err) = msg.id_error;
04515   return (unsigned int) msg.metric.int32;
04516 }
04517 
04518 /*************************************************************************************************************/
04525 unsigned int
04526 get_ast_rx_tooshort(char * dev_name,
04527                     unsigned int * code_err)
04528 {
04529   int file, nb_write, nb_read;
04530   struct qos_metric_ath_msg msg;
04531 
04532   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
04533   msg.type_msg     = T_QUERY_MSG;
04534   msg.id_error     = NO_ERRORS;
04535   msg.metric_name  = AST_RX_TOOSHORT;
04536   msg.metric.int32 = 0; 
04537 
04538   if (dev_name)
04539     strcpy((char *) msg.dev_name, dev_name);
04540   else
04541     msg.dev_name[0] = '\0';   
04542 
04543   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
04544     {
04545       fprintf(stderr, "Can't open: ");
04546       perror(CROSS_LAYER_DEV_NAME_PATH);
04547       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
04548       msg.type_msg = T_ERROR_MSG;
04549     }
04550   nb_write = write(file, &msg, sizeof(msg));
04551   nb_read = read(file, &msg, sizeof(msg));
04552   if (nb_read == 0)
04553     {
04554       msg.id_error = COULD_NOT_READ_UNIX_DEV;
04555       msg.type_msg = T_ERROR_MSG;
04556     }  
04557   close(file);
04558 
04559   (*code_err) = msg.id_error;
04560   return (unsigned int) msg.metric.int32;
04561 }
04562 
04563 /*************************************************************************************************************/
04570 unsigned int
04571 get_ast_rx_toobig(char * dev_name,
04572                   unsigned int * code_err)
04573 {
04574   int file, nb_write, nb_read;
04575   struct qos_metric_ath_msg msg;
04576 
04577   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
04578   msg.type_msg     = T_QUERY_MSG;
04579   msg.id_error     = NO_ERRORS;
04580   msg.metric_name  = AST_RX_TOOBIG;
04581   msg.metric.int32 = 0; 
04582 
04583   if (dev_name)
04584     strcpy((char *) msg.dev_name, dev_name);
04585   else
04586     msg.dev_name[0] = '\0';   
04587 
04588   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
04589     {
04590       fprintf(stderr, "Can't open: ");
04591       perror(CROSS_LAYER_DEV_NAME_PATH);
04592       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
04593       msg.type_msg = T_ERROR_MSG;
04594     }
04595   nb_write = write(file, &msg, sizeof(msg));
04596   nb_read = read(file, &msg, sizeof(msg));
04597   if (nb_read == 0)
04598     {
04599       msg.id_error = COULD_NOT_READ_UNIX_DEV;
04600       msg.type_msg = T_ERROR_MSG;
04601     }  
04602   close(file);
04603 
04604   (*code_err) = msg.id_error;
04605   return (unsigned int) msg.metric.int32;
04606 }
04607 
04608 /*************************************************************************************************************/
04615 unsigned int
04616 get_ast_rx_packets(char * dev_name,
04617                    unsigned int * code_err)
04618 {
04619   int file, nb_write, nb_read;
04620   struct qos_metric_ath_msg msg;
04621 
04622   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
04623   msg.type_msg     = T_QUERY_MSG;
04624   msg.id_error     = NO_ERRORS;
04625   msg.metric_name  = AST_RX_PACKETS;
04626   msg.metric.int32 = 0; 
04627   
04628   if (dev_name)
04629     strcpy((char *) msg.dev_name, dev_name);
04630   else
04631     msg.dev_name[0] = '\0';   
04632 
04633   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
04634     {
04635       fprintf(stderr, "Can't open: ");
04636       perror(CROSS_LAYER_DEV_NAME_PATH);
04637       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
04638       msg.type_msg = T_ERROR_MSG;
04639     }
04640   nb_write = write(file, &msg, sizeof(msg));
04641   nb_read = read(file, &msg, sizeof(msg));
04642   if (nb_read == 0)
04643     {
04644       msg.id_error = COULD_NOT_READ_UNIX_DEV;
04645       msg.type_msg = T_ERROR_MSG;
04646     }  
04647   close(file);
04648 
04649   (*code_err) = msg.id_error;
04650   return (unsigned int) msg.metric.int32;
04651 }
04652 
04653 /*************************************************************************************************************/
04660 unsigned int
04661 get_ast_rx_mgt(char * dev_name,
04662                unsigned int * code_err)
04663 {
04664   int file, nb_write, nb_read;
04665   struct qos_metric_ath_msg msg;
04666 
04667   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
04668   msg.type_msg     = T_QUERY_MSG;
04669   msg.id_error     = NO_ERRORS;
04670   msg.metric_name  = AST_RX_MGT;
04671   msg.metric.int32 = 0; 
04672 
04673   if (dev_name)
04674     strcpy((char *) msg.dev_name, dev_name);
04675   else
04676     msg.dev_name[0] = '\0';   
04677 
04678   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
04679     {
04680       fprintf(stderr, "Can't open: ");
04681       perror(CROSS_LAYER_DEV_NAME_PATH);
04682       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
04683       msg.type_msg = T_ERROR_MSG;
04684     }
04685   nb_write = write(file, &msg, sizeof(msg));
04686   nb_read = read(file, &msg, sizeof(msg));
04687   if (nb_read == 0)
04688     {
04689       msg.id_error = COULD_NOT_READ_UNIX_DEV;
04690       msg.type_msg = T_ERROR_MSG;
04691     }  
04692   close(file);
04693 
04694   (*code_err) = msg.id_error;
04695   return (unsigned int) msg.metric.int32;
04696 }
04697 
04698 /*************************************************************************************************************/
04705 unsigned int
04706 get_ast_rx_ctl(char * dev_name,
04707                unsigned int * code_err)
04708 {
04709   int file, nb_write, nb_read;
04710   struct qos_metric_ath_msg msg;
04711 
04712   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
04713   msg.type_msg     = T_QUERY_MSG;
04714   msg.id_error     = NO_ERRORS;
04715   msg.metric_name  = AST_RX_CTL;
04716   msg.metric.int32 = 0; 
04717   
04718   if (dev_name)
04719     strcpy((char *) msg.dev_name, dev_name);
04720   else
04721     msg.dev_name[0] = '\0';   
04722 
04723   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
04724     {
04725       fprintf(stderr, "Can't open: ");
04726       perror(CROSS_LAYER_DEV_NAME_PATH);
04727       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
04728       msg.type_msg = T_ERROR_MSG;
04729     }
04730   nb_write = write(file, &msg, sizeof(msg));
04731   nb_read = read(file, &msg, sizeof(msg));
04732   if (nb_read == 0)
04733     {
04734       msg.id_error = COULD_NOT_READ_UNIX_DEV;
04735       msg.type_msg = T_ERROR_MSG;
04736     }  
04737   close(file);
04738 
04739   (*code_err) = msg.id_error;
04740   return (unsigned int) msg.metric.int32;
04741 }
04742 
04743 /*************************************************************************************************************/
04750 unsigned char
04751 get_ast_tx_rssi(char * dev_name,
04752                 unsigned int * code_err)
04753 {
04754   int file, nb_write, nb_read;
04755   struct qos_metric_ath_msg msg;
04756 
04757   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
04758   msg.type_msg     = T_QUERY_MSG;
04759   msg.id_error     = NO_ERRORS;
04760   msg.metric_name  = AST_TX_RSSI;
04761   msg.metric.int8  = 0; 
04762 
04763   if (dev_name)
04764     strcpy((char *) msg.dev_name, dev_name);
04765   else
04766     msg.dev_name[0] = '\0';   
04767   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
04768     {
04769       fprintf(stderr, "Can't open: ");
04770       perror(CROSS_LAYER_DEV_NAME_PATH);
04771       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
04772       msg.type_msg = T_ERROR_MSG;
04773     }
04774   nb_write = write(file, &msg, sizeof(msg));
04775   nb_read = read(file, &msg, sizeof(msg));
04776   if (nb_read == 0)
04777     {
04778       msg.id_error = COULD_NOT_READ_UNIX_DEV;
04779       msg.type_msg = T_ERROR_MSG;
04780     }  
04781   close(file);
04782 
04783   (*code_err) = msg.id_error;
04784   return (unsigned char) msg.metric.int8;
04785 }
04786 
04787 /*************************************************************************************************************/
04794 unsigned char
04795 get_ast_rx_rssi(char * dev_name,
04796                 unsigned int * code_err)
04797 {
04798   int file, nb_write, nb_read;
04799   struct qos_metric_ath_msg msg;
04800 
04801   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
04802   msg.type_msg     = T_QUERY_MSG;
04803   msg.id_error     = NO_ERRORS;
04804   msg.metric_name  = AST_RX_RSSI;
04805   msg.metric.int8  = 0; 
04806 
04807   if (dev_name)
04808     strcpy((char *) msg.dev_name, dev_name);
04809   else
04810     msg.dev_name[0] = '\0';   
04811 
04812   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
04813     {
04814       fprintf(stderr, "Can't open: ");
04815       perror(CROSS_LAYER_DEV_NAME_PATH);
04816       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
04817       msg.type_msg = T_ERROR_MSG;
04818     }
04819   nb_write = write(file, &msg, sizeof(msg));
04820   nb_read = read(file, &msg, sizeof(msg));
04821   if (nb_read == 0)
04822     {
04823       msg.id_error = COULD_NOT_READ_UNIX_DEV;
04824       msg.type_msg = T_ERROR_MSG;
04825     }  
04826   close(file);
04827 
04828   (*code_err) = msg.id_error;
04829   return (unsigned char) msg.metric.int8;
04830 }
04831 
04832 /*************************************************************************************************************/
04839 unsigned int
04840 get_ast_be_xmit(char * dev_name,
04841                 unsigned int * code_err)
04842 {
04843   int file, nb_write, nb_read;
04844   struct qos_metric_ath_msg msg;
04845 
04846   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
04847   msg.type_msg     = T_QUERY_MSG;
04848   msg.id_error     = NO_ERRORS;
04849   msg.metric_name  = AST_BE_XMIT;
04850   msg.metric.int32 = 0; 
04851 
04852   if (dev_name)
04853     strcpy((char *) msg.dev_name, dev_name);
04854   else
04855     msg.dev_name[0] = '\0';   
04856 
04857   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
04858     {
04859       fprintf(stderr, "Can't open: ");
04860       perror(CROSS_LAYER_DEV_NAME_PATH);
04861       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
04862       msg.type_msg = T_ERROR_MSG;
04863     }
04864   nb_write = write(file, &msg, sizeof(msg));
04865   nb_read = read(file, &msg, sizeof(msg));
04866   if (nb_read == 0)
04867     {
04868       msg.id_error = COULD_NOT_READ_UNIX_DEV;
04869       msg.type_msg = T_ERROR_MSG;
04870     }  
04871   close(file);
04872 
04873   (*code_err) = msg.id_error;
04874   return (unsigned int) msg.metric.int32;
04875 }
04876 
04877 /*************************************************************************************************************/
04884 unsigned int
04885 get_ast_be_nobuf(char * dev_name,
04886                  unsigned int * code_err)
04887 {
04888   int file, nb_write, nb_read;
04889   struct qos_metric_ath_msg msg;
04890 
04891   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
04892   msg.type_msg     = T_QUERY_MSG;
04893   msg.id_error     = NO_ERRORS;
04894   msg.metric_name  = AST_BE_NOBUF;
04895   msg.metric.int32 = 0; 
04896 
04897   if (dev_name)
04898     strcpy((char *) msg.dev_name, dev_name);
04899   else
04900     msg.dev_name[0] = '\0';   
04901 
04902   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
04903     {
04904       fprintf(stderr, "Can't open: ");
04905       perror(CROSS_LAYER_DEV_NAME_PATH);
04906       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
04907       msg.type_msg = T_ERROR_MSG;
04908     }
04909   nb_write = write(file, &msg, sizeof(msg));
04910   nb_read = read(file, &msg, sizeof(msg));
04911   if (nb_read == 0)
04912     {
04913       msg.id_error = COULD_NOT_READ_UNIX_DEV;
04914       msg.type_msg = T_ERROR_MSG;
04915     }  
04916   close(file);
04917 
04918   (*code_err) = msg.id_error;
04919   return (unsigned int) msg.metric.int32;
04920 }
04921 
04922 /*************************************************************************************************************/
04929 unsigned int
04930 get_ast_per_cal(char * dev_name,
04931                 unsigned int * code_err)
04932 {
04933   int file, nb_write, nb_read;
04934   struct qos_metric_ath_msg msg;
04935 
04936   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
04937   msg.type_msg     = T_QUERY_MSG;
04938   msg.id_error     = NO_ERRORS;
04939   msg.metric_name  = AST_PER_CAL;
04940   msg.metric.int32 = 0; 
04941 
04942   if (dev_name)
04943     strcpy((char *) msg.dev_name, dev_name);
04944   else
04945     msg.dev_name[0] = '\0';   
04946 
04947   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
04948     {
04949       fprintf(stderr, "Can't open: ");
04950       perror(CROSS_LAYER_DEV_NAME_PATH);
04951       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
04952       msg.type_msg = T_ERROR_MSG;
04953     }
04954   nb_write = write(file, &msg, sizeof(msg));
04955   nb_read = read(file, &msg, sizeof(msg));
04956   if (nb_read == 0)
04957     {
04958       msg.id_error = COULD_NOT_READ_UNIX_DEV;
04959       msg.type_msg = T_ERROR_MSG;
04960     }  
04961   close(file);
04962 
04963   (*code_err) = msg.id_error;
04964   return (unsigned int) msg.metric.int32;
04965 }
04966 
04967 /*************************************************************************************************************/
04974 unsigned int
04975 get_ast_per_calfail(char * dev_name,
04976                     unsigned int * code_err)
04977 {
04978   int file, nb_write, nb_read;
04979   struct qos_metric_ath_msg msg;
04980 
04981   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
04982   msg.type_msg     = T_QUERY_MSG;
04983   msg.id_error     = NO_ERRORS;
04984   msg.metric_name  = AST_PER_CALFAIL;
04985   msg.metric.int32 = 0; 
04986   
04987   if (dev_name)
04988     strcpy((char *) msg.dev_name, dev_name);
04989   else
04990     msg.dev_name[0] = '\0';   
04991 
04992   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
04993     {
04994       fprintf(stderr, "Can't open: ");
04995       perror(CROSS_LAYER_DEV_NAME_PATH);
04996       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
04997       msg.type_msg = T_ERROR_MSG;
04998     }
04999   nb_write = write(file, &msg, sizeof(msg));
05000   nb_read = read(file, &msg, sizeof(msg));
05001   if (nb_read == 0)
05002     {
05003       msg.id_error = COULD_NOT_READ_UNIX_DEV;
05004       msg.type_msg = T_ERROR_MSG;
05005     }  
05006   close(file);
05007 
05008   (*code_err) = msg.id_error;
05009   return (unsigned int) msg.metric.int32;
05010 }
05011 
05012 /*************************************************************************************************************/
05019 unsigned int
05020 get_ast_per_rfgain(char * dev_name,
05021                    unsigned int * code_err)
05022 {
05023   int file, nb_write, nb_read;
05024   struct qos_metric_ath_msg msg;
05025 
05026   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
05027   msg.type_msg     = T_QUERY_MSG;
05028   msg.id_error     = NO_ERRORS;
05029   msg.metric_name  = AST_PER_RFGAIN;
05030   msg.metric.int32 = 0; 
05031 
05032   if (dev_name)
05033     strcpy((char *) msg.dev_name, dev_name);
05034   else
05035     msg.dev_name[0] = '\0';   
05036 
05037   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
05038     {
05039       fprintf(stderr, "Can't open: ");
05040       perror(CROSS_LAYER_DEV_NAME_PATH);
05041       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
05042       msg.type_msg = T_ERROR_MSG;
05043     }
05044   nb_write = write(file, &msg, sizeof(msg));
05045   nb_read = read(file, &msg, sizeof(msg));
05046   if (nb_read == 0)
05047     {
05048       msg.id_error = COULD_NOT_READ_UNIX_DEV;
05049       msg.type_msg = T_ERROR_MSG;
05050     }  
05051   close(file);
05052 
05053   (*code_err) = msg.id_error;
05054   return (unsigned int) msg.metric.int32;
05055 }
05056 
05057 /*************************************************************************************************************/
05064 unsigned int
05065 get_ast_rate_calls(char * dev_name,
05066                    unsigned int * code_err)
05067 {
05068   int file, nb_write, nb_read;
05069   struct qos_metric_ath_msg msg;
05070 
05071   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
05072   msg.type_msg     = T_QUERY_MSG;
05073   msg.id_error     = NO_ERRORS;
05074   msg.metric_name  = AST_RATE_CALLS;
05075   msg.metric.int32 = 0; 
05076 
05077   if (dev_name)
05078     strcpy((char *) msg.dev_name, dev_name);
05079   else
05080     msg.dev_name[0] = '\0';   
05081 
05082   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
05083     {
05084       fprintf(stderr, "Can't open: ");
05085       perror(CROSS_LAYER_DEV_NAME_PATH);
05086       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
05087       msg.type_msg = T_ERROR_MSG;
05088     }
05089   nb_write = write(file, &msg, sizeof(msg));
05090   nb_read = read(file, &msg, sizeof(msg));
05091   if (nb_read == 0)
05092     {
05093       msg.id_error = COULD_NOT_READ_UNIX_DEV;
05094       msg.type_msg = T_ERROR_MSG;
05095     }  
05096   close(file);
05097 
05098   (*code_err) = msg.id_error;
05099   return (unsigned int) msg.metric.int32;
05100 }
05101 
05102 /*************************************************************************************************************/
05109 unsigned int
05110 get_ast_rate_raise(char * dev_name,
05111                    unsigned int * code_err)
05112 {
05113   int file, nb_write, nb_read;
05114   struct qos_metric_ath_msg msg;
05115 
05116   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
05117   msg.type_msg     = T_QUERY_MSG;
05118   msg.id_error     = NO_ERRORS;
05119   msg.metric_name  = AST_RATE_RAISE;
05120   msg.metric.int32 = 0; 
05121 
05122   if (dev_name)
05123     strcpy((char *) msg.dev_name, dev_name);
05124   else
05125     msg.dev_name[0] = '\0';   
05126 
05127   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
05128     {
05129       fprintf(stderr, "Can't open: ");
05130       perror(CROSS_LAYER_DEV_NAME_PATH);
05131       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
05132       msg.type_msg = T_ERROR_MSG;
05133     }
05134   nb_write = write(file, &msg, sizeof(msg));
05135   nb_read = read(file, &msg, sizeof(msg));
05136   if (nb_read == 0)
05137     {
05138       msg.id_error = COULD_NOT_READ_UNIX_DEV;
05139       msg.type_msg = T_ERROR_MSG;
05140     }  
05141   close(file);
05142 
05143   (*code_err) = msg.id_error;
05144   return (unsigned int) msg.metric.int32;
05145 }
05146 
05147 /*************************************************************************************************************/
05154 unsigned int
05155 get_ast_rate_drop(char * dev_name,
05156                   unsigned int * code_err)
05157 {
05158   int file, nb_write, nb_read;
05159   struct qos_metric_ath_msg msg;
05160 
05161   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
05162   msg.type_msg     = T_QUERY_MSG;
05163   msg.id_error     = NO_ERRORS;
05164   msg.metric_name  = AST_RATE_DROP;
05165   msg.metric.int32 = 0; 
05166 
05167   if (dev_name)
05168     strcpy((char *) msg.dev_name, dev_name);
05169   else
05170     msg.dev_name[0] = '\0';   
05171 
05172   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
05173     {
05174       fprintf(stderr, "Can't open: ");
05175       perror(CROSS_LAYER_DEV_NAME_PATH);
05176       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
05177       msg.type_msg = T_ERROR_MSG;
05178     }
05179   nb_write = write(file, &msg, sizeof(msg));
05180   nb_read = read(file, &msg, sizeof(msg));
05181   if (nb_read == 0)
05182     {
05183       msg.id_error = COULD_NOT_READ_UNIX_DEV;
05184       msg.type_msg = T_ERROR_MSG;
05185     }  
05186   close(file);
05187 
05188   (*code_err) = msg.id_error;
05189   return (unsigned int) msg.metric.int32;
05190 }
05191 
05192 /*************************************************************************************************************/
05199 unsigned int
05200 get_ast_ant_defswitch(char * dev_name,
05201                       unsigned int * code_err)
05202 {
05203   int file, nb_write, nb_read;
05204   struct qos_metric_ath_msg msg;
05205 
05206   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
05207   msg.type_msg     = T_QUERY_MSG;
05208   msg.id_error     = NO_ERRORS;
05209   msg.metric_name  = AST_ANT_DEFSWITCH;
05210   msg.metric.int32 = 0; 
05211 
05212   if (dev_name)
05213     strcpy((char *) msg.dev_name, dev_name);
05214   else
05215     msg.dev_name[0] = '\0';   
05216 
05217   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
05218     {
05219       fprintf(stderr, "Can't open: ");
05220       perror(CROSS_LAYER_DEV_NAME_PATH);
05221       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
05222       msg.type_msg = T_ERROR_MSG;
05223     }
05224   nb_write = write(file, &msg, sizeof(msg));
05225   nb_read = read(file, &msg, sizeof(msg));
05226   if (nb_read == 0)
05227     {
05228       msg.id_error = COULD_NOT_READ_UNIX_DEV;
05229       msg.type_msg = T_ERROR_MSG;
05230     }  
05231   close(file);
05232 
05233   (*code_err) = msg.id_error;
05234   return (unsigned int) msg.metric.int32;
05235 }
05236 
05237 /*************************************************************************************************************/
05244 unsigned int
05245 get_ast_ant_txswitch(char * dev_name,
05246                      unsigned int * code_err)
05247 {
05248   int file, nb_write, nb_read;
05249   struct qos_metric_ath_msg msg;
05250 
05251   msg.struct_id    = T_QOS_METRIC_ATH_MSG;
05252   msg.type_msg     = T_QUERY_MSG;
05253   msg.id_error     = NO_ERRORS;
05254   msg.metric_name  = AST_ANT_TXSWITCH;
05255   msg.metric.int32 = 0; 
05256 
05257   if (dev_name)
05258     strcpy((char *) msg.dev_name, dev_name);
05259   else
05260     msg.dev_name[0] = '\0';   
05261 
05262   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
05263     {
05264       fprintf(stderr, "Can't open: ");
05265       perror(CROSS_LAYER_DEV_NAME_PATH);
05266       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
05267       msg.type_msg = T_ERROR_MSG;
05268     }
05269   nb_write = write(file, &msg, sizeof(msg));
05270   nb_read = read(file, &msg, sizeof(msg));
05271   if (nb_read == 0)
05272     {
05273       msg.id_error = COULD_NOT_READ_UNIX_DEV;
05274       msg.type_msg = T_ERROR_MSG;
05275     }  
05276   close(file);
05277 
05278   (*code_err) = msg.id_error;
05279   return (unsigned int) msg.metric.int32;
05280 }
05281 
05282 /****************************************************************************************************************
05283  ****************************************************************************************************************
05284  *  IEEE 802.11 STATS METRICS
05285  *
05286  *  Number of :
05287  *
05288  * - rx frame with bad version 
05289  * - rx frame too short
05290  * - rx from wrong bssid
05291  * - rx discard 'cuz dup
05292  * - rx w/ wrong direction
05293  * - rx discard 'cuz mcast echo
05294  * - rx discard 'cuz sta !assoc 
05295  * - rx w/ wep but privacy off
05296  * - rx w/o wep and privacy on 
05297  * - rx wep processing failed
05298  * - rx decapsulation failed
05299  * - rx discard mgt frames
05300  * - rx discard ctrl frames 
05301  * - rx beacon frames
05302  * - rx rate set truncated 
05303  * - rx required element missing
05304  * - rx element too big
05305  * - rx element too small 
05306  * - rx element unknown
05307  * - rx frame w/ invalid chan 
05308  * - rx frame chan mismatch
05309  * - rx frame dropped 
05310  * - rx frame ssid mismatch
05311  * - rx w/ unsupported auth alg
05312  * - rx sta auth failure
05313  * - rx auth discard 'cuz CM 
05314  * - rx assoc from wrong bssid
05315  * - rx assoc w/o auth
05316  * - rx assoc w/ cap mismatch 
05317  * - rx assoc w/ no rate match
05318  * - rx assoc w/ bad WPA IE 
05319  * - rx deauthentication
05320  * - rx disassociation
05321  * - rx frame w/ unknown subtype
05322  * - rx failed for lack of buf
05323  * - rx decrypt failed on crc 
05324  * - rx discard ahdemo mgt frame
05325  * - rx bad auth request 
05326  * - rx on unauthorized port 
05327  * - rx w/ incorrect keyid 
05328  * - rx seq# violation (CCMP)
05329  * - rx format bad (CCMP)
05330  * - rx MIC check failed (CCMP) 
05331  * - rx seq# violation (TKIP)
05332  * - rx format bad (TKIP) 
05333  * - rx MIC check failed (TKIP) 
05334  * - rx ICV check failed (TKIP)
05335  * - rx failed 'cuz key type
05336  * - rx failed 'cuz key !setup
05337  * - rx discard 'cuz acl policy 
05338  * - tx failed for lack of buf
05339  * - tx failed for no node 
05340  * - tx of unknown mgt frame 
05341  * - tx failed 'cuz key type 
05342  * - tx failed 'cuz no defkey
05343  * - tx failed 'cuz no space
05344  * - active scans started 
05345  * - passive scans started
05346  * - nodes timed out inactivity 
05347  * - no memory for crypto ctx
05348  * - tkip crypto done in s/w
05349  * - tkip en-MIC done in s/w 
05350  * - tkip de-MIC done in s/w
05351  * - tkip counter measures
05352  * - ccmp crypto done in s/w 
05353  * - wep crypto done in s/w
05354  * - cipher rejected key
05355  * - no key index for setkey
05356  * - driver key delete failed
05357  * - unknown cipher
05358  * - cipher not available 
05359  * - cipher attach failed
05360  * - cipher fallback to s/w
05361  * - driver key alloc failed 
05362  * - en-MIC failed
05363  * - merge failed-cap mismatch
05364  * - merge failed-rate mismatch
05365  * - ps-poll for unassoc. sta 
05366  * - ps-poll w/ incorrect aid
05367  * - ps-poll w/ nothing to send
05368  *   
05369  ****************************************************************************************************************
05370  ***************************************************************************************************************/
05371 
05372 /*************************************************************************************************************/
05379 unsigned int
05380 get_is_rx_badversion(char * dev_name,
05381                      unsigned int * code_err)
05382 {
05383   int file, nb_write, nb_read;
05384   struct qos_metric_net80211_msg msg;
05385 
05386   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
05387   msg.type_msg     = T_QUERY_MSG;
05388   msg.id_error     = NO_ERRORS;
05389   msg.metric_name  = IS_RX_BADVERSION;
05390   msg.metric.int32 = 0; 
05391 
05392   if (dev_name)
05393     strcpy((char *) msg.dev_name, dev_name);
05394   else
05395     msg.dev_name[0] = '\0';   
05396 
05397   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
05398     {
05399       fprintf(stderr, "Can't open: ");
05400       perror(CROSS_LAYER_DEV_NAME_PATH);
05401       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
05402       msg.type_msg = T_ERROR_MSG;
05403     }
05404   nb_write = write(file, &msg, sizeof(msg));
05405   nb_read = read(file, &msg, sizeof(msg));
05406   if (nb_read == 0)
05407     {
05408       msg.id_error = COULD_NOT_READ_UNIX_DEV;
05409       msg.type_msg = T_ERROR_MSG;
05410     }  
05411   close(file);
05412 
05413   (*code_err) = msg.id_error;
05414   return (unsigned int) msg.metric.int32;
05415 }
05416 
05417 
05418 /*************************************************************************************************************/
05425 unsigned int
05426 get_is_rx_tooshort(char * dev_name,
05427                    unsigned int * code_err)
05428 {
05429   int file, nb_write, nb_read;
05430   struct qos_metric_net80211_msg msg;
05431 
05432   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
05433   msg.type_msg     = T_QUERY_MSG;
05434   msg.id_error     = NO_ERRORS;
05435   msg.metric_name  = IS_RX_TOOSHORT;
05436   msg.metric.int32 = 0; 
05437 
05438   if (dev_name)
05439     strcpy((char *) msg.dev_name, dev_name);
05440   else
05441     msg.dev_name[0] = '\0';   
05442 
05443   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
05444     {
05445       fprintf(stderr, "Can't open: ");
05446       perror(CROSS_LAYER_DEV_NAME_PATH);
05447       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
05448       msg.type_msg = T_ERROR_MSG;
05449     }
05450   nb_write = write(file, &msg, sizeof(msg));
05451   nb_read = read(file, &msg, sizeof(msg));
05452   if (nb_read == 0)
05453     {
05454       msg.id_error = COULD_NOT_READ_UNIX_DEV;
05455       msg.type_msg = T_ERROR_MSG;
05456     }  
05457   close(file);
05458 
05459   (*code_err) = msg.id_error;
05460   return (unsigned int) msg.metric.int32;
05461 }
05462 
05463 /*************************************************************************************************************/
05470 unsigned int
05471 get_is_rx_wrongbss(char * dev_name,
05472                    unsigned int * code_err)
05473 {
05474   int file, nb_write, nb_read;
05475   struct qos_metric_net80211_msg msg;
05476 
05477   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
05478   msg.type_msg     = T_QUERY_MSG;
05479   msg.id_error     = NO_ERRORS;
05480   msg.metric_name  = IS_RX_WRONGBSS;
05481   msg.metric.int32 = 0; 
05482   
05483   if (dev_name)
05484     strcpy((char *) msg.dev_name, dev_name);
05485   else
05486     msg.dev_name[0] = '\0';   
05487 
05488   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
05489     {
05490       fprintf(stderr, "Can't open: ");
05491       perror(CROSS_LAYER_DEV_NAME_PATH);
05492       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
05493       msg.type_msg = T_ERROR_MSG;
05494     }
05495   nb_write = write(file, &msg, sizeof(msg));
05496   nb_read = read(file, &msg, sizeof(msg));
05497   if (nb_read == 0)
05498     {
05499       msg.id_error = COULD_NOT_READ_UNIX_DEV;
05500       msg.type_msg = T_ERROR_MSG;
05501     }  
05502   close(file);
05503 
05504   (*code_err) = msg.id_error;
05505   return (unsigned int) msg.metric.int32;
05506 }
05507 
05508 /*************************************************************************************************************/
05515 unsigned int
05516 get_is_rx_dup(char * dev_name,
05517               unsigned int * code_err)
05518 {
05519   int file, nb_write, nb_read;
05520   struct qos_metric_net80211_msg msg;
05521 
05522   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
05523   msg.type_msg     = T_QUERY_MSG;
05524   msg.id_error     = NO_ERRORS;
05525   msg.metric_name  = IS_RX_DUP;
05526   msg.metric.int32 = 0; 
05527 
05528   if (dev_name)
05529     strcpy((char *) msg.dev_name, dev_name);
05530   else
05531     msg.dev_name[0] = '\0';   
05532 
05533   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
05534     {
05535       fprintf(stderr, "Can't open: ");
05536       perror(CROSS_LAYER_DEV_NAME_PATH);
05537       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
05538       msg.type_msg = T_ERROR_MSG;
05539     }
05540   nb_write = write(file, &msg, sizeof(msg));
05541   nb_read = read(file, &msg, sizeof(msg));
05542   if (nb_read == 0)
05543     {
05544       msg.id_error = COULD_NOT_READ_UNIX_DEV;
05545       msg.type_msg = T_ERROR_MSG;
05546     }  
05547   close(file);
05548 
05549   (*code_err) = msg.id_error;
05550   return (unsigned int) msg.metric.int32;
05551 }
05552 
05553 /*************************************************************************************************************/
05560 unsigned int
05561 get_is_rx_wrongdir(char * dev_name,
05562                    unsigned int * code_err)
05563 {
05564   int file, nb_write, nb_read;
05565   struct qos_metric_net80211_msg msg;
05566 
05567   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
05568   msg.type_msg     = T_QUERY_MSG;
05569   msg.id_error     = NO_ERRORS;
05570   msg.metric_name  = IS_RX_WRONGDIR;
05571   msg.metric.int32 = 0; 
05572 
05573   if (dev_name)
05574     strcpy((char *) msg.dev_name, dev_name);
05575   else
05576     msg.dev_name[0] = '\0';   
05577 
05578   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
05579     {
05580       fprintf(stderr, "Can't open: ");
05581       perror(CROSS_LAYER_DEV_NAME_PATH);
05582       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
05583       msg.type_msg = T_ERROR_MSG;
05584     }
05585   nb_write = write(file, &msg, sizeof(msg));
05586   nb_read = read(file, &msg, sizeof(msg));
05587   if (nb_read == 0)
05588     {
05589       msg.id_error = COULD_NOT_READ_UNIX_DEV;
05590       msg.type_msg = T_ERROR_MSG;
05591     }  
05592   close(file);
05593 
05594   (*code_err) = msg.id_error;
05595   return (unsigned int) msg.metric.int32;
05596 }
05597 
05598 /*************************************************************************************************************/
05605 unsigned int
05606 get_is_rx_mcastecho(char * dev_name,
05607                     unsigned int * code_err)
05608 {
05609   int file, nb_write, nb_read;
05610   struct qos_metric_net80211_msg msg;
05611 
05612   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
05613   msg.type_msg     = T_QUERY_MSG;
05614   msg.id_error     = NO_ERRORS;
05615   msg.metric_name  = IS_RX_MCASTECHO;
05616   msg.metric.int32 = 0; 
05617 
05618   if (dev_name)
05619     strcpy((char *) msg.dev_name, dev_name);
05620   else
05621     msg.dev_name[0] = '\0';   
05622 
05623   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
05624     {
05625       fprintf(stderr, "Can't open: ");
05626       perror(CROSS_LAYER_DEV_NAME_PATH);
05627       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
05628       msg.type_msg = T_ERROR_MSG;
05629     }
05630   nb_write = write(file, &msg, sizeof(msg));
05631   nb_read = read(file, &msg, sizeof(msg));
05632   if (nb_read == 0)
05633     {
05634       msg.id_error = COULD_NOT_READ_UNIX_DEV;
05635       msg.type_msg = T_ERROR_MSG;
05636     }  
05637   close(file);
05638 
05639   (*code_err) = msg.id_error;
05640   return (unsigned int) msg.metric.int32;
05641 }
05642 
05643 
05644 /*************************************************************************************************************/
05651 unsigned int
05652 get_is_rx_notassoc(char * dev_name,
05653                    unsigned int * code_err)
05654 {
05655   int file, nb_write, nb_read;
05656   struct qos_metric_net80211_msg msg;
05657 
05658   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
05659   msg.type_msg     = T_QUERY_MSG;
05660   msg.id_error     = NO_ERRORS;
05661   msg.metric_name  = IS_RX_NOTASSOC;
05662   msg.metric.int32 = 0; 
05663 
05664   if (dev_name)
05665     strcpy((char *) msg.dev_name, dev_name);
05666   else
05667     msg.dev_name[0] = '\0';   
05668 
05669   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
05670     {
05671       fprintf(stderr, "Can't open: ");
05672       perror(CROSS_LAYER_DEV_NAME_PATH);
05673       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
05674       msg.type_msg = T_ERROR_MSG;
05675     }
05676   nb_write = write(file, &msg, sizeof(msg));
05677   nb_read = read(file, &msg, sizeof(msg));
05678   if (nb_read == 0)
05679     {
05680       msg.id_error = COULD_NOT_READ_UNIX_DEV;
05681       msg.type_msg = T_ERROR_MSG;
05682     }  
05683   close(file);
05684 
05685   (*code_err) = msg.id_error;
05686   return (unsigned int) msg.metric.int32;
05687 }
05688 
05689 /*************************************************************************************************************/
05696 unsigned int
05697 get_is_rx_noprivacy(char * dev_name,
05698                     unsigned int * code_err)
05699 {
05700   int file, nb_write, nb_read;
05701   struct qos_metric_net80211_msg msg;
05702 
05703   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
05704   msg.type_msg     = T_QUERY_MSG;
05705   msg.id_error     = NO_ERRORS;
05706   msg.metric_name  = IS_RX_NOPRIVACY;
05707   msg.metric.int32 = 0; 
05708 
05709   if (dev_name)
05710     strcpy((char *) msg.dev_name, dev_name);
05711   else
05712     msg.dev_name[0] = '\0';   
05713 
05714   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
05715     {
05716       fprintf(stderr, "Can't open: ");
05717       perror(CROSS_LAYER_DEV_NAME_PATH);
05718       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
05719       msg.type_msg = T_ERROR_MSG;
05720     }
05721   nb_write = write(file, &msg, sizeof(msg));
05722   nb_read = read(file, &msg, sizeof(msg));
05723   if (nb_read == 0)
05724     {
05725       msg.id_error = COULD_NOT_READ_UNIX_DEV;
05726       msg.type_msg = T_ERROR_MSG;
05727     }  
05728   close(file);
05729 
05730   (*code_err) = msg.id_error;
05731   return (unsigned int) msg.metric.int32;
05732 }
05733 
05734 /*************************************************************************************************************/
05741 unsigned int
05742 get_is_rx_unencrypted(char * dev_name,
05743                       unsigned int * code_err)
05744 {
05745   int file, nb_write, nb_read;
05746   struct qos_metric_net80211_msg msg;
05747 
05748   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
05749   msg.type_msg     = T_QUERY_MSG;
05750   msg.id_error     = NO_ERRORS;
05751   msg.metric_name  = IS_RX_UNENCRYPTED;
05752   msg.metric.int32 = 0; 
05753 
05754   if (dev_name)
05755     strcpy((char *) msg.dev_name, dev_name);
05756   else
05757     msg.dev_name[0] = '\0';   
05758 
05759   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
05760     {
05761       fprintf(stderr, "Can't open: ");
05762       perror(CROSS_LAYER_DEV_NAME_PATH);
05763       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
05764       msg.type_msg = T_ERROR_MSG;
05765     }
05766   nb_write = write(file, &msg, sizeof(msg));
05767   nb_read = read(file, &msg, sizeof(msg));
05768   if (nb_read == 0)
05769     {
05770       msg.id_error = COULD_NOT_READ_UNIX_DEV;
05771       msg.type_msg = T_ERROR_MSG;
05772     }  
05773   close(file);
05774 
05775   (*code_err) = msg.id_error;
05776   return (unsigned int) msg.metric.int32;
05777 }
05778 
05779 /*************************************************************************************************************/
05786 unsigned int
05787 get_is_rx_wepfail(char * dev_name,
05788                   unsigned int * code_err)
05789 {
05790   int file, nb_write, nb_read;
05791   struct qos_metric_net80211_msg msg;
05792 
05793   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
05794   msg.type_msg     = T_QUERY_MSG;
05795   msg.id_error     = NO_ERRORS;
05796   msg.metric_name  = IS_RX_WEPFAIL;
05797   msg.metric.int32 = 0; 
05798 
05799   if (dev_name)
05800     strcpy((char *) msg.dev_name, dev_name);
05801   else
05802     msg.dev_name[0] = '\0';   
05803 
05804   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
05805     {
05806       fprintf(stderr, "Can't open: ");
05807       perror(CROSS_LAYER_DEV_NAME_PATH);
05808       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
05809       msg.type_msg = T_ERROR_MSG;
05810     }
05811   nb_write = write(file, &msg, sizeof(msg));
05812   nb_read = read(file, &msg, sizeof(msg));
05813   if (nb_read == 0)
05814     {
05815       msg.id_error = COULD_NOT_READ_UNIX_DEV;
05816       msg.type_msg = T_ERROR_MSG;
05817     }  
05818   close(file);
05819 
05820   (*code_err) = msg.id_error;
05821   return (unsigned int) msg.metric.int32;
05822 }
05823 
05824 /*************************************************************************************************************/
05831 unsigned int
05832 get_is_rx_decap(char * dev_name,
05833                 unsigned int * code_err)
05834 {
05835   int file, nb_write, nb_read;
05836   struct qos_metric_net80211_msg msg;
05837 
05838   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
05839   msg.type_msg     = T_QUERY_MSG;
05840   msg.id_error     = NO_ERRORS;
05841   msg.metric_name  = IS_RX_DECAP;
05842   msg.metric.int32 = 0; 
05843 
05844   if (dev_name)
05845     strcpy((char *) msg.dev_name, dev_name);
05846   else
05847     msg.dev_name[0] = '\0';   
05848 
05849   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
05850     {
05851       fprintf(stderr, "Can't open: ");
05852       perror(CROSS_LAYER_DEV_NAME_PATH);
05853       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
05854       msg.type_msg = T_ERROR_MSG;
05855     }
05856   nb_write = write(file, &msg, sizeof(msg));
05857   nb_read = read(file, &msg, sizeof(msg));
05858   if (nb_read == 0)
05859     {
05860       msg.id_error = COULD_NOT_READ_UNIX_DEV;
05861       msg.type_msg = T_ERROR_MSG;
05862     }  
05863   close(file);
05864 
05865   (*code_err) = msg.id_error;
05866   return (unsigned int) msg.metric.int32;
05867 }
05868 
05869 /*************************************************************************************************************/
05876 unsigned int
05877 get_is_rx_mgtdiscard(char * dev_name,
05878                      unsigned int * code_err)
05879 {
05880   int file, nb_write, nb_read;
05881   struct qos_metric_net80211_msg msg;
05882 
05883   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
05884   msg.type_msg     = T_QUERY_MSG;
05885   msg.id_error     = NO_ERRORS;
05886   msg.metric_name  = IS_RX_MGTDISCARD;
05887   msg.metric.int32 = 0; 
05888 
05889   if (dev_name)
05890     strcpy((char *) msg.dev_name, dev_name);
05891   else
05892     msg.dev_name[0] = '\0';   
05893 
05894   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
05895     {
05896       fprintf(stderr, "Can't open: ");
05897       perror(CROSS_LAYER_DEV_NAME_PATH);
05898       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
05899       msg.type_msg = T_ERROR_MSG;
05900     }
05901   nb_write = write(file, &msg, sizeof(msg));
05902   nb_read = read(file, &msg, sizeof(msg));
05903   if (nb_read == 0)
05904     {
05905       msg.id_error = COULD_NOT_READ_UNIX_DEV;
05906       msg.type_msg = T_ERROR_MSG;
05907     }  
05908   close(file);
05909 
05910   (*code_err) = msg.id_error;
05911   return (unsigned int) msg.metric.int32;
05912 }
05913 
05914 
05915 /*************************************************************************************************************/
05922 unsigned int
05923 get_is_rx_ctl(char * dev_name,
05924               unsigned int * code_err)
05925 {
05926   int file, nb_write, nb_read;
05927   struct qos_metric_net80211_msg msg;
05928 
05929   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
05930   msg.type_msg     = T_QUERY_MSG;
05931   msg.id_error     = NO_ERRORS;
05932   msg.metric_name  = IS_RX_CTL;
05933   msg.metric.int32 = 0; 
05934 
05935   if (dev_name)
05936     strcpy((char *) msg.dev_name, dev_name);
05937   else
05938     msg.dev_name[0] = '\0';   
05939 
05940   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
05941     {
05942       fprintf(stderr, "Can't open: ");
05943       perror(CROSS_LAYER_DEV_NAME_PATH);
05944       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
05945       msg.type_msg = T_ERROR_MSG;
05946     }
05947   nb_write = write(file, &msg, sizeof(msg));
05948   nb_read = read(file, &msg, sizeof(msg));
05949   if (nb_read == 0)
05950     {
05951       msg.id_error = COULD_NOT_READ_UNIX_DEV;
05952       msg.type_msg = T_ERROR_MSG;
05953     }  
05954   close(file);
05955 
05956   (*code_err) = msg.id_error;
05957   return (unsigned int) msg.metric.int32;
05958 }
05959 
05960 /*************************************************************************************************************/
05967 unsigned int
05968 get_is_rx_beacon(char * dev_name,
05969                  unsigned int * code_err)
05970 {
05971   int file, nb_write, nb_read;
05972   struct qos_metric_net80211_msg msg;
05973 
05974   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
05975   msg.type_msg     = T_QUERY_MSG;
05976   msg.id_error     = NO_ERRORS;
05977   msg.metric_name  = IS_RX_BEACON;
05978   msg.metric.int32 = 0; 
05979 
05980   if (dev_name)
05981     strcpy((char *) msg.dev_name, dev_name);
05982   else
05983     msg.dev_name[0] = '\0';   
05984 
05985   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
05986     {
05987       fprintf(stderr, "Can't open: ");
05988       perror(CROSS_LAYER_DEV_NAME_PATH);
05989       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
05990       msg.type_msg = T_ERROR_MSG;
05991     }
05992   nb_write = write(file, &msg, sizeof(msg));
05993   nb_read = read(file, &msg, sizeof(msg));
05994   if (nb_read == 0)
05995     {
05996       msg.id_error = COULD_NOT_READ_UNIX_DEV;
05997       msg.type_msg = T_ERROR_MSG;
05998     }  
05999   close(file);
06000 
06001   (*code_err) = msg.id_error;
06002   return (unsigned int) msg.metric.int32;
06003 }
06004 
06005 /*************************************************************************************************************/
06012 unsigned int
06013 get_is_rx_rstoobig(char * dev_name,
06014                    unsigned int * code_err)
06015 {
06016   int file, nb_write, nb_read;
06017   struct qos_metric_net80211_msg msg;
06018 
06019   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
06020   msg.type_msg     = T_QUERY_MSG;
06021   msg.id_error     = NO_ERRORS;
06022   msg.metric_name  = IS_RX_RSTOOBIG;
06023   msg.metric.int32 = 0; 
06024 
06025   if (dev_name)
06026     strcpy((char *) msg.dev_name, dev_name);
06027   else
06028     msg.dev_name[0] = '\0';   
06029 
06030   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
06031     {
06032       fprintf(stderr, "Can't open: ");
06033       perror(CROSS_LAYER_DEV_NAME_PATH);
06034       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
06035       msg.type_msg = T_ERROR_MSG;
06036     }
06037   nb_write = write(file, &msg, sizeof(msg));
06038   nb_read = read(file, &msg, sizeof(msg));
06039   if (nb_read == 0)
06040     {
06041       msg.id_error = COULD_NOT_READ_UNIX_DEV;
06042       msg.type_msg = T_ERROR_MSG;
06043     }  
06044   close(file);
06045 
06046   (*code_err) = msg.id_error;
06047   return (unsigned int) msg.metric.int32;
06048 }
06049 
06050 /*************************************************************************************************************/
06057 unsigned int
06058 get_is_rx_elem_missing(char * dev_name,
06059                        unsigned int * code_err)
06060 {
06061   int file, nb_write, nb_read;
06062   struct qos_metric_net80211_msg msg;
06063 
06064   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
06065   msg.type_msg     = T_QUERY_MSG;
06066   msg.id_error     = NO_ERRORS;
06067   msg.metric_name  = IS_RX_ELEM_MISSING;
06068   msg.metric.int32 = 0; 
06069 
06070   if (dev_name)
06071     strcpy((char *) msg.dev_name, dev_name);
06072   else
06073     msg.dev_name[0] = '\0';   
06074 
06075   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
06076     {
06077       fprintf(stderr, "Can't open: ");
06078       perror(CROSS_LAYER_DEV_NAME_PATH);
06079       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
06080       msg.type_msg = T_ERROR_MSG;
06081     }
06082   nb_write = write(file, &msg, sizeof(msg));
06083   nb_read = read(file, &msg, sizeof(msg));
06084   if (nb_read == 0)
06085     {
06086       msg.id_error = COULD_NOT_READ_UNIX_DEV;
06087       msg.type_msg = T_ERROR_MSG;
06088     }  
06089   close(file);
06090 
06091   (*code_err) = msg.id_error;
06092   return (unsigned int) msg.metric.int32;
06093 }
06094 
06095 /*************************************************************************************************************/
06102 unsigned int
06103 get_is_rx_elem_toobig(char * dev_name,
06104                       unsigned int * code_err)
06105 {
06106   int file, nb_write, nb_read;
06107   struct qos_metric_net80211_msg msg;
06108 
06109   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
06110   msg.type_msg     = T_QUERY_MSG;
06111   msg.id_error     = NO_ERRORS;
06112   msg.metric_name  = IS_RX_ELEM_TOOBIG;
06113   msg.metric.int32 = 0; 
06114   
06115   if (dev_name)
06116     strcpy((char *) msg.dev_name, dev_name);
06117   else
06118     msg.dev_name[0] = '\0';   
06119 
06120   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
06121     {
06122       fprintf(stderr, "Can't open: ");
06123       perror(CROSS_LAYER_DEV_NAME_PATH);
06124       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
06125       msg.type_msg = T_ERROR_MSG;
06126     }
06127   nb_write = write(file, &msg, sizeof(msg));
06128   nb_read = read(file, &msg, sizeof(msg));
06129   if (nb_read == 0)
06130     {
06131       msg.id_error = COULD_NOT_READ_UNIX_DEV;
06132       msg.type_msg = T_ERROR_MSG;
06133     }  
06134   close(file);
06135 
06136   (*code_err) = msg.id_error;
06137   return (unsigned int) msg.metric.int32;
06138 }
06139 
06140 /*************************************************************************************************************/
06147 unsigned int
06148 get_is_rx_elem_toosmall(char * dev_name,
06149                         unsigned int * code_err)
06150 {
06151   int file, nb_write, nb_read;
06152   struct qos_metric_net80211_msg msg;
06153 
06154   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
06155   msg.type_msg     = T_QUERY_MSG;
06156   msg.id_error     = NO_ERRORS;
06157   msg.metric_name  = IS_RX_ELEM_TOOSMALL;
06158   msg.metric.int32 = 0; 
06159 
06160   if (dev_name)
06161     strcpy((char *) msg.dev_name, dev_name);
06162   else
06163     msg.dev_name[0] = '\0';   
06164 
06165   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
06166     {
06167       fprintf(stderr, "Can't open: ");
06168       perror(CROSS_LAYER_DEV_NAME_PATH);
06169       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
06170       msg.type_msg = T_ERROR_MSG;
06171     }
06172   nb_write = write(file, &msg, sizeof(msg));
06173   nb_read = read(file, &msg, sizeof(msg));
06174   if (nb_read == 0)
06175     {
06176       msg.id_error = COULD_NOT_READ_UNIX_DEV;
06177       msg.type_msg = T_ERROR_MSG;
06178     }  
06179   close(file);
06180 
06181   (*code_err) = msg.id_error;
06182   return (unsigned int) msg.metric.int32;
06183 }
06184 
06185 /*************************************************************************************************************/
06192 unsigned int
06193 get_is_rx_elem_unknown(char * dev_name,
06194                        unsigned int * code_err)
06195 {
06196   int file, nb_write, nb_read;
06197   struct qos_metric_net80211_msg msg;
06198 
06199   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
06200   msg.type_msg     = T_QUERY_MSG;
06201   msg.id_error     = NO_ERRORS;
06202   msg.metric_name  = IS_RX_ELEM_UNKNOWN;
06203   msg.metric.int32 = 0; 
06204   
06205   if (dev_name)
06206     strcpy((char *) msg.dev_name, dev_name);
06207   else
06208     msg.dev_name[0] = '\0';   
06209 
06210   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
06211     {
06212       fprintf(stderr, "Can't open: ");
06213       perror(CROSS_LAYER_DEV_NAME_PATH);
06214       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
06215       msg.type_msg = T_ERROR_MSG;
06216     }
06217   nb_write = write(file, &msg, sizeof(msg));
06218   nb_read = read(file, &msg, sizeof(msg));
06219   if (nb_read == 0)
06220     {
06221       msg.id_error = COULD_NOT_READ_UNIX_DEV;
06222       msg.type_msg = T_ERROR_MSG;
06223     }  
06224   close(file);
06225 
06226   (*code_err) = msg.id_error;
06227   return (unsigned int) msg.metric.int32;
06228 }
06229 
06230 /*************************************************************************************************************/
06237 unsigned int
06238 get_is_rx_badchan(char * dev_name,
06239                   unsigned int * code_err)
06240 {
06241   int file, nb_write, nb_read;
06242   struct qos_metric_net80211_msg msg;
06243 
06244   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
06245   msg.type_msg     = T_QUERY_MSG;
06246   msg.id_error     = NO_ERRORS;
06247   msg.metric_name  = IS_RX_BADCHAN;
06248   msg.metric.int32 = 0; 
06249 
06250   if (dev_name)
06251     strcpy((char *) msg.dev_name, dev_name);
06252   else
06253     msg.dev_name[0] = '\0';   
06254 
06255   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
06256     {
06257       fprintf(stderr, "Can't open: ");
06258       perror(CROSS_LAYER_DEV_NAME_PATH);
06259       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
06260       msg.type_msg = T_ERROR_MSG;
06261     }
06262   nb_write = write(file, &msg, sizeof(msg));
06263   nb_read = read(file, &msg, sizeof(msg));
06264   if (nb_read == 0)
06265     {
06266       msg.id_error = COULD_NOT_READ_UNIX_DEV;
06267       msg.type_msg = T_ERROR_MSG;
06268     }  
06269   close(file);
06270 
06271   (*code_err) = msg.id_error;
06272   return (unsigned int) msg.metric.int32;
06273 }
06274 
06275 /*************************************************************************************************************/
06282 unsigned int
06283 get_is_rx_chanmismatch(char * dev_name,
06284                        unsigned int * code_err)
06285 {
06286   int file, nb_write, nb_read;
06287   struct qos_metric_net80211_msg msg;
06288   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
06289   msg.type_msg     = T_QUERY_MSG;
06290   msg.id_error     = NO_ERRORS;
06291   msg.metric_name  = IS_RX_CHANMISMATCH;
06292   msg.metric.int32 = 0; 
06293 
06294   if (dev_name)
06295     strcpy((char *) msg.dev_name, dev_name);
06296   else
06297     msg.dev_name[0] = '\0';   
06298 
06299   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
06300     {
06301       fprintf(stderr, "Can't open: ");
06302       perror(CROSS_LAYER_DEV_NAME_PATH);
06303       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
06304       msg.type_msg = T_ERROR_MSG;
06305     }
06306   nb_write = write(file, &msg, sizeof(msg));
06307   nb_read = read(file, &msg, sizeof(msg));
06308   if (nb_read == 0)
06309     {
06310       msg.id_error = COULD_NOT_READ_UNIX_DEV;
06311       msg.type_msg = T_ERROR_MSG;
06312     }  
06313   close(file);
06314 
06315   (*code_err) = msg.id_error;
06316   return (unsigned int) msg.metric.int32;
06317 }
06318 
06319 /*************************************************************************************************************/
06326 unsigned int
06327 get_is_rx_nodealloc(char * dev_name,
06328                     unsigned int * code_err)
06329 {
06330   int file, nb_write, nb_read;
06331   struct qos_metric_net80211_msg msg;
06332 
06333   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
06334   msg.type_msg     = T_QUERY_MSG;
06335   msg.id_error     = NO_ERRORS;
06336   msg.metric_name  = IS_RX_NODEALLOC;
06337   msg.metric.int32 = 0; 
06338 
06339   if (dev_name)
06340     strcpy((char *) msg.dev_name, dev_name);
06341   else
06342     msg.dev_name[0] = '\0';   
06343 
06344   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
06345     {
06346       fprintf(stderr, "Can't open: ");
06347       perror(CROSS_LAYER_DEV_NAME_PATH);
06348       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
06349       msg.type_msg = T_ERROR_MSG;
06350     }
06351   nb_write = write(file, &msg, sizeof(msg));
06352   nb_read = read(file, &msg, sizeof(msg));
06353   if (nb_read == 0)
06354     {
06355       msg.id_error = COULD_NOT_READ_UNIX_DEV;
06356       msg.type_msg = T_ERROR_MSG;
06357     }  
06358   close(file);
06359 
06360   (*code_err) = msg.id_error;
06361   return (unsigned int) msg.metric.int32;
06362 }
06363 
06364 /*************************************************************************************************************/
06371 unsigned int
06372 get_is_rx_ssidmismatch(char * dev_name,
06373                        unsigned int * code_err)
06374 {
06375   int file, nb_write, nb_read;
06376   struct qos_metric_net80211_msg msg;
06377 
06378   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
06379   msg.type_msg     = T_QUERY_MSG;
06380   msg.id_error     = NO_ERRORS;
06381   msg.metric_name  = IS_RX_SSIDMISMATCH;
06382   msg.metric.int32 = 0; 
06383 
06384   if (dev_name)
06385     strcpy((char *) msg.dev_name, dev_name);
06386   else
06387     msg.dev_name[0] = '\0';   
06388 
06389   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
06390     {
06391       fprintf(stderr, "Can't open: ");
06392       perror(CROSS_LAYER_DEV_NAME_PATH);
06393       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
06394       msg.type_msg = T_ERROR_MSG;
06395     }
06396   nb_write = write(file, &msg, sizeof(msg));
06397   nb_read = read(file, &msg, sizeof(msg));
06398   if (nb_read == 0)
06399     {
06400       msg.id_error = COULD_NOT_READ_UNIX_DEV;
06401       msg.type_msg = T_ERROR_MSG;
06402     }  
06403   close(file);
06404 
06405   (*code_err) = msg.id_error;
06406   return (unsigned int) msg.metric.int32;
06407 }
06408 
06409 /*************************************************************************************************************/
06416 unsigned int
06417 get_is_rx_auth_unsupported(char * dev_name,
06418                            unsigned int * code_err)
06419 {
06420   int file, nb_write, nb_read;
06421   struct qos_metric_net80211_msg msg;
06422 
06423   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
06424   msg.type_msg     = T_QUERY_MSG;
06425   msg.id_error     = NO_ERRORS;
06426   msg.metric_name  = IS_RX_AUTH_UNSUPPORTED;
06427   msg.metric.int32 = 0; 
06428 
06429   if (dev_name)
06430     strcpy((char *) msg.dev_name, dev_name);
06431   else
06432     msg.dev_name[0] = '\0';   
06433 
06434   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
06435     {
06436       fprintf(stderr, "Can't open: ");
06437       perror(CROSS_LAYER_DEV_NAME_PATH);
06438       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
06439       msg.type_msg = T_ERROR_MSG;
06440     }
06441   nb_write = write(file, &msg, sizeof(msg));
06442   nb_read = read(file, &msg, sizeof(msg));
06443   if (nb_read == 0)
06444     {
06445       msg.id_error = COULD_NOT_READ_UNIX_DEV;
06446       msg.type_msg = T_ERROR_MSG;
06447     }  
06448   close(file);
06449 
06450   (*code_err) = msg.id_error;
06451   return (unsigned int) msg.metric.int32;
06452 }
06453 
06454 /*************************************************************************************************************/
06461 unsigned int
06462 get_is_rx_auth_fail(char * dev_name,
06463                     unsigned int * code_err)
06464 {
06465   int file, nb_write, nb_read;
06466   struct qos_metric_net80211_msg msg;
06467 
06468   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
06469   msg.type_msg     = T_QUERY_MSG;
06470   msg.id_error     = NO_ERRORS;
06471   msg.metric_name  = IS_RX_AUTH_FAIL;
06472   msg.metric.int32 = 0; 
06473 
06474   if (dev_name)
06475     strcpy((char *) msg.dev_name, dev_name);
06476   else
06477     msg.dev_name[0] = '\0';   
06478 
06479   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
06480     {
06481       fprintf(stderr, "Can't open: ");
06482       perror(CROSS_LAYER_DEV_NAME_PATH);
06483       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
06484       msg.type_msg = T_ERROR_MSG;
06485     }
06486   nb_write = write(file, &msg, sizeof(msg));
06487   nb_read = read(file, &msg, sizeof(msg));
06488   if (nb_read == 0)
06489     {
06490       msg.id_error = COULD_NOT_READ_UNIX_DEV;
06491       msg.type_msg = T_ERROR_MSG;
06492     }  
06493   close(file);
06494 
06495   (*code_err) = msg.id_error;
06496   return (unsigned int) msg.metric.int32;
06497 }
06498 
06499 /*************************************************************************************************************/
06506 unsigned int
06507 get_is_rx_auth_countermeasures(char * dev_name,
06508                                unsigned int * code_err)
06509 {
06510   int file, nb_write, nb_read;
06511   struct qos_metric_net80211_msg msg;
06512 
06513   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
06514   msg.type_msg     = T_QUERY_MSG;
06515   msg.id_error     = NO_ERRORS;
06516   msg.metric_name  = IS_RX_AUTH_COUNTERMEASURES;
06517   msg.metric.int32 = 0; 
06518 
06519   if (dev_name)
06520     strcpy((char *) msg.dev_name, dev_name);
06521   else
06522     msg.dev_name[0] = '\0';   
06523 
06524   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
06525     {
06526       fprintf(stderr, "Can't open: ");
06527       perror(CROSS_LAYER_DEV_NAME_PATH);
06528       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
06529       msg.type_msg = T_ERROR_MSG;
06530     }
06531   nb_write = write(file, &msg, sizeof(msg));
06532   nb_read = read(file, &msg, sizeof(msg));
06533   if (nb_read == 0)
06534     {
06535       msg.id_error = COULD_NOT_READ_UNIX_DEV;
06536       msg.type_msg = T_ERROR_MSG;
06537     }  
06538   close(file);
06539 
06540   (*code_err) = msg.id_error;
06541   return (unsigned int) msg.metric.int32;
06542 }
06543 
06544 /*************************************************************************************************************/
06551 unsigned int
06552 get_is_rx_assoc_bss(char * dev_name,
06553                     unsigned int * code_err)
06554 {
06555   int file, nb_write, nb_read;
06556   struct qos_metric_net80211_msg msg;
06557 
06558   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
06559   msg.type_msg     = T_QUERY_MSG;
06560   msg.id_error     = NO_ERRORS;
06561   msg.metric_name  = IS_RX_ASSOC_BSS;
06562   msg.metric.int32 = 0; 
06563 
06564   if (dev_name)
06565     strcpy((char *) msg.dev_name, dev_name);
06566   else
06567     msg.dev_name[0] = '\0';   
06568 
06569   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
06570     {
06571       fprintf(stderr, "Can't open: ");
06572       perror(CROSS_LAYER_DEV_NAME_PATH);
06573       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
06574       msg.type_msg = T_ERROR_MSG;
06575     }
06576   nb_write = write(file, &msg, sizeof(msg));
06577   nb_read = read(file, &msg, sizeof(msg));
06578   if (nb_read == 0)
06579     {
06580       msg.id_error = COULD_NOT_READ_UNIX_DEV;
06581       msg.type_msg = T_ERROR_MSG;
06582     }  
06583   close(file);
06584 
06585   (*code_err) = msg.id_error;
06586   return (unsigned int) msg.metric.int32;
06587 }
06588 
06589 /*************************************************************************************************************/
06596 unsigned int
06597 get_is_rx_assoc_notauth(char * dev_name,
06598                         unsigned int * code_err)
06599 {
06600   int file, nb_write, nb_read;
06601   struct qos_metric_net80211_msg msg;
06602 
06603   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
06604   msg.type_msg     = T_QUERY_MSG;
06605   msg.id_error     = NO_ERRORS;
06606   msg.metric_name  = IS_RX_ASSOC_NOTAUTH;
06607   msg.metric.int32 = 0; 
06608 
06609   if (dev_name)
06610     strcpy((char *) msg.dev_name, dev_name);
06611   else
06612     msg.dev_name[0] = '\0';   
06613 
06614   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
06615     {
06616       fprintf(stderr, "Can't open: ");
06617       perror(CROSS_LAYER_DEV_NAME_PATH);
06618       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
06619       msg.type_msg = T_ERROR_MSG;
06620     }
06621   nb_write = write(file, &msg, sizeof(msg));
06622   nb_read = read(file, &msg, sizeof(msg));
06623   if (nb_read == 0)
06624     {
06625       msg.id_error = COULD_NOT_READ_UNIX_DEV;
06626       msg.type_msg = T_ERROR_MSG;
06627     }  
06628   close(file);
06629 
06630   (*code_err) = msg.id_error;
06631   return (unsigned int) msg.metric.int32;
06632 }
06633 
06634 /*************************************************************************************************************/
06641 unsigned int
06642 get_is_rx_assoc_capmismatch(char * dev_name,
06643                             unsigned int * code_err)
06644 {
06645   int file, nb_write, nb_read;
06646   struct qos_metric_net80211_msg msg;
06647 
06648   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
06649   msg.type_msg     = T_QUERY_MSG;
06650   msg.id_error     = NO_ERRORS;
06651   msg.metric_name  = IS_RX_ASSOC_CAPMISMATCH;
06652   msg.metric.int32 = 0; 
06653 
06654   if (dev_name)
06655     strcpy((char *) msg.dev_name, dev_name);
06656   else
06657     msg.dev_name[0] = '\0';   
06658 
06659   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
06660     {
06661       fprintf(stderr, "Can't open: ");
06662       perror(CROSS_LAYER_DEV_NAME_PATH);
06663       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
06664       msg.type_msg = T_ERROR_MSG;
06665     }
06666   nb_write = write(file, &msg, sizeof(msg));
06667   nb_read = read(file, &msg, sizeof(msg));
06668   if (nb_read == 0)
06669     {
06670       msg.id_error = COULD_NOT_READ_UNIX_DEV;
06671       msg.type_msg = T_ERROR_MSG;
06672     }  
06673   close(file);
06674 
06675   (*code_err) = msg.id_error;
06676   return (unsigned int) msg.metric.int32;
06677 }
06678 
06679 /*************************************************************************************************************/
06686 unsigned int
06687 get_is_rx_assoc_norate(char * dev_name,
06688                        unsigned int * code_err)
06689 {
06690   int file, nb_write, nb_read;
06691   struct qos_metric_net80211_msg msg;
06692 
06693   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
06694   msg.type_msg     = T_QUERY_MSG;
06695   msg.id_error     = NO_ERRORS;
06696   msg.metric_name  = IS_RX_ASSOC_NORATE;
06697   msg.metric.int32 = 0; 
06698 
06699   if (dev_name)
06700     strcpy((char *) msg.dev_name, dev_name);
06701   else
06702     msg.dev_name[0] = '\0';   
06703 
06704   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
06705     {
06706       fprintf(stderr, "Can't open: ");
06707       perror(CROSS_LAYER_DEV_NAME_PATH);
06708       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
06709       msg.type_msg = T_ERROR_MSG;
06710     }
06711   nb_write = write(file, &msg, sizeof(msg));
06712   nb_read = read(file, &msg, sizeof(msg));
06713   if (nb_read == 0)
06714     {
06715       msg.id_error = COULD_NOT_READ_UNIX_DEV;
06716       msg.type_msg = T_ERROR_MSG;
06717     }  
06718   close(file);
06719 
06720   (*code_err) = msg.id_error;
06721   return (unsigned int) msg.metric.int32;
06722 }
06723 
06724 /*************************************************************************************************************/
06731 unsigned int
06732 get_is_rx_assoc_badwpaie(char * dev_name,
06733                          unsigned int * code_err)
06734 {
06735   int file, nb_write, nb_read;
06736   struct qos_metric_net80211_msg msg;
06737 
06738   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
06739   msg.type_msg     = T_QUERY_MSG;
06740   msg.id_error     = NO_ERRORS;
06741   msg.metric_name  = IS_RX_ASSOC_BADWPAIE;
06742   msg.metric.int32 = 0; 
06743   
06744   if (dev_name)
06745     strcpy((char *) msg.dev_name, dev_name);
06746   else
06747     msg.dev_name[0] = '\0';   
06748 
06749   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
06750     {
06751       fprintf(stderr, "Can't open: ");
06752       perror(CROSS_LAYER_DEV_NAME_PATH);
06753       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
06754       msg.type_msg = T_ERROR_MSG;
06755     }
06756   nb_write = write(file, &msg, sizeof(msg));
06757   nb_read = read(file, &msg, sizeof(msg));
06758   if (nb_read == 0)
06759     {
06760       msg.id_error = COULD_NOT_READ_UNIX_DEV;
06761       msg.type_msg = T_ERROR_MSG;
06762     }  
06763   close(file);
06764 
06765   (*code_err) = msg.id_error;
06766   return (unsigned int) msg.metric.int32;
06767 }
06768 
06769 /*************************************************************************************************************/
06776 unsigned int
06777 get_is_rx_deauth(char * dev_name,
06778                  unsigned int * code_err)
06779 {
06780   int file, nb_write, nb_read;
06781   struct qos_metric_net80211_msg msg;
06782 
06783   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
06784   msg.type_msg     = T_QUERY_MSG;
06785   msg.id_error     = NO_ERRORS;
06786   msg.metric_name  = IS_RX_DEAUTH;
06787   msg.metric.int32 = 0; 
06788 
06789   if (dev_name)
06790     strcpy((char *) msg.dev_name, dev_name);
06791   else
06792     msg.dev_name[0] = '\0';   
06793 
06794   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
06795     {
06796       fprintf(stderr, "Can't open: ");
06797       perror(CROSS_LAYER_DEV_NAME_PATH);
06798       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
06799       msg.type_msg = T_ERROR_MSG;
06800     }
06801   nb_write = write(file, &msg, sizeof(msg));
06802   nb_read = read(file, &msg, sizeof(msg));
06803   if (nb_read == 0)
06804     {
06805       msg.id_error = COULD_NOT_READ_UNIX_DEV;
06806       msg.type_msg = T_ERROR_MSG;
06807     }  
06808   close(file);
06809 
06810   (*code_err) = msg.id_error;
06811   return (unsigned int) msg.metric.int32;
06812 }
06813 
06814 /*************************************************************************************************************/
06821 unsigned int
06822 get_is_rx_disassoc(char * dev_name,
06823                    unsigned int * code_err)
06824 {
06825   int file, nb_write, nb_read;
06826   struct qos_metric_net80211_msg msg;
06827 
06828   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
06829   msg.type_msg     = T_QUERY_MSG;
06830   msg.id_error     = NO_ERRORS;
06831   msg.metric_name  = IS_RX_DISASSOC;
06832   msg.metric.int32 = 0; 
06833 
06834   if (dev_name)
06835     strcpy((char *) msg.dev_name, dev_name);
06836   else
06837     msg.dev_name[0] = '\0';   
06838 
06839   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
06840     {
06841       fprintf(stderr, "Can't open: ");
06842       perror(CROSS_LAYER_DEV_NAME_PATH);
06843       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
06844       msg.type_msg = T_ERROR_MSG;
06845     }
06846   nb_write = write(file, &msg, sizeof(msg));
06847   nb_read = read(file, &msg, sizeof(msg));
06848   if (nb_read == 0)
06849     {
06850       msg.id_error = COULD_NOT_READ_UNIX_DEV;
06851       msg.type_msg = T_ERROR_MSG;
06852     }  
06853   close(file);
06854 
06855   (*code_err) = msg.id_error;
06856   return (unsigned int) msg.metric.int32;
06857 }
06858 
06859 /*************************************************************************************************************/
06866 unsigned int
06867 get_is_rx_badsubtype(char * dev_name,
06868                      unsigned int * code_err)
06869 {
06870   int file, nb_write, nb_read;
06871   struct qos_metric_net80211_msg msg;
06872 
06873   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
06874   msg.type_msg     = T_QUERY_MSG;
06875   msg.id_error     = NO_ERRORS;
06876   msg.metric_name  = IS_RX_BADSUBTYPE;
06877   msg.metric.int32 = 0; 
06878 
06879   if (dev_name)
06880     strcpy((char *) msg.dev_name, dev_name);
06881   else
06882     msg.dev_name[0] = '\0';   
06883 
06884   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
06885     {
06886       fprintf(stderr, "Can't open: ");
06887       perror(CROSS_LAYER_DEV_NAME_PATH);
06888       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
06889       msg.type_msg = T_ERROR_MSG;
06890     }
06891   nb_write = write(file, &msg, sizeof(msg));
06892   nb_read = read(file, &msg, sizeof(msg));
06893   if (nb_read == 0)
06894     {
06895       msg.id_error = COULD_NOT_READ_UNIX_DEV;
06896       msg.type_msg = T_ERROR_MSG;
06897     }  
06898   close(file);
06899 
06900   (*code_err) = msg.id_error;
06901   return (unsigned int) msg.metric.int32;
06902 }
06903 
06904 /*************************************************************************************************************/
06911 unsigned int
06912 get_is_rx_nobuf(char * dev_name,
06913                 unsigned int * code_err)
06914 {
06915   int file, nb_write, nb_read;
06916   struct qos_metric_net80211_msg msg;
06917 
06918   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
06919   msg.type_msg     = T_QUERY_MSG;
06920   msg.id_error     = NO_ERRORS;
06921   msg.metric_name  = IS_RX_NOBUF;
06922   msg.metric.int32 = 0; 
06923 
06924   if (dev_name)
06925     strcpy((char *) msg.dev_name, dev_name);
06926   else
06927     msg.dev_name[0] = '\0';   
06928 
06929   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
06930     {
06931       fprintf(stderr, "Can't open: ");
06932       perror(CROSS_LAYER_DEV_NAME_PATH);
06933       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
06934       msg.type_msg = T_ERROR_MSG;
06935     }
06936   nb_write = write(file, &msg, sizeof(msg));
06937   nb_read = read(file, &msg, sizeof(msg));
06938   if (nb_read == 0)
06939     {
06940       msg.id_error = COULD_NOT_READ_UNIX_DEV;
06941       msg.type_msg = T_ERROR_MSG;
06942     }  
06943   close(file);
06944 
06945   (*code_err) = msg.id_error;
06946   return (unsigned int) msg.metric.int32;
06947 }
06948 
06949 /*************************************************************************************************************/
06956 unsigned int
06957 get_is_rx_decryptcrc(char * dev_name,
06958                      unsigned int * code_err)
06959 {
06960   int file, nb_write, nb_read;
06961   struct qos_metric_net80211_msg msg;
06962 
06963   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
06964   msg.type_msg     = T_QUERY_MSG;
06965   msg.id_error     = NO_ERRORS;
06966   msg.metric_name  = IS_RX_DECRYPTCRC;
06967   msg.metric.int32 = 0; 
06968 
06969   if (dev_name)
06970     strcpy((char *) msg.dev_name, dev_name);
06971   else
06972     msg.dev_name[0] = '\0';   
06973 
06974   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
06975     {
06976       fprintf(stderr, "Can't open: ");
06977       perror(CROSS_LAYER_DEV_NAME_PATH);
06978       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
06979       msg.type_msg = T_ERROR_MSG;
06980     }
06981   nb_write = write(file, &msg, sizeof(msg));
06982   nb_read = read(file, &msg, sizeof(msg));
06983   if (nb_read == 0)
06984     {
06985       msg.id_error = COULD_NOT_READ_UNIX_DEV;
06986       msg.type_msg = T_ERROR_MSG;
06987     }  
06988   close(file);
06989 
06990   (*code_err) = msg.id_error;
06991   return (unsigned int) msg.metric.int32;
06992 }
06993 
06994 /*************************************************************************************************************/
07001 unsigned int
07002 get_is_rx_ahdemo_mgt(char * dev_name,
07003                      unsigned int * code_err)
07004 {
07005   int file, nb_write, nb_read;
07006   struct qos_metric_net80211_msg msg;
07007 
07008   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
07009   msg.type_msg     = T_QUERY_MSG;
07010   msg.id_error     = NO_ERRORS;
07011   msg.metric_name  = IS_RX_AHDEMO_MGT;
07012   msg.metric.int32 = 0; 
07013   
07014   if (dev_name)
07015     strcpy((char *) msg.dev_name, dev_name);
07016   else
07017     msg.dev_name[0] = '\0';   
07018 
07019   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
07020     {
07021       fprintf(stderr, "Can't open: ");
07022       perror(CROSS_LAYER_DEV_NAME_PATH);
07023       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
07024       msg.type_msg = T_ERROR_MSG;
07025     }
07026   nb_write = write(file, &msg, sizeof(msg));
07027   nb_read = read(file, &msg, sizeof(msg));
07028   if (nb_read == 0)
07029     {
07030       msg.id_error = COULD_NOT_READ_UNIX_DEV;
07031       msg.type_msg = T_ERROR_MSG;
07032     }  
07033   close(file);
07034 
07035   (*code_err) = msg.id_error;
07036   return (unsigned int) msg.metric.int32;
07037 }
07038 
07039 /*************************************************************************************************************/
07046 unsigned int
07047 get_is_rx_bad_auth(char * dev_name,
07048                    unsigned int * code_err)
07049 {
07050   int file, nb_write, nb_read;
07051   struct qos_metric_net80211_msg msg;
07052 
07053   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
07054   msg.type_msg     = T_QUERY_MSG;
07055   msg.id_error     = NO_ERRORS;
07056   msg.metric_name  = IS_RX_BAD_AUTH;
07057   msg.metric.int32 = 0; 
07058 
07059   if (dev_name)
07060     strcpy((char *) msg.dev_name, dev_name);
07061   else
07062     msg.dev_name[0] = '\0';   
07063 
07064   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
07065     {
07066       fprintf(stderr, "Can't open: ");
07067       perror(CROSS_LAYER_DEV_NAME_PATH);
07068       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
07069       msg.type_msg = T_ERROR_MSG;
07070     }
07071   nb_write = write(file, &msg, sizeof(msg));
07072   nb_read = read(file, &msg, sizeof(msg));
07073   if (nb_read == 0)
07074     {
07075       msg.id_error = COULD_NOT_READ_UNIX_DEV;
07076       msg.type_msg = T_ERROR_MSG;
07077     }  
07078   close(file);
07079 
07080   (*code_err) = msg.id_error;
07081   return (unsigned int) msg.metric.int32;
07082 }
07083 
07084 /*************************************************************************************************************/
07091 unsigned int
07092 get_is_rx_unauth(char * dev_name,
07093                  unsigned int * code_err)
07094 {
07095   int file, nb_write, nb_read;
07096   struct qos_metric_net80211_msg msg;
07097 
07098   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
07099   msg.type_msg     = T_QUERY_MSG;
07100   msg.id_error     = NO_ERRORS;
07101   msg.metric_name  = IS_RX_UNAUTH;
07102   msg.metric.int32 = 0; 
07103 
07104   if (dev_name)
07105     strcpy((char *) msg.dev_name, dev_name);
07106   else
07107     msg.dev_name[0] = '\0';   
07108 
07109   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
07110     {
07111       fprintf(stderr, "Can't open: ");
07112       perror(CROSS_LAYER_DEV_NAME_PATH);
07113       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
07114       msg.type_msg = T_ERROR_MSG;
07115     }
07116   nb_write = write(file, &msg, sizeof(msg));
07117   nb_read = read(file, &msg, sizeof(msg));
07118   if (nb_read == 0)
07119     {
07120       msg.id_error = COULD_NOT_READ_UNIX_DEV;
07121       msg.type_msg = T_ERROR_MSG;
07122     }  
07123   close(file);
07124 
07125   (*code_err) = msg.id_error;
07126   return (unsigned int) msg.metric.int32;
07127 }
07128 
07129 /*************************************************************************************************************/
07136 unsigned int
07137 get_is_rx_badkeyid(char * dev_name,
07138                    unsigned int * code_err)
07139 {
07140   int file, nb_write, nb_read;
07141   struct qos_metric_net80211_msg msg;
07142 
07143   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
07144   msg.type_msg     = T_QUERY_MSG;
07145   msg.id_error     = NO_ERRORS;
07146   msg.metric_name  = IS_RX_BADKEYID;
07147   msg.metric.int32 = 0; 
07148 
07149   if (dev_name)
07150     strcpy((char *) msg.dev_name, dev_name);
07151   else
07152     msg.dev_name[0] = '\0';   
07153 
07154   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
07155     {
07156       fprintf(stderr, "Can't open: ");
07157       perror(CROSS_LAYER_DEV_NAME_PATH);
07158       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
07159       msg.type_msg = T_ERROR_MSG;
07160     }
07161   nb_write = write(file, &msg, sizeof(msg));
07162   nb_read = read(file, &msg, sizeof(msg));
07163   if (nb_read == 0)
07164     {
07165       msg.id_error = COULD_NOT_READ_UNIX_DEV;
07166       msg.type_msg = T_ERROR_MSG;
07167     }  
07168   close(file);
07169 
07170   (*code_err) = msg.id_error;
07171   return (unsigned int) msg.metric.int32;
07172 }
07173 
07174 /*************************************************************************************************************/
07181 unsigned int
07182 get_is_rx_ccmpreplay(char * dev_name,
07183                       unsigned int * code_err)
07184 {
07185   int file, nb_write, nb_read;
07186   struct qos_metric_net80211_msg msg;
07187 
07188   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
07189   msg.type_msg     = T_QUERY_MSG;
07190   msg.id_error     = NO_ERRORS;
07191   msg.metric_name  = IS_RX_CCMPREPLAY;
07192   msg.metric.int32 = 0; 
07193 
07194   if (dev_name)
07195     strcpy((char *) msg.dev_name, dev_name);
07196   else
07197     msg.dev_name[0] = '\0';   
07198 
07199   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
07200     {
07201       fprintf(stderr, "Can't open: ");
07202       perror(CROSS_LAYER_DEV_NAME_PATH);
07203       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
07204       msg.type_msg = T_ERROR_MSG;
07205     }
07206   nb_write = write(file, &msg, sizeof(msg));
07207   nb_read = read(file, &msg, sizeof(msg));
07208   if (nb_read == 0)
07209     {
07210       msg.id_error = COULD_NOT_READ_UNIX_DEV;
07211       msg.type_msg = T_ERROR_MSG;
07212     }  
07213   close(file);
07214 
07215   (*code_err) = msg.id_error;
07216   return (unsigned int) msg.metric.int32;
07217 }
07218 
07219 /*************************************************************************************************************/
07226 unsigned int
07227 get_is_rx_ccmpformat(char * dev_name,
07228                      unsigned int * code_err)
07229 {
07230   int file, nb_write, nb_read;
07231   struct qos_metric_net80211_msg msg;
07232 
07233   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
07234   msg.type_msg     = T_QUERY_MSG;
07235   msg.id_error     = NO_ERRORS;
07236   msg.metric_name  = IS_RX_CCMPFORMAT;
07237   msg.metric.int32 = 0; 
07238 
07239   if (dev_name)
07240     strcpy((char *) msg.dev_name, dev_name);
07241   else
07242     msg.dev_name[0] = '\0';   
07243 
07244   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
07245     {
07246       fprintf(stderr, "Can't open: ");
07247       perror(CROSS_LAYER_DEV_NAME_PATH);
07248       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
07249       msg.type_msg = T_ERROR_MSG;
07250     }
07251   nb_write = write(file, &msg, sizeof(msg));
07252   nb_read = read(file, &msg, sizeof(msg));
07253   if (nb_read == 0)
07254     {
07255       msg.id_error = COULD_NOT_READ_UNIX_DEV;
07256       msg.type_msg = T_ERROR_MSG;
07257     }  
07258   close(file);
07259 
07260   (*code_err) = msg.id_error;
07261   return (unsigned int) msg.metric.int32;
07262 }
07263 
07264 /*************************************************************************************************************/
07271 unsigned int
07272 get_is_rx_ccmpmic(char * dev_name,
07273                   unsigned int * code_err)
07274 {
07275   int file, nb_write, nb_read;
07276   struct qos_metric_net80211_msg msg;
07277 
07278   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
07279   msg.type_msg     = T_QUERY_MSG;
07280   msg.id_error     = NO_ERRORS;
07281   msg.metric_name  = IS_RX_CCMPMIC;
07282   msg.metric.int32 = 0; 
07283 
07284   if (dev_name)
07285     strcpy((char *) msg.dev_name, dev_name);
07286   else
07287     msg.dev_name[0] = '\0';   
07288 
07289   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
07290     {
07291       fprintf(stderr, "Can't open: ");
07292       perror(CROSS_LAYER_DEV_NAME_PATH);
07293       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
07294       msg.type_msg = T_ERROR_MSG;
07295     }
07296   nb_write = write(file, &msg, sizeof(msg));
07297   nb_read = read(file, &msg, sizeof(msg));
07298   if (nb_read == 0)
07299     {
07300       msg.id_error = COULD_NOT_READ_UNIX_DEV;
07301       msg.type_msg = T_ERROR_MSG;
07302     }  
07303   close(file);
07304 
07305   (*code_err) = msg.id_error;
07306   return (unsigned int) msg.metric.int32;
07307 }
07308 
07309 /*************************************************************************************************************/
07316 unsigned int
07317 get_is_rx_tkipreplay(char * dev_name,
07318                      unsigned int * code_err)
07319 {
07320   int file, nb_write, nb_read;
07321   struct qos_metric_net80211_msg msg;
07322 
07323   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
07324   msg.type_msg     = T_QUERY_MSG;
07325   msg.id_error     = NO_ERRORS;
07326   msg.metric_name  = IS_RX_TKIPREPLAY;
07327   msg.metric.int32 = 0; 
07328 
07329   if (dev_name)
07330     strcpy((char *) msg.dev_name, dev_name);
07331   else
07332     msg.dev_name[0] = '\0';   
07333 
07334   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
07335     {
07336       fprintf(stderr, "Can't open: ");
07337       perror(CROSS_LAYER_DEV_NAME_PATH);
07338       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
07339       msg.type_msg = T_ERROR_MSG;
07340     }
07341   nb_write = write(file, &msg, sizeof(msg));
07342   nb_read = read(file, &msg, sizeof(msg));
07343   if (nb_read == 0)
07344     {
07345       msg.id_error = COULD_NOT_READ_UNIX_DEV;
07346       msg.type_msg = T_ERROR_MSG;
07347     }  
07348   close(file);
07349 
07350   (*code_err) = msg.id_error;
07351   return (unsigned int) msg.metric.int32;
07352 }
07353 
07354 /*************************************************************************************************************/
07361 unsigned int
07362 get_is_rx_tkipformat(char * dev_name,
07363                      unsigned int * code_err)
07364 {
07365   int file, nb_write, nb_read;
07366   struct qos_metric_net80211_msg msg;
07367 
07368   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
07369   msg.type_msg     = T_QUERY_MSG;
07370   msg.id_error     = NO_ERRORS;
07371   msg.metric_name  = IS_RX_TKIPFORMAT;
07372   msg.metric.int32 = 0; 
07373 
07374   if (dev_name)
07375     strcpy((char *) msg.dev_name, dev_name);
07376   else
07377     msg.dev_name[0] = '\0';   
07378 
07379   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
07380     {
07381       fprintf(stderr, "Can't open: ");
07382       perror(CROSS_LAYER_DEV_NAME_PATH);
07383       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
07384       msg.type_msg = T_ERROR_MSG;
07385     }
07386   nb_write = write(file, &msg, sizeof(msg));
07387   nb_read = read(file, &msg, sizeof(msg));
07388   if (nb_read == 0)
07389     {
07390       msg.id_error = COULD_NOT_READ_UNIX_DEV;
07391       msg.type_msg = T_ERROR_MSG;
07392     }  
07393   close(file);
07394 
07395   (*code_err) = msg.id_error;
07396   return (unsigned int) msg.metric.int32;
07397 }
07398 
07399 /*************************************************************************************************************/
07406 unsigned int
07407 get_is_rx_tkipmic(char * dev_name,
07408                      unsigned int * code_err)
07409 {
07410   int file, nb_write, nb_read;
07411   struct qos_metric_net80211_msg msg;
07412 
07413   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
07414   msg.type_msg     = T_QUERY_MSG;
07415   msg.id_error     = NO_ERRORS;
07416   msg.metric_name  = IS_RX_TKIPMIC;
07417   msg.metric.int32 = 0; 
07418 
07419   if (dev_name)
07420     strcpy((char *) msg.dev_name, dev_name);
07421   else
07422     msg.dev_name[0] = '\0';   
07423 
07424   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
07425     {
07426       fprintf(stderr, "Can't open: ");
07427       perror(CROSS_LAYER_DEV_NAME_PATH);
07428       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
07429       msg.type_msg = T_ERROR_MSG;
07430     }
07431   nb_write = write(file, &msg, sizeof(msg));
07432   nb_read = read(file, &msg, sizeof(msg));
07433   if (nb_read == 0)
07434     {
07435       msg.id_error = COULD_NOT_READ_UNIX_DEV;
07436       msg.type_msg = T_ERROR_MSG;
07437     }  
07438   close(file);
07439 
07440   (*code_err) = msg.id_error;
07441   return (unsigned int) msg.metric.int32;
07442 }
07443 
07444 /*************************************************************************************************************/
07451 unsigned int
07452 get_is_rx_tkipicv(char * dev_name,
07453                   unsigned int * code_err)
07454 {
07455   int file, nb_write, nb_read;
07456   struct qos_metric_net80211_msg msg;
07457 
07458   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
07459   msg.type_msg     = T_QUERY_MSG;
07460   msg.id_error     = NO_ERRORS;
07461   msg.metric_name  = IS_RX_TKIPICV;
07462   msg.metric.int32 = 0; 
07463 
07464   if (dev_name)
07465     strcpy((char *) msg.dev_name, dev_name);
07466   else
07467     msg.dev_name[0] = '\0';   
07468 
07469   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
07470     {
07471       fprintf(stderr, "Can't open: ");
07472       perror(CROSS_LAYER_DEV_NAME_PATH);
07473       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
07474       msg.type_msg = T_ERROR_MSG;
07475     }
07476   nb_write = write(file, &msg, sizeof(msg));
07477   nb_read = read(file, &msg, sizeof(msg));
07478   if (nb_read == 0)
07479     {
07480       msg.id_error = COULD_NOT_READ_UNIX_DEV;
07481       msg.type_msg = T_ERROR_MSG;
07482     }  
07483   close(file);
07484 
07485   (*code_err) = msg.id_error;
07486   return (unsigned int) msg.metric.int32;
07487 }
07488 
07489 /*************************************************************************************************************/
07496 unsigned int
07497 get_is_rx_badcipher(char * dev_name,
07498                     unsigned int * code_err)
07499 {
07500   int file, nb_write, nb_read;
07501   struct qos_metric_net80211_msg msg;
07502 
07503   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
07504   msg.type_msg     = T_QUERY_MSG;
07505   msg.id_error     = NO_ERRORS;
07506   msg.metric_name  = IS_RX_BADCIPHER;
07507   msg.metric.int32 = 0; 
07508 
07509   if (dev_name)
07510     strcpy((char *) msg.dev_name, dev_name);
07511   else
07512     msg.dev_name[0] = '\0';   
07513 
07514   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
07515     {
07516       fprintf(stderr, "Can't open: ");
07517       perror(CROSS_LAYER_DEV_NAME_PATH);
07518       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
07519       msg.type_msg = T_ERROR_MSG;
07520     }
07521   nb_write = write(file, &msg, sizeof(msg));
07522   nb_read = read(file, &msg, sizeof(msg));
07523   if (nb_read == 0)
07524     {
07525       msg.id_error = COULD_NOT_READ_UNIX_DEV;
07526       msg.type_msg = T_ERROR_MSG;
07527     }  
07528   close(file);
07529 
07530   (*code_err) = msg.id_error;
07531   return (unsigned int) msg.metric.int32;
07532 }
07533 
07534 /*************************************************************************************************************/
07541 unsigned int
07542 get_is_rx_nocipherctx(char * dev_name,
07543                       unsigned int * code_err)
07544 {
07545   int file, nb_write, nb_read;
07546   struct qos_metric_net80211_msg msg;
07547 
07548   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
07549   msg.type_msg     = T_QUERY_MSG;
07550   msg.id_error     = NO_ERRORS;
07551   msg.metric_name  = IS_RX_NOCIPHERCTX;
07552   msg.metric.int32 = 0; 
07553 
07554   if (dev_name)
07555     strcpy((char *) msg.dev_name, dev_name);
07556   else
07557     msg.dev_name[0] = '\0';   
07558 
07559   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
07560     {
07561       fprintf(stderr, "Can't open: ");
07562       perror(CROSS_LAYER_DEV_NAME_PATH);
07563       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
07564       msg.type_msg = T_ERROR_MSG;
07565     }
07566   nb_write = write(file, &msg, sizeof(msg));
07567   nb_read = read(file, &msg, sizeof(msg));
07568   if (nb_read == 0)
07569     {
07570       msg.id_error = COULD_NOT_READ_UNIX_DEV;
07571       msg.type_msg = T_ERROR_MSG;
07572     }  
07573   close(file);
07574 
07575   (*code_err) = msg.id_error;
07576   return (unsigned int) msg.metric.int32;
07577 }
07578 
07579 /*************************************************************************************************************/
07586 unsigned int
07587 get_is_rx_acl(char * dev_name,
07588               unsigned int * code_err)
07589 {
07590   int file, nb_write, nb_read;
07591   struct qos_metric_net80211_msg msg;
07592 
07593   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
07594   msg.type_msg     = T_QUERY_MSG;
07595   msg.id_error     = NO_ERRORS;
07596   msg.metric_name  = IS_RX_ACL;
07597   msg.metric.int32 = 0; 
07598 
07599   if (dev_name)
07600     strcpy((char *) msg.dev_name, dev_name);
07601   else
07602     msg.dev_name[0] = '\0';   
07603 
07604   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
07605     {
07606       fprintf(stderr, "Can't open: ");
07607       perror(CROSS_LAYER_DEV_NAME_PATH);
07608       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
07609       msg.type_msg = T_ERROR_MSG;
07610     }
07611   nb_write = write(file, &msg, sizeof(msg));
07612   nb_read = read(file, &msg, sizeof(msg));
07613   if (nb_read == 0)
07614     {
07615       msg.id_error = COULD_NOT_READ_UNIX_DEV;
07616       msg.type_msg = T_ERROR_MSG;
07617     }  
07618   close(file);
07619 
07620   (*code_err) = msg.id_error;
07621   return (unsigned int) msg.metric.int32;
07622 }
07623 
07624 /*************************************************************************************************************/
07631 unsigned int
07632 get_is_tx_nobuf(char * dev_name,
07633                 unsigned int * code_err)
07634 {
07635   int file, nb_write, nb_read;
07636   struct qos_metric_net80211_msg msg;
07637 
07638   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
07639   msg.type_msg     = T_QUERY_MSG;
07640   msg.id_error     = NO_ERRORS;
07641   msg.metric_name  = IS_TX_NOBUF;
07642   msg.metric.int32 = 0; 
07643 
07644   if (dev_name)
07645     strcpy((char *) msg.dev_name, dev_name);
07646   else
07647     msg.dev_name[0] = '\0';   
07648 
07649   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
07650     {
07651       fprintf(stderr, "Can't open: ");
07652       perror(CROSS_LAYER_DEV_NAME_PATH);
07653       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
07654       msg.type_msg = T_ERROR_MSG;
07655     }
07656   nb_write = write(file, &msg, sizeof(msg));
07657   nb_read = read(file, &msg, sizeof(msg));
07658   if (nb_read == 0)
07659     {
07660       msg.id_error = COULD_NOT_READ_UNIX_DEV;
07661       msg.type_msg = T_ERROR_MSG;
07662     }  
07663   close(file);
07664 
07665   (*code_err) = msg.id_error;
07666   return (unsigned int) msg.metric.int32;
07667 }
07668 
07669 /*************************************************************************************************************/
07676 unsigned int
07677 get_is_tx_nonode(char * dev_name,
07678                  unsigned int * code_err)
07679 {
07680   int file, nb_write, nb_read;
07681   struct qos_metric_net80211_msg msg;
07682 
07683   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
07684   msg.type_msg     = T_QUERY_MSG;
07685   msg.id_error     = NO_ERRORS;
07686   msg.metric_name  = IS_TX_NONODE;
07687   msg.metric.int32 = 0; 
07688 
07689   if (dev_name)
07690     strcpy((char *) msg.dev_name, dev_name);
07691   else
07692     msg.dev_name[0] = '\0';   
07693 
07694   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
07695     {
07696       fprintf(stderr, "Can't open: ");
07697       perror(CROSS_LAYER_DEV_NAME_PATH);
07698       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
07699       msg.type_msg = T_ERROR_MSG;
07700     }
07701   nb_write = write(file, &msg, sizeof(msg));
07702   nb_read = read(file, &msg, sizeof(msg));
07703   if (nb_read == 0)
07704     {
07705       msg.id_error = COULD_NOT_READ_UNIX_DEV;
07706       msg.type_msg = T_ERROR_MSG;
07707     }  
07708   close(file);
07709 
07710   (*code_err) = msg.id_error;
07711   return (unsigned int) msg.metric.int32;
07712 }
07713 
07714 /*************************************************************************************************************/
07721 unsigned int
07722 get_is_tx_unknownmgt(char * dev_name,
07723                      unsigned int * code_err)
07724 {
07725   int file, nb_write, nb_read;
07726   struct qos_metric_net80211_msg msg;
07727 
07728   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
07729   msg.type_msg     = T_QUERY_MSG;
07730   msg.id_error     = NO_ERRORS;
07731   msg.metric_name  = IS_TX_UNKNOWNMGT;
07732   msg.metric.int32 = 0; 
07733 
07734   if (dev_name)
07735     strcpy((char *) msg.dev_name, dev_name);
07736   else
07737     msg.dev_name[0] = '\0';   
07738 
07739   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
07740     {
07741       fprintf(stderr, "Can't open: ");
07742       perror(CROSS_LAYER_DEV_NAME_PATH);
07743       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
07744       msg.type_msg = T_ERROR_MSG;
07745     }
07746   nb_write = write(file, &msg, sizeof(msg));
07747   nb_read = read(file, &msg, sizeof(msg));
07748   if (nb_read == 0)
07749     {
07750       msg.id_error = COULD_NOT_READ_UNIX_DEV;
07751       msg.type_msg = T_ERROR_MSG;
07752     }  
07753   close(file);
07754 
07755   (*code_err) = msg.id_error;
07756   return (unsigned int) msg.metric.int32;
07757 }
07758 
07759 /*************************************************************************************************************/
07766 unsigned int
07767 get_is_tx_badcipher(char * dev_name,
07768                     unsigned int * code_err)
07769 {
07770   int file, nb_write, nb_read;
07771   struct qos_metric_net80211_msg msg;
07772 
07773   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
07774   msg.type_msg     = T_QUERY_MSG;
07775   msg.id_error     = NO_ERRORS;
07776   msg.metric_name  = IS_TX_BADCIPHER;
07777   msg.metric.int32 = 0; 
07778 
07779   if (dev_name)
07780     strcpy((char *) msg.dev_name, dev_name);
07781   else
07782     msg.dev_name[0] = '\0';   
07783 
07784   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
07785     {
07786       fprintf(stderr, "Can't open: ");
07787       perror(CROSS_LAYER_DEV_NAME_PATH);
07788       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
07789       msg.type_msg = T_ERROR_MSG;
07790     }
07791   nb_write = write(file, &msg, sizeof(msg));
07792   nb_read = read(file, &msg, sizeof(msg));
07793   if (nb_read == 0)
07794     {
07795       msg.id_error = COULD_NOT_READ_UNIX_DEV;
07796       msg.type_msg = T_ERROR_MSG;
07797     }  
07798   close(file);
07799 
07800   (*code_err) = msg.id_error;
07801   return (unsigned int) msg.metric.int32;
07802 }
07803 
07804 /*************************************************************************************************************/
07811 unsigned int
07812 get_is_tx_nodefkey(char * dev_name,
07813                    unsigned int * code_err)
07814 {
07815   int file, nb_write, nb_read;
07816   struct qos_metric_net80211_msg msg;
07817 
07818   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
07819   msg.type_msg     = T_QUERY_MSG;
07820   msg.id_error     = NO_ERRORS;
07821   msg.metric_name  = IS_TX_NODEFKEY;
07822   msg.metric.int32 = 0; 
07823 
07824   if (dev_name)
07825     strcpy((char *) msg.dev_name, dev_name);
07826   else
07827     msg.dev_name[0] = '\0';   
07828 
07829   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
07830     {
07831       fprintf(stderr, "Can't open: ");
07832       perror(CROSS_LAYER_DEV_NAME_PATH);
07833       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
07834       msg.type_msg = T_ERROR_MSG;
07835     }
07836   nb_write = write(file, &msg, sizeof(msg));
07837   nb_read = read(file, &msg, sizeof(msg));
07838   if (nb_read == 0)
07839     {
07840       msg.id_error = COULD_NOT_READ_UNIX_DEV;
07841       msg.type_msg = T_ERROR_MSG;
07842     }  
07843   close(file);
07844 
07845   (*code_err) = msg.id_error;
07846   return (unsigned int) msg.metric.int32;
07847 }
07848 
07849 /*************************************************************************************************************/
07856 unsigned int
07857 get_is_tx_noheadroom(char * dev_name,
07858                      unsigned int * code_err)
07859 {
07860   int file, nb_write, nb_read;
07861   struct qos_metric_net80211_msg msg;
07862 
07863   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
07864   msg.type_msg     = T_QUERY_MSG;
07865   msg.id_error     = NO_ERRORS;
07866   msg.metric_name  = IS_TX_NOHEADROOM;
07867   msg.metric.int32 = 0; 
07868 
07869   if (dev_name)
07870     strcpy((char *) msg.dev_name, dev_name);
07871   else
07872     msg.dev_name[0] = '\0';   
07873 
07874   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
07875     {
07876       fprintf(stderr, "Can't open: ");
07877       perror(CROSS_LAYER_DEV_NAME_PATH);
07878       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
07879       msg.type_msg = T_ERROR_MSG;
07880     }
07881   nb_write = write(file, &msg, sizeof(msg));
07882   nb_read = read(file, &msg, sizeof(msg));
07883   if (nb_read == 0)
07884     {
07885       msg.id_error = COULD_NOT_READ_UNIX_DEV;
07886       msg.type_msg = T_ERROR_MSG;
07887     }  
07888   close(file);
07889 
07890   (*code_err) = msg.id_error;
07891   return (unsigned int) msg.metric.int32;
07892 }
07893 
07894 /*************************************************************************************************************/
07901 unsigned int
07902 get_is_scan_active(char * dev_name,
07903                    unsigned int * code_err)
07904 {
07905   int file, nb_write, nb_read;
07906   struct qos_metric_net80211_msg msg;
07907 
07908   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
07909   msg.type_msg     = T_QUERY_MSG;
07910   msg.id_error     = NO_ERRORS;
07911   msg.metric_name  = IS_SCAN_ACTIVE;
07912   msg.metric.int32 = 0; 
07913 
07914   if (dev_name)
07915     strcpy((char *) msg.dev_name, dev_name);
07916   else
07917     msg.dev_name[0] = '\0';   
07918 
07919   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
07920     {
07921       fprintf(stderr, "Can't open: ");
07922       perror(CROSS_LAYER_DEV_NAME_PATH);
07923       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
07924       msg.type_msg = T_ERROR_MSG;
07925     }
07926   nb_write = write(file, &msg, sizeof(msg));
07927   nb_read = read(file, &msg, sizeof(msg));
07928   if (nb_read == 0)
07929     {
07930       msg.id_error = COULD_NOT_READ_UNIX_DEV;
07931       msg.type_msg = T_ERROR_MSG;
07932     }  
07933   close(file);
07934 
07935   (*code_err) = msg.id_error;
07936   return (unsigned int) msg.metric.int32;
07937 }
07938 
07939 /*************************************************************************************************************/
07946 unsigned int
07947 get_is_scan_passive(char * dev_name,
07948                     unsigned int * code_err)
07949 {
07950   int file, nb_write, nb_read;
07951   struct qos_metric_net80211_msg msg;
07952 
07953   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
07954   msg.type_msg     = T_QUERY_MSG;
07955   msg.id_error     = NO_ERRORS;
07956   msg.metric_name  = IS_SCAN_PASSIVE;
07957   msg.metric.int32 = 0; 
07958 
07959   if (dev_name)
07960     strcpy((char *) msg.dev_name, dev_name);
07961   else
07962     msg.dev_name[0] = '\0';   
07963 
07964   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
07965     {
07966       fprintf(stderr, "Can't open: ");
07967       perror(CROSS_LAYER_DEV_NAME_PATH);
07968       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
07969       msg.type_msg = T_ERROR_MSG;
07970     }
07971   nb_write = write(file, &msg, sizeof(msg));
07972   nb_read = read(file, &msg, sizeof(msg));
07973   if (nb_read == 0)
07974     {
07975       msg.id_error = COULD_NOT_READ_UNIX_DEV;
07976       msg.type_msg = T_ERROR_MSG;
07977     }  
07978   close(file);
07979 
07980   (*code_err) = msg.id_error;
07981   return (unsigned int) msg.metric.int32;
07982 }
07983 
07984 /*************************************************************************************************************/
07991 unsigned int
07992 get_is_node_timeout(char * dev_name,
07993                     unsigned int * code_err)
07994 {
07995   int file, nb_write, nb_read;
07996   struct qos_metric_net80211_msg msg;
07997 
07998   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
07999   msg.type_msg     = T_QUERY_MSG;
08000   msg.id_error     = NO_ERRORS;
08001   msg.metric_name  = IS_NODE_TIMEOUT;
08002   msg.metric.int32 = 0; 
08003 
08004   if (dev_name)
08005     strcpy((char *) msg.dev_name, dev_name);
08006   else
08007     msg.dev_name[0] = '\0';   
08008 
08009   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
08010     {
08011       fprintf(stderr, "Can't open: ");
08012       perror(CROSS_LAYER_DEV_NAME_PATH);
08013       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
08014       msg.type_msg = T_ERROR_MSG;
08015     }
08016   nb_write = write(file, &msg, sizeof(msg));
08017   nb_read = read(file, &msg, sizeof(msg));
08018   if (nb_read == 0)
08019     {
08020       msg.id_error = COULD_NOT_READ_UNIX_DEV;
08021       msg.type_msg = T_ERROR_MSG;
08022     }  
08023   close(file);
08024 
08025   (*code_err) = msg.id_error;
08026   return (unsigned int) msg.metric.int32;
08027 }
08028 
08029 /*************************************************************************************************************/
08036 unsigned int
08037 get_is_crypto_nomem(char * dev_name,
08038                     unsigned int * code_err)
08039 {
08040   int file, nb_write, nb_read;
08041   struct qos_metric_net80211_msg msg;
08042 
08043   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
08044   msg.type_msg     = T_QUERY_MSG;
08045   msg.id_error     = NO_ERRORS;
08046   msg.metric_name  = IS_CRYPTO_NOMEM;
08047   msg.metric.int32 = 0; 
08048 
08049   if (dev_name)
08050     strcpy((char *) msg.dev_name, dev_name);
08051   else
08052     msg.dev_name[0] = '\0';   
08053 
08054   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
08055     {
08056       fprintf(stderr, "Can't open: ");
08057       perror(CROSS_LAYER_DEV_NAME_PATH);
08058       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
08059       msg.type_msg = T_ERROR_MSG;
08060     }
08061   nb_write = write(file, &msg, sizeof(msg));
08062   nb_read = read(file, &msg, sizeof(msg));
08063   if (nb_read == 0)
08064     {
08065       msg.id_error = COULD_NOT_READ_UNIX_DEV;
08066       msg.type_msg = T_ERROR_MSG;
08067     }  
08068   close(file);
08069 
08070   (*code_err) = msg.id_error;
08071   return (unsigned int) msg.metric.int32;
08072 }
08073 
08074 /*************************************************************************************************************/
08081 unsigned int
08082 get_is_crypto_tkip(char * dev_name,
08083                    unsigned int * code_err)
08084 {
08085   int file, nb_write, nb_read;
08086   struct qos_metric_net80211_msg msg;
08087 
08088   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
08089   msg.type_msg     = T_QUERY_MSG;
08090   msg.id_error     = NO_ERRORS;
08091   msg.metric_name  = IS_CRYPTO_TKIP;
08092   msg.metric.int32 = 0; 
08093 
08094   if (dev_name)
08095     strcpy((char *) msg.dev_name, dev_name);
08096   else
08097     msg.dev_name[0] = '\0';   
08098 
08099   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
08100     {
08101       fprintf(stderr, "Can't open: ");
08102       perror(CROSS_LAYER_DEV_NAME_PATH);
08103       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
08104       msg.type_msg = T_ERROR_MSG;
08105     }
08106   nb_write = write(file, &msg, sizeof(msg));
08107   nb_read = read(file, &msg, sizeof(msg));
08108   if (nb_read == 0)
08109     {
08110       msg.id_error = COULD_NOT_READ_UNIX_DEV;
08111       msg.type_msg = T_ERROR_MSG;
08112     }  
08113   close(file);
08114 
08115   (*code_err) = msg.id_error;
08116   return (unsigned int) msg.metric.int32;
08117 }
08118 
08119 /*************************************************************************************************************/
08126 unsigned int
08127 get_is_crypto_tkipenmic(char * dev_name,
08128                            unsigned int * code_err)
08129 {
08130   int file, nb_write, nb_read;
08131   struct qos_metric_net80211_msg msg;
08132 
08133   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
08134   msg.type_msg     = T_QUERY_MSG;
08135   msg.id_error     = NO_ERRORS;
08136   msg.metric_name  = IS_CRYPTO_TKIPENMIC;
08137   msg.metric.int32 = 0; 
08138 
08139   if (dev_name)
08140     strcpy((char *) msg.dev_name, dev_name);
08141   else
08142     msg.dev_name[0] = '\0';   
08143 
08144   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
08145     {
08146       fprintf(stderr, "Can't open: ");
08147       perror(CROSS_LAYER_DEV_NAME_PATH);
08148       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
08149       msg.type_msg = T_ERROR_MSG;
08150     }
08151   nb_write = write(file, &msg, sizeof(msg));
08152   nb_read = read(file, &msg, sizeof(msg));
08153   if (nb_read == 0)
08154     {
08155       msg.id_error = COULD_NOT_READ_UNIX_DEV;
08156       msg.type_msg = T_ERROR_MSG;
08157     }  
08158   close(file);
08159 
08160   (*code_err) = msg.id_error;
08161   return (unsigned int) msg.metric.int32;
08162 }
08163 
08164 /*************************************************************************************************************/
08171 unsigned int
08172 get_is_crypto_tkipdemic(char * dev_name,
08173                         unsigned int * code_err)
08174 {
08175   int file, nb_write, nb_read;
08176   struct qos_metric_net80211_msg msg;
08177 
08178   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
08179   msg.type_msg     = T_QUERY_MSG;
08180   msg.id_error     = NO_ERRORS;
08181   msg.metric_name  = IS_CRYPTO_TKIPDEMIC;
08182   msg.metric.int32 = 0; 
08183 
08184   if (dev_name)
08185     strcpy((char *) msg.dev_name, dev_name);
08186   else
08187     msg.dev_name[0] = '\0';   
08188 
08189   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
08190     {
08191       fprintf(stderr, "Can't open: ");
08192       perror(CROSS_LAYER_DEV_NAME_PATH);
08193       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
08194       msg.type_msg = T_ERROR_MSG;
08195     }
08196   nb_write = write(file, &msg, sizeof(msg));
08197   nb_read = read(file, &msg, sizeof(msg));
08198   if (nb_read == 0)
08199     {
08200       msg.id_error = COULD_NOT_READ_UNIX_DEV;
08201       msg.type_msg = T_ERROR_MSG;
08202     }  
08203   close(file);
08204 
08205   (*code_err) = msg.id_error;
08206   return (unsigned int) msg.metric.int32;
08207 }
08208 
08209 /*************************************************************************************************************/
08216 unsigned int
08217 get_is_crypto_tkipcm(char * dev_name,
08218                      unsigned int * code_err)
08219 {
08220   int file, nb_write, nb_read;
08221   struct qos_metric_net80211_msg msg;
08222 
08223   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
08224   msg.type_msg     = T_QUERY_MSG;
08225   msg.id_error     = NO_ERRORS;
08226   msg.metric_name  = IS_CRYPTO_TKIPCM;
08227   msg.metric.int32 = 0; 
08228 
08229   if (dev_name)
08230     strcpy((char *) msg.dev_name, dev_name);
08231   else
08232     msg.dev_name[0] = '\0';   
08233 
08234   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
08235     {
08236       fprintf(stderr, "Can't open: ");
08237       perror(CROSS_LAYER_DEV_NAME_PATH);
08238       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
08239       msg.type_msg = T_ERROR_MSG;
08240     }
08241   nb_write = write(file, &msg, sizeof(msg));
08242   nb_read = read(file, &msg, sizeof(msg));
08243   if (nb_read == 0)
08244     {
08245       msg.id_error = COULD_NOT_READ_UNIX_DEV;
08246       msg.type_msg = T_ERROR_MSG;
08247     }  
08248   close(file);
08249 
08250   (*code_err) = msg.id_error;
08251   return (unsigned int) msg.metric.int32;
08252 }
08253 
08254 /*************************************************************************************************************/
08261 unsigned int
08262 get_is_crypto_ccmp(char * dev_name,
08263                    unsigned int * code_err)
08264 {
08265   int file, nb_write, nb_read;
08266   struct qos_metric_net80211_msg msg;
08267 
08268   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
08269   msg.type_msg     = T_QUERY_MSG;
08270   msg.id_error     = NO_ERRORS;
08271   msg.metric_name  = IS_CRYPTO_CCMP;
08272   msg.metric.int32 = 0; 
08273 
08274   if (dev_name)
08275     strcpy((char *) msg.dev_name, dev_name);
08276   else
08277     msg.dev_name[0] = '\0';   
08278 
08279   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
08280     {
08281       fprintf(stderr, "Can't open: ");
08282       perror(CROSS_LAYER_DEV_NAME_PATH);
08283       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
08284       msg.type_msg = T_ERROR_MSG;
08285     }
08286   nb_write = write(file, &msg, sizeof(msg));
08287   nb_read = read(file, &msg, sizeof(msg));
08288   if (nb_read == 0)
08289     {
08290       msg.id_error = COULD_NOT_READ_UNIX_DEV;
08291       msg.type_msg = T_ERROR_MSG;
08292     }  
08293   close(file);
08294 
08295   (*code_err) = msg.id_error;
08296   return (unsigned int) msg.metric.int32;
08297 }
08298 
08299 /*************************************************************************************************************/
08306 unsigned int
08307 get_is_crypto_wep(char * dev_name,
08308                   unsigned int * code_err)
08309 {
08310   int file, nb_write, nb_read;
08311   struct qos_metric_net80211_msg msg;
08312 
08313   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
08314   msg.type_msg     = T_QUERY_MSG;
08315   msg.id_error     = NO_ERRORS;
08316   msg.metric_name  = IS_CRYPTO_WEP;
08317   msg.metric.int32 = 0; 
08318 
08319   if (dev_name)
08320     strcpy((char *) msg.dev_name, dev_name);
08321   else
08322     msg.dev_name[0] = '\0';   
08323 
08324   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
08325     {
08326       fprintf(stderr, "Can't open: ");
08327       perror(CROSS_LAYER_DEV_NAME_PATH);
08328       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
08329       msg.type_msg = T_ERROR_MSG;
08330     }
08331   nb_write = write(file, &msg, sizeof(msg));
08332   nb_read = read(file, &msg, sizeof(msg));
08333   if (nb_read == 0)
08334     {
08335       msg.id_error = COULD_NOT_READ_UNIX_DEV;
08336       msg.type_msg = T_ERROR_MSG;
08337     }  
08338   close(file);
08339 
08340   (*code_err) = msg.id_error;
08341   return (unsigned int) msg.metric.int32;
08342 }
08343 
08344 /*************************************************************************************************************/
08351 unsigned int
08352 get_is_crypto_setkey_cipher(char * dev_name,
08353                             unsigned int * code_err)
08354 {
08355   int file, nb_write, nb_read;
08356   struct qos_metric_net80211_msg msg;
08357 
08358   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
08359   msg.type_msg     = T_QUERY_MSG;
08360   msg.id_error     = NO_ERRORS;
08361   msg.metric_name  = IS_CRYPTO_SETKEY_CIPHER;
08362   msg.metric.int32 = 0; 
08363 
08364   if (dev_name)
08365     strcpy((char *) msg.dev_name, dev_name);
08366   else
08367     msg.dev_name[0] = '\0';   
08368 
08369   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
08370     {
08371       fprintf(stderr, "Can't open: ");
08372       perror(CROSS_LAYER_DEV_NAME_PATH);
08373       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
08374       msg.type_msg = T_ERROR_MSG;
08375     }
08376   nb_write = write(file, &msg, sizeof(msg));
08377   nb_read = read(file, &msg, sizeof(msg));
08378   if (nb_read == 0)
08379     {
08380       msg.id_error = COULD_NOT_READ_UNIX_DEV;
08381       msg.type_msg = T_ERROR_MSG;
08382     }  
08383   close(file);
08384 
08385   (*code_err) = msg.id_error;
08386   return (unsigned int) msg.metric.int32;
08387 }
08388 
08389 /*************************************************************************************************************/
08396 unsigned int
08397 get_is_crypto_setkey_nokey(char * dev_name,
08398                            unsigned int * code_err)
08399 {
08400   int file, nb_write, nb_read;
08401   struct qos_metric_net80211_msg msg;
08402 
08403   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
08404   msg.type_msg     = T_QUERY_MSG;
08405   msg.id_error     = NO_ERRORS;
08406   msg.metric_name  = IS_CRYPTO_SETKEY_NOKEY;
08407   msg.metric.int32 = 0; 
08408 
08409   if (dev_name)
08410     strcpy((char *) msg.dev_name, dev_name);
08411   else
08412     msg.dev_name[0] = '\0';   
08413 
08414   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
08415     {
08416       fprintf(stderr, "Can't open: ");
08417       perror(CROSS_LAYER_DEV_NAME_PATH);
08418       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
08419       msg.type_msg = T_ERROR_MSG;
08420     }
08421   nb_write = write(file, &msg, sizeof(msg));
08422   nb_read = read(file, &msg, sizeof(msg));
08423   if (nb_read == 0)
08424     {
08425       msg.id_error = COULD_NOT_READ_UNIX_DEV;
08426       msg.type_msg = T_ERROR_MSG;
08427     }  
08428   close(file);
08429 
08430   (*code_err) = msg.id_error;
08431   return (unsigned int) msg.metric.int32;
08432 }
08433 
08434 /*************************************************************************************************************/
08441 unsigned int
08442 get_is_crypto_delkey(char * dev_name,
08443                      unsigned int * code_err)
08444 {
08445   int file, nb_write, nb_read;
08446   struct qos_metric_net80211_msg msg;
08447 
08448   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
08449   msg.type_msg     = T_QUERY_MSG;
08450   msg.id_error     = NO_ERRORS;
08451   msg.metric_name  = IS_CRYPTO_DELKEY;
08452   msg.metric.int32 = 0; 
08453 
08454   if (dev_name)
08455     strcpy((char *) msg.dev_name, dev_name);
08456   else
08457     msg.dev_name[0] = '\0';   
08458 
08459   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
08460     {
08461       fprintf(stderr, "Can't open: ");
08462       perror(CROSS_LAYER_DEV_NAME_PATH);
08463       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
08464       msg.type_msg = T_ERROR_MSG;
08465     }
08466   nb_write = write(file, &msg, sizeof(msg));
08467   nb_read = read(file, &msg, sizeof(msg));
08468   if (nb_read == 0)
08469     {
08470       msg.id_error = COULD_NOT_READ_UNIX_DEV;
08471       msg.type_msg = T_ERROR_MSG;
08472     }  
08473   close(file);
08474 
08475   (*code_err) = msg.id_error;
08476   return (unsigned int) msg.metric.int32;
08477 }
08478 
08479 /*************************************************************************************************************/
08486 unsigned int
08487 get_is_crypto_badcipher(char * dev_name,
08488                         unsigned int * code_err)
08489 {
08490   int file, nb_write, nb_read;
08491   struct qos_metric_net80211_msg msg;
08492 
08493   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
08494   msg.type_msg     = T_QUERY_MSG;
08495   msg.id_error     = NO_ERRORS;
08496   msg.metric_name  = IS_CRYPTO_BADCIPHER;
08497   msg.metric.int32 = 0; 
08498 
08499   if (dev_name)
08500     strcpy((char *) msg.dev_name, dev_name);
08501   else
08502     msg.dev_name[0] = '\0';   
08503 
08504   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
08505     {
08506       fprintf(stderr, "Can't open: ");
08507       perror(CROSS_LAYER_DEV_NAME_PATH);
08508       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
08509       msg.type_msg = T_ERROR_MSG;
08510     }
08511   nb_write = write(file, &msg, sizeof(msg));
08512   nb_read = read(file, &msg, sizeof(msg));
08513   if (nb_read == 0)
08514     {
08515       msg.id_error = COULD_NOT_READ_UNIX_DEV;
08516       msg.type_msg = T_ERROR_MSG;
08517     }  
08518   close(file);
08519 
08520   (*code_err) = msg.id_error;
08521   return (unsigned int) msg.metric.int32;
08522 }
08523 
08524 /*************************************************************************************************************/
08531 unsigned int
08532 get_is_crypto_nocipher(char * dev_name,
08533                        unsigned int * code_err)
08534 {
08535   int file, nb_write, nb_read;
08536   struct qos_metric_net80211_msg msg;
08537 
08538   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
08539   msg.type_msg     = T_QUERY_MSG;
08540   msg.id_error     = NO_ERRORS;
08541   msg.metric_name  = IS_CRYPTO_NOCIPHER;
08542   msg.metric.int32 = 0; 
08543 
08544   if (dev_name)
08545     strcpy((char *) msg.dev_name, dev_name);
08546   else
08547     msg.dev_name[0] = '\0';   
08548 
08549   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
08550     {
08551       fprintf(stderr, "Can't open: ");
08552       perror(CROSS_LAYER_DEV_NAME_PATH);
08553       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
08554       msg.type_msg = T_ERROR_MSG;
08555     }
08556   nb_write = write(file, &msg, sizeof(msg));
08557   nb_read = read(file, &msg, sizeof(msg));
08558   if (nb_read == 0)
08559     {
08560       msg.id_error = COULD_NOT_READ_UNIX_DEV;
08561       msg.type_msg = T_ERROR_MSG;
08562     }  
08563   close(file);
08564 
08565   (*code_err) = msg.id_error;
08566   return (unsigned int) msg.metric.int32;
08567 }
08568 
08569 /*************************************************************************************************************/
08576 unsigned int
08577 get_is_crypto_attachfail(char * dev_name,
08578                          unsigned int * code_err)
08579 {
08580   int file, nb_write, nb_read;
08581   struct qos_metric_net80211_msg msg;
08582 
08583   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
08584   msg.type_msg     = T_QUERY_MSG;
08585   msg.id_error     = NO_ERRORS;
08586   msg.metric_name  = IS_CRYPTO_ATTACHFAIL;
08587   msg.metric.int32 = 0; 
08588   
08589   if (dev_name)
08590     strcpy((char *) msg.dev_name, dev_name);
08591   else
08592     msg.dev_name[0] = '\0';   
08593 
08594   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
08595     {
08596       fprintf(stderr, "Can't open: ");
08597       perror(CROSS_LAYER_DEV_NAME_PATH);
08598       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
08599       msg.type_msg = T_ERROR_MSG;
08600     }
08601   nb_write = write(file, &msg, sizeof(msg));
08602   nb_read = read(file, &msg, sizeof(msg));
08603   if (nb_read == 0)
08604     {
08605       msg.id_error = COULD_NOT_READ_UNIX_DEV;
08606       msg.type_msg = T_ERROR_MSG;
08607     }  
08608   close(file);
08609 
08610   (*code_err) = msg.id_error;
08611   return (unsigned int) msg.metric.int32;
08612 }
08613 
08614 /*************************************************************************************************************/
08621 unsigned int
08622 get_is_crypto_swfallback(char * dev_name,
08623                          unsigned int * code_err)
08624 {
08625   int file, nb_write, nb_read;
08626   struct qos_metric_net80211_msg msg;
08627 
08628   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
08629   msg.type_msg     = T_QUERY_MSG;
08630   msg.id_error     = NO_ERRORS;
08631   msg.metric_name  = IS_CRYPTO_SWFALLBACK;
08632   msg.metric.int32 = 0; 
08633 
08634   if (dev_name)
08635     strcpy((char *) msg.dev_name, dev_name);
08636   else
08637     msg.dev_name[0] = '\0';   
08638 
08639   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
08640     {
08641       fprintf(stderr, "Can't open: ");
08642       perror(CROSS_LAYER_DEV_NAME_PATH);
08643       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
08644       msg.type_msg = T_ERROR_MSG;
08645     }
08646   nb_write = write(file, &msg, sizeof(msg));
08647   nb_read = read(file, &msg, sizeof(msg));
08648   if (nb_read == 0)
08649     {
08650       msg.id_error = COULD_NOT_READ_UNIX_DEV;
08651       msg.type_msg = T_ERROR_MSG;
08652     }  
08653   close(file);
08654 
08655   (*code_err) = msg.id_error;
08656   return (unsigned int) msg.metric.int32;
08657 }
08658 
08659 /*************************************************************************************************************/
08666 unsigned int
08667 get_is_crypto_keyfail(char * dev_name,
08668                       unsigned int * code_err)
08669 {
08670   int file, nb_write, nb_read;
08671   struct qos_metric_net80211_msg msg;
08672 
08673   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
08674   msg.type_msg     = T_QUERY_MSG;
08675   msg.id_error     = NO_ERRORS;
08676   msg.metric_name  = IS_CRYPTO_KEYFAIL;
08677   msg.metric.int32 = 0; 
08678 
08679   if (dev_name)
08680     strcpy((char *) msg.dev_name, dev_name);
08681   else
08682     msg.dev_name[0] = '\0';   
08683 
08684   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
08685     {
08686       fprintf(stderr, "Can't open: ");
08687       perror(CROSS_LAYER_DEV_NAME_PATH);
08688       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
08689       msg.type_msg = T_ERROR_MSG;
08690     }
08691   nb_write = write(file, &msg, sizeof(msg));
08692   nb_read = read(file, &msg, sizeof(msg));
08693   if (nb_read == 0)
08694     {
08695       msg.id_error = COULD_NOT_READ_UNIX_DEV;
08696       msg.type_msg = T_ERROR_MSG;
08697     }  
08698   close(file);
08699 
08700   (*code_err) = msg.id_error;
08701   return (unsigned int) msg.metric.int32;
08702 }
08703 
08704 /*************************************************************************************************************/
08711 unsigned int
08712 get_is_crypto_enmicfail(char * dev_name,
08713                         unsigned int * code_err)
08714 {
08715   int file, nb_write, nb_read;
08716   struct qos_metric_net80211_msg msg;
08717 
08718   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
08719   msg.type_msg     = T_QUERY_MSG;
08720   msg.id_error     = NO_ERRORS;
08721   msg.metric_name  = IS_CRYPTO_ENMICFAIL;
08722   msg.metric.int32 = 0; 
08723 
08724   if (dev_name)
08725     strcpy((char *) msg.dev_name, dev_name);
08726   else
08727     msg.dev_name[0] = '\0';   
08728 
08729   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
08730     {
08731       fprintf(stderr, "Can't open: ");
08732       perror(CROSS_LAYER_DEV_NAME_PATH);
08733       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
08734       msg.type_msg = T_ERROR_MSG;
08735     }
08736   nb_write = write(file, &msg, sizeof(msg));
08737   nb_read = read(file, &msg, sizeof(msg));
08738   if (nb_read == 0)
08739     {
08740       msg.id_error = COULD_NOT_READ_UNIX_DEV;
08741       msg.type_msg = T_ERROR_MSG;
08742     }  
08743   close(file);
08744 
08745   (*code_err) = msg.id_error;
08746   return (unsigned int) msg.metric.int32;
08747 }
08748 
08749 /*************************************************************************************************************/
08756 unsigned int
08757 get_is_ibss_capmismatch(char * dev_name,
08758                         unsigned int * code_err)
08759 {
08760   int file, nb_write, nb_read;
08761   struct qos_metric_net80211_msg msg;
08762 
08763   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
08764   msg.type_msg     = T_QUERY_MSG;
08765   msg.id_error     = NO_ERRORS;
08766   msg.metric_name  = IS_IBSS_CAPMISMATCH;
08767   msg.metric.int32 = 0; 
08768 
08769   if (dev_name)
08770     strcpy((char *) msg.dev_name, dev_name);
08771   else
08772     msg.dev_name[0] = '\0';   
08773 
08774   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
08775     {
08776       fprintf(stderr, "Can't open: ");
08777       perror(CROSS_LAYER_DEV_NAME_PATH);
08778       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
08779       msg.type_msg = T_ERROR_MSG;
08780     }
08781   nb_write = write(file, &msg, sizeof(msg));
08782   nb_read = read(file, &msg, sizeof(msg));
08783   if (nb_read == 0)
08784     {
08785       msg.id_error = COULD_NOT_READ_UNIX_DEV;
08786       msg.type_msg = T_ERROR_MSG;
08787     }  
08788   close(file);
08789 
08790   (*code_err) = msg.id_error;
08791   return (unsigned int) msg.metric.int32;
08792 }
08793 
08794 /*************************************************************************************************************/
08801 unsigned int
08802 get_is_ibss_norate(char * dev_name,
08803                      unsigned int * code_err)
08804 {
08805   int file, nb_write, nb_read;
08806   struct qos_metric_net80211_msg msg;
08807 
08808   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
08809   msg.type_msg     = T_QUERY_MSG;
08810   msg.id_error     = NO_ERRORS;
08811   msg.metric_name  = IS_IBSS_NORATE;
08812   msg.metric.int32 = 0; 
08813 
08814   if (dev_name)
08815     strcpy((char *) msg.dev_name, dev_name);
08816   else
08817     msg.dev_name[0] = '\0';   
08818 
08819   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
08820     {
08821       fprintf(stderr, "Can't open: ");
08822       perror(CROSS_LAYER_DEV_NAME_PATH);
08823       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
08824       msg.type_msg = T_ERROR_MSG;
08825     }
08826   nb_write = write(file, &msg, sizeof(msg));
08827   nb_read = read(file, &msg, sizeof(msg));
08828   if (nb_read == 0)
08829     {
08830       msg.id_error = COULD_NOT_READ_UNIX_DEV;
08831       msg.type_msg = T_ERROR_MSG;
08832     }  
08833   close(file);
08834 
08835   (*code_err) = msg.id_error;
08836   return (unsigned int) msg.metric.int32;
08837 }
08838 
08839 /*************************************************************************************************************/
08846 unsigned int
08847 get_is_ps_unassoc(char * dev_name,
08848                   unsigned int * code_err)
08849 {
08850   int file, nb_write, nb_read;
08851   struct qos_metric_net80211_msg msg;
08852 
08853   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
08854   msg.type_msg     = T_QUERY_MSG;
08855   msg.id_error     = NO_ERRORS;
08856   msg.metric_name  = IS_PS_UNASSOC;
08857   msg.metric.int32 = 0; 
08858 
08859   if (dev_name)
08860     strcpy((char *) msg.dev_name, dev_name);
08861   else
08862     msg.dev_name[0] = '\0';   
08863 
08864   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
08865     {
08866       fprintf(stderr, "Can't open: ");
08867       perror(CROSS_LAYER_DEV_NAME_PATH);
08868       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
08869       msg.type_msg = T_ERROR_MSG;
08870     }
08871   nb_write = write(file, &msg, sizeof(msg));
08872   nb_read = read(file, &msg, sizeof(msg));
08873   if (nb_read == 0)
08874     {
08875       msg.id_error = COULD_NOT_READ_UNIX_DEV;
08876       msg.type_msg = T_ERROR_MSG;
08877     }  
08878   close(file);
08879 
08880   (*code_err) = msg.id_error;
08881   return (unsigned int) msg.metric.int32;
08882 }
08883 
08884 /*************************************************************************************************************/
08891 unsigned int
08892 get_is_ps_badaid(char * dev_name,
08893                  unsigned int * code_err)
08894 {
08895   int file, nb_write, nb_read;
08896   struct qos_metric_net80211_msg msg;
08897 
08898   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
08899   msg.type_msg     = T_QUERY_MSG;
08900   msg.id_error     = NO_ERRORS;
08901   msg.metric_name  = IS_PS_BADAID;
08902   msg.metric.int32 = 0; 
08903 
08904   if (dev_name)
08905     strcpy((char *) msg.dev_name, dev_name);
08906   else
08907     msg.dev_name[0] = '\0';   
08908 
08909   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
08910     {
08911       fprintf(stderr, "Can't open: ");
08912       perror(CROSS_LAYER_DEV_NAME_PATH);
08913       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
08914       msg.type_msg = T_ERROR_MSG;
08915     }
08916   nb_write = write(file, &msg, sizeof(msg));
08917   nb_read = read(file, &msg, sizeof(msg));
08918   if (nb_read == 0)
08919     {
08920       msg.id_error = COULD_NOT_READ_UNIX_DEV;
08921       msg.type_msg = T_ERROR_MSG;
08922     }  
08923   close(file);
08924 
08925   (*code_err) = msg.id_error;
08926   return (unsigned int) msg.metric.int32;
08927 }
08928 
08929 /*************************************************************************************************************/
08936 unsigned int
08937 get_is_ps_qempty(char * dev_name,
08938                  unsigned int * code_err)
08939 {
08940   int file, nb_write, nb_read;
08941   struct qos_metric_net80211_msg msg;
08942 
08943   msg.struct_id    = T_QOS_METRIC_NET80211_MSG;
08944   msg.type_msg     = T_QUERY_MSG;
08945   msg.id_error     = NO_ERRORS;
08946   msg.metric_name  = IS_PS_QEMPTY;
08947   msg.metric.int32 = 0; 
08948 
08949   if (dev_name)
08950     strcpy((char *) msg.dev_name, dev_name);
08951   else
08952     msg.dev_name[0] = '\0';   
08953 
08954   if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
08955     {
08956       fprintf(stderr, "Can't open: ");
08957       perror(CROSS_LAYER_DEV_NAME_PATH);
08958       msg.id_error = COULD_NOT_OPEN_UNIX_DEV;
08959       msg.type_msg = T_ERROR_MSG;
08960     }
08961   nb_write = write(file, &msg, sizeof(msg));
08962   nb_read = read(file, &msg, sizeof(msg));
08963   if (nb_read == 0)
08964     {
08965       msg.id_error = COULD_NOT_READ_UNIX_DEV;
08966       msg.type_msg = T_ERROR_MSG;
08967     }  
08968   close(file);
08969 
08970   (*code_err) = msg.id_error;
08971   return (unsigned int) msg.metric.int32;
08972 }
08973 
08974 /*****************************************************************************************************
08975  *  Main for test
08976  ****************************************************************************************************/
08977 /*
08978 int
08979 main(int argc, char * argv[])
08980 {
08981   unsigned char metric_8;
08982   unsigned int  metric_32;
08983   unsigned long long metric_64;
08984 
08985   unsigned int  code_err;
08986   //  char macaddr[IEEE80211_MAC_ADDR_LEN] = "00:20:ED:0C:76:D2";
08987   //  char macaddr[IEEE80211_MAC_ADDR_LEN] = { '0', '0', ... , '2' };
08988   char * macaddr = argv[1];
08989   char dev_name[IFNAMESIZ] = "ath0";
08990 
08991   metric_32 = get_node_rx_data(macaddr,dev_name,&code_err);
08992   printf("========> Id error = %u\n",code_err);
08993   printf("========> La metric RX DATA = %u\n",metric_32);
08994 
08995   metric_32 = get_node_rx_mgmt(macaddr,dev_name,&code_err);
08996   printf("========> Id error = %u\n",code_err);
08997   printf("========> La metric RX MGMT = %u\n",metric_32);
08998 
08999   metric_32 = get_node_rx_ctrl(macaddr,dev_name,&code_err);
09000   printf("========> Id error = %u\n",code_err);
09001   printf("========> La metric RX CTRL = %u\n",metric_32);
09002   
09003   metric_32 = get_node_rx_ucast(macaddr,dev_name,&code_err);
09004   printf("========> Id error = %u\n",code_err);
09005   printf("========> La metric RX UCAST = %u\n",metric_32);
09006   
09007   metric_32 = get_node_rx_mcast(macaddr,dev_name,&code_err);
09008   printf("========> Id error = %u\n",code_err);
09009   printf("========> La metric RX MCAST = %u\n",metric_32);
09010   
09011   metric_64 = get_node_rx_bytes(macaddr,dev_name,&code_err);
09012   printf("========> Id error = %u\n",code_err);
09013   printf("========> La metric RX BYTES = %u\n",metric_64);
09014 
09015   metric_64 = get_node_rx_beacons(macaddr,dev_name,&code_err);
09016   printf("========> Id error = %u\n",code_err);
09017   printf("========> La metric RX BEACONS = %u\n",metric_64);  
09018 
09019   metric_32 = get_node_rx_proberesp(macaddr,dev_name,&code_err);
09020   printf("========> Id error = %u\n",code_err);
09021   printf("========> La metric RX PROBERESP = %u\n",metric_32);
09022   
09023   metric_32 = get_node_rx_dup(macaddr,dev_name,&code_err);
09024   printf("========> Id error = %u\n",code_err);
09025   printf("========> La metric RX DUP = %u\n",metric_32);
09026 
09027   metric_32 = get_node_rx_noprivacy(macaddr,dev_name,&code_err);
09028   printf("========> Id error = %u\n",code_err);
09029   printf("========> La metric RX NOPRIVACY = %u\n",metric_32);
09030 
09031   metric_32 = get_node_rx_wepfail(macaddr,dev_name,&code_err);
09032   printf("========> Id error = %u\n",code_err);
09033   printf("========> La metric RX WEPFAIL = %u\n",metric_32);
09034 
09035   metric_32 = get_node_rx_demicfail(macaddr,dev_name,&code_err);
09036   printf("========> Id error = %u\n",code_err);
09037   printf("========> La metric RX DEMICFAIL = %u\n",metric_32);
09038 
09039   metric_32 = get_node_rx_decap(macaddr,dev_name,&code_err);
09040   printf("========> Id error = %u\n",code_err);
09041   printf("========> La metric RX DECAP = %u\n",metric_32);
09042 
09043   metric_32 = get_node_rx_defrag(macaddr,dev_name,&code_err);
09044   printf("========> Id error = %u\n",code_err);
09045   printf("========> La metric RX DEFRAG = %u\n",metric_32);
09046 
09047   metric_32 = get_node_rx_disassoc(macaddr,dev_name,&code_err);
09048   printf("========> Id error = %u\n",code_err);
09049   printf("========> La metric RX DISASSOC = %u\n",metric_32);
09050 
09051   metric_32 = get_node_rx_deauth(macaddr,dev_name,&code_err);
09052   printf("========> Id error = %u\n",code_err);
09053   printf("========> La metric RX DEAUTH = %u\n",metric_32);
09054 
09055   metric_32 = get_node_rx_decryptcrc(macaddr,dev_name,&code_err);
09056   printf("========> Id error = %u\n",code_err);
09057   printf("========> La metric RX DECRYPTCRC = %u\n",metric_32);
09058 
09059   metric_32 = get_node_rx_unauth(macaddr,dev_name,&code_err);
09060   printf("========> Id error = %u\n",code_err);
09061   printf("========> La metric RX UNAUTH = %u\n",metric_32);
09062 
09063   metric_32 = get_node_rx_unencrypted(macaddr,dev_name,&code_err);
09064   printf("========> Id error = %u\n",code_err);
09065   printf("========> La metric RX UNENCRYPTED = %u\n",metric_32);
09066 
09067   metric_32 = get_node_tx_data(macaddr,dev_name,&code_err);
09068   printf("========> Id error = %u\n",code_err);
09069   printf("========> La metric TX DATA = %u\n",metric_32);
09070 
09071   metric_32 = get_node_tx_mgmt(macaddr,dev_name,&code_err);
09072   printf("========> Id error = %u\n",code_err);
09073   printf("========> La metric TX MGMT = %u\n",metric_32);
09074 
09075   metric_32 = get_node_tx_ucast(macaddr,dev_name,&code_err);
09076   printf("========> Id error = %u\n",code_err);
09077   printf("========> La metric TX UCAST = %u\n",metric_32);
09078 
09079   metric_32 = get_node_tx_data(macaddr,dev_name,&code_err);
09080   printf("========> Id error = %u\n",code_err);
09081   printf("========> La metric TX MCAST = %u\n",metric_32);
09082 
09083   metric_64 = get_node_tx_bytes(macaddr,dev_name,&code_err);
09084   printf("========> Id error = %u\n",code_err);
09085   printf("========> La metric TX BYTES = %u\n",metric_64);
09086 
09087   metric_32 = get_node_tx_probereq(macaddr,dev_name,&code_err);
09088   printf("========> Id error = %u\n",code_err);
09089   printf("========> La metric TX PROBEREQ = %u\n",metric_32);
09090 
09091   metric_32 = get_node_tx_novlantag(macaddr,dev_name,&code_err);
09092   printf("========> Id error = %u\n",code_err);
09093   printf("========> La metric TX NOVLANTAG = %u\n",metric_32);
09094 
09095   metric_32 = get_node_tx_vlanmismatch(macaddr,dev_name,&code_err);
09096   printf("========> Id error = %u\n",code_err);
09097   printf("========> La metric TX VLANMISMATCH = %u\n",metric_32);
09098 
09099   metric_32 = get_node_ps_discard(macaddr,dev_name,&code_err);
09100   printf("========> Id error = %u\n",code_err);
09101   printf("========> La metric PS DISCARD = %u\n",metric_32);
09102 
09103   metric_32 = get_node_tx_assoc(macaddr,dev_name,&code_err);
09104   printf("========> Id error = %u\n",code_err);
09105   printf("========> La metric TX ASSOC = %u\n",metric_32);
09106 
09107   metric_32 = get_node_tx_assoc_fail(macaddr,dev_name,&code_err);
09108   printf("========> Id error = %u\n",code_err);
09109   printf("========> La metric TX ASSOC FAIL = %u\n",metric_32);
09110 
09111   metric_32 = get_node_tx_auth(macaddr,dev_name,&code_err);
09112   printf("========> Id error = %u\n",code_err);
09113   printf("========> La metric TX AUTH = %u\n",metric_32);
09114 
09115   metric_32 = get_node_tx_auth_fail(macaddr,dev_name,&code_err);
09116   printf("========> Id error = %u\n",code_err);
09117   printf("========> La metric TX AUTH FAIL = %u\n",metric_32);
09118 
09119   metric_32 = get_node_tx_deauth(macaddr,dev_name,&code_err);
09120   printf("========> Id error = %u\n",code_err);
09121   printf("========> La metric TX DEAUTH = %u\n",metric_32);
09122 
09123   metric_32 = get_node_tx_deauth_code(macaddr,dev_name,&code_err);
09124   printf("========> Id error = %u\n",code_err);
09125   printf("========> La metric TX DEAUTH CODE = %u\n",metric_32);
09126 
09127   metric_32 = get_node_tx_disassoc(macaddr,dev_name,&code_err);
09128   printf("========> Id error = %u\n",code_err);
09129   printf("========> La metric TX DISASSOC = %u\n",metric_32);
09130 
09131   metric_32 = get_node_tx_disassoc_code(macaddr,dev_name,&code_err);
09132   printf("========> Id error = %u\n",code_err);
09133   printf("========> La metric TX DISASSOC CODE = %u\n",metric_32);
09134 
09135 
09136   metric_8 = get_node_txpower(macaddr,dev_name,&code_err);
09137   printf("========> Id error = %u\n",code_err);
09138   printf("========> La metric TXPOWER = %u\n",metric_8);
09139 
09140   metric_8 = get_node_negotiated_rate(macaddr,dev_name,&code_err);
09141   printf("========> Id error = %u\n",code_err);
09142   printf("========> La metric NEGOTIATED RATE = %u\n",metric_8);
09143 
09144   metric_8 = get_node_rssi(macaddr,dev_name,&code_err);
09145   printf("========> Id error = %u\n",code_err);
09146   printf("========> La metric RSSI = %u\n",metric_8);
09147   
09148   
09149   
09150 
09151 
09152   
09153   // int file, nb_write, nb_read;
09154   //char buff[BUF_LEN];
09155 
09156   //struct qos_metric_node_msg * msg1, *msg2;
09157   
09158   //msg1->struct_id = T_QOS_METRIC_NODE_MSG;
09159   //msg1->type_msg  = T_QUERY_MSG;
09160   //strcpy(msg1->dev_name,"ath0");
09161   // msg->macaddr   = netdev->dev_addr;
09162   //msg1->metric_name = NODE_TXPOWER; 
09163 
09164   //msg2->struct_id = T_QOS_METRIC_NODE_MSG;
09165   //msg2->type_msg  = T_QUERY_MSG;
09166   //strcpy(msg2->dev_name,"ath0");
09167   // msg->macaddr   = netdev->dev_addr;
09168   //msg2->metric_name = NODE_RSSI;
09169 
09170   
09171   //if ((file = open(CROSS_LAYER_DEV_NAME_PATH, O_RDWR)) < 0)
09172   //{
09173   //  fprintf(stderr, "Can't open: ");
09174   //  perror(CROSS_LAYER_DEV_NAME_PATH);
09175   //  return -1;
09176   //}
09177   
09178   //nb_write = write(file, msg1, sizeof(*msg1));
09179   //nb_read = read(file, msg1, sizeof(*msg1));
09180   
09181   //printf ("Nb de caracteres �crit = %d\n", nb_write);
09182   //printf ("Nb de caracteres lu = %d\n", nb_read);
09183   //printf ("La m�trique TX_POWER %d vaut %d\n",msg1->metric_name, msg1->metric.int8);
09184 
09185 
09186   //nb_write = write(file, msg2, sizeof(*msg2));
09187   //nb_read = read(file, msg2, sizeof(*msg2));
09188   
09189   //printf ("Nb de caracteres �crit = %d\n", nb_write);
09190   //printf ("Nb de caracteres lu = %d\n", nb_read);
09191   //printf ("La m�trique RSSI %d vaut %d\n",msg2->metric_name, msg2->metric.int8);
09192 
09193   //close(file);
09194   return 0;
09195 }
09196 */