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.
8 * Authors: Steve Whitehouse <SteveW@ACM.org>
9 * Eduardo Marcelo Serrat <emserrat@geocities.com>
12 * Steve Whitehouse : Devices now see incoming frames so they
13 * can mark on who it came from.
14 * Steve Whitehouse : Fixed bug in creating neighbours. Each neighbour
15 * can now have a device specific setup func.
16 * Steve Whitehouse : Added /proc/sys/net/decnet/conf/<dev>/
17 * Steve Whitehouse : Fixed bug which sometimes killed timer
18 * Steve Whitehouse : Multiple ifaddr support
19 * Steve Whitehouse : SIOCGIFCONF is now a compile time option
20 * Steve Whitehouse : /proc/sys/net/decnet/conf/<sys>/forwarding
21 * Steve Whitehouse : Removed timer1 - it's a user space issue now
22 * Patrick Caulfield : Fixed router hello message format
23 * Steve Whitehouse : Got rid of constant sizes for blksize for
24 * devices. All mtu based now.
27 #include <linux/capability.h>
28 #include <linux/module.h>
29 #include <linux/moduleparam.h>
30 #include <linux/init.h>
31 #include <linux/net.h>
32 #include <linux/netdevice.h>
33 #include <linux/proc_fs.h>
34 #include <linux/seq_file.h>
35 #include <linux/timer.h>
36 #include <linux/string.h>
37 #include <linux/if_addr.h>
38 #include <linux/if_arp.h>
39 #include <linux/if_ether.h>
40 #include <linux/skbuff.h>
41 #include <linux/sysctl.h>
42 #include <linux/notifier.h>
43 #include <linux/slab.h>
44 #include <asm/uaccess.h>
45 #include <asm/system.h>
46 #include <net/net_namespace.h>
47 #include <net/neighbour.h>
50 #include <net/fib_rules.h>
51 #include <net/netlink.h>
53 #include <net/dn_dev.h>
54 #include <net/dn_route.h>
55 #include <net/dn_neigh.h>
56 #include <net/dn_fib.h>
58 #define DN_IFREQ_SIZE (sizeof(struct ifreq) - sizeof(struct sockaddr) + sizeof(struct sockaddr_dn))
60 static char dn_rt_all_end_mcast
[ETH_ALEN
] = {0xAB,0x00,0x00,0x04,0x00,0x00};
61 static char dn_rt_all_rt_mcast
[ETH_ALEN
] = {0xAB,0x00,0x00,0x03,0x00,0x00};
62 static char dn_hiord
[ETH_ALEN
] = {0xAA,0x00,0x04,0x00,0x00,0x00};
63 static unsigned char dn_eco_version
[3] = {0x02,0x00,0x00};
65 extern struct neigh_table dn_neigh_table
;
68 * decnet_address is kept in network order.
70 __le16 decnet_address
= 0;
72 static DEFINE_SPINLOCK(dndev_lock
);
73 static struct net_device
*decnet_default_device
;
74 static BLOCKING_NOTIFIER_HEAD(dnaddr_chain
);
76 static struct dn_dev
*dn_dev_create(struct net_device
*dev
, int *err
);
77 static void dn_dev_delete(struct net_device
*dev
);
78 static void dn_ifaddr_notify(int event
, struct dn_ifaddr
*ifa
);
80 static int dn_eth_up(struct net_device
*);
81 static void dn_eth_down(struct net_device
*);
82 static void dn_send_brd_hello(struct net_device
*dev
, struct dn_ifaddr
*ifa
);
83 static void dn_send_ptp_hello(struct net_device
*dev
, struct dn_ifaddr
*ifa
);
85 static struct dn_dev_parms dn_dev_list
[] = {
87 .type
= ARPHRD_ETHER
, /* Ethernet */
95 .timer3
= dn_send_brd_hello
,
98 .type
= ARPHRD_IPGRE
, /* DECnet tunneled over GRE in IP */
100 .state
= DN_DEV_S_RU
,
104 .timer3
= dn_send_brd_hello
,
108 .type
= ARPHRD_X25
, /* Bog standard X.25 */
109 .mode
= DN_DEV_UCAST
,
110 .state
= DN_DEV_S_DS
,
114 .timer3
= dn_send_ptp_hello
,
119 .type
= ARPHRD_PPP
, /* DECnet over PPP */
120 .mode
= DN_DEV_BCAST
,
121 .state
= DN_DEV_S_RU
,
125 .timer3
= dn_send_brd_hello
,
129 .type
= ARPHRD_DDCMP
, /* DECnet over DDCMP */
130 .mode
= DN_DEV_UCAST
,
131 .state
= DN_DEV_S_DS
,
135 .timer3
= dn_send_ptp_hello
,
138 .type
= ARPHRD_LOOPBACK
, /* Loopback interface - always last */
139 .mode
= DN_DEV_BCAST
,
140 .state
= DN_DEV_S_RU
,
144 .timer3
= dn_send_brd_hello
,
148 #define DN_DEV_LIST_SIZE ARRAY_SIZE(dn_dev_list)
150 #define DN_DEV_PARMS_OFFSET(x) offsetof(struct dn_dev_parms, x)
154 static int min_t2
[] = { 1 };
155 static int max_t2
[] = { 60 }; /* No max specified, but this seems sensible */
156 static int min_t3
[] = { 1 };
157 static int max_t3
[] = { 8191 }; /* Must fit in 16 bits when multiplied by BCT3MULT or T3MULT */
159 static int min_priority
[1];
160 static int max_priority
[] = { 127 }; /* From DECnet spec */
162 static int dn_forwarding_proc(ctl_table
*, int,
163 void __user
*, size_t *, loff_t
*);
164 static struct dn_dev_sysctl_table
{
165 struct ctl_table_header
*sysctl_header
;
166 ctl_table dn_dev_vars
[5];
171 .procname
= "forwarding",
172 .data
= (void *)DN_DEV_PARMS_OFFSET(forwarding
),
173 .maxlen
= sizeof(int),
175 .proc_handler
= dn_forwarding_proc
,
178 .procname
= "priority",
179 .data
= (void *)DN_DEV_PARMS_OFFSET(priority
),
180 .maxlen
= sizeof(int),
182 .proc_handler
= proc_dointvec_minmax
,
183 .extra1
= &min_priority
,
184 .extra2
= &max_priority
188 .data
= (void *)DN_DEV_PARMS_OFFSET(t2
),
189 .maxlen
= sizeof(int),
191 .proc_handler
= proc_dointvec_minmax
,
197 .data
= (void *)DN_DEV_PARMS_OFFSET(t3
),
198 .maxlen
= sizeof(int),
200 .proc_handler
= proc_dointvec_minmax
,
208 static void dn_dev_sysctl_register(struct net_device
*dev
, struct dn_dev_parms
*parms
)
210 struct dn_dev_sysctl_table
*t
;
213 #define DN_CTL_PATH_DEV 3
215 struct ctl_path dn_ctl_path
[] = {
216 { .procname
= "net", },
217 { .procname
= "decnet", },
218 { .procname
= "conf", },
223 t
= kmemdup(&dn_dev_sysctl
, sizeof(*t
), GFP_KERNEL
);
227 for(i
= 0; i
< ARRAY_SIZE(t
->dn_dev_vars
) - 1; i
++) {
228 long offset
= (long)t
->dn_dev_vars
[i
].data
;
229 t
->dn_dev_vars
[i
].data
= ((char *)parms
) + offset
;
233 dn_ctl_path
[DN_CTL_PATH_DEV
].procname
= dev
->name
;
235 dn_ctl_path
[DN_CTL_PATH_DEV
].procname
= parms
->name
;
238 t
->dn_dev_vars
[0].extra1
= (void *)dev
;
240 t
->sysctl_header
= register_sysctl_paths(dn_ctl_path
, t
->dn_dev_vars
);
241 if (t
->sysctl_header
== NULL
)
247 static void dn_dev_sysctl_unregister(struct dn_dev_parms
*parms
)
250 struct dn_dev_sysctl_table
*t
= parms
->sysctl
;
251 parms
->sysctl
= NULL
;
252 unregister_sysctl_table(t
->sysctl_header
);
257 static int dn_forwarding_proc(ctl_table
*table
, int write
,
259 size_t *lenp
, loff_t
*ppos
)
261 #ifdef CONFIG_DECNET_ROUTER
262 struct net_device
*dev
= table
->extra1
;
263 struct dn_dev
*dn_db
;
267 if (table
->extra1
== NULL
)
271 old
= dn_db
->parms
.forwarding
;
273 err
= proc_dointvec(table
, write
, buffer
, lenp
, ppos
);
275 if ((err
>= 0) && write
) {
276 if (dn_db
->parms
.forwarding
< 0)
277 dn_db
->parms
.forwarding
= 0;
278 if (dn_db
->parms
.forwarding
> 2)
279 dn_db
->parms
.forwarding
= 2;
281 * What an ugly hack this is... its works, just. It
282 * would be nice if sysctl/proc were just that little
283 * bit more flexible so I don't have to write a special
284 * routine, or suffer hacks like this - SJW
286 tmp
= dn_db
->parms
.forwarding
;
287 dn_db
->parms
.forwarding
= old
;
288 if (dn_db
->parms
.down
)
289 dn_db
->parms
.down(dev
);
290 dn_db
->parms
.forwarding
= tmp
;
292 dn_db
->parms
.up(dev
);
301 #else /* CONFIG_SYSCTL */
302 static void dn_dev_sysctl_unregister(struct dn_dev_parms
*parms
)
305 static void dn_dev_sysctl_register(struct net_device
*dev
, struct dn_dev_parms
*parms
)
309 #endif /* CONFIG_SYSCTL */
311 static inline __u16
mtu2blksize(struct net_device
*dev
)
313 u32 blksize
= dev
->mtu
;
314 if (blksize
> 0xffff)
317 if (dev
->type
== ARPHRD_ETHER
||
318 dev
->type
== ARPHRD_PPP
||
319 dev
->type
== ARPHRD_IPGRE
||
320 dev
->type
== ARPHRD_LOOPBACK
)
323 return (__u16
)blksize
;
326 static struct dn_ifaddr
*dn_dev_alloc_ifa(void)
328 struct dn_ifaddr
*ifa
;
330 ifa
= kzalloc(sizeof(*ifa
), GFP_KERNEL
);
335 static __inline__
void dn_dev_free_ifa(struct dn_ifaddr
*ifa
)
340 static void dn_dev_del_ifa(struct dn_dev
*dn_db
, struct dn_ifaddr
**ifap
, int destroy
)
342 struct dn_ifaddr
*ifa1
= *ifap
;
343 unsigned char mac_addr
[6];
344 struct net_device
*dev
= dn_db
->dev
;
348 *ifap
= ifa1
->ifa_next
;
350 if (dn_db
->dev
->type
== ARPHRD_ETHER
) {
351 if (ifa1
->ifa_local
!= dn_eth2dn(dev
->dev_addr
)) {
352 dn_dn2eth(mac_addr
, ifa1
->ifa_local
);
353 dev_mc_del(dev
, mac_addr
);
357 dn_ifaddr_notify(RTM_DELADDR
, ifa1
);
358 blocking_notifier_call_chain(&dnaddr_chain
, NETDEV_DOWN
, ifa1
);
360 dn_dev_free_ifa(ifa1
);
362 if (dn_db
->ifa_list
== NULL
)
363 dn_dev_delete(dn_db
->dev
);
367 static int dn_dev_insert_ifa(struct dn_dev
*dn_db
, struct dn_ifaddr
*ifa
)
369 struct net_device
*dev
= dn_db
->dev
;
370 struct dn_ifaddr
*ifa1
;
371 unsigned char mac_addr
[6];
375 /* Check for duplicates */
376 for(ifa1
= dn_db
->ifa_list
; ifa1
; ifa1
= ifa1
->ifa_next
) {
377 if (ifa1
->ifa_local
== ifa
->ifa_local
)
381 if (dev
->type
== ARPHRD_ETHER
) {
382 if (ifa
->ifa_local
!= dn_eth2dn(dev
->dev_addr
)) {
383 dn_dn2eth(mac_addr
, ifa
->ifa_local
);
384 dev_mc_add(dev
, mac_addr
);
388 ifa
->ifa_next
= dn_db
->ifa_list
;
389 dn_db
->ifa_list
= ifa
;
391 dn_ifaddr_notify(RTM_NEWADDR
, ifa
);
392 blocking_notifier_call_chain(&dnaddr_chain
, NETDEV_UP
, ifa
);
397 static int dn_dev_set_ifa(struct net_device
*dev
, struct dn_ifaddr
*ifa
)
399 struct dn_dev
*dn_db
= dev
->dn_ptr
;
404 dn_db
= dn_dev_create(dev
, &err
);
409 ifa
->ifa_dev
= dn_db
;
411 if (dev
->flags
& IFF_LOOPBACK
)
412 ifa
->ifa_scope
= RT_SCOPE_HOST
;
414 rv
= dn_dev_insert_ifa(dn_db
, ifa
);
416 dn_dev_free_ifa(ifa
);
421 int dn_dev_ioctl(unsigned int cmd
, void __user
*arg
)
423 char buffer
[DN_IFREQ_SIZE
];
424 struct ifreq
*ifr
= (struct ifreq
*)buffer
;
425 struct sockaddr_dn
*sdn
= (struct sockaddr_dn
*)&ifr
->ifr_addr
;
426 struct dn_dev
*dn_db
;
427 struct net_device
*dev
;
428 struct dn_ifaddr
*ifa
= NULL
, **ifap
= NULL
;
431 if (copy_from_user(ifr
, arg
, DN_IFREQ_SIZE
))
433 ifr
->ifr_name
[IFNAMSIZ
-1] = 0;
435 dev_load(&init_net
, ifr
->ifr_name
);
441 if (!capable(CAP_NET_ADMIN
))
443 if (sdn
->sdn_family
!= AF_DECnet
)
452 if ((dev
= __dev_get_by_name(&init_net
, ifr
->ifr_name
)) == NULL
) {
457 if ((dn_db
= dev
->dn_ptr
) != NULL
) {
458 for (ifap
= &dn_db
->ifa_list
; (ifa
=*ifap
) != NULL
; ifap
= &ifa
->ifa_next
)
459 if (strcmp(ifr
->ifr_name
, ifa
->ifa_label
) == 0)
463 if (ifa
== NULL
&& cmd
!= SIOCSIFADDR
) {
464 ret
= -EADDRNOTAVAIL
;
470 *((__le16
*)sdn
->sdn_nodeaddr
) = ifa
->ifa_local
;
475 if ((ifa
= dn_dev_alloc_ifa()) == NULL
) {
479 memcpy(ifa
->ifa_label
, dev
->name
, IFNAMSIZ
);
481 if (ifa
->ifa_local
== dn_saddr2dn(sdn
))
483 dn_dev_del_ifa(dn_db
, ifap
, 0);
486 ifa
->ifa_local
= ifa
->ifa_address
= dn_saddr2dn(sdn
);
488 ret
= dn_dev_set_ifa(dev
, ifa
);
495 if (copy_to_user(arg
, ifr
, DN_IFREQ_SIZE
))
500 struct net_device
*dn_dev_get_default(void)
502 struct net_device
*dev
;
504 spin_lock(&dndev_lock
);
505 dev
= decnet_default_device
;
512 spin_unlock(&dndev_lock
);
517 int dn_dev_set_default(struct net_device
*dev
, int force
)
519 struct net_device
*old
= NULL
;
524 spin_lock(&dndev_lock
);
525 if (force
|| decnet_default_device
== NULL
) {
526 old
= decnet_default_device
;
527 decnet_default_device
= dev
;
530 spin_unlock(&dndev_lock
);
537 static void dn_dev_check_default(struct net_device
*dev
)
539 spin_lock(&dndev_lock
);
540 if (dev
== decnet_default_device
) {
541 decnet_default_device
= NULL
;
545 spin_unlock(&dndev_lock
);
554 static struct dn_dev
*dn_dev_by_index(int ifindex
)
556 struct net_device
*dev
;
557 struct dn_dev
*dn_dev
= NULL
;
559 dev
= __dev_get_by_index(&init_net
, ifindex
);
561 dn_dev
= dev
->dn_ptr
;
566 static const struct nla_policy dn_ifa_policy
[IFA_MAX
+1] = {
567 [IFA_ADDRESS
] = { .type
= NLA_U16
},
568 [IFA_LOCAL
] = { .type
= NLA_U16
},
569 [IFA_LABEL
] = { .type
= NLA_STRING
,
570 .len
= IFNAMSIZ
- 1 },
573 static int dn_nl_deladdr(struct sk_buff
*skb
, struct nlmsghdr
*nlh
, void *arg
)
575 struct net
*net
= sock_net(skb
->sk
);
576 struct nlattr
*tb
[IFA_MAX
+1];
577 struct dn_dev
*dn_db
;
578 struct ifaddrmsg
*ifm
;
579 struct dn_ifaddr
*ifa
, **ifap
;
582 if (!net_eq(net
, &init_net
))
585 err
= nlmsg_parse(nlh
, sizeof(*ifm
), tb
, IFA_MAX
, dn_ifa_policy
);
590 ifm
= nlmsg_data(nlh
);
591 if ((dn_db
= dn_dev_by_index(ifm
->ifa_index
)) == NULL
)
594 err
= -EADDRNOTAVAIL
;
595 for (ifap
= &dn_db
->ifa_list
; (ifa
= *ifap
); ifap
= &ifa
->ifa_next
) {
597 nla_memcmp(tb
[IFA_LOCAL
], &ifa
->ifa_local
, 2))
600 if (tb
[IFA_LABEL
] && nla_strcmp(tb
[IFA_LABEL
], ifa
->ifa_label
))
603 dn_dev_del_ifa(dn_db
, ifap
, 1);
611 static int dn_nl_newaddr(struct sk_buff
*skb
, struct nlmsghdr
*nlh
, void *arg
)
613 struct net
*net
= sock_net(skb
->sk
);
614 struct nlattr
*tb
[IFA_MAX
+1];
615 struct net_device
*dev
;
616 struct dn_dev
*dn_db
;
617 struct ifaddrmsg
*ifm
;
618 struct dn_ifaddr
*ifa
;
621 if (!net_eq(net
, &init_net
))
624 err
= nlmsg_parse(nlh
, sizeof(*ifm
), tb
, IFA_MAX
, dn_ifa_policy
);
628 if (tb
[IFA_LOCAL
] == NULL
)
631 ifm
= nlmsg_data(nlh
);
632 if ((dev
= __dev_get_by_index(&init_net
, ifm
->ifa_index
)) == NULL
)
635 if ((dn_db
= dev
->dn_ptr
) == NULL
) {
636 dn_db
= dn_dev_create(dev
, &err
);
641 if ((ifa
= dn_dev_alloc_ifa()) == NULL
)
644 if (tb
[IFA_ADDRESS
] == NULL
)
645 tb
[IFA_ADDRESS
] = tb
[IFA_LOCAL
];
647 ifa
->ifa_local
= nla_get_le16(tb
[IFA_LOCAL
]);
648 ifa
->ifa_address
= nla_get_le16(tb
[IFA_ADDRESS
]);
649 ifa
->ifa_flags
= ifm
->ifa_flags
;
650 ifa
->ifa_scope
= ifm
->ifa_scope
;
651 ifa
->ifa_dev
= dn_db
;
654 nla_strlcpy(ifa
->ifa_label
, tb
[IFA_LABEL
], IFNAMSIZ
);
656 memcpy(ifa
->ifa_label
, dev
->name
, IFNAMSIZ
);
658 err
= dn_dev_insert_ifa(dn_db
, ifa
);
660 dn_dev_free_ifa(ifa
);
665 static inline size_t dn_ifaddr_nlmsg_size(void)
667 return NLMSG_ALIGN(sizeof(struct ifaddrmsg
))
668 + nla_total_size(IFNAMSIZ
) /* IFA_LABEL */
669 + nla_total_size(2) /* IFA_ADDRESS */
670 + nla_total_size(2); /* IFA_LOCAL */
673 static int dn_nl_fill_ifaddr(struct sk_buff
*skb
, struct dn_ifaddr
*ifa
,
674 u32 pid
, u32 seq
, int event
, unsigned int flags
)
676 struct ifaddrmsg
*ifm
;
677 struct nlmsghdr
*nlh
;
679 nlh
= nlmsg_put(skb
, pid
, seq
, event
, sizeof(*ifm
), flags
);
683 ifm
= nlmsg_data(nlh
);
684 ifm
->ifa_family
= AF_DECnet
;
685 ifm
->ifa_prefixlen
= 16;
686 ifm
->ifa_flags
= ifa
->ifa_flags
| IFA_F_PERMANENT
;
687 ifm
->ifa_scope
= ifa
->ifa_scope
;
688 ifm
->ifa_index
= ifa
->ifa_dev
->dev
->ifindex
;
690 if (ifa
->ifa_address
)
691 NLA_PUT_LE16(skb
, IFA_ADDRESS
, ifa
->ifa_address
);
693 NLA_PUT_LE16(skb
, IFA_LOCAL
, ifa
->ifa_local
);
694 if (ifa
->ifa_label
[0])
695 NLA_PUT_STRING(skb
, IFA_LABEL
, ifa
->ifa_label
);
697 return nlmsg_end(skb
, nlh
);
700 nlmsg_cancel(skb
, nlh
);
704 static void dn_ifaddr_notify(int event
, struct dn_ifaddr
*ifa
)
709 skb
= alloc_skb(dn_ifaddr_nlmsg_size(), GFP_KERNEL
);
713 err
= dn_nl_fill_ifaddr(skb
, ifa
, 0, 0, event
, 0);
715 /* -EMSGSIZE implies BUG in dn_ifaddr_nlmsg_size() */
716 WARN_ON(err
== -EMSGSIZE
);
720 rtnl_notify(skb
, &init_net
, 0, RTNLGRP_DECnet_IFADDR
, NULL
, GFP_KERNEL
);
724 rtnl_set_sk_err(&init_net
, RTNLGRP_DECnet_IFADDR
, err
);
727 static int dn_nl_dump_ifaddr(struct sk_buff
*skb
, struct netlink_callback
*cb
)
729 struct net
*net
= sock_net(skb
->sk
);
730 int idx
, dn_idx
= 0, skip_ndevs
, skip_naddr
;
731 struct net_device
*dev
;
732 struct dn_dev
*dn_db
;
733 struct dn_ifaddr
*ifa
;
735 if (!net_eq(net
, &init_net
))
738 skip_ndevs
= cb
->args
[0];
739 skip_naddr
= cb
->args
[1];
742 for_each_netdev(&init_net
, dev
) {
743 if (idx
< skip_ndevs
)
745 else if (idx
> skip_ndevs
) {
746 /* Only skip over addresses for first dev dumped
747 * in this iteration (idx == skip_ndevs) */
751 if ((dn_db
= dev
->dn_ptr
) == NULL
)
754 for (ifa
= dn_db
->ifa_list
, dn_idx
= 0; ifa
;
755 ifa
= ifa
->ifa_next
, dn_idx
++) {
756 if (dn_idx
< skip_naddr
)
759 if (dn_nl_fill_ifaddr(skb
, ifa
, NETLINK_CB(cb
->skb
).pid
,
760 cb
->nlh
->nlmsg_seq
, RTM_NEWADDR
,
769 cb
->args
[1] = dn_idx
;
774 static int dn_dev_get_first(struct net_device
*dev
, __le16
*addr
)
776 struct dn_dev
*dn_db
= (struct dn_dev
*)dev
->dn_ptr
;
777 struct dn_ifaddr
*ifa
;
784 ifa
= dn_db
->ifa_list
;
786 *addr
= ifa
->ifa_local
;
795 * Find a default address to bind to.
797 * This is one of those areas where the initial VMS concepts don't really
798 * map onto the Linux concepts, and since we introduced multiple addresses
799 * per interface we have to cope with slightly odd ways of finding out what
800 * "our address" really is. Mostly it's not a problem; for this we just guess
801 * a sensible default. Eventually the routing code will take care of all the
802 * nasties for us I hope.
804 int dn_dev_bind_default(__le16
*addr
)
806 struct net_device
*dev
;
808 dev
= dn_dev_get_default();
811 rv
= dn_dev_get_first(dev
, addr
);
813 if (rv
== 0 || dev
== init_net
.loopback_dev
)
816 dev
= init_net
.loopback_dev
;
821 static void dn_send_endnode_hello(struct net_device
*dev
, struct dn_ifaddr
*ifa
)
823 struct endnode_hello_message
*msg
;
824 struct sk_buff
*skb
= NULL
;
826 struct dn_dev
*dn_db
= (struct dn_dev
*)dev
->dn_ptr
;
828 if ((skb
= dn_alloc_skb(NULL
, sizeof(*msg
), GFP_ATOMIC
)) == NULL
)
833 msg
= (struct endnode_hello_message
*)skb_put(skb
,sizeof(*msg
));
836 memcpy(msg
->tiver
, dn_eco_version
, 3);
837 dn_dn2eth(msg
->id
, ifa
->ifa_local
);
838 msg
->iinfo
= DN_RT_INFO_ENDN
;
839 msg
->blksize
= cpu_to_le16(mtu2blksize(dev
));
841 memset(msg
->seed
, 0, 8);
842 memcpy(msg
->neighbor
, dn_hiord
, ETH_ALEN
);
845 struct dn_neigh
*dn
= (struct dn_neigh
*)dn_db
->router
;
846 dn_dn2eth(msg
->neighbor
, dn
->addr
);
849 msg
->timer
= cpu_to_le16((unsigned short)dn_db
->parms
.t3
);
852 memset(msg
->data
, 0xAA, 2);
854 pktlen
= (__le16
*)skb_push(skb
,2);
855 *pktlen
= cpu_to_le16(skb
->len
- 2);
857 skb_reset_network_header(skb
);
859 dn_rt_finish_output(skb
, dn_rt_all_rt_mcast
, msg
->id
);
863 #define DRDELAY (5 * HZ)
865 static int dn_am_i_a_router(struct dn_neigh
*dn
, struct dn_dev
*dn_db
, struct dn_ifaddr
*ifa
)
867 /* First check time since device went up */
868 if ((jiffies
- dn_db
->uptime
) < DRDELAY
)
871 /* If there is no router, then yes... */
875 /* otherwise only if we have a higher priority or.. */
876 if (dn
->priority
< dn_db
->parms
.priority
)
879 /* if we have equal priority and a higher node number */
880 if (dn
->priority
!= dn_db
->parms
.priority
)
883 if (le16_to_cpu(dn
->addr
) < le16_to_cpu(ifa
->ifa_local
))
889 static void dn_send_router_hello(struct net_device
*dev
, struct dn_ifaddr
*ifa
)
892 struct dn_dev
*dn_db
= dev
->dn_ptr
;
893 struct dn_neigh
*dn
= (struct dn_neigh
*)dn_db
->router
;
897 unsigned char *i1
, *i2
;
901 if (mtu2blksize(dev
) < (26 + 7))
904 n
= mtu2blksize(dev
) - 26;
910 size
= 2 + 26 + 7 * n
;
912 if ((skb
= dn_alloc_skb(NULL
, size
, GFP_ATOMIC
)) == NULL
)
916 ptr
= skb_put(skb
, size
);
918 *ptr
++ = DN_RT_PKT_CNTL
| DN_RT_PKT_ERTH
;
919 *ptr
++ = 2; /* ECO */
922 dn_dn2eth(ptr
, ifa
->ifa_local
);
925 *ptr
++ = dn_db
->parms
.forwarding
== 1 ?
926 DN_RT_INFO_L1RT
: DN_RT_INFO_L2RT
;
927 *((__le16
*)ptr
) = cpu_to_le16(mtu2blksize(dev
));
929 *ptr
++ = dn_db
->parms
.priority
; /* Priority */
930 *ptr
++ = 0; /* Area: Reserved */
931 *((__le16
*)ptr
) = cpu_to_le16((unsigned short)dn_db
->parms
.t3
);
933 *ptr
++ = 0; /* MPD: Reserved */
935 memset(ptr
, 0, 7); /* Name: Reserved */
939 n
= dn_neigh_elist(dev
, ptr
, n
);
944 skb_trim(skb
, (27 + *i2
));
946 pktlen
= (__le16
*)skb_push(skb
, 2);
947 *pktlen
= cpu_to_le16(skb
->len
- 2);
949 skb_reset_network_header(skb
);
951 if (dn_am_i_a_router(dn
, dn_db
, ifa
)) {
952 struct sk_buff
*skb2
= skb_copy(skb
, GFP_ATOMIC
);
954 dn_rt_finish_output(skb2
, dn_rt_all_end_mcast
, src
);
958 dn_rt_finish_output(skb
, dn_rt_all_rt_mcast
, src
);
961 static void dn_send_brd_hello(struct net_device
*dev
, struct dn_ifaddr
*ifa
)
963 struct dn_dev
*dn_db
= (struct dn_dev
*)dev
->dn_ptr
;
965 if (dn_db
->parms
.forwarding
== 0)
966 dn_send_endnode_hello(dev
, ifa
);
968 dn_send_router_hello(dev
, ifa
);
971 static void dn_send_ptp_hello(struct net_device
*dev
, struct dn_ifaddr
*ifa
)
974 int size
= dev
->hard_header_len
+ 2 + 4 + tdlen
;
975 struct sk_buff
*skb
= dn_alloc_skb(NULL
, size
, GFP_ATOMIC
);
984 skb_push(skb
, dev
->hard_header_len
);
985 ptr
= skb_put(skb
, 2 + 4 + tdlen
);
987 *ptr
++ = DN_RT_PKT_HELO
;
988 *((__le16
*)ptr
) = ifa
->ifa_local
;
992 for(i
= 0; i
< tdlen
; i
++)
995 dn_dn2eth(src
, ifa
->ifa_local
);
996 dn_rt_finish_output(skb
, dn_rt_all_rt_mcast
, src
);
999 static int dn_eth_up(struct net_device
*dev
)
1001 struct dn_dev
*dn_db
= dev
->dn_ptr
;
1003 if (dn_db
->parms
.forwarding
== 0)
1004 dev_mc_add(dev
, dn_rt_all_end_mcast
);
1006 dev_mc_add(dev
, dn_rt_all_rt_mcast
);
1008 dn_db
->use_long
= 1;
1013 static void dn_eth_down(struct net_device
*dev
)
1015 struct dn_dev
*dn_db
= dev
->dn_ptr
;
1017 if (dn_db
->parms
.forwarding
== 0)
1018 dev_mc_del(dev
, dn_rt_all_end_mcast
);
1020 dev_mc_del(dev
, dn_rt_all_rt_mcast
);
1023 static void dn_dev_set_timer(struct net_device
*dev
);
1025 static void dn_dev_timer_func(unsigned long arg
)
1027 struct net_device
*dev
= (struct net_device
*)arg
;
1028 struct dn_dev
*dn_db
= dev
->dn_ptr
;
1029 struct dn_ifaddr
*ifa
;
1031 if (dn_db
->t3
<= dn_db
->parms
.t2
) {
1032 if (dn_db
->parms
.timer3
) {
1033 for(ifa
= dn_db
->ifa_list
; ifa
; ifa
= ifa
->ifa_next
) {
1034 if (!(ifa
->ifa_flags
& IFA_F_SECONDARY
))
1035 dn_db
->parms
.timer3(dev
, ifa
);
1038 dn_db
->t3
= dn_db
->parms
.t3
;
1040 dn_db
->t3
-= dn_db
->parms
.t2
;
1043 dn_dev_set_timer(dev
);
1046 static void dn_dev_set_timer(struct net_device
*dev
)
1048 struct dn_dev
*dn_db
= dev
->dn_ptr
;
1050 if (dn_db
->parms
.t2
> dn_db
->parms
.t3
)
1051 dn_db
->parms
.t2
= dn_db
->parms
.t3
;
1053 dn_db
->timer
.data
= (unsigned long)dev
;
1054 dn_db
->timer
.function
= dn_dev_timer_func
;
1055 dn_db
->timer
.expires
= jiffies
+ (dn_db
->parms
.t2
* HZ
);
1057 add_timer(&dn_db
->timer
);
1060 static struct dn_dev
*dn_dev_create(struct net_device
*dev
, int *err
)
1063 struct dn_dev_parms
*p
= dn_dev_list
;
1064 struct dn_dev
*dn_db
;
1066 for(i
= 0; i
< DN_DEV_LIST_SIZE
; i
++, p
++) {
1067 if (p
->type
== dev
->type
)
1072 if (i
== DN_DEV_LIST_SIZE
)
1076 if ((dn_db
= kzalloc(sizeof(struct dn_dev
), GFP_ATOMIC
)) == NULL
)
1079 memcpy(&dn_db
->parms
, p
, sizeof(struct dn_dev_parms
));
1081 dev
->dn_ptr
= dn_db
;
1083 init_timer(&dn_db
->timer
);
1085 dn_db
->uptime
= jiffies
;
1087 dn_db
->neigh_parms
= neigh_parms_alloc(dev
, &dn_neigh_table
);
1088 if (!dn_db
->neigh_parms
) {
1094 if (dn_db
->parms
.up
) {
1095 if (dn_db
->parms
.up(dev
) < 0) {
1096 neigh_parms_release(&dn_neigh_table
, dn_db
->neigh_parms
);
1103 dn_dev_sysctl_register(dev
, &dn_db
->parms
);
1105 dn_dev_set_timer(dev
);
1113 * This processes a device up event. We only start up
1114 * the loopback device & ethernet devices with correct
1115 * MAC addreses automatically. Others must be started
1118 * FIXME: How should we configure the loopback address ? If we could dispense
1119 * with using decnet_address here and for autobind, it will be one less thing
1120 * for users to worry about setting up.
1123 void dn_dev_up(struct net_device
*dev
)
1125 struct dn_ifaddr
*ifa
;
1126 __le16 addr
= decnet_address
;
1127 int maybe_default
= 0;
1128 struct dn_dev
*dn_db
= (struct dn_dev
*)dev
->dn_ptr
;
1130 if ((dev
->type
!= ARPHRD_ETHER
) && (dev
->type
!= ARPHRD_LOOPBACK
))
1134 * Need to ensure that loopback device has a dn_db attached to it
1135 * to allow creation of neighbours against it, even though it might
1136 * not have a local address of its own. Might as well do the same for
1137 * all autoconfigured interfaces.
1139 if (dn_db
== NULL
) {
1141 dn_db
= dn_dev_create(dev
, &err
);
1146 if (dev
->type
== ARPHRD_ETHER
) {
1147 if (memcmp(dev
->dev_addr
, dn_hiord
, 4) != 0)
1149 addr
= dn_eth2dn(dev
->dev_addr
);
1156 if ((ifa
= dn_dev_alloc_ifa()) == NULL
)
1159 ifa
->ifa_local
= ifa
->ifa_address
= addr
;
1161 ifa
->ifa_scope
= RT_SCOPE_UNIVERSE
;
1162 strcpy(ifa
->ifa_label
, dev
->name
);
1164 dn_dev_set_ifa(dev
, ifa
);
1167 * Automagically set the default device to the first automatically
1168 * configured ethernet card in the system.
1170 if (maybe_default
) {
1172 if (dn_dev_set_default(dev
, 0))
1177 static void dn_dev_delete(struct net_device
*dev
)
1179 struct dn_dev
*dn_db
= dev
->dn_ptr
;
1184 del_timer_sync(&dn_db
->timer
);
1185 dn_dev_sysctl_unregister(&dn_db
->parms
);
1186 dn_dev_check_default(dev
);
1187 neigh_ifdown(&dn_neigh_table
, dev
);
1189 if (dn_db
->parms
.down
)
1190 dn_db
->parms
.down(dev
);
1194 neigh_parms_release(&dn_neigh_table
, dn_db
->neigh_parms
);
1195 neigh_ifdown(&dn_neigh_table
, dev
);
1198 neigh_release(dn_db
->router
);
1200 neigh_release(dn_db
->peer
);
1205 void dn_dev_down(struct net_device
*dev
)
1207 struct dn_dev
*dn_db
= dev
->dn_ptr
;
1208 struct dn_ifaddr
*ifa
;
1213 while((ifa
= dn_db
->ifa_list
) != NULL
) {
1214 dn_dev_del_ifa(dn_db
, &dn_db
->ifa_list
, 0);
1215 dn_dev_free_ifa(ifa
);
1221 void dn_dev_init_pkt(struct sk_buff
*skb
)
1226 void dn_dev_veri_pkt(struct sk_buff
*skb
)
1231 void dn_dev_hello(struct sk_buff
*skb
)
1236 void dn_dev_devices_off(void)
1238 struct net_device
*dev
;
1241 for_each_netdev(&init_net
, dev
)
1247 void dn_dev_devices_on(void)
1249 struct net_device
*dev
;
1252 for_each_netdev(&init_net
, dev
) {
1253 if (dev
->flags
& IFF_UP
)
1259 int register_dnaddr_notifier(struct notifier_block
*nb
)
1261 return blocking_notifier_chain_register(&dnaddr_chain
, nb
);
1264 int unregister_dnaddr_notifier(struct notifier_block
*nb
)
1266 return blocking_notifier_chain_unregister(&dnaddr_chain
, nb
);
1269 #ifdef CONFIG_PROC_FS
1270 static inline int is_dn_dev(struct net_device
*dev
)
1272 return dev
->dn_ptr
!= NULL
;
1275 static void *dn_dev_seq_start(struct seq_file
*seq
, loff_t
*pos
)
1279 struct net_device
*dev
;
1284 return SEQ_START_TOKEN
;
1287 for_each_netdev_rcu(&init_net
, dev
) {
1288 if (!is_dn_dev(dev
))
1298 static void *dn_dev_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
1300 struct net_device
*dev
;
1304 dev
= (struct net_device
*)v
;
1305 if (v
== SEQ_START_TOKEN
)
1306 dev
= net_device_entry(&init_net
.dev_base_head
);
1308 for_each_netdev_continue_rcu(&init_net
, dev
) {
1309 if (!is_dn_dev(dev
))
1318 static void dn_dev_seq_stop(struct seq_file
*seq
, void *v
)
1324 static char *dn_type2asc(char type
)
1338 static int dn_dev_seq_show(struct seq_file
*seq
, void *v
)
1340 if (v
== SEQ_START_TOKEN
)
1341 seq_puts(seq
, "Name Flags T1 Timer1 T3 Timer3 BlkSize Pri State DevType Router Peer\n");
1343 struct net_device
*dev
= v
;
1344 char peer_buf
[DN_ASCBUF_LEN
];
1345 char router_buf
[DN_ASCBUF_LEN
];
1346 struct dn_dev
*dn_db
= dev
->dn_ptr
;
1348 seq_printf(seq
, "%-8s %1s %04u %04u %04lu %04lu"
1349 " %04hu %03d %02x %-10s %-7s %-7s\n",
1350 dev
->name
? dev
->name
: "???",
1351 dn_type2asc(dn_db
->parms
.mode
),
1353 dn_db
->t3
, dn_db
->parms
.t3
,
1355 dn_db
->parms
.priority
,
1356 dn_db
->parms
.state
, dn_db
->parms
.name
,
1357 dn_db
->router
? dn_addr2asc(le16_to_cpu(*(__le16
*)dn_db
->router
->primary_key
), router_buf
) : "",
1358 dn_db
->peer
? dn_addr2asc(le16_to_cpu(*(__le16
*)dn_db
->peer
->primary_key
), peer_buf
) : "");
1363 static const struct seq_operations dn_dev_seq_ops
= {
1364 .start
= dn_dev_seq_start
,
1365 .next
= dn_dev_seq_next
,
1366 .stop
= dn_dev_seq_stop
,
1367 .show
= dn_dev_seq_show
,
1370 static int dn_dev_seq_open(struct inode
*inode
, struct file
*file
)
1372 return seq_open(file
, &dn_dev_seq_ops
);
1375 static const struct file_operations dn_dev_seq_fops
= {
1376 .owner
= THIS_MODULE
,
1377 .open
= dn_dev_seq_open
,
1379 .llseek
= seq_lseek
,
1380 .release
= seq_release
,
1383 #endif /* CONFIG_PROC_FS */
1386 module_param_array(addr
, int, NULL
, 0444);
1387 MODULE_PARM_DESC(addr
, "The DECnet address of this machine: area,node");
1389 void __init
dn_dev_init(void)
1391 if (addr
[0] > 63 || addr
[0] < 0) {
1392 printk(KERN_ERR
"DECnet: Area must be between 0 and 63");
1396 if (addr
[1] > 1023 || addr
[1] < 0) {
1397 printk(KERN_ERR
"DECnet: Node must be between 0 and 1023");
1401 decnet_address
= cpu_to_le16((addr
[0] << 10) | addr
[1]);
1403 dn_dev_devices_on();
1405 rtnl_register(PF_DECnet
, RTM_NEWADDR
, dn_nl_newaddr
, NULL
);
1406 rtnl_register(PF_DECnet
, RTM_DELADDR
, dn_nl_deladdr
, NULL
);
1407 rtnl_register(PF_DECnet
, RTM_GETADDR
, NULL
, dn_nl_dump_ifaddr
);
1409 proc_net_fops_create(&init_net
, "decnet_dev", S_IRUGO
, &dn_dev_seq_fops
);
1411 #ifdef CONFIG_SYSCTL
1414 for(i
= 0; i
< DN_DEV_LIST_SIZE
; i
++)
1415 dn_dev_sysctl_register(NULL
, &dn_dev_list
[i
]);
1417 #endif /* CONFIG_SYSCTL */
1420 void __exit
dn_dev_cleanup(void)
1422 #ifdef CONFIG_SYSCTL
1425 for(i
= 0; i
< DN_DEV_LIST_SIZE
; i
++)
1426 dn_dev_sysctl_unregister(&dn_dev_list
[i
]);
1428 #endif /* CONFIG_SYSCTL */
1430 proc_net_remove(&init_net
, "decnet_dev");
1432 dn_dev_devices_off();