/*! \brief finds a connection, if id=0 uses the ip addr & port (host byte order)
* \note WARNING: unprotected (locks) use tcpconn_get unless you really
* know what you are doing */
struct tcp_connection* _tcpconn_find(int id, struct ip_addr* ip, int port)
{
struct tcp_connection *c;
struct tcp_conn_alias* a;
unsigned hash;
#ifdef EXTRA_DEBUG
LM_DBG("%d port %d\n",id, port);
if (ip) print_ip("tcpconn_find: ip ", ip, "\n");
#endif
if (id){
hash=tcp_id_hash(id);
for (c=tcpconn_id_hash[hash]; c; c=c->id_next){
#ifdef EXTRA_DEBUG
LM_DBG("c=%p, c->id=%d, port=%d\n",c, c->id, c->rcv.src_port);
print_ip("ip=", &c->rcv.src_ip, "\n");
#endif
if ((id==c->id)&&(c->state!=S_CONN_BAD)) return c;
}
}else if (ip){
hash=tcp_addr_hash(ip, port);
for (a=tcpconn_aliases_hash[hash]; a; a=a->next){
#ifdef EXTRA_DEBUG
LM_DBG("a=%p, c=%p, c->id=%d, alias port= %d port=%d\n",
a, a->parent, a->parent->id, a->port, a->parent->rcv.src_port);
print_ip("ip=",&a->parent->rcv.src_ip,"\n");
#endif
if ( (a->parent->state!=S_CONN_BAD) && (port==a->port) &&
(ip_addr_cmp(ip, &a->parent->rcv.src_ip)) )
return a->parent;
}
}
return 0;
}
bool get_route_entry(uint32_t network, uint32_t dest_ip,
char *interface, uint32_t *mask, uint32_t *next_hop,
uint32_t *metric) {
router_entry *rentry = (router_entry*)find_entry(network);
if (rentry == NULL) {
printf("ROUTER: This should never happen\n");
exit(1);
}
if ( (dest_ip & rentry->mask) != rentry->network ) {
return false;
}
if (DEBUG) {
uint32_t result_and = dest_ip & rentry->mask;
printf("\n ANDED = ");
print_ip(result_and);
printf("\n Debug route: Dest ip: ");
print_ip(dest_ip);
printf(" Network ip : ");
print_ip(network);
printf("\n");
}
*mask = rentry->mask;
*next_hop = rentry->next_hop;
*metric = rentry->metric;
strcpy(interface, rentry->interface);
return true;
}
static void parse_arp(arp_hdr *a)
{
char mac1[macbuf_size];
char mac2[macbuf_size];
char ip1[ipbuf_size];
char ip2[ipbuf_size];
print_mac(mac1, &a->snd_hw_addr);
print_mac(mac2, &a->target_hw_addr);
print_ip(ip1, &a->snd_prot_addr);
print_ip(ip2, &a->target_prot_addr);
if (PA_ARP) {
switch(ntohs(a->op))
{
case arp_op_request:
printf(" REQ from %s (%s) for %s\n", mac1, ip1, ip2);
break;
case arp_op_reply:
printf(" REPLY from %s (%s), target = %s (%s)\n",
mac1, ip1, mac2, ip2);
break;
case arp_op_rarp_request:
printf(" RARP REQ from %s (%s) for %s\n", mac1, ip1, ip2);
break;
case arp_op_rarp_reply:
printf(" RARP REPLY from %s (%s), target = %s (%s)\n",
mac1, ip1, mac2, ip2);
break;
}
}
}
/* finds a connection, if id=0 uses the ip addr & port (host byte order)
* WARNING: unprotected (locks) use tcpconn_get unless you really
* know what you are doing */
struct tcp_connection* _tcpconn_find(int id, struct ip_addr* ip, int port)
{
struct tcp_connection *c;
unsigned hash;
#ifdef EXTRA_DEBUG
DBG("tcpconn_find: %d port %d\n",id, port);
print_ip("tcpconn_find: ip ", ip, "\n");
#endif
if (id){
hash=tcp_id_hash(id);
for (c=tcpconn_id_hash[hash]; c; c=c->id_next){
#ifdef EXTRA_DEBUG
DBG("c=%p, c->id=%d, port=%d\n",c, c->id, c->rcv.src_port);
print_ip("ip=", &c->rcv.src_ip, "\n");
#endif
if ((id==c->id)&&(c->state!=S_CONN_BAD)) return c;
}
}else if (ip){
hash=tcp_addr_hash(ip, port);
for (c=tcpconn_addr_hash[hash]; c; c=c->next){
#ifdef EXTRA_DEBUG
DBG("c=%p, c->id=%d, port=%d\n",c, c->id, c->rcv.src_port);
print_ip("ip=",&c->rcv.src_ip,"\n");
#endif
if ( (c->state!=S_CONN_BAD) && (port==c->rcv.src_port) &&
(ip_addr_cmp(ip, &c->rcv.src_ip)) )
return c;
}
}
return 0;
}
void packet_in(uint8_t *data, uint16_t size)
{
FullPacket p;
/* print_packet(data, size);*/
proto_eth_demangle(&p.eth, data);
printf("Eth received\r\n");
if (!MAC_ADDR_EQUAL(p.eth.dst.addr, _bmac) && !MAC_ADDR_EQUAL(p.eth.dst.addr, simple_net_get_mac()))
return;
if (p.eth.type != PROTO_IP)
return;
proto_ip_demangle(&p.ip, data + IP_OFFSET);
printf("IP received\r\n");
printf("Src: ");
print_ip(p.ip.src_addr);
printf("\r\nDst: ");
print_ip(p.ip.dst_addr);
printf("\r\n");
if (p.ip.protocol != PROTO_UDP)
return;
proto_udp_demangle(&p.udp, data + UDP_OFFSET);
printf("UDP received %d %d\r\n", p.udp.src_port, p.udp.dst_port);
if (p.udp.dst_port != DHCP_CLIENT_PORT || p.udp.src_port != DHCP_SERVER_PORT)
return;
printf("Received DHCP packet\r\n");
proto_dhcp_demangle(&p.dhcp, data + DHCP_OFFSET);
dhcp_process_packet(&p);
}
int NSCLASS dsr_ack_opt_recv(struct dsr_ack_opt *ack)
{
unsigned short id;
struct in_addr dst, src, myaddr;
int n;
if (!ack)
return DSR_PKT_ERROR;
myaddr = my_addr();
dst.s_addr = ack->dst;
src.s_addr = ack->src;
id = ntohs(ack->id);
LOG_DBG("ACK dst=%s src=%s id=%u\n", print_ip(dst), print_ip(src), id);
if (dst.s_addr != myaddr.s_addr)
return DSR_PKT_ERROR;
/* Purge packets buffered for this next hop */
n = maint_buf_del_all_id(src, id);
LOG_DBG("Removed %d packets from maint buf\n", n);
return DSR_PKT_NONE;
}
void
print_ip_settings(struct ip_addr *ip, struct ip_addr *mask, struct ip_addr *gw)
{
print_ip("Board IP: ", ip);
print_ip("Netmask : ", mask);
print_ip("Gateway : ", gw);
}
struct net* mk_new_net(struct ip_addr* ip, struct ip_addr* mask)
{
struct net* n;
int warning;
int r;
warning=0;
if ((ip->af != mask->af) || (ip->len != mask->len)){
LM_CRIT("trying to use a different mask family"
" (eg. ipv4/ipv6mask or ipv6/ipv4mask)\n");
goto error;
}
n=(struct net*)pkg_malloc(sizeof(struct net));
if (n==0){
LM_CRIT("memory allocation failure\n");
goto error;
}
n->ip=*ip;
n->mask=*mask;
for (r=0; r<n->ip.len/4; r++) { /*ipv4 & ipv6 addresses are multiple of 4*/
n->ip.u.addr32[r] &= n->mask.u.addr32[r];
if (n->ip.u.addr32[r]!=ip->u.addr32[r]) warning=1;
};
if (warning){
LM_WARN("invalid network address/netmask "
"combination fixed...\n");
print_ip("original network address:", ip, "/");
print_ip("", mask, "\n");
print_ip("fixed network address:", &(n->ip), "/");
print_ip("", &(n->mask), "\n");
};
return n;
error:
return 0;
}
void print_net(struct net* net)
{
if (net==0){
LOG(L_WARN, "ERROR: print net: null pointer\n");
return;
}
print_ip("", &net->ip, "/"); print_ip("", &net->mask, "");
}
void print_net(struct net* net)
{
if (net==0){
LM_WARN("null pointer\n");
return;
}
print_ip("", &net->ip, "/"); print_ip("", &net->mask, "");
}
void __forwarding_table_show_a(uint32_t subnet, uint32_t mask, uint32_t next_hop,
char * interface, void * userdata, int * finished)
{
print_t print = (print_t)userdata;
print_ip(subnet,print);print("\t");
print_ip(mask,print);print("\t");
print_ip(next_hop,print);print("\t");
print("%s\n",interface);
}
void border_printNodes(struct ip_list *list) {
printf("Im Netz verfügbare Knoten:\n");
int i;
for (i = 0; i < size_ip(list); i++) {
printf("%d: ", i);
print_ip(get_ip(list, i));
uint8_t *tmp = get_via(list, i);
if (tmp != NULL) {
printf(" via ");
print_ip(tmp);
}
printf("\n");
}
}
//*******************************************************************************************
//
// Function : standby_display
// Description : display board status such as AVR ip, server ip, countdown time, temparature
//
//*******************************************************************************************
void standby_display ( void )
{
BYTE generic_buf[64];
// update lcd display flag not set, exit from function
if ( flag1.bits.update_display == 0 )
return;
flag1.bits.update_display = 0;
// lcd display is displaying other information, wait until busy flag clear
if ( flag1.bits.lcd_busy )
return;
// now displaying menu information, wait until exit from menu
if ( menu_index )
return;
// display status on lcd line 1
lcd_putc ( '\f' );
lcd_print ( (BYTE*)standby_list[ standby_cursor - 1 ] );
// display status devices on lcd line 2
lcd_putc ( '\n' );
if ( standby_cursor == 1 )
{
print_devices (generic_buf,ind_device_cur);
}
// display avr ip
if ( standby_cursor == 2 )
{
print_ip ( generic_buf, (BYTE*)&avr_ip, 0 );
}
// display server ip
else if ( standby_cursor == 3 )
{
print_ip ( generic_buf, (BYTE*)&server_ip, 0 );
}
// display countdown timer
else if ( standby_cursor == 4 )
{
print_time ( generic_buf, count_time, 0 );
}
// display current temparature
else if ( standby_cursor == 5 )
{
print_temp ( generic_buf );
}
lcd_print ( generic_buf );
}
//*******************************************************************************************
//
// Function : display_menu
// Description : display LCD user interface menu on LCD
//
//*******************************************************************************************
void display_menu(void)
{
BYTE generic_buf[64];
if( menu_index == 0)
return;
// display menu title on lcd first line
lcd_putc( '\f' );
lcd_print ( (BYTE *)menu_list[ menu_index - 1 ] );
// display menu detail on lcd second line
lcd_putc( '\n' );
if( menu_index == 1 )//MENU_MAIN)
{
lcd_print( (BYTE *)menu_list[ submenu_index ] );
}
// setup avr ip address
else if( menu_index == 2 )
{
print_ip ( generic_buf, (BYTE*)&avr_ip, setting_cursor+1 );
lcd_print ( generic_buf );
}
// setup server ip address
else if(menu_index == 3 )
{
print_ip ( generic_buf, (BYTE*)&server_ip, setting_cursor+1 );
lcd_print ( generic_buf );
}
// setup countdown timer for send temparature
else if ( menu_index == 4 )
{
print_time ( generic_buf, count_time, setting_cursor+1 );
lcd_print ( generic_buf );
}
// ping server
else if ( menu_index == 5 )
{
print_ip ( generic_buf, (BYTE*)&server_ip, 1 );
lcd_print ( generic_buf );
}
// send temparature now
//else if ( menu_index == 6 )
//{
// lcd_put ( ASCII_CURSOR );
// lcd_print_p ( PSTR ( "OK" ) );
//}
}
static int kaodv_netlink_receive_peer(unsigned char type, void *msg,
unsigned int len)
{
int ret = 0;
struct kaodv_rt_msg *m;
struct kaodv_conf_msg *cm;
struct expl_entry e;
KAODV_DEBUG("Received msg: %s", kaodv_msg_type_to_str(type));
switch (type) {
case KAODVM_ADDROUTE:
if (len < sizeof(struct kaodv_rt_msg))
return -EINVAL;
m = (struct kaodv_rt_msg *)msg;
ret = kaodv_expl_get(m->dst, &e);
if (ret > 0) {
ret = kaodv_expl_update(m->dst, m->nhop, m->time,
m->flags, m->ifindex);
} else {
ret = kaodv_expl_add(m->dst, m->nhop, m->time,
m->flags, m->ifindex);
}
printk(KERN_DEBUG "kaodv: KAODVM_ADDROUTE!\n");
kaodv_queue_set_verdict(KAODV_QUEUE_SEND, m->dst);
break;
case KAODVM_DELROUTE:
if (len < sizeof(struct kaodv_rt_msg))
return -EINVAL;
m = (struct kaodv_rt_msg *)msg;
kaodv_expl_del(m->dst);
kaodv_queue_set_verdict(KAODV_QUEUE_DROP, m->dst);
break;
case KAODVM_NOROUTE_FOUND:
if (len < sizeof(struct kaodv_rt_msg))
return -EINVAL;
m = (struct kaodv_rt_msg *)msg;
KAODV_DEBUG("No route found for %s", print_ip(m->dst));
kaodv_queue_set_verdict(KAODV_QUEUE_DROP, m->dst);
break;
case KAODVM_CONFIG:
if (len < sizeof(struct kaodv_conf_msg))
return -EINVAL;
cm = (struct kaodv_conf_msg *)msg;
active_route_timeout = cm->active_route_timeout;
qual_th = cm->qual_th;
is_gateway = cm->is_gateway;
break;
default:
printk("kaodv-netlink: Unknown message type\n");
ret = -EINVAL;
}
return ret;
}
void add_route(device *dev, int family, unsigned char *ip)
{
unsigned int i, len = (family == AF_INET ? IP_ADDR_LEN : IP6_ADDR_LEN);
for (i = 0; i < dev->route_cnt; i++)
if ((dev->route[i].family == family) &&
!memcmp(dev->route[i].peer, ip, len)) {
dev->route[i].peer_time = time(NULL);
return; /* already added */
}
if (i == MAX_ADDRESSES) {
print_dbg(1, "Too many peer IP addresses on device %s\n",
dev->name);
return;
}
printf("Device %s peer IP is ", dev->name);
print_ip(family, ip);
putchar('\n');
dev->route[dev->route_cnt].family = family;
memcpy(dev->route[dev->route_cnt].peer, ip, len);
dev->route[dev->route_cnt++].peer_time = time(NULL);
}
int dsr_hw_header_create(struct dsr_pkt *dp, struct sk_buff *skb)
{
struct sockaddr broadcast =
{ AF_UNSPEC, {0xff, 0xff, 0xff, 0xff, 0xff, 0xff} };
struct neighbor_info neigh_info;
if (dp->dst.s_addr == DSR_BROADCAST)
memcpy(neigh_info.hw_addr.sa_data, broadcast.sa_data, ETH_ALEN);
else {
/* Get hardware destination address */
if (neigh_tbl_query(dp->nxt_hop, &neigh_info) < 0) {
DEBUG
("Could not get hardware address for next hop %s\n",
print_ip(dp->nxt_hop));
return -1;
}
}
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
if (skb->dev->hard_header) {
skb->dev->hard_header(skb, skb->dev, ETH_P_IP,
neigh_info.hw_addr.sa_data, 0, skb->len);
} else {
DEBUG("Missing hard_header\n");
return -1;
}
#else
dev_hard_header(skb, skb->dev, ETH_P_IP,
neigh_info.hw_addr.sa_data, 0, skb->len);
#endif
return 0;
}
void expire_routes(void)
{
device *dev = first;
while (dev) {
if (dev->active && dev->add_route) {
unsigned int i = 0;
while (i < dev->route_cnt) {
if (time(NULL) - dev->route[i].peer_time >
INARP_TIMEOUT) {
printf("Device %s peer ", dev->name);
print_ip(dev->route[i].family,
dev->route[i].peer);
printf(" is no longer active\n");
dev->route_cnt--;
memcpy(&dev->route[i],
&dev->route[i + 1],
(MAX_ADDRESSES - i - 1) *
sizeof(route_t));
continue;
}
i++;
}
}
dev = dev->next;
}
}
static void cmd_ping(BaseSequentialStream *chp, int argc, char *argv[])
{
uint32_t remoteHostIp;
(void)argv;
if (argc != 1)
{
chprintf(chp, "Usage:\r\n");
chprintf(chp, "ping <hostname>\r\n");
return;
}
chprintf(chp,"Looking up IP of %s...\r\n", argv[0]);
gethostbyname(argv[0], strlen(argv[0]), &remoteHostIp);
chprintf(chp,"Pinging...", NULL); print_ip(chp, (const char *) &remoteHostIp);
remoteHostIp = htonl(remoteHostIp);
memset((void *)&cc3000AsyncData.ping, 0, sizeof(cc3000AsyncData.ping));
netapp_ping_send(&remoteHostIp, 3, 10, 3000);
while (cc3000AsyncData.ping.present != TRUE)
{
chThdSleep(MS2ST(100));
}
chprintf(chp,"--Ping Results--:\r\n", NULL);
chprintf(chp,"Number of Packets Sent: %u\r\n", cc3000AsyncData.ping.report.packets_sent);
chprintf(chp,"Number of Packet Received: %u\r\n", cc3000AsyncData.ping.report.packets_received);
chprintf(chp,"Min Round Time: %u\r\n", cc3000AsyncData.ping.report.min_round_time);
chprintf(chp,"Max Round Time: %u\r\n", cc3000AsyncData.ping.report.max_round_time);
chprintf(chp,"Avg Round Time: %u\r\n", cc3000AsyncData.ping.report.avg_round_time);
chprintf(chp,"--End of Ping Results--\r\n", NULL);
}
void dhcp_process_packet(FullPacket *p)
{
DhcpHead *dhcp = &p->dhcp;
uint8_t *current = dhcp->options + 4;
for ( ; current <= dhcp->options + 64 && *current != OPTION_END; current += current[1]+2 /* 2 == size of code + len */)
{
if (*current != OPTION_DHCP_MESSAGE_TYPE)
continue;
switch(current[2])
{
case DHCPOFFER:
printf("DHCPOFFER ip: ");
print_ip(dhcp->yiaddr);
printf("\r\n");
dhcp_request(p);
return;
case DHCPACK:
printf("ACK Received\r\n");
dhcp_handle_ack(p);
return;
default:
break;
}
}
}
static void parse_dhcp_clnt(dhcp *d)
{
char ip1[ipbuf_size];
char ip2[ipbuf_size];
char ip3[ipbuf_size];
char ip4[ipbuf_size];
print_ip(ip1, &d->clnt_addr);
print_ip(ip2, &d->your_addr);
print_ip(ip3, &d->server_addr);
print_ip(ip4, &d->gateway_addr);
printf(" [DHCP/Clnt] op %x ", d->op);
printf("CLNT %s YOUR %s\n", ip1, ip2);
printf(" SRV %s GW %s\n", ip3, ip4);
}
void do_ip( char * data )
{
global.packet_ip ++;
struct iphdr *pip;
pip = ( struct iphdr * ) data; /* pip = point to ip layer */
if( global.print_flag_ip )
print_ip( pip );
char * pdata = data + pip->ihl * 4;
switch( pip->protocol ){
case IPPROTO_ICMP:
do_icmp( pdata );
break;
case IPPROTO_IGMP:
do_igmp( pdata );
break;
case IPPROTO_TCP:
do_tcp( pdata );
break;
case IPPROTO_UDP:
do_udp( pdata );
break;
default:
printf("IP: 未知其上层协议.\n");
break;
}
}
void do_ip(void *p)
{
struct iphdr *ip = p;
g.packet_ip++;
if(g.print_flag_ip)
print_ip(ip);
void *data = ip;
data += ip->ihl << 2;
switch(ip->protocol)
{
case IPPROTO_TCP:
do_tcp(data);
break;
case IPPROTO_UDP:
do_udp(data);
break;
case IPPROTO_ICMP:
do_icmp(data);
break;
case IPPROTO_IGMP:
do_igmp(data);
break;
}
}
void dhcp_handle_ack(FullPacket *p)
{
printf("DHCP Server: ");
print_ip(ntohl(dhcp_get_option_simple(p->dhcp.options+4, OPTION_DHCP_SERVER_IDENTIFIER)));
printf("\r\n");
printf("My ip: ");
print_ip(p->dhcp.yiaddr);
printf("\r\n");
printf("Subnet mask: ");
print_ip(ntohl(dhcp_get_option_simple(p->dhcp.options+4, OPTION_SUBNET_MASK)));
printf("\r\n");
printf("Router: ");
print_ip(ntohl(dhcp_get_option_simple(p->dhcp.options+4, OPTION_ROUTER)));
printf("\r\n");
printf("Lease time: %d s\r\n", ntohl(dhcp_get_option_simple(p->dhcp.options+4, OPTION_DHCP_LEASE_TIME)));
}
void print_iphdr(struct iphdr *ip)
{
print_boundary();
printf("|");
print_data(ip->version,1,0);
print_data(ip->ihl,10,0);
print_data(ip->tos,100,0);
print_data(ntohs(ip->tot_len),10000,1);
print_boundary();
printf("|");
print_data(ip->id,10000,3);
print_data(ip->frag_off,10000,1);
print_boundary();
printf("|");
print_data(ip->ttl,100,1);
print_data(ip->protocol,100,0);
print_data(ip->check,10000,1);
print_boundary();
printf("|");
struct sockaddr_in s;
s.sin_addr.s_addr=ip->saddr;
print_ip(s);
print_boundary();
printf("|");
s.sin_addr.s_addr=ip->daddr;
print_ip(s);
print_boundary();
printf("\n\n");
}
struct tcp_connection* tcpconn_new(int sock, union sockaddr_union* su,
struct socket_info* ba, int type,
int state)
{
struct tcp_connection *c;
c=(struct tcp_connection*)shm_malloc(sizeof(struct tcp_connection));
if (c==0){
LM_ERR("shared memory allocation failure\n");
goto error;
}
memset(c, 0, sizeof(struct tcp_connection)); /* zero init */
c->s=sock;
c->fd=-1; /* not initialized */
if (lock_init(&c->write_lock)==0){
LM_ERR("init lock failed\n");
goto error;
}
c->rcv.src_su=*su;
c->refcnt=0;
su2ip_addr(&c->rcv.src_ip, su);
c->rcv.src_port=su_getport(su);
c->rcv.bind_address=ba;
if (ba){
c->rcv.dst_ip=ba->address;
c->rcv.dst_port=ba->port_no;
}
print_ip("tcpconn_new: new tcp connection to: ", &c->rcv.src_ip, "\n");
LM_DBG("on port %d, type %d\n", c->rcv.src_port, type);
init_tcp_req(&c->req);
c->id=(*connection_id)++;
c->rcv.proto_reserved1=0; /* this will be filled before receive_message*/
c->rcv.proto_reserved2=0;
c->state=state;
c->extra_data=0;
#ifdef USE_TLS
if (type==PROTO_TLS){
if (tls_tcpconn_init(c, sock)==-1) goto error;
}else
#endif /* USE_TLS*/
{
c->type=PROTO_TCP;
c->rcv.proto=PROTO_TCP;
c->timeout=get_ticks()+tcp_con_lifetime;
}
c->flags|=F_CONN_REMOVED;
tcp_connections_no++;
return c;
error:
if (c) shm_free(c);
return 0;
}
static l4_uint16_t parse_ip(ip_hdr *ip)
{
char ip1[ipbuf_size];
char ip2[ipbuf_size];
print_ip(ip1, &ip->src_addr);
print_ip(ip2, &ip->dest_addr);
unsigned char hlen = (ip->ver_hlen & 0x0F) * sizeof(int);
#if 0
printf(" [IP] version %d, hlen %d, services %d, plen %d, id %d\n",
(ip->ver_hlen & 0xF0) >> 4,
(ip->ver_hlen & 0x0F),
ip->services,
ntohs(ip->plen),
ntohs(ip->id));
printf(" flags %x, offset %x, ttl %d, proto %s (%d)\n",
(ntohs(ip->flags_frag_offset) & 0x70000000) >> 13,
(ntohs(ip->flags_frag_offset) & 0x1FFFFFFF),
ip->ttl, ip_proto_str(ip->proto), ip->proto);
printf(" csum %x, src %s, dest %s\n",
ntohs(ip->checksum), ip1, ip2);
#endif
switch(ip->proto)
{
case ip_proto_icmp:
if (PA_ICMP) parse_icmp((icmp_hdr*)((char*)ip + hlen));
return ip_proto_icmp;
break;
case ip_proto_tcp:
if (PA_TCP) parse_tcp((tcp_hdr*)((char*)ip + hlen));
return ip_proto_tcp;
break;
case ip_proto_udp:
if (PA_UDP) ;
return parse_udp((udp_hdr*)((char*)ip + hlen));
break;
default:
break;
}
}
static struct tcp_connection* tcpconn_new(int sock, union sockaddr_union* su,
struct socket_info* si, int state, int flags)
{
struct tcp_connection *c;
c=(struct tcp_connection*)shm_malloc(sizeof(struct tcp_connection));
if (c==0){
LM_ERR("shared memory allocation failure\n");
return 0;
}
memset(c, 0, sizeof(struct tcp_connection)); /* zero init */
c->s=sock;
c->fd=-1; /* not initialized */
if (lock_init(&c->write_lock)==0){
LM_ERR("init lock failed\n");
goto error0;
}
c->rcv.src_su=*su;
c->refcnt=0;
su2ip_addr(&c->rcv.src_ip, su);
c->rcv.src_port=su_getport(su);
c->rcv.bind_address = si;
c->rcv.dst_ip = si->address;
c->rcv.dst_port = si->port_no;
print_ip("tcpconn_new: new tcp connection to: ", &c->rcv.src_ip, "\n");
LM_DBG("on port %d, proto %d\n", c->rcv.src_port, si->proto);
c->id=(*connection_id)++;
c->rcv.proto_reserved1=0; /* this will be filled before receive_message*/
c->rcv.proto_reserved2=0;
c->state=state;
c->extra_data=0;
c->type = si->proto;
c->rcv.proto = si->proto;
/* start with the default conn lifetime */
c->lifetime = get_ticks()+tcp_con_lifetime;
c->flags|=F_CONN_REMOVED|flags;
if (protos[si->proto].net.conn_init &&
protos[si->proto].net.conn_init(c)<0) {
LM_ERR("failed to do proto %d specific init for conn %p\n",
si->proto,c);
goto error1;
}
tcp_connections_no++;
return c;
error1:
lock_destroy(&c->write_lock);
error0:
shm_free(c);
return 0;
}
void dijkstra_print_links_list( linked_list_t *links )
{
list_item_t *link;
printf( "---- start print_links (length: %d) --\n", links->length );
printf( "---- TO -----+------ Weight ---+\n" );
for ( link= links->head; link != NULL; link= link->next ) {
uint32_t temp= *((uint32_t*)link->data);
if ( temp == INFINITY )
printf( "%s\t|\tINF\n",
print_ip(link->key) );
else
printf( "%s\t|\t%d\n",
print_ip(link->key),
temp );
}
printf( "---- end print_links (length: %d) --\n", links->length );
}
void dijkstra_print_links( links_t *links )
{
link_from_t *node;
link_to_t *link;
printf( "---- start print_links (length: %d) --\n", links->length );
printf( "----- FROM -----+---- TO -----+------ Weight ---+\n" );
for ( node= links->head; node != NULL; node= node->next_node ) {
for (link= node->links; link != NULL; link= link->next_link) {
printf( "---- \t%s\t|\t",
print_ip(node->ip) );
printf( "%s\t|\t%d\n",
print_ip(link->ip),
link->distance );
}
}
printf( "---- end print_links (length: %d) --\n", links->length );
}
