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

Go to the documentation of this file.

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

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

MODULE_DESCRIPTION("XIAN - Module XNP:  XIAN Nano-Protocol Handler");
MODULE_LICENSE("GPL");

void (*XIAN_Manager_relay)(unsigned char *saddr, struct xian_msg * stat);

/***********************************************************************************/
void config_relay(void *pf){
  if(pf!=NULL){
    printk(KERN_ALERT "XNP's relaying configured by XMM\n");
  }
  XIAN_Manager_relay=pf;
}
XIAN_EXPORT_SYMBOL(config_relay);

int xian_handler_init(void)
{
  printk(KERN_ALERT "Init XIAN XNP (XIAN Nano-Protocol Handler module)\n");
  XIAN_Manager_relay=NULL;
  return 0;
}

void xian_handler_exit(void)
{
  printk(KERN_ALERT "Unload XIAN XNP (XIAN Nano-Protocol Handler)\n");
}

module_init(xian_handler_init);
module_exit(xian_handler_exit);

/***********************************************************************************/
void recv_msg(unsigned char *saddr, struct xian_msg *stat){
  int i;
  if(0){// !=0 to see input
    printk(KERN_ALERT "[XNP] INPUT");
    printk(" version=%u", stat->version);
    printk(" id=%u", stat->id);  
    printk(" length=%u\n", stat->length);  
    for(i=0; i<stat->length; i++){ 
      printk("[%d]", i);
      printk(" type=%u", stat->msg[i].type);
      printk(" id=%u", stat->msg[i].id);
      printk(" value=%llu/%llu\n", stat->msg[i].value.numerator, stat->msg[i].value.denominator);
    }
    printk("\n");
  }
  if(XIAN_Manager_relay!=NULL){//XIAN  Metric Manager present
    (*XIAN_Manager_relay)(saddr, stat);//relaying
  }
}
/***********************************************************************************/
extern void xian_netif_rx(struct sk_buff *skb){
  struct xian_msg *stat;
  struct ethhdr *eth;
  unsigned char *saddr;
    
  /*char *data;
  int len;
  int i;
  data = skb->data;
  len = skb->len;
  printk("INPUT");
  for (i=0 ; i<len; i++){
    printk(" %02x", data[i]&0xff);//affichage
  }
  printk("\n");*/
  if(skb->protocol==1024){//Warning XIAN_NANO_PROTOCOL 1 => 1024
    eth=(struct ethhdr *)skb->mac.raw;
    saddr=kmalloc(ETH_ALEN, GFP_ATOMIC);
    memcpy(saddr, eth->h_source, ETH_ALEN);

    stat=(struct xian_msg *)(skb->data);
    recv_msg(saddr, stat);
  }else{
    netif_rx(skb);//relaying to the upper layer
  }
}
XIAN_EXPORT_SYMBOL(xian_netif_rx);


/****************************************************************************************************************************************
 * SEND FUNCTIONS
 ***************************************************************************************************************************************/

/**************************************************************************************************************************************/
int hard_header(struct sk_buff *skb, struct net_device *dev,
                unsigned short type, void *daddr, void *saddr,
                unsigned int len)
{
        struct ethhdr *eth = (struct ethhdr *)skb_push(skb,ETH_HLEN);

        eth->h_proto = __constant_htons(type);
        memcpy(eth->h_source, saddr ? saddr : dev->dev_addr, dev->addr_len);
        memcpy(eth->h_dest,   daddr ? daddr : dev->dev_addr, dev->addr_len);
        return (dev->hard_header_len);
}
 
unsigned int incrementer(void){
  static unsigned int inc=0;
  if(inc>65530){
    inc=0;
  }
  return inc++;
}

/**************************************************************************************************************************************/
extern void xian_if_send(char *dev_name, void *daddr, void *saddr, struct qos_metric_proto_msg message){
  int i;
  struct sk_buff *skb;
  struct net_device *xian_if;
  struct xian_msg *stat;
  stat=kmalloc(sizeof(struct xian_msg),GFP_KERNEL);
  skb = dev_alloc_skb(HEADER_SIZE+XIAN_HEADER_SIZE+METRIC_MSG_LEN*message.nb);
  if(!skb){
    printk("[XNP] dev_alloc_skb() No Memory");
  }
  xian_if = dev_get_by_name(dev_name);
  skb_reserve(skb, LL_RESERVED_SPACE(xian_if));//alignement
  //skb->input_dev=xian_if; // not in 2.4 kernel version
  skb->dev=xian_if;
  
  skb->data=skb_put(skb, XIAN_HEADER_SIZE+METRIC_MSG_LEN*message.nb);

  stat=(struct xian_msg *)skb->data;
  memset(stat, 0, XIAN_HEADER_SIZE+METRIC_MSG_LEN*message.nb);

  stat->version=XIAN_NANO_PROTOCOL_VERSION;
  stat->id=incrementer();
 
  stat->length=message.nb;
  for(i=0; i<message.nb; i++){
    stat->msg[i].type=message.metric_name[i];
    stat->msg[i].id=message.id[i];
    stat->msg[i].encoding_type=message.encoding_type[i];
    memcpy(stat->msg[i].mac,message.mac[i],ETH_ALEN);
    stat->msg[i].value=message.metric[i].value;
  }

  hard_header(skb, xian_if, XIAN_NANO_PROTOCOL, daddr, saddr, 0);
  //skb->len;
  //skb->data_len;
  
  skb->pkt_type=PACKET_HOST;

  if(0){// !=0 to see output
    printk(KERN_ALERT "OUTPUT");
    for (i=0 ; i<skb->len; i++){
      printk(" %02x",skb->data[i]&0xff);//affichage
    }
    printk("\n");
  }

  dev_queue_xmit(skb);//transmit
  dev_put(xian_if);//release device
}
XIAN_EXPORT_SYMBOL(xian_if_send);

/**************************************************************************************************************************************/
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){
  //int i;
  int nb;
  nb=msg->nb;
  if(nb<NB_METRICS){
    msg->metric_name[nb]=type;
    msg->id[nb]=id; 
    msg->encoding_type[nb]=encoding_type;
    memcpy(msg->mac[nb],mac,ETH_ALEN);
    /*printk(KERN_ALERT "[XIAN Nano-Protocol Handler] KINSERT mac inserted=");
    for (i=0 ; i<ETH_ALEN; i++){
      printk("%02x", mac[i]&0xff);//affichage
    }
    printk(" mac recorded=");
    for (i=0 ; i<ETH_ALEN; i++){
      printk("%02x", msg->mac[nb][i]&0xff);//affichage
    }
    printk("\n");*/
    msg->metric[nb].value=value;
    msg->nb=nb+1;
    if(msg->nb>NB_METRICS){
       msg->nb=NB_METRICS;
    }
  }
}
XIAN_EXPORT_SYMBOL(kinsert_metric);

/**************************************************************************************************************************************/
void ksend_metric(char * dev_name, char * macadd, struct qos_metric_proto_msg msg, unsigned int * code_err){
  unsigned char mac_addr_converted[ETH_ALEN];
  convert_mac_addr(macadd, mac_addr_converted, &(msg.id_error));
  xian_if_send(dev_name, mac_addr_converted, NULL, msg);//xian_if
}
XIAN_EXPORT_SYMBOL(ksend_metric);

---