/home/tai/chorist/xian-1.2/src/include/xian_proto.h

Go to the documentation of this file.

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

#include <linux/init.h>
#include <linux/module.h>
#include <linux/time.h>

#include <linux/netdevice.h>   /* struct device, and other headers */
#include <linux/version.h>
#include "itm.h"
#include "errors.h"

#define XIAN_NANO_PROTOCOL_VERSION 1
#define XIAN_NANO_PROTOCOL 1
#define XIAN_HEADER_SIZE 12
#define METRIC_MSG_LEN sizeof(struct metric_msg)
#define NB_METRICS 10 //itm.h

#define NB_MAX_INDEX 5

#define ETH_ALEN 6
#define HEADER_SIZE 14

#define HH_DATA_MOD     16
#define LL_RESERVED_SPACE(dev) \
        (((dev)->hard_header_len&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
#define XIAN_EXPORT_SYMBOL(x) EXPORT_SYMBOL_NOVERS(x)
#else
#define XIAN_EXPORT_SYMBOL(x) EXPORT_SYMBOL(x)
#endif

struct metric_msg {
  unsigned int type; 
  unsigned int id;
  unsigned int encoding_type;//not used at this time
  unsigned char mac[ETH_ALEN];
  struct xian_float value;
};

struct xian_msg {
  unsigned short version;
  unsigned int id;
  unsigned int length;
  struct metric_msg msg[NB_METRICS];
};

struct metric_conf{
  unsigned int index;
  char dev_name[IFNAMESIZ+1];
  char macadd[IEEE80211_MAC_ADDR_LEN+1];
  unsigned int nb;
  unsigned int frequency;
  unsigned int id[NB_METRICS];
  unsigned int metrics[NB_METRICS];//warning : total < NB_METRICS
  struct xian_float value[NB_METRICS];
  void (*function[NB_METRICS])(unsigned char *saddr, struct metric_msg *metric);
};


struct xian_stat{
  struct xian_stat *next_stat;
  unsigned char saddr[ETH_ALEN];//@MAC source
  struct xian_float value;//value
};

struct xian_stats{
  unsigned int id_conf;//id_metrique
  struct xian_stats *next_stats;
  struct xian_stat *stat;
};

struct neighbour_table  // structure constituée en local grâce aux infos du driver mad wifi.
{
  char macaddr[IEEE80211_MAC_ADDR_LEN+1];
  long  timestamp;
  struct neighbour_table * next;
};

extern void xian_if_send(char *dev_name, void *daddr, void *saddr, struct qos_metric_proto_msg message);
extern void xian_netif_rx(struct sk_buff *skb);

extern void kinsert_metric(struct qos_metric_proto_msg *msg, unsigned int type, unsigned int id, unsigned int encoding_type, unsigned char mac[ETH_ALEN], struct xian_float value);
extern void ksend_metric(char *dev_name, char *macadd, struct qos_metric_proto_msg msg, unsigned int *code_err);

extern void insert_mac_to_broadcast(unsigned char *saddr);
extern void delete_mac_to_broadcast(unsigned char *saddr);
extern void free_mac_to_broadcast(void);
extern void register_id(unsigned int id, unsigned int metric, char dev[IFNAMESIZ+1], char mac[IEEE80211_MAC_ADDR_LEN+1], unsigned int freq, void *pf);
extern void register_id_no_report(unsigned int id, unsigned int metric, char dev[IFNAMESIZ+1], char mac[IEEE80211_MAC_ADDR_LEN+1], void *pf);
extern void unregister_id(unsigned int id, unsigned int metric);

void config_relay(void *pf);
int XIAN_Manager_receive(unsigned char *saddr, struct xian_msg *stat);

struct xian_float get_xian_stat(unsigned char macadd[IEEE80211_MAC_ADDR_LEN+1], unsigned char dev_name[IFNAMESIZ+1], unsigned int id_conf, unsigned int *code_err);
void update_xian_stat(unsigned char saddr[IEEE80211_MAC_ADDR_LEN+1], unsigned char dev_name[IFNAMESIZ+1], unsigned int id_conf, struct xian_float value);
void del_xian_stat(unsigned char dev_name[IFNAMESIZ+1], unsigned int id_conf);

struct xian_float xian_float_add(struct xian_float a, struct xian_float b);
struct xian_float xian_float_mult(struct xian_float a, struct xian_float b);
struct xian_float xian_float_div(struct xian_float a, struct xian_float b);
int xian_float_cmp(struct xian_float a, struct xian_float b);
struct xian_float int2xian_float(unsigned int x);

struct xian_neighbour* xian_get_neighbour(char *a );
void xian_print_neighbour(char *a);


#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
static inline unsigned int jiffies_to_msecs(const unsigned long j)
{
#if HZ <= 1000 && !(1000%HZ)
return(1000/HZ)*j;
#elif HZ > 1000 && !(HZ%1000)
return (j + (HZ/1000)-1)/(HZ/1000);
#else
return (j*1000)/HZ;
#endif
}
#endif

/**************************************************************************************************************************************/
int
is_hexa (char c)
{
  return ((c == '0') || 
          (c == '1') || 
          (c == '2') || 
          (c == '3') || 
          (c == '4') || 
          (c == '5') || 
          (c == '6') || 
          (c == '7') || 
          (c == '8') || 
          (c == '9') || 
          (c == 'A') || 
          (c == 'a') ||
          (c == 'B') ||
          (c == 'b') ||
          (c == 'C') ||
          (c == 'c') ||
          (c == 'D') ||
          (c == 'd') ||
          (c == 'E') ||
          (c == 'e') ||
          (c == 'F') ||
          (c == 'f'));
}


/**************************************************************************************************************************************/
int
is_mac_addr_valid (char * mac_addr)
{
  if (mac_addr) {
    if (strlen (mac_addr) == ((IEEE80211_MAC_ADDR_LEN)))
      return (is_hexa(mac_addr[0]) && 
              is_hexa(mac_addr[1]) && 
              (mac_addr[2] == ':') && 
              is_hexa(mac_addr[3]) &&
              is_hexa(mac_addr[4]) &&
              (mac_addr[5] == ':') &&
              is_hexa(mac_addr[6]) &&
              is_hexa(mac_addr[7]) &&
              (mac_addr[8] == ':') &&
              is_hexa(mac_addr[9]) &&
              is_hexa(mac_addr[10]) &&
              (mac_addr[11] == ':') &&
              is_hexa(mac_addr[12]) &&
              is_hexa(mac_addr[13]) &&
              (mac_addr[14] == ':') &&
              is_hexa(mac_addr[15]) &&
              is_hexa(mac_addr[16])
              );  
  }
  return 0;
}


/**************************************************************************************************************************************/
void
convert_mac_addr (char * mac_addr, unsigned char * res, unsigned int * code_err)
{
  char s[2];
  if (is_mac_addr_valid(mac_addr))
  {
    int i, y;
    y = 0;
    for (i=0;i<IEEE80211_MAC_ADDR_LEN;i = i+3)
    {
      s[0] = mac_addr[i];
      s[1] = mac_addr[i+1];
      res[y] = simple_strtoul (s, NULL, 16);
      //printk("address mac fields %d ====> %x\n", y, res[y]);
      y++;
    }
    return;
  }  
  (*code_err) = INVALID_MAC_ADDR;
  return;
}

/**************************************************************************************************************************************/
unsigned char hex2char(unsigned char input){
  char c;
  if(input==0x0){c='0';}
  if(input==0x1){c='1';}
  if(input==0x2){c='2';}
  if(input==0x3){c='3';}
  if(input==0x4){c='4';}
  if(input==0x5){c='5';}
  if(input==0x6){c='6';}
  if(input==0x7){c='7';}
  if(input==0x8){c='8';}
  if(input==0x9){c='9';}
  if(input==0xa){c='a';}
  if(input==0xb){c='b';}
  if(input==0xc){c='c';}
  if(input==0xd){c='d';}
  if(input==0xe){c='e';}
  if(input==0xf){c='f';}
  return c;
}

/**************************************************************************************************************************************/
void convert_hexamac(unsigned char * saddr, unsigned char * res){
  int i,j;
  for (i=0 ; i<ETH_ALEN-1; i++){
    j=3*i;
    res[j]=hex2char((saddr[i]&0xf0)>>4);
    res[j+1]=hex2char((saddr[i]&0xf));
    res[j+2]=':';
  }
  j=ETH_ALEN-1;
  res[j*3]=hex2char((saddr[j]&0xf0)>>4);
  res[j*3+1]=hex2char((saddr[j]&0xf));
  res[j*3+2]='\0';
 return;
}

/**************************************************************************************************************************************/
int strcmp_mac(unsigned char mac[6], unsigned char mac_addr_converted[6]){
  int i;
  for(i=0; i<6; i++){
    if(mac[i]!=mac_addr_converted[i]){
      return 1;
    }
  }
  return 0;
}

---