maki/openairinterface5g
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
286c092cfc33dca717acbe2722ce0c0497268a4e
openairinterface5g/openair2/NAS/DRIVER/MESH/tool.c
T
Lionel Gauthier c60dc45b2b Changed uX, uX_t sX, sX_t to uinX_t 
Cleaned some PDCP/driver code

types parameters and vars

Please see openair2/COMMON/platform_types.h for simple coding rules.

please declare prototypes of functions in .h and include .h files in where the function is used and where it is implemented.



git-svn-id: http://svn.eurecom.fr/openair4G/trunk@5096 818b1a75-f10b-46b9-bf7c-635c3b92a50f
2014-02-28 13:03:10 +00:00

745 lines
22 KiB
C
Executable File
Raw Blame History

/*******************************************************************************
Eurecom OpenAirInterface 2
Copyright(c) 1999 - 2010 Eurecom
This program is free software; you can redistribute it and/or modify it
under the terms and conditions of the GNU General Public License,
version 2, as published by the Free Software Foundation.
This program is distributed in the hope 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
this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
The full GNU General Public License is included in this distribution in
the file called "COPYING".
Contact Information
Openair Admin: openair_admin@eurecom.fr
Openair Tech : openair_tech@eurecom.fr
Forums : http://forums.eurecom.fsr/openairinterface
Address : Eurecom, 2229, route des crêtes, 06560 Valbonne Sophia Antipolis, France
*******************************************************************************/
#include "local.h"
#include "proto_extern.h"
//#include <linux/in.h>
//#include <net/ndisc.h>
//#include <linux/icmpv6.h>
//#include <linux/icmp.h>
//#include <linux/udp.h>
//#include <linux/tcp.h>
//#define KERNEL_VERSION_GREATER_THAN_2622 1
//#define KERNEL_VERSION_GREATER_THAN_2630 1
//#define NAS_DEBUG_TOOL 1
//---------------------------------------------------------------------------
//
void nas_TOOL_fct(struct classifier_entity *gc, uint8_t fct){
//---------------------------------------------------------------------------
// Start debug information
#ifdef NAS_DEBUG_TOOL
printk("NAS_TOOL_FCT - begin \n");
#endif
if (gc==NULL){
#ifdef NAS_DEBUG_TOOL
printk("NAS_TOOL_FCT - input parameter gc is NULL \n");
#endif
return;
}
// End debug information
switch(fct){
case NAS_FCT_QOS_SEND:
gc->fct=nas_COMMON_QOS_send;
break;
case NAS_FCT_CTL_SEND:
gc->fct=nas_CTL_send;
break;
case NAS_FCT_DC_SEND:
gc->fct=nas_mesh_DC_send_sig_data_request;
break;
case NAS_FCT_DEL_SEND:
gc->fct=nas_COMMON_del_send;
break;
default:
gc->fct=nas_COMMON_del_send;
}
}
//---------------------------------------------------------------------------
uint8_t nas_TOOL_invfct(struct classifier_entity *gc){
//---------------------------------------------------------------------------
// Start debug information
#ifdef NAS_DEBUG_TOOL
printk("NAS_TOOL_INVFCT - begin \n");
#endif
if (gc==NULL){
#ifdef NAS_DEBUG_TOOL
printk("NAS_TOOL_INVFCT - input parameter gc is NULL \n");
#endif
return 0;
}
// End debug information
if (gc->fct==nas_COMMON_QOS_send)
return NAS_FCT_QOS_SEND;
if (gc->fct==nas_CTL_send)
return NAS_FCT_CTL_SEND;
if (gc->fct==nas_COMMON_del_send)
return NAS_FCT_DEL_SEND;
if (gc->fct==nas_mesh_DC_send_sig_data_request)
return NAS_FCT_DC_SEND;
return 0;
}
//---------------------------------------------------------------------------
uint8_t nas_TOOL_get_dscp6(struct ipv6hdr *iph){
//---------------------------------------------------------------------------
// Start debug information
#ifdef NAS_DEBUG_TOOL
printk("NAS_TOOL_GET_DSCP6 - begin \n");
#endif
if (iph==NULL){
#ifdef NAS_DEBUG_TOOL
printk("NAS_TOOL_GET_DSCP6 - input parameter iph is NULL \n");
#endif
return 0;
}
// End debug information
return (ntohl(((*(__u32 *)iph)&NAS_TRAFFICCLASS_MASK)))>>22;
//return ntohs(*(const __be16 *)iph) >> 4; // see linux/dsfield.h
}
//---------------------------------------------------------------------------
uint8_t nas_TOOL_get_dscp4(struct iphdr *iph){
//---------------------------------------------------------------------------
// Start debug information
#ifdef NAS_DEBUG_TOOL
printk("NAS_TOOL_GET_DSCP4 - begin \n");
#endif
if (iph==NULL){
#ifdef NAS_DEBUG_TOOL
printk("NAS_TOOL_GET_DSCP4 - input parameter iph is NULL \n");
#endif
return 0;
}
// End debug information
return (iph->tos);
}
//---------------------------------------------------------------------------
int nas_TOOL_network6(struct in6_addr *addr, struct in6_addr *prefix, uint8_t plen){
//---------------------------------------------------------------------------
// Start debug information
#ifdef NAS_DEBUG_TOOL
printk("NAS_TOOL_NETWORK6 - begin \n");
#endif
if (addr==NULL){
#ifdef NAS_DEBUG_TOOL
printk("NAS_TOOL_NETWORK6 - input parameter addr is NULL \n");
#endif
return 0;
}
if (prefix==NULL){
#ifdef NAS_DEBUG_TOOL
printk("NAS_TOOL_NETWORK6 - input parameter prefix is NULL \n");
#endif
return 0;
}
// End debug information
switch(plen/32)
{
case 0:
return (((addr->s6_addr32[0]>>(32-plen))<<(32-plen))==prefix->s6_addr[0]);
case 1:
return ((addr->s6_addr32[0]==prefix->s6_addr[0])&&
(((addr->s6_addr32[1]>>(64-plen))<<(64-plen))==prefix->s6_addr[1]));
case 2:
return ((addr->s6_addr32[0]==prefix->s6_addr[0])&&
(addr->s6_addr32[1]==prefix->s6_addr[1])&&
(((addr->s6_addr32[2]>>(96-plen))<<(96-plen))==prefix->s6_addr[2]));
case 3:
return ((addr->s6_addr32[0]==prefix->s6_addr[0])&&
(addr->s6_addr32[1]==prefix->s6_addr[1])&&
(addr->s6_addr32[2]==prefix->s6_addr[2])&&
(((addr->s6_addr32[3]>>(128-plen))<<(128-plen))==prefix->s6_addr[3]));
default:
return ((addr->s6_addr32[0]==prefix->s6_addr[0])&&
(addr->s6_addr32[1]==prefix->s6_addr[1])&&
(addr->s6_addr32[2]==prefix->s6_addr[2])&&
(addr->s6_addr32[3]==prefix->s6_addr[3]));
}
}
//---------------------------------------------------------------------------
int nas_TOOL_network4(uint32_t *addr, uint32_t *prefix, uint8_t plen){
//---------------------------------------------------------------------------
// Start debug information
#ifdef NAS_DEBUG_TOOL
printk("NAS_TOOL_NETWORK4 - begin \n");
#endif
if (addr==NULL){
#ifdef NAS_DEBUG_TOOL
printk("NAS_TOOL_NETWORK4 - input parameter addr is NULL \n");
#endif
return 0;
}
if (prefix==NULL){
#ifdef NAS_DEBUG_TOOL
printk("NAS_TOOL_NETWORK4 - input parameter prefix is NULL \n");
#endif
return 0;
}
// End debug information
if (plen>=32)
return (*addr==*prefix);
else
return (((*addr>>(32-plen))<<(32-plen))==*prefix);
}
//---------------------------------------------------------------------------
//struct udphdr *nas_TOOL_get_udp6(struct ipv6hdr *iph){
//---------------------------------------------------------------------------
// return (struct udphdr *)((char *)iph+NAS_IPV6_SIZE); // to modify
//}
//---------------------------------------------------------------------------
uint8_t *nas_TOOL_get_protocol6(struct ipv6hdr *iph, uint8_t *protocol){
//---------------------------------------------------------------------------
uint16_t size;
// Start debug information
#ifdef NAS_DEBUG_TOOL
printk("NAS_TOOL_GET_PROTOCOL6 - begin \n");
#endif
if (iph==NULL){
#ifdef NAS_DEBUG_TOOL
printk("NAS_TOOL_GET_PROTOCOL6 - input parameter iph is NULL \n");
#endif
return NULL;
}
if (protocol==NULL){
#ifdef NAS_DEBUG_TOOL
printk("NAS_TOOL_GET_PROTOCOL6 - input parameter protocol is NULL \n");
#endif
return NULL;
}
// End debug information
*protocol=iph->nexthdr;
size=NAS_IPV6_SIZE;
while (1)
{
switch(*protocol)
{
case IPPROTO_UDP:
case IPPROTO_TCP:
case IPPROTO_ICMPV6:
return (uint8_t *)((uint8_t *)iph+size);
case IPPROTO_HOPOPTS:
case IPPROTO_ROUTING:
case IPPROTO_DSTOPTS:
*protocol=((uint8_t *)iph+size)[0];
size+=((uint8_t *)iph+size)[1]*8+8;
break;
case IPPROTO_FRAGMENT:
*protocol=((uint8_t *)iph+size)[0];
size+=((uint8_t *)iph+size)[1]+8;
break;
case IPPROTO_NONE:
case IPPROTO_AH:
case IPPROTO_ESP:
default:
return NULL;
}
}
}
//---------------------------------------------------------------------------
uint8_t *nas_TOOL_get_protocol4(struct iphdr *iph, uint8_t *protocol){
//---------------------------------------------------------------------------
// Start debug information
#ifdef NAS_DEBUG_TOOL
printk("NAS_TOOL_GET_PROTOCOL4 - begin \n");
#endif
if (iph==NULL){
#ifdef NAS_DEBUG_TOOL
printk("NAS_TOOL_GET_PROTOCOL4 - input parameter iph is NULL \n");
#endif
return NULL;
}
if (protocol==NULL){
#ifdef NAS_DEBUG_TOOL
printk("NAS_TOOL_GET_PROTOCOL4 - input parameter protocol is NULL \n");
#endif
return NULL;
}
// End debug information
*protocol=iph->protocol;
switch(*protocol)
{
case IPPROTO_UDP:
case IPPROTO_TCP:
case IPPROTO_ICMP:
return (uint8_t *)((uint8_t *)iph+iph->tot_len);
default:
return NULL;
}
}
//---------------------------------------------------------------------------
// Convert the IMEI to iid
void nas_TOOL_imei2iid(uint8_t *imei, uint8_t *iid){
//---------------------------------------------------------------------------
// Start debug information
#ifdef NAS_DEBUG_TOOL
printk("NAS_TOOL_IMEI2IID - begin \n");
#endif
if (imei==NULL){
#ifdef NAS_DEBUG_TOOL
printk("NAS_TOOL_IMEI2IID - input parameter imei is NULL \n");
#endif
return;
}
if (iid==NULL){
#ifdef NAS_DEBUG_TOOL
printk("NAS_TOOL_IMEI2IID - input parameter iid is NULL \n");
#endif
return;
}
// End debug information
memset(iid, 0, NAS_ADDR_LEN);
iid[0] = 0x03;
iid[1] = 16*imei[0]+imei[1];
iid[2] = 16*imei[2]+imei[3];
iid[3] = 16*imei[4]+imei[5];
iid[4] = 16*imei[6]+imei[7];
iid[5] = 16*imei[8]+imei[9];
iid[6] = 16*imei[10]+imei[11];
iid[7] = 16*imei[12]+imei[13];
}
//struct udphdr *nas_TOOL_get_udp4(struct iphdr *iph)
//{
// return (struct udphdr *)((char *)iph+NAS_IPV4_SIZE); // to modify
//}
//---------------------------------------------------------------------------
char *nas_TOOL_get_udpmsg(struct udphdr *udph){
//---------------------------------------------------------------------------
// Start debug information
#ifdef NAS_DEBUG_TOOL
printk("NAS_TOOL_GET_UDPMSG - begin \n");
#endif
if (udph==NULL){
#ifdef NAS_DEBUG_TOOL
printk("NAS_TOOL_GET_UDPMSG - input parameter udph is NULL \n");
#endif
return NULL;
}
// End debug information
return ((char *)udph+sizeof(struct udphdr));
}
//---------------------------------------------------------------------------
// Compute the UDP checksum (the data size must be odd)
uint16_t nas_TOOL_udpcksum(struct in6_addr *saddr, struct in6_addr *daddr, uint8_t proto, uint32_t udplen, void *data){
//---------------------------------------------------------------------------
uint32_t i;
uint16_t *data16;
uint32_t csum=0;
// Start debug information
#ifdef NAS_DEBUG_TOOL
printk("NAS_TOOL_UDPCKSUM - begin \n");
#endif
if (saddr==NULL){
#ifdef NAS_DEBUG_TOOL
printk("NAS_TOOL_UDPCKSUM - input parameter saddr is NULL \n");
#endif
return 0;
}
if (daddr==NULL){
#ifdef NAS_DEBUG_TOOL
printk("NAS_TOOL_UDPCKSUM - input parameter daddr is NULL \n");
#endif
return 0;
}
if (data==NULL){
#ifdef NAS_DEBUG_TOOL
printk("NAS_TOOL_UDPCKSUM - input parameter data is NULL \n");
#endif
return 0;
}
// End debug information
data16=data;
for (i=0; i<8; ++i)
{
csum+=ntohs(saddr->s6_addr16[i]);
if (csum>0xffff)
csum-=0xffff;
}
for (i=0; i<8; ++i)
{
csum+=ntohs(daddr->s6_addr16[i]);
if (csum>0xffff)
csum-=0xffff;
}
csum+=(udplen>>16); // udplen checksum
if (csum>0xffff)
csum -= 0xffff;
csum+=udplen & 0xffff;
if (csum>0xffff)
csum -= 0xffff;
csum+=proto; // protocol checksum
if (csum>0xffff)
csum-=0xffff;
for (i = 0; 2*i < udplen; i++)
{
csum+=ntohs(data16[i]);
if (csum>0xffff)
csum-=0xffff;
}
return htons((uint16_t)(~csum)&0xffff);
}
//---------------------------------------------------------------------------
void print_TOOL_pk_udp(struct udphdr *udph){
//---------------------------------------------------------------------------
// Start debug information
#ifdef NAS_DEBUG_TOOL
printk("PRINT_TOOL_PK_UDP - begin \n");
#endif
if (udph==NULL){
#ifdef NAS_DEBUG_TOOL
printk("NAS_TOOL_PK_UDP - input parameter udph is NULL \n");
#endif
return;
}
// End debug information
if (udph!=NULL)
{
printk("UDP:\t source = %u, dest = %u, len = %u, check = %x\n", ntohs(udph->source), ntohs(udph->dest), ntohs(udph->len), udph->check);
}
}
//---------------------------------------------------------------------------
void print_TOOL_pk_tcp(struct tcphdr *tcph){
//---------------------------------------------------------------------------
// Start debug information
#ifdef NAS_DEBUG_TOOL
printk("PRINT_TOOL_PK_TDP - begin \n");
#endif
if (tcph==NULL){
#ifdef NAS_DEBUG_TOOL
printk("NAS_TOOL_PK_TDP - input parameter tcph is NULL \n");
#endif
return;
}
// End debug information
if (tcph!=NULL)
{
printk("TCP:\t source = %u, dest = %u\n", tcph->source, tcph->dest);
}
}
//---------------------------------------------------------------------------
void print_TOOL_pk_icmp6(struct icmp6hdr *icmph){
//---------------------------------------------------------------------------
// Start debug information
#ifdef NAS_DEBUG_TOOL
printk("PRINT_TOOL_PK_ICMP6 - begin \n");
#endif
if (icmph==NULL){
#ifdef NAS_DEBUG_TOOL
printk("NAS_TOOL_PK_ICMP6 - input parameter icmph is NULL \n");
#endif
return;
}
// End debug information
if (icmph!=NULL)
{
printk("ICMPv6:\t type= %d, code = %d\n", icmph->icmp6_type, icmph->icmp6_code);
switch(icmph->icmp6_type)
{
case ICMPV6_DEST_UNREACH:printk("Destination unreachable\n");break;
case ICMPV6_PKT_TOOBIG:printk("Packet too big\n");break;
case ICMPV6_TIME_EXCEED:printk("Time exceeded\n");break;
case ICMPV6_PARAMPROB:printk("Parameter problem\n");break;
case ICMPV6_ECHO_REQUEST:printk("Echo request\n");break;
case ICMPV6_ECHO_REPLY:printk("Echo reply\n");break;
case ICMPV6_MGM_QUERY:printk("Multicast listener query\n");break;
case ICMPV6_MGM_REPORT:printk("Multicast listener report\n");break;
case ICMPV6_MGM_REDUCTION:printk("Multicast listener done\n");break;
case NDISC_ROUTER_SOLICITATION:printk("Router solicitation\n");break;
case NDISC_ROUTER_ADVERTISEMENT:printk("Router advertisment\n");break;
case NDISC_NEIGHBOUR_SOLICITATION:printk("Neighbour solicitation\n");break;
case NDISC_NEIGHBOUR_ADVERTISEMENT:printk("Neighbour advertisment\n");break;
case NDISC_REDIRECT:printk("redirect message\n");break;
}
}
}
//---------------------------------------------------------------------------
void print_TOOL_pk_ipv6(struct ipv6hdr *iph){
//---------------------------------------------------------------------------
// Start debug information
#ifdef NAS_DEBUG_TOOL
printk("PRINT_TOOL_PK_IPv6 - begin \n");
#endif
if (iph==NULL){
#ifdef NAS_DEBUG_TOOL
printk("NAS_TOOL_PK_IPv6 - input parameter iph is NULL \n");
#endif
return;
}
// End debug information
if (iph!=NULL)
{
// char addr[NAS_INET6_ADDRSTRLEN];
printk("IP:\t version = %u, priority = %u, payload_len = %u\n", iph->version, iph->priority, ntohs(iph->payload_len));
printk("\t fl0 = %u, fl1 = %u, fl2 = %u\n",iph->flow_lbl[0],iph->flow_lbl[1],iph->flow_lbl[2]);
printk("\t next header = %u, hop_limit = %u\n", iph->nexthdr, iph->hop_limit);
// inet_ntop(AF_INET6, (void *)(&iph->saddr), addr, NAS_INET6_ADDRSTRLEN);
// printk("\t saddr = %s",addr);
// inet_ntop(AF_INET6, (void *)(&iph->daddr), addr, NAS_INET6_ADDRSTRLEN);
// printk(", daddr = %s\n",addr);
switch(iph->nexthdr)
{
case IPPROTO_UDP:
print_TOOL_pk_udp((struct udphdr *)((char *)iph+sizeof(struct ipv6hdr)));
break;
case IPPROTO_TCP:
print_TOOL_pk_tcp((struct tcphdr *)((char *)iph+sizeof(struct ipv6hdr)));
break;
case IPPROTO_ICMPV6:
print_TOOL_pk_icmp6((struct icmp6hdr *)((char *)iph+sizeof(struct ipv6hdr)));
break;
case IPPROTO_IPV6:
print_TOOL_pk_ipv6((struct ipv6hdr *)((char *)iph+sizeof(struct ipv6hdr)));
break;
default:
printk("Unknown upper layer\n");
}
}
}
//---------------------------------------------------------------------------
void print_TOOL_pk_ipv4(struct iphdr *iph){
//---------------------------------------------------------------------------
// Start debug information
#ifdef NAS_DEBUG_TOOL
printk("PRINT_TOOL_PK_IPv4 - begin \n");
#endif
if (iph==NULL){
#ifdef NAS_DEBUG_TOOL
printk("NAS_TOOL_PK_IPv4 - input parameter iph is NULL \n");
#endif
return;
}
// End debug information
if (iph!=NULL)
{
// char addr[NAS_INET_ADDRSTRLEN];
printk("IP:\t version = %u, IP length = %u\n", iph->version, iph->ihl);
// inet_ntop(AF_INET, (void *)(&iph->saddr), addr, NAS_INET_ADDRSTRLEN);
// printk("\t saddr = %s", addr);
// inet_ntop(AF_INET, (void *)(&iph->saddr), addr, NAS_INET_ADDRSTRLEN);
// printk("\t saddr = %s", addr);
}
}
//---------------------------------------------------------------------------
void print_TOOL_pk_all(struct sk_buff *skb){
//---------------------------------------------------------------------------
printk("Skb:\t %p, len = %u\n", skb, skb->len);
#ifdef KERNEL_VERSION_GREATER_THAN_2629
//navid: need to calculate the current used space: fixme?
printk("Skb:\t available buf space = %u \n", skb->truesize);
#else
printk("Skb:\t available buf space = %u, cur used space = %u \n", skb->end-skb->head, skb->tail-skb->data);
#endif
switch (ntohs(skb->protocol))
{
case ETH_P_IPV6:
#ifdef KERNEL_VERSION_GREATER_THAN_2622
print_TOOL_pk_ipv6((struct ipv6hdr *)skb->network_header);
#else
print_TOOL_pk_ipv6(skb->nh.ipv6h);
#endif
break;
case ETH_P_IP:
#ifdef KERNEL_VERSION_GREATER_THAN_2622
print_TOOL_pk_ipv4((struct iphdr *)skb->network_header);
#else
print_TOOL_pk_ipv4(skb->nh.iph);
#endif
break;
}
}
//---------------------------------------------------------------------------
/*int isdigit(char c)
{
switch(c)
{
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
return 1;
default:
return 0;
}
}*/
/*int nas_TOOL_inet_pton4(char *src, uint32_t *dst)
{
uint32_t val;
int n;
uint8_t c;
uint32_t parts[4];
c = *src;
val=0;
n=0
for (;;)
{
for (;;)
{
if (isdigit(c))
{
val = (val * 10) + c - '0';
c = *++src;
}
else
break;
}
if (c == '.')
{
if (n>4)
return -1;
parts[n]=val;
c = *++src;
++n;
}
else
break;
}
if ((c != '\0')||(n!=3))
return (0);
if ((parts[0] | parts[1] | parts[2] | val) > 256)
return (0);
val |= (parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8);
if (dst)
dst = htonl(val);
return (1);
}*/
//---------------------------------------------------------------------------
void print_TOOL_state(uint8_t state){
//---------------------------------------------------------------------------
// case NAS_STATE_IDLE:printk(" State NAS_STATE_IDLE\n");return;
// case NAS_STATE_CONNECTED:printk(" State NAS_STATE_CONNECTED\n");return;
// case NAS_STATE_ESTABLISHMENT_REQUEST:printk(" State NAS_STATE_ESTABLISHMENT_REQUEST\n");return;
// case NAS_STATE_ESTABLISHMENT_FAILURE:printk(" State NAS_STATE_ESTABLISHMENT_FAILURE\n");return;
// case NAS_STATE_RELEASE_FAILURE:printk(" State NAS_STATE_RELEASE_FAILURE\n");return;
switch(state){
case NAS_IDLE:printk("NAS_IDLE\n");return;
case NAS_CX_FACH:printk("NAS_CX_FACH\n");return;
case NAS_CX_DCH:printk("NAS_CX_DCH\n");return;
case NAS_CX_RECEIVED:printk("NAS_CX_RECEIVED\n");return;
case NAS_CX_CONNECTING:printk("NAS_CX_CONNECTING\n");return;
case NAS_CX_RELEASING:printk("NAS_CX_RELEASING\n");return;
case NAS_CX_CONNECTING_FAILURE:printk("NAS_CX_CONNECTING_FAILURE\n");return;
case NAS_CX_RELEASING_FAILURE:printk("NAS_CX_RELEASING_FAILURE\n");return;
case NAS_RB_ESTABLISHING:printk("NAS_RB_ESTABLISHING\n");return;
case NAS_RB_RELEASING:printk("NAS_RB_RELEASING\n");return;
case NAS_RB_DCH:printk("NAS_RB_DCH\n");return;
default: printk(" Unknown state\n");
}
}
//-----------------------------------------------------------------------------
// Print the content of a buffer in hexadecimal
void nas_tool_print_buffer(char * buffer,int length) {
//-----------------------------------------------------------------------------
int i;
// Start debug information
#ifdef NAS_DEBUG_TOOL
printk("NAS_TOOL_PRINT_BUFFER - begin \n");
#endif
if (buffer==NULL){
#ifdef NAS_DEBUG_TOOL
printk("NAS_TOOL_PRINT_BUFFER - input parameter buffer is NULL \n");
#endif
return;
}
// End debug information
printk("\nBuffer content: ");
for (i=0;i<length;i++)
printk("-%hx-",buffer[i]);
printk(",\t length %d\n", length);
}
//-----------------------------------------------------------------------------
void nas_print_rb_entity(struct rb_entity *rb){
//-----------------------------------------------------------------------------
// Start debug information
#ifdef NAS_DEBUG_TOOL
printk("NAS_PRINT_RB_ENTITY - begin \n");
#endif
if (rb==NULL){
#ifdef NAS_DEBUG_TOOL
printk("NAS_PRINT_RB_ENTITY - input parameter rb is NULL \n");
#endif
return;
}
// End debug information
printk("\nrb_entity content: rab_id %d, sapi %d, qos %d, \n", rb->rab_id, rb->sapi, rb->qos);
printk("state %d, retry %d, countimer %d\n",rb->state, rb->retry, rb->countimer);
};
//-----------------------------------------------------------------------------
void nas_print_classifier(struct classifier_entity *gc){
//-----------------------------------------------------------------------------
// Start debug information
#ifdef NAS_DEBUG_TOOL
printk("NAS_PRINT_GC_ENTITY - begin \n");
#endif
if (gc==NULL){
#ifdef NAS_DEBUG_TOOL
printk("NAS_PRINT_GC_ENTITY - input parameter gc is NULL \n");
#endif
return;
}
// End debug information
printk("\nClassifier content: classref %d, version %d, splen %d, dplen %d,\n", gc->classref, gc->version, gc->splen, gc->dplen);
printk("protocol %d, sport %d, dport %d, rab_id %d\n", gc->protocol, gc->sport, gc->dport, gc->rab_id);
if (gc->rb != NULL){
nas_print_rb_entity(gc->rb);
}
};
Reference in New Issue View Git Blame Copy Permalink