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 <linux/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 int dn_neigh_construct(struct neighbour
*);
52 static void dn_long_error_report(struct neighbour
*, struct sk_buff
*);
53 static void dn_short_error_report(struct neighbour
*, struct sk_buff
*);
54 static int dn_long_output(struct neighbour
*, struct sk_buff
*);
55 static int dn_short_output(struct neighbour
*, struct sk_buff
*);
56 static int dn_phase3_output(struct neighbour
*, struct sk_buff
*);
60 * For talking to broadcast devices: Ethernet & PPP
62 static const struct neigh_ops dn_long_ops
= {
64 .error_report
= dn_long_error_report
,
65 .output
= dn_long_output
,
66 .connected_output
= dn_long_output
,
70 * For talking to pointopoint and multidrop devices: DDCMP and X.25
72 static const struct neigh_ops dn_short_ops
= {
74 .error_report
= dn_short_error_report
,
75 .output
= dn_short_output
,
76 .connected_output
= dn_short_output
,
80 * For talking to DECnet phase III nodes
82 static const struct neigh_ops dn_phase3_ops
= {
84 .error_report
= dn_short_error_report
, /* Can use short version here */
85 .output
= dn_phase3_output
,
86 .connected_output
= dn_phase3_output
,
89 static u32
dn_neigh_hash(const void *pkey
,
90 const struct net_device
*dev
,
93 return jhash_2words(*(__u16
*)pkey
, 0, hash_rnd
[0]);
96 struct neigh_table dn_neigh_table
= {
98 .entry_size
= NEIGH_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 .reachable_time
= 30 * HZ
,
107 [NEIGH_VAR_MCAST_PROBES
] = 0,
108 [NEIGH_VAR_UCAST_PROBES
] = 0,
109 [NEIGH_VAR_APP_PROBES
] = 0,
110 [NEIGH_VAR_RETRANS_TIME
] = 1 * HZ
,
111 [NEIGH_VAR_BASE_REACHABLE_TIME
] = 30 * HZ
,
112 [NEIGH_VAR_DELAY_PROBE_TIME
] = 5 * HZ
,
113 [NEIGH_VAR_GC_STALETIME
] = 60 * HZ
,
114 [NEIGH_VAR_QUEUE_LEN_BYTES
] = 64*1024,
115 [NEIGH_VAR_PROXY_QLEN
] = 0,
116 [NEIGH_VAR_ANYCAST_DELAY
] = 0,
117 [NEIGH_VAR_PROXY_DELAY
] = 0,
118 [NEIGH_VAR_LOCKTIME
] = 1 * HZ
,
121 .gc_interval
= 30 * HZ
,
127 static int dn_neigh_construct(struct neighbour
*neigh
)
129 struct net_device
*dev
= neigh
->dev
;
130 struct dn_neigh
*dn
= (struct dn_neigh
*)neigh
;
131 struct dn_dev
*dn_db
;
132 struct neigh_parms
*parms
;
135 dn_db
= rcu_dereference(dev
->dn_ptr
);
141 parms
= dn_db
->neigh_parms
;
147 __neigh_parms_put(neigh
->parms
);
148 neigh
->parms
= neigh_parms_clone(parms
);
151 neigh
->ops
= &dn_long_ops
;
153 neigh
->ops
= &dn_short_ops
;
156 if (dn
->flags
& DN_NDFLAG_P3
)
157 neigh
->ops
= &dn_phase3_ops
;
159 neigh
->nud_state
= NUD_NOARP
;
160 neigh
->output
= neigh
->ops
->connected_output
;
162 if ((dev
->type
== ARPHRD_IPGRE
) || (dev
->flags
& IFF_POINTOPOINT
))
163 memcpy(neigh
->ha
, dev
->broadcast
, dev
->addr_len
);
164 else if ((dev
->type
== ARPHRD_ETHER
) || (dev
->type
== ARPHRD_LOOPBACK
))
165 dn_dn2eth(neigh
->ha
, dn
->addr
);
167 net_dbg_ratelimited("Trying to create neigh for hw %d\n",
173 * Make an estimate of the remote block size by assuming that its
174 * two less then the device mtu, which it true for ethernet (and
175 * other things which support long format headers) since there is
176 * an extra length field (of 16 bits) which isn't part of the
177 * ethernet headers and which the DECnet specs won't admit is part
178 * of the DECnet routing headers either.
180 * If we over estimate here its no big deal, the NSP negotiations
181 * will prevent us from sending packets which are too large for the
182 * remote node to handle. In any case this figure is normally updated
183 * by a hello message in most cases.
185 dn
->blksize
= dev
->mtu
- 2;
190 static void dn_long_error_report(struct neighbour
*neigh
, struct sk_buff
*skb
)
192 printk(KERN_DEBUG
"dn_long_error_report: called\n");
197 static void dn_short_error_report(struct neighbour
*neigh
, struct sk_buff
*skb
)
199 printk(KERN_DEBUG
"dn_short_error_report: called\n");
203 static int dn_neigh_output_packet(struct sk_buff
*skb
)
205 struct dst_entry
*dst
= skb_dst(skb
);
206 struct dn_route
*rt
= (struct dn_route
*)dst
;
207 struct neighbour
*neigh
= rt
->n
;
208 struct net_device
*dev
= neigh
->dev
;
209 char mac_addr
[ETH_ALEN
];
213 dn_dn2eth(mac_addr
, rt
->rt_local_src
);
215 seq
= read_seqbegin(&neigh
->ha_lock
);
216 err
= dev_hard_header(skb
, dev
, ntohs(skb
->protocol
),
217 neigh
->ha
, mac_addr
, skb
->len
);
218 } while (read_seqretry(&neigh
->ha_lock
, seq
));
221 err
= dev_queue_xmit(skb
);
229 static int dn_long_output(struct neighbour
*neigh
, struct sk_buff
*skb
)
231 struct net_device
*dev
= neigh
->dev
;
232 int headroom
= dev
->hard_header_len
+ sizeof(struct dn_long_packet
) + 3;
234 struct dn_long_packet
*lp
;
235 struct dn_skb_cb
*cb
= DN_SKB_CB(skb
);
238 if (skb_headroom(skb
) < headroom
) {
239 struct sk_buff
*skb2
= skb_realloc_headroom(skb
, headroom
);
241 net_crit_ratelimited("dn_long_output: no memory\n");
247 net_info_ratelimited("dn_long_output: Increasing headroom\n");
250 data
= skb_push(skb
, sizeof(struct dn_long_packet
) + 3);
251 lp
= (struct dn_long_packet
*)(data
+3);
253 *((__le16
*)data
) = cpu_to_le16(skb
->len
- 2);
254 *(data
+ 2) = 1 | DN_RT_F_PF
; /* Padding */
256 lp
->msgflg
= DN_RT_PKT_LONG
|(cb
->rt_flags
&(DN_RT_F_IE
|DN_RT_F_RQR
|DN_RT_F_RTS
));
257 lp
->d_area
= lp
->d_subarea
= 0;
258 dn_dn2eth(lp
->d_id
, cb
->dst
);
259 lp
->s_area
= lp
->s_subarea
= 0;
260 dn_dn2eth(lp
->s_id
, cb
->src
);
262 lp
->visit_ct
= cb
->hops
& 0x3f;
266 skb_reset_network_header(skb
);
268 return NF_HOOK(NFPROTO_DECNET
, NF_DN_POST_ROUTING
, skb
, NULL
,
269 neigh
->dev
, dn_neigh_output_packet
);
272 static int dn_short_output(struct neighbour
*neigh
, struct sk_buff
*skb
)
274 struct net_device
*dev
= neigh
->dev
;
275 int headroom
= dev
->hard_header_len
+ sizeof(struct dn_short_packet
) + 2;
276 struct dn_short_packet
*sp
;
278 struct dn_skb_cb
*cb
= DN_SKB_CB(skb
);
281 if (skb_headroom(skb
) < headroom
) {
282 struct sk_buff
*skb2
= skb_realloc_headroom(skb
, headroom
);
284 net_crit_ratelimited("dn_short_output: no memory\n");
290 net_info_ratelimited("dn_short_output: Increasing headroom\n");
293 data
= skb_push(skb
, sizeof(struct dn_short_packet
) + 2);
294 *((__le16
*)data
) = cpu_to_le16(skb
->len
- 2);
295 sp
= (struct dn_short_packet
*)(data
+2);
297 sp
->msgflg
= DN_RT_PKT_SHORT
|(cb
->rt_flags
&(DN_RT_F_RQR
|DN_RT_F_RTS
));
298 sp
->dstnode
= cb
->dst
;
299 sp
->srcnode
= cb
->src
;
300 sp
->forward
= cb
->hops
& 0x3f;
302 skb_reset_network_header(skb
);
304 return NF_HOOK(NFPROTO_DECNET
, NF_DN_POST_ROUTING
, skb
, NULL
,
305 neigh
->dev
, dn_neigh_output_packet
);
309 * Phase 3 output is the same is short output, execpt that
310 * it clears the area bits before transmission.
312 static int dn_phase3_output(struct neighbour
*neigh
, struct sk_buff
*skb
)
314 struct net_device
*dev
= neigh
->dev
;
315 int headroom
= dev
->hard_header_len
+ sizeof(struct dn_short_packet
) + 2;
316 struct dn_short_packet
*sp
;
318 struct dn_skb_cb
*cb
= DN_SKB_CB(skb
);
320 if (skb_headroom(skb
) < headroom
) {
321 struct sk_buff
*skb2
= skb_realloc_headroom(skb
, headroom
);
323 net_crit_ratelimited("dn_phase3_output: no memory\n");
329 net_info_ratelimited("dn_phase3_output: Increasing headroom\n");
332 data
= skb_push(skb
, sizeof(struct dn_short_packet
) + 2);
333 *((__le16
*)data
) = cpu_to_le16(skb
->len
- 2);
334 sp
= (struct dn_short_packet
*)(data
+ 2);
336 sp
->msgflg
= DN_RT_PKT_SHORT
|(cb
->rt_flags
&(DN_RT_F_RQR
|DN_RT_F_RTS
));
337 sp
->dstnode
= cb
->dst
& cpu_to_le16(0x03ff);
338 sp
->srcnode
= cb
->src
& cpu_to_le16(0x03ff);
339 sp
->forward
= cb
->hops
& 0x3f;
341 skb_reset_network_header(skb
);
343 return NF_HOOK(NFPROTO_DECNET
, NF_DN_POST_ROUTING
, skb
, NULL
,
344 neigh
->dev
, dn_neigh_output_packet
);
348 * Unfortunately, the neighbour code uses the device in its hash
349 * function, so we don't get any advantage from it. This function
350 * basically does a neigh_lookup(), but without comparing the device
351 * field. This is required for the On-Ethernet cache
355 * Pointopoint link receives a hello message
357 void dn_neigh_pointopoint_hello(struct sk_buff
*skb
)
363 * Ethernet router hello message received
365 int dn_neigh_router_hello(struct sk_buff
*skb
)
367 struct rtnode_hello_message
*msg
= (struct rtnode_hello_message
*)skb
->data
;
369 struct neighbour
*neigh
;
371 struct dn_dev
*dn_db
;
374 src
= dn_eth2dn(msg
->id
);
376 neigh
= __neigh_lookup(&dn_neigh_table
, &src
, skb
->dev
, 1);
378 dn
= (struct dn_neigh
*)neigh
;
381 write_lock(&neigh
->lock
);
383 neigh
->used
= jiffies
;
384 dn_db
= rcu_dereference(neigh
->dev
->dn_ptr
);
386 if (!(neigh
->nud_state
& NUD_PERMANENT
)) {
387 neigh
->updated
= jiffies
;
389 if (neigh
->dev
->type
== ARPHRD_ETHER
)
390 memcpy(neigh
->ha
, ð_hdr(skb
)->h_source
, ETH_ALEN
);
392 dn
->blksize
= le16_to_cpu(msg
->blksize
);
393 dn
->priority
= msg
->priority
;
395 dn
->flags
&= ~DN_NDFLAG_P3
;
397 switch (msg
->iinfo
& DN_RT_INFO_TYPE
) {
398 case DN_RT_INFO_L1RT
:
399 dn
->flags
&=~DN_NDFLAG_R2
;
400 dn
->flags
|= DN_NDFLAG_R1
;
402 case DN_RT_INFO_L2RT
:
403 dn
->flags
|= DN_NDFLAG_R2
;
407 /* Only use routers in our area */
408 if ((le16_to_cpu(src
)>>10) == (le16_to_cpu((decnet_address
))>>10)) {
409 if (!dn_db
->router
) {
410 dn_db
->router
= neigh_clone(neigh
);
412 if (msg
->priority
> ((struct dn_neigh
*)dn_db
->router
)->priority
)
413 neigh_release(xchg(&dn_db
->router
, neigh_clone(neigh
)));
416 write_unlock(&neigh
->lock
);
417 neigh_release(neigh
);
425 * Endnode hello message received
427 int dn_neigh_endnode_hello(struct sk_buff
*skb
)
429 struct endnode_hello_message
*msg
= (struct endnode_hello_message
*)skb
->data
;
430 struct neighbour
*neigh
;
434 src
= dn_eth2dn(msg
->id
);
436 neigh
= __neigh_lookup(&dn_neigh_table
, &src
, skb
->dev
, 1);
438 dn
= (struct dn_neigh
*)neigh
;
441 write_lock(&neigh
->lock
);
443 neigh
->used
= jiffies
;
445 if (!(neigh
->nud_state
& NUD_PERMANENT
)) {
446 neigh
->updated
= jiffies
;
448 if (neigh
->dev
->type
== ARPHRD_ETHER
)
449 memcpy(neigh
->ha
, ð_hdr(skb
)->h_source
, ETH_ALEN
);
450 dn
->flags
&= ~(DN_NDFLAG_R1
| DN_NDFLAG_R2
);
451 dn
->blksize
= le16_to_cpu(msg
->blksize
);
455 write_unlock(&neigh
->lock
);
456 neigh_release(neigh
);
463 static char *dn_find_slot(char *base
, int max
, int priority
)
466 unsigned char *min
= NULL
;
468 base
+= 6; /* skip first id */
470 for(i
= 0; i
< max
; i
++) {
471 if (!min
|| (*base
< *min
))
473 base
+= 7; /* find next priority */
479 return (*min
< priority
) ? (min
- 6) : NULL
;
482 struct elist_cb_state
{
483 struct net_device
*dev
;
489 static void neigh_elist_cb(struct neighbour
*neigh
, void *_info
)
491 struct elist_cb_state
*s
= _info
;
494 if (neigh
->dev
!= s
->dev
)
497 dn
= (struct dn_neigh
*) neigh
;
498 if (!(dn
->flags
& (DN_NDFLAG_R1
|DN_NDFLAG_R2
)))
502 s
->rs
= dn_find_slot(s
->ptr
, s
->n
, dn
->priority
);
508 dn_dn2eth(s
->rs
, dn
->addr
);
510 *(s
->rs
) = neigh
->nud_state
& NUD_CONNECTED
? 0x80 : 0x0;
511 *(s
->rs
) |= dn
->priority
;
515 int dn_neigh_elist(struct net_device
*dev
, unsigned char *ptr
, int n
)
517 struct elist_cb_state state
;
525 neigh_for_each(&dn_neigh_table
, neigh_elist_cb
, &state
);
531 #ifdef CONFIG_PROC_FS
533 static inline void dn_neigh_format_entry(struct seq_file
*seq
,
536 struct dn_neigh
*dn
= (struct dn_neigh
*) n
;
537 char buf
[DN_ASCBUF_LEN
];
540 seq_printf(seq
, "%-7s %s%s%s %02x %02d %07ld %-8s\n",
541 dn_addr2asc(le16_to_cpu(dn
->addr
), buf
),
542 (dn
->flags
&DN_NDFLAG_R1
) ? "1" : "-",
543 (dn
->flags
&DN_NDFLAG_R2
) ? "2" : "-",
544 (dn
->flags
&DN_NDFLAG_P3
) ? "3" : "-",
546 atomic_read(&dn
->n
.refcnt
),
548 (dn
->n
.dev
) ? dn
->n
.dev
->name
: "?");
549 read_unlock(&n
->lock
);
552 static int dn_neigh_seq_show(struct seq_file
*seq
, void *v
)
554 if (v
== SEQ_START_TOKEN
) {
555 seq_puts(seq
, "Addr Flags State Use Blksize Dev\n");
557 dn_neigh_format_entry(seq
, v
);
563 static void *dn_neigh_seq_start(struct seq_file
*seq
, loff_t
*pos
)
565 return neigh_seq_start(seq
, pos
, &dn_neigh_table
,
566 NEIGH_SEQ_NEIGH_ONLY
);
569 static const struct seq_operations dn_neigh_seq_ops
= {
570 .start
= dn_neigh_seq_start
,
571 .next
= neigh_seq_next
,
572 .stop
= neigh_seq_stop
,
573 .show
= dn_neigh_seq_show
,
576 static int dn_neigh_seq_open(struct inode
*inode
, struct file
*file
)
578 return seq_open_net(inode
, file
, &dn_neigh_seq_ops
,
579 sizeof(struct neigh_seq_state
));
582 static const struct file_operations dn_neigh_seq_fops
= {
583 .owner
= THIS_MODULE
,
584 .open
= dn_neigh_seq_open
,
587 .release
= seq_release_net
,
592 void __init
dn_neigh_init(void)
594 neigh_table_init(&dn_neigh_table
);
595 proc_create("decnet_neigh", S_IRUGO
, init_net
.proc_net
,
599 void __exit
dn_neigh_cleanup(void)
601 remove_proc_entry("decnet_neigh", init_net
.proc_net
);
602 neigh_table_clear(&dn_neigh_table
);