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 static bool dn_key_eq(const struct neighbour
*neigh
, const void *pkey
)
98 return neigh_key_eq16(neigh
, pkey
);
101 struct neigh_table dn_neigh_table
= {
103 .entry_size
= NEIGH_ENTRY_SIZE(sizeof(struct dn_neigh
)),
104 .key_len
= sizeof(__le16
),
105 .protocol
= cpu_to_be16(ETH_P_DNA_RT
),
106 .hash
= dn_neigh_hash
,
108 .constructor
= dn_neigh_construct
,
109 .id
= "dn_neigh_cache",
111 .tbl
= &dn_neigh_table
,
112 .reachable_time
= 30 * HZ
,
114 [NEIGH_VAR_MCAST_PROBES
] = 0,
115 [NEIGH_VAR_UCAST_PROBES
] = 0,
116 [NEIGH_VAR_APP_PROBES
] = 0,
117 [NEIGH_VAR_RETRANS_TIME
] = 1 * HZ
,
118 [NEIGH_VAR_BASE_REACHABLE_TIME
] = 30 * HZ
,
119 [NEIGH_VAR_DELAY_PROBE_TIME
] = 5 * HZ
,
120 [NEIGH_VAR_GC_STALETIME
] = 60 * HZ
,
121 [NEIGH_VAR_QUEUE_LEN_BYTES
] = 64*1024,
122 [NEIGH_VAR_PROXY_QLEN
] = 0,
123 [NEIGH_VAR_ANYCAST_DELAY
] = 0,
124 [NEIGH_VAR_PROXY_DELAY
] = 0,
125 [NEIGH_VAR_LOCKTIME
] = 1 * HZ
,
128 .gc_interval
= 30 * HZ
,
134 static int dn_neigh_construct(struct neighbour
*neigh
)
136 struct net_device
*dev
= neigh
->dev
;
137 struct dn_neigh
*dn
= (struct dn_neigh
*)neigh
;
138 struct dn_dev
*dn_db
;
139 struct neigh_parms
*parms
;
142 dn_db
= rcu_dereference(dev
->dn_ptr
);
148 parms
= dn_db
->neigh_parms
;
154 __neigh_parms_put(neigh
->parms
);
155 neigh
->parms
= neigh_parms_clone(parms
);
158 neigh
->ops
= &dn_long_ops
;
160 neigh
->ops
= &dn_short_ops
;
163 if (dn
->flags
& DN_NDFLAG_P3
)
164 neigh
->ops
= &dn_phase3_ops
;
166 neigh
->nud_state
= NUD_NOARP
;
167 neigh
->output
= neigh
->ops
->connected_output
;
169 if ((dev
->type
== ARPHRD_IPGRE
) || (dev
->flags
& IFF_POINTOPOINT
))
170 memcpy(neigh
->ha
, dev
->broadcast
, dev
->addr_len
);
171 else if ((dev
->type
== ARPHRD_ETHER
) || (dev
->type
== ARPHRD_LOOPBACK
))
172 dn_dn2eth(neigh
->ha
, dn
->addr
);
174 net_dbg_ratelimited("Trying to create neigh for hw %d\n",
180 * Make an estimate of the remote block size by assuming that its
181 * two less then the device mtu, which it true for ethernet (and
182 * other things which support long format headers) since there is
183 * an extra length field (of 16 bits) which isn't part of the
184 * ethernet headers and which the DECnet specs won't admit is part
185 * of the DECnet routing headers either.
187 * If we over estimate here its no big deal, the NSP negotiations
188 * will prevent us from sending packets which are too large for the
189 * remote node to handle. In any case this figure is normally updated
190 * by a hello message in most cases.
192 dn
->blksize
= dev
->mtu
- 2;
197 static void dn_long_error_report(struct neighbour
*neigh
, struct sk_buff
*skb
)
199 printk(KERN_DEBUG
"dn_long_error_report: called\n");
204 static void dn_short_error_report(struct neighbour
*neigh
, struct sk_buff
*skb
)
206 printk(KERN_DEBUG
"dn_short_error_report: called\n");
210 static int dn_neigh_output_packet(struct sk_buff
*skb
)
212 struct dst_entry
*dst
= skb_dst(skb
);
213 struct dn_route
*rt
= (struct dn_route
*)dst
;
214 struct neighbour
*neigh
= rt
->n
;
215 struct net_device
*dev
= neigh
->dev
;
216 char mac_addr
[ETH_ALEN
];
220 dn_dn2eth(mac_addr
, rt
->rt_local_src
);
222 seq
= read_seqbegin(&neigh
->ha_lock
);
223 err
= dev_hard_header(skb
, dev
, ntohs(skb
->protocol
),
224 neigh
->ha
, mac_addr
, skb
->len
);
225 } while (read_seqretry(&neigh
->ha_lock
, seq
));
228 err
= dev_queue_xmit(skb
);
236 static int dn_long_output(struct neighbour
*neigh
, struct sk_buff
*skb
)
238 struct net_device
*dev
= neigh
->dev
;
239 int headroom
= dev
->hard_header_len
+ sizeof(struct dn_long_packet
) + 3;
241 struct dn_long_packet
*lp
;
242 struct dn_skb_cb
*cb
= DN_SKB_CB(skb
);
245 if (skb_headroom(skb
) < headroom
) {
246 struct sk_buff
*skb2
= skb_realloc_headroom(skb
, headroom
);
248 net_crit_ratelimited("dn_long_output: no memory\n");
254 net_info_ratelimited("dn_long_output: Increasing headroom\n");
257 data
= skb_push(skb
, sizeof(struct dn_long_packet
) + 3);
258 lp
= (struct dn_long_packet
*)(data
+3);
260 *((__le16
*)data
) = cpu_to_le16(skb
->len
- 2);
261 *(data
+ 2) = 1 | DN_RT_F_PF
; /* Padding */
263 lp
->msgflg
= DN_RT_PKT_LONG
|(cb
->rt_flags
&(DN_RT_F_IE
|DN_RT_F_RQR
|DN_RT_F_RTS
));
264 lp
->d_area
= lp
->d_subarea
= 0;
265 dn_dn2eth(lp
->d_id
, cb
->dst
);
266 lp
->s_area
= lp
->s_subarea
= 0;
267 dn_dn2eth(lp
->s_id
, cb
->src
);
269 lp
->visit_ct
= cb
->hops
& 0x3f;
273 skb_reset_network_header(skb
);
275 return NF_HOOK(NFPROTO_DECNET
, NF_DN_POST_ROUTING
, skb
, NULL
,
276 neigh
->dev
, dn_neigh_output_packet
);
279 static int dn_short_output(struct neighbour
*neigh
, struct sk_buff
*skb
)
281 struct net_device
*dev
= neigh
->dev
;
282 int headroom
= dev
->hard_header_len
+ sizeof(struct dn_short_packet
) + 2;
283 struct dn_short_packet
*sp
;
285 struct dn_skb_cb
*cb
= DN_SKB_CB(skb
);
288 if (skb_headroom(skb
) < headroom
) {
289 struct sk_buff
*skb2
= skb_realloc_headroom(skb
, headroom
);
291 net_crit_ratelimited("dn_short_output: no memory\n");
297 net_info_ratelimited("dn_short_output: Increasing headroom\n");
300 data
= skb_push(skb
, sizeof(struct dn_short_packet
) + 2);
301 *((__le16
*)data
) = cpu_to_le16(skb
->len
- 2);
302 sp
= (struct dn_short_packet
*)(data
+2);
304 sp
->msgflg
= DN_RT_PKT_SHORT
|(cb
->rt_flags
&(DN_RT_F_RQR
|DN_RT_F_RTS
));
305 sp
->dstnode
= cb
->dst
;
306 sp
->srcnode
= cb
->src
;
307 sp
->forward
= cb
->hops
& 0x3f;
309 skb_reset_network_header(skb
);
311 return NF_HOOK(NFPROTO_DECNET
, NF_DN_POST_ROUTING
, skb
, NULL
,
312 neigh
->dev
, dn_neigh_output_packet
);
316 * Phase 3 output is the same is short output, execpt that
317 * it clears the area bits before transmission.
319 static int dn_phase3_output(struct neighbour
*neigh
, struct sk_buff
*skb
)
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
;
325 struct dn_skb_cb
*cb
= DN_SKB_CB(skb
);
327 if (skb_headroom(skb
) < headroom
) {
328 struct sk_buff
*skb2
= skb_realloc_headroom(skb
, headroom
);
330 net_crit_ratelimited("dn_phase3_output: no memory\n");
336 net_info_ratelimited("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(NFPROTO_DECNET
, NF_DN_POST_ROUTING
, skb
, NULL
,
351 neigh
->dev
, dn_neigh_output_packet
);
355 * Unfortunately, the neighbour code uses the device in its hash
356 * function, so we don't get any advantage from it. This function
357 * basically does a neigh_lookup(), but without comparing the device
358 * field. This is required for the On-Ethernet cache
362 * Pointopoint link receives a hello message
364 void dn_neigh_pointopoint_hello(struct sk_buff
*skb
)
370 * Ethernet router hello message received
372 int dn_neigh_router_hello(struct sk_buff
*skb
)
374 struct rtnode_hello_message
*msg
= (struct rtnode_hello_message
*)skb
->data
;
376 struct neighbour
*neigh
;
378 struct dn_dev
*dn_db
;
381 src
= dn_eth2dn(msg
->id
);
383 neigh
= __neigh_lookup(&dn_neigh_table
, &src
, skb
->dev
, 1);
385 dn
= (struct dn_neigh
*)neigh
;
388 write_lock(&neigh
->lock
);
390 neigh
->used
= jiffies
;
391 dn_db
= rcu_dereference(neigh
->dev
->dn_ptr
);
393 if (!(neigh
->nud_state
& NUD_PERMANENT
)) {
394 neigh
->updated
= jiffies
;
396 if (neigh
->dev
->type
== ARPHRD_ETHER
)
397 memcpy(neigh
->ha
, ð_hdr(skb
)->h_source
, ETH_ALEN
);
399 dn
->blksize
= le16_to_cpu(msg
->blksize
);
400 dn
->priority
= msg
->priority
;
402 dn
->flags
&= ~DN_NDFLAG_P3
;
404 switch (msg
->iinfo
& DN_RT_INFO_TYPE
) {
405 case DN_RT_INFO_L1RT
:
406 dn
->flags
&=~DN_NDFLAG_R2
;
407 dn
->flags
|= DN_NDFLAG_R1
;
409 case DN_RT_INFO_L2RT
:
410 dn
->flags
|= DN_NDFLAG_R2
;
414 /* Only use routers in our area */
415 if ((le16_to_cpu(src
)>>10) == (le16_to_cpu((decnet_address
))>>10)) {
416 if (!dn_db
->router
) {
417 dn_db
->router
= neigh_clone(neigh
);
419 if (msg
->priority
> ((struct dn_neigh
*)dn_db
->router
)->priority
)
420 neigh_release(xchg(&dn_db
->router
, neigh_clone(neigh
)));
423 write_unlock(&neigh
->lock
);
424 neigh_release(neigh
);
432 * Endnode hello message received
434 int dn_neigh_endnode_hello(struct sk_buff
*skb
)
436 struct endnode_hello_message
*msg
= (struct endnode_hello_message
*)skb
->data
;
437 struct neighbour
*neigh
;
441 src
= dn_eth2dn(msg
->id
);
443 neigh
= __neigh_lookup(&dn_neigh_table
, &src
, skb
->dev
, 1);
445 dn
= (struct dn_neigh
*)neigh
;
448 write_lock(&neigh
->lock
);
450 neigh
->used
= jiffies
;
452 if (!(neigh
->nud_state
& NUD_PERMANENT
)) {
453 neigh
->updated
= jiffies
;
455 if (neigh
->dev
->type
== ARPHRD_ETHER
)
456 memcpy(neigh
->ha
, ð_hdr(skb
)->h_source
, ETH_ALEN
);
457 dn
->flags
&= ~(DN_NDFLAG_R1
| DN_NDFLAG_R2
);
458 dn
->blksize
= le16_to_cpu(msg
->blksize
);
462 write_unlock(&neigh
->lock
);
463 neigh_release(neigh
);
470 static char *dn_find_slot(char *base
, int max
, int priority
)
473 unsigned char *min
= NULL
;
475 base
+= 6; /* skip first id */
477 for(i
= 0; i
< max
; i
++) {
478 if (!min
|| (*base
< *min
))
480 base
+= 7; /* find next priority */
486 return (*min
< priority
) ? (min
- 6) : NULL
;
489 struct elist_cb_state
{
490 struct net_device
*dev
;
496 static void neigh_elist_cb(struct neighbour
*neigh
, void *_info
)
498 struct elist_cb_state
*s
= _info
;
501 if (neigh
->dev
!= s
->dev
)
504 dn
= (struct dn_neigh
*) neigh
;
505 if (!(dn
->flags
& (DN_NDFLAG_R1
|DN_NDFLAG_R2
)))
509 s
->rs
= dn_find_slot(s
->ptr
, s
->n
, dn
->priority
);
515 dn_dn2eth(s
->rs
, dn
->addr
);
517 *(s
->rs
) = neigh
->nud_state
& NUD_CONNECTED
? 0x80 : 0x0;
518 *(s
->rs
) |= dn
->priority
;
522 int dn_neigh_elist(struct net_device
*dev
, unsigned char *ptr
, int n
)
524 struct elist_cb_state state
;
532 neigh_for_each(&dn_neigh_table
, neigh_elist_cb
, &state
);
538 #ifdef CONFIG_PROC_FS
540 static inline void dn_neigh_format_entry(struct seq_file
*seq
,
543 struct dn_neigh
*dn
= (struct dn_neigh
*) n
;
544 char buf
[DN_ASCBUF_LEN
];
547 seq_printf(seq
, "%-7s %s%s%s %02x %02d %07ld %-8s\n",
548 dn_addr2asc(le16_to_cpu(dn
->addr
), buf
),
549 (dn
->flags
&DN_NDFLAG_R1
) ? "1" : "-",
550 (dn
->flags
&DN_NDFLAG_R2
) ? "2" : "-",
551 (dn
->flags
&DN_NDFLAG_P3
) ? "3" : "-",
553 atomic_read(&dn
->n
.refcnt
),
555 (dn
->n
.dev
) ? dn
->n
.dev
->name
: "?");
556 read_unlock(&n
->lock
);
559 static int dn_neigh_seq_show(struct seq_file
*seq
, void *v
)
561 if (v
== SEQ_START_TOKEN
) {
562 seq_puts(seq
, "Addr Flags State Use Blksize Dev\n");
564 dn_neigh_format_entry(seq
, v
);
570 static void *dn_neigh_seq_start(struct seq_file
*seq
, loff_t
*pos
)
572 return neigh_seq_start(seq
, pos
, &dn_neigh_table
,
573 NEIGH_SEQ_NEIGH_ONLY
);
576 static const struct seq_operations dn_neigh_seq_ops
= {
577 .start
= dn_neigh_seq_start
,
578 .next
= neigh_seq_next
,
579 .stop
= neigh_seq_stop
,
580 .show
= dn_neigh_seq_show
,
583 static int dn_neigh_seq_open(struct inode
*inode
, struct file
*file
)
585 return seq_open_net(inode
, file
, &dn_neigh_seq_ops
,
586 sizeof(struct neigh_seq_state
));
589 static const struct file_operations dn_neigh_seq_fops
= {
590 .owner
= THIS_MODULE
,
591 .open
= dn_neigh_seq_open
,
594 .release
= seq_release_net
,
599 void __init
dn_neigh_init(void)
601 neigh_table_init(NEIGH_DN_TABLE
, &dn_neigh_table
);
602 proc_create("decnet_neigh", S_IRUGO
, init_net
.proc_net
,
606 void __exit
dn_neigh_cleanup(void)
608 remove_proc_entry("decnet_neigh", init_net
.proc_net
);
609 neigh_table_clear(NEIGH_DN_TABLE
, &dn_neigh_table
);