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 <asm/uaccess.h>
44 #include <asm/system.h>
45 #include <net/net_namespace.h>
46 #include <net/neighbour.h>
49 #include <net/fib_rules.h>
50 #include <net/netlink.h>
52 #include <net/dn_dev.h>
53 #include <net/dn_route.h>
54 #include <net/dn_neigh.h>
55 #include <net/dn_fib.h>
57 #define DN_IFREQ_SIZE (sizeof(struct ifreq) - sizeof(struct sockaddr) + sizeof(struct sockaddr_dn))
59 static char dn_rt_all_end_mcast
[ETH_ALEN
] = {0xAB,0x00,0x00,0x04,0x00,0x00};
60 static char dn_rt_all_rt_mcast
[ETH_ALEN
] = {0xAB,0x00,0x00,0x03,0x00,0x00};
61 static char dn_hiord
[ETH_ALEN
] = {0xAA,0x00,0x04,0x00,0x00,0x00};
62 static unsigned char dn_eco_version
[3] = {0x02,0x00,0x00};
64 extern struct neigh_table dn_neigh_table
;
67 * decnet_address is kept in network order.
69 __le16 decnet_address
= 0;
71 static DEFINE_RWLOCK(dndev_lock
);
72 static struct net_device
*decnet_default_device
;
73 static BLOCKING_NOTIFIER_HEAD(dnaddr_chain
);
75 static struct dn_dev
*dn_dev_create(struct net_device
*dev
, int *err
);
76 static void dn_dev_delete(struct net_device
*dev
);
77 static void dn_ifaddr_notify(int event
, struct dn_ifaddr
*ifa
);
79 static int dn_eth_up(struct net_device
*);
80 static void dn_eth_down(struct net_device
*);
81 static void dn_send_brd_hello(struct net_device
*dev
, struct dn_ifaddr
*ifa
);
82 static void dn_send_ptp_hello(struct net_device
*dev
, struct dn_ifaddr
*ifa
);
84 static struct dn_dev_parms dn_dev_list
[] = {
86 .type
= ARPHRD_ETHER
, /* Ethernet */
94 .timer3
= dn_send_brd_hello
,
97 .type
= ARPHRD_IPGRE
, /* DECnet tunneled over GRE in IP */
103 .timer3
= dn_send_brd_hello
,
107 .type
= ARPHRD_X25
, /* Bog standard X.25 */
108 .mode
= DN_DEV_UCAST
,
109 .state
= DN_DEV_S_DS
,
113 .timer3
= dn_send_ptp_hello
,
118 .type
= ARPHRD_PPP
, /* DECnet over PPP */
119 .mode
= DN_DEV_BCAST
,
120 .state
= DN_DEV_S_RU
,
124 .timer3
= dn_send_brd_hello
,
128 .type
= ARPHRD_DDCMP
, /* DECnet over DDCMP */
129 .mode
= DN_DEV_UCAST
,
130 .state
= DN_DEV_S_DS
,
134 .timer3
= dn_send_ptp_hello
,
137 .type
= ARPHRD_LOOPBACK
, /* Loopback interface - always last */
138 .mode
= DN_DEV_BCAST
,
139 .state
= DN_DEV_S_RU
,
143 .timer3
= dn_send_brd_hello
,
147 #define DN_DEV_LIST_SIZE ARRAY_SIZE(dn_dev_list)
149 #define DN_DEV_PARMS_OFFSET(x) offsetof(struct dn_dev_parms, x)
153 static int min_t2
[] = { 1 };
154 static int max_t2
[] = { 60 }; /* No max specified, but this seems sensible */
155 static int min_t3
[] = { 1 };
156 static int max_t3
[] = { 8191 }; /* Must fit in 16 bits when multiplied by BCT3MULT or T3MULT */
158 static int min_priority
[1];
159 static int max_priority
[] = { 127 }; /* From DECnet spec */
161 static int dn_forwarding_proc(ctl_table
*, int,
162 void __user
*, size_t *, loff_t
*);
163 static struct dn_dev_sysctl_table
{
164 struct ctl_table_header
*sysctl_header
;
165 ctl_table dn_dev_vars
[5];
170 .procname
= "forwarding",
171 .data
= (void *)DN_DEV_PARMS_OFFSET(forwarding
),
172 .maxlen
= sizeof(int),
174 .proc_handler
= dn_forwarding_proc
,
177 .procname
= "priority",
178 .data
= (void *)DN_DEV_PARMS_OFFSET(priority
),
179 .maxlen
= sizeof(int),
181 .proc_handler
= proc_dointvec_minmax
,
182 .extra1
= &min_priority
,
183 .extra2
= &max_priority
187 .data
= (void *)DN_DEV_PARMS_OFFSET(t2
),
188 .maxlen
= sizeof(int),
190 .proc_handler
= proc_dointvec_minmax
,
196 .data
= (void *)DN_DEV_PARMS_OFFSET(t3
),
197 .maxlen
= sizeof(int),
199 .proc_handler
= proc_dointvec_minmax
,
207 static void dn_dev_sysctl_register(struct net_device
*dev
, struct dn_dev_parms
*parms
)
209 struct dn_dev_sysctl_table
*t
;
212 #define DN_CTL_PATH_DEV 3
214 struct ctl_path dn_ctl_path
[] = {
215 { .procname
= "net", },
216 { .procname
= "decnet", },
217 { .procname
= "conf", },
222 t
= kmemdup(&dn_dev_sysctl
, sizeof(*t
), GFP_KERNEL
);
226 for(i
= 0; i
< ARRAY_SIZE(t
->dn_dev_vars
) - 1; i
++) {
227 long offset
= (long)t
->dn_dev_vars
[i
].data
;
228 t
->dn_dev_vars
[i
].data
= ((char *)parms
) + offset
;
232 dn_ctl_path
[DN_CTL_PATH_DEV
].procname
= dev
->name
;
234 dn_ctl_path
[DN_CTL_PATH_DEV
].procname
= parms
->name
;
237 t
->dn_dev_vars
[0].extra1
= (void *)dev
;
239 t
->sysctl_header
= register_sysctl_paths(dn_ctl_path
, t
->dn_dev_vars
);
240 if (t
->sysctl_header
== NULL
)
246 static void dn_dev_sysctl_unregister(struct dn_dev_parms
*parms
)
249 struct dn_dev_sysctl_table
*t
= parms
->sysctl
;
250 parms
->sysctl
= NULL
;
251 unregister_sysctl_table(t
->sysctl_header
);
256 static int dn_forwarding_proc(ctl_table
*table
, int write
,
258 size_t *lenp
, loff_t
*ppos
)
260 #ifdef CONFIG_DECNET_ROUTER
261 struct net_device
*dev
= table
->extra1
;
262 struct dn_dev
*dn_db
;
266 if (table
->extra1
== NULL
)
270 old
= dn_db
->parms
.forwarding
;
272 err
= proc_dointvec(table
, write
, buffer
, lenp
, ppos
);
274 if ((err
>= 0) && write
) {
275 if (dn_db
->parms
.forwarding
< 0)
276 dn_db
->parms
.forwarding
= 0;
277 if (dn_db
->parms
.forwarding
> 2)
278 dn_db
->parms
.forwarding
= 2;
280 * What an ugly hack this is... its works, just. It
281 * would be nice if sysctl/proc were just that little
282 * bit more flexible so I don't have to write a special
283 * routine, or suffer hacks like this - SJW
285 tmp
= dn_db
->parms
.forwarding
;
286 dn_db
->parms
.forwarding
= old
;
287 if (dn_db
->parms
.down
)
288 dn_db
->parms
.down(dev
);
289 dn_db
->parms
.forwarding
= tmp
;
291 dn_db
->parms
.up(dev
);
300 #else /* CONFIG_SYSCTL */
301 static void dn_dev_sysctl_unregister(struct dn_dev_parms
*parms
)
304 static void dn_dev_sysctl_register(struct net_device
*dev
, struct dn_dev_parms
*parms
)
308 #endif /* CONFIG_SYSCTL */
310 static inline __u16
mtu2blksize(struct net_device
*dev
)
312 u32 blksize
= dev
->mtu
;
313 if (blksize
> 0xffff)
316 if (dev
->type
== ARPHRD_ETHER
||
317 dev
->type
== ARPHRD_PPP
||
318 dev
->type
== ARPHRD_IPGRE
||
319 dev
->type
== ARPHRD_LOOPBACK
)
322 return (__u16
)blksize
;
325 static struct dn_ifaddr
*dn_dev_alloc_ifa(void)
327 struct dn_ifaddr
*ifa
;
329 ifa
= kzalloc(sizeof(*ifa
), GFP_KERNEL
);
334 static __inline__
void dn_dev_free_ifa(struct dn_ifaddr
*ifa
)
339 static void dn_dev_del_ifa(struct dn_dev
*dn_db
, struct dn_ifaddr
**ifap
, int destroy
)
341 struct dn_ifaddr
*ifa1
= *ifap
;
342 unsigned char mac_addr
[6];
343 struct net_device
*dev
= dn_db
->dev
;
347 *ifap
= ifa1
->ifa_next
;
349 if (dn_db
->dev
->type
== ARPHRD_ETHER
) {
350 if (ifa1
->ifa_local
!= dn_eth2dn(dev
->dev_addr
)) {
351 dn_dn2eth(mac_addr
, ifa1
->ifa_local
);
352 dev_mc_delete(dev
, mac_addr
, ETH_ALEN
, 0);
356 dn_ifaddr_notify(RTM_DELADDR
, ifa1
);
357 blocking_notifier_call_chain(&dnaddr_chain
, NETDEV_DOWN
, ifa1
);
359 dn_dev_free_ifa(ifa1
);
361 if (dn_db
->ifa_list
== NULL
)
362 dn_dev_delete(dn_db
->dev
);
366 static int dn_dev_insert_ifa(struct dn_dev
*dn_db
, struct dn_ifaddr
*ifa
)
368 struct net_device
*dev
= dn_db
->dev
;
369 struct dn_ifaddr
*ifa1
;
370 unsigned char mac_addr
[6];
374 /* Check for duplicates */
375 for(ifa1
= dn_db
->ifa_list
; ifa1
; ifa1
= ifa1
->ifa_next
) {
376 if (ifa1
->ifa_local
== ifa
->ifa_local
)
380 if (dev
->type
== ARPHRD_ETHER
) {
381 if (ifa
->ifa_local
!= dn_eth2dn(dev
->dev_addr
)) {
382 dn_dn2eth(mac_addr
, ifa
->ifa_local
);
383 dev_mc_add(dev
, mac_addr
, ETH_ALEN
, 0);
387 ifa
->ifa_next
= dn_db
->ifa_list
;
388 dn_db
->ifa_list
= ifa
;
390 dn_ifaddr_notify(RTM_NEWADDR
, ifa
);
391 blocking_notifier_call_chain(&dnaddr_chain
, NETDEV_UP
, ifa
);
396 static int dn_dev_set_ifa(struct net_device
*dev
, struct dn_ifaddr
*ifa
)
398 struct dn_dev
*dn_db
= dev
->dn_ptr
;
403 dn_db
= dn_dev_create(dev
, &err
);
408 ifa
->ifa_dev
= dn_db
;
410 if (dev
->flags
& IFF_LOOPBACK
)
411 ifa
->ifa_scope
= RT_SCOPE_HOST
;
413 rv
= dn_dev_insert_ifa(dn_db
, ifa
);
415 dn_dev_free_ifa(ifa
);
420 int dn_dev_ioctl(unsigned int cmd
, void __user
*arg
)
422 char buffer
[DN_IFREQ_SIZE
];
423 struct ifreq
*ifr
= (struct ifreq
*)buffer
;
424 struct sockaddr_dn
*sdn
= (struct sockaddr_dn
*)&ifr
->ifr_addr
;
425 struct dn_dev
*dn_db
;
426 struct net_device
*dev
;
427 struct dn_ifaddr
*ifa
= NULL
, **ifap
= NULL
;
430 if (copy_from_user(ifr
, arg
, DN_IFREQ_SIZE
))
432 ifr
->ifr_name
[IFNAMSIZ
-1] = 0;
434 dev_load(&init_net
, ifr
->ifr_name
);
440 if (!capable(CAP_NET_ADMIN
))
442 if (sdn
->sdn_family
!= AF_DECnet
)
451 if ((dev
= __dev_get_by_name(&init_net
, ifr
->ifr_name
)) == NULL
) {
456 if ((dn_db
= dev
->dn_ptr
) != NULL
) {
457 for (ifap
= &dn_db
->ifa_list
; (ifa
=*ifap
) != NULL
; ifap
= &ifa
->ifa_next
)
458 if (strcmp(ifr
->ifr_name
, ifa
->ifa_label
) == 0)
462 if (ifa
== NULL
&& cmd
!= SIOCSIFADDR
) {
463 ret
= -EADDRNOTAVAIL
;
469 *((__le16
*)sdn
->sdn_nodeaddr
) = ifa
->ifa_local
;
474 if ((ifa
= dn_dev_alloc_ifa()) == NULL
) {
478 memcpy(ifa
->ifa_label
, dev
->name
, IFNAMSIZ
);
480 if (ifa
->ifa_local
== dn_saddr2dn(sdn
))
482 dn_dev_del_ifa(dn_db
, ifap
, 0);
485 ifa
->ifa_local
= ifa
->ifa_address
= dn_saddr2dn(sdn
);
487 ret
= dn_dev_set_ifa(dev
, ifa
);
494 if (copy_to_user(arg
, ifr
, DN_IFREQ_SIZE
))
499 struct net_device
*dn_dev_get_default(void)
501 struct net_device
*dev
;
502 read_lock(&dndev_lock
);
503 dev
= decnet_default_device
;
510 read_unlock(&dndev_lock
);
514 int dn_dev_set_default(struct net_device
*dev
, int force
)
516 struct net_device
*old
= NULL
;
520 write_lock(&dndev_lock
);
521 if (force
|| decnet_default_device
== NULL
) {
522 old
= decnet_default_device
;
523 decnet_default_device
= dev
;
526 write_unlock(&dndev_lock
);
532 static void dn_dev_check_default(struct net_device
*dev
)
534 write_lock(&dndev_lock
);
535 if (dev
== decnet_default_device
) {
536 decnet_default_device
= NULL
;
540 write_unlock(&dndev_lock
);
545 static struct dn_dev
*dn_dev_by_index(int ifindex
)
547 struct net_device
*dev
;
548 struct dn_dev
*dn_dev
= NULL
;
549 dev
= dev_get_by_index(&init_net
, ifindex
);
551 dn_dev
= dev
->dn_ptr
;
558 static const struct nla_policy dn_ifa_policy
[IFA_MAX
+1] = {
559 [IFA_ADDRESS
] = { .type
= NLA_U16
},
560 [IFA_LOCAL
] = { .type
= NLA_U16
},
561 [IFA_LABEL
] = { .type
= NLA_STRING
,
562 .len
= IFNAMSIZ
- 1 },
565 static int dn_nl_deladdr(struct sk_buff
*skb
, struct nlmsghdr
*nlh
, void *arg
)
567 struct net
*net
= sock_net(skb
->sk
);
568 struct nlattr
*tb
[IFA_MAX
+1];
569 struct dn_dev
*dn_db
;
570 struct ifaddrmsg
*ifm
;
571 struct dn_ifaddr
*ifa
, **ifap
;
574 if (net
!= &init_net
)
577 err
= nlmsg_parse(nlh
, sizeof(*ifm
), tb
, IFA_MAX
, dn_ifa_policy
);
582 ifm
= nlmsg_data(nlh
);
583 if ((dn_db
= dn_dev_by_index(ifm
->ifa_index
)) == NULL
)
586 err
= -EADDRNOTAVAIL
;
587 for (ifap
= &dn_db
->ifa_list
; (ifa
= *ifap
); ifap
= &ifa
->ifa_next
) {
589 nla_memcmp(tb
[IFA_LOCAL
], &ifa
->ifa_local
, 2))
592 if (tb
[IFA_LABEL
] && nla_strcmp(tb
[IFA_LABEL
], ifa
->ifa_label
))
595 dn_dev_del_ifa(dn_db
, ifap
, 1);
603 static int dn_nl_newaddr(struct sk_buff
*skb
, struct nlmsghdr
*nlh
, void *arg
)
605 struct net
*net
= sock_net(skb
->sk
);
606 struct nlattr
*tb
[IFA_MAX
+1];
607 struct net_device
*dev
;
608 struct dn_dev
*dn_db
;
609 struct ifaddrmsg
*ifm
;
610 struct dn_ifaddr
*ifa
;
613 if (net
!= &init_net
)
616 err
= nlmsg_parse(nlh
, sizeof(*ifm
), tb
, IFA_MAX
, dn_ifa_policy
);
620 if (tb
[IFA_LOCAL
] == NULL
)
623 ifm
= nlmsg_data(nlh
);
624 if ((dev
= __dev_get_by_index(&init_net
, ifm
->ifa_index
)) == NULL
)
627 if ((dn_db
= dev
->dn_ptr
) == NULL
) {
628 dn_db
= dn_dev_create(dev
, &err
);
633 if ((ifa
= dn_dev_alloc_ifa()) == NULL
)
636 if (tb
[IFA_ADDRESS
] == NULL
)
637 tb
[IFA_ADDRESS
] = tb
[IFA_LOCAL
];
639 ifa
->ifa_local
= nla_get_le16(tb
[IFA_LOCAL
]);
640 ifa
->ifa_address
= nla_get_le16(tb
[IFA_ADDRESS
]);
641 ifa
->ifa_flags
= ifm
->ifa_flags
;
642 ifa
->ifa_scope
= ifm
->ifa_scope
;
643 ifa
->ifa_dev
= dn_db
;
646 nla_strlcpy(ifa
->ifa_label
, tb
[IFA_LABEL
], IFNAMSIZ
);
648 memcpy(ifa
->ifa_label
, dev
->name
, IFNAMSIZ
);
650 err
= dn_dev_insert_ifa(dn_db
, ifa
);
652 dn_dev_free_ifa(ifa
);
657 static inline size_t dn_ifaddr_nlmsg_size(void)
659 return NLMSG_ALIGN(sizeof(struct ifaddrmsg
))
660 + nla_total_size(IFNAMSIZ
) /* IFA_LABEL */
661 + nla_total_size(2) /* IFA_ADDRESS */
662 + nla_total_size(2); /* IFA_LOCAL */
665 static int dn_nl_fill_ifaddr(struct sk_buff
*skb
, struct dn_ifaddr
*ifa
,
666 u32 pid
, u32 seq
, int event
, unsigned int flags
)
668 struct ifaddrmsg
*ifm
;
669 struct nlmsghdr
*nlh
;
671 nlh
= nlmsg_put(skb
, pid
, seq
, event
, sizeof(*ifm
), flags
);
675 ifm
= nlmsg_data(nlh
);
676 ifm
->ifa_family
= AF_DECnet
;
677 ifm
->ifa_prefixlen
= 16;
678 ifm
->ifa_flags
= ifa
->ifa_flags
| IFA_F_PERMANENT
;
679 ifm
->ifa_scope
= ifa
->ifa_scope
;
680 ifm
->ifa_index
= ifa
->ifa_dev
->dev
->ifindex
;
682 if (ifa
->ifa_address
)
683 NLA_PUT_LE16(skb
, IFA_ADDRESS
, ifa
->ifa_address
);
685 NLA_PUT_LE16(skb
, IFA_LOCAL
, ifa
->ifa_local
);
686 if (ifa
->ifa_label
[0])
687 NLA_PUT_STRING(skb
, IFA_LABEL
, ifa
->ifa_label
);
689 return nlmsg_end(skb
, nlh
);
692 nlmsg_cancel(skb
, nlh
);
696 static void dn_ifaddr_notify(int event
, struct dn_ifaddr
*ifa
)
701 skb
= alloc_skb(dn_ifaddr_nlmsg_size(), GFP_KERNEL
);
705 err
= dn_nl_fill_ifaddr(skb
, ifa
, 0, 0, event
, 0);
707 /* -EMSGSIZE implies BUG in dn_ifaddr_nlmsg_size() */
708 WARN_ON(err
== -EMSGSIZE
);
712 rtnl_notify(skb
, &init_net
, 0, RTNLGRP_DECnet_IFADDR
, NULL
, GFP_KERNEL
);
716 rtnl_set_sk_err(&init_net
, RTNLGRP_DECnet_IFADDR
, err
);
719 static int dn_nl_dump_ifaddr(struct sk_buff
*skb
, struct netlink_callback
*cb
)
721 struct net
*net
= sock_net(skb
->sk
);
722 int idx
, dn_idx
= 0, skip_ndevs
, skip_naddr
;
723 struct net_device
*dev
;
724 struct dn_dev
*dn_db
;
725 struct dn_ifaddr
*ifa
;
727 if (net
!= &init_net
)
730 skip_ndevs
= cb
->args
[0];
731 skip_naddr
= cb
->args
[1];
734 for_each_netdev(&init_net
, dev
) {
735 if (idx
< skip_ndevs
)
737 else if (idx
> skip_ndevs
) {
738 /* Only skip over addresses for first dev dumped
739 * in this iteration (idx == skip_ndevs) */
743 if ((dn_db
= dev
->dn_ptr
) == NULL
)
746 for (ifa
= dn_db
->ifa_list
, dn_idx
= 0; ifa
;
747 ifa
= ifa
->ifa_next
, dn_idx
++) {
748 if (dn_idx
< skip_naddr
)
751 if (dn_nl_fill_ifaddr(skb
, ifa
, NETLINK_CB(cb
->skb
).pid
,
752 cb
->nlh
->nlmsg_seq
, RTM_NEWADDR
,
761 cb
->args
[1] = dn_idx
;
766 static int dn_dev_get_first(struct net_device
*dev
, __le16
*addr
)
768 struct dn_dev
*dn_db
= (struct dn_dev
*)dev
->dn_ptr
;
769 struct dn_ifaddr
*ifa
;
773 ifa
= dn_db
->ifa_list
;
775 *addr
= ifa
->ifa_local
;
783 * Find a default address to bind to.
785 * This is one of those areas where the initial VMS concepts don't really
786 * map onto the Linux concepts, and since we introduced multiple addresses
787 * per interface we have to cope with slightly odd ways of finding out what
788 * "our address" really is. Mostly it's not a problem; for this we just guess
789 * a sensible default. Eventually the routing code will take care of all the
790 * nasties for us I hope.
792 int dn_dev_bind_default(__le16
*addr
)
794 struct net_device
*dev
;
796 dev
= dn_dev_get_default();
799 read_lock(&dev_base_lock
);
800 rv
= dn_dev_get_first(dev
, addr
);
801 read_unlock(&dev_base_lock
);
803 if (rv
== 0 || dev
== init_net
.loopback_dev
)
806 dev
= init_net
.loopback_dev
;
811 static void dn_send_endnode_hello(struct net_device
*dev
, struct dn_ifaddr
*ifa
)
813 struct endnode_hello_message
*msg
;
814 struct sk_buff
*skb
= NULL
;
816 struct dn_dev
*dn_db
= (struct dn_dev
*)dev
->dn_ptr
;
818 if ((skb
= dn_alloc_skb(NULL
, sizeof(*msg
), GFP_ATOMIC
)) == NULL
)
823 msg
= (struct endnode_hello_message
*)skb_put(skb
,sizeof(*msg
));
826 memcpy(msg
->tiver
, dn_eco_version
, 3);
827 dn_dn2eth(msg
->id
, ifa
->ifa_local
);
828 msg
->iinfo
= DN_RT_INFO_ENDN
;
829 msg
->blksize
= cpu_to_le16(mtu2blksize(dev
));
831 memset(msg
->seed
, 0, 8);
832 memcpy(msg
->neighbor
, dn_hiord
, ETH_ALEN
);
835 struct dn_neigh
*dn
= (struct dn_neigh
*)dn_db
->router
;
836 dn_dn2eth(msg
->neighbor
, dn
->addr
);
839 msg
->timer
= cpu_to_le16((unsigned short)dn_db
->parms
.t3
);
842 memset(msg
->data
, 0xAA, 2);
844 pktlen
= (__le16
*)skb_push(skb
,2);
845 *pktlen
= cpu_to_le16(skb
->len
- 2);
847 skb_reset_network_header(skb
);
849 dn_rt_finish_output(skb
, dn_rt_all_rt_mcast
, msg
->id
);
853 #define DRDELAY (5 * HZ)
855 static int dn_am_i_a_router(struct dn_neigh
*dn
, struct dn_dev
*dn_db
, struct dn_ifaddr
*ifa
)
857 /* First check time since device went up */
858 if ((jiffies
- dn_db
->uptime
) < DRDELAY
)
861 /* If there is no router, then yes... */
865 /* otherwise only if we have a higher priority or.. */
866 if (dn
->priority
< dn_db
->parms
.priority
)
869 /* if we have equal priority and a higher node number */
870 if (dn
->priority
!= dn_db
->parms
.priority
)
873 if (le16_to_cpu(dn
->addr
) < le16_to_cpu(ifa
->ifa_local
))
879 static void dn_send_router_hello(struct net_device
*dev
, struct dn_ifaddr
*ifa
)
882 struct dn_dev
*dn_db
= dev
->dn_ptr
;
883 struct dn_neigh
*dn
= (struct dn_neigh
*)dn_db
->router
;
887 unsigned char *i1
, *i2
;
891 if (mtu2blksize(dev
) < (26 + 7))
894 n
= mtu2blksize(dev
) - 26;
900 size
= 2 + 26 + 7 * n
;
902 if ((skb
= dn_alloc_skb(NULL
, size
, GFP_ATOMIC
)) == NULL
)
906 ptr
= skb_put(skb
, size
);
908 *ptr
++ = DN_RT_PKT_CNTL
| DN_RT_PKT_ERTH
;
909 *ptr
++ = 2; /* ECO */
912 dn_dn2eth(ptr
, ifa
->ifa_local
);
915 *ptr
++ = dn_db
->parms
.forwarding
== 1 ?
916 DN_RT_INFO_L1RT
: DN_RT_INFO_L2RT
;
917 *((__le16
*)ptr
) = cpu_to_le16(mtu2blksize(dev
));
919 *ptr
++ = dn_db
->parms
.priority
; /* Priority */
920 *ptr
++ = 0; /* Area: Reserved */
921 *((__le16
*)ptr
) = cpu_to_le16((unsigned short)dn_db
->parms
.t3
);
923 *ptr
++ = 0; /* MPD: Reserved */
925 memset(ptr
, 0, 7); /* Name: Reserved */
929 n
= dn_neigh_elist(dev
, ptr
, n
);
934 skb_trim(skb
, (27 + *i2
));
936 pktlen
= (__le16
*)skb_push(skb
, 2);
937 *pktlen
= cpu_to_le16(skb
->len
- 2);
939 skb_reset_network_header(skb
);
941 if (dn_am_i_a_router(dn
, dn_db
, ifa
)) {
942 struct sk_buff
*skb2
= skb_copy(skb
, GFP_ATOMIC
);
944 dn_rt_finish_output(skb2
, dn_rt_all_end_mcast
, src
);
948 dn_rt_finish_output(skb
, dn_rt_all_rt_mcast
, src
);
951 static void dn_send_brd_hello(struct net_device
*dev
, struct dn_ifaddr
*ifa
)
953 struct dn_dev
*dn_db
= (struct dn_dev
*)dev
->dn_ptr
;
955 if (dn_db
->parms
.forwarding
== 0)
956 dn_send_endnode_hello(dev
, ifa
);
958 dn_send_router_hello(dev
, ifa
);
961 static void dn_send_ptp_hello(struct net_device
*dev
, struct dn_ifaddr
*ifa
)
964 int size
= dev
->hard_header_len
+ 2 + 4 + tdlen
;
965 struct sk_buff
*skb
= dn_alloc_skb(NULL
, size
, GFP_ATOMIC
);
974 skb_push(skb
, dev
->hard_header_len
);
975 ptr
= skb_put(skb
, 2 + 4 + tdlen
);
977 *ptr
++ = DN_RT_PKT_HELO
;
978 *((__le16
*)ptr
) = ifa
->ifa_local
;
982 for(i
= 0; i
< tdlen
; i
++)
985 dn_dn2eth(src
, ifa
->ifa_local
);
986 dn_rt_finish_output(skb
, dn_rt_all_rt_mcast
, src
);
989 static int dn_eth_up(struct net_device
*dev
)
991 struct dn_dev
*dn_db
= dev
->dn_ptr
;
993 if (dn_db
->parms
.forwarding
== 0)
994 dev_mc_add(dev
, dn_rt_all_end_mcast
, ETH_ALEN
, 0);
996 dev_mc_add(dev
, dn_rt_all_rt_mcast
, ETH_ALEN
, 0);
1003 static void dn_eth_down(struct net_device
*dev
)
1005 struct dn_dev
*dn_db
= dev
->dn_ptr
;
1007 if (dn_db
->parms
.forwarding
== 0)
1008 dev_mc_delete(dev
, dn_rt_all_end_mcast
, ETH_ALEN
, 0);
1010 dev_mc_delete(dev
, dn_rt_all_rt_mcast
, ETH_ALEN
, 0);
1013 static void dn_dev_set_timer(struct net_device
*dev
);
1015 static void dn_dev_timer_func(unsigned long arg
)
1017 struct net_device
*dev
= (struct net_device
*)arg
;
1018 struct dn_dev
*dn_db
= dev
->dn_ptr
;
1019 struct dn_ifaddr
*ifa
;
1021 if (dn_db
->t3
<= dn_db
->parms
.t2
) {
1022 if (dn_db
->parms
.timer3
) {
1023 for(ifa
= dn_db
->ifa_list
; ifa
; ifa
= ifa
->ifa_next
) {
1024 if (!(ifa
->ifa_flags
& IFA_F_SECONDARY
))
1025 dn_db
->parms
.timer3(dev
, ifa
);
1028 dn_db
->t3
= dn_db
->parms
.t3
;
1030 dn_db
->t3
-= dn_db
->parms
.t2
;
1033 dn_dev_set_timer(dev
);
1036 static void dn_dev_set_timer(struct net_device
*dev
)
1038 struct dn_dev
*dn_db
= dev
->dn_ptr
;
1040 if (dn_db
->parms
.t2
> dn_db
->parms
.t3
)
1041 dn_db
->parms
.t2
= dn_db
->parms
.t3
;
1043 dn_db
->timer
.data
= (unsigned long)dev
;
1044 dn_db
->timer
.function
= dn_dev_timer_func
;
1045 dn_db
->timer
.expires
= jiffies
+ (dn_db
->parms
.t2
* HZ
);
1047 add_timer(&dn_db
->timer
);
1050 static struct dn_dev
*dn_dev_create(struct net_device
*dev
, int *err
)
1053 struct dn_dev_parms
*p
= dn_dev_list
;
1054 struct dn_dev
*dn_db
;
1056 for(i
= 0; i
< DN_DEV_LIST_SIZE
; i
++, p
++) {
1057 if (p
->type
== dev
->type
)
1062 if (i
== DN_DEV_LIST_SIZE
)
1066 if ((dn_db
= kzalloc(sizeof(struct dn_dev
), GFP_ATOMIC
)) == NULL
)
1069 memcpy(&dn_db
->parms
, p
, sizeof(struct dn_dev_parms
));
1071 dev
->dn_ptr
= dn_db
;
1073 init_timer(&dn_db
->timer
);
1075 dn_db
->uptime
= jiffies
;
1077 dn_db
->neigh_parms
= neigh_parms_alloc(dev
, &dn_neigh_table
);
1078 if (!dn_db
->neigh_parms
) {
1084 if (dn_db
->parms
.up
) {
1085 if (dn_db
->parms
.up(dev
) < 0) {
1086 neigh_parms_release(&dn_neigh_table
, dn_db
->neigh_parms
);
1093 dn_dev_sysctl_register(dev
, &dn_db
->parms
);
1095 dn_dev_set_timer(dev
);
1103 * This processes a device up event. We only start up
1104 * the loopback device & ethernet devices with correct
1105 * MAC addreses automatically. Others must be started
1108 * FIXME: How should we configure the loopback address ? If we could dispense
1109 * with using decnet_address here and for autobind, it will be one less thing
1110 * for users to worry about setting up.
1113 void dn_dev_up(struct net_device
*dev
)
1115 struct dn_ifaddr
*ifa
;
1116 __le16 addr
= decnet_address
;
1117 int maybe_default
= 0;
1118 struct dn_dev
*dn_db
= (struct dn_dev
*)dev
->dn_ptr
;
1120 if ((dev
->type
!= ARPHRD_ETHER
) && (dev
->type
!= ARPHRD_LOOPBACK
))
1124 * Need to ensure that loopback device has a dn_db attached to it
1125 * to allow creation of neighbours against it, even though it might
1126 * not have a local address of its own. Might as well do the same for
1127 * all autoconfigured interfaces.
1129 if (dn_db
== NULL
) {
1131 dn_db
= dn_dev_create(dev
, &err
);
1136 if (dev
->type
== ARPHRD_ETHER
) {
1137 if (memcmp(dev
->dev_addr
, dn_hiord
, 4) != 0)
1139 addr
= dn_eth2dn(dev
->dev_addr
);
1146 if ((ifa
= dn_dev_alloc_ifa()) == NULL
)
1149 ifa
->ifa_local
= ifa
->ifa_address
= addr
;
1151 ifa
->ifa_scope
= RT_SCOPE_UNIVERSE
;
1152 strcpy(ifa
->ifa_label
, dev
->name
);
1154 dn_dev_set_ifa(dev
, ifa
);
1157 * Automagically set the default device to the first automatically
1158 * configured ethernet card in the system.
1160 if (maybe_default
) {
1162 if (dn_dev_set_default(dev
, 0))
1167 static void dn_dev_delete(struct net_device
*dev
)
1169 struct dn_dev
*dn_db
= dev
->dn_ptr
;
1174 del_timer_sync(&dn_db
->timer
);
1175 dn_dev_sysctl_unregister(&dn_db
->parms
);
1176 dn_dev_check_default(dev
);
1177 neigh_ifdown(&dn_neigh_table
, dev
);
1179 if (dn_db
->parms
.down
)
1180 dn_db
->parms
.down(dev
);
1184 neigh_parms_release(&dn_neigh_table
, dn_db
->neigh_parms
);
1185 neigh_ifdown(&dn_neigh_table
, dev
);
1188 neigh_release(dn_db
->router
);
1190 neigh_release(dn_db
->peer
);
1195 void dn_dev_down(struct net_device
*dev
)
1197 struct dn_dev
*dn_db
= dev
->dn_ptr
;
1198 struct dn_ifaddr
*ifa
;
1203 while((ifa
= dn_db
->ifa_list
) != NULL
) {
1204 dn_dev_del_ifa(dn_db
, &dn_db
->ifa_list
, 0);
1205 dn_dev_free_ifa(ifa
);
1211 void dn_dev_init_pkt(struct sk_buff
*skb
)
1216 void dn_dev_veri_pkt(struct sk_buff
*skb
)
1221 void dn_dev_hello(struct sk_buff
*skb
)
1226 void dn_dev_devices_off(void)
1228 struct net_device
*dev
;
1231 for_each_netdev(&init_net
, dev
)
1237 void dn_dev_devices_on(void)
1239 struct net_device
*dev
;
1242 for_each_netdev(&init_net
, dev
) {
1243 if (dev
->flags
& IFF_UP
)
1249 int register_dnaddr_notifier(struct notifier_block
*nb
)
1251 return blocking_notifier_chain_register(&dnaddr_chain
, nb
);
1254 int unregister_dnaddr_notifier(struct notifier_block
*nb
)
1256 return blocking_notifier_chain_unregister(&dnaddr_chain
, nb
);
1259 #ifdef CONFIG_PROC_FS
1260 static inline int is_dn_dev(struct net_device
*dev
)
1262 return dev
->dn_ptr
!= NULL
;
1265 static void *dn_dev_seq_start(struct seq_file
*seq
, loff_t
*pos
)
1266 __acquires(&dev_base_lock
)
1269 struct net_device
*dev
;
1271 read_lock(&dev_base_lock
);
1274 return SEQ_START_TOKEN
;
1277 for_each_netdev(&init_net
, dev
) {
1278 if (!is_dn_dev(dev
))
1288 static void *dn_dev_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
1290 struct net_device
*dev
;
1294 dev
= (struct net_device
*)v
;
1295 if (v
== SEQ_START_TOKEN
)
1296 dev
= net_device_entry(&init_net
.dev_base_head
);
1298 for_each_netdev_continue(&init_net
, dev
) {
1299 if (!is_dn_dev(dev
))
1308 static void dn_dev_seq_stop(struct seq_file
*seq
, void *v
)
1309 __releases(&dev_base_lock
)
1311 read_unlock(&dev_base_lock
);
1314 static char *dn_type2asc(char type
)
1328 static int dn_dev_seq_show(struct seq_file
*seq
, void *v
)
1330 if (v
== SEQ_START_TOKEN
)
1331 seq_puts(seq
, "Name Flags T1 Timer1 T3 Timer3 BlkSize Pri State DevType Router Peer\n");
1333 struct net_device
*dev
= v
;
1334 char peer_buf
[DN_ASCBUF_LEN
];
1335 char router_buf
[DN_ASCBUF_LEN
];
1336 struct dn_dev
*dn_db
= dev
->dn_ptr
;
1338 seq_printf(seq
, "%-8s %1s %04u %04u %04lu %04lu"
1339 " %04hu %03d %02x %-10s %-7s %-7s\n",
1340 dev
->name
? dev
->name
: "???",
1341 dn_type2asc(dn_db
->parms
.mode
),
1343 dn_db
->t3
, dn_db
->parms
.t3
,
1345 dn_db
->parms
.priority
,
1346 dn_db
->parms
.state
, dn_db
->parms
.name
,
1347 dn_db
->router
? dn_addr2asc(le16_to_cpu(*(__le16
*)dn_db
->router
->primary_key
), router_buf
) : "",
1348 dn_db
->peer
? dn_addr2asc(le16_to_cpu(*(__le16
*)dn_db
->peer
->primary_key
), peer_buf
) : "");
1353 static const struct seq_operations dn_dev_seq_ops
= {
1354 .start
= dn_dev_seq_start
,
1355 .next
= dn_dev_seq_next
,
1356 .stop
= dn_dev_seq_stop
,
1357 .show
= dn_dev_seq_show
,
1360 static int dn_dev_seq_open(struct inode
*inode
, struct file
*file
)
1362 return seq_open(file
, &dn_dev_seq_ops
);
1365 static const struct file_operations dn_dev_seq_fops
= {
1366 .owner
= THIS_MODULE
,
1367 .open
= dn_dev_seq_open
,
1369 .llseek
= seq_lseek
,
1370 .release
= seq_release
,
1373 #endif /* CONFIG_PROC_FS */
1376 module_param_array(addr
, int, NULL
, 0444);
1377 MODULE_PARM_DESC(addr
, "The DECnet address of this machine: area,node");
1379 void __init
dn_dev_init(void)
1381 if (addr
[0] > 63 || addr
[0] < 0) {
1382 printk(KERN_ERR
"DECnet: Area must be between 0 and 63");
1386 if (addr
[1] > 1023 || addr
[1] < 0) {
1387 printk(KERN_ERR
"DECnet: Node must be between 0 and 1023");
1391 decnet_address
= cpu_to_le16((addr
[0] << 10) | addr
[1]);
1393 dn_dev_devices_on();
1395 rtnl_register(PF_DECnet
, RTM_NEWADDR
, dn_nl_newaddr
, NULL
);
1396 rtnl_register(PF_DECnet
, RTM_DELADDR
, dn_nl_deladdr
, NULL
);
1397 rtnl_register(PF_DECnet
, RTM_GETADDR
, NULL
, dn_nl_dump_ifaddr
);
1399 proc_net_fops_create(&init_net
, "decnet_dev", S_IRUGO
, &dn_dev_seq_fops
);
1401 #ifdef CONFIG_SYSCTL
1404 for(i
= 0; i
< DN_DEV_LIST_SIZE
; i
++)
1405 dn_dev_sysctl_register(NULL
, &dn_dev_list
[i
]);
1407 #endif /* CONFIG_SYSCTL */
1410 void __exit
dn_dev_cleanup(void)
1412 #ifdef CONFIG_SYSCTL
1415 for(i
= 0; i
< DN_DEV_LIST_SIZE
; i
++)
1416 dn_dev_sysctl_unregister(&dn_dev_list
[i
]);
1418 #endif /* CONFIG_SYSCTL */
1420 proc_net_remove(&init_net
, "decnet_dev");
1422 dn_dev_devices_off();