1/* 2 * DECnet An implementation of the DECnet protocol suite for the LINUX 3 * operating system. DECnet is implemented using the BSD Socket 4 * interface as the means of communication with the user level. 5 * 6 * DECnet Neighbour Functions (Adjacency Database and 7 * On-Ethernet Cache) 8 * 9 * Author: Steve Whitehouse <SteveW@ACM.org> 10 * 11 * 12 * Changes: 13 * Steve Whitehouse : Fixed router listing routine 14 * Steve Whitehouse : Added error_report functions 15 * Steve Whitehouse : Added default router detection 16 * Steve Whitehouse : Hop counts in outgoing messages 17 * Steve Whitehouse : Fixed src/dst in outgoing messages so 18 * forwarding now stands a good chance of 19 * working. 20 * Steve Whitehouse : Fixed neighbour states (for now anyway). 21 * Steve Whitehouse : Made error_report functions dummies. This 22 * is not the right place to return skbs. 23 * Steve Whitehouse : Convert to seq_file 24 * 25 */ 26 27#include <linux/net.h> 28#include <linux/module.h> 29#include <linux/socket.h> 30#include <linux/if_arp.h> 31#include <linux/slab.h> 32#include <linux/if_ether.h> 33#include <linux/init.h> 34#include <linux/proc_fs.h> 35#include <linux/string.h> 36#include <linux/netfilter_decnet.h> 37#include <linux/spinlock.h> 38#include <linux/seq_file.h> 39#include <linux/rcupdate.h> 40#include <linux/jhash.h> 41#include <asm/atomic.h> 42#include <net/net_namespace.h> 43#include <net/neighbour.h> 44#include <net/dst.h> 45#include <net/flow.h> 46#include <net/dn.h> 47#include <net/dn_dev.h> 48#include <net/dn_neigh.h> 49#include <net/dn_route.h> 50 51static u32 dn_neigh_hash(const void *pkey, const struct net_device *dev); 52static int dn_neigh_construct(struct neighbour *); 53static void dn_long_error_report(struct neighbour *, struct sk_buff *); 54static void dn_short_error_report(struct neighbour *, struct sk_buff *); 55static int dn_long_output(struct sk_buff *); 56static int dn_short_output(struct sk_buff *); 57static int dn_phase3_output(struct sk_buff *); 58 59 60/* 61 * For talking to broadcast devices: Ethernet & PPP 62 */ 63static const struct neigh_ops dn_long_ops = { 64 .family = AF_DECnet, 65 .error_report = dn_long_error_report, 66 .output = dn_long_output, 67 .connected_output = dn_long_output, 68 .hh_output = dev_queue_xmit, 69 .queue_xmit = dev_queue_xmit, 70}; 71 72/* 73 * For talking to pointopoint and multidrop devices: DDCMP and X.25 74 */ 75static const struct neigh_ops dn_short_ops = { 76 .family = AF_DECnet, 77 .error_report = dn_short_error_report, 78 .output = dn_short_output, 79 .connected_output = dn_short_output, 80 .hh_output = dev_queue_xmit, 81 .queue_xmit = dev_queue_xmit, 82}; 83 84/* 85 * For talking to DECnet phase III nodes 86 */ 87static const struct neigh_ops dn_phase3_ops = { 88 .family = AF_DECnet, 89 .error_report = dn_short_error_report, /* Can use short version here */ 90 .output = dn_phase3_output, 91 .connected_output = dn_phase3_output, 92 .hh_output = dev_queue_xmit, 93 .queue_xmit = dev_queue_xmit 94}; 95 96struct neigh_table dn_neigh_table = { 97 .family = PF_DECnet, 98 .entry_size = sizeof(struct dn_neigh), 99 .key_len = sizeof(__le16), 100 .hash = dn_neigh_hash, 101 .constructor = dn_neigh_construct, 102 .id = "dn_neigh_cache", 103 .parms ={ 104 .tbl = &dn_neigh_table, 105 .base_reachable_time = 30 * HZ, 106 .retrans_time = 1 * HZ, 107 .gc_staletime = 60 * HZ, 108 .reachable_time = 30 * HZ, 109 .delay_probe_time = 5 * HZ, 110 .queue_len = 3, 111 .ucast_probes = 0, 112 .app_probes = 0, 113 .mcast_probes = 0, 114 .anycast_delay = 0, 115 .proxy_delay = 0, 116 .proxy_qlen = 0, 117 .locktime = 1 * HZ, 118 }, 119 .gc_interval = 30 * HZ, 120 .gc_thresh1 = 128, 121 .gc_thresh2 = 512, 122 .gc_thresh3 = 1024, 123}; 124 125static u32 dn_neigh_hash(const void *pkey, const struct net_device *dev) 126{ 127 return jhash_2words(*(__u16 *)pkey, 0, dn_neigh_table.hash_rnd); 128} 129 130static int dn_neigh_construct(struct neighbour *neigh) 131{ 132 struct net_device *dev = neigh->dev; 133 struct dn_neigh *dn = (struct dn_neigh *)neigh; 134 struct dn_dev *dn_db; 135 struct neigh_parms *parms; 136 137 rcu_read_lock(); 138 dn_db = rcu_dereference(dev->dn_ptr); 139 if (dn_db == NULL) { 140 rcu_read_unlock(); 141 return -EINVAL; 142 } 143 144 parms = dn_db->neigh_parms; 145 if (!parms) { 146 rcu_read_unlock(); 147 return -EINVAL; 148 } 149 150 __neigh_parms_put(neigh->parms); 151 neigh->parms = neigh_parms_clone(parms); 152 153 if (dn_db->use_long) 154 neigh->ops = &dn_long_ops; 155 else 156 neigh->ops = &dn_short_ops; 157 rcu_read_unlock(); 158 159 if (dn->flags & DN_NDFLAG_P3) 160 neigh->ops = &dn_phase3_ops; 161 162 neigh->nud_state = NUD_NOARP; 163 neigh->output = neigh->ops->connected_output; 164 165 if ((dev->type == ARPHRD_IPGRE) || (dev->flags & IFF_POINTOPOINT)) 166 memcpy(neigh->ha, dev->broadcast, dev->addr_len); 167 else if ((dev->type == ARPHRD_ETHER) || (dev->type == ARPHRD_LOOPBACK)) 168 dn_dn2eth(neigh->ha, dn->addr); 169 else { 170 if (net_ratelimit()) 171 printk(KERN_DEBUG "Trying to create neigh for hw %d\n", dev->type); 172 return -EINVAL; 173 } 174 175 /* 176 * Make an estimate of the remote block size by assuming that its 177 * two less then the device mtu, which it true for ethernet (and 178 * other things which support long format headers) since there is 179 * an extra length field (of 16 bits) which isn't part of the 180 * ethernet headers and which the DECnet specs won't admit is part 181 * of the DECnet routing headers either. 182 * 183 * If we over estimate here its no big deal, the NSP negotiations 184 * will prevent us from sending packets which are too large for the 185 * remote node to handle. In any case this figure is normally updated 186 * by a hello message in most cases. 187 */ 188 dn->blksize = dev->mtu - 2; 189 190 return 0; 191} 192 193static void dn_long_error_report(struct neighbour *neigh, struct sk_buff *skb) 194{ 195 printk(KERN_DEBUG "dn_long_error_report: called\n"); 196 kfree_skb(skb); 197} 198 199 200static void dn_short_error_report(struct neighbour *neigh, struct sk_buff *skb) 201{ 202 printk(KERN_DEBUG "dn_short_error_report: called\n"); 203 kfree_skb(skb); 204} 205 206static int dn_neigh_output_packet(struct sk_buff *skb) 207{ 208 struct dst_entry *dst = skb_dst(skb); 209 struct dn_route *rt = (struct dn_route *)dst; 210 struct neighbour *neigh = dst->neighbour; 211 struct net_device *dev = neigh->dev; 212 char mac_addr[ETH_ALEN]; 213 214 dn_dn2eth(mac_addr, rt->rt_local_src); 215 if (dev_hard_header(skb, dev, ntohs(skb->protocol), neigh->ha, 216 mac_addr, skb->len) >= 0) 217 return neigh->ops->queue_xmit(skb); 218 219 if (net_ratelimit()) 220 printk(KERN_DEBUG "dn_neigh_output_packet: oops, can't send packet\n"); 221 222 kfree_skb(skb); 223 return -EINVAL; 224} 225 226static int dn_long_output(struct sk_buff *skb) 227{ 228 struct dst_entry *dst = skb_dst(skb); 229 struct neighbour *neigh = dst->neighbour; 230 struct net_device *dev = neigh->dev; 231 int headroom = dev->hard_header_len + sizeof(struct dn_long_packet) + 3; 232 unsigned char *data; 233 struct dn_long_packet *lp; 234 struct dn_skb_cb *cb = DN_SKB_CB(skb); 235 236 237 if (skb_headroom(skb) < headroom) { 238 struct sk_buff *skb2 = skb_realloc_headroom(skb, headroom); 239 if (skb2 == NULL) { 240 if (net_ratelimit()) 241 printk(KERN_CRIT "dn_long_output: no memory\n"); 242 kfree_skb(skb); 243 return -ENOBUFS; 244 } 245 kfree_skb(skb); 246 skb = skb2; 247 if (net_ratelimit()) 248 printk(KERN_INFO "dn_long_output: Increasing headroom\n"); 249 } 250 251 data = skb_push(skb, sizeof(struct dn_long_packet) + 3); 252 lp = (struct dn_long_packet *)(data+3); 253 254 *((__le16 *)data) = cpu_to_le16(skb->len - 2); 255 *(data + 2) = 1 | DN_RT_F_PF; /* Padding */ 256 257 lp->msgflg = DN_RT_PKT_LONG|(cb->rt_flags&(DN_RT_F_IE|DN_RT_F_RQR|DN_RT_F_RTS)); 258 lp->d_area = lp->d_subarea = 0; 259 dn_dn2eth(lp->d_id, cb->dst); 260 lp->s_area = lp->s_subarea = 0; 261 dn_dn2eth(lp->s_id, cb->src); 262 lp->nl2 = 0; 263 lp->visit_ct = cb->hops & 0x3f; 264 lp->s_class = 0; 265 lp->pt = 0; 266 267 skb_reset_network_header(skb); 268 269 return NF_HOOK(NFPROTO_DECNET, NF_DN_POST_ROUTING, skb, NULL, 270 neigh->dev, dn_neigh_output_packet); 271} 272 273static int dn_short_output(struct sk_buff *skb) 274{ 275 struct dst_entry *dst = skb_dst(skb); 276 struct neighbour *neigh = dst->neighbour; 277 struct net_device *dev = neigh->dev; 278 int headroom = dev->hard_header_len + sizeof(struct dn_short_packet) + 2; 279 struct dn_short_packet *sp; 280 unsigned char *data; 281 struct dn_skb_cb *cb = DN_SKB_CB(skb); 282 283 284 if (skb_headroom(skb) < headroom) { 285 struct sk_buff *skb2 = skb_realloc_headroom(skb, headroom); 286 if (skb2 == NULL) { 287 if (net_ratelimit()) 288 printk(KERN_CRIT "dn_short_output: no memory\n"); 289 kfree_skb(skb); 290 return -ENOBUFS; 291 } 292 kfree_skb(skb); 293 skb = skb2; 294 if (net_ratelimit()) 295 printk(KERN_INFO "dn_short_output: Increasing headroom\n"); 296 } 297 298 data = skb_push(skb, sizeof(struct dn_short_packet) + 2); 299 *((__le16 *)data) = cpu_to_le16(skb->len - 2); 300 sp = (struct dn_short_packet *)(data+2); 301 302 sp->msgflg = DN_RT_PKT_SHORT|(cb->rt_flags&(DN_RT_F_RQR|DN_RT_F_RTS)); 303 sp->dstnode = cb->dst; 304 sp->srcnode = cb->src; 305 sp->forward = cb->hops & 0x3f; 306 307 skb_reset_network_header(skb); 308 309 return NF_HOOK(NFPROTO_DECNET, NF_DN_POST_ROUTING, skb, NULL, 310 neigh->dev, dn_neigh_output_packet); 311} 312 313/* 314 * Phase 3 output is the same is short output, execpt that 315 * it clears the area bits before transmission. 316 */ 317static int dn_phase3_output(struct sk_buff *skb) 318{ 319 struct dst_entry *dst = skb_dst(skb); 320 struct neighbour *neigh = dst->neighbour; 321 struct net_device *dev = neigh->dev; 322 int headroom = dev->hard_header_len + sizeof(struct dn_short_packet) + 2; 323 struct dn_short_packet *sp; 324 unsigned char *data; 325 struct dn_skb_cb *cb = DN_SKB_CB(skb); 326 327 if (skb_headroom(skb) < headroom) { 328 struct sk_buff *skb2 = skb_realloc_headroom(skb, headroom); 329 if (skb2 == NULL) { 330 if (net_ratelimit()) 331 printk(KERN_CRIT "dn_phase3_output: no memory\n"); 332 kfree_skb(skb); 333 return -ENOBUFS; 334 } 335 kfree_skb(skb); 336 skb = skb2; 337 if (net_ratelimit()) 338 printk(KERN_INFO "dn_phase3_output: Increasing headroom\n"); 339 } 340 341 data = skb_push(skb, sizeof(struct dn_short_packet) + 2); 342 *((__le16 *)data) = cpu_to_le16(skb->len - 2); 343 sp = (struct dn_short_packet *)(data + 2); 344 345 sp->msgflg = DN_RT_PKT_SHORT|(cb->rt_flags&(DN_RT_F_RQR|DN_RT_F_RTS)); 346 sp->dstnode = cb->dst & cpu_to_le16(0x03ff); 347 sp->srcnode = cb->src & cpu_to_le16(0x03ff); 348 sp->forward = cb->hops & 0x3f; 349 350 skb_reset_network_header(skb); 351 352 return NF_HOOK(NFPROTO_DECNET, NF_DN_POST_ROUTING, skb, NULL, 353 neigh->dev, dn_neigh_output_packet); 354} 355 356/* 357 * Unfortunately, the neighbour code uses the device in its hash 358 * function, so we don't get any advantage from it. This function 359 * basically does a neigh_lookup(), but without comparing the device 360 * field. This is required for the On-Ethernet cache 361 */ 362 363/* 364 * Pointopoint link receives a hello message 365 */ 366void dn_neigh_pointopoint_hello(struct sk_buff *skb) 367{ 368 kfree_skb(skb); 369} 370 371/* 372 * Ethernet router hello message received 373 */ 374int dn_neigh_router_hello(struct sk_buff *skb) 375{ 376 struct rtnode_hello_message *msg = (struct rtnode_hello_message *)skb->data; 377 378 struct neighbour *neigh; 379 struct dn_neigh *dn; 380 struct dn_dev *dn_db; 381 __le16 src; 382 383 src = dn_eth2dn(msg->id); 384 385 neigh = __neigh_lookup(&dn_neigh_table, &src, skb->dev, 1); 386 387 dn = (struct dn_neigh *)neigh; 388 389 if (neigh) { 390 write_lock(&neigh->lock); 391 392 neigh->used = jiffies; 393 dn_db = (struct dn_dev *)neigh->dev->dn_ptr; 394 395 if (!(neigh->nud_state & NUD_PERMANENT)) { 396 neigh->updated = jiffies; 397 398 if (neigh->dev->type == ARPHRD_ETHER) 399 memcpy(neigh->ha, ð_hdr(skb)->h_source, ETH_ALEN); 400 401 dn->blksize = le16_to_cpu(msg->blksize); 402 dn->priority = msg->priority; 403 404 dn->flags &= ~DN_NDFLAG_P3; 405 406 switch(msg->iinfo & DN_RT_INFO_TYPE) { 407 case DN_RT_INFO_L1RT: 408 dn->flags &=~DN_NDFLAG_R2; 409 dn->flags |= DN_NDFLAG_R1; 410 break; 411 case DN_RT_INFO_L2RT: 412 dn->flags |= DN_NDFLAG_R2; 413 } 414 } 415 416 /* Only use routers in our area */ 417 if ((le16_to_cpu(src)>>10) == (le16_to_cpu((decnet_address))>>10)) { 418 if (!dn_db->router) { 419 dn_db->router = neigh_clone(neigh); 420 } else { 421 if (msg->priority > ((struct dn_neigh *)dn_db->router)->priority) 422 neigh_release(xchg(&dn_db->router, neigh_clone(neigh))); 423 } 424 } 425 write_unlock(&neigh->lock); 426 neigh_release(neigh); 427 } 428 429 kfree_skb(skb); 430 return 0; 431} 432 433/* 434 * Endnode hello message received 435 */ 436int dn_neigh_endnode_hello(struct sk_buff *skb) 437{ 438 struct endnode_hello_message *msg = (struct endnode_hello_message *)skb->data; 439 struct neighbour *neigh; 440 struct dn_neigh *dn; 441 __le16 src; 442 443 src = dn_eth2dn(msg->id); 444 445 neigh = __neigh_lookup(&dn_neigh_table, &src, skb->dev, 1); 446 447 dn = (struct dn_neigh *)neigh; 448 449 if (neigh) { 450 write_lock(&neigh->lock); 451 452 neigh->used = jiffies; 453 454 if (!(neigh->nud_state & NUD_PERMANENT)) { 455 neigh->updated = jiffies; 456 457 if (neigh->dev->type == ARPHRD_ETHER) 458 memcpy(neigh->ha, ð_hdr(skb)->h_source, ETH_ALEN); 459 dn->flags &= ~(DN_NDFLAG_R1 | DN_NDFLAG_R2); 460 dn->blksize = le16_to_cpu(msg->blksize); 461 dn->priority = 0; 462 } 463 464 write_unlock(&neigh->lock); 465 neigh_release(neigh); 466 } 467 468 kfree_skb(skb); 469 return 0; 470} 471 472static char *dn_find_slot(char *base, int max, int priority) 473{ 474 int i; 475 unsigned char *min = NULL; 476 477 base += 6; /* skip first id */ 478 479 for(i = 0; i < max; i++) { 480 if (!min || (*base < *min)) 481 min = base; 482 base += 7; /* find next priority */ 483 } 484 485 if (!min) 486 return NULL; 487 488 return (*min < priority) ? (min - 6) : NULL; 489} 490 491struct elist_cb_state { 492 struct net_device *dev; 493 unsigned char *ptr; 494 unsigned char *rs; 495 int t, n; 496}; 497 498static void neigh_elist_cb(struct neighbour *neigh, void *_info) 499{ 500 struct elist_cb_state *s = _info; 501 struct dn_neigh *dn; 502 503 if (neigh->dev != s->dev) 504 return; 505 506 dn = (struct dn_neigh *) neigh; 507 if (!(dn->flags & (DN_NDFLAG_R1|DN_NDFLAG_R2))) 508 return; 509 510 if (s->t == s->n) 511 s->rs = dn_find_slot(s->ptr, s->n, dn->priority); 512 else 513 s->t++; 514 if (s->rs == NULL) 515 return; 516 517 dn_dn2eth(s->rs, dn->addr); 518 s->rs += 6; 519 *(s->rs) = neigh->nud_state & NUD_CONNECTED ? 0x80 : 0x0; 520 *(s->rs) |= dn->priority; 521 s->rs++; 522} 523 524int dn_neigh_elist(struct net_device *dev, unsigned char *ptr, int n) 525{ 526 struct elist_cb_state state; 527 528 state.dev = dev; 529 state.t = 0; 530 state.n = n; 531 state.ptr = ptr; 532 state.rs = ptr; 533 534 neigh_for_each(&dn_neigh_table, neigh_elist_cb, &state); 535 536 return state.t; 537} 538 539 540#ifdef CONFIG_PROC_FS 541 542static inline void dn_neigh_format_entry(struct seq_file *seq, 543 struct neighbour *n) 544{ 545 struct dn_neigh *dn = (struct dn_neigh *) n; 546 char buf[DN_ASCBUF_LEN]; 547 548 read_lock(&n->lock); 549 seq_printf(seq, "%-7s %s%s%s %02x %02d %07ld %-8s\n", 550 dn_addr2asc(le16_to_cpu(dn->addr), buf), 551 (dn->flags&DN_NDFLAG_R1) ? "1" : "-", 552 (dn->flags&DN_NDFLAG_R2) ? "2" : "-", 553 (dn->flags&DN_NDFLAG_P3) ? "3" : "-", 554 dn->n.nud_state, 555 atomic_read(&dn->n.refcnt), 556 dn->blksize, 557 (dn->n.dev) ? dn->n.dev->name : "?"); 558 read_unlock(&n->lock); 559} 560 561static int dn_neigh_seq_show(struct seq_file *seq, void *v) 562{ 563 if (v == SEQ_START_TOKEN) { 564 seq_puts(seq, "Addr Flags State Use Blksize Dev\n"); 565 } else { 566 dn_neigh_format_entry(seq, v); 567 } 568 569 return 0; 570} 571 572static void *dn_neigh_seq_start(struct seq_file *seq, loff_t *pos) 573{ 574 return neigh_seq_start(seq, pos, &dn_neigh_table, 575 NEIGH_SEQ_NEIGH_ONLY); 576} 577 578static const struct seq_operations dn_neigh_seq_ops = { 579 .start = dn_neigh_seq_start, 580 .next = neigh_seq_next, 581 .stop = neigh_seq_stop, 582 .show = dn_neigh_seq_show, 583}; 584 585static int dn_neigh_seq_open(struct inode *inode, struct file *file) 586{ 587 return seq_open_net(inode, file, &dn_neigh_seq_ops, 588 sizeof(struct neigh_seq_state)); 589} 590 591static const struct file_operations dn_neigh_seq_fops = { 592 .owner = THIS_MODULE, 593 .open = dn_neigh_seq_open, 594 .read = seq_read, 595 .llseek = seq_lseek, 596 .release = seq_release_net, 597}; 598 599#endif 600 601void __init dn_neigh_init(void) 602{ 603 neigh_table_init(&dn_neigh_table); 604 proc_net_fops_create(&init_net, "decnet_neigh", S_IRUGO, &dn_neigh_seq_fops); 605} 606 607void __exit dn_neigh_cleanup(void) 608{ 609 proc_net_remove(&init_net, "decnet_neigh"); 610 neigh_table_clear(&dn_neigh_table); 611} 612