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.
6 * DECnet Neighbour Functions (Adjacency Database and
9 * Author: Steve Whitehouse <SteveW@ACM.org>
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
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
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>
47 #include <net/dn_dev.h>
48 #include <net/dn_neigh.h>
49 #include <net/dn_route.h>
51 static u32
dn_neigh_hash(const void *pkey
, const struct net_device
*dev
);
52 static int dn_neigh_construct(struct neighbour
*);
53 static void dn_long_error_report(struct neighbour
*, struct sk_buff
*);
54 static void dn_short_error_report(struct neighbour
*, struct sk_buff
*);
55 static int dn_long_output(struct sk_buff
*);
56 static int dn_short_output(struct sk_buff
*);
57 static int dn_phase3_output(struct sk_buff
*);
61 * For talking to broadcast devices: Ethernet & PPP
63 static const struct neigh_ops dn_long_ops
= {
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
,
73 * For talking to pointopoint and multidrop devices: DDCMP and X.25
75 static const struct neigh_ops dn_short_ops
= {
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
,
85 * For talking to DECnet phase III nodes
87 static const struct neigh_ops dn_phase3_ops
= {
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
96 struct neigh_table dn_neigh_table
= {
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",
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
,
119 .gc_interval
= 30 * HZ
,
125 static u32
dn_neigh_hash(const void *pkey
, const struct net_device
*dev
)
127 return jhash_2words(*(__u16
*)pkey
, 0, dn_neigh_table
.hash_rnd
);
130 static int dn_neigh_construct(struct neighbour
*neigh
)
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
;
138 dn_db
= rcu_dereference(dev
->dn_ptr
);
144 parms
= dn_db
->neigh_parms
;
150 __neigh_parms_put(neigh
->parms
);
151 neigh
->parms
= neigh_parms_clone(parms
);
154 neigh
->ops
= &dn_long_ops
;
156 neigh
->ops
= &dn_short_ops
;
159 if (dn
->flags
& DN_NDFLAG_P3
)
160 neigh
->ops
= &dn_phase3_ops
;
162 neigh
->nud_state
= NUD_NOARP
;
163 neigh
->output
= neigh
->ops
->connected_output
;
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
);
171 printk(KERN_DEBUG
"Trying to create neigh for hw %d\n", dev
->type
);
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.
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.
188 dn
->blksize
= dev
->mtu
- 2;
193 static void dn_long_error_report(struct neighbour
*neigh
, struct sk_buff
*skb
)
195 printk(KERN_DEBUG
"dn_long_error_report: called\n");
200 static void dn_short_error_report(struct neighbour
*neigh
, struct sk_buff
*skb
)
202 printk(KERN_DEBUG
"dn_short_error_report: called\n");
206 static int dn_neigh_output_packet(struct sk_buff
*skb
)
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
];
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
);
220 printk(KERN_DEBUG
"dn_neigh_output_packet: oops, can't send packet\n");
226 static int dn_long_output(struct sk_buff
*skb
)
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;
233 struct dn_long_packet
*lp
;
234 struct dn_skb_cb
*cb
= DN_SKB_CB(skb
);
237 if (skb_headroom(skb
) < headroom
) {
238 struct sk_buff
*skb2
= skb_realloc_headroom(skb
, headroom
);
241 printk(KERN_CRIT
"dn_long_output: no memory\n");
248 printk(KERN_INFO
"dn_long_output: Increasing headroom\n");
251 data
= skb_push(skb
, sizeof(struct dn_long_packet
) + 3);
252 lp
= (struct dn_long_packet
*)(data
+3);
254 *((__le16
*)data
) = cpu_to_le16(skb
->len
- 2);
255 *(data
+ 2) = 1 | DN_RT_F_PF
; /* Padding */
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
);
263 lp
->visit_ct
= cb
->hops
& 0x3f;
267 skb_reset_network_header(skb
);
269 return NF_HOOK(PF_DECnet
, NF_DN_POST_ROUTING
, skb
, NULL
, neigh
->dev
, dn_neigh_output_packet
);
272 static int dn_short_output(struct sk_buff
*skb
)
274 struct dst_entry
*dst
= skb_dst(skb
);
275 struct neighbour
*neigh
= dst
->neighbour
;
276 struct net_device
*dev
= neigh
->dev
;
277 int headroom
= dev
->hard_header_len
+ sizeof(struct dn_short_packet
) + 2;
278 struct dn_short_packet
*sp
;
280 struct dn_skb_cb
*cb
= DN_SKB_CB(skb
);
283 if (skb_headroom(skb
) < headroom
) {
284 struct sk_buff
*skb2
= skb_realloc_headroom(skb
, headroom
);
287 printk(KERN_CRIT
"dn_short_output: no memory\n");
294 printk(KERN_INFO
"dn_short_output: Increasing headroom\n");
297 data
= skb_push(skb
, sizeof(struct dn_short_packet
) + 2);
298 *((__le16
*)data
) = cpu_to_le16(skb
->len
- 2);
299 sp
= (struct dn_short_packet
*)(data
+2);
301 sp
->msgflg
= DN_RT_PKT_SHORT
|(cb
->rt_flags
&(DN_RT_F_RQR
|DN_RT_F_RTS
));
302 sp
->dstnode
= cb
->dst
;
303 sp
->srcnode
= cb
->src
;
304 sp
->forward
= cb
->hops
& 0x3f;
306 skb_reset_network_header(skb
);
308 return NF_HOOK(PF_DECnet
, NF_DN_POST_ROUTING
, skb
, NULL
, neigh
->dev
, dn_neigh_output_packet
);
312 * Phase 3 output is the same is short output, execpt that
313 * it clears the area bits before transmission.
315 static int dn_phase3_output(struct sk_buff
*skb
)
317 struct dst_entry
*dst
= skb_dst(skb
);
318 struct neighbour
*neigh
= dst
->neighbour
;
319 struct net_device
*dev
= neigh
->dev
;
320 int headroom
= dev
->hard_header_len
+ sizeof(struct dn_short_packet
) + 2;
321 struct dn_short_packet
*sp
;
323 struct dn_skb_cb
*cb
= DN_SKB_CB(skb
);
325 if (skb_headroom(skb
) < headroom
) {
326 struct sk_buff
*skb2
= skb_realloc_headroom(skb
, headroom
);
329 printk(KERN_CRIT
"dn_phase3_output: no memory\n");
336 printk(KERN_INFO
"dn_phase3_output: Increasing headroom\n");
339 data
= skb_push(skb
, sizeof(struct dn_short_packet
) + 2);
340 *((__le16
*)data
) = cpu_to_le16(skb
->len
- 2);
341 sp
= (struct dn_short_packet
*)(data
+ 2);
343 sp
->msgflg
= DN_RT_PKT_SHORT
|(cb
->rt_flags
&(DN_RT_F_RQR
|DN_RT_F_RTS
));
344 sp
->dstnode
= cb
->dst
& cpu_to_le16(0x03ff);
345 sp
->srcnode
= cb
->src
& cpu_to_le16(0x03ff);
346 sp
->forward
= cb
->hops
& 0x3f;
348 skb_reset_network_header(skb
);
350 return NF_HOOK(PF_DECnet
, NF_DN_POST_ROUTING
, skb
, NULL
, neigh
->dev
, dn_neigh_output_packet
);
354 * Unfortunately, the neighbour code uses the device in its hash
355 * function, so we don't get any advantage from it. This function
356 * basically does a neigh_lookup(), but without comparing the device
357 * field. This is required for the On-Ethernet cache
361 * Pointopoint link receives a hello message
363 void dn_neigh_pointopoint_hello(struct sk_buff
*skb
)
369 * Ethernet router hello message received
371 int dn_neigh_router_hello(struct sk_buff
*skb
)
373 struct rtnode_hello_message
*msg
= (struct rtnode_hello_message
*)skb
->data
;
375 struct neighbour
*neigh
;
377 struct dn_dev
*dn_db
;
380 src
= dn_eth2dn(msg
->id
);
382 neigh
= __neigh_lookup(&dn_neigh_table
, &src
, skb
->dev
, 1);
384 dn
= (struct dn_neigh
*)neigh
;
387 write_lock(&neigh
->lock
);
389 neigh
->used
= jiffies
;
390 dn_db
= (struct dn_dev
*)neigh
->dev
->dn_ptr
;
392 if (!(neigh
->nud_state
& NUD_PERMANENT
)) {
393 neigh
->updated
= jiffies
;
395 if (neigh
->dev
->type
== ARPHRD_ETHER
)
396 memcpy(neigh
->ha
, ð_hdr(skb
)->h_source
, ETH_ALEN
);
398 dn
->blksize
= le16_to_cpu(msg
->blksize
);
399 dn
->priority
= msg
->priority
;
401 dn
->flags
&= ~DN_NDFLAG_P3
;
403 switch(msg
->iinfo
& DN_RT_INFO_TYPE
) {
404 case DN_RT_INFO_L1RT
:
405 dn
->flags
&=~DN_NDFLAG_R2
;
406 dn
->flags
|= DN_NDFLAG_R1
;
408 case DN_RT_INFO_L2RT
:
409 dn
->flags
|= DN_NDFLAG_R2
;
413 /* Only use routers in our area */
414 if ((le16_to_cpu(src
)>>10) == (le16_to_cpu((decnet_address
))>>10)) {
415 if (!dn_db
->router
) {
416 dn_db
->router
= neigh_clone(neigh
);
418 if (msg
->priority
> ((struct dn_neigh
*)dn_db
->router
)->priority
)
419 neigh_release(xchg(&dn_db
->router
, neigh_clone(neigh
)));
422 write_unlock(&neigh
->lock
);
423 neigh_release(neigh
);
431 * Endnode hello message received
433 int dn_neigh_endnode_hello(struct sk_buff
*skb
)
435 struct endnode_hello_message
*msg
= (struct endnode_hello_message
*)skb
->data
;
436 struct neighbour
*neigh
;
440 src
= dn_eth2dn(msg
->id
);
442 neigh
= __neigh_lookup(&dn_neigh_table
, &src
, skb
->dev
, 1);
444 dn
= (struct dn_neigh
*)neigh
;
447 write_lock(&neigh
->lock
);
449 neigh
->used
= jiffies
;
451 if (!(neigh
->nud_state
& NUD_PERMANENT
)) {
452 neigh
->updated
= jiffies
;
454 if (neigh
->dev
->type
== ARPHRD_ETHER
)
455 memcpy(neigh
->ha
, ð_hdr(skb
)->h_source
, ETH_ALEN
);
456 dn
->flags
&= ~(DN_NDFLAG_R1
| DN_NDFLAG_R2
);
457 dn
->blksize
= le16_to_cpu(msg
->blksize
);
461 write_unlock(&neigh
->lock
);
462 neigh_release(neigh
);
469 static char *dn_find_slot(char *base
, int max
, int priority
)
472 unsigned char *min
= NULL
;
474 base
+= 6; /* skip first id */
476 for(i
= 0; i
< max
; i
++) {
477 if (!min
|| (*base
< *min
))
479 base
+= 7; /* find next priority */
485 return (*min
< priority
) ? (min
- 6) : NULL
;
488 struct elist_cb_state
{
489 struct net_device
*dev
;
495 static void neigh_elist_cb(struct neighbour
*neigh
, void *_info
)
497 struct elist_cb_state
*s
= _info
;
500 if (neigh
->dev
!= s
->dev
)
503 dn
= (struct dn_neigh
*) neigh
;
504 if (!(dn
->flags
& (DN_NDFLAG_R1
|DN_NDFLAG_R2
)))
508 s
->rs
= dn_find_slot(s
->ptr
, s
->n
, dn
->priority
);
514 dn_dn2eth(s
->rs
, dn
->addr
);
516 *(s
->rs
) = neigh
->nud_state
& NUD_CONNECTED
? 0x80 : 0x0;
517 *(s
->rs
) |= dn
->priority
;
521 int dn_neigh_elist(struct net_device
*dev
, unsigned char *ptr
, int n
)
523 struct elist_cb_state state
;
531 neigh_for_each(&dn_neigh_table
, neigh_elist_cb
, &state
);
537 #ifdef CONFIG_PROC_FS
539 static inline void dn_neigh_format_entry(struct seq_file
*seq
,
542 struct dn_neigh
*dn
= (struct dn_neigh
*) n
;
543 char buf
[DN_ASCBUF_LEN
];
546 seq_printf(seq
, "%-7s %s%s%s %02x %02d %07ld %-8s\n",
547 dn_addr2asc(le16_to_cpu(dn
->addr
), buf
),
548 (dn
->flags
&DN_NDFLAG_R1
) ? "1" : "-",
549 (dn
->flags
&DN_NDFLAG_R2
) ? "2" : "-",
550 (dn
->flags
&DN_NDFLAG_P3
) ? "3" : "-",
552 atomic_read(&dn
->n
.refcnt
),
554 (dn
->n
.dev
) ? dn
->n
.dev
->name
: "?");
555 read_unlock(&n
->lock
);
558 static int dn_neigh_seq_show(struct seq_file
*seq
, void *v
)
560 if (v
== SEQ_START_TOKEN
) {
561 seq_puts(seq
, "Addr Flags State Use Blksize Dev\n");
563 dn_neigh_format_entry(seq
, v
);
569 static void *dn_neigh_seq_start(struct seq_file
*seq
, loff_t
*pos
)
571 return neigh_seq_start(seq
, pos
, &dn_neigh_table
,
572 NEIGH_SEQ_NEIGH_ONLY
);
575 static const struct seq_operations dn_neigh_seq_ops
= {
576 .start
= dn_neigh_seq_start
,
577 .next
= neigh_seq_next
,
578 .stop
= neigh_seq_stop
,
579 .show
= dn_neigh_seq_show
,
582 static int dn_neigh_seq_open(struct inode
*inode
, struct file
*file
)
584 return seq_open_net(inode
, file
, &dn_neigh_seq_ops
,
585 sizeof(struct neigh_seq_state
));
588 static const struct file_operations dn_neigh_seq_fops
= {
589 .owner
= THIS_MODULE
,
590 .open
= dn_neigh_seq_open
,
593 .release
= seq_release_net
,
598 void __init
dn_neigh_init(void)
600 neigh_table_init(&dn_neigh_table
);
601 proc_net_fops_create(&init_net
, "decnet_neigh", S_IRUGO
, &dn_neigh_seq_fops
);
604 void __exit
dn_neigh_cleanup(void)
606 proc_net_remove(&init_net
, "decnet_neigh");
607 neigh_table_clear(&dn_neigh_table
);